+5 -1

.tangled/workflows/build.yml

··· 1 1 when: 2 2 - - event: ["push"] 2 2 + - event: ["push", "pull_request"] 3 3 branch: ["master"] 4 4 5 5 dependencies: ··· 22 22 - name: build knot 23 23 command: | 24 24 go build -o knot.out ./cmd/knot 25 25 + 26 26 + - name: build spindle 27 27 + command: | 28 28 + go build -o spindle.out ./cmd/spindle

+1 -1

.tangled/workflows/fmt.yml

··· 1 1 when: 2 2 - - event: ["push"] 2 2 + - event: ["push", "pull_request"] 3 3 branch: ["master"] 4 4 5 5 dependencies:

+2 -2

.tangled/workflows/test.yml

··· 1 1 when: 2 2 - - event: ["push"] 3 3 - branch: ["master", "test-ci"] 2 2 + - event: ["push", "pull_request"] 3 3 + branch: ["master"] 4 4 5 5 dependencies: 6 6 nixpkgs:

+269 -297

api/tangled/cbor_gen.go

··· 504 504 505 505 return nil 506 506 } 507 507 + func (t *FeedReaction) MarshalCBOR(w io.Writer) error { 508 508 + if t == nil { 509 509 + _, err := w.Write(cbg.CborNull) 510 510 + return err 511 511 + } 512 512 + 513 513 + cw := cbg.NewCborWriter(w) 514 514 + 515 515 + if _, err := cw.Write([]byte{164}); err != nil { 516 516 + return err 517 517 + } 518 518 + 519 519 + // t.LexiconTypeID (string) (string) 520 520 + if len("$type") > 1000000 { 521 521 + return xerrors.Errorf("Value in field \"$type\" was too long") 522 522 + } 523 523 + 524 524 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 525 525 + return err 526 526 + } 527 527 + if _, err := cw.WriteString(string("$type")); err != nil { 528 528 + return err 529 529 + } 530 530 + 531 531 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.feed.reaction"))); err != nil { 532 532 + return err 533 533 + } 534 534 + if _, err := cw.WriteString(string("sh.tangled.feed.reaction")); err != nil { 535 535 + return err 536 536 + } 537 537 + 538 538 + // t.Subject (string) (string) 539 539 + if len("subject") > 1000000 { 540 540 + return xerrors.Errorf("Value in field \"subject\" was too long") 541 541 + } 542 542 + 543 543 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 544 544 + return err 545 545 + } 546 546 + if _, err := cw.WriteString(string("subject")); err != nil { 547 547 + return err 548 548 + } 549 549 + 550 550 + if len(t.Subject) > 1000000 { 551 551 + return xerrors.Errorf("Value in field t.Subject was too long") 552 552 + } 553 553 + 554 554 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 555 555 + return err 556 556 + } 557 557 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 558 558 + return err 559 559 + } 560 560 + 561 561 + // t.Reaction (string) (string) 562 562 + if len("reaction") > 1000000 { 563 563 + return xerrors.Errorf("Value in field \"reaction\" was too long") 564 564 + } 565 565 + 566 566 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reaction"))); err != nil { 567 567 + return err 568 568 + } 569 569 + if _, err := cw.WriteString(string("reaction")); err != nil { 570 570 + return err 571 571 + } 572 572 + 573 573 + if len(t.Reaction) > 1000000 { 574 574 + return xerrors.Errorf("Value in field t.Reaction was too long") 575 575 + } 576 576 + 577 577 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Reaction))); err != nil { 578 578 + return err 579 579 + } 580 580 + if _, err := cw.WriteString(string(t.Reaction)); err != nil { 581 581 + return err 582 582 + } 583 583 + 584 584 + // t.CreatedAt (string) (string) 585 585 + if len("createdAt") > 1000000 { 586 586 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 587 587 + } 588 588 + 589 589 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 590 590 + return err 591 591 + } 592 592 + if _, err := cw.WriteString(string("createdAt")); err != nil { 593 593 + return err 594 594 + } 595 595 + 596 596 + if len(t.CreatedAt) > 1000000 { 597 597 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 598 598 + } 599 599 + 600 600 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 601 601 + return err 602 602 + } 603 603 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 604 604 + return err 605 605 + } 606 606 + return nil 607 607 + } 608 608 + 609 609 + func (t *FeedReaction) UnmarshalCBOR(r io.Reader) (err error) { 610 610 + *t = FeedReaction{} 611 611 + 612 612 + cr := cbg.NewCborReader(r) 613 613 + 614 614 + maj, extra, err := cr.ReadHeader() 615 615 + if err != nil { 616 616 + return err 617 617 + } 618 618 + defer func() { 619 619 + if err == io.EOF { 620 620 + err = io.ErrUnexpectedEOF 621 621 + } 622 622 + }() 623 623 + 624 624 + if maj != cbg.MajMap { 625 625 + return fmt.Errorf("cbor input should be of type map") 626 626 + } 627 627 + 628 628 + if extra > cbg.MaxLength { 629 629 + return fmt.Errorf("FeedReaction: map struct too large (%d)", extra) 630 630 + } 631 631 + 632 632 + n := extra 633 633 + 634 634 + nameBuf := make([]byte, 9) 635 635 + for i := uint64(0); i < n; i++ { 636 636 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 637 637 + if err != nil { 638 638 + return err 639 639 + } 640 640 + 641 641 + if !ok { 642 642 + // Field doesn't exist on this type, so ignore it 643 643 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 644 644 + return err 645 645 + } 646 646 + continue 647 647 + } 648 648 + 649 649 + switch string(nameBuf[:nameLen]) { 650 650 + // t.LexiconTypeID (string) (string) 651 651 + case "$type": 652 652 + 653 653 + { 654 654 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 655 655 + if err != nil { 656 656 + return err 657 657 + } 658 658 + 659 659 + t.LexiconTypeID = string(sval) 660 660 + } 661 661 + // t.Subject (string) (string) 662 662 + case "subject": 663 663 + 664 664 + { 665 665 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 666 666 + if err != nil { 667 667 + return err 668 668 + } 669 669 + 670 670 + t.Subject = string(sval) 671 671 + } 672 672 + // t.Reaction (string) (string) 673 673 + case "reaction": 674 674 + 675 675 + { 676 676 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 677 677 + if err != nil { 678 678 + return err 679 679 + } 680 680 + 681 681 + t.Reaction = string(sval) 682 682 + } 683 683 + // t.CreatedAt (string) (string) 684 684 + case "createdAt": 685 685 + 686 686 + { 687 687 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 688 688 + if err != nil { 689 689 + return err 690 690 + } 691 691 + 692 692 + t.CreatedAt = string(sval) 693 693 + } 694 694 + 695 695 + default: 696 696 + // Field doesn't exist on this type, so ignore it 697 697 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 698 698 + return err 699 699 + } 700 700 + } 701 701 + } 702 702 + 703 703 + return nil 704 704 + } 507 705 func (t *FeedStar) MarshalCBOR(w io.Writer) error { 508 706 if t == nil { 509 707 _, err := w.Write(cbg.CborNull) ··· 2188 2386 2189 2387 return nil 2190 2388 } 2191 2191 - func (t *Pipeline_Dependencies_Elem) MarshalCBOR(w io.Writer) error { 2389 2389 + func (t *Pipeline_Dependency) MarshalCBOR(w io.Writer) error { 2192 2390 if t == nil { 2193 2391 _, err := w.Write(cbg.CborNull) 2194 2392 return err ··· 2258 2456 return nil 2259 2457 } 2260 2458 2261 2261 - func (t *Pipeline_Dependencies_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2262 2262 - *t = Pipeline_Dependencies_Elem{} 2459 2459 + func (t *Pipeline_Dependency) UnmarshalCBOR(r io.Reader) (err error) { 2460 2460 + *t = Pipeline_Dependency{} 2263 2461 2264 2462 cr := cbg.NewCborReader(r) 2265 2463 ··· 2278 2476 } 2279 2477 2280 2478 if extra > cbg.MaxLength { 2281 2281 - return fmt.Errorf("Pipeline_Dependencies_Elem: map struct too large (%d)", extra) 2479 2479 + return fmt.Errorf("Pipeline_Dependency: map struct too large (%d)", extra) 2282 2480 } 2283 2481 2284 2482 n := extra ··· 2378 2576 return err 2379 2577 } 2380 2578 2381 2381 - // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2579 2579 + // t.Inputs ([]*tangled.Pipeline_Pair) (slice) 2382 2580 if t.Inputs != nil { 2383 2581 2384 2582 if len("inputs") > 1000000 { ··· 2450 2648 } 2451 2649 2452 2650 switch string(nameBuf[:nameLen]) { 2453 2453 - // t.Inputs ([]*tangled.Pipeline_ManualTriggerData_Inputs_Elem) (slice) 2651 2651 + // t.Inputs ([]*tangled.Pipeline_Pair) (slice) 2454 2652 case "inputs": 2455 2653 2456 2654 maj, extra, err = cr.ReadHeader() ··· 2467 2665 } 2468 2666 2469 2667 if extra > 0 { 2470 2470 - t.Inputs = make([]*Pipeline_ManualTriggerData_Inputs_Elem, extra) 2668 2668 + t.Inputs = make([]*Pipeline_Pair, extra) 2471 2669 } 2472 2670 2473 2671 for i := 0; i < int(extra); i++ { ··· 2489 2687 if err := cr.UnreadByte(); err != nil { 2490 2688 return err 2491 2689 } 2492 2492 - t.Inputs[i] = new(Pipeline_ManualTriggerData_Inputs_Elem) 2690 2690 + t.Inputs[i] = new(Pipeline_Pair) 2493 2691 if err := t.Inputs[i].UnmarshalCBOR(cr); err != nil { 2494 2692 return xerrors.Errorf("unmarshaling t.Inputs[i] pointer: %w", err) 2495 2693 } ··· 2510 2708 2511 2709 return nil 2512 2710 } 2513 2513 - func (t *Pipeline_ManualTriggerData_Inputs_Elem) MarshalCBOR(w io.Writer) error { 2711 2711 + func (t *Pipeline_Pair) MarshalCBOR(w io.Writer) error { 2514 2712 if t == nil { 2515 2713 _, err := w.Write(cbg.CborNull) 2516 2714 return err ··· 2570 2768 return nil 2571 2769 } 2572 2770 2573 2573 - func (t *Pipeline_ManualTriggerData_Inputs_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2574 2574 - *t = Pipeline_ManualTriggerData_Inputs_Elem{} 2771 2771 + func (t *Pipeline_Pair) UnmarshalCBOR(r io.Reader) (err error) { 2772 2772 + *t = Pipeline_Pair{} 2575 2773 2576 2774 cr := cbg.NewCborReader(r) 2577 2775 ··· 2590 2788 } 2591 2789 2592 2790 if extra > cbg.MaxLength { 2593 2593 - return fmt.Errorf("Pipeline_ManualTriggerData_Inputs_Elem: map struct too large (%d)", extra) 2791 2791 + return fmt.Errorf("Pipeline_Pair: map struct too large (%d)", extra) 2594 2792 } 2595 2793 2596 2794 n := extra ··· 3014 3212 3015 3213 return nil 3016 3214 } 3017 3017 - 3018 3018 - func (t *Pipeline_Step_Environment_Elem) MarshalCBOR(w io.Writer) error { 3019 3019 - if t == nil { 3020 3020 - _, err := w.Write(cbg.CborNull) 3021 3021 - return err 3022 3022 - } 3023 3023 - 3024 3024 - cw := cbg.NewCborWriter(w) 3025 3025 - 3026 3026 - if _, err := cw.Write([]byte{162}); err != nil { 3027 3027 - return err 3028 3028 - } 3029 3029 - 3030 3030 - // t.Key (string) (string) 3031 3031 - if len("key") > 1000000 { 3032 3032 - return xerrors.Errorf("Value in field \"key\" was too long") 3033 3033 - } 3034 3034 - 3035 3035 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 3036 3036 - return err 3037 3037 - } 3038 3038 - if _, err := cw.WriteString(string("key")); err != nil { 3039 3039 - return err 3040 3040 - } 3041 3041 - 3042 3042 - if len(t.Key) > 1000000 { 3043 3043 - return xerrors.Errorf("Value in field t.Key was too long") 3044 3044 - } 3045 3045 - 3046 3046 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 3047 3047 - return err 3048 3048 - } 3049 3049 - if _, err := cw.WriteString(string(t.Key)); err != nil { 3050 3050 - return err 3051 3051 - } 3052 3052 - 3053 3053 - // t.Value (string) (string) 3054 3054 - if len("value") > 1000000 { 3055 3055 - return xerrors.Errorf("Value in field \"value\" was too long") 3056 3056 - } 3057 3057 - 3058 3058 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 3059 3059 - return err 3060 3060 - } 3061 3061 - if _, err := cw.WriteString(string("value")); err != nil { 3062 3062 - return err 3063 3063 - } 3064 3064 - 3065 3065 - if len(t.Value) > 1000000 { 3066 3066 - return xerrors.Errorf("Value in field t.Value was too long") 3067 3067 - } 3068 3068 - 3069 3069 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 3070 3070 - return err 3071 3071 - } 3072 3072 - if _, err := cw.WriteString(string(t.Value)); err != nil { 3073 3073 - return err 3074 3074 - } 3075 3075 - return nil 3076 3076 - } 3077 3077 - 3078 3078 - func (t *Pipeline_Step_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 3079 3079 - *t = Pipeline_Step_Environment_Elem{} 3080 3080 - 3081 3081 - cr := cbg.NewCborReader(r) 3082 3082 - 3083 3083 - maj, extra, err := cr.ReadHeader() 3084 3084 - if err != nil { 3085 3085 - return err 3086 3086 - } 3087 3087 - defer func() { 3088 3088 - if err == io.EOF { 3089 3089 - err = io.ErrUnexpectedEOF 3090 3090 - } 3091 3091 - }() 3092 3092 - 3093 3093 - if maj != cbg.MajMap { 3094 3094 - return fmt.Errorf("cbor input should be of type map") 3095 3095 - } 3096 3096 - 3097 3097 - if extra > cbg.MaxLength { 3098 3098 - return fmt.Errorf("Pipeline_Step_Environment_Elem: map struct too large (%d)", extra) 3099 3099 - } 3100 3100 - 3101 3101 - n := extra 3102 3102 - 3103 3103 - nameBuf := make([]byte, 5) 3104 3104 - for i := uint64(0); i < n; i++ { 3105 3105 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 3106 3106 - if err != nil { 3107 3107 - return err 3108 3108 - } 3109 3109 - 3110 3110 - if !ok { 3111 3111 - // Field doesn't exist on this type, so ignore it 3112 3112 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 3113 3113 - return err 3114 3114 - } 3115 3115 - continue 3116 3116 - } 3117 3117 - 3118 3118 - switch string(nameBuf[:nameLen]) { 3119 3119 - // t.Key (string) (string) 3120 3120 - case "key": 3121 3121 - 3122 3122 - { 3123 3123 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3124 3124 - if err != nil { 3125 3125 - return err 3126 3126 - } 3127 3127 - 3128 3128 - t.Key = string(sval) 3129 3129 - } 3130 3130 - // t.Value (string) (string) 3131 3131 - case "value": 3132 3132 - 3133 3133 - { 3134 3134 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3135 3135 - if err != nil { 3136 3136 - return err 3137 3137 - } 3138 3138 - 3139 3139 - t.Value = string(sval) 3140 3140 - } 3141 3141 - 3142 3142 - default: 3143 3143 - // Field doesn't exist on this type, so ignore it 3144 3144 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 3145 3145 - return err 3146 3146 - } 3147 3147 - } 3148 3148 - } 3149 3149 - 3150 3150 - return nil 3151 3151 - } 3152 3215 func (t *PipelineStatus) MarshalCBOR(w io.Writer) error { 3153 3216 if t == nil { 3154 3217 _, err := w.Write(cbg.CborNull) ··· 3511 3574 3512 3575 return nil 3513 3576 } 3514 3514 - 3515 3577 func (t *Pipeline_Step) MarshalCBOR(w io.Writer) error { 3516 3578 if t == nil { 3517 3579 _, err := w.Write(cbg.CborNull) ··· 3575 3637 return err 3576 3638 } 3577 3639 3578 3578 - // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice) 3640 3640 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 3579 3641 if t.Environment != nil { 3580 3642 3581 3643 if len("environment") > 1000000 { ··· 3669 3731 3670 3732 t.Command = string(sval) 3671 3733 } 3672 3672 - // t.Environment ([]*tangled.Pipeline_Step_Environment_Elem) (slice) 3734 3734 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 3673 3735 case "environment": 3674 3736 3675 3737 maj, extra, err = cr.ReadHeader() ··· 3686 3748 } 3687 3749 3688 3750 if extra > 0 { 3689 3689 - t.Environment = make([]*Pipeline_Step_Environment_Elem, extra) 3751 3751 + t.Environment = make([]*Pipeline_Pair, extra) 3690 3752 } 3691 3753 3692 3754 for i := 0; i < int(extra); i++ { ··· 3708 3770 if err := cr.UnreadByte(); err != nil { 3709 3771 return err 3710 3772 } 3711 3711 - t.Environment[i] = new(Pipeline_Step_Environment_Elem) 3773 3773 + t.Environment[i] = new(Pipeline_Pair) 3712 3774 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { 3713 3775 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) 3714 3776 } ··· 4274 4336 4275 4337 } 4276 4338 4277 4277 - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 4339 4339 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 4278 4340 if len("environment") > 1000000 { 4279 4341 return xerrors.Errorf("Value in field \"environment\" was too long") 4280 4342 } ··· 4300 4362 4301 4363 } 4302 4364 4303 4303 - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 4365 4365 + // t.Dependencies ([]*tangled.Pipeline_Dependency) (slice) 4304 4366 if len("dependencies") > 1000000 { 4305 4367 return xerrors.Errorf("Value in field \"dependencies\" was too long") 4306 4368 } ··· 4449 4511 4450 4512 } 4451 4513 } 4452 4452 - // t.Environment ([]*tangled.Pipeline_Workflow_Environment_Elem) (slice) 4514 4514 + // t.Environment ([]*tangled.Pipeline_Pair) (slice) 4453 4515 case "environment": 4454 4516 4455 4517 maj, extra, err = cr.ReadHeader() ··· 4466 4528 } 4467 4529 4468 4530 if extra > 0 { 4469 4469 - t.Environment = make([]*Pipeline_Workflow_Environment_Elem, extra) 4531 4531 + t.Environment = make([]*Pipeline_Pair, extra) 4470 4532 } 4471 4533 4472 4534 for i := 0; i < int(extra); i++ { ··· 4488 4550 if err := cr.UnreadByte(); err != nil { 4489 4551 return err 4490 4552 } 4491 4491 - t.Environment[i] = new(Pipeline_Workflow_Environment_Elem) 4553 4553 + t.Environment[i] = new(Pipeline_Pair) 4492 4554 if err := t.Environment[i].UnmarshalCBOR(cr); err != nil { 4493 4555 return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err) 4494 4556 } ··· 4498 4560 4499 4561 } 4500 4562 } 4501 4501 - // t.Dependencies ([]tangled.Pipeline_Dependencies_Elem) (slice) 4563 4563 + // t.Dependencies ([]*tangled.Pipeline_Dependency) (slice) 4502 4564 case "dependencies": 4503 4565 4504 4566 maj, extra, err = cr.ReadHeader() ··· 4515 4577 } 4516 4578 4517 4579 if extra > 0 { 4518 4518 - t.Dependencies = make([]Pipeline_Dependencies_Elem, extra) 4580 4580 + t.Dependencies = make([]*Pipeline_Dependency, extra) 4519 4581 } 4520 4582 4521 4583 for i := 0; i < int(extra); i++ { ··· 4529 4591 4530 4592 { 4531 4593 4532 4532 - if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { 4533 4533 - return xerrors.Errorf("unmarshaling t.Dependencies[i]: %w", err) 4594 4594 + b, err := cr.ReadByte() 4595 4595 + if err != nil { 4596 4596 + return err 4597 4597 + } 4598 4598 + if b != cbg.CborNull[0] { 4599 4599 + if err := cr.UnreadByte(); err != nil { 4600 4600 + return err 4601 4601 + } 4602 4602 + t.Dependencies[i] = new(Pipeline_Dependency) 4603 4603 + if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil { 4604 4604 + return xerrors.Errorf("unmarshaling t.Dependencies[i] pointer: %w", err) 4605 4605 + } 4534 4606 } 4535 4607 4536 4608 } 4537 4609 4538 4610 } 4539 4539 - } 4540 4540 - 4541 4541 - default: 4542 4542 - // Field doesn't exist on this type, so ignore it 4543 4543 - if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 4544 4544 - return err 4545 4545 - } 4546 4546 - } 4547 4547 - } 4548 4548 - 4549 4549 - return nil 4550 4550 - } 4551 4551 - func (t *Pipeline_Workflow_Environment_Elem) MarshalCBOR(w io.Writer) error { 4552 4552 - if t == nil { 4553 4553 - _, err := w.Write(cbg.CborNull) 4554 4554 - return err 4555 4555 - } 4556 4556 - 4557 4557 - cw := cbg.NewCborWriter(w) 4558 4558 - 4559 4559 - if _, err := cw.Write([]byte{162}); err != nil { 4560 4560 - return err 4561 4561 - } 4562 4562 - 4563 4563 - // t.Key (string) (string) 4564 4564 - if len("key") > 1000000 { 4565 4565 - return xerrors.Errorf("Value in field \"key\" was too long") 4566 4566 - } 4567 4567 - 4568 4568 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("key"))); err != nil { 4569 4569 - return err 4570 4570 - } 4571 4571 - if _, err := cw.WriteString(string("key")); err != nil { 4572 4572 - return err 4573 4573 - } 4574 4574 - 4575 4575 - if len(t.Key) > 1000000 { 4576 4576 - return xerrors.Errorf("Value in field t.Key was too long") 4577 4577 - } 4578 4578 - 4579 4579 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Key))); err != nil { 4580 4580 - return err 4581 4581 - } 4582 4582 - if _, err := cw.WriteString(string(t.Key)); err != nil { 4583 4583 - return err 4584 4584 - } 4585 4585 - 4586 4586 - // t.Value (string) (string) 4587 4587 - if len("value") > 1000000 { 4588 4588 - return xerrors.Errorf("Value in field \"value\" was too long") 4589 4589 - } 4590 4590 - 4591 4591 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("value"))); err != nil { 4592 4592 - return err 4593 4593 - } 4594 4594 - if _, err := cw.WriteString(string("value")); err != nil { 4595 4595 - return err 4596 4596 - } 4597 4597 - 4598 4598 - if len(t.Value) > 1000000 { 4599 4599 - return xerrors.Errorf("Value in field t.Value was too long") 4600 4600 - } 4601 4601 - 4602 4602 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Value))); err != nil { 4603 4603 - return err 4604 4604 - } 4605 4605 - if _, err := cw.WriteString(string(t.Value)); err != nil { 4606 4606 - return err 4607 4607 - } 4608 4608 - return nil 4609 4609 - } 4610 4610 - 4611 4611 - func (t *Pipeline_Workflow_Environment_Elem) UnmarshalCBOR(r io.Reader) (err error) { 4612 4612 - *t = Pipeline_Workflow_Environment_Elem{} 4613 4613 - 4614 4614 - cr := cbg.NewCborReader(r) 4615 4615 - 4616 4616 - maj, extra, err := cr.ReadHeader() 4617 4617 - if err != nil { 4618 4618 - return err 4619 4619 - } 4620 4620 - defer func() { 4621 4621 - if err == io.EOF { 4622 4622 - err = io.ErrUnexpectedEOF 4623 4623 - } 4624 4624 - }() 4625 4625 - 4626 4626 - if maj != cbg.MajMap { 4627 4627 - return fmt.Errorf("cbor input should be of type map") 4628 4628 - } 4629 4629 - 4630 4630 - if extra > cbg.MaxLength { 4631 4631 - return fmt.Errorf("Pipeline_Workflow_Environment_Elem: map struct too large (%d)", extra) 4632 4632 - } 4633 4633 - 4634 4634 - n := extra 4635 4635 - 4636 4636 - nameBuf := make([]byte, 5) 4637 4637 - for i := uint64(0); i < n; i++ { 4638 4638 - nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 4639 4639 - if err != nil { 4640 4640 - return err 4641 4641 - } 4642 4642 - 4643 4643 - if !ok { 4644 4644 - // Field doesn't exist on this type, so ignore it 4645 4645 - if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 4646 4646 - return err 4647 4647 - } 4648 4648 - continue 4649 4649 - } 4650 4650 - 4651 4651 - switch string(nameBuf[:nameLen]) { 4652 4652 - // t.Key (string) (string) 4653 4653 - case "key": 4654 4654 - 4655 4655 - { 4656 4656 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4657 4657 - if err != nil { 4658 4658 - return err 4659 4659 - } 4660 4660 - 4661 4661 - t.Key = string(sval) 4662 4662 - } 4663 4663 - // t.Value (string) (string) 4664 4664 - case "value": 4665 4665 - 4666 4666 - { 4667 4667 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 4668 4668 - if err != nil { 4669 4669 - return err 4670 4670 - } 4671 4671 - 4672 4672 - t.Value = string(sval) 4673 4611 } 4674 4612 4675 4613 default: ··· 7268 7206 } 7269 7207 7270 7208 cw := cbg.NewCborWriter(w) 7271 7271 - fieldCount := 2 7209 7209 + fieldCount := 3 7272 7210 7273 7211 if t.Repo == nil { 7274 7212 fieldCount-- 7275 7213 } 7276 7214 7277 7215 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7216 7216 + return err 7217 7217 + } 7218 7218 + 7219 7219 + // t.Sha (string) (string) 7220 7220 + if len("sha") > 1000000 { 7221 7221 + return xerrors.Errorf("Value in field \"sha\" was too long") 7222 7222 + } 7223 7223 + 7224 7224 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sha"))); err != nil { 7225 7225 + return err 7226 7226 + } 7227 7227 + if _, err := cw.WriteString(string("sha")); err != nil { 7228 7228 + return err 7229 7229 + } 7230 7230 + 7231 7231 + if len(t.Sha) > 1000000 { 7232 7232 + return xerrors.Errorf("Value in field t.Sha was too long") 7233 7233 + } 7234 7234 + 7235 7235 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Sha))); err != nil { 7236 7236 + return err 7237 7237 + } 7238 7238 + if _, err := cw.WriteString(string(t.Sha)); err != nil { 7278 7239 return err 7279 7240 } 7280 7241 ··· 7376 7337 } 7377 7338 7378 7339 switch string(nameBuf[:nameLen]) { 7379 7379 - // t.Repo (string) (string) 7340 7340 + // t.Sha (string) (string) 7341 7341 + case "sha": 7342 7342 + 7343 7343 + { 7344 7344 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7345 7345 + if err != nil { 7346 7346 + return err 7347 7347 + } 7348 7348 + 7349 7349 + t.Sha = string(sval) 7350 7350 + } 7351 7351 + // t.Repo (string) (string) 7380 7352 case "repo": 7381 7353 7382 7354 {

+24

api/tangled/feedreaction.go

··· 1 1 + // Code generated by cmd/lexgen (see Makefile's lexgen); DO NOT EDIT. 2 2 + 3 3 + package tangled 4 4 + 5 5 + // schema: sh.tangled.feed.reaction 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + FeedReactionNSID = "sh.tangled.feed.reaction" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.feed.reaction", &FeedReaction{}) 17 17 + } // 18 18 + // RECORDTYPE: FeedReaction 19 19 + type FeedReaction struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.feed.reaction" cborgen:"$type,const=sh.tangled.feed.reaction"` 21 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 22 + Reaction string `json:"reaction" cborgen:"reaction"` 23 23 + Subject string `json:"subject" cborgen:"subject"` 24 24 + }

+1

api/tangled/repopull.go

··· 32 32 type RepoPull_Source struct { 33 33 Branch string `json:"branch" cborgen:"branch"` 34 34 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 35 35 + Sha string `json:"sha" cborgen:"sha"` 35 36 }

+13 -21

api/tangled/tangledpipeline.go

··· 29 29 Submodules bool `json:"submodules" cborgen:"submodules"` 30 30 } 31 31 32 32 - type Pipeline_Dependencies_Elem struct { 32 32 + // Pipeline_Dependency is a "dependency" in the sh.tangled.pipeline schema. 33 33 + type Pipeline_Dependency struct { 33 34 Packages []string `json:"packages" cborgen:"packages"` 34 35 Registry string `json:"registry" cborgen:"registry"` 35 36 } 36 37 37 38 // Pipeline_ManualTriggerData is a "manualTriggerData" in the sh.tangled.pipeline schema. 38 39 type Pipeline_ManualTriggerData struct { 39 39 - Inputs []*Pipeline_ManualTriggerData_Inputs_Elem `json:"inputs,omitempty" cborgen:"inputs,omitempty"` 40 40 + Inputs []*Pipeline_Pair `json:"inputs,omitempty" cborgen:"inputs,omitempty"` 40 41 } 41 42 42 42 - type Pipeline_ManualTriggerData_Inputs_Elem struct { 43 43 + // Pipeline_Pair is a "pair" in the sh.tangled.pipeline schema. 44 44 + type Pipeline_Pair struct { 43 45 Key string `json:"key" cborgen:"key"` 44 46 Value string `json:"value" cborgen:"value"` 45 47 } ··· 61 63 62 64 // Pipeline_Step is a "step" in the sh.tangled.pipeline schema. 63 65 type Pipeline_Step struct { 64 64 - Command string `json:"command" cborgen:"command"` 65 65 - Environment []*Pipeline_Step_Environment_Elem `json:"environment,omitempty" cborgen:"environment,omitempty"` 66 66 - Name string `json:"name" cborgen:"name"` 67 67 - } 68 68 - 69 69 - type Pipeline_Step_Environment_Elem struct { 70 70 - Key string `json:"key" cborgen:"key"` 71 71 - Value string `json:"value" cborgen:"value"` 66 66 + Command string `json:"command" cborgen:"command"` 67 67 + Environment []*Pipeline_Pair `json:"environment,omitempty" cborgen:"environment,omitempty"` 68 68 + Name string `json:"name" cborgen:"name"` 72 69 } 73 70 74 71 // Pipeline_TriggerMetadata is a "triggerMetadata" in the sh.tangled.pipeline schema. ··· 90 87 91 88 // Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema. 92 89 type Pipeline_Workflow struct { 93 93 - Clone *Pipeline_CloneOpts `json:"clone" cborgen:"clone"` 94 94 - Dependencies []Pipeline_Dependencies_Elem `json:"dependencies" cborgen:"dependencies"` 95 95 - Environment []*Pipeline_Workflow_Environment_Elem `json:"environment" cborgen:"environment"` 96 96 - Name string `json:"name" cborgen:"name"` 97 97 - Steps []*Pipeline_Step `json:"steps" cborgen:"steps"` 98 98 - } 99 99 - 100 100 - type Pipeline_Workflow_Environment_Elem struct { 101 101 - Key string `json:"key" cborgen:"key"` 102 102 - Value string `json:"value" cborgen:"value"` 90 90 + Clone *Pipeline_CloneOpts `json:"clone" cborgen:"clone"` 91 91 + Dependencies []*Pipeline_Dependency `json:"dependencies" cborgen:"dependencies"` 92 92 + Environment []*Pipeline_Pair `json:"environment" cborgen:"environment"` 93 93 + Name string `json:"name" cborgen:"name"` 94 94 + Steps []*Pipeline_Step `json:"steps" cborgen:"steps"` 103 95 }

+1 -1

appview/db/artifact.go

··· 27 27 } 28 28 29 29 func (a *Artifact) ArtifactAt() syntax.ATURI { 30 30 - return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoPullNSID, a.Rkey)) 30 30 + return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", a.Did, tangled.RepoArtifactNSID, a.Rkey)) 31 31 } 32 32 33 33 func AddArtifact(e Execer, artifact Artifact) error {

