+225 -458

api/tangled/cbor_gen.go

··· 353 353 } 354 354 355 355 cw := cbg.NewCborWriter(w) 356 356 - fieldCount := 4 357 356 358 358 - if t.AddedAt == nil { 359 359 - fieldCount-- 360 360 - } 361 361 - 362 362 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 357 357 + if _, err := cw.Write([]byte{164}); err != nil { 363 358 return err 364 359 } 365 360 ··· 405 400 return err 406 401 } 407 402 408 408 - // t.Member (string) (string) 409 409 - if len("member") > 1000000 { 410 410 - return xerrors.Errorf("Value in field \"member\" was too long") 403 403 + // t.Subject (string) (string) 404 404 + if len("subject") > 1000000 { 405 405 + return xerrors.Errorf("Value in field \"subject\" was too long") 411 406 } 412 407 413 413 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("member"))); err != nil { 408 408 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 414 409 return err 415 410 } 416 416 - if _, err := cw.WriteString(string("member")); err != nil { 411 411 + if _, err := cw.WriteString(string("subject")); err != nil { 417 412 return err 418 413 } 419 414 420 420 - if len(t.Member) > 1000000 { 421 421 - return xerrors.Errorf("Value in field t.Member was too long") 415 415 + if len(t.Subject) > 1000000 { 416 416 + return xerrors.Errorf("Value in field t.Subject was too long") 422 417 } 423 418 424 424 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Member))); err != nil { 419 419 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 425 420 return err 426 421 } 427 427 - if _, err := cw.WriteString(string(t.Member)); err != nil { 422 422 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 428 423 return err 429 424 } 430 425 431 431 - // t.AddedAt (string) (string) 432 432 - if t.AddedAt != nil { 433 433 - 434 434 - if len("addedAt") > 1000000 { 435 435 - return xerrors.Errorf("Value in field \"addedAt\" was too long") 436 436 - } 426 426 + // t.CreatedAt (string) (string) 427 427 + if len("createdAt") > 1000000 { 428 428 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 429 429 + } 437 430 438 438 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("addedAt"))); err != nil { 439 439 - return err 440 440 - } 441 441 - if _, err := cw.WriteString(string("addedAt")); err != nil { 442 442 - return err 443 443 - } 431 431 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 432 432 + return err 433 433 + } 434 434 + if _, err := cw.WriteString(string("createdAt")); err != nil { 435 435 + return err 436 436 + } 444 437 445 445 - if t.AddedAt == nil { 446 446 - if _, err := cw.Write(cbg.CborNull); err != nil { 447 447 - return err 448 448 - } 449 449 - } else { 450 450 - if len(*t.AddedAt) > 1000000 { 451 451 - return xerrors.Errorf("Value in field t.AddedAt was too long") 452 452 - } 438 438 + if len(t.CreatedAt) > 1000000 { 439 439 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 440 440 + } 453 441 454 454 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AddedAt))); err != nil { 455 455 - return err 456 456 - } 457 457 - if _, err := cw.WriteString(string(*t.AddedAt)); err != nil { 458 458 - return err 459 459 - } 460 460 - } 442 442 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 443 443 + return err 444 444 + } 445 445 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 446 446 + return err 461 447 } 462 448 return nil 463 449 } ··· 487 473 488 474 n := extra 489 475 490 490 - nameBuf := make([]byte, 7) 476 476 + nameBuf := make([]byte, 9) 491 477 for i := uint64(0); i < n; i++ { 492 478 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 493 479 if err != nil { ··· 525 511 526 512 t.Domain = string(sval) 527 513 } 528 528 - // t.Member (string) (string) 529 529 - case "member": 514 514 + // t.Subject (string) (string) 515 515 + case "subject": 530 516 531 517 { 532 518 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 534 520 return err 535 521 } 536 522 537 537 - t.Member = string(sval) 523 523 + t.Subject = string(sval) 538 524 } 539 539 - // t.AddedAt (string) (string) 540 540 - case "addedAt": 525 525 + // t.CreatedAt (string) (string) 526 526 + case "createdAt": 541 527 542 528 { 543 543 - b, err := cr.ReadByte() 529 529 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 544 530 if err != nil { 545 531 return err 546 532 } 547 547 - if b != cbg.CborNull[0] { 548 548 - if err := cr.UnreadByte(); err != nil { 549 549 - return err 550 550 - } 551 533 552 552 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 553 553 - if err != nil { 554 554 - return err 555 555 - } 556 556 - 557 557 - t.AddedAt = (*string)(&sval) 558 558 - } 534 534 + t.CreatedAt = string(sval) 559 535 } 560 536 561 537 default: ··· 645 621 return err 646 622 } 647 623 648 648 - // t.Created (string) (string) 649 649 - if len("created") > 1000000 { 650 650 - return xerrors.Errorf("Value in field \"created\" was too long") 624 624 + // t.CreatedAt (string) (string) 625 625 + if len("createdAt") > 1000000 { 626 626 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 651 627 } 652 628 653 653 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("created"))); err != nil { 629 629 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 654 630 return err 655 631 } 656 656 - if _, err := cw.WriteString(string("created")); err != nil { 632 632 + if _, err := cw.WriteString(string("createdAt")); err != nil { 657 633 return err 658 634 } 659 635 660 660 - if len(t.Created) > 1000000 { 661 661 - return xerrors.Errorf("Value in field t.Created was too long") 636 636 + if len(t.CreatedAt) > 1000000 { 637 637 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 662 638 } 663 639 664 664 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Created))); err != nil { 640 640 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 665 641 return err 666 642 } 667 667 - if _, err := cw.WriteString(string(t.Created)); err != nil { 643 643 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 668 644 return err 669 645 } 670 646 return nil ··· 695 671 696 672 n := extra 697 673 698 698 - nameBuf := make([]byte, 7) 674 674 + nameBuf := make([]byte, 9) 699 675 for i := uint64(0); i < n; i++ { 700 676 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 701 677 if err != nil { ··· 744 720 745 721 t.LexiconTypeID = string(sval) 746 722 } 747 747 - // t.Created (string) (string) 748 748 - case "created": 723 723 + // t.CreatedAt (string) (string) 724 724 + case "createdAt": 749 725 750 726 { 751 727 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 753 729 return err 754 730 } 755 731 756 756 - t.Created = string(sval) 732 732 + t.CreatedAt = string(sval) 757 733 } 758 734 759 735 default: ··· 775 751 cw := cbg.NewCborWriter(w) 776 752 fieldCount := 7 777 753 778 778 - if t.Body == nil { 779 779 - fieldCount-- 780 780 - } 781 781 - 782 754 if t.CommentId == nil { 783 755 fieldCount-- 784 756 } 785 757 786 786 - if t.CreatedAt == nil { 787 787 - fieldCount-- 788 788 - } 789 789 - 790 758 if t.Owner == nil { 791 759 fieldCount-- 792 760 } ··· 800 768 } 801 769 802 770 // t.Body (string) (string) 803 803 - if t.Body != nil { 804 804 - 805 805 - if len("body") > 1000000 { 806 806 - return xerrors.Errorf("Value in field \"body\" was too long") 807 807 - } 771 771 + if len("body") > 1000000 { 772 772 + return xerrors.Errorf("Value in field \"body\" was too long") 773 773 + } 808 774 809 809 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 810 810 - return err 811 811 - } 812 812 - if _, err := cw.WriteString(string("body")); err != nil { 813 813 - return err 814 814 - } 775 775 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 776 776 + return err 777 777 + } 778 778 + if _, err := cw.WriteString(string("body")); err != nil { 779 779 + return err 780 780 + } 815 781 816 816 - if t.Body == nil { 817 817 - if _, err := cw.Write(cbg.CborNull); err != nil { 818 818 - return err 819 819 - } 820 820 - } else { 821 821 - if len(*t.Body) > 1000000 { 822 822 - return xerrors.Errorf("Value in field t.Body was too long") 823 823 - } 782 782 + if len(t.Body) > 1000000 { 783 783 + return xerrors.Errorf("Value in field t.Body was too long") 784 784 + } 824 785 825 825 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil { 826 826 - return err 827 827 - } 828 828 - if _, err := cw.WriteString(string(*t.Body)); err != nil { 829 829 - return err 830 830 - } 831 831 - } 786 786 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 787 787 + return err 788 788 + } 789 789 + if _, err := cw.WriteString(string(t.Body)); err != nil { 790 790 + return err 832 791 } 833 792 834 793 // t.Repo (string) (string) ··· 970 929 } 971 930 972 931 // t.CreatedAt (string) (string) 973 973 - if t.CreatedAt != nil { 932 932 + if len("createdAt") > 1000000 { 933 933 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 934 934 + } 974 935 975 975 - if len("createdAt") > 1000000 { 976 976 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 977 977 - } 936 936 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 937 937 + return err 938 938 + } 939 939 + if _, err := cw.WriteString(string("createdAt")); err != nil { 940 940 + return err 941 941 + } 978 942 979 979 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 980 980 - return err 981 981 - } 982 982 - if _, err := cw.WriteString(string("createdAt")); err != nil { 983 983 - return err 984 984 - } 985 985 - 986 986 - if t.CreatedAt == nil { 987 987 - if _, err := cw.Write(cbg.CborNull); err != nil { 988 988 - return err 989 989 - } 990 990 - } else { 991 991 - if len(*t.CreatedAt) > 1000000 { 992 992 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 993 993 - } 943 943 + if len(t.CreatedAt) > 1000000 { 944 944 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 945 945 + } 994 946 995 995 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil { 996 996 - return err 997 997 - } 998 998 - if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil { 999 999 - return err 1000 1000 - } 1001 1001 - } 947 947 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 948 948 + return err 949 949 + } 950 950 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 951 951 + return err 1002 952 } 1003 953 return nil 1004 954 } ··· 1048 998 case "body": 1049 999 1050 1000 { 1051 1051 - b, err := cr.ReadByte() 1001 1001 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1052 1002 if err != nil { 1053 1003 return err 1054 1004 } 1055 1055 - if b != cbg.CborNull[0] { 1056 1056 - if err := cr.UnreadByte(); err != nil { 1057 1057 - return err 1058 1058 - } 1059 1005 1060 1060 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1061 1061 - if err != nil { 1062 1062 - return err 1063 1063 - } 1064 1064 - 1065 1065 - t.Body = (*string)(&sval) 1066 1066 - } 1006 1006 + t.Body = string(sval) 1067 1007 } 1068 1008 // t.Repo (string) (string) 1069 1009 case "repo": ··· 1169 1109 case "createdAt": 1170 1110 1171 1111 { 1172 1172 - b, err := cr.ReadByte() 1112 1112 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1173 1113 if err != nil { 1174 1114 return err 1175 1115 } 1176 1176 - if b != cbg.CborNull[0] { 1177 1177 - if err := cr.UnreadByte(); err != nil { 1178 1178 - return err 1179 1179 - } 1180 1116 1181 1181 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1182 1182 - if err != nil { 1183 1183 - return err 1184 1184 - } 1185 1185 - 1186 1186 - t.CreatedAt = (*string)(&sval) 1187 1187 - } 1117 1117 + t.CreatedAt = string(sval) 1188 1118 } 1189 1119 1190 1120 default: ··· 1204 1134 } 1205 1135 1206 1136 cw := cbg.NewCborWriter(w) 1207 1207 - fieldCount := 3 1208 1137 1209 1209 - if t.State == nil { 1210 1210 - fieldCount-- 1211 1211 - } 1212 1212 - 1213 1213 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1138 1138 + if _, err := cw.Write([]byte{163}); err != nil { 1214 1139 return err 1215 1140 } 1216 1141 ··· 1257 1182 } 1258 1183 1259 1184 // t.State (string) (string) 1260 1260 - if t.State != nil { 1185 1185 + if len("state") > 1000000 { 1186 1186 + return xerrors.Errorf("Value in field \"state\" was too long") 1187 1187 + } 1261 1188 1262 1262 - if len("state") > 1000000 { 1263 1263 - return xerrors.Errorf("Value in field \"state\" was too long") 1264 1264 - } 1189 1189 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil { 1190 1190 + return err 1191 1191 + } 1192 1192 + if _, err := cw.WriteString(string("state")); err != nil { 1193 1193 + return err 1194 1194 + } 1265 1195 1266 1266 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("state"))); err != nil { 1267 1267 - return err 1268 1268 - } 1269 1269 - if _, err := cw.WriteString(string("state")); err != nil { 1270 1270 - return err 1271 1271 - } 1196 1196 + if len(t.State) > 1000000 { 1197 1197 + return xerrors.Errorf("Value in field t.State was too long") 1198 1198 + } 1272 1199 1273 1273 - if t.State == nil { 1274 1274 - if _, err := cw.Write(cbg.CborNull); err != nil { 1275 1275 - return err 1276 1276 - } 1277 1277 - } else { 1278 1278 - if len(*t.State) > 1000000 { 1279 1279 - return xerrors.Errorf("Value in field t.State was too long") 1280 1280 - } 1281 1281 - 1282 1282 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.State))); err != nil { 1283 1283 - return err 1284 1284 - } 1285 1285 - if _, err := cw.WriteString(string(*t.State)); err != nil { 1286 1286 - return err 1287 1287 - } 1288 1288 - } 1200 1200 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.State))); err != nil { 1201 1201 + return err 1202 1202 + } 1203 1203 + if _, err := cw.WriteString(string(t.State)); err != nil { 1204 1204 + return err 1289 1205 } 1290 1206 return nil 1291 1207 } ··· 1357 1273 case "state": 1358 1274 1359 1275 { 1360 1360 - b, err := cr.ReadByte() 1276 1276 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1361 1277 if err != nil { 1362 1278 return err 1363 1279 } 1364 1364 - if b != cbg.CborNull[0] { 1365 1365 - if err := cr.UnreadByte(); err != nil { 1366 1366 - return err 1367 1367 - } 1368 1280 1369 1369 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1370 1370 - if err != nil { 1371 1371 - return err 1372 1372 - } 1373 1373 - 1374 1374 - t.State = (*string)(&sval) 1375 1375 - } 1281 1281 + t.State = string(sval) 1376 1282 } 1377 1283 1378 1284 default: ··· 1395 1301 fieldCount := 7 1396 1302 1397 1303 if t.Body == nil { 1398 1398 - fieldCount-- 1399 1399 - } 1400 1400 - 1401 1401 - if t.CreatedAt == nil { 1402 1304 fieldCount-- 1403 1305 } 1404 1306 ··· 1549 1451 } 1550 1452 1551 1453 // t.CreatedAt (string) (string) 1552 1552 - if t.CreatedAt != nil { 1454 1454 + if len("createdAt") > 1000000 { 1455 1455 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 1456 1456 + } 1553 1457 1554 1554 - if len("createdAt") > 1000000 { 1555 1555 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 1556 1556 - } 1458 1458 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 1459 1459 + return err 1460 1460 + } 1461 1461 + if _, err := cw.WriteString(string("createdAt")); err != nil { 1462 1462 + return err 1463 1463 + } 1557 1464 1558 1558 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 1559 1559 - return err 1560 1560 - } 1561 1561 - if _, err := cw.WriteString(string("createdAt")); err != nil { 1562 1562 - return err 1563 1563 - } 1465 1465 + if len(t.CreatedAt) > 1000000 { 1466 1466 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 1467 1467 + } 1564 1468 1565 1565 - if t.CreatedAt == nil { 1566 1566 - if _, err := cw.Write(cbg.CborNull); err != nil { 1567 1567 - return err 1568 1568 - } 1569 1569 - } else { 1570 1570 - if len(*t.CreatedAt) > 1000000 { 1571 1571 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 1572 1572 - } 1573 1573 - 1574 1574 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil { 1575 1575 - return err 1576 1576 - } 1577 1577 - if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil { 1578 1578 - return err 1579 1579 - } 1580 1580 - } 1469 1469 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 1470 1470 + return err 1471 1471 + } 1472 1472 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 1473 1473 + return err 1581 1474 } 1582 1475 return nil 1583 1476 } ··· 1718 1611 case "createdAt": 1719 1612 1720 1613 { 1721 1721 - b, err := cr.ReadByte() 1614 1614 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1722 1615 if err != nil { 1723 1616 return err 1724 1617 } 1725 1725 - if b != cbg.CborNull[0] { 1726 1726 - if err := cr.UnreadByte(); err != nil { 1727 1727 - return err 1728 1728 - } 1729 1618 1730 1730 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1731 1731 - if err != nil { 1732 1732 - return err 1733 1733 - } 1734 1734 - 1735 1735 - t.CreatedAt = (*string)(&sval) 1736 1736 - } 1619 1619 + t.CreatedAt = string(sval) 1737 1620 } 1738 1621 1739 1622 default: ··· 1754 1637 1755 1638 cw := cbg.NewCborWriter(w) 1756 1639 fieldCount := 7 1757 1757 - 1758 1758 - if t.AddedAt == nil { 1759 1759 - fieldCount-- 1760 1760 - } 1761 1640 1762 1641 if t.Description == nil { 1763 1642 fieldCount-- ··· 1891 1770 } 1892 1771 } 1893 1772 1894 1894 - // t.AddedAt (string) (string) 1895 1895 - if t.AddedAt != nil { 1896 1896 - 1897 1897 - if len("addedAt") > 1000000 { 1898 1898 - return xerrors.Errorf("Value in field \"addedAt\" was too long") 1899 1899 - } 1773 1773 + // t.CreatedAt (string) (string) 1774 1774 + if len("createdAt") > 1000000 { 1775 1775 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 1776 1776 + } 1900 1777 1901 1901 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("addedAt"))); err != nil { 1902 1902 - return err 1903 1903 - } 1904 1904 - if _, err := cw.WriteString(string("addedAt")); err != nil { 1905 1905 - return err 1906 1906 - } 1778 1778 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 1779 1779 + return err 1780 1780 + } 1781 1781 + if _, err := cw.WriteString(string("createdAt")); err != nil { 1782 1782 + return err 1783 1783 + } 1907 1784 1908 1908 - if t.AddedAt == nil { 1909 1909 - if _, err := cw.Write(cbg.CborNull); err != nil { 1910 1910 - return err 1911 1911 - } 1912 1912 - } else { 1913 1913 - if len(*t.AddedAt) > 1000000 { 1914 1914 - return xerrors.Errorf("Value in field t.AddedAt was too long") 1915 1915 - } 1785 1785 + if len(t.CreatedAt) > 1000000 { 1786 1786 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 1787 1787 + } 1916 1788 1917 1917 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.AddedAt))); err != nil { 1918 1918 - return err 1919 1919 - } 1920 1920 - if _, err := cw.WriteString(string(*t.AddedAt)); err != nil { 1921 1921 - return err 1922 1922 - } 1923 1923 - } 1789 1789 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 1790 1790 + return err 1791 1791 + } 1792 1792 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 1793 1793 + return err 1924 1794 } 1925 1795 1926 1796 // t.Description (string) (string) ··· 2063 1933 t.Source = (*string)(&sval) 2064 1934 } 2065 1935 } 2066 2066 - // t.AddedAt (string) (string) 2067 2067 - case "addedAt": 1936 1936 + // t.CreatedAt (string) (string) 1937 1937 + case "createdAt": 2068 1938 2069 1939 { 2070 2070 - b, err := cr.ReadByte() 1940 1940 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2071 1941 if err != nil { 2072 1942 return err 2073 1943 } 2074 2074 - if b != cbg.CborNull[0] { 2075 2075 - if err := cr.UnreadByte(); err != nil { 2076 2076 - return err 2077 2077 - } 2078 1944 2079 2079 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2080 2080 - if err != nil { 2081 2081 - return err 2082 2082 - } 2083 2083 - 2084 2084 - t.AddedAt = (*string)(&sval) 2085 2085 - } 1945 1945 + t.CreatedAt = string(sval) 2086 1946 } 2087 1947 // t.Description (string) (string) 2088 1948 case "description": ··· 2126 1986 fieldCount := 9 2127 1987 2128 1988 if t.Body == nil { 2129 2129 - fieldCount-- 2130 2130 - } 2131 2131 - 2132 2132 - if t.CreatedAt == nil { 2133 1989 fieldCount-- 2134 1990 } 2135 1991 ··· 2280 2136 } 2281 2137 2282 2138 // t.CreatedAt (string) (string) 2283 2283 - if t.CreatedAt != nil { 2139 2139 + if len("createdAt") > 1000000 { 2140 2140 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2141 2141 + } 2284 2142 2285 2285 - if len("createdAt") > 1000000 { 2286 2286 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 2287 2287 - } 2143 2143 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2144 2144 + return err 2145 2145 + } 2146 2146 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2147 2147 + return err 2148 2148 + } 2288 2149 2289 2289 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2290 2290 - return err 2291 2291 - } 2292 2292 - if _, err := cw.WriteString(string("createdAt")); err != nil { 2293 2293 - return err 2294 2294 - } 2150 2150 + if len(t.CreatedAt) > 1000000 { 2151 2151 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2152 2152 + } 2295 2153 2296 2296 - if t.CreatedAt == nil { 2297 2297 - if _, err := cw.Write(cbg.CborNull); err != nil { 2298 2298 - return err 2299 2299 - } 2300 2300 - } else { 2301 2301 - if len(*t.CreatedAt) > 1000000 { 2302 2302 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 2303 2303 - } 2304 2304 - 2305 2305 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil { 2306 2306 - return err 2307 2307 - } 2308 2308 - if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil { 2309 2309 - return err 2310 2310 - } 2311 2311 - } 2154 2154 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2155 2155 + return err 2156 2156 + } 2157 2157 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2158 2158 + return err 2312 2159 } 2313 2160 2314 2161 // t.TargetRepo (string) (string) ··· 2504 2351 case "createdAt": 2505 2352 2506 2353 { 2507 2507 - b, err := cr.ReadByte() 2354 2354 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2508 2355 if err != nil { 2509 2356 return err 2510 2357 } 2511 2511 - if b != cbg.CborNull[0] { 2512 2512 - if err := cr.UnreadByte(); err != nil { 2513 2513 - return err 2514 2514 - } 2515 2358 2516 2516 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2517 2517 - if err != nil { 2518 2518 - return err 2519 2519 - } 2520 2520 - 2521 2521 - t.CreatedAt = (*string)(&sval) 2522 2522 - } 2359 2359 + t.CreatedAt = string(sval) 2523 2360 } 2524 2361 // t.TargetRepo (string) (string) 2525 2362 case "targetRepo": ··· 2719 2556 } 2720 2557 2721 2558 cw := cbg.NewCborWriter(w) 2722 2722 - fieldCount := 3 2723 2559 2724 2724 - if t.Status == nil { 2725 2725 - fieldCount-- 2726 2726 - } 2727 2727 - 2728 2728 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2560 2560 + if _, err := cw.Write([]byte{163}); err != nil { 2729 2561 return err 2730 2562 } 2731 2563 ··· 2772 2604 } 2773 2605 2774 2606 // t.Status (string) (string) 2775 2775 - if t.Status != nil { 2607 2607 + if len("status") > 1000000 { 2608 2608 + return xerrors.Errorf("Value in field \"status\" was too long") 2609 2609 + } 2776 2610 2777 2777 - if len("status") > 1000000 { 2778 2778 - return xerrors.Errorf("Value in field \"status\" was too long") 2779 2779 - } 2611 2611 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 2612 2612 + return err 2613 2613 + } 2614 2614 + if _, err := cw.WriteString(string("status")); err != nil { 2615 2615 + return err 2616 2616 + } 2780 2617 2781 2781 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("status"))); err != nil { 2782 2782 - return err 2783 2783 - } 2784 2784 - if _, err := cw.WriteString(string("status")); err != nil { 2785 2785 - return err 2786 2786 - } 2787 2787 - 2788 2788 - if t.Status == nil { 2789 2789 - if _, err := cw.Write(cbg.CborNull); err != nil { 2790 2790 - return err 2791 2791 - } 2792 2792 - } else { 2793 2793 - if len(*t.Status) > 1000000 { 2794 2794 - return xerrors.Errorf("Value in field t.Status was too long") 2795 2795 - } 2618 2618 + if len(t.Status) > 1000000 { 2619 2619 + return xerrors.Errorf("Value in field t.Status was too long") 2620 2620 + } 2796 2621 2797 2797 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Status))); err != nil { 2798 2798 - return err 2799 2799 - } 2800 2800 - if _, err := cw.WriteString(string(*t.Status)); err != nil { 2801 2801 - return err 2802 2802 - } 2803 2803 - } 2622 2622 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Status))); err != nil { 2623 2623 + return err 2624 2624 + } 2625 2625 + if _, err := cw.WriteString(string(t.Status)); err != nil { 2626 2626 + return err 2804 2627 } 2805 2628 return nil 2806 2629 } ··· 2872 2695 case "status": 2873 2696 2874 2697 { 2875 2875 - b, err := cr.ReadByte() 2698 2698 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2876 2699 if err != nil { 2877 2700 return err 2878 2701 } 2879 2879 - if b != cbg.CborNull[0] { 2880 2880 - if err := cr.UnreadByte(); err != nil { 2881 2881 - return err 2882 2882 - } 2883 2702 2884 2884 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2885 2885 - if err != nil { 2886 2886 - return err 2887 2887 - } 2888 2888 - 2889 2889 - t.Status = (*string)(&sval) 2890 2890 - } 2703 2703 + t.Status = string(sval) 2891 2704 } 2892 2705 2893 2706 default: ··· 2909 2722 cw := cbg.NewCborWriter(w) 2910 2723 fieldCount := 7 2911 2724 2912 2912 - if t.Body == nil { 2913 2913 - fieldCount-- 2914 2914 - } 2915 2915 - 2916 2725 if t.CommentId == nil { 2917 2726 fieldCount-- 2918 2727 } 2919 2728 2920 2920 - if t.CreatedAt == nil { 2921 2921 - fieldCount-- 2922 2922 - } 2923 2923 - 2924 2729 if t.Owner == nil { 2925 2730 fieldCount-- 2926 2731 } ··· 2934 2739 } 2935 2740 2936 2741 // t.Body (string) (string) 2937 2937 - if t.Body != nil { 2938 2938 - 2939 2939 - if len("body") > 1000000 { 2940 2940 - return xerrors.Errorf("Value in field \"body\" was too long") 2941 2941 - } 2742 2742 + if len("body") > 1000000 { 2743 2743 + return xerrors.Errorf("Value in field \"body\" was too long") 2744 2744 + } 2942 2745 2943 2943 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 2944 2944 - return err 2945 2945 - } 2946 2946 - if _, err := cw.WriteString(string("body")); err != nil { 2947 2947 - return err 2948 2948 - } 2746 2746 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 2747 2747 + return err 2748 2748 + } 2749 2749 + if _, err := cw.WriteString(string("body")); err != nil { 2750 2750 + return err 2751 2751 + } 2949 2752 2950 2950 - if t.Body == nil { 2951 2951 - if _, err := cw.Write(cbg.CborNull); err != nil { 2952 2952 - return err 2953 2953 - } 2954 2954 - } else { 2955 2955 - if len(*t.Body) > 1000000 { 2956 2956 - return xerrors.Errorf("Value in field t.Body was too long") 2957 2957 - } 2753 2753 + if len(t.Body) > 1000000 { 2754 2754 + return xerrors.Errorf("Value in field t.Body was too long") 2755 2755 + } 2958 2756 2959 2959 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Body))); err != nil { 2960 2960 - return err 2961 2961 - } 2962 2962 - if _, err := cw.WriteString(string(*t.Body)); err != nil { 2963 2963 - return err 2964 2964 - } 2965 2965 - } 2757 2757 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 2758 2758 + return err 2759 2759 + } 2760 2760 + if _, err := cw.WriteString(string(t.Body)); err != nil { 2761 2761 + return err 2966 2762 } 2967 2763 2968 2764 // t.Pull (string) (string) ··· 3104 2900 } 3105 2901 3106 2902 // t.CreatedAt (string) (string) 3107 3107 - if t.CreatedAt != nil { 2903 2903 + if len("createdAt") > 1000000 { 2904 2904 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 2905 2905 + } 3108 2906 3109 3109 - if len("createdAt") > 1000000 { 3110 3110 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 3111 3111 - } 2907 2907 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2908 2908 + return err 2909 2909 + } 2910 2910 + if _, err := cw.WriteString(string("createdAt")); err != nil { 2911 2911 + return err 2912 2912 + } 3112 2913 3113 3113 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 3114 3114 - return err 3115 3115 - } 3116 3116 - if _, err := cw.WriteString(string("createdAt")); err != nil { 3117 3117 - return err 3118 3118 - } 2914 2914 + if len(t.CreatedAt) > 1000000 { 2915 2915 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 2916 2916 + } 3119 2917 3120 3120 - if t.CreatedAt == nil { 3121 3121 - if _, err := cw.Write(cbg.CborNull); err != nil { 3122 3122 - return err 3123 3123 - } 3124 3124 - } else { 3125 3125 - if len(*t.CreatedAt) > 1000000 { 3126 3126 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 3127 3127 - } 3128 3128 - 3129 3129 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.CreatedAt))); err != nil { 3130 3130 - return err 3131 3131 - } 3132 3132 - if _, err := cw.WriteString(string(*t.CreatedAt)); err != nil { 3133 3133 - return err 3134 3134 - } 3135 3135 - } 2918 2918 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2919 2919 + return err 2920 2920 + } 2921 2921 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2922 2922 + return err 3136 2923 } 3137 2924 return nil 3138 2925 } ··· 3182 2969 case "body": 3183 2970 3184 2971 { 3185 3185 - b, err := cr.ReadByte() 2972 2972 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3186 2973 if err != nil { 3187 2974 return err 3188 2975 } 3189 3189 - if b != cbg.CborNull[0] { 3190 3190 - if err := cr.UnreadByte(); err != nil { 3191 3191 - return err 3192 3192 - } 3193 2976 3194 3194 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3195 3195 - if err != nil { 3196 3196 - return err 3197 3197 - } 3198 3198 - 3199 3199 - t.Body = (*string)(&sval) 3200 3200 - } 2977 2977 + t.Body = string(sval) 3201 2978 } 3202 2979 // t.Pull (string) (string) 3203 2980 case "pull": ··· 3303 3080 case "createdAt": 3304 3081 3305 3082 { 3306 3306 - b, err := cr.ReadByte() 3083 3083 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 3307 3084 if err != nil { 3308 3085 return err 3309 3086 } 3310 3310 - if b != cbg.CborNull[0] { 3311 3311 - if err := cr.UnreadByte(); err != nil { 3312 3312 - return err 3313 3313 - } 3314 3087 3315 3315 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 3316 3316 - if err != nil { 3317 3317 - return err 3318 3318 - } 3319 3319 - 3320 3320 - t.CreatedAt = (*string)(&sval) 3321 3321 - } 3088 3088 + t.CreatedAt = string(sval) 3322 3089 } 3323 3090 3324 3091 default:

