+256

api/tangled/cbor_gen.go

··· 602 602 603 603 return nil 604 604 } 605 605 + func (t *Repo) MarshalCBOR(w io.Writer) error { 606 606 + if t == nil { 607 607 + _, err := w.Write(cbg.CborNull) 608 608 + return err 609 609 + } 610 610 + 611 611 + cw := cbg.NewCborWriter(w) 612 612 + fieldCount := 5 613 613 + 614 614 + if t.AddedAt == nil { 615 615 + fieldCount-- 616 616 + } 617 617 + 618 618 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 619 619 + return err 620 620 + } 621 621 + 622 622 + // t.Knot (string) (string) 623 623 + if len("knot") > 1000000 { 624 624 + return xerrors.Errorf("Value in field \"knot\" was too long") 625 625 + } 626 626 + 627 627 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("knot"))); err != nil { 628 628 + return err 629 629 + } 630 630 + if _, err := cw.WriteString(string("knot")); err != nil { 631 631 + return err 632 632 + } 633 633 + 634 634 + if len(t.Knot) > 1000000 { 635 635 + return xerrors.Errorf("Value in field t.Knot was too long") 636 636 + } 637 637 + 638 638 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Knot))); err != nil { 639 639 + return err 640 640 + } 641 641 + if _, err := cw.WriteString(string(t.Knot)); err != nil { 642 642 + return err 643 643 + } 644 644 + 645 645 + // t.Name (string) (string) 646 646 + if len("name") > 1000000 { 647 647 + return xerrors.Errorf("Value in field \"name\" was too long") 648 648 + } 649 649 + 650 650 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 651 651 + return err 652 652 + } 653 653 + if _, err := cw.WriteString(string("name")); err != nil { 654 654 + return err 655 655 + } 656 656 + 657 657 + if len(t.Name) > 1000000 { 658 658 + return xerrors.Errorf("Value in field t.Name was too long") 659 659 + } 660 660 + 661 661 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 662 662 + return err 663 663 + } 664 664 + if _, err := cw.WriteString(string(t.Name)); err != nil { 665 665 + return err 666 666 + } 667 667 + 668 668 + // t.LexiconTypeID (string) (string) 669 669 + if len("$type") > 1000000 { 670 670 + return xerrors.Errorf("Value in field \"$type\" was too long") 671 671 + } 672 672 + 673 673 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 674 674 + return err 675 675 + } 676 676 + if _, err := cw.WriteString(string("$type")); err != nil { 677 677 + return err 678 678 + } 679 679 + 680 680 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("sh.tangled.repo"))); err != nil { 681 681 + return err 682 682 + } 683 683 + if _, err := cw.WriteString(string("sh.tangled.repo")); err != nil { 684 684 + return err 685 685 + } 686 686 + 687 687 + // t.Owner (string) (string) 688 688 + if len("owner") > 1000000 { 689 689 + return xerrors.Errorf("Value in field \"owner\" was too long") 690 690 + } 691 691 + 692 692 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("owner"))); err != nil { 693 693 + return err 694 694 + } 695 695 + if _, err := cw.WriteString(string("owner")); err != nil { 696 696 + return err 697 697 + } 698 698 + 699 699 + if len(t.Owner) > 1000000 { 700 700 + return xerrors.Errorf("Value in field t.Owner was too long") 701 701 + } 702 702 + 703 703 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Owner))); err != nil { 704 704 + return err 705 705 + } 706 706 + if _, err := cw.WriteString(string(t.Owner)); err != nil { 707 707 + return err 708 708 + } 709 709 + 710 710 + // t.AddedAt (string) (string) 711 711 + if t.AddedAt != nil { 712 712 + 713 713 + if len("addedAt") > 1000000 { 714 714 + return xerrors.Errorf("Value in field \"addedAt\" was too long") 715 715 + } 716 716 + 717 717 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("addedAt"))); err != nil { 718 718 + return err 719 719 + } 720 720 + if _, err := cw.WriteString(string("addedAt")); err != nil { 721 721 + return err 722 722 + } 723 723 + 724 724 + if t.AddedAt == nil { 725 725 + if _, err := cw.Write(cbg.CborNull); err != nil { 726 726 + return err 727 727 + } 728 728 + } else { 729 729 + if len(*t.AddedAt) > 1000000 { 730 730 + return xerrors.Errorf("Value in field t.AddedAt was too long") 731 731 + } 732 732 + 733 733 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AddedAt))); err != nil { 734 734 + return err 735 735 + } 736 736 + if _, err := cw.WriteString(string(*t.AddedAt)); err != nil { 737 737 + return err 738 738 + } 739 739 + } 740 740 + } 741 741 + return nil 742 742 + } 743 743 + 744 744 + func (t *Repo) UnmarshalCBOR(r io.Reader) (err error) { 745 745 + *t = Repo{} 746 746 + 747 747 + cr := cbg.NewCborReader(r) 748 748 + 749 749 + maj, extra, err := cr.ReadHeader() 750 750 + if err != nil { 751 751 + return err 752 752 + } 753 753 + defer func() { 754 754 + if err == io.EOF { 755 755 + err = io.ErrUnexpectedEOF 756 756 + } 757 757 + }() 758 758 + 759 759 + if maj != cbg.MajMap { 760 760 + return fmt.Errorf("cbor input should be of type map") 761 761 + } 762 762 + 763 763 + if extra > cbg.MaxLength { 764 764 + return fmt.Errorf("Repo: map struct too large (%d)", extra) 765 765 + } 766 766 + 767 767 + n := extra 768 768 + 769 769 + nameBuf := make([]byte, 7) 770 770 + for i := uint64(0); i < n; i++ { 771 771 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 772 772 + if err != nil { 773 773 + return err 774 774 + } 775 775 + 776 776 + if !ok { 777 777 + // Field doesn't exist on this type, so ignore it 778 778 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 779 779 + return err 780 780 + } 781 781 + continue 782 782 + } 783 783 + 784 784 + switch string(nameBuf[:nameLen]) { 785 785 + // t.Knot (string) (string) 786 786 + case "knot": 787 787 + 788 788 + { 789 789 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 790 790 + if err != nil { 791 791 + return err 792 792 + } 793 793 + 794 794 + t.Knot = string(sval) 795 795 + } 796 796 + // t.Name (string) (string) 797 797 + case "name": 798 798 + 799 799 + { 800 800 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 801 801 + if err != nil { 802 802 + return err 803 803 + } 804 804 + 805 805 + t.Name = string(sval) 806 806 + } 807 807 + // t.LexiconTypeID (string) (string) 808 808 + case "$type": 809 809 + 810 810 + { 811 811 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 812 812 + if err != nil { 813 813 + return err 814 814 + } 815 815 + 816 816 + t.LexiconTypeID = string(sval) 817 817 + } 818 818 + // t.Owner (string) (string) 819 819 + case "owner": 820 820 + 821 821 + { 822 822 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 823 823 + if err != nil { 824 824 + return err 825 825 + } 826 826 + 827 827 + t.Owner = string(sval) 828 828 + } 829 829 + // t.AddedAt (string) (string) 830 830 + case "addedAt": 831 831 + 832 832 + { 833 833 + b, err := cr.ReadByte() 834 834 + if err != nil { 835 835 + return err 836 836 + } 837 837 + if b != cbg.CborNull[0] { 838 838 + if err := cr.UnreadByte(); err != nil { 839 839 + return err 840 840 + } 841 841 + 842 842 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 843 843 + if err != nil { 844 844 + return err 845 845 + } 846 846 + 847 847 + t.AddedAt = (*string)(&sval) 848 848 + } 849 849 + } 850 850 + 851 851 + default: 852 852 + // Field doesn't exist on this type, so ignore it 853 853 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 854 854 + return err 855 855 + } 856 856 + } 857 857 + } 858 858 + 859 859 + return nil 860 860 + }