+10

appview/db/db.go

··· 199 199 unique(starred_by_did, repo_at) 200 200 ); 201 201 202 202 + create table if not exists reactions ( 203 203 + id integer primary key autoincrement, 204 204 + reacted_by_did text not null, 205 205 + thread_at text not null, 206 206 + kind text not null, 207 207 + rkey text not null, 208 208 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 209 209 + unique(reacted_by_did, thread_at, kind) 210 210 + ); 211 211 + 202 212 create table if not exists emails ( 203 213 id integer primary key autoincrement, 204 214 did text not null,

+2 -2

appview/db/issues.go

··· 277 277 } 278 278 279 279 func GetIssueWithComments(e Execer, repoAt syntax.ATURI, issueId int) (*Issue, []Comment, error) { 280 280 - query := `select owner_did, issue_id, created, title, body, open from issues where repo_at = ? and issue_id = ?` 280 280 + query := `select owner_did, issue_id, created, title, body, open, issue_at from issues where repo_at = ? and issue_id = ?` 281 281 row := e.QueryRow(query, repoAt, issueId) 282 282 283 283 var issue Issue 284 284 var createdAt string 285 285 - err := row.Scan(&issue.OwnerDid, &issue.IssueId, &createdAt, &issue.Title, &issue.Body, &issue.Open) 285 285 + err := row.Scan(&issue.OwnerDid, &issue.IssueId, &createdAt, &issue.Title, &issue.Body, &issue.Open, &issue.IssueAt) 286 286 if err != nil { 287 287 return nil, nil, err 288 288 }

+4 -3

appview/db/pipeline.go

··· 9 9 "github.com/bluesky-social/indigo/atproto/syntax" 10 10 "github.com/go-git/go-git/v5/plumbing" 11 11 spindle "tangled.sh/tangled.sh/core/spindle/models" 12 12 + "tangled.sh/tangled.sh/core/workflow" 12 13 ) 13 14 14 15 type Pipeline struct { ··· 85 86 86 87 type Trigger struct { 87 88 Id int 88 88 - Kind string 89 89 + Kind workflow.TriggerKind 89 90 90 91 // push trigger fields 91 92 PushRef *string ··· 100 101 } 101 102 102 103 func (t *Trigger) IsPush() bool { 103 103 - return t != nil && t.Kind == "push" 104 104 + return t != nil && t.Kind == workflow.TriggerKindPush 104 105 } 105 106 106 107 func (t *Trigger) IsPullRequest() bool { 107 107 - return t != nil && t.Kind == "pull_request" 108 108 + return t != nil && t.Kind == workflow.TriggerKindPullRequest 108 109 } 109 110 110 111 func (t *Trigger) TargetRef() string {

+6

appview/db/pulls.go

··· 87 87 if p.PullSource != nil { 88 88 s := p.PullSource.AsRecord() 89 89 source = &s 90 90 + source.Sha = p.LatestSha() 90 91 } 91 92 92 93 record := tangled.RepoPull{ ··· 162 163 func (p *Pull) LatestPatch() string { 163 164 latestSubmission := p.Submissions[p.LastRoundNumber()] 164 165 return latestSubmission.Patch 166 166 + } 167 167 + 168 168 + func (p *Pull) LatestSha() string { 169 169 + latestSubmission := p.Submissions[p.LastRoundNumber()] 170 170 + return latestSubmission.SourceRev 165 171 } 166 172 167 173 func (p *Pull) PullAt() syntax.ATURI {

+141

appview/db/reaction.go

··· 1 1 + package db 2 2 + 3 3 + import ( 4 4 + "log" 5 5 + "time" 6 6 + 7 7 + "github.com/bluesky-social/indigo/atproto/syntax" 8 8 + ) 9 9 + 10 10 + type ReactionKind string 11 11 + 12 12 + const ( 13 13 + Like ReactionKind = "👍" 14 14 + Unlike = "👎" 15 15 + Laugh = "😆" 16 16 + Celebration = "🎉" 17 17 + Confused = "🫤" 18 18 + Heart = "❤️" 19 19 + Rocket = "🚀" 20 20 + Eyes = "👀" 21 21 + ) 22 22 + 23 23 + func (rk ReactionKind) String() string { 24 24 + return string(rk) 25 25 + } 26 26 + 27 27 + var OrderedReactionKinds = []ReactionKind{ 28 28 + Like, 29 29 + Unlike, 30 30 + Laugh, 31 31 + Celebration, 32 32 + Confused, 33 33 + Heart, 34 34 + Rocket, 35 35 + Eyes, 36 36 + } 37 37 + 38 38 + func ParseReactionKind(raw string) (ReactionKind, bool) { 39 39 + k, ok := (map[string]ReactionKind{ 40 40 + "👍": Like, 41 41 + "👎": Unlike, 42 42 + "😆": Laugh, 43 43 + "🎉": Celebration, 44 44 + "🫤": Confused, 45 45 + "❤️": Heart, 46 46 + "🚀": Rocket, 47 47 + "👀": Eyes, 48 48 + })[raw] 49 49 + return k, ok 50 50 + } 51 51 + 52 52 + type Reaction struct { 53 53 + ReactedByDid string 54 54 + ThreadAt syntax.ATURI 55 55 + Created time.Time 56 56 + Rkey string 57 57 + Kind ReactionKind 58 58 + } 59 59 + 60 60 + func AddReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind ReactionKind, rkey string) error { 61 61 + query := `insert or ignore into reactions (reacted_by_did, thread_at, kind, rkey) values (?, ?, ?, ?)` 62 62 + _, err := e.Exec(query, reactedByDid, threadAt, kind, rkey) 63 63 + return err 64 64 + } 65 65 + 66 66 + // Get a reaction record 67 67 + func GetReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind ReactionKind) (*Reaction, error) { 68 68 + query := ` 69 69 + select reacted_by_did, thread_at, created, rkey 70 70 + from reactions 71 71 + where reacted_by_did = ? and thread_at = ? and kind = ?` 72 72 + row := e.QueryRow(query, reactedByDid, threadAt, kind) 73 73 + 74 74 + var reaction Reaction 75 75 + var created string 76 76 + err := row.Scan(&reaction.ReactedByDid, &reaction.ThreadAt, &created, &reaction.Rkey) 77 77 + if err != nil { 78 78 + return nil, err 79 79 + } 80 80 + 81 81 + createdAtTime, err := time.Parse(time.RFC3339, created) 82 82 + if err != nil { 83 83 + log.Println("unable to determine followed at time") 84 84 + reaction.Created = time.Now() 85 85 + } else { 86 86 + reaction.Created = createdAtTime 87 87 + } 88 88 + 89 89 + return &reaction, nil 90 90 + } 91 91 + 92 92 + // Remove a reaction 93 93 + func DeleteReaction(e Execer, reactedByDid string, threadAt syntax.ATURI, kind ReactionKind) error { 94 94 + _, err := e.Exec(`delete from reactions where reacted_by_did = ? and thread_at = ? and kind = ?`, reactedByDid, threadAt, kind) 95 95 + return err 96 96 + } 97 97 + 98 98 + // Remove a reaction 99 99 + func DeleteReactionByRkey(e Execer, reactedByDid string, rkey string) error { 100 100 + _, err := e.Exec(`delete from reactions where reacted_by_did = ? and rkey = ?`, reactedByDid, rkey) 101 101 + return err 102 102 + } 103 103 + 104 104 + func GetReactionCount(e Execer, threadAt syntax.ATURI, kind ReactionKind) (int, error) { 105 105 + count := 0 106 106 + err := e.QueryRow( 107 107 + `select count(reacted_by_did) from reactions where thread_at = ? and kind = ?`, threadAt, kind).Scan(&count) 108 108 + if err != nil { 109 109 + return 0, err 110 110 + } 111 111 + return count, nil 112 112 + } 113 113 + 114 114 + func GetReactionCountMap(e Execer, threadAt syntax.ATURI) (map[ReactionKind]int, error) { 115 115 + countMap := map[ReactionKind]int{} 116 116 + for _, kind := range OrderedReactionKinds { 117 117 + count, err := GetReactionCount(e, threadAt, kind) 118 118 + if err != nil { 119 119 + return map[ReactionKind]int{}, nil 120 120 + } 121 121 + countMap[kind] = count 122 122 + } 123 123 + return countMap, nil 124 124 + } 125 125 + 126 126 + func GetReactionStatus(e Execer, userDid string, threadAt syntax.ATURI, kind ReactionKind) bool { 127 127 + if _, err := GetReaction(e, userDid, threadAt, kind); err != nil { 128 128 + return false 129 129 + } else { 130 130 + return true 131 131 + } 132 132 + } 133 133 + 134 134 + func GetReactionStatusMap(e Execer, userDid string, threadAt syntax.ATURI) map[ReactionKind]bool { 135 135 + statusMap := map[ReactionKind]bool{} 136 136 + for _, kind := range OrderedReactionKinds { 137 137 + count := GetReactionStatus(e, userDid, threadAt, kind) 138 138 + statusMap[kind] = count 139 139 + } 140 140 + return statusMap 141 141 + }

+9

appview/idresolver/resolver.go

··· 102 102 wg.Wait() 103 103 return results 104 104 } 105 105 + 106 106 + func (r *Resolver) InvalidateIdent(ctx context.Context, arg string) error { 107 107 + id, err := syntax.ParseAtIdentifier(arg) 108 108 + if err != nil { 109 109 + return err 110 110 + } 111 111 + 112 112 + return r.directory.Purge(ctx, *id) 113 113 + }

+26 -20

appview/ingester.go

··· 40 40 } 41 41 }() 42 42 43 43 - if e.Kind != models.EventKindCommit { 44 44 - return nil 45 45 - } 46 46 - 47 47 - switch e.Commit.Collection { 48 48 - case tangled.GraphFollowNSID: 49 49 - err = i.ingestFollow(e) 50 50 - case tangled.FeedStarNSID: 51 51 - err = i.ingestStar(e) 52 52 - case tangled.PublicKeyNSID: 53 53 - err = i.ingestPublicKey(e) 54 54 - case tangled.RepoArtifactNSID: 55 55 - err = i.ingestArtifact(e) 56 56 - case tangled.ActorProfileNSID: 57 57 - err = i.ingestProfile(e) 58 58 - case tangled.SpindleMemberNSID: 59 59 - err = i.ingestSpindleMember(e) 60 60 - case tangled.SpindleNSID: 61 61 - err = i.ingestSpindle(e) 43 43 + l := i.Logger.With("kind", e.Kind) 44 44 + switch e.Kind { 45 45 + case models.EventKindAccount: 46 46 + if !e.Account.Active && *e.Account.Status == "deactivated" { 47 47 + err = i.IdResolver.InvalidateIdent(ctx, e.Account.Did) 48 48 + } 49 49 + case models.EventKindIdentity: 50 50 + err = i.IdResolver.InvalidateIdent(ctx, e.Identity.Did) 51 51 + case models.EventKindCommit: 52 52 + switch e.Commit.Collection { 53 53 + case tangled.GraphFollowNSID: 54 54 + err = i.ingestFollow(e) 55 55 + case tangled.FeedStarNSID: 56 56 + err = i.ingestStar(e) 57 57 + case tangled.PublicKeyNSID: 58 58 + err = i.ingestPublicKey(e) 59 59 + case tangled.RepoArtifactNSID: 60 60 + err = i.ingestArtifact(e) 61 61 + case tangled.ActorProfileNSID: 62 62 + err = i.ingestProfile(e) 63 63 + case tangled.SpindleMemberNSID: 64 64 + err = i.ingestSpindleMember(e) 65 65 + case tangled.SpindleNSID: 66 66 + err = i.ingestSpindle(e) 67 67 + } 68 68 + l = i.Logger.With("nsid", e.Commit.Collection) 62 69 } 63 70 64 71 if err != nil { 65 65 - l := i.Logger.With("nsid", e.Commit.Collection) 66 72 l.Error("error ingesting record", "err", err) 67 73 } 68 74

+16

appview/issues/issues.go

··· 11 11 12 12 comatproto "github.com/bluesky-social/indigo/api/atproto" 13 13 "github.com/bluesky-social/indigo/atproto/data" 14 14 + "github.com/bluesky-social/indigo/atproto/syntax" 14 15 lexutil "github.com/bluesky-social/indigo/lex/util" 15 16 "github.com/go-chi/chi/v5" 16 17 "github.com/posthog/posthog-go" ··· 79 80 return 80 81 } 81 82 83 83 + reactionCountMap, err := db.GetReactionCountMap(rp.db, syntax.ATURI(issue.IssueAt)) 84 84 + if err != nil { 85 85 + log.Println("failed to get issue reactions") 86 86 + rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 87 87 + } 88 88 + 89 89 + userReactions := map[db.ReactionKind]bool{} 90 90 + if user != nil { 91 91 + userReactions = db.GetReactionStatusMap(rp.db, user.Did, syntax.ATURI(issue.IssueAt)) 92 92 + } 93 93 + 82 94 issueOwnerIdent, err := rp.idResolver.ResolveIdent(r.Context(), issue.OwnerDid) 83 95 if err != nil { 84 96 log.Println("failed to resolve issue owner", err) ··· 106 118 107 119 IssueOwnerHandle: issueOwnerIdent.Handle.String(), 108 120 DidHandleMap: didHandleMap, 121 121 + 122 122 + OrderedReactionKinds: db.OrderedReactionKinds, 123 123 + Reactions: reactionCountMap, 124 124 + UserReacted: userReactions, 109 125 }) 110 126 111 127 }

