lexicons,api: remove ids from issue/comment lexicons #522

···

       
5512
       
5512
       
 
       
	}

     

       
5513
       
5513
       
 
       


     

       
5514
       
5514
       
 
       
	cw := cbg.NewCborWriter(w)

     

       
5515
       
5515
       
-
       
	fieldCount := 7

     

       
5515
       
5515
       
+
       
	fieldCount := 6

     

       
5516
       
5516
       
 
       


     

       
5517
       
5517
       
 
       
	if t.Body == nil {

     

       
5518
       
5518
       
 
       
		fieldCount--

     
···

       
5642
       
5642
       
 
       
		return err

     

       
5643
       
5643
       
 
       
	}

     

       
5644
       
5644
       
 
       


     

       
5645
       
5645
       
-
       
	// t.IssueId (int64) (int64)

     

       
5646
       
5646
       
-
       
	if len("issueId") > 1000000 {

     

       
5647
       
5647
       
-
       
		return xerrors.Errorf("Value in field \"issueId\" was too long")

     

       
5648
       
5648
       
-
       
	}

     

       
5649
       
5649
       
-
       


     

       
5650
       
5650
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("issueId"))); err != nil {

     

       
5651
       
5651
       
-
       
		return err

     

       
5652
       
5652
       
-
       
	}

     

       
5653
       
5653
       
-
       
	if _, err := cw.WriteString(string("issueId")); err != nil {

     

       
5654
       
5654
       
-
       
		return err

     

       
5655
       
5655
       
-
       
	}

     

       
5656
       
5656
       
-
       


     

       
5657
       
5657
       
-
       
	if t.IssueId >= 0 {

     

       
5658
       
5658
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.IssueId)); err != nil {

     

       
5659
       
5659
       
-
       
			return err

     

       
5660
       
5660
       
-
       
		}

     

       
5661
       
5661
       
-
       
	} else {

     

       
5662
       
5662
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.IssueId-1)); err != nil {

     

       
5663
       
5663
       
-
       
			return err

     

       
5664
       
5664
       
-
       
		}

     

       
5665
       
5665
       
-
       
	}

     

       
5666
       
5666
       
-
       


     

       
5667
       
5645
       
 
       
	// t.CreatedAt (string) (string)

     

       
5668
       
5646
       
 
       
	if len("createdAt") > 1000000 {

     

       
5669
       
5647
       
 
       
		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

       
5795
       
5773
       
 
       


     

       
5796
       
5774
       
 
       
				t.Title = string(sval)

     

       
5797
       
5775
       
 
       
			}

     

       
5798
       
5798
       
-
       
			// t.IssueId (int64) (int64)

     

       
5799
       
5799
       
-
       
		case "issueId":

     

       
5800
       
5800
       
-
       
			{

     

       
5801
       
5801
       
-
       
				maj, extra, err := cr.ReadHeader()

     

       
5802
       
5802
       
-
       
				if err != nil {

     

       
5803
       
5803
       
-
       
					return err

     

       
5804
       
5804
       
-
       
				}

     

       
5805
       
5805
       
-
       
				var extraI int64

     

       
5806
       
5806
       
-
       
				switch maj {

     

       
5807
       
5807
       
-
       
				case cbg.MajUnsignedInt:

     

       
5808
       
5808
       
-
       
					extraI = int64(extra)

     

       
5809
       
5809
       
-
       
					if extraI < 0 {

     

       
5810
       
5810
       
-
       
						return fmt.Errorf("int64 positive overflow")

     

       
5811
       
5811
       
-
       
					}

     

       
5812
       
5812
       
-
       
				case cbg.MajNegativeInt:

     

       
5813
       
5813
       
-
       
					extraI = int64(extra)

     

       
5814
       
5814
       
-
       
					if extraI < 0 {

     

       
5815
       
5815
       
-
       
						return fmt.Errorf("int64 negative overflow")

     

       
5816
       
5816
       
-
       
					}

     

       
5817
       
5817
       
-
       
					extraI = -1 - extraI

     

       
5818
       
5818
       
-
       
				default:

     

       
5819
       
5819
       
-
       
					return fmt.Errorf("wrong type for int64 field: %d", maj)

     

       
5820
       
5820
       
-
       
				}

     

       
5821
       
5821
       
-
       


     

       
5822
       
5822
       
-
       
				t.IssueId = int64(extraI)

     

       
5823
       
5823
       
-
       
			}

     

       
5824
       
