commit 5d021119d9469fd6f3012fcf1afe472bb90e19b0 · veryroundbird.house/core

+225 -458

api/tangled/cbor_gen.go

···

       353
        
       	}

     

       354
        
       

     

       355
        
       	cw := cbg.NewCborWriter(w)

     

       356
       -
       	fieldCount := 4

     

       357
        
       

     

       358
       -
       	if t.AddedAt == nil {

     

       359
       -
       		fieldCount--

     

       360
       -
       	}

     

       361
       -
       

     

       362
       -
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       363
        
       		return err

     

       364
        
       	}

     

       365
        
       

     
···

       405
        
       		return err

     

       406
        
       	}

     

       407
        
       

     

       408
       -
       	// t.Member (string) (string)

     

       409
       -
       	if len("member") > 1000000 {

     

       410
       -
       		return xerrors.Errorf("Value in field \"member\" was too long")

     

       411
        
       	}

     

       412
        
       

     

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

     

       414
        
       		return err

     

       415
        
       	}

     

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

     

       417
        
       		return err

     

       418
        
       	}

     

       419
        
       

     

       420
       -
       	if len(t.Member) > 1000000 {

     

       421
       -
       		return xerrors.Errorf("Value in field t.Member was too long")

     

       422
        
       	}

     

       423
        
       

     

       424
       -
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Member))); err != nil {

     

       425
        
       		return err

     

       426
        
       	}

     

       427
       -
       	if _, err := cw.WriteString(string(t.Member)); err != nil {

     

       428
        
       		return err

     

       429
        
       	}

     

       430
        
       

     

       431
       -
       	// t.AddedAt (string) (string)

     

       432
       -
       	if t.AddedAt != nil {

     

       433
       -
       

     

       434
       -
       		if len("addedAt") > 1000000 {

     

       435
       -
       			return xerrors.Errorf("Value in field \"addedAt\" was too long")

     

       436
       -
       		}

     

       437
        
       

     

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

     

       439
       -
       			return err

     

       440
       -
       		}

     

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

     

       442
       -
       			return err

     

       443
       -
       		}

     

       444
        
       

     

       445
       -
       		if t.AddedAt == nil {

     

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

     

       447
       -
       				return err

     

       448
       -
       			}

     

       449
       -
       		} else {

     

       450
       -
       			if len(*t.AddedAt) > 1000000 {

     

       451
       -
       				return xerrors.Errorf("Value in field t.AddedAt was too long")

     

       452
       -
       			}

     

       453
        
       

     

       454
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AddedAt))); err != nil {

     

       455
       -
       				return err

     

       456
       -
       			}

     

       457
       -
       			if _, err := cw.WriteString(string(*t.AddedAt)); err != nil {

     

       458
       -
       				return err

     

       459
       -
       			}

     

       460
       -
       		}

     

       461
        
       	}

     

       462
        
       	return nil

     

       463
        
       }

     
···

       487
        
       

     

       488
        
       	n := extra

     

       489
        
       

     

       490
       -
       	nameBuf := make([]byte, 7)

     

       491
        
       	for i := uint64(0); i < n; i++ {

     

       492
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       493
        
       		if err != nil {

     
···

       525
        
       

     

       526
        
       				t.Domain = string(sval)

     

       527
        
       			}

     

       528
       -
       			// t.Member (string) (string)

     

       529
       -
       		case "member":

     

       530
        
       

     

       531
        
       			{

     

       532
        
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     
···

       534
        
       					return err

     

       535
        
       				}

     

       536
        
       

     

       537
       -
       				t.Member = string(sval)

     

       538
        
       			}

     

       539
       -
       			// t.AddedAt (string) (string)

     

       540
       -
       		case "addedAt":

     

       541
        
       

     

       542
        
       			{

     

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

     

       544
        
       				if err != nil {

     

       545
        
       					return err

     

       546
        
       				}

     

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

     

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

     

       549
       -
       						return err

     

       550
       -
       					}

     

       551
        
       

     

       552
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       553
       -
       					if err != nil {

     

       554
       -
       						return err

     

       555
       -
       					}

     

       556
       -
       

     

       557
       -
       					t.AddedAt = (*string)(&sval)

     

       558
       -
       				}

     

       559
        
       			}

     

       560
        
       

     

       561
        
       		default:

     
···

       645
        
       		return err

     

       646
        
       	}

     

       647
        
       

     

       648
       -
       	// t.Created (string) (string)

     

       649
       -
       	if len("created") > 1000000 {

     

       650
       -
       		return xerrors.Errorf("Value in field \"created\" was too long")

     

       651
        
       	}

     

       652
        
       

     

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

     

       654
        
       		return err

     

       655
        
       	}

     

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

     

       657
        
       		return err

     

       658
        
       	}

     

       659
        
       

     

       660
       -
       	if len(t.Created) > 1000000 {

     

       661
       -
       		return xerrors.Errorf("Value in field t.Created was too long")

     

       662
        
       	}

     

       663
        
       

     

       664
       -
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Created))); err != nil {

     

       665
        
       		return err

     

       666
        
       	}

     

       667
       -
       	if _, err := cw.WriteString(string(t.Created)); err != nil {

     

       668
        
       		return err

     

       669
        
       	}

     

       670
        
       	return nil

     
···

       695
        
       

     

       696
        
       	n := extra

     

       697
        
       

     

       698
       -
       	nameBuf := make([]byte, 7)

     

       699
        
       	for i := uint64(0); i < n; i++ {

     

       700
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       701
        
       		if err != nil {

     
···

       744
        
       

     

       745
        
       				t.LexiconTypeID = string(sval)

     

       746
        
       			}

     

       747
       -
       			// t.Created (string) (string)

     

       748
       -
       		case "created":

     

       749
        
       

     

       750
        
       			{

     

       751
        
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     
···

       753
        
       					return err

     

       754
        
       				}

     

       755
        
       

     

       756
       -
       				t.Created = string(sval)

     

       757
        
       			}

     

       758
        
       

     

       759
        
       		default:

     
···

       775
        
       	cw := cbg.NewCborWriter(w)

     

       776
        
       	fieldCount := 7

     

       777
        
       

     

       778
       -
       	if t.Body == nil {

     

       779
       -
       		fieldCount--

     

       780
       -
       	}

     

       781
       -
       

     

       782
        
       	if t.CommentId == nil {

     

       783
        
       		fieldCount--

     

       784
        
       	}

     

       785
        
       

     

       786
       -
       	if t.CreatedAt == nil {

     

       787
       -
       		fieldCount--

     

       788
       -
       	}

     

       789
       -
       

     

       790
        
       	if t.Owner == nil {

     

       791
        
       		fieldCount--

     

       792
        
       	}

     
···

       800
        
       	}

     

       801
        
       

     

       802
        
       	// t.Body (string) (string)

     

       803
       -
       	if t.Body != nil {

     

       804
       -
       

     

       805
       -
       		if len("body") > 1000000 {

     

       806
       -
       			return xerrors.Errorf("Value in field \"body\" was too long")

     

       807
       -
       		}

     

       808
        
       

     

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

     

       810
       -
       			return err

     

       811
       -
       		}

     

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

     

       813
       -
       			return err

     

       814
       -
       		}

     

       815
        
       

     

       816
       -
       		if t.Body == nil {

     

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

     

       818
       -
       				return err

     

       819
       -
       			}

     

       820
       -
       		} else {

     

       821
       -
       			if len(*t.Body) > 1000000 {

     

       822
       -
       				return xerrors.Errorf("Value in field t.Body was too long")

     

       823
       -
       			}

     

       824
        
       

     

       825
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {

     

       826
       -
       				return err

     

       827
       -
       			}

     

       828
       -
       			if _, err := cw.WriteString(string(*t.Body)); err != nil {

     

       829
       -
       				return err

     

       830
       -
       			}

     

       831
       -
       		}

     

       832
        
       	}

     

       833
        
       

     

       834
        
       	// t.Repo (string) (string)

     
···

       970
        
       	}

     

       971
        
       

     

       972
        
       	// t.CreatedAt (string) (string)

     

       973
       -
       	if t.CreatedAt != nil {

     

       0
        
       
     

       0
        
       
     

       974
        
       

     

       975
       -
       		if len("createdAt") > 1000000 {

     

       976
       -
       			return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       977
       -
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       978
        
       

     

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

     

       980
       -
       			return err

     

       981
       -
       		}

     

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

     

       983
       -
       			return err

     

       984
       -
       		}

     

       985
       -
       

     

       986
       -
       		if t.CreatedAt == nil {

     

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

     

       988
       -
       				return err

     

       989
       -
       			}

     

       990
       -
       		} else {

     

       991
       -
       			if len(*t.CreatedAt) > 1000000 {

     

       992
       -
       				return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       993
       -
       			}

     

       994
        
       

     

       995
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {

     

       996
       -
       				return err

     

       997
       -
       			}

     

       998
       -
       			if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {

     

       999
       -
       				return err

     

       1000
       -
       			}

     

       1001
       -
       		}

     

       1002
        
       	}

     

       1003
        
       	return nil

     

       1004
        
       }

     
···

       1048
        
       		case "body":

     

       1049
        
       

     

       1050
        
       			{

     

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

     

       1052
        
       				if err != nil {

     

       1053
        
       					return err

     

       1054
        
       				}

     

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

     

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

     

       1057
       -
       						return err

     

       1058
       -
       					}

     

       1059
        
       

     

       1060
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1061
       -
       					if err != nil {

     

       1062
       -
       						return err

     

       1063
       -
       					}

     

       1064
       -
       

     

       1065
       -
       					t.Body = (*string)(&sval)

     

       1066
       -
       				}

     

       1067
        
       			}

     

       1068
        
       			// t.Repo (string) (string)

     

       1069
        
       		case "repo":

     
···

       1169
        
       		case "createdAt":

     

       1170
        
       

     

       1171
        
       			{

     

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

     

       1173
        
       				if err != nil {

     

       1174
        
       					return err

     

       1175
        
       				}

     

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

     

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

     

       1178
       -
       						return err

     

       1179
       -
       					}

     

       1180
        
       

     

       1181
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1182
       -
       					if err != nil {

     

       1183
       -
       						return err

     

       1184
       -
       					}

     

       1185
       -
       

     

       1186
       -
       					t.CreatedAt = (*string)(&sval)

     

       1187
       -
       				}

     

       1188
        
       			}

     

       1189
        
       

     

       1190
        
       		default:

     
···

       1204
        
       	}

     

       1205
        
       

     

       1206
        
       	cw := cbg.NewCborWriter(w)

     

       1207
       -
       	fieldCount := 3

     

       1208
        
       

     

       1209
       -
       	if t.State == nil {

     

       1210
       -
       		fieldCount--

     

       1211
       -
       	}

     

       1212
       -
       

     

       1213
       -
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       1214
        
       		return err

     

       1215
        
       	}

     

       1216
        
       

     