+2 -2

api/tangled/issuecomment.go

··· 18 18 // RECORDTYPE: RepoIssueComment 19 19 type RepoIssueComment struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue.comment" cborgen:"$type,const=sh.tangled.repo.issue.comment"` 21 21 - Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 21 21 + Body string `json:"body" cborgen:"body"` 22 22 CommentId *int64 `json:"commentId,omitempty" cborgen:"commentId,omitempty"` 23 23 - CreatedAt *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"` 23 23 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 24 24 Issue string `json:"issue" cborgen:"issue"` 25 25 Owner *string `json:"owner,omitempty" cborgen:"owner,omitempty"` 26 26 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

+1 -1

api/tangled/issuestate.go

··· 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue.state" cborgen:"$type,const=sh.tangled.repo.issue.state"` 21 21 Issue string `json:"issue" cborgen:"issue"` 22 22 // state: state of the issue 23 23 - State *string `json:"state,omitempty" cborgen:"state,omitempty"` 23 23 + State string `json:"state" cborgen:"state"` 24 24 }

+4 -4

api/tangled/knotmember.go

··· 17 17 } // 18 18 // RECORDTYPE: KnotMember 19 19 type KnotMember struct { 20 20 - LexiconTypeID string `json:"$type,const=sh.tangled.knot.member" cborgen:"$type,const=sh.tangled.knot.member"` 21 21 - AddedAt *string `json:"addedAt,omitempty" cborgen:"addedAt,omitempty"` 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.knot.member" cborgen:"$type,const=sh.tangled.knot.member"` 21 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 22 // domain: domain that this member now belongs to 23 23 - Domain string `json:"domain" cborgen:"domain"` 24 24 - Member string `json:"member" cborgen:"member"` 23 23 + Domain string `json:"domain" cborgen:"domain"` 24 24 + Subject string `json:"subject" cborgen:"subject"` 25 25 }