5776
       
 
       
			// t.CreatedAt (string) (string)

     

       
5825
       
5777
       
 
       
		case "createdAt":

     

       
5826
       
5778
       
 
       


     
···

       
5850
       
5802
       
 
       
	}

     

       
5851
       
5803
       
 
       


     

       
5852
       
5804
       
 
       
	cw := cbg.NewCborWriter(w)

     

       
5853
       
5853
       
-
       
	fieldCount := 7

     

       
5854
       
5854
       
-
       


     

       
5855
       
5855
       
-
       
	if t.CommentId == nil {

     

       
5856
       
5856
       
-
       
		fieldCount--

     

       
5857
       
5857
       
-
       
	}

     

       
5805
       
5805
       
+
       
	fieldCount := 6

     

       
5858
       
5806
       
 
       


     

       
5859
       
5807
       
 
       
	if t.Owner == nil {

     

       
5860
       
5808
       
 
       
		fieldCount--

     
···

       
5997
       
5945
       
 
       
		}

     

       
5998
       
5946
       
 
       
	}

     

       
5999
       
5947
       
 
       


     

       
6000
       
6000
       
-
       
	// t.CommentId (int64) (int64)

     

       
6001
       
6001
       
-
       
	if t.CommentId != nil {

     

       
6002
       
6002
       
-
       


     

       
6003
       
6003
       
-
       
		if len("commentId") > 1000000 {

     

       
6004
       
6004
       
-
       
			return xerrors.Errorf("Value in field \"commentId\" was too long")

     

       
6005
       
6005
       
-
       
		}

     

       
6006
       
6006
       
-
       


     

       
6007
       
6007
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("commentId"))); err != nil {

     

       
6008
       
6008
       
-
       
			return err

     

       
6009
       
6009
       
-
       
		}

     

       
6010
       
6010
       
-
       
		if _, err := cw.WriteString(string("commentId")); err != nil {

     

       
6011
       
6011
       
-
       
			return err

     

       
6012
       
6012
       
-
       
		}

     

       
6013
       
6013
       
-
       


     

       
6014
       
6014
       
-
       
		if t.CommentId == nil {

     

       
6015
       
6015
       
-
       
			if _, err := cw.Write(cbg.CborNull); err != nil {

     

       
6016
       
6016
       
-
       
				return err

     

       
6017
       
6017
       
-
       
			}

     

       
6018
       
6018
       
-
       
		} else {

     

       
6019
       
6019
       
-
       
			if *t.CommentId >= 0 {

     

       
6020
       
6020
       
-
       
				if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(*t.CommentId)); err != nil {

     

       
6021
       
6021
       
-
       
					return err

     

       
6022
       
6022
       
-
       
				}

     

       
6023
       
6023
       
-
       
			} else {

     

       
6024
       
6024
       
-
       
				if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-*t.CommentId-1)); err != nil {

     

       
6025
       
6025
       
-
       
					return err

     

       
6026
       
6026
       
-
       
				}

     

       
6027
       
6027
       
-
       
			}

     

       
6028
       
6028
       
-
       
		}

     

       
6029
       
6029
       
-
       


     

       
6030
       
6030
       
-
       
	}

     

       
6031
       
6031
       
-
       


     

       
6032
       
5948
       
 
       
	// t.CreatedAt (string) (string)

     

       
6033
       
5949
       
 
       
	if len("createdAt") > 1000000 {

     

       
6034
       
5950
       
 
       
		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

       
6170
       
6086
       
 
       
					t.Owner = (*string)(&sval)

     

       
6171
       
6087
       
 
       
				}

     

       
6172
       
6088
       
 
       
			}

     

       
6173
       
6173
       
-
       
			// t.CommentId (int64) (int64)

     

       
6174
       
6174
       
-
       
		case "commentId":

     

       
6175
       
6175
       