···

       1257
        
       	}

     

       1258
        
       

     

       1259
        
       	// t.State (string) (string)

     

       1260
       -
       	if t.State != nil {

     

       0
        
       
     

       0
        
       
     

       1261
        
       

     

       1262
       -
       		if len("state") > 1000000 {

     

       1263
       -
       			return xerrors.Errorf("Value in field \"state\" was too long")

     

       1264
       -
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1265
        
       

     

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

     

       1267
       -
       			return err

     

       1268
       -
       		}

     

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

     

       1270
       -
       			return err

     

       1271
       -
       		}

     

       1272
        
       

     

       1273
       -
       		if t.State == nil {

     

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

     

       1275
       -
       				return err

     

       1276
       -
       			}

     

       1277
       -
       		} else {

     

       1278
       -
       			if len(*t.State) > 1000000 {

     

       1279
       -
       				return xerrors.Errorf("Value in field t.State was too long")

     

       1280
       -
       			}

     

       1281
       -
       

     

       1282
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.State))); err != nil {

     

       1283
       -
       				return err

     

       1284
       -
       			}

     

       1285
       -
       			if _, err := cw.WriteString(string(*t.State)); err != nil {

     

       1286
       -
       				return err

     

       1287
       -
       			}

     

       1288
       -
       		}

     

       1289
        
       	}

     

       1290
        
       	return nil

     

       1291
        
       }

     
···

       1357
        
       		case "state":

     

       1358
        
       

     

       1359
        
       			{

     

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

     

       1361
        
       				if err != nil {

     

       1362
        
       					return err

     

       1363
        
       				}

     

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

     

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

     

       1366
       -
       						return err

     

       1367
       -
       					}

     

       1368
        
       

     

       1369
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1370
       -
       					if err != nil {

     

       1371
       -
       						return err

     

       1372
       -
       					}

     

       1373
       -
       

     

       1374
       -
       					t.State = (*string)(&sval)

     

       1375
       -
       				}

     

       1376
        
       			}

     

       1377
        
       

     

       1378
        
       		default:

     
···

       1395
        
       	fieldCount := 7

     

       1396
        
       

     

       1397
        
       	if t.Body == nil {

     

       1398
       -
       		fieldCount--

     

       1399
       -
       	}

     

       1400
       -
       

     

       1401
       -
       	if t.CreatedAt == nil {

     

       1402
        
       		fieldCount--

     

       1403
        
       	}

     

       1404
        
       

     
···

       1549
        
       	}

     

       1550
        
       

     

       1551
        
       	// t.CreatedAt (string) (string)

     

       1552
       -
       	if t.CreatedAt != nil {

     

       0
        
       
     

       0
        
       
     

       1553
        
       

     

       1554
       -
       		if len("createdAt") > 1000000 {

     

       1555
       -
       			return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       1556
       -
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1557
        
       

     

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

     

       1559
       -
       			return err

     

       1560
       -
       		}

     

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

     

       1562
       -
       			return err

     

       1563
       -
       		}

     

       1564
        
       

     

       1565
       -
       		if t.CreatedAt == nil {

     

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

     

       1567
       -
       				return err

     

       1568
       -
       			}

     

       1569
       -
       		} else {

     

       1570
       -
       			if len(*t.CreatedAt) > 1000000 {

     

       1571
       -
       				return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       1572
       -
       			}

     

       1573
       -
       

     

       1574
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {

     

       1575
       -
       				return err

     

       1576
       -
       			}

     

       1577
       -
       			if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {

     

       1578
       -
       				return err

     

       1579
       -
       			}

     

       1580
       -
       		}

     

       1581
        
       	}

     

       1582
        
       	return nil

     

       1583
        
       }

     
···

       1718
        
       		case "createdAt":

     

       1719
        
       

     

       1720
        
       			{

     

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

     

       1722
        
       				if err != nil {

     

       1723
        
       					return err

     

       1724
        
       				}

     

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

     

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

     

       1727
       -
       						return err

     

       1728
       -
       					}

     

       1729
        
       

     

       1730
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1731
       -
       					if err != nil {

     

       1732
       -
       						return err

     

       1733
       -
       					}

     

       1734
       -
       

     

       1735
       -
       					t.CreatedAt = (*string)(&sval)

     

       1736
       -
       				}

     

       1737
        
       			}

     

       1738
        
       

     

       1739
        
       		default:

     
···

       1754
        
       

     

       1755
        
       	cw := cbg.NewCborWriter(w)

     

       1756
        
       	fieldCount := 7

     

       1757
       -
       

     

       1758
       -
       	if t.AddedAt == nil {

     

       1759
       -
       		fieldCount--

     

       1760
       -
       	}

     

       1761
        
       

     

       1762
        
       	if t.Description == nil {

     

       1763
        
       		fieldCount--

     
···

       1891
        
       		}

     

       1892
        
       	}

     

       1893
        
       

     

       1894
       -
       	// t.AddedAt (string) (string)

     

       1895
       -
       	if t.AddedAt != nil {

     

       1896
       -
       

     

       1897
       -
       		if len("addedAt") > 1000000 {

     

       1898
       -
       			return xerrors.Errorf("Value in field \"addedAt\" was too long")

     

       1899
       -
       		}

     

       1900
        
       

     

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

     

       1902
       -
       			return err

     

       1903
       -
       		}

     

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

     

       1905
       -
       			return err

     

       1906
       -
       		}

     

       1907
        
       

     

       1908
       -
       		if t.AddedAt == nil {

     

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

     

       1910
       -
       				return err

     

       1911
       -
       			}

     

       1912
       -
       		} else {

     

       1913
       -
       			if len(*t.AddedAt) > 1000000 {

     

       1914
       -
       				return xerrors.Errorf("Value in field t.AddedAt was too long")

     

       1915
       -
       			}

     

       1916
        
       

     

       1917
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AddedAt))); err != nil {

     

       1918
       -
       				return err

     

       1919
       -
       			}

     

       1920
       -
       			if _, err := cw.WriteString(string(*t.AddedAt)); err != nil {

     

       1921
       -
       				return err

     

       1922
       -
       			}

     

       1923
       -
       		}

     

       1924
        
       	}

     

       1925
        
       

     

       1926
        
       	// t.Description (string) (string)

     
···

       2063
        
       					t.Source = (*string)(&sval)

     

       2064
        
       				}

     

       2065
        
       			}

     

       2066
       -
       			// t.AddedAt (string) (string)

     

       2067
       -
       		case "addedAt":

     

       2068
        
       

     

       2069
        
       			{

     

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

     

       2071
        
       				if err != nil {

     

       2072
        
       					return err

     

       2073
        
       				}

     

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

     

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

     

       2076
       -
       						return err

     

       2077
       -
       					}

     

       2078
        
       

     

       2079
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       2080
       -
       					if err != nil {

     

       2081
       -
       						return err

     

       2082
       -
       					}

     

       2083
       -
       

     

       2084
       -
       					t.AddedAt = (*string)(&sval)

     

       2085
       -
       				}

     

       2086
        
       			}

     

       2087
        
       			// t.Description (string) (string)

     

       2088
        
       		case "description":

     
···

       2126
        
       	fieldCount := 9

     

       2127
        
       

     

       2128
        
       	if t.Body == nil {

     

       2129
       -
       		fieldCount--

     

       2130
       -
       	}

     

       2131
       -
       

     

       2132
       -
       	if t.CreatedAt == nil {

     

       2133
        
       		fieldCount--

     

       2134
        
       	}

     

       2135
        
       

     
···

       2280
        
       	}

     

       2281
        
       

     

       2282
        
       	// t.CreatedAt (string) (string)

     

       2283
       -
       	if t.CreatedAt != nil {

     

       0
        
       
     

       0
        
       
     

       2284
        
       

     

       2285
       -
       		if len("createdAt") > 1000000 {

     

       2286
       -
       			return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       2287
       -
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2288
        
       

     

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

     

       2290
       -
       			return err

     

       2291
       -
       		}

     

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

     

       2293
       -
       			return err

     

       2294
       -
       		}

     

       2295
        
       

     

       2296
       -
       		if t.CreatedAt == nil {

     

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

     

       2298
       -
       				return err

     

       2299
       -
       			}

     

       2300
       -
       		} else {

     

       2301
       -
       			if len(*t.CreatedAt) > 1000000 {

     

       2302
       -
       				return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       2303
       -
       			}

     

       2304
       -
       

     

       2305
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {

     

       2306
       -
       				return err

     

       2307
       -
       			}

     

       2308
       -
       			if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {

     

       2309
       -
       				return err

     

       2310
       -
       			}

     

       2311
       -
       		}

     

       2312
        
       	}

     

       2313
        
       

     

       2314
        
       	// t.TargetRepo (string) (string)

     
···

       2504
        
       		case "createdAt":

     

       2505
        
       

     

       2506
        
       			{

     

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

     

       2508
        
       				if err != nil {

     

       2509
        
       					return err

     

       2510
        
       				}

     

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

     

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

     

       2513
       -
       						return err

     

       2514
       -
       					}

     

       2515
        
       

     

       2516
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       2517
       -
       					if err != nil {

     

       2518
       -
       						return err

     

       2519
       -
       					}

     

       2520
       -
       

     

       2521
       -
       					t.CreatedAt = (*string)(&sval)

     

       2522
       -
       				}

     

       2523
        
       			}

     

       2524
        
       			// t.TargetRepo (string) (string)

     

       2525
        
       		case "targetRepo":

     
···

       2719
        
       	}

     

       2720
        
       

     

       2721
        
       	cw := cbg.NewCborWriter(w)

     

       2722
       -
       	fieldCount := 3

     

       2723
        
       

     

       2724
       -
       	if t.Status == nil {

     

       2725
       -
       		fieldCount--

     

       2726
       -
       	}

     

       2727
       -
       

     

       2728
       -
       	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       2729
        
       		return err

     

       2730
        
       	}

     

       2731
        
       

     