+2 -2

api/tangled/pullcomment.go

··· 18 18 // RECORDTYPE: RepoPullComment 19 19 type RepoPullComment struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull.comment" cborgen:"$type,const=sh.tangled.repo.pull.comment"` 21 21 - Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 21 21 + Body string `json:"body" cborgen:"body"` 22 22 CommentId *int64 `json:"commentId,omitempty" cborgen:"commentId,omitempty"` 23 23 - CreatedAt *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"` 23 23 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 24 24 Owner *string `json:"owner,omitempty" cborgen:"owner,omitempty"` 25 25 Pull string `json:"pull" cborgen:"pull"` 26 26 Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"`

+1 -1

api/tangled/pullstatus.go

··· 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull.status" cborgen:"$type,const=sh.tangled.repo.pull.status"` 21 21 Pull string `json:"pull" cborgen:"pull"` 22 22 // status: status of the pull request 23 23 - Status *string `json:"status,omitempty" cborgen:"status,omitempty"` 23 23 + Status string `json:"status" cborgen:"status"` 24 24 }

+1 -1

api/tangled/repoissue.go

··· 19 19 type RepoIssue struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"` 21 21 Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 22 22 - CreatedAt *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 IssueId int64 `json:"issueId" cborgen:"issueId"` 24 24 Owner string `json:"owner" cborgen:"owner"` 25 25 Repo string `json:"repo" cborgen:"repo"`