-
       
			{

     

       
6176
       
6176
       
-
       


     

       
6177
       
6177
       
-
       
				b, err := cr.ReadByte()

     

       
6178
       
6178
       
-
       
				if err != nil {

     

       
6179
       
6179
       
-
       
					return err

     

       
6180
       
6180
       
-
       
				}

     

       
6181
       
6181
       
-
       
				if b != cbg.CborNull[0] {

     

       
6182
       
6182
       
-
       
					if err := cr.UnreadByte(); err != nil {

     

       
6183
       
6183
       
-
       
						return err

     

       
6184
       
6184
       
-
       
					}

     

       
6185
       
6185
       
-
       
					maj, extra, err := cr.ReadHeader()

     

       
6186
       
6186
       
-
       
					if err != nil {

     

       
6187
       
6187
       
-
       
						return err

     

       
6188
       
6188
       
-
       
					}

     

       
6189
       
6189
       
-
       
					var extraI int64

     

       
6190
       
6190
       
-
       
					switch maj {

     

       
6191
       
6191
       
-
       
					case cbg.MajUnsignedInt:

     

       
6192
       
6192
       
-
       
						extraI = int64(extra)

     

       
6193
       
6193
       
-
       
						if extraI < 0 {

     

       
6194
       
6194
       
-
       
							return fmt.Errorf("int64 positive overflow")

     

       
6195
       
6195
       
-
       
						}

     

       
6196
       
6196
       
-
       
					case cbg.MajNegativeInt:

     

       
6197
       
6197
       
-
       
						extraI = int64(extra)

     

       
6198
       
6198
       
-
       
						if extraI < 0 {

     

       
6199
       
6199
       
-
       
							return fmt.Errorf("int64 negative overflow")

     

       
6200
       
6200
       
-
       
						}

     

       
6201
       
6201
       
-
       
						extraI = -1 - extraI

     

       
6202
       
6202
       
-
       
					default:

     

       
6203
       
6203
       
-
       
						return fmt.Errorf("wrong type for int64 field: %d", maj)

     

       
6204
       
6204
       
-
       
					}

     

       
6205
       
6205
       
-
       


     

       
6206
       
6206
       
-
       
					t.CommentId = (*int64)(&extraI)

     

       
6207
       
6207
       
-
       
				}

     

       
6208
       
6208
       
-
       
			}

     

       
6209
       
6089
       
 
       
			// t.CreatedAt (string) (string)

     

       
6210
       
6090
       
 
       
		case "createdAt":

     

       
6211
       
6091
       
 
       


     

···

       
19
       
19
       
 
       
type RepoIssueComment struct {

     

       
20
       
20
       
 
       
	LexiconTypeID string  `json:"$type,const=sh.tangled.repo.issue.comment" cborgen:"$type,const=sh.tangled.repo.issue.comment"`

     

       
21
       
21
       
 
       
	Body          string  `json:"body" cborgen:"body"`

     

       
22
       
22
       
-
       
	CommentId     *int64  `json:"commentId,omitempty" cborgen:"commentId,omitempty"`

     

       
23
       
22
       
 
       
	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       
24
       
23
       
 
       
	Issue         string  `json:"issue" cborgen:"issue"`

     

       
25
       
24
       
 
       
	Owner         *string `json:"owner,omitempty" cborgen:"owner,omitempty"`

     

···

       
20
       
20
       
 
       
	LexiconTypeID string  `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"`

     

       
21
       
21
       
 
       
	Body          *string `json:"body,omitempty" cborgen:"body,omitempty"`

     

       
22
       
22
       
 
       
	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       
23
       
23
       
-
       
	IssueId       int64   `json:"issueId" cborgen:"issueId"`

     

       
24
       
23
       
 
       
	Owner         string  `json:"owner" cborgen:"owner"`

     

       
25
       
24
       
 
       
	Repo          string  `json:"repo" cborgen:"repo"`

     

       
26
       
25
       
 
       
	Title         string  `json:"title" cborgen:"title"`

     

···

       
278
       
278
       
 
       
		}

     

       
279
       
279
       
 
       


     

       
280
       
280
       
 
       
		createdAt := time.Now().Format(time.RFC3339)

     

       
281
       
281
       
-
       
		commentIdInt64 := int64(commentId)

     

       
282
       
281
       
 
       
		ownerDid := user.Did

     

       
283
       
282
       
 
       
		issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt)

     

       
284
       