···

       2772
        
       	}

     

       2773
        
       

     

       2774
        
       	// t.Status (string) (string)

     

       2775
       -
       	if t.Status != nil {

     

       0
        
       
     

       0
        
       
     

       2776
        
       

     

       2777
       -
       		if len("status") > 1000000 {

     

       2778
       -
       			return xerrors.Errorf("Value in field \"status\" was too long")

     

       2779
       -
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2780
        
       

     

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

     

       2782
       -
       			return err

     

       2783
       -
       		}

     

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

     

       2785
       -
       			return err

     

       2786
       -
       		}

     

       2787
       -
       

     

       2788
       -
       		if t.Status == nil {

     

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

     

       2790
       -
       				return err

     

       2791
       -
       			}

     

       2792
       -
       		} else {

     

       2793
       -
       			if len(*t.Status) > 1000000 {

     

       2794
       -
       				return xerrors.Errorf("Value in field t.Status was too long")

     

       2795
       -
       			}

     

       2796
        
       

     

       2797
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Status))); err != nil {

     

       2798
       -
       				return err

     

       2799
       -
       			}

     

       2800
       -
       			if _, err := cw.WriteString(string(*t.Status)); err != nil {

     

       2801
       -
       				return err

     

       2802
       -
       			}

     

       2803
       -
       		}

     

       2804
        
       	}

     

       2805
        
       	return nil

     

       2806
        
       }

     
···

       2872
        
       		case "status":

     

       2873
        
       

     

       2874
        
       			{

     

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

     

       2876
        
       				if err != nil {

     

       2877
        
       					return err

     

       2878
        
       				}

     

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

     

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

     

       2881
       -
       						return err

     

       2882
       -
       					}

     

       2883
        
       

     

       2884
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       2885
       -
       					if err != nil {

     

       2886
       -
       						return err

     

       2887
       -
       					}

     

       2888
       -
       

     

       2889
       -
       					t.Status = (*string)(&sval)

     

       2890
       -
       				}

     

       2891
        
       			}

     

       2892
        
       

     

       2893
        
       		default:

     
···

       2909
        
       	cw := cbg.NewCborWriter(w)

     

       2910
        
       	fieldCount := 7

     

       2911
        
       

     

       2912
       -
       	if t.Body == nil {

     

       2913
       -
       		fieldCount--

     

       2914
       -
       	}

     

       2915
       -
       

     

       2916
        
       	if t.CommentId == nil {

     

       2917
        
       		fieldCount--

     

       2918
        
       	}

     

       2919
        
       

     

       2920
       -
       	if t.CreatedAt == nil {

     

       2921
       -
       		fieldCount--

     

       2922
       -
       	}

     

       2923
       -
       

     

       2924
        
       	if t.Owner == nil {

     

       2925
        
       		fieldCount--

     

       2926
        
       	}

     
···

       2934
        
       	}

     

       2935
        
       

     

       2936
        
       	// t.Body (string) (string)

     

       2937
       -
       	if t.Body != nil {

     

       2938
       -
       

     

       2939
       -
       		if len("body") > 1000000 {

     

       2940
       -
       			return xerrors.Errorf("Value in field \"body\" was too long")

     

       2941
       -
       		}

     

       2942
        
       

     

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

     

       2944
       -
       			return err

     

       2945
       -
       		}

     

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

     

       2947
       -
       			return err

     

       2948
       -
       		}

     

       2949
        
       

     

       2950
       -
       		if t.Body == nil {

     

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

     

       2952
       -
       				return err

     

       2953
       -
       			}

     

       2954
       -
       		} else {

     

       2955
       -
       			if len(*t.Body) > 1000000 {

     

       2956
       -
       				return xerrors.Errorf("Value in field t.Body was too long")

     

       2957
       -
       			}

     

       2958
        
       

     

       2959
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil {

     

       2960
       -
       				return err

     

       2961
       -
       			}

     

       2962
       -
       			if _, err := cw.WriteString(string(*t.Body)); err != nil {

     

       2963
       -
       				return err

     

       2964
       -
       			}

     

       2965
       -
       		}

     

       2966
        
       	}

     

       2967
        
       

     

       2968
        
       	// t.Pull (string) (string)

     
···

       3104
        
       	}

     

       3105
        
       

     

       3106
        
       	// t.CreatedAt (string) (string)

     

       3107
       -
       	if t.CreatedAt != nil {

     

       0
        
       
     

       0
        
       
     

       3108
        
       

     

       3109
       -
       		if len("createdAt") > 1000000 {

     

       3110
       -
       			return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       3111
       -
       		}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3112
        
       

     

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

     

       3114
       -
       			return err

     

       3115
       -
       		}

     

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

     

       3117
       -
       			return err

     

       3118
       -
       		}

     

       3119
        
       

     

       3120
       -
       		if t.CreatedAt == nil {

     

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

     

       3122
       -
       				return err

     

       3123
       -
       			}

     

       3124
       -
       		} else {

     

       3125
       -
       			if len(*t.CreatedAt) > 1000000 {

     

       3126
       -
       				return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       3127
       -
       			}

     

       3128
       -
       

     

       3129
       -
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil {

     

       3130
       -
       				return err

     

       3131
       -
       			}

     

       3132
       -
       			if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil {

     

       3133
       -
       				return err

     

       3134
       -
       			}

     

       3135
       -
       		}

     

       3136
        
       	}

     

       3137
        
       	return nil

     

       3138
        
       }

     
···

       3182
        
       		case "body":

     

       3183
        
       

     

       3184
        
       			{

     

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

     

       3186
        
       				if err != nil {

     

       3187
        
       					return err

     

       3188
        
       				}

     

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

     

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

     

       3191
       -
       						return err

     

       3192
       -
       					}

     

       3193
        
       

     

       3194
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       3195
       -
       					if err != nil {

     

       3196
       -
       						return err

     

       3197
       -
       					}

     

       3198
       -
       

     

       3199
       -
       					t.Body = (*string)(&sval)

     

       3200
       -
       				}

     

       3201
        
       			}

     

       3202
        
       			// t.Pull (string) (string)

     

       3203
        
       		case "pull":

     
···

       3303
        
       		case "createdAt":

     

       3304
        
       

     

       3305
        
       			{

     

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

     

       3307
        
       				if err != nil {

     

       3308
        
       					return err

     

       3309
        
       				}

     

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

     

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

     

       3312
       -
       						return err

     

       3313
       -
       					}

     

       3314
        
       

     

       3315
       -
       					sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       3316
       -
       					if err != nil {

     

       3317
       -
       						return err

     

       3318
       -
       					}

     

       3319
       -
       

     

       3320
       -
       					t.CreatedAt = (*string)(&sval)

     

       3321
       -
       				}

     

       3322
        
       			}

     

       3323
        
       

     

       3324
        
       		default:

···

       353
        
       	}

     

       354
        
       

     

       355
        
       	cw := cbg.NewCborWriter(w)

     

       0
        
       
     

       356
        
       

     

       357
       +
       	if _, err := cw.Write([]byte{164}); err != nil {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       358
        
       		return err

     

       359
        
       	}

     

       360
        
       

     
···

       400
        
       		return err

     

       401
        
       	}

     

       402
        
       

     

       403
       +
       	// t.Subject (string) (string)

     

       404
       +
       	if len("subject") > 1000000 {

     

       405
       +
       		return xerrors.Errorf("Value in field \"subject\" was too long")

     

       406
        
       	}

     

       407
        
       

     

       408
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil {

     

       409
        
       		return err

     

       410
        
       	}

     

       411
       +
       	if _, err := cw.WriteString(string("subject")); err != nil {

     

       412
        
       		return err

     

       413
        
       	}

     

       414
        
       

     

       415
       +
       	if len(t.Subject) > 1000000 {

     

       416
       +
       		return xerrors.Errorf("Value in field t.Subject was too long")

     

       417
        
       	}

     

       418
        
       

     

       419
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil {

     

       420
        
       		return err

     

       421
        
       	}

     

       422
       +
       	if _, err := cw.WriteString(string(t.Subject)); err != nil {

     

       423
        
       		return err

     

       424
        
       	}

     

       425
        
       

     

       426
       +
       	// t.CreatedAt (string) (string)

     

       427
       +
       	if len("createdAt") > 1000000 {

     

       428
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       429
       +
       	}

     

       0
        
       
     

       0
        
       
     

       430
        
       

     

       431
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       432
       +
       		return err

     

       433
       +
       	}

     

       434
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       435
       +
       		return err

     

       436
       +
       	}

     

       437
        
       

     

       438
       +
       	if len(t.CreatedAt) > 1000000 {

     

       439
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       440
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       441
        
       

     

       442
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       443
       +
       		return err

     

       444
       +
       	}

     

       445
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       446
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       447
        
       	}

     

       448
        
       	return nil

     

       449
        
       }

     
···

       473
        
       

     

       474
        
       	n := extra

     

       475
        
       

     

       476
       +
       	nameBuf := make([]byte, 9)

     

       477
        
       	for i := uint64(0); i < n; i++ {

     

       478
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       479
        
       		if err != nil {

     
···

       511
        
       

     

       512
        
       				t.Domain = string(sval)

     

       513
        
       			}

     

       514
       +
       			// t.Subject (string) (string)

     

       515
       +
       		case "subject":

     

       516
        
       

     

       517
        
       			{

     

       518
        
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     
···

       520
        
       					return err

     

       521
        
       				}

     

       522
        
       

     

       523
       +
       				t.Subject = string(sval)

     

       524
        
       			}

     

       525
       +
       			// t.CreatedAt (string) (string)

     

       526
       +
       		case "createdAt":

     

       527
        
       

     

       528
        
       			{

     

       529
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       530
        
       				if err != nil {

     

       531
        
       					return err

     

       532
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       533
        
       

     

       534
       +
       				t.CreatedAt = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       535
        
       			}

     

       536
        
       

     

       537
        
       		default:

     
···

       621
        
       		return err

     

       622
        
       	}

     

       623
        
       

     

       624
       +
       	// t.CreatedAt (string) (string)

     

       625
       +
       	if len("createdAt") > 1000000 {

     

       626
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       627
        
       	}

     

       628
        
       

     

       629
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       630
        
       		return err

     

       631
        
       	}

     

       632
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       633
        
       		return err

     

       634
        
       	}

     

       635
        
       

     

       636
       +
       	if len(t.CreatedAt) > 1000000 {

     

       637
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       638
        
       	}

     

       639
        
       

     

       640
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       641
        
       		return err

     

       642
        
       	}

     

       643
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       644
        
       		return err

     

       645
        
       	}

     

       646
        
       	return nil

     
···

       671
        
       

     

       672
        
       	n := extra

     

       673
        
       

     

       674
       +
       	nameBuf := make([]byte, 9)

     

       675
        
       	for i := uint64(0); i < n; i++ {

     

       676
        
       		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       677
        
       		if err != nil {

     
···

       720
        
       

     

       721
        
       				t.LexiconTypeID = string(sval)

     

       722
        
       			}

     

       723
       +
       			// t.CreatedAt (string) (string)

     

       724
       +
       		case "createdAt":

     

       725
        
       

     

       726
        
       			{

     

       727
        
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     
···

       729
        
       					return err

     

       730
        
       				}

     

       731
        
       

     

       732
       +
       				t.CreatedAt = string(sval)

     

       733
        
       			}

     

       734
        
       

     

       735
        
       		default:

     