+1 -1

api/tangled/repopull.go

··· 19 19 type RepoPull struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"` 21 21 Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 22 22 - CreatedAt *string `json:"createdAt,omitempty" cborgen:"createdAt,omitempty"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 Patch string `json:"patch" cborgen:"patch"` 24 24 PullId int64 `json:"pullId" cborgen:"pullId"` 25 25 Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

+2 -2

api/tangled/tangledpublicKey.go

··· 18 18 // RECORDTYPE: PublicKey 19 19 type PublicKey struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.publicKey" cborgen:"$type,const=sh.tangled.publicKey"` 21 21 - // created: key upload timestamp 22 22 - Created string `json:"created" cborgen:"created"` 21 21 + // createdAt: key upload timestamp 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 // key: public key contents 24 24 Key string `json:"key" cborgen:"key"` 25 25 // name: human-readable name for this key

+1 -1

api/tangled/tangledrepo.go

··· 18 18 // RECORDTYPE: Repo 19 19 type Repo struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo" cborgen:"$type,const=sh.tangled.repo"` 21 21 - AddedAt *string `json:"addedAt,omitempty" cborgen:"addedAt,omitempty"` 21 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 22 Description *string `json:"description,omitempty" cborgen:"description,omitempty"` 23 23 // knot: knot where the repo was created 24 24 Knot string `json:"knot" cborgen:"knot"`