+36 -14

appview/pages/pages.go

··· 690 690 IssueOwnerHandle string 691 691 DidHandleMap map[string]string 692 692 693 693 + OrderedReactionKinds []db.ReactionKind 694 694 + Reactions map[db.ReactionKind]int 695 695 + UserReacted map[db.ReactionKind]bool 696 696 + 693 697 State string 698 698 + } 699 699 + 700 700 + type ThreadReactionFragmentParams struct { 701 701 + ThreadAt syntax.ATURI 702 702 + Kind db.ReactionKind 703 703 + Count int 704 704 + IsReacted bool 705 705 + } 706 706 + 707 707 + func (p *Pages) ThreadReactionFragment(w io.Writer, params ThreadReactionFragmentParams) error { 708 708 + return p.executePlain("repo/fragments/reaction", w, params) 694 709 } 695 710 696 711 func (p *Pages) RepoSingleIssue(w io.Writer, params RepoSingleIssueParams) error { ··· 797 812 AbandonedPulls []*db.Pull 798 813 MergeCheck types.MergeCheckResponse 799 814 ResubmitCheck ResubmitResult 815 815 + Pipelines map[string]db.Pipeline 816 816 + 817 817 + OrderedReactionKinds []db.ReactionKind 818 818 + Reactions map[db.ReactionKind]int 819 819 + UserReacted map[db.ReactionKind]bool 800 820 } 801 821 802 822 func (p *Pages) RepoSinglePull(w io.Writer, params RepoSinglePullParams) error { ··· 805 825 } 806 826 807 827 type RepoPullPatchParams struct { 808 808 - LoggedInUser *oauth.User 809 809 - DidHandleMap map[string]string 810 810 - RepoInfo repoinfo.RepoInfo 811 811 - Pull *db.Pull 812 812 - Stack db.Stack 813 813 - Diff *types.NiceDiff 814 814 - Round int 815 815 - Submission *db.PullSubmission 828 828 + LoggedInUser *oauth.User 829 829 + DidHandleMap map[string]string 830 830 + RepoInfo repoinfo.RepoInfo 831 831 + Pull *db.Pull 832 832 + Stack db.Stack 833 833 + Diff *types.NiceDiff 834 834 + Round int 835 835 + Submission *db.PullSubmission 836 836 + OrderedReactionKinds []db.ReactionKind 816 837 } 817 838 818 839 // this name is a mouthful ··· 821 842 } 822 843 823 844 type RepoPullInterdiffParams struct { 824 824 - LoggedInUser *oauth.User 825 825 - DidHandleMap map[string]string 826 826 - RepoInfo repoinfo.RepoInfo 827 827 - Pull *db.Pull 828 828 - Round int 829 829 - Interdiff *patchutil.InterdiffResult 845 845 + LoggedInUser *oauth.User 846 846 + DidHandleMap map[string]string 847 847 + RepoInfo repoinfo.RepoInfo 848 848 + Pull *db.Pull 849 849 + Round int 850 850 + Interdiff *patchutil.InterdiffResult 851 851 + OrderedReactionKinds []db.ReactionKind 830 852 } 831 853 832 854 // this name is a mouthful

+1 -1

appview/pages/templates/layouts/repobase.html

··· 64 64 </div> 65 65 </nav> 66 66 <section 67 67 - class="bg-white dark:bg-gray-800 p-6 rounded relative w-full drop-shadow-sm dark:text-white" 67 67 + class="bg-white dark:bg-gray-800 p-6 rounded relative w-full dark:text-white" 68 68 > 69 69 {{ block "repoContent" . }}{{ end }} 70 70 </section>

+11 -10

appview/pages/templates/layouts/topbar.html

··· 1 1 {{ define "layouts/topbar" }} 2 2 <nav class="space-x-4 mb-4 px-6 py-2 rounded bg-white dark:bg-gray-800 dark:text-white drop-shadow-sm"> 3 3 - <div class="container flex justify-between p-0"> 3 3 + <div class="container flex justify-between p-0 items-center"> 4 4 <div id="left-items"> 5 5 <a href="/" hx-boost="true" class="flex gap-2 font-semibold italic"> 6 6 tangled_alpha ··· 19 19 {{ i "code" "size-4" }} source 20 20 </a> 21 21 </div> 22 22 - <div id="right-items" class="flex gap-2"> 22 22 + <div id="right-items" class="flex items-center gap-4"> 23 23 {{ with .LoggedInUser }} 24 24 - <a href="/repo/new" hx-boost="true"> 25 25 - {{ i "plus" "w-6 h-6" }} 24 24 + <a href="/repo/new" hx-boost="true" class="btn-create hover:no-underline hover:text-white"> 25 25 + {{ i "plus" "w-4 h-4" }} 26 26 </a> 27 27 {{ block "dropDown" . }} {{ end }} 28 28 {{ else }} ··· 36 36 {{ define "dropDown" }} 37 37 <details class="relative inline-block text-left"> 38 38 <summary 39 39 - class="cursor-pointer list-none" 39 39 + class="cursor-pointer list-none flex items-center" 40 40 > 41 41 - {{ didOrHandle .Did .Handle }} 41 41 + {{ $user := didOrHandle .Did .Handle }} 42 42 + {{ template "user/fragments/picHandleLink" $user }} 42 43 </summary> 43 44 <div 44 45 class="absolute flex flex-col right-0 mt-4 p-4 rounded w-48 bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700" 45 46 > 46 46 - <a href="/{{ didOrHandle .Did .Handle }}">profile</a> 47 47 + <a href="/{{ $user }}">profile</a> 47 48 <a href="/knots">knots</a> 48 49 <a href="/spindles">spindles</a> 49 50 <a href="/settings">settings</a> 50 50 - <a href="#" 51 51 - hx-post="/logout" 52 52 - hx-swap="none" 51 51 + <a href="#" 52 52 + hx-post="/logout" 53 53 + hx-swap="none" 53 54 class="text-red-400 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300"> 54 55 logout 55 56 </a>

+1 -1

appview/pages/templates/repo/commit.html

··· 59 59 <div class="flex items-center gap-2 my-2"> 60 60 {{ i "user" "w-4 h-4" }} 61 61 {{ $committerDidOrHandle := index $.EmailToDidOrHandle $commit.Committer.Email }} 62 62 - <a href="/{{ $committerDidOrHandle }}">{{ $committerDidOrHandle }}</a> 62 62 + <a href="/{{ $committerDidOrHandle }}">{{ template "user/fragments/picHandleLink" $committerDidOrHandle }}</a> 63 63 </div> 64 64 <div class="my-1 pt-2 text-xs border-t"> 65 65 <div class="text-gray-600 dark:text-gray-300">SSH Key Fingerprint:</div>

+34

appview/pages/templates/repo/fragments/reaction.html

··· 1 1 + {{ define "repo/fragments/reaction" }} 2 2 + <button 3 3 + id="reactIndi-{{ .Kind }}" 4 4 + class="flex justify-center items-center min-w-8 min-h-8 rounded border 5 5 + leading-4 px-3 gap-1 6 6 + {{ if eq .Count 0 }} 7 7 + hidden 8 8 + {{ end }} 9 9 + {{ if .IsReacted }} 10 10 + bg-sky-100 11 11 + border-sky-400 12 12 + dark:bg-sky-900 13 13 + dark:border-sky-500 14 14 + {{ else }} 15 15 + border-gray-200 16 16 + hover:bg-gray-50 17 17 + hover:border-gray-300 18 18 + dark:border-gray-700 19 19 + dark:hover:bg-gray-700 20 20 + dark:hover:border-gray-600 21 21 + {{ end }} 22 22 + " 23 23 + {{ if .IsReacted }} 24 24 + hx-delete="/react?subject={{ .ThreadAt }}&kind={{ .Kind }}" 25 25 + {{ else }} 26 26 + hx-post="/react?subject={{ .ThreadAt }}&kind={{ .Kind }}" 27 27 + {{ end }} 28 28 + hx-swap="outerHTML" 29 29 + hx-trigger="click from:(#reactBtn-{{ .Kind }}, #reactIndi-{{ .Kind }})" 30 30 + hx-disabled-elt="this" 31 31 + > 32 32 + <span>{{ .Kind }}</span> <span>{{ .Count }}</span> 33 33 + </button> 34 34 + {{ end }}

+30

appview/pages/templates/repo/fragments/reactionsPopUp.html

··· 1 1 + {{ define "repo/fragments/reactionsPopUp" }} 2 2 + <details 3 3 + id="reactionsPopUp" 4 4 + class="relative inline-block" 5 5 + > 6 6 + <summary 7 7 + class="flex justify-center items-center min-w-8 min-h-8 rounded border border-gray-200 dark:border-gray-700 8 8 + hover:bg-gray-50 9 9 + hover:border-gray-300 10 10 + dark:hover:bg-gray-700 11 11 + dark:hover:border-gray-600 12 12 + cursor-pointer list-none" 13 13 + > 14 14 + {{ i "smile" "size-4" }} 15 15 + </summary> 16 16 + <div 17 17 + class="absolute flex left-0 z-10 mt-4 rounded bg-white dark:bg-gray-800 dark:text-white border border-gray-200 dark:border-gray-700 shadow-lg" 18 18 + > 19 19 + {{ range $kind := . }} 20 20 + <button 21 21 + id="reactBtn-{{ $kind }}" 22 22 + class="size-12 hover:bg-gray-100 dark:hover:bg-gray-700" 23 23 + hx-on:click="this.parentElement.parentElement.removeAttribute('open')" 24 24 + > 25 25 + {{ $kind }} 26 26 + </button> 27 27 + {{ end }} 28 28 + </div> 29 29 + </details> 30 30 + {{ end }}

+1 -1

appview/pages/templates/repo/index.html

··· 266 266 {{ end }}" 267 267 class="text-gray-500 dark:text-gray-400 no-underline hover:underline" 268 268 >{{ if $didOrHandle }} 269 269 - {{ $didOrHandle }} 269 269 + {{ template "user/fragments/picHandleLink" $didOrHandle }} 270 270 {{ else }} 271 271 {{ .Author.Name }} 272 272 {{ end }}</a

+6 -6

appview/pages/templates/repo/issues/fragments/issueComment.html

··· 1 1 {{ define "repo/issues/fragments/issueComment" }} 2 2 {{ with .Comment }} 3 3 <div id="comment-container-{{.CommentId}}"> 4 4 - <div class="flex items-center gap-2 mb-2 text-gray-500 dark:text-gray-400 text-sm"> 4 4 + <div class="flex items-center gap-2 mb-2 text-gray-500 dark:text-gray-400 text-sm flex-wrap"> 5 5 {{ $owner := index $.DidHandleMap .OwnerDid }} 6 6 - <a href="/{{ $owner }}" class="no-underline hover:underline">{{ $owner }}</a> 6 6 + {{ template "user/fragments/picHandleLink" $owner }} 7 7 8 8 <span class="before:content-['·']"></span> 9 9 <a ··· 18 18 {{ .Created | timeFmt }} 19 19 {{ end }} 20 20 </a> 21 21 - 21 21 + 22 22 <!-- show user "hats" --> 23 23 {{ $isIssueAuthor := eq .OwnerDid $.Issue.OwnerDid }} 24 24 {{ if $isIssueAuthor }} ··· 29 29 30 30 {{ $isCommentOwner := and $.LoggedInUser (eq $.LoggedInUser.Did .OwnerDid) }} 31 31 {{ if and $isCommentOwner (not .Deleted) }} 32 32 - <button 33 33 - class="btn px-2 py-1 text-sm" 32 32 + <button 33 33 + class="btn px-2 py-1 text-sm" 34 34 hx-get="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/edit" 35 35 hx-swap="outerHTML" 36 36 hx-target="#comment-container-{{.CommentId}}" 37 37 > 38 38 {{ i "pencil" "w-4 h-4" }} 39 39 </button> 40 40 - <button 40 40 + <button 41 41 class="btn px-2 py-1 text-sm text-red-500 flex gap-2 items-center group" 42 42 hx-delete="/{{ $.RepoInfo.FullName }}/issues/{{ .Issue }}/comment/{{ .CommentId }}/" 43 43 hx-confirm="Are you sure you want to delete your comment?"

+16 -2

appview/pages/templates/repo/issues/issue.html

··· 33 33 <span class="text-gray-500 dark:text-gray-400 text-sm flex flex-wrap items-center gap-1"> 34 34 opened by 35 35 {{ $owner := didOrHandle .Issue.OwnerDid .IssueOwnerHandle }} 36 36 - {{ template "user/fragments/picHandle" $owner }} 36 36 + {{ template "user/fragments/picHandleLink" $owner }} 37 37 <span class="select-none before:content-['\00B7']"></span> 38 38 <time title="{{ .Issue.Created | longTimeFmt }}"> 39 39 {{ .Issue.Created | timeFmt }} ··· 46 46 {{ .Issue.Body | markdown }} 47 47 </article> 48 48 {{ end }} 49 49 + 50 50 + <div class="flex items-center gap-2 mt-2"> 51 51 + {{ template "repo/fragments/reactionsPopUp" .OrderedReactionKinds }} 52 52 + {{ range $kind := .OrderedReactionKinds }} 53 53 + {{ 54 54 + template "repo/fragments/reaction" 55 55 + (dict 56 56 + "Kind" $kind 57 57 + "Count" (index $.Reactions $kind) 58 58 + "IsReacted" (index $.UserReacted $kind) 59 59 + "ThreadAt" $.Issue.IssueAt) 60 60 + }} 61 61 + {{ end }} 62 62 + </div> 49 63 </section> 50 64 {{ end }} 51 65 ··· 76 90 > 77 91 <div class="bg-white dark:bg-gray-800 rounded drop-shadow-sm py-4 px-4 relative w-full md:w-3/5"> 78 92 <div class="text-sm pb-2 text-gray-500 dark:text-gray-400"> 79 79 - {{ didOrHandle .LoggedInUser.Did .LoggedInUser.Handle }} 93 93 + {{ template "user/fragments/picHandleLink" (didOrHandle .LoggedInUser.Did .LoggedInUser.Handle) }} 80 94 </div> 81 95 <textarea 82 96 id="comment-textarea"

+2 -2

appview/pages/templates/repo/issues/issues.html