···

       751
        
       	cw := cbg.NewCborWriter(w)

     

       752
        
       	fieldCount := 7

     

       753
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       754
        
       	if t.CommentId == nil {

     

       755
        
       		fieldCount--

     

       756
        
       	}

     

       757
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       758
        
       	if t.Owner == nil {

     

       759
        
       		fieldCount--

     

       760
        
       	}

     
···

       768
        
       	}

     

       769
        
       

     

       770
        
       	// t.Body (string) (string)

     

       771
       +
       	if len("body") > 1000000 {

     

       772
       +
       		return xerrors.Errorf("Value in field \"body\" was too long")

     

       773
       +
       	}

     

       0
        
       
     

       0
        
       
     

       774
        
       

     

       775
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {

     

       776
       +
       		return err

     

       777
       +
       	}

     

       778
       +
       	if _, err := cw.WriteString(string("body")); err != nil {

     

       779
       +
       		return err

     

       780
       +
       	}

     

       781
        
       

     

       782
       +
       	if len(t.Body) > 1000000 {

     

       783
       +
       		return xerrors.Errorf("Value in field t.Body was too long")

     

       784
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       785
        
       

     

       786
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {

     

       787
       +
       		return err

     

       788
       +
       	}

     

       789
       +
       	if _, err := cw.WriteString(string(t.Body)); err != nil {

     

       790
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       791
        
       	}

     

       792
        
       

     

       793
        
       	// t.Repo (string) (string)

     
···

       929
        
       	}

     

       930
        
       

     

       931
        
       	// t.CreatedAt (string) (string)

     

       932
       +
       	if len("createdAt") > 1000000 {

     

       933
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       934
       +
       	}

     

       935
        
       

     

       936
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       937
       +
       		return err

     

       938
       +
       	}

     

       939
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       940
       +
       		return err

     

       941
       +
       	}

     

       942
        
       

     

       943
       +
       	if len(t.CreatedAt) > 1000000 {

     

       944
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       945
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       946
        
       

     

       947
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       948
       +
       		return err

     

       949
       +
       	}

     

       950
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       951
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       952
        
       	}

     

       953
        
       	return nil

     

       954
        
       }

     
···

       998
        
       		case "body":

     

       999
        
       

     

       1000
        
       			{

     

       1001
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1002
        
       				if err != nil {

     

       1003
        
       					return err

     

       1004
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1005
        
       

     

       1006
       +
       				t.Body = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1007
        
       			}

     

       1008
        
       			// t.Repo (string) (string)

     

       1009
        
       		case "repo":

     
···

       1109
        
       		case "createdAt":

     

       1110
        
       

     

       1111
        
       			{

     

       1112
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1113
        
       				if err != nil {

     

       1114
        
       					return err

     

       1115
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1116
        
       

     

       1117
       +
       				t.CreatedAt = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1118
        
       			}

     

       1119
        
       

     

       1120
        
       		default:

     
···

       1134
        
       	}

     

       1135
        
       

     

       1136
        
       	cw := cbg.NewCborWriter(w)

     

       0
        
       
     

       1137
        
       

     

       1138
       +
       	if _, err := cw.Write([]byte{163}); err != nil {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1139
        
       		return err

     

       1140
        
       	}

     

       1141
        
       

     
···

       1182
        
       	}

     

       1183
        
       

     

       1184
        
       	// t.State (string) (string)

     

       1185
       +
       	if len("state") > 1000000 {

     

       1186
       +
       		return xerrors.Errorf("Value in field \"state\" was too long")

     

       1187
       +
       	}

     

       1188
        
       

     

       1189
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil {

     

       1190
       +
       		return err

     

       1191
       +
       	}

     

       1192
       +
       	if _, err := cw.WriteString(string("state")); err != nil {

     

       1193
       +
       		return err

     

       1194
       +
       	}

     

       1195
        
       

     

       1196
       +
       	if len(t.State) > 1000000 {

     

       1197
       +
       		return xerrors.Errorf("Value in field t.State was too long")

     

       1198
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1199
        
       

     

       1200
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil {

     

       1201
       +
       		return err

     

       1202
       +
       	}

     

       1203
       +
       	if _, err := cw.WriteString(string(t.State)); err != nil {

     

       1204
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1205
        
       	}

     

       1206
        
       	return nil

     

       1207
        
       }

     
···

       1273
        
       		case "state":

     

       1274
        
       

     

       1275
        
       			{

     

       1276
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1277
        
       				if err != nil {

     

       1278
        
       					return err

     

       1279
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1280
        
       

     

       1281
       +
       				t.State = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1282
        
       			}

     

       1283
        
       

     

       1284
        
       		default:

     
···

       1301
        
       	fieldCount := 7

     

       1302
        
       

     

       1303
        
       	if t.Body == nil {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1304
        
       		fieldCount--

     

       1305
        
       	}

     

       1306
        
       

     
···

       1451
        
       	}

     

       1452
        
       

     

       1453
        
       	// t.CreatedAt (string) (string)

     

       1454
       +
       	if len("createdAt") > 1000000 {

     

       1455
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       1456
       +
       	}

     

       1457
        
       

     

       1458
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       1459
       +
       		return err

     

       1460
       +
       	}

     

       1461
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       1462
       +
       		return err

     

       1463
       +
       	}

     

       1464
        
       

     

       1465
       +
       	if len(t.CreatedAt) > 1000000 {

     

       1466
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       1467
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1468
        
       

     

       1469
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       1470
       +
       		return err

     

       1471
       +
       	}

     

       1472
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       1473
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1474
        
       	}

     

       1475
        
       	return nil

     

       1476
        
       }

     
···

       1611
        
       		case "createdAt":

     

       1612
        
       

     

       1613
        
       			{

     

       1614
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1615
        
       				if err != nil {

     

       1616
        
       					return err

     

       1617
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1618
        
       

     

       1619
       +
       				t.CreatedAt = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1620
        
       			}

     

       1621
        
       

     

       1622
        
       		default:

     
···

       1637
        
       

     

       1638
        
       	cw := cbg.NewCborWriter(w)

     

       1639
        
       	fieldCount := 7

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1640
        
       

     

       1641
        
       	if t.Description == nil {

     

       1642
        
       		fieldCount--

     
···

       1770
        
       		}

     

       1771
        
       	}

     

       1772
        
       

     

       1773
       +
       	// t.CreatedAt (string) (string)

     

       1774
       +
       	if len("createdAt") > 1000000 {

     

       1775
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       1776
       +
       	}

     

       0
        
       
     

       0
        
       
     

       1777
        
       

     

       1778
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       1779
       +
       		return err

     

       1780
       +
       	}

     

       1781
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       1782
       +
       		return err

     

       1783
       +
       	}

     

       1784
        
       

     

       1785
       +
       	if len(t.CreatedAt) > 1000000 {

     

       1786
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       1787
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1788
        
       

     

       1789
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       1790
       +
       		return err

     

       1791
       +
       	}

     

       1792
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       1793
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       1794
        
       	}

     

       1795
        
       

     

       1796
        
       	// t.Description (string) (string)

     
···

       1933
        
       					t.Source = (*string)(&sval)

     

       1934
        
       				}

     

       1935
        
       			}

     

       1936
       +
       			// t.CreatedAt (string) (string)

     

       1937
       +
       		case "createdAt":

     

       1938
        
       

     

       1939
        
       			{

     

       1940
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       1941
        
       				if err != nil {

     

       1942
        
       					return err

     

       1943
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1944
        
       

     

       1945
       +
       				t.CreatedAt = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1946
        
       			}

     

       1947
        
       			// t.Description (string) (string)

     

       1948
        
       		case "description":

     
···

       1986
        
       	fieldCount := 9

     

       1987
        
       

     

       1988
        
       	if t.Body == nil {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       1989
        
       		fieldCount--

     

       1990
        
       	}

     

       1991
        
       

     
···

       2136
        
       	}

     

       2137
        
       

     

       2138
        
       	// t.CreatedAt (string) (string)

     

       2139
       +
       	if len("createdAt") > 1000000 {

     

       2140
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       2141
       +
       	}

     

       2142
        
       

     

       2143
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       2144
       +
       		return err

     

       2145
       +
       	}

     

       2146
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       2147
       +
       		return err

     

       2148
       +
       	}

     

       2149
        
       

     

       2150
       +
       	if len(t.CreatedAt) > 1000000 {

     

       2151
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       2152
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2153
        
       

     

       2154
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       2155
       +
       		return err

     

       2156
       +
       	}

     

       2157
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       2158
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2159
        
       	}

     

       2160
        
       

     

       2161
        
       	// t.TargetRepo (string) (string)

     
···

       2351
        
       		case "createdAt":

     

       2352
        
       

     

       2353
        
       			{

     

       2354
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       2355
        
       				if err != nil {

     

       2356
        
       					return err

     

       2357
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2358
        
       

     

       2359
       +
       				t.CreatedAt = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2360
        
       			}

     

       2361
        
       			// t.TargetRepo (string) (string)

     

       2362
        
       		case "targetRepo":

     
···

       2556
        
       	}

     

       2557
        
       

     

       2558
        
       	cw := cbg.NewCborWriter(w)

     

       0
        
       
     

       2559
        
       

     

       2560
       +
       	if _, err := cw.Write([]byte{163}); err != nil {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2561
        
       		return err

     

       2562
        
       	}

     

       2563
        
       

     
···

       2604
        
       	}

     

       2605
        
       

     

       2606
        
       	// t.Status (string) (string)

     

       2607
       +
       	if len("status") > 1000000 {

     

       2608
       +
       		return xerrors.Errorf("Value in field \"status\" was too long")

     

       2609
       +
       	}

     

       2610
        
       

     

       2611
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil {

     

       2612
       +
       		return err

     

       2613
       +
       	}

     

       2614
       +
       	if _, err := cw.WriteString(string("status")); err != nil {

     

       2615
       +
       		return err

     

       2616
       +
       	}

     

       2617
        
       

     

       2618
       +
       	if len(t.Status) > 1000000 {

     

       2619
       +
       		return xerrors.Errorf("Value in field t.Status was too long")

     

       2620
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2621
        
       

     

       2622
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil {

     

       2623
       +
       		return err

     

       2624
       +
       	}

     

       2625
       +
       	if _, err := cw.WriteString(string(t.Status)); err != nil {

     

       2626
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       2627
        
       	}

     

       2628
        
       	return nil

     

       2629
        
       }

     
