commit f5b6793ac802106b84ec856cfd7885c5d2b7b721 · julien.rbrt.fr/tangled-core

+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
        
       		}

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
       +
       }