283
       
 
       
		if err != nil {

     
···

       
302
       
301
       
 
       
				Val: &tangled.RepoIssueComment{

     

       
303
       
302
       
 
       
					Repo:      &atUri,

     

       
304
       
303
       
 
       
					Issue:     issueAt,

     

       
305
       
305
       
-
       
					CommentId: &commentIdInt64,

     

       
306
       
304
       
 
       
					Owner:     &ownerDid,

     

       
307
       
305
       
 
       
					Body:      body,

     

       
308
       
306
       
 
       
					CreatedAt: createdAt,

     
···

       
451
       
449
       
 
       
			repoAt := record["repo"].(string)

     

       
452
       
450
       
 
       
			issueAt := record["issue"].(string)

     

       
453
       
451
       
 
       
			createdAt := record["createdAt"].(string)

     

       
454
       
454
       
-
       
			commentIdInt64 := int64(commentIdInt)

     

       
455
       
452
       
 
       


     

       
456
       
453
       
 
       
			_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{

     

       
457
       
454
       
 
       
				Collection: tangled.RepoIssueCommentNSID,

     
···

       
462
       
459
       
 
       
					Val: &tangled.RepoIssueComment{

     

       
463
       
460
       
 
       
						Repo:      &repoAt,

     

       
464
       
461
       
 
       
						Issue:     issueAt,

     

       
465
       
465
       
-
       
						CommentId: &commentIdInt64,

     

       
466
       
462
       
 
       
						Owner:     &comment.OwnerDid,

     

       
467
       
463
       
 
       
						Body:      newBody,

     

       
468
       
464
       
 
       
						CreatedAt: createdAt,

     
···

       
687
       
683
       
 
       
			Rkey:       issue.Rkey,

     

       
688
       
684
       
 
       
			Record: &lexutil.LexiconTypeDecoder{

     

       
689
       
685
       
 
       
				Val: &tangled.RepoIssue{

     

       
690
       
690
       
-
       
					Repo:    atUri,

     

       
691
       
691
       
-
       
					Title:   title,

     

       
692
       
692
       
-
       
					Body:    &body,

     

       
693
       
693
       
-
       
					Owner:   user.Did,

     

       
694
       
694
       
-
       
					IssueId: int64(issue.IssueId),

     

       
686
       
686
       
+
       
					Repo:  atUri,

     

       
687
       
687
       
+
       
					Title: title,

     

       
688
       
688
       
+
       
					Body:  &body,

     

       
689
       
689
       
+
       
					Owner: user.Did,

     

       
695
       
690
       
 
       
				},

     

       
696
       
691
       
 
       
			},

     

       
697
       
692
       
 
       
		})

     

···

       
9
       
9
       
 
       
      "key": "tid",

     

       
10
       
10
       
 
       
      "record": {

     

       
11
       
11
       
 
       
        "type": "object",

     

       
12
       
12
       
-
       
        "required": [

     

       
13
       
13
       
-
       
          "issue",

     

       
14
       
14
       
-
       
          "body",

     

       
15
       
15
       
-
       
          "createdAt"

     

       
16
       
16
       
-
       
        ],

     

       
12
       
12
       
+
       
        "required": ["issue", "body", "createdAt"],

     

       
17
       
13
       
 
       
        "properties": {

     

       
18
       
14
       
 
       
          "issue": {

     

       
19
       
15
       
 
       
            "type": "string",

     
···

       
23
       
19
       
 
       
            "type": "string",

     

       
24
       
20
       
 
       
            "format": "at-uri"

     

       
25
       
21
       
 
       
          },

     

       
26
       
26
       
-
       
          "commentId": {

     

       
27
       
27
       
-
       
            "type": "integer"

     

       
28
       
28
       
-
       
          },

     

       
29
       
22
       
 
       
          "owner": {

     

       
30
       
23
       
 
       
            "type": "string",

     

       
31
       
24
       
 
       
            "format": "did"

     

···

       
9
       
9
       
 
       
      "key": "tid",

     

       
10
       
10
       
 
       
      "record": {

     

       
11
       
11
       
 
       
        "type": "object",

     

       
12
       
12
       
-
       
        "required": [

     

       
13
       
13
       
-
       
          "repo",

     

       
14
       
14
       
-
       
          "issueId",

     

       
15
       
15
       
-
       
          "owner",

     

       
16
       
16
       
-
       
          "title",

     

       
17
       
17
       
-
       
          "createdAt"

     

       
18
       
18
       
-
       
        ],

     

       
12
       
12
       
+
       
        "required": ["repo", "owner", "title", "createdAt"],

     

       
19
       
13
       
 
       
        "properties": {

     

       
20
       
14
       
 
       
          "repo": {

     

       
21
       
15
       
 
       
            "type": "string",

     

       
22
       
16
       
 
       
            "format": "at-uri"

     

       
23
       
17
       
 
       
          },

     

       
24
       
24
       
-
       
          "issueId": {

     

       
25
       
25
       
-
       
            "type": "integer"

     

       
26
       
26
       
-
       
          },

     

       
27
       
18
       
 
       
          "owner": {

     

       
28
       
19
       
 
       
            "type": "string",

     

       
29
       
20
       
 
       
            "format": "did"