···

       2695
        
       		case "status":

     

       2696
        
       

     

       2697
        
       			{

     

       2698
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       2699
        
       				if err != nil {

     

       2700
        
       					return err

     

       2701
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2702
        
       

     

       2703
       +
       				t.Status = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2704
        
       			}

     

       2705
        
       

     

       2706
        
       		default:

     
···

       2722
        
       	cw := cbg.NewCborWriter(w)

     

       2723
        
       	fieldCount := 7

     

       2724
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2725
        
       	if t.CommentId == nil {

     

       2726
        
       		fieldCount--

     

       2727
        
       	}

     

       2728
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2729
        
       	if t.Owner == nil {

     

       2730
        
       		fieldCount--

     

       2731
        
       	}

     
···

       2739
        
       	}

     

       2740
        
       

     

       2741
        
       	// t.Body (string) (string)

     

       2742
       +
       	if len("body") > 1000000 {

     

       2743
       +
       		return xerrors.Errorf("Value in field \"body\" was too long")

     

       2744
       +
       	}

     

       0
        
       
     

       0
        
       
     

       2745
        
       

     

       2746
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil {

     

       2747
       +
       		return err

     

       2748
       +
       	}

     

       2749
       +
       	if _, err := cw.WriteString(string("body")); err != nil {

     

       2750
       +
       		return err

     

       2751
       +
       	}

     

       2752
        
       

     

       2753
       +
       	if len(t.Body) > 1000000 {

     

       2754
       +
       		return xerrors.Errorf("Value in field t.Body was too long")

     

       2755
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2756
        
       

     

       2757
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil {

     

       2758
       +
       		return err

     

       2759
       +
       	}

     

       2760
       +
       	if _, err := cw.WriteString(string(t.Body)); err != nil {

     

       2761
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       2762
        
       	}

     

       2763
        
       

     

       2764
        
       	// t.Pull (string) (string)

     
···

       2900
        
       	}

     

       2901
        
       

     

       2902
        
       	// t.CreatedAt (string) (string)

     

       2903
       +
       	if len("createdAt") > 1000000 {

     

       2904
       +
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     

       2905
       +
       	}

     

       2906
        
       

     

       2907
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil {

     

       2908
       +
       		return err

     

       2909
       +
       	}

     

       2910
       +
       	if _, err := cw.WriteString(string("createdAt")); err != nil {

     

       2911
       +
       		return err

     

       2912
       +
       	}

     

       2913
        
       

     

       2914
       +
       	if len(t.CreatedAt) > 1000000 {

     

       2915
       +
       		return xerrors.Errorf("Value in field t.CreatedAt was too long")

     

       2916
       +
       	}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2917
        
       

     

       2918
       +
       	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil {

     

       2919
       +
       		return err

     

       2920
       +
       	}

     

       2921
       +
       	if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {

     

       2922
       +
       		return err

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2923
        
       	}

     

       2924
        
       	return nil

     

       2925
        
       }

     
···

       2969
        
       		case "body":

     

       2970
        
       

     

       2971
        
       			{

     

       2972
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       2973
        
       				if err != nil {

     

       2974
        
       					return err

     

       2975
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2976
        
       

     

       2977
       +
       				t.Body = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       2978
        
       			}

     

       2979
        
       			// t.Pull (string) (string)

     

       2980
        
       		case "pull":

     
···

       3080
        
       		case "createdAt":

     

       3081
        
       

     

       3082
        
       			{

     

       3083
       +
       				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       3084
        
       				if err != nil {

     

       3085
        
       					return err

     

       3086
        
       				}

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3087
        
       

     

       3088
       +
       				t.CreatedAt = string(sval)

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       3089
        
       			}

     

       3090
        
       

     

       3091
        
       		default:

+2 -2

api/tangled/issuecomment.go

···

       18
        
       // RECORDTYPE: RepoIssueComment

     

       19
        
       type RepoIssueComment struct {

     

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

     

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

     

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

     

       23
       -
       	CreatedAt     *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`

     

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

     

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

     

       26
        
       	Repo          *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

···

       18
        
       // RECORDTYPE: RepoIssueComment

     

       19
        
       type RepoIssueComment struct {

     

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

     

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

     

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

     

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

     

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

     

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

     

       26
        
       	Repo          *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

+1 -1

api/tangled/issuestate.go

···

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

     

       21
        
       	Issue         string `json:"issue" cborgen:"issue"`

     

       22
        
       	// state: state of the issue

     

       23
       -
       	State *string `json:"state,omitempty" cborgen:"state,omitempty"`

     

       24
        
       }

···

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

     

       21
        
       	Issue         string `json:"issue" cborgen:"issue"`

     

       22
        
       	// state: state of the issue

     

       23
       +
       	State string `json:"state" cborgen:"state"`

     

       24
        
       }

+4 -4

api/tangled/knotmember.go

···

       17
        
       } //

     

       18
        
       // RECORDTYPE: KnotMember

     

       19
        
       type KnotMember struct {

     

       20
       -
       	LexiconTypeID string  `json:"$type,const=sh.tangled.knot.member" cborgen:"$type,const=sh.tangled.knot.member"`

     

       21
       -
       	AddedAt       *string `json:"addedAt,omitempty" cborgen:"addedAt,omitempty"`

     

       22
        
       	// domain: domain that this member now belongs to

     

       23
       -
       	Domain string `json:"domain" cborgen:"domain"`

     

       24
       -
       	Member string `json:"member" cborgen:"member"`

     

       25
        
       }

···

       17
        
       } //

     

       18
        
       // RECORDTYPE: KnotMember

     

       19
        
       type KnotMember struct {

     

       20
       +
       	LexiconTypeID string `json:"$type,const=sh.tangled.knot.member" cborgen:"$type,const=sh.tangled.knot.member"`

     

       21
       +
       	CreatedAt     string `json:"createdAt" cborgen:"createdAt"`

     

       22
        
       	// domain: domain that this member now belongs to

     

       23
       +
       	Domain  string `json:"domain" cborgen:"domain"`

     

       24
       +
       	Subject string `json:"subject" cborgen:"subject"`

     

       25
        
       }

+2 -2

api/tangled/pullcomment.go

···

       18
        
       // RECORDTYPE: RepoPullComment

     

       19
        
       type RepoPullComment struct {

     

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

     

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

     

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

     

       23
       -
       	CreatedAt     *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`

     

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

     

       25
        
       	Pull          string  `json:"pull" cborgen:"pull"`

     

       26
        
       	Repo          *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

···

       18
        
       // RECORDTYPE: RepoPullComment

     

       19
        
       type RepoPullComment struct {

     

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

     

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

     

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

     

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

     

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

     

       25
        
       	Pull          string  `json:"pull" cborgen:"pull"`

     

       26
        
       	Repo          *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

+1 -1

api/tangled/pullstatus.go

···

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

     

       21
        
       	Pull          string `json:"pull" cborgen:"pull"`

     

       22
        
       	// status: status of the pull request

     

       23
       -
       	Status *string `json:"status,omitempty" cborgen:"status,omitempty"`

     

       24
        
       }

···

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

     

       21
        
       	Pull          string `json:"pull" cborgen:"pull"`

     

       22
        
       	// status: status of the pull request

     

       23
       +
       	Status string `json:"status" cborgen:"status"`

     

       24
        
       }

+1 -1

api/tangled/repoissue.go

···

       19
        
       type RepoIssue struct {

     

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

     

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

     

       22
       -
       	CreatedAt     *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`

     

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

     

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

     

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

···

       19
        
       type RepoIssue struct {

     

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

     

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

     

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

     

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

     

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

     

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

+1 -1

api/tangled/repopull.go

···

       19
        
       type RepoPull struct {

     

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

     

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

     

       22
       -
       	CreatedAt     *string          `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"`

     

       23
        
       	Patch         string           `json:"patch" cborgen:"patch"`

     

       24
        
       	PullId        int64            `json:"pullId" cborgen:"pullId"`

     

       25
        
       	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

···

       19
        
       type RepoPull struct {

     

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

     

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

     

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

     

       23
        
       	Patch         string           `json:"patch" cborgen:"patch"`

     

       24
        
       	PullId        int64            `json:"pullId" cborgen:"pullId"`

     

       25
        
       	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

+2 -2

api/tangled/tangledpublicKey.go

···

       18
        
       // RECORDTYPE: PublicKey

     

       19
        
       type PublicKey struct {

     

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

     

       21
       -
       	// created: key upload timestamp

     

       22
       -
       	Created string `json:"created" cborgen:"created"`

     

       23
        
       	// key: public key contents

     

       24
        
       	Key string `json:"key" cborgen:"key"`

     

       25
        
       	// name: human-readable name for this key

···

       18
        
       // RECORDTYPE: PublicKey

     

       19
        
       type PublicKey struct {

     

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

     

       21
       +
       	// createdAt: key upload timestamp

     

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

     

       23
        
       	// key: public key contents

     

       24
        
       	Key string `json:"key" cborgen:"key"`

     

       25
        
       	// name: human-readable name for this key

+1 -1

api/tangled/tangledrepo.go

···

       18
        
       // RECORDTYPE: Repo

     

       19
        
       type Repo struct {

     

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

     

       21
       -
       	AddedAt       *string `json:"addedAt,omitempty" cborgen:"addedAt,omitempty"`

     

       22
        
       	Description   *string `json:"description,omitempty" cborgen:"description,omitempty"`

     

       23
        
       	// knot: knot where the repo was created

     

       24
        
       	Knot string `json:"knot" cborgen:"knot"`

···

       18
        
       // RECORDTYPE: Repo

     

       19
        
       type Repo struct {

     

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

     

       21
       +
       	CreatedAt     string  `json:"createdAt" cborgen:"createdAt"`

     

       22
        
       	Description   *string `json:"description,omitempty" cborgen:"description,omitempty"`

     

       23
        
       	// knot: knot where the repo was created

     

       24
        
       	Knot string `json:"knot" cborgen:"knot"`

+2 -2

appview/pages/templates/knot.html

···

       83
        
           class="max-w-2xl space-y-4">

     

       84
        
           <input

     

       85
        
             type="text"

     

       86
       -
             id="member"

     

       87
       -
             name="member"

     

       88
        
             placeholder="did or handle"

     

       89
        
             required

     

       90
        
             class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400"/>

···

       83
        
           class="max-w-2xl space-y-4">

     

       84
        
           <input

     

       85
        
             type="text"

     

       86
       +
             id="subject"

     

       87
       +
             name="subject"

     

       88
        
             placeholder="did or handle"

     

       89
        
             required

     

       90
        
             class="w-full dark:bg-gray-700 dark:text-white dark:border-gray-600 dark:placeholder-gray-400"/>

+3 -3

appview/settings/settings.go

···

       384
        
       			Rkey:       rkey,

     

       385
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       386
        
       				Val: &tangled.PublicKey{

     

       387
       -
       					Created: time.Now().Format(time.RFC3339),

     

       388
       -
       					Key:     key,

     

       389
       -
       					Name:    name,

     

       390
        
       				}},

     

       391
        
       		})

     

       392
        
       		// invalid record

···

       384
        
       			Rkey:       rkey,

     

       385
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       386
        
       				Val: &tangled.PublicKey{

     

       387
       +
       					CreatedAt: time.Now().Format(time.RFC3339),

     

       388
       +
       					Key:       key,

     

       389
       +
       					Name:      name,

     

       390
        
       				}},

     

       391
        
       		})

     

       392
        
       		// invalid record

+2 -2

appview/state/pull.go

···

       530
        
       					Repo:      &atUri,

     

       531
        
       					Pull:      string(pullAt),

     

       532
        
       					Owner:     &ownerDid,

     

       533
       -
       					Body:      &body,

     

       534
       -
       					CreatedAt: &createdAt,

     

       535
        
       				},

     

       536
        
       			},

     

       537
        
       		})