+2 -2

appview/pages/templates/knot.html

··· 83 83 class="max-w-2xl space-y-4"> 84 84 <input 85 85 type="text" 86 86 - id="member" 87 87 - name="member" 86 86 + id="subject" 87 87 + name="subject" 88 88 placeholder="did or handle" 89 89 required 90 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 384 Rkey: rkey, 385 385 Record: &lexutil.LexiconTypeDecoder{ 386 386 Val: &tangled.PublicKey{ 387 387 - Created: time.Now().Format(time.RFC3339), 388 388 - Key: key, 389 389 - Name: name, 387 387 + CreatedAt: time.Now().Format(time.RFC3339), 388 388 + Key: key, 389 389 + Name: name, 390 390 }}, 391 391 }) 392 392 // invalid record

+2 -2

appview/state/pull.go

··· 530 530 Repo: &atUri, 531 531 Pull: string(pullAt), 532 532 Owner: &ownerDid, 533 533 - Body: &body, 534 534 - CreatedAt: &createdAt, 533 533 + Body: body, 534 534 + CreatedAt: createdAt, 535 535 }, 536 536 }, 537 537 })

+15 -15

appview/state/repo.go

··· 217 217 Knot: f.Knot, 218 218 Name: f.RepoName, 219 219 Owner: user.Did, 220 220 - AddedAt: &f.AddedAt, 220 220 + CreatedAt: f.CreatedAt, 221 221 Description: &newDescription, 222 222 }, 223 223 }, ··· 851 851 RepoName string 852 852 RepoAt syntax.ATURI 853 853 Description string 854 854 - AddedAt string 854 854 + CreatedAt string 855 855 } 856 856 857 857 func (f *FullyResolvedRepo) OwnerDid() string { ··· 1122 1122 Record: &lexutil.LexiconTypeDecoder{ 1123 1123 Val: &tangled.RepoIssueState{ 1124 1124 Issue: issue.IssueAt, 1125 1125 - State: &closed, 1125 1125 + State: closed, 1126 1126 }, 1127 1127 }, 1128 1128 }) ··· 1260 1260 Issue: issueAt, 1261 1261 CommentId: &commentIdInt64, 1262 1262 Owner: &ownerDid, 1263 1263 - Body: &body, 1264 1264 - CreatedAt: &createdAt, 1263 1263 + Body: body, 1264 1264 + CreatedAt: createdAt, 1265 1265 }, 1266 1266 }, 1267 1267 }) ··· 1429 1429 Issue: issueAt, 1430 1430 CommentId: &commentIdInt64, 1431 1431 Owner: &comment.OwnerDid, 1432 1432 - Body: &newBody, 1433 1433 - CreatedAt: &createdAt, 1432 1432 + Body: newBody, 1433 1433 + CreatedAt: createdAt, 1434 1434 }, 1435 1435 }, 1436 1436 }) ··· 1760 1760 } else { 1761 1761 uri = "https" 1762 1762 } 1763 1763 - sourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName) 1763 1763 + forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName) 1764 1764 sourceAt := f.RepoAt.String() 1765 1765 1766 1766 rkey := appview.TID() ··· 1786 1786 } 1787 1787 }() 1788 1788 1789 1789 - resp, err := client.ForkRepo(user.Did, sourceUrl, forkName) 1789 1789 + resp, err := client.ForkRepo(user.Did, forkSourceUrl, forkName) 1790 1790 if err != nil { 1791 1791 s.pages.Notice(w, "repo", "Failed to create repository on knot server.") 1792 1792 return ··· 1804 1804 1805 1805 xrpcClient, _ := s.auth.AuthorizedClient(r) 1806 1806 1807 1807 - addedAt := time.Now().Format(time.RFC3339) 1807 1807 + createdAt := time.Now().Format(time.RFC3339) 1808 1808 atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{ 1809 1809 Collection: tangled.RepoNSID, 1810 1810 Repo: user.Did, 1811 1811 Rkey: rkey, 1812 1812 Record: &lexutil.LexiconTypeDecoder{ 1813 1813 Val: &tangled.Repo{ 1814 1814 - Knot: repo.Knot, 1815 1815 - Name: repo.Name, 1816 1816 - AddedAt: &addedAt, 1817 1817 - Owner: user.Did, 1818 1818 - Source: &sourceAt, 1814 1814 + Knot: repo.Knot, 1815 1815 + Name: repo.Name, 1816 1816 + CreatedAt: createdAt, 1817 1817 + Owner: user.Did, 1818 1818 + Source: &sourceAt, 1819 1819 }}, 1820 1820 }) 1821 1821 if err != nil {

+1 -1

appview/state/repo_util.go

··· 52 52 RepoName: repoName, 53 53 RepoAt: parsedRepoAt, 54 54 Description: description, 55 55 - AddedAt: addedAt, 55 55 + CreatedAt: addedAt, 56 56 }, nil 57 57 } 58 58