··· 27 27 </div> 28 28 <a 29 29 href="/{{ .RepoInfo.FullName }}/issues/new" 30 30 - class="btn text-sm flex items-center justify-center gap-2 no-underline hover:no-underline" 30 30 + class="btn-create text-sm flex items-center justify-center gap-2 no-underline hover:no-underline hover:text-white" 31 31 > 32 32 {{ i "circle-plus" "w-4 h-4" }} 33 33 <span>new</span> ··· 66 66 67 67 <span class="ml-1"> 68 68 {{ $owner := index $.DidHandleMap .OwnerDid }} 69 69 - {{ template "user/fragments/picHandle" $owner }} 69 69 + {{ template "user/fragments/picHandleLink" $owner }} 70 70 </span> 71 71 72 72 <span class="before:content-['·']">

+5 -4

appview/pages/templates/repo/issues/new.html

··· 23 23 ></textarea> 24 24 </div> 25 25 <div> 26 26 - <button type="submit" class="btn flex items-center gap-2"> 27 27 - create 28 28 - <span id="spinner" class="group"> 29 29 - {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 26 26 + <button type="submit" class="btn-create flex items-center gap-2"> 27 27 + {{ i "circle-plus" "w-4 h-4" }} 28 28 + create issue 29 29 + <span id="create-pull-spinner" class="group"> 30 30 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 30 31 </span> 31 32 </button> 32 33 </div>

+2 -2

appview/pages/templates/repo/log.html

··· 31 31 <td class=" py-3 align-top"> 32 32 {{ $didOrHandle := index $.EmailToDidOrHandle $commit.Author.Email }} 33 33 {{ if $didOrHandle }} 34 34 - <a href="/{{ $didOrHandle }}" class="text-gray-700 dark:text-gray-300 no-underline hover:underline">{{ $didOrHandle }}</a> 34 34 + {{ template "user/fragments/picHandleLink" $didOrHandle }} 35 35 {{ else }} 36 36 <a href="mailto:{{ $commit.Author.Email }}" class="text-gray-700 dark:text-gray-300 no-underline hover:underline">{{ $commit.Author.Name }}</a> 37 37 {{ end }} ··· 159 159 {{ $didOrHandle := index $.EmailToDidOrHandle $commit.Author.Email }} 160 160 <a href="{{ if $didOrHandle }}/{{ $didOrHandle }}{{ else }}mailto:{{ $commit.Author.Email }}{{ end }}" 161 161 class="text-gray-500 dark:text-gray-400 no-underline hover:underline"> 162 162 - {{ if $didOrHandle }}{{ $didOrHandle }}{{ else }}{{ $commit.Author.Name }}{{ end }} 162 162 + {{ if $didOrHandle }}{{ template "user/fragments/picHandleLink" $didOrHandle }}{{ else }}{{ $commit.Author.Name }}{{ end }} 163 163 </a> 164 164 </span> 165 165 <div class="inline-block px-1 select-none after:content-['·']"></div>

+8 -7

appview/pages/templates/repo/new.html

··· 60 60 </fieldset> 61 61 62 62 <div class="space-y-2"> 63 63 - <button type="submit" class="btn flex items-center"> 64 64 - create repo 65 65 - <span id="spinner" class="group"> 66 66 - {{ i "loader-circle" "ml-2 w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 67 67 - </span> 68 68 - </button> 69 69 - <div id="repo" class="error"></div> 63 63 + <button type="submit" class="btn-create flex items-center gap-2"> 64 64 + {{ i "book-plus" "w-4 h-4" }} 65 65 + create repo 66 66 + <span id="create-pull-spinner" class="group"> 67 67 + {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 68 68 + </span> 69 69 + </button> 70 70 + <div id="repo" class="error"></div> 70 71 </div> 71 72 </form> 72 73 </div>

+3 -4

appview/pages/templates/repo/pipelines/fragments/logBlock.html

··· 1 1 {{ define "repo/pipelines/fragments/logBlock" }} 2 2 <div id="lines" hx-swap-oob="beforeend"> 3 3 - <details id="step-{{ .Id }}" {{if not .Collapsed}}open{{end}} class="group bg-gray-100 px-2 dark:bg-gray-900"> 4 4 - <summary class="sticky top-0 py-1 list-none cursor-pointer py-2 bg-gray-100 dark:bg-gray-900 hover:text-gray-500 hover:dark:text-gray-400"> 3 3 + <details id="step-{{ .Id }}" {{if not .Collapsed}}open{{end}} class="group bg-gray-100 pb-2 px-2 dark:bg-gray-900"> 4 4 + <summary class="sticky top-0 pt-2 group-open:pb-2 list-none cursor-pointer bg-gray-100 dark:bg-gray-900 hover:text-gray-500 hover:dark:text-gray-400"> 5 5 <div class="group-open:hidden flex items-center gap-1"> 6 6 {{ i "chevron-right" "w-4 h-4" }} {{ .Name }} 7 7 </div> ··· 9 9 {{ i "chevron-down" "w-4 h-4" }} {{ .Name }} 10 10 </div> 11 11 </summary> 12 12 - <div class="text-blue-600 dark:text-blue-300 font-mono">{{ .Command }}</div> 13 13 - <div id="step-body-{{ .Id }}" class="font-mono"></div> 12 12 + <div class="font-mono whitespace-pre overflow-x-auto"><div class="text-blue-600 dark:text-blue-300">{{ .Command }}</div><div id="step-body-{{ .Id }}"></div></div> 14 13 </details> 15 14 </div> 16 15 {{ end }}

+1 -3

appview/pages/templates/repo/pipelines/fragments/logLine.html

··· 1 1 {{ define "repo/pipelines/fragments/logLine" }} 2 2 - <div id="step-body-{{ .Id }}" hx-swap-oob="beforeend"> 3 3 - <p>{{ .Content }}</p> 4 4 - </div> 2 2 + <div id="step-body-{{ .Id }}" hx-swap-oob="beforeend" class="whitespace-pre"><p>{{ .Content }}</p></div> 5 3 {{ end }} 6 4

+1 -1

appview/pages/templates/repo/pipelines/fragments/tooltip.html

··· 10 10 {{ $lastStatus := $all.Latest }} 11 11 {{ $kind := $lastStatus.Status.String }} 12 12 13 13 - {{ $t := $pipeline.TimeTaken }} 13 13 + {{ $t := .TimeTaken }} 14 14 {{ $time := "" }} 15 15 {{ if $t }} 16 16 {{ $time = durationFmt $t }}

+13 -8

appview/pages/templates/repo/pipelines/pipelines.html

··· 34 34 {{ $p := index . 1 }} 35 35 {{ with $p }} 36 36 <div class="grid grid-cols-6 md:grid-cols-12 gap-2 items-center w-full"> 37 37 - <div class="col-span-2 md:col-span-8 flex items-center gap-4"> 37 37 + <div class="text-sm md:text-base col-span-1"> 38 38 + {{ .Trigger.Kind.String }} 39 39 + </div> 40 40 + 41 41 + <div class="col-span-2 md:col-span-7 flex items-center gap-4"> 38 42 {{ $target := .Trigger.TargetRef }} 39 43 {{ $workflows := .Workflows }} 40 44 {{ $link := "" }} ··· 43 47 {{ end }} 44 48 {{ if .Trigger.IsPush }} 45 49 <span class="font-bold">{{ $target }}</span> 46 46 - <span>push</span> 47 50 <span class="hidden md:inline-flex gap-2 items-center font-mono text-sm"> 48 51 {{ $old := deref .Trigger.PushOldSha }} 49 52 {{ $new := deref .Trigger.PushNewSha }} ··· 53 56 <a href="/{{ $root.RepoInfo.FullName }}/commit/{{ $old }}">{{ slice $old 0 8 }}</a> 54 57 </span> 55 58 {{ else if .Trigger.IsPullRequest }} 56 56 - <span> 57 57 - pull request 58 58 - <span class="inline-flex gap-2 items-center"> 59 59 - {{ $target }} 60 60 - {{ i "arrow-left" "size-4" }} 61 61 - {{ .Trigger.PRSourceBranch }} 59 59 + {{ $sha := deref .Trigger.PRSourceSha }} 60 60 + <span class="inline-flex gap-2 items-center"> 61 61 + <span class="font-bold">{{ $target }}</span> 62 62 + {{ i "arrow-left" "size-4" }} 63 63 + {{ .Trigger.PRSourceBranch }} 64 64 + <span class="text-sm font-mono"> 65 65 + @ 66 66 + <a href="/{{ $root.RepoInfo.FullName }}/commit/{{ $sha }}">{{ slice $sha 0 8 }}</a> 62 67 </span> 63 68 </span> 64 69 {{ end }}

+17 -1

appview/pages/templates/repo/pulls/fragments/pullHeader.html

··· 29 29 <span class="text-gray-500 dark:text-gray-400 text-sm flex flex-wrap items-center gap-1"> 30 30 opened by 31 31 {{ $owner := index $.DidHandleMap .Pull.OwnerDid }} 32 32 - {{ template "user/fragments/picHandle" $owner }} 32 32 + {{ template "user/fragments/picHandleLink" $owner }} 33 33 <span class="select-none before:content-['\00B7']"></span> 34 34 <time>{{ .Pull.Created | timeFmt }}</time> 35 35 ··· 60 60 <article id="body" class="mt-8 prose dark:prose-invert"> 61 61 {{ .Pull.Body | markdown }} 62 62 </article> 63 63 + {{ end }} 64 64 + 65 65 + {{ with .OrderedReactionKinds }} 66 66 + <div class="flex items-center gap-2 mt-2"> 67 67 + {{ template "repo/fragments/reactionsPopUp" . }} 68 68 + {{ range $kind := . }} 69 69 + {{ 70 70 + template "repo/fragments/reaction" 71 71 + (dict 72 72 + "Kind" $kind 73 73 + "Count" (index $.Reactions $kind) 74 74 + "IsReacted" (index $.UserReacted $kind) 75 75 + "ThreadAt" $.Pull.PullAt) 76 76 + }} 77 77 + {{ end }} 78 78 + </div> 63 79 {{ end }} 64 80 </section> 65 81

+3 -4

appview/pages/templates/repo/pulls/fragments/pullNewComment.html

··· 1 1 {{ define "repo/pulls/fragments/pullNewComment" }} 2 2 - <div 3 3 - id="pull-comment-card-{{ .RoundNumber }}" 2 2 + <div 3 3 + id="pull-comment-card-{{ .RoundNumber }}" 4 4 class="bg-white dark:bg-gray-800 rounded drop-shadow-sm p-4 relative w-full flex flex-col gap-2"> 5 5 <div class="text-sm text-gray-500 dark:text-gray-400"> 6 6 - {{ didOrHandle .LoggedInUser.Did .LoggedInUser.Handle }} 6 6 + {{ template "user/fragments/picHandleLink" (didOrHandle .LoggedInUser.Did .LoggedInUser.Handle) }} 7 7 </div> 8 8 <form 9 9 hx-post="/{{ .RepoInfo.FullName }}/pulls/{{ .Pull.PullId }}/round/{{ .RoundNumber }}/comment" ··· 38 38 </form> 39 39 </div> 40 40 {{ end }} 41 41 -

+3 -2

appview/pages/templates/repo/pulls/fragments/pullStack.html

··· 10 10 {{ i "chevrons-down-up" "w-4 h-4" }} 11 11 </span> 12 12 STACK 13 13 - <span class="bg-gray-200 dark:bg-gray-700 rounded py-1/2 px-1 text-sm ml-1">{{ len .Stack }}</span> 13 13 + <span class="bg-gray-200 dark:bg-gray-700 font-normal rounded py-1/2 px-1 text-sm">{{ len .Stack }}</span> 14 14 </span> 15 15 </summary> 16 16 {{ block "pullList" (list .Stack $) }} {{ end }} ··· 41 41 <div class="grid grid-cols-1 rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700"> 42 42 {{ range $pull := $list }} 43 43 {{ $isCurrent := false }} 44 44 + {{ $pipeline := index $root.Pipelines $pull.LatestSha }} 44 45 {{ with $root.Pull }} 45 46 {{ $isCurrent = eq $pull.PullId $root.Pull.PullId }} 46 47 {{ end }} ··· 52 53 </div> 53 54 {{ end }} 54 55 <div class="{{ if not $isCurrent }} pl-6 {{ end }} flex-grow min-w-0 w-full py-2"> 55 55 - {{ template "repo/pulls/fragments/summarizedHeader" $pull }} 56 56 + {{ template "repo/pulls/fragments/summarizedHeader" (list $pull $pipeline) }} 56 57 </div> 57 58 </div> 58 59 </a>

+36 -26

appview/pages/templates/repo/pulls/fragments/summarizedPullHeader.html

··· 1 1 {{ define "repo/pulls/fragments/summarizedHeader" }} 2 2 - <div class="flex text-sm items-center justify-between w-full"> 3 3 - <div class="flex items-center gap-2 min-w-0 flex-1 pr-2"> 4 4 - <div class="flex-shrink-0"> 5 5 - {{ template "repo/pulls/fragments/summarizedPullState" .State }} 2 2 + {{ $pull := index . 0 }} 3 3 + {{ $pipeline := index . 1 }} 4 4 + {{ with $pull }} 5 5 + <div class="flex text-sm items-center justify-between w-full"> 6 6 + <div class="flex items-center gap-2 min-w-0 flex-1 pr-2"> 7 7 + <div class="flex-shrink-0"> 8 8 + {{ template "repo/pulls/fragments/summarizedPullState" .State }} 9 9 + </div> 10 10 + <span class="truncate text-sm text-gray-800 dark:text-gray-200"> 11 11 + <span class="text-gray-500 dark:text-gray-400">#{{ .PullId }}</span> 12 12 + {{ .Title }} 13 13 + </span> 6 14 </div> 7 7 - <span class="truncate text-sm text-gray-800 dark:text-gray-200"> 8 8 - <span class="text-gray-500 dark:text-gray-400">#{{ .PullId }}</span> 9 9 - {{ .Title }} 10 10 - </span> 11 11 - </div> 12 15 13 13 - <div class="flex-shrink-0"> 14 14 - {{ $latestRound := .LastRoundNumber }} 15 15 - {{ $lastSubmission := index .Submissions $latestRound }} 16 16 - {{ $commentCount := len $lastSubmission.Comments }} 17 17 - <span> 18 18 - <div class="inline-flex items-center gap-2"> 19 19 - {{ i "message-square" "w-3 h-3 md:hidden" }} 20 20 - {{ $commentCount }} 21 21 - <span class="hidden md:inline">comment{{if ne $commentCount 1}}s{{end}}</span> 22 22 - </div> 23 23 - </span> 24 24 - <span class="mx-2 before:content-['·'] before:select-none"></span> 25 25 - <span> 26 26 - <span class="hidden md:inline">round</span> 27 27 - <span class="font-mono">#{{ $latestRound }}</span> 28 28 - </span> 16 16 + <div class="flex-shrink-0 flex items-center"> 17 17 + {{ $latestRound := .LastRoundNumber }} 18 18 + {{ $lastSubmission := index .Submissions $latestRound }} 19 19 + {{ $commentCount := len $lastSubmission.Comments }} 20 20 + {{ if $pipeline }} 21 21 + <div class="inline-flex items-center gap-2"> 22 22 + {{ template "repo/pipelines/fragments/pipelineSymbol" $pipeline }} 23 23 + <span class="mx-2 before:content-['·'] before:select-none"></span> 24 24 + </div> 25 25 + {{ end }} 26 26 + <span> 27 27 + <div class="inline-flex items-center gap-2"> 28 28 + {{ i "message-square" "w-3 h-3 md:hidden" }} 29 29 + {{ $commentCount }} 30 30 + <span class="hidden md:inline">comment{{if ne $commentCount 1}}s{{end}}</span> 31 31 + </div> 32 32 + </span> 33 33 + <span class="mx-2 before:content-['·'] before:select-none"></span> 34 34 + <span> 35 35 + <span class="hidden md:inline">round</span> 36 36 + <span class="font-mono">#{{ $latestRound }}</span> 37 37 + </span> 38 38 + </div> 29 39 </div> 30 30 - </div> 40 40 + {{ end }} 31 41 {{ end }} 32 42

+1 -1

appview/pages/templates/repo/pulls/new.html

··· 141 141 </div> 142 142 143 143 <div class="flex justify-start items-center gap-2 mt-4"> 144 144 - <button type="submit" class="btn flex items-center gap-2"> 144 144 + <button type="submit" class="btn-create flex items-center gap-2"> 145 145 {{ i "git-pull-request-create" "w-4 h-4" }} 146 146 create pull 147 147 <span id="create-pull-spinner" class="group">

+47 -8

appview/pages/templates/repo/pulls/pull.html

··· 5 5 {{ define "extrameta" }} 6 6 {{ $title := printf "%s &middot; pull #%d &middot; %s" .Pull.Title .Pull.PullId .RepoInfo.FullName }} 7 7 {{ $url := printf "https://tangled.sh/%s/pulls/%d" .RepoInfo.FullName .Pull.PullId }} 8 8 - 8 8 + 9 9 {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }} 10 10 {{ end }} 11 11 ··· 46 46 </div> 47 47 <!-- round summary --> 48 48 <div class="rounded drop-shadow-sm bg-white dark:bg-gray-800 p-2 text-gray-500 dark:text-gray-400"> 49 49 - <span> 49 49 + <span class="gap-1 flex items-center"> 50 50 {{ $owner := index $.DidHandleMap $.Pull.OwnerDid }} 51 51 {{ $re := "re" }} 52 52 {{ if eq .RoundNumber 0 }} 53 53 {{ $re = "" }} 54 54 {{ end }} 55 55 <span class="hidden md:inline">{{$re}}submitted</span> 56 56 - by <a href="/{{ $owner }}">{{ $owner }}</a> 56 56 + by {{ template "user/fragments/picHandleLink" $owner }} 57 57 <span class="select-none before:content-['\00B7']"></span> 58 58 <a class="text-gray-500 dark:text-gray-400 hover:text-gray-500" href="#round-#{{ .RoundNumber }}"><time>{{ .Created | shortTimeFmt }}</time></a> 59 59 <span class="select-none before:content-['·']"></span> ··· 68 68 <a class="btn flex items-center gap-2 no-underline hover:no-underline p-2 group" 69 69 hx-boost="true" 70 70 href="/{{ $.RepoInfo.FullName }}/pulls/{{ $.Pull.PullId }}/round/{{.RoundNumber}}"> 71 71 - {{ i "file-diff" "w-4 h-4" }} 71 71 + {{ i "file-diff" "w-4 h-4" }} 72 72 <span class="hidden md:inline">diff</span> 73 73 {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }} 74 74 </a> ··· 150 150 {{ if gt $cidx 0 }} 151 151 <div class="absolute left-8 -top-2 w-px h-2 bg-gray-300 dark:bg-gray-600"></div> 152 152 {{ end }} 153 153 - <div class="text-sm text-gray-500 dark:text-gray-400"> 154 154 - {{ $owner := index $.DidHandleMap $c.OwnerDid }} 155 155 - <a href="/{{$owner}}">{{$owner}}</a> 153 153 + <div class="text-sm text-gray-500 dark:text-gray-400 flex items-center gap-1"> 154 154 + {{ $owner := index $.DidHandleMap $c.OwnerDid }} 155 155 + {{ template "user/fragments/picHandleLink" $owner }} 156 156 <span class="before:content-['·']"></span> 157 157 <a class="text-gray-500 dark:text-gray-400 hover:text-gray-500 dark:hover:text-gray-300" href="#comment-{{.ID}}"><time>{{ $c.Created | shortTimeFmt }}</time></a> 158 158 </div> ··· 162 162 </div> 163 163 {{ end }} 164 164 165 165 + {{ block "pipelineStatus" (list $ .) }} {{ end }} 166 166 + 165 167 {{ if eq $lastIdx .RoundNumber }} 166 168 {{ block "mergeStatus" $ }} {{ end }} 167 169 {{ block "resubmitStatus" $ }} {{ end }} ··· 260 262 {{ end }} 261 263 {{ end }} 262 264 263 263 - {{ define "commits" }} 265 265 + {{ define "pipelineStatus" }} 266 266 + {{ $root := index . 0 }} 267 267 + {{ $submission := index . 1 }} 268 268 + {{ $pipeline := index $root.Pipelines $submission.SourceRev }} 269 269 + {{ with $pipeline }} 270 270 + {{ $id := .Id }} 271 271 + {{ if .Statuses }} 272 272 + <div class="max-w-80 grid grid-cols-1 bg-white dark:bg-gray-800 rounded border border-gray-200 dark:border-gray-700 divide-y divide-gray-200 dark:divide-gray-700"> 273 273 + {{ range $name, $all := .Statuses }} 274 274 + <a href="/{{ $root.RepoInfo.FullName }}/pipelines/{{ $id }}/workflow/{{ $name }}" class="no-underline hover:no-underline hover:bg-gray-100/25 hover:dark:bg-gray-700/25"> 275 275 + <div 276 276 + class="flex gap-2 items-center justify-between p-2"> 277 277 + {{ $lastStatus := $all.Latest }} 278 278 + {{ $kind := $lastStatus.Status.String }} 279 279 + 280 280 + {{ $t := .TimeTaken }} 281 281 + {{ $time := "" }} 282 282 + 283 283 + {{ if $t }} 284 284 + {{ $time = durationFmt $t }} 285 285 + {{ else }} 286 286 + {{ $time = printf "%s ago" (shortTimeFmt $lastStatus.Created) }} 287 287 + {{ end }} 288 288 + 289 289 + <div id="left" class="flex items-center gap-2 flex-shrink-0"> 290 290 + {{ template "repo/pipelines/fragments/workflowSymbol" $all }} 291 291 + {{ $name }} 292 292 + </div> 293 293 + <div id="right" class="flex items-center gap-2 flex-shrink-0"> 294 294 + <span class="font-bold">{{ $kind }}</span> 295 295 + <time>{{ $time }}</time> 296 296 + </div> 297 297 + </div> 298 298 + </a> 299 299 + {{ end }} 300 300 + </div> 301 301 + {{ end }} 302 302 + {{ end }} 264 303 {{ end }}

+3 -3

appview/pages/templates/repo/pulls/pulls.html

··· 34 34 </div> 35 35 <a 36 36 href="/{{ .RepoInfo.FullName }}/pulls/new" 37 37 - class="btn text-sm flex items-center gap-2 no-underline hover:no-underline" 37 37 + class="btn-create text-sm flex items-center gap-2 no-underline hover:no-underline hover:text-white" 38 38 > 39 39 {{ i "git-pull-request-create" "w-4 h-4" }} 40 40 <span>new</span> ··· 76 76 </span> 77 77 78 78 <span class="ml-1"> 79 79 - {{ template "user/fragments/picHandle" $owner }} 79 79 + {{ template "user/fragments/picHandleLink" $owner }} 80 80 </span> 81 81 82 82 <span> ··· 156 156 <a href="/{{ $root.RepoInfo.FullName }}/pulls/{{ $pull.PullId }}" class="no-underline hover:no-underline hover:bg-gray-100/25 hover:dark:bg-gray-700/25"> 157 157 <div class="flex gap-2 items-center px-6"> 158 158 <div class="flex-grow min-w-0 w-full py-2"> 159 159 - {{ template "repo/pulls/fragments/summarizedHeader" $pull }} 159 159 + {{ template "repo/pulls/fragments/summarizedHeader" (list $pull 0) }} 160 160 </div> 161 161 </div> 162 162 </a>

+7 -1

appview/pages/templates/repo/tree.html

··· 11 11 {{ template "repo/fragments/meta" . }} 12 12 {{ $title := printf "%s at %s &middot; %s" $path .Ref .RepoInfo.FullName }} 13 13 {{ $url := printf "https://tangled.sh/%s/tree/%s%s" .RepoInfo.FullName .Ref $path }} 14 14 - 14 14 + 15 15 {{ template "repo/fragments/og" (dict "RepoInfo" .RepoInfo "Title" $title "Url" $url) }} 16 16 {{ end }} 17 17 ··· 63 63 </div> 64 64 </a> 65 65 {{ if .LastCommit}} 66 66 + <div class="flex items-end gap-2"> 67 67 + <span class="text text-gray-500 dark:text-gray-400 mr-6">{{ .LastCommit.Message }}</span> 66 68 <time class="text-xs text-gray-500 dark:text-gray-400">{{ timeFmt .LastCommit.When }}</time> 69 69 + </div> 67 70 {{ end }} 68 71 </div> 69 72 </div> ··· 80 83 </div> 81 84 </a> 82 85 {{ if .LastCommit}} 86 86 + <div class="flex items-end gap-2"> 87 87 + <span class="text text-gray-500 dark:text-gray-400 mr-6">{{ .LastCommit.Message }}</span> 83 88 <time class="text-xs text-gray-500 dark:text-gray-400">{{ timeFmt .LastCommit.When }}</time> 89 89 + </div> 84 90 {{ end }} 85 91 </div> 86 92 </div>

+5 -5

appview/pages/templates/timeline.html

··· 61 61 {{ $userHandle := index $.DidHandleMap .Repo.Did }} 62 62 <div class="flex items-center"> 63 63 <p class="text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2"> 64 64 - {{ template "user/fragments/picHandle" $userHandle }} 64 64 + {{ template "user/fragments/picHandleLink" $userHandle }} 65 65 {{ if .Source }} 66 66 forked 67 67 <a ··· 95 95 {{ $subjectHandle := index $.DidHandleMap .Follow.SubjectDid }} 96 96 <div class="flex items-center"> 97 97 <p class="text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2"> 98 98 - {{ template "user/fragments/picHandle" $userHandle }} 98 98 + {{ template "user/fragments/picHandleLink" $userHandle }} 99 99 followed 100 100 - {{ template "user/fragments/picHandle" $subjectHandle }} 100 100 + {{ template "user/fragments/picHandleLink" $subjectHandle }} 101 101 <time 102 102 class="text-gray-700 dark:text-gray-400 text-xs" 103 103 >{{ .Follow.FollowedAt | timeFmt }}</time ··· 108 108 {{ $starrerHandle := index $.DidHandleMap .Star.StarredByDid }} 109 109 {{ $repoOwnerHandle := index $.DidHandleMap .Star.Repo.Did }} 110 110 <div class="flex items-center"> 111 111 - {{ template "user/fragments/picHandle" $starrerHandle }} 112 112 - <p class="text-gray-600 dark:text-gray-300 flex items-center gap-2"> 111 111 + <p class="text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2"> 112 112 + {{ template "user/fragments/picHandleLink" $starrerHandle }} 113 113 starred 114 114 <a 115 115 href="/{{ $repoOwnerHandle }}/{{ .Star.Repo.Name }}"

+6 -8

appview/pages/templates/user/fragments/picHandle.html

··· 1 1 {{ define "user/fragments/picHandle" }} 2 2 - <a href="/{{ . }}" class="flex items-center"> 3 3 - <img 4 4 - src="{{ tinyAvatar . }}" 5 5 - alt="{{ . }}" 6 6 - class="rounded-full h-6 w-6 mr-1 border border-gray-300 dark:border-gray-700" 7 7 - /> 8 8 - {{ . | truncateAt30 }} 9 9 - </a> 2 2 + <img 3 3 + src="{{ tinyAvatar . }}" 4 4 + alt="{{ . }}" 5 5 + class="rounded-full h-6 w-6 mr-1 border border-gray-300 dark:border-gray-700" 6 6 + /> 7 7 + {{ . | truncateAt30 }} 10 8 {{ end }}

+5

appview/pages/templates/user/fragments/picHandleLink.html

··· 1 1 + {{ define "user/fragments/picHandleLink" }} 2 2 + <a href="/{{ . }}" class="flex items-center"> 3 3 + {{ template "user/fragments/picHandle" . }} 4 4 + </a> 5 5 + {{ end }}

+69 -12

appview/pulls/pulls.go

··· 167 167 resubmitResult = s.resubmitCheck(f, pull, stack) 168 168 } 169 169 170 170 + repoInfo := f.RepoInfo(user) 171 171 + 172 172 + m := make(map[string]db.Pipeline) 173 173 + 174 174 + var shas []string 175 175 + for _, s := range pull.Submissions { 176 176 + shas = append(shas, s.SourceRev) 177 177 + } 178 178 + for _, p := range stack { 179 179 + shas = append(shas, p.LatestSha()) 180 180 + } 181 181 + for _, p := range abandonedPulls { 182 182 + shas = append(shas, p.LatestSha()) 183 183 + } 184 184 + 185 185 + ps, err := db.GetPipelineStatuses( 186 186 + s.db, 187 187 + db.FilterEq("repo_owner", repoInfo.OwnerDid), 188 188 + db.FilterEq("repo_name", repoInfo.Name), 189 189 + db.FilterEq("knot", repoInfo.Knot), 190 190 + db.FilterIn("sha", shas), 191 191 + ) 192 192 + if err != nil { 193 193 + log.Printf("failed to fetch pipeline statuses: %s", err) 194 194 + // non-fatal 195 195 + } 196 196 + 197 197 + for _, p := range ps { 198 198 + m[p.Sha] = p 199 199 + } 200 200 + 201 201 + reactionCountMap, err := db.GetReactionCountMap(s.db, pull.PullAt()) 202 202 + if err != nil { 203 203 + log.Println("failed to get pull reactions") 204 204 + s.pages.Notice(w, "pulls", "Failed to load pull. Try again later.") 205 205 + } 206 206 + 207 207 + userReactions := map[db.ReactionKind]bool{} 208 208 + if user != nil { 209 209 + userReactions = db.GetReactionStatusMap(s.db, user.Did, pull.PullAt()) 210 210 + } 211 211 + 170 212 s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{ 171 213 LoggedInUser: user, 172 172 - RepoInfo: f.RepoInfo(user), 214 214 + RepoInfo: repoInfo, 173 215 DidHandleMap: didHandleMap, 174 216 Pull: pull, 175 217 Stack: stack, 176 218 AbandonedPulls: abandonedPulls, 177 219 MergeCheck: mergeCheckResponse, 178 220 ResubmitCheck: resubmitResult, 221 221 + Pipelines: m, 222 222 + 223 223 + OrderedReactionKinds: db.OrderedReactionKinds, 224 224 + Reactions: reactionCountMap, 225 225 + UserReacted: userReactions, 179 226 }) 180 227 } 181 228 ··· 798 845 sourceBranch string, 799 846 isStacked bool, 800 847 ) { 801 801 - pullSource := &db.PullSource{ 802 802 - Branch: sourceBranch, 803 803 - } 804 804 - recordPullSource := &tangled.RepoPull_Source{ 805 805 - Branch: sourceBranch, 806 806 - } 807 807 - 808 848 // Generate a patch using /compare 809 849 ksClient, err := knotclient.NewUnsignedClient(f.Knot, s.config.Core.Dev) 810 850 if err != nil { ··· 828 868 return 829 869 } 830 870 871 871 + pullSource := &db.PullSource{ 872 872 + Branch: sourceBranch, 873 873 + } 874 874 + recordPullSource := &tangled.RepoPull_Source{ 875 875 + Branch: sourceBranch, 876 876 + Sha: comparison.Rev2, 877 877 + } 878 878 + 831 879 s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked) 832 880 } 833 881 ··· 914 962 return 915 963 } 916 964 917 917 - s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, &db.PullSource{ 965 965 + pullSource := &db.PullSource{ 918 966 Branch: sourceBranch, 919 967 RepoAt: &forkAtUri, 920 920 - }, &tangled.RepoPull_Source{Branch: sourceBranch, Repo: &fork.AtUri}, isStacked) 968 968 + } 969 969 + recordPullSource := &tangled.RepoPull_Source{ 970 970 + Branch: sourceBranch, 971 971 + Repo: &fork.AtUri, 972 972 + Sha: sourceRev, 973 973 + } 974 974 + 975 975 + s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, sourceRev, pullSource, recordPullSource, isStacked) 921 976 } 922 977 923 978 func (s *Pulls) createPullRequest( ··· 934 989 ) { 935 990 if isStacked { 936 991 // creates a series of PRs, each linking to the previous, identified by jj's change-id 937 937 - s.createStackedPulLRequest( 992 992 + s.createStackedPullRequest( 938 993 w, 939 994 r, 940 995 f, ··· 1049 1104 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", f.OwnerSlashRepo(), pullId)) 1050 1105 } 1051 1106 1052 1052 - func (s *Pulls) createStackedPulLRequest( 1107 1107 + func (s *Pulls) createStackedPullRequest( 1053 1108 w http.ResponseWriter, 1054 1109 r *http.Request, 1055 1110 f *reporesolver.ResolvedRepo, ··· 1566 1621 if pull.IsBranchBased() { 1567 1622 recordPullSource = &tangled.RepoPull_Source{ 1568 1623 Branch: pull.PullSource.Branch, 1624 1624 + Sha: sourceRev, 1569 1625 } 1570 1626 } 1571 1627 if pull.IsForkBased() { ··· 1573 1629 recordPullSource = &tangled.RepoPull_Source{ 1574 1630 Branch: pull.PullSource.Branch, 1575 1631 Repo: &repoAt, 1632 1632 + Sha: sourceRev, 1576 1633 } 1577 1634 } 1578 1635

+1 -1

appview/repo/index.go

··· 133 133 for _, c := range commitsTrunc { 134 134 shas = append(shas, c.Hash.String()) 135 135 } 136 136 - pipelines, err := rp.getPipelineStatuses(repoInfo, shas) 136 136 + pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas) 137 137 if err != nil { 138 138 log.Printf("failed to fetch pipeline statuses: %s", err) 139 139 // non-fatal

+2 -2

appview/repo/repo.go

··· 139 139 for _, c := range repolog.Commits { 140 140 shas = append(shas, c.Hash.String()) 141 141 } 142 142 - pipelines, err := rp.getPipelineStatuses(repoInfo, shas) 142 142 + pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas) 143 143 if err != nil { 144 144 log.Println(err) 145 145 // non-fatal ··· 304 304 305 305 user := rp.oauth.GetUser(r) 306 306 repoInfo := f.RepoInfo(user) 307 307 - pipelines, err := rp.getPipelineStatuses(repoInfo, []string{result.Diff.Commit.This}) 307 307 + pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This}) 308 308 if err != nil { 309 309 log.Println(err) 310 310 // non-fatal

+3 -2

appview/repo/repo_util.go

··· 105 105 // grab pipelines from DB and munge that into a hashmap with commit sha as key 106 106 // 107 107 // golang is so blessed that it requires 35 lines of imperative code for this 108 108 - func (rp *Repo) getPipelineStatuses( 108 108 + func getPipelineStatuses( 109 109 + d *db.DB, 109 110 repoInfo repoinfo.RepoInfo, 110 111 shas []string, 111 112 ) (map[string]db.Pipeline, error) { ··· 116 117 } 117 118 118 119 ps, err := db.GetPipelineStatuses( 119 119 - rp.db, 120 120 + d, 120 121 db.FilterEq("repo_owner", repoInfo.OwnerDid), 121 122 db.FilterEq("repo_name", repoInfo.Name), 122 123 db.FilterEq("knot", repoInfo.Knot),

+7 -8

appview/state/knotstream.go

··· 143 143 // trigger info 144 144 var trigger db.Trigger 145 145 var sha string 146 146 - switch record.TriggerMetadata.Kind { 146 146 + trigger.Kind = workflow.TriggerKind(record.TriggerMetadata.Kind) 147 147 + switch trigger.Kind { 147 148 case workflow.TriggerKindPush: 148 148 - trigger.Kind = workflow.TriggerKindPush 149 149 trigger.PushRef = &record.TriggerMetadata.Push.Ref 150 150 trigger.PushNewSha = &record.TriggerMetadata.Push.NewSha 151 151 trigger.PushOldSha = &record.TriggerMetadata.Push.OldSha 152 152 sha = *trigger.PushNewSha 153 153 case workflow.TriggerKindPullRequest: 154 154 - trigger.Kind = workflow.TriggerKindPush 155 154 trigger.PRSourceBranch = &record.TriggerMetadata.PullRequest.SourceBranch 156 155 trigger.PRTargetBranch = &record.TriggerMetadata.PullRequest.TargetBranch 157 156 trigger.PRSourceSha = &record.TriggerMetadata.PullRequest.SourceSha ··· 161 160 162 161 tx, err := d.Begin() 163 162 if err != nil { 164 164 - return err 163 163 + return fmt.Errorf("failed to start txn: %w", err) 165 164 } 166 165 167 166 triggerId, err := db.AddTrigger(tx, trigger) 168 167 if err != nil { 169 169 - return err 168 168 + return fmt.Errorf("failed to add trigger entry: %w", err) 170 169 } 171 170 172 171 pipeline := db.Pipeline{ ··· 180 179 181 180 err = db.AddPipeline(tx, pipeline) 182 181 if err != nil { 183 183 - return err 182 182 + return fmt.Errorf("failed to add pipeline: %w", err) 184 183 } 185 184 186 185 err = tx.Commit() 187 186 if err != nil { 188 188 - return err 187 187 + return fmt.Errorf("failed to commit txn: %w", err) 189 188 } 190 189 191 191 - return err 190 190 + return nil 192 191 }

+126

appview/state/reaction.go

··· 1 1 + package state 2 2 + 3 3 + import ( 4 4 + "log" 5 5 + "net/http" 6 6 + "time" 7 7 + 8 8 + comatproto "github.com/bluesky-social/indigo/api/atproto" 9 9 + "github.com/bluesky-social/indigo/atproto/syntax" 10 10 + 11 11 + lexutil "github.com/bluesky-social/indigo/lex/util" 12 12 + "tangled.sh/tangled.sh/core/api/tangled" 13 13 + "tangled.sh/tangled.sh/core/appview" 14 14 + "tangled.sh/tangled.sh/core/appview/db" 15 15 + "tangled.sh/tangled.sh/core/appview/pages" 16 16 + ) 17 17 + 18 18 + func (s *State) React(w http.ResponseWriter, r *http.Request) { 19 19 + currentUser := s.oauth.GetUser(r) 20 20 + 21 21 + subject := r.URL.Query().Get("subject") 22 22 + if subject == "" { 23 23 + log.Println("invalid form") 24 24 + return 25 25 + } 26 26 + 27 27 + subjectUri, err := syntax.ParseATURI(subject) 28 28 + if err != nil { 29 29 + log.Println("invalid form") 30 30 + return 31 31 + } 32 32 + 33 33 + reactionKind, ok := db.ParseReactionKind(r.URL.Query().Get("kind")) 34 34 + if !ok { 35 35 + log.Println("invalid reaction kind") 36 36 + return 37 37 + } 38 38 + 39 39 + client, err := s.oauth.AuthorizedClient(r) 40 40 + if err != nil { 41 41 + log.Println("failed to authorize client", err) 42 42 + return 43 43 + } 44 44 + 45 45 + switch r.Method { 46 46 + case http.MethodPost: 47 47 + createdAt := time.Now().Format(time.RFC3339) 48 48 + rkey := appview.TID() 49 49 + resp, err := client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 50 50 + Collection: tangled.FeedReactionNSID, 51 51 + Repo: currentUser.Did, 52 52 + Rkey: rkey, 53 53 + Record: &lexutil.LexiconTypeDecoder{ 54 54 + Val: &tangled.FeedReaction{ 55 55 + Subject: subjectUri.String(), 56 56 + Reaction: reactionKind.String(), 57 57 + CreatedAt: createdAt, 58 58 + }, 59 59 + }, 60 60 + }) 61 61 + if err != nil { 62 62 + log.Println("failed to create atproto record", err) 63 63 + return 64 64 + } 65 65 + 66 66 + err = db.AddReaction(s.db, currentUser.Did, subjectUri, reactionKind, rkey) 67 67 + if err != nil { 68 68 + log.Println("failed to react", err) 69 69 + return 70 70 + } 71 71 + 72 72 + count, err := db.GetReactionCount(s.db, subjectUri, reactionKind) 73 73 + if err != nil { 74 74 + log.Println("failed to get reaction count for ", subjectUri) 75 75 + } 76 76 + 77 77 + log.Println("created atproto record: ", resp.Uri) 78 78 + 79 79 + s.pages.ThreadReactionFragment(w, pages.ThreadReactionFragmentParams{ 80 80 + ThreadAt: subjectUri, 81 81 + Kind: reactionKind, 82 82 + Count: count, 83 83 + IsReacted: true, 84 84 + }) 85 85 + 86 86 + return 87 87 + case http.MethodDelete: 88 88 + reaction, err := db.GetReaction(s.db, currentUser.Did, subjectUri, reactionKind) 89 89 + if err != nil { 90 90 + log.Println("failed to get reaction relationship for", currentUser.Did, subjectUri) 91 91 + return 92 92 + } 93 93 + 94 94 + _, err = client.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{ 95 95 + Collection: tangled.FeedReactionNSID, 96 96 + Repo: currentUser.Did, 97 97 + Rkey: reaction.Rkey, 98 98 + }) 99 99 + 100 100 + if err != nil { 101 101 + log.Println("failed to remove reaction") 102 102 + return 103 103 + } 104 104 + 105 105 + err = db.DeleteReactionByRkey(s.db, currentUser.Did, reaction.Rkey) 106 106 + if err != nil { 107 107 + log.Println("failed to delete reaction from DB") 108 108 + // this is not an issue, the firehose event might have already done this 109 109 + } 110 110 + 111 111 + count, err := db.GetReactionCount(s.db, subjectUri, reactionKind) 112 112 + if err != nil { 113 113 + log.Println("failed to get reaction count for ", subjectUri) 114 114 + return 115 115 + } 116 116 + 117 117 + s.pages.ThreadReactionFragment(w, pages.ThreadReactionFragmentParams{ 118 118 + ThreadAt: subjectUri, 119 119 + Kind: reactionKind, 120 120 + Count: count, 121 121 + IsReacted: false, 122 122 + }) 123 123 + 124 124 + return 125 125 + } 126 126 + }

+5

appview/state/router.go

··· 137 137 r.Delete("/", s.Star) 138 138 }) 139 139 140 140 + r.With(middleware.AuthMiddleware(s.oauth)).Route("/react", func(r chi.Router) { 141 141 + r.Post("/", s.React) 142 142 + r.Delete("/", s.React) 143 143 + }) 144 144 + 140 145 r.Route("/profile", func(r chi.Router) { 141 146 r.Use(middleware.AuthMiddleware(s.oauth)) 142 147 r.Get("/edit-bio", s.EditBioFragment)

+7 -1

appview/state/spindlestream.go

··· 3 3 import ( 4 4 "context" 5 5 "encoding/json" 6 6 + "fmt" 6 7 "log/slog" 7 8 "strings" 8 9 "time" ··· 100 101 ExitCode: exitCode, 101 102 } 102 103 103 103 - return db.AddPipelineStatus(d, status) 104 104 + err = db.AddPipelineStatus(d, status) 105 105 + if err != nil { 106 106 + return fmt.Errorf("failed to add pipeline status: %w", err) 107 107 + } 108 108 + 109 109 + return nil 104 110 }

+3 -4

cmd/gen.go

··· 15 15 "api/tangled/cbor_gen.go", 16 16 "tangled", 17 17 tangled.ActorProfile{}, 18 18 + tangled.FeedReaction{}, 18 19 tangled.FeedStar{}, 19 20 tangled.GitRefUpdate{}, 20 21 tangled.GitRefUpdate_Meta{}, ··· 24 25 tangled.KnotMember{}, 25 26 tangled.Pipeline{}, 26 27 tangled.Pipeline_CloneOpts{}, 27 27 - tangled.Pipeline_Dependencies_Elem{}, 28 28 + tangled.Pipeline_Dependency{}, 28 29 tangled.Pipeline_ManualTriggerData{}, 29 29 - tangled.Pipeline_ManualTriggerData_Inputs_Elem{}, 30 30 + tangled.Pipeline_Pair{}, 30 31 tangled.Pipeline_PullRequestTriggerData{}, 31 32 tangled.Pipeline_PushTriggerData{}, 32 32 - tangled.Pipeline_Step_Environment_Elem{}, 33 33 tangled.PipelineStatus{}, 34 34 tangled.Pipeline_Step{}, 35 35 tangled.Pipeline_TriggerMetadata{}, 36 36 tangled.Pipeline_TriggerRepo{}, 37 37 tangled.Pipeline_Workflow{}, 38 38 - tangled.Pipeline_Workflow_Environment_Elem{}, 39 38 tangled.PublicKey{}, 40 39 tangled.Repo{}, 41 40 tangled.RepoArtifact{},

+5 -4

docs/hacking.md

··· 47 47 `nixos-shell` like so: 48 48 49 49 ```bash 50 50 - QEMU_NET_OPTS="hostfwd=tcp::6000-:6000,hostfwd=tcp::2222-:22" nixos-shell --flake .#knotVM 50 50 + nix run .#vm 51 51 + # or nixos-shell --flake .#vm 51 52 52 53 # hit Ctrl-a + c + q to exit the VM 53 54 ``` 54 55 55 55 - This starts a knot on port 6000 with `ssh` exposed on port 56 56 - 2222. You can push repositories to this VM with this ssh 57 57 - config block on your main machine: 56 56 + This starts a knot on port 6000, a spindle on port 6555 57 57 + with `ssh` exposed on port 2222. You can push repositories 58 58 + to this VM with this ssh config block on your main machine: 58 59 59 60 ```bash 60 61 Host nixos-shell

+33

docs/knot-hosting.md

··· 89 89 systemctl start knotserver 90 90 ``` 91 91 92 92 + The last step is to configure a reverse proxy like Nginx or Caddy to front yourself 93 93 + knot. Here's an example configuration for Nginx: 94 94 + 95 95 + ``` 96 96 + server { 97 97 + listen 80; 98 98 + listen [::]:80; 99 99 + server_name knot.example.com; 100 100 + 101 101 + location / { 102 102 + proxy_pass http://localhost:5555; 103 103 + proxy_set_header Host $host; 104 104 + proxy_set_header X-Real-IP $remote_addr; 105 105 + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; 106 106 + proxy_set_header X-Forwarded-Proto $scheme; 107 107 + } 108 108 + 109 109 + # wss endpoint for git events 110 110 + location /events { 111 111 + proxy_set_header X-Forwarded-For $remote_addr; 112 112 + proxy_set_header Host $http_host; 113 113 + proxy_set_header Upgrade websocket; 114 114 + proxy_set_header Connection Upgrade; 115 115 + proxy_pass http://localhost:5555; 116 116 + } 117 117 + # additional config for SSL/TLS go here. 118 118 + } 119 119 + 120 120 + ``` 121 121 + 122 122 + Remember to use Let's Encrypt or similar to procure a certificate for your 123 123 + knot domain. 124 124 + 92 125 You should now have a running knot server! You can finalize your registration by hitting the 93 126 `initialize` button on the [/knots](/knots) page. 94 127

+12 -3

docs/spindle/hosting.md

··· 31 31 2. **Build the Spindle binary.** 32 32 33 33 ```shell 34 34 - go build -o spindle core/spindle/server.go 34 34 + cd core 35 35 + go mod download 36 36 + go build -o cmd/spindle/spindle cmd/spindle/main.go 37 37 + ``` 38 38 + 39 39 + 3. **Create the log directory.** 40 40 + 41 41 + ```shell 42 42 + sudo mkdir -p /var/log/spindle 43 43 + sudo chown $USER:$USER -R /var/log/spindle 35 44 ``` 36 45 37 37 - 3. **Run the Spindle binary.** 46 46 + 4. **Run the Spindle binary.** 38 47 39 48 ```shell 40 40 - ./spindle 49 49 + ./cmd/spindle/spindle 41 50 ``` 42 51 43 52 Spindle will now start, connect to the Jetstream server, and begin processing pipelines.

+12 -1

eventconsumer/consumer.go

··· 172 172 func (c *Consumer) startConnectionLoop(ctx context.Context, source Source) { 173 173 defer c.wg.Done() 174 174 175 175 + // attempt connection initially 176 176 + err := c.runConnection(ctx, source) 177 177 + if err != nil { 178 178 + c.logger.Error("failed to run connection", "err", err) 179 179 + } 180 180 + 181 181 + timer := time.NewTimer(1 * time.Minute) 182 182 + defer timer.Stop() 183 183 + 184 184 + // every subsequent attempt is delayed by 1 minute 175 185 for { 176 186 select { 177 187 case <-ctx.Done(): 178 188 return 179 179 - default: 189 189 + case <-timer.C: 180 190 err := c.runConnection(ctx, source) 181 191 if err != nil { 182 192 c.logger.Error("failed to run connection", "err", err) 183 193 } 194 194 + timer.Reset(1 * time.Minute) 184 195 } 185 196 } 186 197 }

+47 -50

flake.nix

··· 53 53 }: let 54 54 supportedSystems = ["x86_64-linux" "x86_64-darwin" "aarch64-linux" "aarch64-darwin"]; 55 55 forAllSystems = nixpkgs.lib.genAttrs supportedSystems; 56 56 - nixpkgsFor = forAllSystems (system: 57 57 - import nixpkgs { 58 58 - inherit system; 59 59 - overlays = [self.overlays.default]; 60 60 - }); 56 56 + nixpkgsFor = forAllSystems (system: nixpkgs.legacyPackages.${system}); 61 57 inherit (gitignore.lib) gitignoreSource; 62 62 - in { 63 63 - overlays.default = final: prev: let 58 58 + mkPackageSet = pkgs: let 64 59 goModHash = "sha256-SLi+nALwCd/Lzn3aljwPqCo2UaM9hl/4OAjcHQLt2Bk="; 65 65 - appviewDeps = { 66 66 - inherit htmx-src htmx-ws-src lucide-src inter-fonts-src ibm-plex-mono-src goModHash gitignoreSource; 60 60 + sqlite-lib = pkgs.callPackage ./nix/pkgs/sqlite-lib.nix { 61 61 + inherit (pkgs) gcc; 62 62 + inherit sqlite-lib-src; 67 63 }; 68 68 - knotDeps = { 69 69 - inherit goModHash gitignoreSource; 64 64 + genjwks = pkgs.callPackage ./nix/pkgs/genjwks.nix {inherit goModHash gitignoreSource;}; 65 65 + lexgen = pkgs.callPackage ./nix/pkgs/lexgen.nix {inherit indigo;}; 66 66 + appview = pkgs.callPackage ./nix/pkgs/appview.nix { 67 67 + inherit sqlite-lib htmx-src htmx-ws-src lucide-src inter-fonts-src ibm-plex-mono-src goModHash gitignoreSource; 70 68 }; 71 71 - spindleDeps = { 72 72 - inherit goModHash gitignoreSource; 73 73 - }; 74 74 - mkPackageSet = pkgs: { 75 75 - lexgen = pkgs.callPackage ./nix/pkgs/lexgen.nix {inherit indigo;}; 76 76 - appview = pkgs.callPackage ./nix/pkgs/appview.nix appviewDeps; 77 77 - knot = pkgs.callPackage ./nix/pkgs/knot.nix {}; 78 78 - spindle = pkgs.callPackage ./nix/pkgs/spindle.nix spindleDeps; 79 79 - knot-unwrapped = pkgs.callPackage ./nix/pkgs/knot-unwrapped.nix knotDeps; 80 80 - sqlite-lib = pkgs.callPackage ./nix/pkgs/sqlite-lib.nix { 81 81 - inherit (pkgs) gcc; 82 82 - inherit sqlite-lib-src; 83 83 - }; 84 84 - genjwks = pkgs.callPackage ./nix/pkgs/genjwks.nix {inherit goModHash gitignoreSource;}; 85 85 - }; 86 86 - in 87 87 - mkPackageSet final; 69 69 + spindle = pkgs.callPackage ./nix/pkgs/spindle.nix {inherit sqlite-lib goModHash gitignoreSource;}; 70 70 + knot-unwrapped = pkgs.callPackage ./nix/pkgs/knot-unwrapped.nix {inherit sqlite-lib goModHash gitignoreSource;}; 71 71 + knot = pkgs.callPackage ./nix/pkgs/knot.nix {inherit knot-unwrapped;}; 72 72 + in { 73 73 + inherit lexgen appview spindle knot-unwrapped knot sqlite-lib genjwks; 74 74 + }; 75 75 + in { 76 76 + overlays.default = final: prev: mkPackageSet final; 88 77 89 78 packages = forAllSystems (system: let 90 79 pkgs = nixpkgsFor.${system}; 91 91 - staticPkgs = pkgs.pkgsStatic; 92 92 - crossPkgs = pkgs.pkgsCross.gnu64.pkgsStatic; 80 80 + packages = mkPackageSet pkgs; 81 81 + staticPackages = mkPackageSet pkgs.pkgsStatic; 82 82 + crossPackages = mkPackageSet pkgs.pkgsCross.gnu64.pkgsStatic; 93 83 in { 94 94 - appview = pkgs.appview; 95 95 - lexgen = pkgs.lexgen; 96 96 - knot = pkgs.knot; 97 97 - knot-unwrapped = pkgs.knot-unwrapped; 98 98 - spindle = pkgs.spindle; 99 99 - genjwks = pkgs.genjwks; 100 100 - sqlite-lib = pkgs.sqlite-lib; 84 84 + appview = packages.appview; 85 85 + lexgen = packages.lexgen; 86 86 + knot = packages.knot; 87 87 + knot-unwrapped = packages.knot-unwrapped; 88 88 + spindle = packages.spindle; 89 89 + genjwks = packages.genjwks; 90 90 + sqlite-lib = packages.sqlite-lib; 101 91 102 102 - pkgsStatic-appview = staticPkgs.appview; 103 103 - pkgsStatic-knot = staticPkgs.knot; 104 104 - pkgsStatic-knot-unwrapped = staticPkgs.knot-unwrapped; 105 105 - pkgsStatic-spindle = staticPkgs.spindle; 106 106 - pkgsStatic-sqlite-lib = staticPkgs.sqlite-lib; 92 92 + pkgsStatic-appview = staticPackages.appview; 93 93 + pkgsStatic-knot = staticPackages.knot; 94 94 + pkgsStatic-knot-unwrapped = staticPackages.knot-unwrapped; 95 95 + pkgsStatic-spindle = staticPackages.spindle; 96 96 + pkgsStatic-sqlite-lib = staticPackages.sqlite-lib; 107 97 108 108 - pkgsCross-gnu64-pkgsStatic-appview = crossPkgs.appview; 109 109 - pkgsCross-gnu64-pkgsStatic-knot = crossPkgs.knot; 110 110 - pkgsCross-gnu64-pkgsStatic-knot-unwrapped = crossPkgs.knot-unwrapped; 111 111 - pkgsCross-gnu64-pkgsStatic-spindle = crossPkgs.spindle; 98 98 + pkgsCross-gnu64-pkgsStatic-appview = crossPackages.appview; 99 99 + pkgsCross-gnu64-pkgsStatic-knot = crossPackages.knot; 100 100 + pkgsCross-gnu64-pkgsStatic-knot-unwrapped = crossPackages.knot-unwrapped; 101 101 + pkgsCross-gnu64-pkgsStatic-spindle = crossPackages.spindle; 112 102 }); 113 113 - defaultPackage = forAllSystems (system: nixpkgsFor.${system}.appview); 114 114 - formatter = forAllSystems (system: nixpkgsFor."${system}".alejandra); 103 103 + defaultPackage = forAllSystems (system: self.packages.${system}.appview); 104 104 + formatter = forAllSystems (system: nixpkgsFor.${system}.alejandra); 115 105 devShells = forAllSystems (system: let 116 106 pkgs = nixpkgsFor.${system}; 107 107 + packages' = self.packages.${system}; 117 108 staticShell = pkgs.mkShell.override { 118 109 stdenv = pkgs.pkgsStatic.stdenv; 119 110 }; ··· 124 115 pkgs.air 125 116 pkgs.gopls 126 117 pkgs.httpie 127 127 - pkgs.lexgen 128 118 pkgs.litecli 129 119 pkgs.websocat 130 120 pkgs.tailwindcss 131 121 pkgs.nixos-shell 132 122 pkgs.redis 123 123 + packages'.lexgen 133 124 ]; 134 125 shellHook = '' 135 126 mkdir -p appview/pages/static/{fonts,icons} ··· 139 130 cp -f ${inter-fonts-src}/web/InterVariable*.woff2 appview/pages/static/fonts/ 140 131 cp -f ${inter-fonts-src}/web/InterDisplay*.woff2 appview/pages/static/fonts/ 141 132 cp -f ${ibm-plex-mono-src}/fonts/complete/woff2/IBMPlexMono-Regular.woff2 appview/pages/static/fonts/ 142 142 - export TANGLED_OAUTH_JWKS="$(${pkgs.genjwks}/bin/genjwks)" 133 133 + export TANGLED_OAUTH_JWKS="$(${packages'.genjwks}/bin/genjwks)" 143 134 ''; 144 135 env.CGO_ENABLED = 1; 145 136 }; ··· 172 163 watch-tailwind = { 173 164 type = "app"; 174 165 program = ''${tailwind-watcher}/bin/run''; 166 166 + }; 167 167 + vm = { 168 168 + type = "app"; 169 169 + program = toString (pkgs.writeShellScript "vm" '' 170 170 + ${pkgs.nixos-shell}/bin/nixos-shell --flake .#vm 171 171 + ''); 175 172 }; 176 173 }); 177 174

+22 -19

input.css

··· 74 74 75 75 @layer components { 76 76 .btn { 77 77 - @apply relative z-10 inline-flex min-h-[30px] cursor-pointer items-center 78 78 - justify-center bg-transparent px-2 pb-[0.2rem] text-base 79 79 - text-gray-900 before:absolute before:inset-0 before:-z-10 80 80 - before:block before:rounded before:border before:border-gray-200 81 81 - before:bg-white before:drop-shadow-sm 82 82 - before:content-[''] hover:before:border-gray-300 83 83 - hover:before:bg-gray-50 84 84 - hover:before:shadow-[0_2px_2px_0_rgba(20,20,96,0.1),inset_0_-2px_0_0_#f5f5f5] 85 85 - focus:outline-none focus-visible:before:outline 86 86 - focus-visible:before:outline-4 focus-visible:before:outline-gray-500 87 87 - active:before:shadow-[inset_0_2px_2px_0_rgba(20,20,96,0.1)] 88 88 - disabled:cursor-not-allowed disabled:opacity-50 disabled:hover:before:border-gray-200 89 89 - disabled:hover:before:bg-white disabled:hover:before:shadow-none 90 90 - dark:text-gray-100 dark:before:bg-gray-800 dark:before:border-gray-700 91 91 - dark:hover:before:border-gray-600 dark:hover:before:bg-gray-700 92 92 - dark:hover:before:shadow-[0_2px_2px_0_rgba(0,0,0,0.2),inset_0_-2px_0_0_#2d3748] 93 93 - dark:focus-visible:before:outline-gray-400 94 94 - dark:active:before:shadow-[inset_0_2px_2px_0_rgba(0,0,0,0.3)] 95 95 - dark:disabled:hover:before:bg-gray-800 dark:disabled:hover:before:border-gray-700; 77 77 + @apply relative z-10 inline-flex min-h-[30px] cursor-pointer items-center justify-center 78 78 + bg-transparent px-2 pb-[0.2rem] text-sm text-gray-900 79 79 + before:absolute before:inset-0 before:-z-10 before:block before:rounded 80 80 + before:border before:border-gray-200 before:bg-white 81 81 + before:shadow-[inset_0_-2px_0_0_rgba(0,0,0,0.1),0_1px_0_0_rgba(0,0,0,0.04)] 82 82 + before:content-[''] before:transition-all before:duration-150 before:ease-in-out 83 83 + hover:before:shadow-[inset_0_-2px_0_0_rgba(0,0,0,0.15),0_2px_1px_0_rgba(0,0,0,0.06)] 84 84 + hover:before:bg-gray-50 85 85 + dark:hover:before:bg-gray-700 86 86 + active:before:shadow-[inset_0_2px_2px_0_rgba(0,0,0,0.1)] 87 87 + focus:outline-none focus-visible:before:outline focus-visible:before:outline-2 focus-visible:before:outline-gray-400 88 88 + disabled:cursor-not-allowed disabled:opacity-50 89 89 + dark:text-gray-100 dark:before:bg-gray-800 dark:before:border-gray-700; 90 90 + } 91 91 + 92 92 + .btn-create { 93 93 + @apply btn text-white 94 94 + before:bg-green-600 hover:before:bg-green-700 95 95 + dark:before:bg-green-700 dark:hover:before:bg-green-800 96 96 + before:border before:border-green-700 hover:before:border-green-800 97 97 + focus-visible:before:outline-green-500 98 98 + disabled:before:bg-green-400 dark:disabled:before:bg-green-600; 96 99 } 97 100 98 101 .prose img {

+305

knotserver/ingester.go

··· 1 1 + package knotserver 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "encoding/json" 6 6 + "fmt" 7 7 + "io" 8 8 + "net/http" 9 9 + "net/url" 10 10 + "path/filepath" 11 11 + "slices" 12 12 + "strings" 13 13 + 14 14 + comatproto "github.com/bluesky-social/indigo/api/atproto" 15 15 + "github.com/bluesky-social/indigo/atproto/syntax" 16 16 + "github.com/bluesky-social/indigo/xrpc" 17 17 + "github.com/bluesky-social/jetstream/pkg/models" 18 18 + securejoin "github.com/cyphar/filepath-securejoin" 19 19 + "tangled.sh/tangled.sh/core/api/tangled" 20 20 + "tangled.sh/tangled.sh/core/appview/idresolver" 21 21 + "tangled.sh/tangled.sh/core/knotserver/db" 22 22 + "tangled.sh/tangled.sh/core/knotserver/git" 23 23 + "tangled.sh/tangled.sh/core/log" 24 24 + "tangled.sh/tangled.sh/core/workflow" 25 25 + ) 26 26 + 27 27 + func (h *Handle) processPublicKey(ctx context.Context, did string, record tangled.PublicKey) error { 28 28 + l := log.FromContext(ctx) 29 29 + pk := db.PublicKey{ 30 30 + Did: did, 31 31 + PublicKey: record, 32 32 + } 33 33 + if err := h.db.AddPublicKey(pk); err != nil { 34 34 + l.Error("failed to add public key", "error", err) 35 35 + return fmt.Errorf("failed to add public key: %w", err) 36 36 + } 37 37 + l.Info("added public key from firehose", "did", did) 38 38 + return nil 39 39 + } 40 40 + 41 41 + func (h *Handle) processKnotMember(ctx context.Context, did string, record tangled.KnotMember) error { 42 42 + l := log.FromContext(ctx) 43 43 + 44 44 + if record.Domain != h.c.Server.Hostname { 45 45 + l.Error("domain mismatch", "domain", record.Domain, "expected", h.c.Server.Hostname) 46 46 + return fmt.Errorf("domain mismatch: %s != %s", record.Domain, h.c.Server.Hostname) 47 47 + } 48 48 + 49 49 + ok, err := h.e.E.Enforce(did, ThisServer, ThisServer, "server:invite") 50 50 + if err != nil || !ok { 51 51 + l.Error("failed to add member", "did", did) 52 52 + return fmt.Errorf("failed to enforce permissions: %w", err) 53 53 + } 54 54 + 55 55 + if err := h.e.AddKnotMember(ThisServer, record.Subject); err != nil { 56 56 + l.Error("failed to add member", "error", err) 57 57 + return fmt.Errorf("failed to add member: %w", err) 58 58 + } 59 59 + l.Info("added member from firehose", "member", record.Subject) 60 60 + 61 61 + if err := h.db.AddDid(did); err != nil { 62 62 + l.Error("failed to add did", "error", err) 63 63 + return fmt.Errorf("failed to add did: %w", err) 64 64 + } 65 65 + h.jc.AddDid(did) 66 66 + 67 67 + if err := h.fetchAndAddKeys(ctx, did); err != nil { 68 68 + return fmt.Errorf("failed to fetch and add keys: %w", err) 69 69 + } 70 70 + 71 71 + return nil 72 72 + } 73 73 + 74 74 + func (h *Handle) processPull(ctx context.Context, did string, record tangled.RepoPull) error { 75 75 + l := log.FromContext(ctx) 76 76 + l = l.With("handler", "processPull") 77 77 + l = l.With("did", did) 78 78 + l = l.With("target_repo", record.TargetRepo) 79 79 + l = l.With("target_branch", record.TargetBranch) 80 80 + 81 81 + if record.Source == nil { 82 82 + reason := "not a branch-based pull request" 83 83 + l.Info("ignoring pull record", "reason", reason) 84 84 + return fmt.Errorf("ignoring pull record: %s", reason) 85 85 + } 86 86 + 87 87 + if record.Source.Repo != nil { 88 88 + reason := "fork based pull" 89 89 + l.Info("ignoring pull record", "reason", reason) 90 90 + return fmt.Errorf("ignoring pull record: %s", reason) 91 91 + } 92 92 + 93 93 + allDids, err := h.db.GetAllDids() 94 94 + if err != nil { 95 95 + return err 96 96 + } 97 97 + 98 98 + // presently: we only process PRs from collaborators for pipelines 99 99 + if !slices.Contains(allDids, did) { 100 100 + reason := "not a known did" 101 101 + l.Info("rejecting pull record", "reason", reason) 102 102 + return fmt.Errorf("rejected pull record: %s, %s", reason, did) 103 103 + } 104 104 + 105 105 + repoAt, err := syntax.ParseATURI(record.TargetRepo) 106 106 + if err != nil { 107 107 + return err 108 108 + } 109 109 + 110 110 + // resolve this aturi to extract the repo record 111 111 + resolver := idresolver.DefaultResolver() 112 112 + ident, err := resolver.ResolveIdent(ctx, repoAt.Authority().String()) 113 113 + if err != nil || ident.Handle.IsInvalidHandle() { 114 114 + return fmt.Errorf("failed to resolve handle: %w", err) 115 115 + } 116 116 + 117 117 + xrpcc := xrpc.Client{ 118 118 + Host: ident.PDSEndpoint(), 119 119 + } 120 120 + 121 121 + resp, err := comatproto.RepoGetRecord(ctx, &xrpcc, "", tangled.RepoNSID, repoAt.Authority().String(), repoAt.RecordKey().String()) 122 122 + if err != nil { 123 123 + return err 124 124 + } 125 125 + 126 126 + repo := resp.Value.Val.(*tangled.Repo) 127 127 + 128 128 + if repo.Knot != h.c.Server.Hostname { 129 129 + reason := "not this knot" 130 130 + l.Info("rejecting pull record", "reason", reason) 131 131 + return fmt.Errorf("rejected pull record: %s", reason) 132 132 + } 133 133 + 134 134 + didSlashRepo, err := securejoin.SecureJoin(repo.Owner, repo.Name) 135 135 + if err != nil { 136 136 + return err 137 137 + } 138 138 + 139 139 + repoPath, err := securejoin.SecureJoin(h.c.Repo.ScanPath, didSlashRepo) 140 140 + if err != nil { 141 141 + return err 142 142 + } 143 143 + 144 144 + gr, err := git.Open(repoPath, record.Source.Branch) 145 145 + if err != nil { 146 146 + return err 147 147 + } 148 148 + 149 149 + workflowDir, err := gr.FileTree(ctx, workflow.WorkflowDir) 150 150 + if err != nil { 151 151 + return err 152 152 + } 153 153 + 154 154 + var pipeline workflow.Pipeline 155 155 + for _, e := range workflowDir { 156 156 + if !e.IsFile { 157 157 + continue 158 158 + } 159 159 + 160 160 + fpath := filepath.Join(workflow.WorkflowDir, e.Name) 161 161 + contents, err := gr.RawContent(fpath) 162 162 + if err != nil { 163 163 + continue 164 164 + } 165 165 + 166 166 + wf, err := workflow.FromFile(e.Name, contents) 167 167 + if err != nil { 168 168 + // TODO: log here, respond to client that is pushing 169 169 + h.l.Error("failed to parse workflow", "err", err, "path", fpath) 170 170 + continue 171 171 + } 172 172 + 173 173 + pipeline = append(pipeline, wf) 174 174 + } 175 175 + 176 176 + trigger := tangled.Pipeline_PullRequestTriggerData{ 177 177 + Action: "create", 178 178 + SourceBranch: record.Source.Branch, 179 179 + SourceSha: record.Source.Sha, 180 180 + TargetBranch: record.TargetBranch, 181 181 + } 182 182 + 183 183 + compiler := workflow.Compiler{ 184 184 + Trigger: tangled.Pipeline_TriggerMetadata{ 185 185 + Kind: string(workflow.TriggerKindPullRequest), 186 186 + PullRequest: &trigger, 187 187 + Repo: &tangled.Pipeline_TriggerRepo{ 188 188 + Did: repo.Owner, 189 189 + Knot: repo.Knot, 190 190 + Repo: repo.Name, 191 191 + }, 192 192 + }, 193 193 + } 194 194 + 195 195 + cp := compiler.Compile(pipeline) 196 196 + eventJson, err := json.Marshal(cp) 197 197 + if err != nil { 198 198 + return err 199 199 + } 200 200 + 201 201 + // do not run empty pipelines 202 202 + if cp.Workflows == nil { 203 203 + return nil 204 204 + } 205 205 + 206 206 + event := db.Event{ 207 207 + Rkey: TID(), 208 208 + Nsid: tangled.PipelineNSID, 209 209 + EventJson: string(eventJson), 210 210 + } 211 211 + 212 212 + return h.db.InsertEvent(event, h.n) 213 213 + } 214 214 + 215 215 + func (h *Handle) fetchAndAddKeys(ctx context.Context, did string) error { 216 216 + l := log.FromContext(ctx) 217 217 + 218 218 + keysEndpoint, err := url.JoinPath(h.c.AppViewEndpoint, "keys", did) 219 219 + if err != nil { 220 220 + l.Error("error building endpoint url", "did", did, "error", err.Error()) 221 221 + return fmt.Errorf("error building endpoint url: %w", err) 222 222 + } 223 223 + 224 224 + resp, err := http.Get(keysEndpoint) 225 225 + if err != nil { 226 226 + l.Error("error getting keys", "did", did, "error", err) 227 227 + return fmt.Errorf("error getting keys: %w", err) 228 228 + } 229 229 + defer resp.Body.Close() 230 230 + 231 231 + if resp.StatusCode == http.StatusNotFound { 232 232 + l.Info("no keys found for did", "did", did) 233 233 + return nil 234 234 + } 235 235 + 236 236 + plaintext, err := io.ReadAll(resp.Body) 237 237 + if err != nil { 238 238 + l.Error("error reading response body", "error", err) 239 239 + return fmt.Errorf("error reading response body: %w", err) 240 240 + } 241 241 + 242 242 + for _, key := range strings.Split(string(plaintext), "\n") { 243 243 + if key == "" { 244 244 + continue 245 245 + } 246 246 + pk := db.PublicKey{ 247 247 + Did: did, 248 248 + } 249 249 + pk.Key = key 250 250 + if err := h.db.AddPublicKey(pk); err != nil { 251 251 + l.Error("failed to add public key", "error", err) 252 252 + return fmt.Errorf("failed to add public key: %w", err) 253 253 + } 254 254 + } 255 255 + return nil 256 256 + } 257 257 + 258 258 + func (h *Handle) processMessages(ctx context.Context, event *models.Event) error { 259 259 + did := event.Did 260 260 + if event.Kind != models.EventKindCommit { 261 261 + return nil 262 262 + } 263 263 + 264 264 + var err error 265 265 + defer func() { 266 266 + eventTime := event.TimeUS 267 267 + lastTimeUs := eventTime + 1 268 268 + fmt.Println("lastTimeUs", lastTimeUs) 269 269 + if err := h.db.SaveLastTimeUs(lastTimeUs); err != nil { 270 270 + err = fmt.Errorf("(deferred) failed to save last time us: %w", err) 271 271 + } 272 272 + }() 273 273 + 274 274 + raw := json.RawMessage(event.Commit.Record) 275 275 + 276 276 + switch event.Commit.Collection { 277 277 + case tangled.PublicKeyNSID: 278 278 + var record tangled.PublicKey 279 279 + if err := json.Unmarshal(raw, &record); err != nil { 280 280 + return fmt.Errorf("failed to unmarshal record: %w", err) 281 281 + } 282 282 + if err := h.processPublicKey(ctx, did, record); err != nil { 283 283 + return fmt.Errorf("failed to process public key: %w", err) 284 284 + } 285 285 + 286 286 + case tangled.KnotMemberNSID: 287 287 + var record tangled.KnotMember 288 288 + if err := json.Unmarshal(raw, &record); err != nil { 289 289 + return fmt.Errorf("failed to unmarshal record: %w", err) 290 290 + } 291 291 + if err := h.processKnotMember(ctx, did, record); err != nil { 292 292 + return fmt.Errorf("failed to process knot member: %w", err) 293 293 + } 294 294 + case tangled.RepoPullNSID: 295 295 + var record tangled.RepoPull 296 296 + if err := json.Unmarshal(raw, &record); err != nil { 297 297 + return fmt.Errorf("failed to unmarshal record: %w", err) 298 298 + } 299 299 + if err := h.processPull(ctx, did, record); err != nil { 300 300 + return fmt.Errorf("failed to process knot member: %w", err) 301 301 + } 302 302 + } 303 303 + 304 304 + return err 305 305 + }

+2 -6

knotserver/internal.go

··· 147 147 } 148 148 149 149 func (h *InternalHandle) triggerPipeline(line git.PostReceiveLine, gitUserDid, repoDid, repoName string) error { 150 150 - const ( 151 151 - WorkflowDir = ".tangled/workflows" 152 152 - ) 153 153 - 154 150 didSlashRepo, err := securejoin.SecureJoin(repoDid, repoName) 155 151 if err != nil { 156 152 return err ··· 166 162 return err 167 163 } 168 164 169 169 - workflowDir, err := gr.FileTree(context.Background(), WorkflowDir) 165 165 + workflowDir, err := gr.FileTree(context.Background(), workflow.WorkflowDir) 170 166 if err != nil { 171 167 return err 172 168 } ··· 177 173 continue 178 174 } 179 175 180 180 - fpath := filepath.Join(WorkflowDir, e.Name) 176 176 + fpath := filepath.Join(workflow.WorkflowDir, e.Name) 181 177 contents, err := gr.RawContent(fpath) 182 178 if err != nil { 183 179 continue

-147

knotserver/jetstream.go

··· 1 1 - package knotserver 2 2 - 3 3 - import ( 4 4 - "context" 5 5 - "encoding/json" 6 6 - "fmt" 7 7 - "io" 8 8 - "net/http" 9 9 - "net/url" 10 10 - "strings" 11 11 - 12 12 - "github.com/bluesky-social/jetstream/pkg/models" 13 13 - "tangled.sh/tangled.sh/core/api/tangled" 14 14 - "tangled.sh/tangled.sh/core/knotserver/db" 15 15 - "tangled.sh/tangled.sh/core/log" 16 16 - ) 17 17 - 18 18 - func (h *Handle) processPublicKey(ctx context.Context, did string, record tangled.PublicKey) error { 19 19 - l := log.FromContext(ctx) 20 20 - pk := db.PublicKey{ 21 21 - Did: did, 22 22 - PublicKey: record, 23 23 - } 24 24 - if err := h.db.AddPublicKey(pk); err != nil { 25 25 - l.Error("failed to add public key", "error", err) 26 26 - return fmt.Errorf("failed to add public key: %w", err) 27 27 - } 28 28 - l.Info("added public key from firehose", "did", did) 29 29 - return nil 30 30 - } 31 31 - 32 32 - func (h *Handle) processKnotMember(ctx context.Context, did string, record tangled.KnotMember) error { 33 33 - l := log.FromContext(ctx) 34 34 - 35 35 - if record.Domain != h.c.Server.Hostname { 36 36 - l.Error("domain mismatch", "domain", record.Domain, "expected", h.c.Server.Hostname) 37 37 - return fmt.Errorf("domain mismatch: %s != %s", record.Domain, h.c.Server.Hostname) 38 38 - } 39 39 - 40 40 - ok, err := h.e.E.Enforce(did, ThisServer, ThisServer, "server:invite") 41 41 - if err != nil || !ok { 42 42 - l.Error("failed to add member", "did", did) 43 43 - return fmt.Errorf("failed to enforce permissions: %w", err) 44 44 - } 45 45 - 46 46 - if err := h.e.AddKnotMember(ThisServer, record.Subject); err != nil { 47 47 - l.Error("failed to add member", "error", err) 48 48 - return fmt.Errorf("failed to add member: %w", err) 49 49 - } 50 50 - l.Info("added member from firehose", "member", record.Subject) 51 51 - 52 52 - if err := h.db.AddDid(did); err != nil { 53 53 - l.Error("failed to add did", "error", err) 54 54 - return fmt.Errorf("failed to add did: %w", err) 55 55 - } 56 56 - h.jc.AddDid(did) 57 57 - 58 58 - if err := h.fetchAndAddKeys(ctx, did); err != nil { 59 59 - return fmt.Errorf("failed to fetch and add keys: %w", err) 60 60 - } 61 61 - 62 62 - return nil 63 63 - } 64 64 - 65 65 - func (h *Handle) fetchAndAddKeys(ctx context.Context, did string) error { 66 66 - l := log.FromContext(ctx) 67 67 - 68 68 - keysEndpoint, err := url.JoinPath(h.c.AppViewEndpoint, "keys", did) 69 69 - if err != nil { 70 70 - l.Error("error building endpoint url", "did", did, "error", err.Error()) 71 71 - return fmt.Errorf("error building endpoint url: %w", err) 72 72 - } 73 73 - 74 74 - resp, err := http.Get(keysEndpoint) 75 75 - if err != nil { 76 76 - l.Error("error getting keys", "did", did, "error", err) 77 77 - return fmt.Errorf("error getting keys: %w", err) 78 78 - } 79 79 - defer resp.Body.Close() 80 80 - 81 81 - if resp.StatusCode == http.StatusNotFound { 82 82 - l.Info("no keys found for did", "did", did) 83 83 - return nil 84 84 - } 85 85 - 86 86 - plaintext, err := io.ReadAll(resp.Body) 87 87 - if err != nil { 88 88 - l.Error("error reading response body", "error", err) 89 89 - return fmt.Errorf("error reading response body: %w", err) 90 90 - } 91 91 - 92 92 - for _, key := range strings.Split(string(plaintext), "\n") { 93 93 - if key == "" { 94 94 - continue 95 95 - } 96 96 - pk := db.PublicKey{ 97 97 - Did: did, 98 98 - } 99 99 - pk.Key = key 100 100 - if err := h.db.AddPublicKey(pk); err != nil { 101 101 - l.Error("failed to add public key", "error", err) 102 102 - return fmt.Errorf("failed to add public key: %w", err) 103 103 - } 104 104 - } 105 105 - return nil 106 106 - } 107 107 - 108 108 - func (h *Handle) processMessages(ctx context.Context, event *models.Event) error { 109 109 - did := event.Did 110 110 - if event.Kind != models.EventKindCommit { 111 111 - return nil 112 112 - } 113 113 - 114 114 - var err error 115 115 - defer func() { 116 116 - eventTime := event.TimeUS 117 117 - lastTimeUs := eventTime + 1 118 118 - fmt.Println("lastTimeUs", lastTimeUs) 119 119 - if err := h.db.SaveLastTimeUs(lastTimeUs); err != nil { 120 120 - err = fmt.Errorf("(deferred) failed to save last time us: %w", err) 121 121 - } 122 122 - }() 123 123 - 124 124 - raw := json.RawMessage(event.Commit.Record) 125 125 - 126 126 - switch event.Commit.Collection { 127 127 - case tangled.PublicKeyNSID: 128 128 - var record tangled.PublicKey 129 129 - if err := json.Unmarshal(raw, &record); err != nil { 130 130 - return fmt.Errorf("failed to unmarshal record: %w", err) 131 131 - } 132 132 - if err := h.processPublicKey(ctx, did, record); err != nil { 133 133 - return fmt.Errorf("failed to process public key: %w", err) 134 134 - } 135 135 - 136 136 - case tangled.KnotMemberNSID: 137 137 - var record tangled.KnotMember 138 138 - if err := json.Unmarshal(raw, &record); err != nil { 139 139 - return fmt.Errorf("failed to unmarshal record: %w", err) 140 140 - } 141 141 - if err := h.processKnotMember(ctx, did, record); err != nil { 142 142 - return fmt.Errorf("failed to process knot member: %w", err) 143 143 - } 144 144 - } 145 145 - 146 146 - return err 147 147 - }

+1

knotserver/server.go

··· 75 75 jc, err := jetstream.NewJetstreamClient(c.Server.JetstreamEndpoint, "knotserver", []string{ 76 76 tangled.PublicKeyNSID, 77 77 tangled.KnotMemberNSID, 78 78 + tangled.RepoPullNSID, 78 79 }, nil, logger, db, true, c.Server.LogDids) 79 80 if err != nil { 80 81 logger.Error("failed to setup jetstream", "error", err)

+34

lexicons/feed/reaction.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.feed.reaction", 4 4 + "needsCbor": true, 5 5 + "needsType": true, 6 6 + "defs": { 7 7 + "main": { 8 8 + "type": "record", 9 9 + "key": "tid", 10 10 + "record": { 11 11 + "type": "object", 12 12 + "required": [ 13 13 + "subject", 14 14 + "reaction", 15 15 + "createdAt" 16 16 + ], 17 17 + "properties": { 18 18 + "subject": { 19 19 + "type": "string", 20 20 + "format": "at-uri" 21 21 + }, 22 22 + "reaction": { 23 23 + "type": "string", 24 24 + "enum": [ "👍", "👎", "😆", "🎉", "🫤", "❤️", "🚀", "👀" ] 25 25 + }, 26 26 + "createdAt": { 27 27 + "type": "string", 28 28 + "format": "datetime" 29 29 + } 30 30 + } 31 31 + } 32 32 + } 33 33 + } 34 34 + }

+85 -54

lexicons/pipeline.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": ["triggerMetadata", "workflows"], 12 12 + "required": [ 13 13 + "triggerMetadata", 14 14 + "workflows" 15 15 + ], 13 16 "properties": { 14 17 "triggerMetadata": { 15 18 "type": "ref", ··· 27 30 }, 28 31 "triggerMetadata": { 29 32 "type": "object", 30 30 - "required": ["kind", "repo"], 33 33 + "required": [ 34 34 + "kind", 35 35 + "repo" 36 36 + ], 31 37 "properties": { 32 38 "kind": { 33 39 "type": "string", 34 34 - "enum": ["push", "pull_request", "manual"] 40 40 + "enum": [ 41 41 + "push", 42 42 + "pull_request", 43 43 + "manual" 44 44 + ] 35 45 }, 36 46 "repo": { 37 47 "type": "ref", ··· 53 63 }, 54 64 "triggerRepo": { 55 65 "type": "object", 56 56 - "required": ["knot", "did", "repo", "defaultBranch"], 66 66 + "required": [ 67 67 + "knot", 68 68 + "did", 69 69 + "repo", 70 70 + "defaultBranch" 71 71 + ], 57 72 "properties": { 58 73 "knot": { 59 74 "type": "string" ··· 72 87 }, 73 88 "pushTriggerData": { 74 89 "type": "object", 75 75 - "required": ["ref", "newSha", "oldSha"], 90 90 + "required": [ 91 91 + "ref", 92 92 + "newSha", 93 93 + "oldSha" 94 94 + ], 76 95 "properties": { 77 96 "ref": { 78 97 "type": "string" ··· 91 110 }, 92 111 "pullRequestTriggerData": { 93 112 "type": "object", 94 94 - "required": ["sourceBranch", "targetBranch", "sourceSha", "action"], 113 113 + "required": [ 114 114 + "sourceBranch", 115 115 + "targetBranch", 116 116 + "sourceSha", 117 117 + "action" 118 118 + ], 95 119 "properties": { 96 120 "sourceBranch": { 97 121 "type": "string" ··· 115 139 "inputs": { 116 140 "type": "array", 117 141 "items": { 118 118 - "type": "object", 119 119 - "required": ["key", "value"], 120 120 - "properties": { 121 121 - "key": { 122 122 - "type": "string" 123 123 - }, 124 124 - "value": { 125 125 - "type": "string" 126 126 - } 127 127 - } 142 142 + "type": "ref", 143 143 + "ref": "#pair" 128 144 } 129 145 } 130 146 } 131 147 }, 132 148 "workflow": { 133 149 "type": "object", 134 134 - "required": ["name", "dependencies", "steps", "environment", "clone"], 150 150 + "required": [ 151 151 + "name", 152 152 + "dependencies", 153 153 + "steps", 154 154 + "environment", 155 155 + "clone" 156 156 + ], 135 157 "properties": { 136 158 "name": { 137 159 "type": "string" 138 160 }, 139 161 "dependencies": { 140 140 - "type": "ref", 141 141 - "ref": "#dependencies" 162 162 + "type": "array", 163 163 + "items": { 164 164 + "type": "ref", 165 165 + "ref": "#dependency" 166 166 + } 142 167 }, 143 168 "steps": { 144 169 "type": "array", ··· 150 175 "environment": { 151 176 "type": "array", 152 177 "items": { 153 153 - "type": "object", 154 154 - "required": ["key", "value"], 155 155 - "properties": { 156 156 - "key": { 157 157 - "type": "string" 158 158 - }, 159 159 - "value": { 160 160 - "type": "string" 161 161 - } 162 162 - } 178 178 + "type": "ref", 179 179 + "ref": "#pair" 163 180 } 164 181 }, 165 182 "clone": { ··· 168 185 } 169 186 } 170 187 }, 171 171 - "dependencies": { 172 172 - "type": "array", 173 173 - "items": { 174 174 - "type": "object", 175 175 - "required": ["registry", "packages"], 176 176 - "properties": { 177 177 - "registry": { 188 188 + "dependency": { 189 189 + "type": "object", 190 190 + "required": [ 191 191 + "registry", 192 192 + "packages" 193 193 + ], 194 194 + "properties": { 195 195 + "registry": { 196 196 + "type": "string" 197 197 + }, 198 198 + "packages": { 199 199 + "type": "array", 200 200 + "items": { 178 201 "type": "string" 179 179 - }, 180 180 - "packages": { 181 181 - "type": "array", 182 182 - "items": { 183 183 - "type": "string" 184 184 - } 185 202 } 186 203 } 187 204 } 188 205 }, 189 206 "cloneOpts": { 190 207 "type": "object", 191 191 - "required": ["skip", "depth", "submodules"], 208 208 + "required": [ 209 209 + "skip", 210 210 + "depth", 211 211 + "submodules" 212 212 + ], 192 213 "properties": { 193 214 "skip": { 194 215 "type": "boolean" ··· 203 224 }, 204 225 "step": { 205 226 "type": "object", 206 206 - "required": ["name", "command"], 227 227 + "required": [ 228 228 + "name", 229 229 + "command" 230 230 + ], 207 231 "properties": { 208 232 "name": { 209 233 "type": "string" ··· 214 238 "environment": { 215 239 "type": "array", 216 240 "items": { 217 217 - "type": "object", 218 218 - "required": ["key", "value"], 219 219 - "properties": { 220 220 - "key": { 221 221 - "type": "string" 222 222 - }, 223 223 - "value": { 224 224 - "type": "string" 225 225 - } 226 226 - } 241 241 + "type": "ref", 242 242 + "ref": "#pair" 227 243 } 244 244 + } 245 245 + } 246 246 + }, 247 247 + "pair": { 248 248 + "type": "object", 249 249 + "required": [ 250 250 + "key", 251 251 + "value" 252 252 + ], 253 253 + "properties": { 254 254 + "key": { 255 255 + "type": "string" 256 256 + }, 257 257 + "value": { 258 258 + "type": "string" 228 259 } 229 260 } 230 261 }

+7 -1

lexicons/pulls/pull.json

··· 51 51 "source": { 52 52 "type": "object", 53 53 "required": [ 54 54 - "branch" 54 54 + "branch", 55 55 + "sha" 55 56 ], 56 57 "properties": { 57 58 "branch": { 58 59 "type": "string" 60 60 + }, 61 61 + "sha": { 62 62 + "type": "string", 63 63 + "minLength": 40, 64 64 + "maxLength": 40 59 65 }, 60 66 "repo": { 61 67 "type": "string",

+1 -1

spindle/engine/engine.go

··· 90 90 91 91 reader, err := e.docker.ImagePull(ctx, w.Image, image.PullOptions{}) 92 92 if err != nil { 93 93 - e.l.Error("pipeline failed!", "workflowId", wid, "error", err.Error()) 93 93 + e.l.Error("pipeline image pull failed!", "image", w.Image, "workflowId", wid, "error", err.Error()) 94 94 95 95 err := e.db.StatusFailed(wid, err.Error(), -1, e.n) 96 96 if err != nil {

+2 -2

spindle/engine/envs_test.go

··· 34 34 if got == nil { 35 35 got = EnvVars{} 36 36 } 37 37 - assert.Equal(t, tt.want, got) 37 37 + assert.ElementsMatch(t, tt.want, got) 38 38 }) 39 39 } 40 40 } ··· 44 44 ev.AddEnv("FOO", "bar") 45 45 ev.AddEnv("BAZ", "qux") 46 46 want := EnvVars{"FOO=bar", "BAZ=qux"} 47 47 - assert.Equal(t, want, ev) 47 47 + assert.ElementsMatch(t, want, ev) 48 48 }

+9 -6

spindle/models/pipeline.go

··· 69 69 70 70 setup.addStep(nixConfStep()) 71 71 setup.addStep(cloneStep(*twf, *pl.TriggerMetadata, cfg.Server.Dev)) 72 72 - setup.addStep(checkoutStep(*twf, *pl.TriggerMetadata)) 73 72 // this step could be empty 74 73 if s := dependencyStep(*twf); s != nil { 75 74 setup.addStep(*s) ··· 83 82 return &Pipeline{Workflows: workflows} 84 83 } 85 84 86 86 - func workflowEnvToMap(envs []*tangled.Pipeline_Workflow_Environment_Elem) map[string]string { 85 85 + func workflowEnvToMap(envs []*tangled.Pipeline_Pair) map[string]string { 87 86 envMap := map[string]string{} 88 87 for _, env := range envs { 89 89 - envMap[env.Key] = env.Value 88 88 + if env != nil { 89 89 + envMap[env.Key] = env.Value 90 90 + } 90 91 } 91 92 return envMap 92 93 } 93 94 94 94 - func stepEnvToMap(envs []*tangled.Pipeline_Step_Environment_Elem) map[string]string { 95 95 + func stepEnvToMap(envs []*tangled.Pipeline_Pair) map[string]string { 95 96 envMap := map[string]string{} 96 97 for _, env := range envs { 97 97 - envMap[env.Key] = env.Value 98 98 + if env != nil { 99 99 + envMap[env.Key] = env.Value 100 100 + } 98 101 } 99 102 return envMap 100 103 } 101 104 102 102 - func workflowImage(deps []tangled.Pipeline_Dependencies_Elem, nixery string) string { 105 105 + func workflowImage(deps []*tangled.Pipeline_Dependency, nixery string) string { 103 106 var dependencies string 104 107 for _, d := range deps { 105 108 if d.Registry == "nixpkgs" {

+45 -56

spindle/models/setup_steps.go

··· 5 5 "path" 6 6 "strings" 7 7 8 8 - "github.com/go-git/go-git/v5/plumbing" 9 8 "tangled.sh/tangled.sh/core/api/tangled" 10 9 "tangled.sh/tangled.sh/core/workflow" 11 10 ) ··· 19 18 } 20 19 } 21 20 22 22 - // checkoutStep checks out the specified ref in the cloned repository. 23 23 - func checkoutStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata) Step { 24 24 - if twf.Clone.Skip { 25 25 - return Step{} 26 26 - } 27 27 - 28 28 - var ref string 29 29 - switch tr.Kind { 30 30 - case "push": 31 31 - ref = tr.Push.NewSha 32 32 - case "pull_request": 33 33 - ref = tr.PullRequest.TargetBranch 34 34 - 35 35 - // TODO: this needs to be specified in lexicon 36 36 - case "manual": 37 37 - ref = tr.Repo.DefaultBranch 38 38 - } 39 39 - 40 40 - checkoutCmd := fmt.Sprintf("git config advice.detachedHead false; git checkout --progress --force %s", ref) 41 41 - 42 42 - return Step{ 43 43 - Command: checkoutCmd, 44 44 - Name: "Checkout ref " + ref, 45 45 - } 46 46 - } 47 47 - 48 21 // cloneOptsAsSteps processes clone options and adds corresponding steps 49 22 // to the beginning of the workflow's step list if cloning is not skipped. 23 23 + // 24 24 + // the steps to do here are: 25 25 + // - git init 26 26 + // - git remote add origin <url> 27 27 + // - git fetch --depth=<d> --recurse-submodules=<yes|no> <sha> 28 28 + // - git checkout FETCH_HEAD 50 29 func cloneStep(twf tangled.Pipeline_Workflow, tr tangled.Pipeline_TriggerMetadata, dev bool) Step { 51 30 if twf.Clone.Skip { 52 31 return Step{} 53 32 } 54 33 55 55 - uri := "https://" 34 34 + var commands []string 35 35 + 36 36 + // initialize git repo in workspace 37 37 + commands = append(commands, "git init") 38 38 + 39 39 + // add repo as git remote 40 40 + scheme := "https://" 56 41 if dev { 57 57 - uri = "http://" 42 42 + scheme = "http://" 58 43 tr.Repo.Knot = strings.ReplaceAll(tr.Repo.Knot, "localhost", "host.docker.internal") 59 44 } 45 45 + url := scheme + path.Join(tr.Repo.Knot, tr.Repo.Did, tr.Repo.Repo) 46 46 + commands = append(commands, fmt.Sprintf("git remote add origin %s", url)) 60 47 61 61 - cloneUrl := uri + path.Join(tr.Repo.Knot, tr.Repo.Did, tr.Repo.Repo) 62 62 - cloneCmd := []string{"git", "clone", cloneUrl, "."} 48 48 + // run git fetch 49 49 + { 50 50 + var fetchArgs []string 51 51 + 52 52 + // default clone depth is 1 53 53 + depth := 1 54 54 + if twf.Clone.Depth > 1 { 55 55 + depth = int(twf.Clone.Depth) 56 56 + } 57 57 + fetchArgs = append(fetchArgs, fmt.Sprintf("--depth=%d", depth)) 63 58 64 64 - // default clone depth is 1 65 65 - cloneDepth := 1 66 66 - if twf.Clone.Depth > 1 { 67 67 - cloneDepth = int(twf.Clone.Depth) 68 68 - } 69 69 - cloneCmd = append(cloneCmd, fmt.Sprintf("--depth=%d", cloneDepth)) 59 59 + // optionally recurse submodules 60 60 + if twf.Clone.Submodules { 61 61 + fetchArgs = append(fetchArgs, "--recurse-submodules=yes") 62 62 + } 70 63 71 71 - // select the clone branch 72 72 - cloneBranch := "" 73 73 - switch tr.Kind { 74 74 - case workflow.TriggerKindManual: 75 75 - // TODO: unimplemented 76 76 - case workflow.TriggerKindPush: 77 77 - ref := tr.Push.Ref 78 78 - refName := plumbing.ReferenceName(ref) 79 79 - cloneBranch = refName.Short() 80 80 - case workflow.TriggerKindPullRequest: 81 81 - cloneBranch = tr.PullRequest.SourceBranch 82 82 - } 64 64 + // set remote to fetch from 65 65 + fetchArgs = append(fetchArgs, "origin") 83 66 84 84 - if cloneBranch != "" { 85 85 - cloneCmd = append(cloneCmd, fmt.Sprintf("--branch=%s", cloneBranch)) 86 86 - } 67 67 + // set revision to checkout 68 68 + switch workflow.TriggerKind(tr.Kind) { 69 69 + case workflow.TriggerKindManual: 70 70 + // TODO: unimplemented 71 71 + case workflow.TriggerKindPush: 72 72 + fetchArgs = append(fetchArgs, tr.Push.NewSha) 73 73 + case workflow.TriggerKindPullRequest: 74 74 + fetchArgs = append(fetchArgs, tr.PullRequest.SourceSha) 75 75 + } 87 76 88 88 - if twf.Clone.Submodules { 89 89 - cloneCmd = append(cloneCmd, "--recursive") 77 77 + commands = append(commands, fmt.Sprintf("git fetch %s", strings.Join(fetchArgs, " "))) 90 78 } 91 79 92 92 - fmt.Println(strings.Join(cloneCmd, " ")) 80 80 + // run git checkout 81 81 + commands = append(commands, "git checkout FETCH_HEAD") 93 82 94 83 cloneStep := Step{ 95 95 - Command: strings.Join(cloneCmd, " "), 84 84 + Command: strings.Join(commands, "\n"), 96 85 Name: "Clone repository into workspace", 97 86 } 98 87 return cloneStep

+2 -2

workflow/compile.go

··· 98 98 Name: s.Name, 99 99 } 100 100 for k, v := range s.Environment { 101 101 - e := &tangled.Pipeline_Step_Environment_Elem{ 101 101 + e := &tangled.Pipeline_Pair{ 102 102 Key: k, 103 103 Value: v, 104 104 } ··· 107 107 cw.Steps = append(cw.Steps, &step) 108 108 } 109 109 for k, v := range w.Environment { 110 110 - e := &tangled.Pipeline_Workflow_Environment_Elem{ 110 110 + e := &tangled.Pipeline_Pair{ 111 111 Key: k, 112 112 Value: v, 113 113 }

+1 -1

workflow/compile_test.go

··· 9 9 ) 10 10 11 11 var trigger = tangled.Pipeline_TriggerMetadata{ 12 12 - Kind: TriggerKindPush, 12 12 + Kind: string(TriggerKindPush), 13 13 Push: &tangled.Pipeline_PushTriggerData{ 14 14 Ref: "refs/heads/main", 15 15 OldSha: strings.Repeat("0", 40),

+15 -6

workflow/def.go

··· 4 4 "errors" 5 5 "fmt" 6 6 "slices" 7 7 + "strings" 7 8 8 9 "tangled.sh/tangled.sh/core/api/tangled" 9 10 ··· 51 52 } 52 53 53 54 StringList []string 55 55 + 56 56 + TriggerKind string 54 57 ) 55 58 56 59 const ( 57 57 - TriggerKindPush string = "push" 58 58 - TriggerKindPullRequest string = "pull_request" 59 59 - TriggerKindManual string = "manual" 60 60 + WorkflowDir = ".tangled/workflows" 61 61 + 62 62 + TriggerKindPush TriggerKind = "push" 63 63 + TriggerKindPullRequest TriggerKind = "pull_request" 64 64 + TriggerKindManual TriggerKind = "manual" 60 65 ) 66 66 + 67 67 + func (t TriggerKind) String() string { 68 68 + return strings.ReplaceAll(string(t), "_", " ") 69 69 + } 61 70 62 71 func FromFile(name string, contents []byte) (Workflow, error) { 63 72 var wf Workflow ··· 167 176 } 168 177 169 178 // conversion utilities to atproto records 170 170 - func (d Dependencies) AsRecord() []tangled.Pipeline_Dependencies_Elem { 171 171 - var deps []tangled.Pipeline_Dependencies_Elem 179 179 + func (d Dependencies) AsRecord() []*tangled.Pipeline_Dependency { 180 180 + var deps []*tangled.Pipeline_Dependency 172 181 for registry, packages := range d { 173 173 - deps = append(deps, tangled.Pipeline_Dependencies_Elem{ 182 182 + deps = append(deps, &tangled.Pipeline_Dependency{ 174 183 Registry: registry, 175 184 Packages: packages, 176 185 })