···

       530
        
       					Repo:      &atUri,

     

       531
        
       					Pull:      string(pullAt),

     

       532
        
       					Owner:     &ownerDid,

     

       533
       +
       					Body:      body,

     

       534
       +
       					CreatedAt: createdAt,

     

       535
        
       				},

     

       536
        
       			},

     

       537
        
       		})

+15 -15

appview/state/repo.go

···

       217
        
       					Knot:        f.Knot,

     

       218
        
       					Name:        f.RepoName,

     

       219
        
       					Owner:       user.Did,

     

       220
       -
       					AddedAt:     &f.AddedAt,

     

       221
        
       					Description: &newDescription,

     

       222
        
       				},

     

       223
        
       			},

     
···

       851
        
       	RepoName    string

     

       852
        
       	RepoAt      syntax.ATURI

     

       853
        
       	Description string

     

       854
       -
       	AddedAt     string

     

       855
        
       }

     

       856
        
       

     

       857
        
       func (f *FullyResolvedRepo) OwnerDid() string {

     
···

       1122
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       1123
        
       				Val: &tangled.RepoIssueState{

     

       1124
        
       					Issue: issue.IssueAt,

     

       1125
       -
       					State: &closed,

     

       1126
        
       				},

     

       1127
        
       			},

     

       1128
        
       		})

     
···

       1260
        
       					Issue:     issueAt,

     

       1261
        
       					CommentId: &commentIdInt64,

     

       1262
        
       					Owner:     &ownerDid,

     

       1263
       -
       					Body:      &body,

     

       1264
       -
       					CreatedAt: &createdAt,

     

       1265
        
       				},

     

       1266
        
       			},

     

       1267
        
       		})

     
···

       1429
        
       						Issue:     issueAt,

     

       1430
        
       						CommentId: &commentIdInt64,

     

       1431
        
       						Owner:     &comment.OwnerDid,

     

       1432
       -
       						Body:      &newBody,

     

       1433
       -
       						CreatedAt: &createdAt,

     

       1434
        
       					},

     

       1435
        
       				},

     

       1436
        
       			})

     
···

       1760
        
       		} else {

     

       1761
        
       			uri = "https"

     

       1762
        
       		}

     

       1763
       -
       		sourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)

     

       1764
        
       		sourceAt := f.RepoAt.String()

     

       1765
        
       

     

       1766
        
       		rkey := appview.TID()

     
···

       1786
        
       			}

     

       1787
        
       		}()

     

       1788
        
       

     

       1789
       -
       		resp, err := client.ForkRepo(user.Did, sourceUrl, forkName)

     

       1790
        
       		if err != nil {

     

       1791
        
       			s.pages.Notice(w, "repo", "Failed to create repository on knot server.")

     

       1792
        
       			return

     
···

       1804
        
       

     

       1805
        
       		xrpcClient, _ := s.auth.AuthorizedClient(r)

     

       1806
        
       

     

       1807
       -
       		addedAt := time.Now().Format(time.RFC3339)

     

       1808
        
       		atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{

     

       1809
        
       			Collection: tangled.RepoNSID,

     

       1810
        
       			Repo:       user.Did,

     

       1811
        
       			Rkey:       rkey,

     

       1812
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       1813
        
       				Val: &tangled.Repo{

     

       1814
       -
       					Knot:    repo.Knot,

     

       1815
       -
       					Name:    repo.Name,

     

       1816
       -
       					AddedAt: &addedAt,

     

       1817
       -
       					Owner:   user.Did,

     

       1818
       -
       					Source:  &sourceAt,

     

       1819
        
       				}},

     

       1820
        
       		})

     

       1821
        
       		if err != nil {

···

       217
        
       					Knot:        f.Knot,

     

       218
        
       					Name:        f.RepoName,

     

       219
        
       					Owner:       user.Did,

     

       220
       +
       					CreatedAt:   f.CreatedAt,

     

       221
        
       					Description: &newDescription,

     

       222
        
       				},

     

       223
        
       			},

     
···

       851
        
       	RepoName    string

     

       852
        
       	RepoAt      syntax.ATURI

     

       853
        
       	Description string

     

       854
       +
       	CreatedAt   string

     

       855
        
       }

     

       856
        
       

     

       857
        
       func (f *FullyResolvedRepo) OwnerDid() string {

     
···

       1122
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       1123
        
       				Val: &tangled.RepoIssueState{

     

       1124
        
       					Issue: issue.IssueAt,

     

       1125
       +
       					State: closed,

     

       1126
        
       				},

     

       1127
        
       			},

     

       1128
        
       		})

     
···

       1260
        
       					Issue:     issueAt,

     

       1261
        
       					CommentId: &commentIdInt64,

     

       1262
        
       					Owner:     &ownerDid,

     

       1263
       +
       					Body:      body,

     

       1264
       +
       					CreatedAt: createdAt,

     

       1265
        
       				},

     

       1266
        
       			},

     

       1267
        
       		})

     
···

       1429
        
       						Issue:     issueAt,

     

       1430
        
       						CommentId: &commentIdInt64,

     

       1431
        
       						Owner:     &comment.OwnerDid,

     

       1432
       +
       						Body:      newBody,

     

       1433
       +
       						CreatedAt: createdAt,

     

       1434
        
       					},

     

       1435
        
       				},

     

       1436
        
       			})

     
···

       1760
        
       		} else {

     

       1761
        
       			uri = "https"

     

       1762
        
       		}

     

       1763
       +
       		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)

     

       1764
        
       		sourceAt := f.RepoAt.String()

     

       1765
        
       

     

       1766
        
       		rkey := appview.TID()

     
···

       1786
        
       			}

     

       1787
        
       		}()

     

       1788
        
       

     

       1789
       +
       		resp, err := client.ForkRepo(user.Did, forkSourceUrl, forkName)

     

       1790
        
       		if err != nil {

     

       1791
        
       			s.pages.Notice(w, "repo", "Failed to create repository on knot server.")

     

       1792
        
       			return

     
···

       1804
        
       

     

       1805
        
       		xrpcClient, _ := s.auth.AuthorizedClient(r)

     

       1806
        
       

     

       1807
       +
       		createdAt := time.Now().Format(time.RFC3339)

     

       1808
        
       		atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{

     

       1809
        
       			Collection: tangled.RepoNSID,

     

       1810
        
       			Repo:       user.Did,

     

       1811
        
       			Rkey:       rkey,

     

       1812
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       1813
        
       				Val: &tangled.Repo{

     

       1814
       +
       					Knot:      repo.Knot,

     

       1815
       +
       					Name:      repo.Name,

     

       1816
       +
       					CreatedAt: createdAt,

     

       1817
       +
       					Owner:     user.Did,

     

       1818
       +
       					Source:    &sourceAt,

     

       1819
        
       				}},

     

       1820
        
       		})

     

       1821
        
       		if err != nil {

+1 -1

appview/state/repo_util.go

···

       52
        
       		RepoName:    repoName,

     

       53
        
       		RepoAt:      parsedRepoAt,

     

       54
        
       		Description: description,

     

       55
       -
       		AddedAt:     addedAt,

     

       56
        
       	}, nil

     

       57
        
       }

     

       58

···

       52
        
       		RepoName:    repoName,

     

       53
        
       		RepoAt:      parsedRepoAt,

     

       54
        
       		Description: description,

     

       55
       +
       		CreatedAt:   addedAt,

     

       56
        
       	}, nil

     

       57
        
       }

     

       58

+16 -16

appview/state/state.go

···

       502
        
       		return

     

       503
        
       	}

     

       504
        
       

     

       505
       -
       	memberDid := r.FormValue("member")

     

       506
       -
       	if memberDid == "" {

     

       507
        
       		http.Error(w, "malformed form", http.StatusBadRequest)

     

       508
        
       		return

     

       509
        
       	}

     

       510
        
       

     

       511
       -
       	memberIdent, err := s.resolver.ResolveIdent(r.Context(), memberDid)

     

       512
        
       	if err != nil {

     

       513
        
       		w.Write([]byte("failed to resolve member did to a handle"))

     

       514
        
       		return

     

       515
        
       	}

     

       516
       -
       	log.Printf("adding %s to %s\n", memberIdent.Handle.String(), domain)

     

       517
        
       

     

       518
        
       	// announce this relation into the firehose, store into owners' pds

     

       519
        
       	client, _ := s.auth.AuthorizedClient(r)

     

       520
        
       	currentUser := s.auth.GetUser(r)

     

       521
       -
       	addedAt := time.Now().Format(time.RFC3339)

     

       522
        
       	resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       523
        
       		Collection: tangled.KnotMemberNSID,

     

       524
        
       		Repo:       currentUser.Did,

     

       525
        
       		Rkey:       appview.TID(),

     

       526
        
       		Record: &lexutil.LexiconTypeDecoder{

     

       527
        
       			Val: &tangled.KnotMember{

     

       528
       -
       				Member:  memberIdent.DID.String(),

     

       529
       -
       				Domain:  domain,

     

       530
       -
       				AddedAt: &addedAt,

     

       531
        
       			}},

     

       532
        
       	})

     

       533
        
       

     