+16 -16

appview/state/state.go

··· 502 502 return 503 503 } 504 504 505 505 - memberDid := r.FormValue("member") 506 506 - if memberDid == "" { 505 505 + subjectIdentifier := r.FormValue("subject") 506 506 + if subjectIdentifier == "" { 507 507 http.Error(w, "malformed form", http.StatusBadRequest) 508 508 return 509 509 } 510 510 511 511 - memberIdent, err := s.resolver.ResolveIdent(r.Context(), memberDid) 511 511 + subjectIdentity, err := s.resolver.ResolveIdent(r.Context(), subjectIdentifier) 512 512 if err != nil { 513 513 w.Write([]byte("failed to resolve member did to a handle")) 514 514 return 515 515 } 516 516 - log.Printf("adding %s to %s\n", memberIdent.Handle.String(), domain) 516 516 + log.Printf("adding %s to %s\n", subjectIdentity.Handle.String(), domain) 517 517 518 518 // announce this relation into the firehose, store into owners' pds 519 519 client, _ := s.auth.AuthorizedClient(r) 520 520 currentUser := s.auth.GetUser(r) 521 521 - addedAt := time.Now().Format(time.RFC3339) 521 521 + createdAt := time.Now().Format(time.RFC3339) 522 522 resp, err := comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{ 523 523 Collection: tangled.KnotMemberNSID, 524 524 Repo: currentUser.Did, 525 525 Rkey: appview.TID(), 526 526 Record: &lexutil.LexiconTypeDecoder{ 527 527 Val: &tangled.KnotMember{ 528 528 - Member: memberIdent.DID.String(), 529 529 - Domain: domain, 530 530 - AddedAt: &addedAt, 528 528 + Subject: subjectIdentity.DID.String(), 529 529 + Domain: domain, 530 530 + CreatedAt: createdAt, 531 531 }}, 532 532 }) 533 533 ··· 550 550 return 551 551 } 552 552 553 553 - ksResp, err := ksClient.AddMember(memberIdent.DID.String()) 553 553 + ksResp, err := ksClient.AddMember(subjectIdentity.DID.String()) 554 554 if err != nil { 555 555 log.Printf("failed to make request to %s: %s", domain, err) 556 556 return ··· 561 561 return 562 562 } 563 563 564 564 - err = s.enforcer.AddMember(domain, memberIdent.DID.String()) 564 564 + err = s.enforcer.AddMember(domain, subjectIdentity.DID.String()) 565 565 if err != nil { 566 566 w.Write([]byte(fmt.Sprint("failed to add member: ", err))) 567 567 return 568 568 } 569 569 570 570 - w.Write([]byte(fmt.Sprint("added member: ", memberIdent.Handle.String()))) 570 570 + w.Write([]byte(fmt.Sprint("added member: ", subjectIdentity.Handle.String()))) 571 571 } 572 572 573 573 func (s *State) RemoveMember(w http.ResponseWriter, r *http.Request) { ··· 657 657 658 658 xrpcClient, _ := s.auth.AuthorizedClient(r) 659 659 660 660 - addedAt := time.Now().Format(time.RFC3339) 660 660 + createdAt := time.Now().Format(time.RFC3339) 661 661 atresp, err := comatproto.RepoPutRecord(r.Context(), xrpcClient, &comatproto.RepoPutRecord_Input{ 662 662 Collection: tangled.RepoNSID, 663 663 Repo: user.Did, 664 664 Rkey: rkey, 665 665 Record: &lexutil.LexiconTypeDecoder{ 666 666 Val: &tangled.Repo{ 667 667 - Knot: repo.Knot, 668 668 - Name: repoName, 669 669 - AddedAt: &addedAt, 670 670 - Owner: user.Did, 667 667 + Knot: repo.Knot, 668 668 + Name: repoName, 669 669 + CreatedAt: createdAt, 670 670 + Owner: user.Did, 671 671 }}, 672 672 }) 673 673 if err != nil {

+9 -9

knotserver/db/pubkeys.go

··· 23 23 Did: did, 24 24 } 25 25 pk.Key = record["key"] 26 26 - pk.Created = record["created"] 26 26 + pk.CreatedAt = record["createdAt"] 27 27 28 28 return d.AddPublicKey(pk) 29 29 } 30 30 31 31 func (d *DB) AddPublicKey(pk PublicKey) error { 32 32 - if pk.Created == "" { 33 33 - pk.Created = time.Now().Format(time.RFC3339) 32 32 + if pk.CreatedAt == "" { 33 33 + pk.CreatedAt = time.Now().Format(time.RFC3339) 34 34 } 35 35 36 36 query := `insert or ignore into public_keys (did, key, created) values (?, ?, ?)` 37 37 - _, err := d.db.Exec(query, pk.Did, pk.Key, pk.Created) 37 37 + _, err := d.db.Exec(query, pk.Did, pk.Key, pk.CreatedAt) 38 38 return err 39 39 } 40 40 ··· 46 46 47 47 func (pk *PublicKey) JSON() map[string]any { 48 48 return map[string]any{ 49 49 - "did": pk.Did, 50 50 - "key": pk.Key, 51 51 - "created": pk.Created, 49 49 + "did": pk.Did, 50 50 + "key": pk.Key, 51 51 + "createdAt": pk.CreatedAt, 52 52 } 53 53 } 54 54 ··· 63 63 64 64 for rows.Next() { 65 65 var publicKey PublicKey 66 66 - if err := rows.Scan(&publicKey.Key, &publicKey.Did, &publicKey.Created); err != nil { 66 66 + if err := rows.Scan(&publicKey.Key, &publicKey.Did, &publicKey.CreatedAt); err != nil { 67 67 return nil, err 68 68 } 69 69 keys = append(keys, publicKey) ··· 87 87 88 88 for rows.Next() { 89 89 var publicKey PublicKey 90 90 - if err := rows.Scan(&publicKey.Did, &publicKey.Key, &publicKey.Created); err != nil { 90 90 + if err := rows.Scan(&publicKey.Did, &publicKey.Key, &publicKey.CreatedAt); err != nil { 91 91 return nil, err 92 92 } 93 93 keys = append(keys, publicKey)

+2 -2

knotserver/jetstream.go

··· 43 43 return fmt.Errorf("failed to enforce permissions: %w", err) 44 44 } 45 45 46 46 - if err := h.e.AddMember(ThisServer, record.Member); err != nil { 46 46 + if err := h.e.AddMember(ThisServer, record.Subject); err != nil { 47 47 l.Error("failed to add member", "error", err) 48 48 return fmt.Errorf("failed to add member: %w", err) 49 49 } 50 50 - l.Info("added member from firehose", "member", record.Member) 50 50 + l.Info("added member from firehose", "member", record.Subject) 51 51 52 52 if err := h.db.AddDid(did); err != nil { 53 53 l.Error("failed to add did", "error", err)

+6 -7

lexicons/follow.json

··· 10 10 "record": { 11 11 "type": "object", 12 12 "required": [ 13 13 - "createdAt", 14 14 - "subject" 13 13 + "subject", 14 14 + "createdAt" 15 15 ], 16 16 "properties": { 17 17 + "subject": { 18 18 + "type": "string", 19 19 + "format": "did" 20 20 + }, 17 21 "createdAt": { 18 22 "type": "string", 19 23 "format": "datetime" 20 20 - }, 21 21 - "subject": { 22 22 - "type": "string", 23 23 - "format": "did" 24 24 } 25 25 } 26 26 } 27 27 } 28 28 } 29 29 } 30 30 -

+5 -1

lexicons/issue/comment.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": ["issue"], 12 12 + "required": [ 13 13 + "issue", 14 14 + "body", 15 15 + "createdAt" 16 16 + ], 13 17 "properties": { 14 18 "issue": { 15 19 "type": "string",

+7 -1

lexicons/issue/issue.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": ["repo", "issueId", "owner", "title"], 12 12 + "required": [ 13 13 + "repo", 14 14 + "issueId", 15 15 + "owner", 16 16 + "title", 17 17 + "createdAt" 18 18 + ], 13 19 "properties": { 14 20 "repo": { 15 21 "type": "string",

+4 -1

lexicons/issue/state.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": ["issue"], 12 12 + "required": [ 13 13 + "issue", 14 14 + "state" 15 15 + ], 13 16 "properties": { 14 17 "issue": { 15 18 "type": "string",

+5 -4

lexicons/member.json

··· 10 10 "record": { 11 11 "type": "object", 12 12 "required": [ 13 13 - "member", 14 14 - "domain" 13 13 + "subject", 14 14 + "domain", 15 15 + "createdAt" 15 16 ], 16 17 "properties": { 17 17 - "member": { 18 18 + "subject": { 18 19 "type": "string", 19 20 "format": "did" 20 21 }, ··· 22 23 "type": "string", 23 24 "description": "domain that this member now belongs to" 24 25 }, 25 25 - "addedAt": { 26 26 + "createdAt": { 26 27 "type": "string", 27 28 "format": "datetime" 28 29 }

+2 -3

lexicons/publicKey.json

··· 12 12 "required": [ 13 13 "key", 14 14 "name", 15 15 - "created" 15 15 + "createdAt" 16 16 ], 17 17 "properties": { 18 18 "key": { 19 19 "type": "string", 20 20 "maxLength": 4096, 21 21 - "maxGraphemes": 4096, 22 21 "description": "public key contents" 23 22 }, 24 23 "name": { ··· 26 25 "format": "string", 27 26 "description": "human-readable name for this key" 28 27 }, 29 29 - "created": { 28 28 + "createdAt": { 30 29 "type": "string", 31 30 "format": "datetime", 32 31 "description": "key upload timestamp"

+5 -1

lexicons/pulls/comment.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": ["pull"], 12 12 + "required": [ 13 13 + "pull", 14 14 + "body", 15 15 + "createdAt" 16 16 + ], 13 17 "properties": { 14 18 "pull": { 15 19 "type": "string",

+9 -6

lexicons/pulls/pull.json

··· 14 14 "targetBranch", 15 15 "pullId", 16 16 "title", 17 17 - "patch" 17 17 + "patch", 18 18 + "createdAt" 18 19 ], 19 20 "properties": { 20 21 "targetRepo": { ··· 33 34 "body": { 34 35 "type": "string" 35 36 }, 36 36 - "createdAt": { 37 37 - "type": "string", 38 38 - "format": "datetime" 39 39 - }, 40 37 "patch": { 41 38 "type": "string" 42 39 }, 43 40 "source": { 44 41 "type": "ref", 45 42 "ref": "#source" 43 43 + }, 44 44 + "createdAt": { 45 45 + "type": "string", 46 46 + "format": "datetime" 46 47 } 47 48 } 48 49 } 49 50 }, 50 51 "source": { 51 52 "type": "object", 52 52 - "required": ["branch"], 53 53 + "required": [ 54 54 + "branch" 55 55 + ], 53 56 "properties": { 54 57 "branch": { 55 58 "type": "string"

+4 -1

lexicons/pulls/state.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": ["pull"], 12 12 + "required": [ 13 13 + "pull", 14 14 + "status" 15 15 + ], 13 16 "properties": { 14 17 "pull": { 15 18 "type": "string",

+12 -7

lexicons/repo.json

··· 9 9 "key": "tid", 10 10 "record": { 11 11 "type": "object", 12 12 - "required": ["name", "knot", "owner"], 12 12 + "required": [ 13 13 + "name", 14 14 + "knot", 15 15 + "owner", 16 16 + "createdAt" 17 17 + ], 13 18 "properties": { 14 19 "name": { 15 20 "type": "string", ··· 23 28 "type": "string", 24 29 "description": "knot where the repo was created" 25 30 }, 26 26 - "addedAt": { 27 27 - "type": "string", 28 28 - "format": "datetime" 29 29 - }, 30 31 "description": { 31 32 "type": "string", 32 33 "format": "datetime", 33 33 - "minLength": 1, 34 34 - "maxLength": 140 34 34 + "minGraphemes": 1, 35 35 + "maxGraphemes": 140 35 36 }, 36 37 "source": { 37 38 "type": "string", 38 39 "format": "uri", 39 40 "description": "source of the repo" 41 41 + }, 42 42 + "createdAt": { 43 43 + "type": "string", 44 44 + "format": "datetime" 40 45 } 41 46 } 42 47 }

+6 -8

lexicons/star.json

··· 10 10 "record": { 11 11 "type": "object", 12 12 "required": [ 13 13 - "createdAt", 14 14 - "subject" 13 13 + "subject", 14 14 + "createdAt" 15 15 ], 16 16 "properties": { 17 17 - "createdAt": { 18 18 - "type": "string", 19 19 - "format": "datetime" 20 20 - }, 21 17 "subject": { 22 18 "type": "string", 23 19 "format": "at-uri" 20 20 + }, 21 21 + "createdAt": { 22 22 + "type": "string", 23 23 + "format": "datetime" 24 24 } 25 25 } 26 26 } 27 27 } 28 28 } 29 29 } 30 30 - 31 31 -