+27

api/tangled/tangledrepo.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.repo 6 6 + 7 7 + import ( 8 8 + "github.com/bluesky-social/indigo/lex/util" 9 9 + ) 10 10 + 11 11 + const ( 12 12 + RepoNSID = "sh.tangled.repo" 13 13 + ) 14 14 + 15 15 + func init() { 16 16 + util.RegisterType("sh.tangled.repo", &Repo{}) 17 17 + } // 18 18 + // RECORDTYPE: Repo 19 19 + type Repo struct { 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.repo" cborgen:"$type,const=sh.tangled.repo"` 21 21 + AddedAt *string `json:"addedAt,omitempty" cborgen:"addedAt,omitempty"` 22 22 + // knot: knot where the repo was created 23 23 + Knot string `json:"knot" cborgen:"knot"` 24 24 + // name: name of the repo 25 25 + Name string `json:"name" cborgen:"name"` 26 26 + Owner string `json:"owner" cborgen:"owner"` 27 27 + }

+2 -1

appview/db/db.go

··· 46 46 did text not null, 47 47 name text not null, 48 48 knot text not null, 49 49 + rkey text not null, 49 50 created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 50 50 - unique(did, name, knot) 51 51 + unique(did, name, knot, rkey) 51 52 ); 52 53 create table if not exists collaborators ( 53 54 id integer primary key autoincrement,

+4 -3

appview/db/repos.go

··· 10 10 Name string 11 11 Knot string 12 12 Created *time.Time 13 13 + Rkey string 13 14 } 14 15 15 16 func (d *DB) GetAllReposByDid(did string) ([]Repo, error) { ··· 52 53 } 53 54 54 55 func (d *DB) AddRepo(repo *Repo) error { 55 55 - _, err := d.db.Exec(`insert into repos (did, name, knot) values (?, ?, ?)`, repo.Did, repo.Name, repo.Knot) 56 56 + _, err := d.db.Exec(`insert into repos (did, name, knot, rkey) values (?, ?, ?, ?)`, repo.Did, repo.Name, repo.Knot, repo.Rkey) 56 57 return err 57 58 } 58 59 59 59 - func (d *DB) RemoveRepo(did, name, knot string) error { 60 60 - _, err := d.db.Exec(`delete from repos where did = ? and name = ? and knot = ?`, did, name, knot) 60 60 + func (d *DB) RemoveRepo(did, name, rkey string) error { 61 61 + _, err := d.db.Exec(`delete from repos where did = ? and name = ? and rkey = ?`, did, name, rkey) 61 62 return err 62 63 } 63 64

+26 -1

appview/state/state.go

··· 535 535 // continue 536 536 } 537 537 538 538 - // add to local db 538 538 + rkey := s.TID() 539 539 repo := &db.Repo{ 540 540 Did: user.Did, 541 541 Name: repoName, 542 542 Knot: domain, 543 543 + Rkey: rkey, 543 544 } 545 545 + 546 546 + xrpcClient, _ := s.auth.AuthorizedClient(r) 547 547 + 548 548 + addedAt := time.Now().Format(time.RFC3339) 549 549 + atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{ 550 550 + Collection: tangled.RepoNSID, 551 551 + Repo: user.Did, 552 552 + Rkey: rkey, 553 553 + Record: &lexutil.LexiconTypeDecoder{ 554 554 + Val: &tangled.Repo{ 555 555 + Knot: repo.Knot, 556 556 + Name: repoName, 557 557 + AddedAt: &addedAt, 558 558 + Owner: user.Did, 559 559 + }}, 560 560 + }) 561 561 + if err != nil { 562 562 + log.Printf("failed to create record: %s", err) 563 563 + s.pages.Notice(w, "repo", "Failed to announce repository creation.") 564 564 + return 565 565 + } 566 566 + log.Println("created repo record: ", atresp.Uri) 567 567 + 544 568 err = s.db.AddRepo(repo) 545 569 if err != nil { 570 570 + log.Println(err) 546 571 s.pages.Notice(w, "repo", "Failed to save repository information.") 547 572 return 548 573 }

+1

cmd/gen.go

··· 17 17 shtangled.PublicKey{}, 18 18 shtangled.KnotMember{}, 19 19 shtangled.GraphFollow{}, 20 20 + shtangled.Repo{}, 20 21 ); err != nil { 21 22 panic(err) 22 23 }

+38

lexicons/repo.json

··· 1 1 + { 2 2 + "lexicon": 1, 3 3 + "id": "sh.tangled.repo", 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 + "name", 14 14 + "knot", 15 15 + "owner" 16 16 + ], 17 17 + "properties": { 18 18 + "name": { 19 19 + "type": "string", 20 20 + "description": "name of the repo" 21 21 + }, 22 22 + "owner": { 23 23 + "type": "string", 24 24 + "format": "did" 25 25 + }, 26 26 + "knot": { 27 27 + "type": "string", 28 28 + "description": "knot where the repo was created" 29 29 + }, 30 30 + "addedAt": { 31 31 + "type": "string", 32 32 + "format": "datetime" 33 33 + } 34 34 + } 35 35 + } 36 36 + } 37 37 + } 38 38 + }