···

       550
        
       		return

     

       551
        
       	}

     

       552
        
       

     

       553
       -
       	ksResp, err := ksClient.AddMember(memberIdent.DID.String())

     

       554
        
       	if err != nil {

     

       555
        
       		log.Printf("failed to make request to %s: %s", domain, err)

     

       556
        
       		return

     
···

       561
        
       		return

     

       562
        
       	}

     

       563
        
       

     

       564
       -
       	err = s.enforcer.AddMember(domain, memberIdent.DID.String())

     

       565
        
       	if err != nil {

     

       566
        
       		w.Write([]byte(fmt.Sprint("failed to add member: ", err)))

     

       567
        
       		return

     

       568
        
       	}

     

       569
        
       

     

       570
       -
       	w.Write([]byte(fmt.Sprint("added member: ", memberIdent.Handle.String())))

     

       571
        
       }

     

       572
        
       

     

       573
        
       func (s *State) RemoveMember(w http.ResponseWriter, r *http.Request) {

     
···

       657
        
       

     

       658
        
       		xrpcClient, _ := s.auth.AuthorizedClient(r)

     

       659
        
       

     

       660
       -
       		addedAt := time.Now().Format(time.RFC3339)

     

       661
        
       		atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{

     

       662
        
       			Collection: tangled.RepoNSID,

     

       663
        
       			Repo:       user.Did,

     

       664
        
       			Rkey:       rkey,

     

       665
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       666
        
       				Val: &tangled.Repo{

     

       667
       -
       					Knot:    repo.Knot,

     

       668
       -
       					Name:    repoName,

     

       669
       -
       					AddedAt: &addedAt,

     

       670
       -
       					Owner:   user.Did,

     

       671
        
       				}},

     

       672
        
       		})

     

       673
        
       		if err != nil {

···

       502
        
       		return

     

       503
        
       	}

     

       504
        
       

     

       505
       +
       	subjectIdentifier := r.FormValue("subject")

     

       506
       +
       	if subjectIdentifier == "" {

     

       507
        
       		http.Error(w, "malformed form", http.StatusBadRequest)

     

       508
        
       		return

     

       509
        
       	}

     

       510
        
       

     

       511
       +
       	subjectIdentity, err := s.resolver.ResolveIdent(r.Context(), subjectIdentifier)

     

       512
        
       	if err != nil {

     

       513
        
       		w.Write([]byte("failed to resolve member did to a handle"))

     

       514
        
       		return

     

       515
        
       	}

     

       516
       +
       	log.Printf("adding %s to %s\n", subjectIdentity.Handle.String(), domain)

     

       517
        
       

     

       518
        
       	// announce this relation into the firehose, store into owners' pds

     

       519
        
       	client, _ := s.auth.AuthorizedClient(r)

     

       520
        
       	currentUser := s.auth.GetUser(r)

     

       521
       +
       	createdAt := time.Now().Format(time.RFC3339)

     

       522
        
       	resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       523
        
       		Collection: tangled.KnotMemberNSID,

     

       524
        
       		Repo:       currentUser.Did,

     

       525
        
       		Rkey:       appview.TID(),

     

       526
        
       		Record: &lexutil.LexiconTypeDecoder{

     

       527
        
       			Val: &tangled.KnotMember{

     

       528
       +
       				Subject:   subjectIdentity.DID.String(),

     

       529
       +
       				Domain:    domain,

     

       530
       +
       				CreatedAt: createdAt,

     

       531
        
       			}},

     

       532
        
       	})

     

       533
        
       

     
···

       550
        
       		return

     

       551
        
       	}

     

       552
        
       

     

       553
       +
       	ksResp, err := ksClient.AddMember(subjectIdentity.DID.String())

     

       554
        
       	if err != nil {

     

       555
        
       		log.Printf("failed to make request to %s: %s", domain, err)

     

       556
        
       		return

     
···

       561
        
       		return

     

       562
        
       	}

     

       563
        
       

     

       564
       +
       	err = s.enforcer.AddMember(domain, subjectIdentity.DID.String())

     

       565
        
       	if err != nil {

     

       566
        
       		w.Write([]byte(fmt.Sprint("failed to add member: ", err)))

     

       567
        
       		return

     

       568
        
       	}

     

       569
        
       

     

       570
       +
       	w.Write([]byte(fmt.Sprint("added member: ", subjectIdentity.Handle.String())))

     

       571
        
       }

     

       572
        
       

     

       573
        
       func (s *State) RemoveMember(w http.ResponseWriter, r *http.Request) {

     
···

       657
        
       

     

       658
        
       		xrpcClient, _ := s.auth.AuthorizedClient(r)

     

       659
        
       

     

       660
       +
       		createdAt := time.Now().Format(time.RFC3339)

     

       661
        
       		atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{

     

       662
        
       			Collection: tangled.RepoNSID,

     

       663
        
       			Repo:       user.Did,

     

       664
        
       			Rkey:       rkey,

     

       665
        
       			Record: &lexutil.LexiconTypeDecoder{

     

       666
        
       				Val: &tangled.Repo{

     

       667
       +
       					Knot:      repo.Knot,

     

       668
       +
       					Name:      repoName,

     

       669
       +
       					CreatedAt: createdAt,

     

       670
       +
       					Owner:     user.Did,

     

       671
        
       				}},

     

       672
        
       		})

     

       673
        
       		if err != nil {

+9 -9

knotserver/db/pubkeys.go

···

       23
        
       		Did: did,

     

       24
        
       	}

     

       25
        
       	pk.Key = record["key"]

     

       26
       -
       	pk.Created = record["created"]

     

       27
        
       

     

       28
        
       	return d.AddPublicKey(pk)

     

       29
        
       }

     

       30
        
       

     

       31
        
       func (d *DB) AddPublicKey(pk PublicKey) error {

     

       32
       -
       	if pk.Created == "" {

     

       33
       -
       		pk.Created = time.Now().Format(time.RFC3339)

     

       34
        
       	}

     

       35
        
       

     

       36
        
       	query := `insert or ignore into public_keys (did, key, created) values (?, ?, ?)`

     

       37
       -
       	_, err := d.db.Exec(query, pk.Did, pk.Key, pk.Created)

     

       38
        
       	return err

     

       39
        
       }

     

       40
        
       

     
···

       46
        
       

     

       47
        
       func (pk *PublicKey) JSON() map[string]any {

     

       48
        
       	return map[string]any{

     

       49
       -
       		"did":     pk.Did,

     

       50
       -
       		"key":     pk.Key,

     

       51
       -
       		"created": pk.Created,

     

       52
        
       	}

     

       53
        
       }

     

       54
        
       

     
···

       63
        
       

     

       64
        
       	for rows.Next() {

     

       65
        
       		var publicKey PublicKey

     

       66
       -
       		if err := rows.Scan(&publicKey.Key, &publicKey.Did, &publicKey.Created); err != nil {

     

       67
        
       			return nil, err

     

       68
        
       		}

     

       69
        
       		keys = append(keys, publicKey)

     
···

       87
        
       

     

       88
        
       	for rows.Next() {

     

       89
        
       		var publicKey PublicKey

     

       90
       -
       		if err := rows.Scan(&publicKey.Did, &publicKey.Key, &publicKey.Created); err != nil {

     

       91
        
       			return nil, err

     

       92
        
       		}

     

       93
        
       		keys = append(keys, publicKey)

···

       23
        
       		Did: did,

     

       24
        
       	}

     

       25
        
       	pk.Key = record["key"]

     

       26
       +
       	pk.CreatedAt = record["createdAt"]

     

       27
        
       

     

       28
        
       	return d.AddPublicKey(pk)

     

       29
        
       }

     

       30
        
       

     

       31
        
       func (d *DB) AddPublicKey(pk PublicKey) error {

     

       32
       +
       	if pk.CreatedAt == "" {

     

       33
       +
       		pk.CreatedAt = time.Now().Format(time.RFC3339)

     

       34
        
       	}

     

       35
        
       

     

       36
        
       	query := `insert or ignore into public_keys (did, key, created) values (?, ?, ?)`

     

       37
       +
       	_, err := d.db.Exec(query, pk.Did, pk.Key, pk.CreatedAt)

     

       38
        
       	return err

     

       39
        
       }

     

       40
        
       

     
···

       46
        
       

     

       47
        
       func (pk *PublicKey) JSON() map[string]any {

     

       48
        
       	return map[string]any{

     

       49
       +
       		"did":       pk.Did,

     

       50
       +
       		"key":       pk.Key,

     

       51
       +
       		"createdAt": pk.CreatedAt,

     

       52
        
       	}

     

       53
        
       }

     

       54
        
       

     
···

       63
        
       

     

       64
        
       	for rows.Next() {

     

       65
        
       		var publicKey PublicKey

     

       66
       +
       		if err := rows.Scan(&publicKey.Key, &publicKey.Did, &publicKey.CreatedAt); err != nil {

     

       67
        
       			return nil, err

     

       68
        
       		}

     

       69
        
       		keys = append(keys, publicKey)

     
···

       87
        
       

     

       88
        
       	for rows.Next() {

     

       89
        
       		var publicKey PublicKey

     

       90
       +
       		if err := rows.Scan(&publicKey.Did, &publicKey.Key, &publicKey.CreatedAt); err != nil {

     

       91
        
       			return nil, err

     

       92
        
       		}

     

       93
        
       		keys = append(keys, publicKey)

+2 -2

knotserver/jetstream.go

···

       43
        
       		return fmt.Errorf("failed to enforce permissions: %w", err)

     

       44
        
       	}

     

       45
        
       

     

       46
       -
       	if err := h.e.AddMember(ThisServer, record.Member); err != nil {

     

       47
        
       		l.Error("failed to add member", "error", err)

     

       48
        
       		return fmt.Errorf("failed to add member: %w", err)

     

       49
        
       	}

     

       50
       -
       	l.Info("added member from firehose", "member", record.Member)

     

       51
        
       

     

       52
        
       	if err := h.db.AddDid(did); err != nil {

     

       53
        
       		l.Error("failed to add did", "error", err)

···

       43
        
       		return fmt.Errorf("failed to enforce permissions: %w", err)

     

       44
        
       	}

     

       45
        
       

     

       46
       +
       	if err := h.e.AddMember(ThisServer, record.Subject); err != nil {

     

       47
        
       		l.Error("failed to add member", "error", err)

     

       48
        
       		return fmt.Errorf("failed to add member: %w", err)

     

       49
        
       	}

     

       50
       +
       	l.Info("added member from firehose", "member", record.Subject)

     

       51
        
       

     

       52
        
       	if err := h.db.AddDid(did); err != nil {

     

       53
        
       		l.Error("failed to add did", "error", err)

+6 -7

lexicons/follow.json

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       -
                 "createdAt",

     

       14
       -
                 "subject"

     

       15
        
               ],

     

       16
        
               "properties": {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
                 "createdAt": {

     

       18
        
                   "type": "string",

     

       19
        
                   "format": "datetime"

     

       20
       -
                 },

     

       21
       -
                 "subject": {

     

       22
       -
                   "type": "string",

     

       23
       -
                   "format": "did"

     

       24
        
                 }

     

       25
        
               }

     

       26
        
             }

     

       27
        
           }

     

       28
        
         }

     

       29
        
       }

     

       30
       -

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       +
                 "subject",

     

       14
       +
                 "createdAt"

     

       15
        
               ],

     

       16
        
               "properties": {

     

       17
       +
                 "subject": {

     

       18
       +
                   "type": "string",

     

       19
       +
                   "format": "did"

     

       20
       +
                 },

     

       21
        
                 "createdAt": {

     

       22
        
                   "type": "string",

     

       23
        
                   "format": "datetime"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
                 }

     

       25
        
               }

     

       26
        
             }

     

       27
        
           }

     

       28
        
         }

     

       29
        
       }

     

       0

+5 -1

lexicons/issue/comment.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": ["issue"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "issue": {

     

       15
        
                   "type": "string",

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "issue",

     

       14
       +
                 "body",

     

       15
       +
                 "createdAt"

     

       16
       +
               ],

     

       17
        
               "properties": {

     

       18
        
                 "issue": {

     

       19
        
                   "type": "string",

+7 -1

lexicons/issue/issue.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": ["repo", "issueId", "owner", "title"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "repo": {

     

       15
        
                   "type": "string",

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "repo",

     

       14
       +
                 "issueId",

     

       15
       +
                 "owner",

     

       16
       +
                 "title",

     

       17
       +
                 "createdAt"

     

       18
       +
               ],

     

       19
        
               "properties": {

     

       20
        
                 "repo": {

     

       21
        
                   "type": "string",

+4 -1

lexicons/issue/state.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": ["issue"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "issue": {

     

       15
        
                   "type": "string",

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "issue",

     

       14
       +
                 "state"

     

       15
       +
               ],

     

       16
        
               "properties": {

     

       17
        
                 "issue": {

     

       18
        
                   "type": "string",

+5 -4

lexicons/member.json

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       -
                 "member",

     

       14
       -
                 "domain"

     

       0
        
       
     

       15
        
               ],

     

       16
        
               "properties": {

     

       17
       -
                 "member": {

     

       18
        
                   "type": "string",

     

       19
        
                   "format": "did"

     

       20
        
                 },

     
···

       22
        
                   "type": "string",

     

       23
        
                   "description": "domain that this member now belongs to"

     

       24
        
                 },

     

       25
       -
                 "addedAt": {

     

       26
        
                   "type": "string",

     

       27
        
                   "format": "datetime"

     

       28
        
                 }

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       +
                 "subject",

     

       14
       +
                 "domain",

     

       15
       +
                 "createdAt"

     

       16
        
               ],

     

       17
        
               "properties": {

     

       18
       +
                 "subject": {

     

       19
        
                   "type": "string",

     

       20
        
                   "format": "did"

     

       21
        
                 },

     
···

       23
        
                   "type": "string",

     

       24
        
                   "description": "domain that this member now belongs to"

     

       25
        
                 },

     

       26
       +
                 "createdAt": {

     

       27
        
                   "type": "string",

     

       28
        
                   "format": "datetime"

     

       29
        
                 }

+2 -3

lexicons/publicKey.json

···

       12
        
               "required": [

     

       13
        
                 "key",

     

       14
        
                 "name",

     

       15
       -
                 "created"

     

       16
        
               ],

     

       17
        
               "properties": {

     

       18
        
                 "key": {

     

       19
        
                   "type": "string",

     

       20
        
                   "maxLength": 4096,

     

       21
       -
                   "maxGraphemes": 4096,

     

       22
        
                   "description": "public key contents"

     

       23
        
                 },

     

       24
        
                 "name": {

     
···

       26
        
                   "format": "string",

     

       27
        
                   "description": "human-readable name for this key"

     

       28
        
                 },

     

       29
       -
                 "created": {

     

       30
        
                   "type": "string",

     

       31
        
                   "format": "datetime",

     

       32
        
                   "description": "key upload timestamp"

···

       12
        
               "required": [

     

       13
        
                 "key",

     

       14
        
                 "name",

     

       15
       +
                 "createdAt"

     

       16
        
               ],

     

       17
        
               "properties": {

     

       18
        
                 "key": {

     

       19
        
                   "type": "string",

     

       20
        
                   "maxLength": 4096,

     

       0
        
       
     

       21
        
                   "description": "public key contents"

     

       22
        
                 },

     

       23
        
                 "name": {

     
···

       25
        
                   "format": "string",

     

       26
        
                   "description": "human-readable name for this key"

     

       27
        
                 },

     

       28
       +
                 "createdAt": {

     

       29
        
                   "type": "string",

     

       30
        
                   "format": "datetime",

     

       31
        
                   "description": "key upload timestamp"

+5 -1

lexicons/pulls/comment.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": ["pull"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "pull": {

     

       15
        
                   "type": "string",

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "pull",

     

       14
       +
                 "body",

     

       15
       +
                 "createdAt"

     

       16
       +
               ],

     

       17
        
               "properties": {

     

       18
        
                 "pull": {

     

       19
        
                   "type": "string",

+9 -6

lexicons/pulls/pull.json

···

       14
        
                 "targetBranch",

     

       15
        
                 "pullId",

     

       16
        
                 "title",

     

       17
       -
                 "patch"

     

       0
        
       
     

       18
        
               ],

     

       19
        
               "properties": {

     

       20
        
                 "targetRepo": {

     
···

       33
        
                 "body": {

     

       34
        
                   "type": "string"

     

       35
        
                 },

     

       36
       -
                 "createdAt": {

     

       37
       -
                   "type": "string",

     

       38
       -
                   "format": "datetime"

     

       39
       -
                 },

     

       40
        
                 "patch": {

     

       41
        
                   "type": "string"

     

       42
        
                 },

     

       43
        
                 "source": {

     

       44
        
                   "type": "ref",

     

       45
        
                   "ref": "#source"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       46
        
                 }

     

       47
        
               }

     

       48
        
             }

     

       49
        
           },

     

       50
        
           "source": {

     

       51
        
             "type": "object",

     

       52
       -
             "required": ["branch"],

     

       0
        
       
     

       0
        
       
     

       53
        
             "properties": {

     

       54
        
               "branch": {

     

       55
        
                 "type": "string"

···

       14
        
                 "targetBranch",

     

       15
        
                 "pullId",

     

       16
        
                 "title",

     

       17
       +
                 "patch",

     

       18
       +
                 "createdAt"

     

       19
        
               ],

     

       20
        
               "properties": {

     

       21
        
                 "targetRepo": {

     
···

       34
        
                 "body": {

     

       35
        
                   "type": "string"

     

       36
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       37
        
                 "patch": {

     

       38
        
                   "type": "string"

     

       39
        
                 },

     

       40
        
                 "source": {

     

       41
        
                   "type": "ref",

     

       42
        
                   "ref": "#source"

     

       43
       +
                 },

     

       44
       +
                 "createdAt": {

     

       45
       +
                   "type": "string",

     

       46
       +
                   "format": "datetime"

     

       47
        
                 }

     

       48
        
               }

     

       49
        
             }

     

       50
        
           },

     

       51
        
           "source": {

     

       52
        
             "type": "object",

     

       53
       +
             "required": [

     

       54
       +
               "branch"

     

       55
       +
             ],

     

       56
        
             "properties": {

     

       57
        
               "branch": {

     

       58
        
                 "type": "string"

+4 -1

lexicons/pulls/state.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": ["pull"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "pull": {

     

       15
        
                   "type": "string",

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "pull",

     

       14
       +
                 "status"

     

       15
       +
               ],

     

       16
        
               "properties": {

     

       17
        
                 "pull": {

     

       18
        
                   "type": "string",

+12 -7

lexicons/repo.json

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       -
               "required": ["name", "knot", "owner"],

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       13
        
               "properties": {

     

       14
        
                 "name": {

     

       15
        
                   "type": "string",

     
···

       23
        
                   "type": "string",

     

       24
        
                   "description": "knot where the repo was created"

     

       25
        
                 },

     

       26
       -
                 "addedAt": {

     

       27
       -
                   "type": "string",

     

       28
       -
                   "format": "datetime"

     

       29
       -
                 },

     

       30
        
                 "description": {

     

       31
        
                   "type": "string",

     

       32
        
                   "format": "datetime",

     

       33
       -
                   "minLength": 1,

     

       34
       -
                   "maxLength": 140

     

       35
        
                 },

     

       36
        
                 "source": {

     

       37
        
                   "type": "string",

     

       38
        
                   "format": "uri",

     

       39
        
                   "description": "source of the repo"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       40
        
                 }

     

       41
        
               }

     

       42
        
             }

···

       9
        
             "key": "tid",

     

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
       +
               "required": [

     

       13
       +
                 "name",

     

       14
       +
                 "knot",

     

       15
       +
                 "owner",

     

       16
       +
                 "createdAt"

     

       17
       +
               ],

     

       18
        
               "properties": {

     

       19
        
                 "name": {

     

       20
        
                   "type": "string",

     
···

       28
        
                   "type": "string",

     

       29
        
                   "description": "knot where the repo was created"

     

       30
        
                 },

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       31
        
                 "description": {

     

       32
        
                   "type": "string",

     

       33
        
                   "format": "datetime",

     

       34
       +
                   "minGraphemes": 1,

     

       35
       +
                   "maxGraphemes": 140

     

       36
        
                 },

     

       37
        
                 "source": {

     

       38
        
                   "type": "string",

     

       39
        
                   "format": "uri",

     

       40
        
                   "description": "source of the repo"

     

       41
       +
                 },

     

       42
       +
                 "createdAt": {

     

       43
       +
                   "type": "string",

     

       44
       +
                   "format": "datetime"

     

       45
        
                 }

     

       46
        
               }

     

       47
        
             }

+6 -8

lexicons/star.json

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       -
                 "createdAt",

     

       14
       -
                 "subject"

     

       15
        
               ],

     

       16
        
               "properties": {

     

       17
       -
                 "createdAt": {

     

       18
       -
                   "type": "string",

     

       19
       -
                   "format": "datetime"

     

       20
       -
                 },

     

       21
        
                 "subject": {

     

       22
        
                   "type": "string",

     

       23
        
                   "format": "at-uri"

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       24
        
                 }

     

       25
        
               }

     

       26
        
             }

     

       27
        
           }

     

       28
        
         }

     

       29
        
       }

     

       30
       -
       

     

       31
       -

···

       10
        
             "record": {

     

       11
        
               "type": "object",

     

       12
        
               "required": [

     

       13
       +
                 "subject",

     

       14
       +
                 "createdAt"

     

       15
        
               ],

     

       16
        
               "properties": {

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       17
        
                 "subject": {

     

       18
        
                   "type": "string",

     

       19
        
                   "format": "at-uri"

     

       20
       +
                 },

     

       21
       +
                 "createdAt": {

     

       22
       +
                   "type": "string",

     

       23
       +
                   "format": "datetime"

     

       24
        
                 }

     

       25
        
               }

     

       26
        
             }

     

       27
        
           }

     

       28
        
         }

     

       29
        
       }

     

       0
        
       
     

       0