+2 -1

api/tangled/actorprofile.go

··· 28 // location: Free-form location text. 29 Location *string `json:"location,omitempty" cborgen:"location,omitempty"` 30 // pinnedRepositories: Any ATURI, it is up to appviews to validate these fields. 31 - PinnedRepositories []string `json:"pinnedRepositories,omitempty" cborgen:"pinnedRepositories,omitempty"` 0 32 // pronouns: Preferred gender pronouns. 33 Pronouns *string `json:"pronouns,omitempty" cborgen:"pronouns,omitempty"` 34 Stats []string `json:"stats,omitempty" cborgen:"stats,omitempty"`

··· 28 // location: Free-form location text. 29 Location *string `json:"location,omitempty" cborgen:"location,omitempty"` 30 // pinnedRepositories: Any ATURI, it is up to appviews to validate these fields. 31 + PinnedRepositories []string `json:"pinnedRepositories,omitempty" cborgen:"pinnedRepositories,omitempty"` 32 + PinnedRepositoryDids []string `json:"pinnedRepositoryDids,omitempty" cborgen:"pinnedRepositoryDids,omitempty"` 33 // pronouns: Preferred gender pronouns. 34 Pronouns *string `json:"pronouns,omitempty" cborgen:"pronouns,omitempty"` 35 Stats []string `json:"stats,omitempty" cborgen:"stats,omitempty"`

+902 -143

api/tangled/cbor_gen.go

··· 26 } 27 28 cw := cbg.NewCborWriter(w) 29 - fieldCount := 9 30 31 if t.Avatar == nil { 32 fieldCount-- ··· 45 } 46 47 if t.PinnedRepositories == nil { 0 0 0 0 48 fieldCount-- 49 } 50 ··· 317 318 } 319 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 320 return nil 321 } 322 ··· 345 346 n := extra 347 348 - nameBuf := make([]byte, 18) 349 for i := uint64(0); i < n; i++ { 350 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 351 if err != nil { ··· 593 594 } 595 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 596 597 default: 598 // Field doesn't exist on this type, so ignore it ··· 809 } 810 811 cw := cbg.NewCborWriter(w) 0 812 813 - if _, err := cw.Write([]byte{163}); err != nil { 0 0 0 0 0 0 0 0 814 return err 815 } 816 ··· 834 } 835 836 // t.Subject (string) (string) 837 - if len("subject") > 1000000 { 838 - return xerrors.Errorf("Value in field \"subject\" was too long") 839 - } 840 841 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 842 - return err 843 - } 844 - if _, err := cw.WriteString(string("subject")); err != nil { 845 - return err 846 - } 847 848 - if len(t.Subject) > 1000000 { 849 - return xerrors.Errorf("Value in field t.Subject was too long") 850 - } 0 0 0 0 0 0 0 0 0 0 0 0 851 852 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 853 - return err 854 - } 855 - if _, err := cw.WriteString(string(t.Subject)); err != nil { 856 - return err 0 0 857 } 858 859 // t.CreatedAt (string) (string) ··· 878 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 879 return err 880 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 881 return nil 882 } 883 ··· 906 907 n := extra 908 909 - nameBuf := make([]byte, 9) 910 for i := uint64(0); i < n; i++ { 911 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 912 if err != nil { ··· 937 case "subject": 938 939 { 940 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 941 if err != nil { 942 return err 943 } 0 0 0 0 944 945 - t.Subject = string(sval) 0 0 0 0 0 0 946 } 947 // t.CreatedAt (string) (string) 948 case "createdAt": ··· 955 956 t.CreatedAt = string(sval) 957 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 958 959 default: 960 // Field doesn't exist on this type, so ignore it ··· 973 } 974 975 cw := cbg.NewCborWriter(w) 0 976 977 - if _, err := cw.Write([]byte{168}); err != nil { 0 0 0 0 0 0 0 0 978 return err 979 } 980 ··· 1083 } 1084 1085 // t.RepoDid (string) (string) 1086 - if len("repoDid") > 1000000 { 1087 - return xerrors.Errorf("Value in field \"repoDid\" was too long") 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1088 } 1089 1090 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 1091 - return err 1092 - } 1093 - if _, err := cw.WriteString(string("repoDid")); err != nil { 1094 - return err 1095 - } 1096 1097 - if len(t.RepoDid) > 1000000 { 1098 - return xerrors.Errorf("Value in field t.RepoDid was too long") 1099 - } 1100 1101 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RepoDid))); err != nil { 1102 - return err 1103 - } 1104 - if _, err := cw.WriteString(string(t.RepoDid)); err != nil { 1105 - return err 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1106 } 1107 1108 // t.RepoName (string) (string) ··· 1262 case "repoDid": 1263 1264 { 1265 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1266 if err != nil { 1267 return err 1268 } 0 0 0 0 1269 1270 - t.RepoDid = string(sval) 0 0 0 0 0 0 1271 } 1272 // t.RepoName (string) (string) 1273 case "repoName": ··· 5302 } 5303 5304 cw := cbg.NewCborWriter(w) 0 5305 5306 - if _, err := cw.Write([]byte{164}); err != nil { 0 0 0 0 0 0 0 0 5307 return err 5308 } 5309 ··· 5354 } 5355 5356 // t.Repo (string) (string) 5357 - if len("repo") > 1000000 { 5358 - return xerrors.Errorf("Value in field \"repo\" was too long") 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5359 } 5360 5361 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 5362 - return err 5363 - } 5364 - if _, err := cw.WriteString(string("repo")); err != nil { 5365 - return err 5366 - } 0 0 0 0 0 0 0 5367 5368 - if len(t.Repo) > 1000000 { 5369 - return xerrors.Errorf("Value in field t.Repo was too long") 5370 - } 0 0 0 0 0 5371 5372 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 5373 - return err 5374 - } 5375 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 5376 - return err 0 0 5377 } 5378 5379 // t.DefaultBranch (string) (string) ··· 5468 case "repo": 5469 5470 { 5471 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 5472 if err != nil { 5473 return err 5474 } 0 0 0 0 5475 5476 - t.Repo = string(sval) 0 0 0 0 0 0 5477 } 5478 // t.DefaultBranch (string) (string) 5479 case "defaultBranch": ··· 5906 } 5907 5908 cw := cbg.NewCborWriter(w) 5909 - fieldCount := 10 5910 5911 if t.Description == nil { 5912 fieldCount-- 5913 } 5914 5915 if t.Labels == nil { 0 0 0 0 5916 fieldCount-- 5917 } 5918 ··· 6105 } 6106 } 6107 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6108 // t.Spindle (string) (string) 6109 if t.Spindle != nil { 6110 ··· 6401 6402 } 6403 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6404 // t.Spindle (string) (string) 6405 case "spindle": 6406 ··· 6493 } 6494 6495 cw := cbg.NewCborWriter(w) 6496 - fieldCount := 6 0 0 0 0 0 0 0 0 6497 6498 if t.Tag == nil { 6499 fieldCount-- ··· 6555 } 6556 6557 // t.Repo (string) (string) 6558 - if len("repo") > 1000000 { 6559 - return xerrors.Errorf("Value in field \"repo\" was too long") 6560 - } 0 0 6561 6562 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6563 - return err 6564 - } 6565 - if _, err := cw.WriteString(string("repo")); err != nil { 6566 - return err 6567 - } 6568 6569 - if len(t.Repo) > 1000000 { 6570 - return xerrors.Errorf("Value in field t.Repo was too long") 6571 - } 0 0 0 0 0 6572 6573 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6574 - return err 6575 - } 6576 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 6577 - return err 0 0 6578 } 6579 6580 // t.LexiconTypeID (string) (string) ··· 6594 } 6595 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil { 6596 return err 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6597 } 6598 6599 // t.Artifact (util.LexBlob) (struct) ··· 6716 case "repo": 6717 6718 { 6719 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6720 if err != nil { 6721 return err 6722 } 0 0 0 0 6723 6724 - t.Repo = string(sval) 0 0 0 0 0 0 6725 } 6726 // t.LexiconTypeID (string) (string) 6727 case "$type": ··· 6734 6735 t.LexiconTypeID = string(sval) 6736 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6737 // t.Artifact (util.LexBlob) (struct) 6738 case "artifact": 6739 ··· 6783 } 6784 6785 cw := cbg.NewCborWriter(w) 0 6786 6787 - if _, err := cw.Write([]byte{164}); err != nil { 6788 - return err 6789 } 6790 6791 - // t.Repo (string) (string) 6792 - if len("repo") > 1000000 { 6793 - return xerrors.Errorf("Value in field \"repo\" was too long") 6794 } 6795 6796 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6797 return err 6798 } 6799 - if _, err := cw.WriteString(string("repo")); err != nil { 6800 - return err 6801 - } 0 0 0 0 0 0 0 0 0 0 0 6802 6803 - if len(t.Repo) > 1000000 { 6804 - return xerrors.Errorf("Value in field t.Repo was too long") 6805 - } 0 0 0 0 0 6806 6807 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 6808 - return err 6809 - } 6810 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 6811 - return err 0 0 6812 } 6813 6814 // t.LexiconTypeID (string) (string) ··· 6830 return err 6831 } 6832 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6833 // t.Subject (string) (string) 6834 if len("subject") > 1000000 { 6835 return xerrors.Errorf("Value in field \"subject\" was too long") ··· 6923 case "repo": 6924 6925 { 6926 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 6927 if err != nil { 6928 return err 6929 } 0 0 0 0 6930 6931 - t.Repo = string(sval) 0 0 0 0 0 0 6932 } 6933 // t.LexiconTypeID (string) (string) 6934 case "$type": ··· 6941 6942 t.LexiconTypeID = string(sval) 6943 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6944 // t.Subject (string) (string) 6945 case "subject": 6946 ··· 6981 } 6982 6983 cw := cbg.NewCborWriter(w) 6984 - fieldCount := 7 6985 6986 if t.Body == nil { 6987 fieldCount-- ··· 6995 fieldCount-- 6996 } 6997 0 0 0 0 0 0 0 0 6998 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6999 return err 7000 } ··· 7032 } 7033 7034 // t.Repo (string) (string) 7035 - if len("repo") > 1000000 { 7036 - return xerrors.Errorf("Value in field \"repo\" was too long") 7037 - } 7038 7039 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 7040 - return err 7041 - } 7042 - if _, err := cw.WriteString(string("repo")); err != nil { 7043 - return err 7044 - } 7045 7046 - if len(t.Repo) > 1000000 { 7047 - return xerrors.Errorf("Value in field t.Repo was too long") 7048 - } 0 0 0 7049 7050 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 7051 - return err 7052 - } 7053 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 7054 - return err 0 0 0 0 0 0 0 0 0 0 0 7055 } 7056 7057 // t.LexiconTypeID (string) (string) ··· 7094 } 7095 if _, err := cw.WriteString(string(t.Title)); err != nil { 7096 return err 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7097 } 7098 7099 // t.Mentions ([]string) (slice) ··· 7259 case "repo": 7260 7261 { 7262 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 7263 if err != nil { 7264 return err 7265 } 0 0 0 0 7266 7267 - t.Repo = string(sval) 0 0 0 0 0 0 7268 } 7269 // t.LexiconTypeID (string) (string) 7270 case "$type": ··· 7287 } 7288 7289 t.Title = string(sval) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 7290 } 7291 // t.Mentions ([]string) (slice) 7292 case "mentions": ··· 8890 } 8891 8892 cw := cbg.NewCborWriter(w) 8893 - fieldCount := 3 8894 8895 if t.Repo == nil { 0 0 0 0 8896 fieldCount-- 8897 } 8898 ··· 8977 if _, err := cw.WriteString(string(t.Branch)); err != nil { 8978 return err 8979 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 8980 return nil 8981 } 8982 ··· 9005 9006 n := extra 9007 9008 - nameBuf := make([]byte, 6) 9009 for i := uint64(0); i < n; i++ { 9010 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 9011 if err != nil { ··· 9064 9065 t.Branch = string(sval) 9066 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9067 9068 default: 9069 // Field doesn't exist on this type, so ignore it ··· 9246 } 9247 9248 cw := cbg.NewCborWriter(w) 0 9249 9250 - if _, err := cw.Write([]byte{162}); err != nil { 9251 - return err 9252 } 9253 9254 - // t.Repo (string) (string) 9255 - if len("repo") > 1000000 { 9256 - return xerrors.Errorf("Value in field \"repo\" was too long") 9257 } 9258 9259 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 9260 - return err 9261 - } 9262 - if _, err := cw.WriteString(string("repo")); err != nil { 9263 return err 9264 } 9265 9266 - if len(t.Repo) > 1000000 { 9267 - return xerrors.Errorf("Value in field t.Repo was too long") 9268 - } 0 0 0 9269 9270 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Repo))); err != nil { 9271 - return err 9272 - } 9273 - if _, err := cw.WriteString(string(t.Repo)); err != nil { 9274 - return err 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9275 } 9276 9277 // t.Branch (string) (string) ··· 9296 if _, err := cw.WriteString(string(t.Branch)); err != nil { 9297 return err 9298 } 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9299 return nil 9300 } 9301 ··· 9324 9325 n := extra 9326 9327 - nameBuf := make([]byte, 6) 9328 for i := uint64(0); i < n; i++ { 9329 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 9330 if err != nil { ··· 9344 case "repo": 9345 9346 { 9347 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 9348 if err != nil { 9349 return err 9350 } 0 0 0 0 9351 9352 - t.Repo = string(sval) 0 0 0 0 0 0 9353 } 9354 // t.Branch (string) (string) 9355 case "branch": ··· 9361 } 9362 9363 t.Branch = string(sval) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 9364 } 9365 9366 default:

··· 26 } 27 28 cw := cbg.NewCborWriter(w) 29 + fieldCount := 10 30 31 if t.Avatar == nil { 32 fieldCount-- ··· 45 } 46 47 if t.PinnedRepositories == nil { 48 + fieldCount-- 49 + } 50 + 51 + if t.PinnedRepositoryDids == nil { 52 fieldCount-- 53 } 54 ··· 321 322 } 323 } 324 + 325 + // t.PinnedRepositoryDids ([]string) (slice) 326 + if t.PinnedRepositoryDids != nil { 327 + 328 + if len("pinnedRepositoryDids") > 1000000 { 329 + return xerrors.Errorf("Value in field \"pinnedRepositoryDids\" was too long") 330 + } 331 + 332 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("pinnedRepositoryDids"))); err != nil { 333 + return err 334 + } 335 + if _, err := cw.WriteString(string("pinnedRepositoryDids")); err != nil { 336 + return err 337 + } 338 + 339 + if len(t.PinnedRepositoryDids) > 8192 { 340 + return xerrors.Errorf("Slice value in field t.PinnedRepositoryDids was too long") 341 + } 342 + 343 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.PinnedRepositoryDids))); err != nil { 344 + return err 345 + } 346 + for _, v := range t.PinnedRepositoryDids { 347 + if len(v) > 1000000 { 348 + return xerrors.Errorf("Value in field v was too long") 349 + } 350 + 351 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 352 + return err 353 + } 354 + if _, err := cw.WriteString(string(v)); err != nil { 355 + return err 356 + } 357 + 358 + } 359 + } 360 return nil 361 } 362 ··· 385 386 n := extra 387 388 + nameBuf := make([]byte, 20) 389 for i := uint64(0); i < n; i++ { 390 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 391 if err != nil { ··· 633 634 } 635 } 636 + // t.PinnedRepositoryDids ([]string) (slice) 637 + case "pinnedRepositoryDids": 638 + 639 + maj, extra, err = cr.ReadHeader() 640 + if err != nil { 641 + return err 642 + } 643 + 644 + if extra > 8192 { 645 + return fmt.Errorf("t.PinnedRepositoryDids: array too large (%d)", extra) 646 + } 647 + 648 + if maj != cbg.MajArray { 649 + return fmt.Errorf("expected cbor array") 650 + } 651 + 652 + if extra > 0 { 653 + t.PinnedRepositoryDids = make([]string, extra) 654 + } 655 + 656 + for i := 0; i < int(extra); i++ { 657 + { 658 + var maj byte 659 + var extra uint64 660 + var err error 661 + _ = maj 662 + _ = extra 663 + _ = err 664 + 665 + { 666 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 667 + if err != nil { 668 + return err 669 + } 670 + 671 + t.PinnedRepositoryDids[i] = string(sval) 672 + } 673 + 674 + } 675 + } 676 677 default: 678 // Field doesn't exist on this type, so ignore it ··· 889 } 890 891 cw := cbg.NewCborWriter(w) 892 + fieldCount := 4 893 894 + if t.Subject == nil { 895 + fieldCount-- 896 + } 897 + 898 + if t.SubjectDid == nil { 899 + fieldCount-- 900 + } 901 + 902 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 903 return err 904 } 905 ··· 923 } 924 925 // t.Subject (string) (string) 926 + if t.Subject != nil { 0 0 927 928 + if len("subject") > 1000000 { 929 + return xerrors.Errorf("Value in field \"subject\" was too long") 930 + } 0 0 0 931 932 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 933 + return err 934 + } 935 + if _, err := cw.WriteString(string("subject")); err != nil { 936 + return err 937 + } 938 + 939 + if t.Subject == nil { 940 + if _, err := cw.Write(cbg.CborNull); err != nil { 941 + return err 942 + } 943 + } else { 944 + if len(*t.Subject) > 1000000 { 945 + return xerrors.Errorf("Value in field t.Subject was too long") 946 + } 947 948 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Subject))); err != nil { 949 + return err 950 + } 951 + if _, err := cw.WriteString(string(*t.Subject)); err != nil { 952 + return err 953 + } 954 + } 955 } 956 957 // t.CreatedAt (string) (string) ··· 976 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 977 return err 978 } 979 + 980 + // t.SubjectDid (string) (string) 981 + if t.SubjectDid != nil { 982 + 983 + if len("subjectDid") > 1000000 { 984 + return xerrors.Errorf("Value in field \"subjectDid\" was too long") 985 + } 986 + 987 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subjectDid"))); err != nil { 988 + return err 989 + } 990 + if _, err := cw.WriteString(string("subjectDid")); err != nil { 991 + return err 992 + } 993 + 994 + if t.SubjectDid == nil { 995 + if _, err := cw.Write(cbg.CborNull); err != nil { 996 + return err 997 + } 998 + } else { 999 + if len(*t.SubjectDid) > 1000000 { 1000 + return xerrors.Errorf("Value in field t.SubjectDid was too long") 1001 + } 1002 + 1003 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.SubjectDid))); err != nil { 1004 + return err 1005 + } 1006 + if _, err := cw.WriteString(string(*t.SubjectDid)); err != nil { 1007 + return err 1008 + } 1009 + } 1010 + } 1011 return nil 1012 } 1013 ··· 1036 1037 n := extra 1038 1039 + nameBuf := make([]byte, 10) 1040 for i := uint64(0); i < n; i++ { 1041 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1042 if err != nil { ··· 1067 case "subject": 1068 1069 { 1070 + b, err := cr.ReadByte() 1071 if err != nil { 1072 return err 1073 } 1074 + if b != cbg.CborNull[0] { 1075 + if err := cr.UnreadByte(); err != nil { 1076 + return err 1077 + } 1078 1079 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1080 + if err != nil { 1081 + return err 1082 + } 1083 + 1084 + t.Subject = (*string)(&sval) 1085 + } 1086 } 1087 // t.CreatedAt (string) (string) 1088 case "createdAt": ··· 1095 1096 t.CreatedAt = string(sval) 1097 } 1098 + // t.SubjectDid (string) (string) 1099 + case "subjectDid": 1100 + 1101 + { 1102 + b, err := cr.ReadByte() 1103 + if err != nil { 1104 + return err 1105 + } 1106 + if b != cbg.CborNull[0] { 1107 + if err := cr.UnreadByte(); err != nil { 1108 + return err 1109 + } 1110 + 1111 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1112 + if err != nil { 1113 + return err 1114 + } 1115 + 1116 + t.SubjectDid = (*string)(&sval) 1117 + } 1118 + } 1119 1120 default: 1121 // Field doesn't exist on this type, so ignore it ··· 1134 } 1135 1136 cw := cbg.NewCborWriter(w) 1137 + fieldCount := 9 1138 1139 + if t.OwnerDid == nil { 1140 + fieldCount-- 1141 + } 1142 + 1143 + if t.RepoDid == nil { 1144 + fieldCount-- 1145 + } 1146 + 1147 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 1148 return err 1149 } 1150 ··· 1253 } 1254 1255 // t.RepoDid (string) (string) 1256 + if t.RepoDid != nil { 1257 + 1258 + if len("repoDid") > 1000000 { 1259 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 1260 + } 1261 + 1262 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 1263 + return err 1264 + } 1265 + if _, err := cw.WriteString(string("repoDid")); err != nil { 1266 + return err 1267 + } 1268 + 1269 + if t.RepoDid == nil { 1270 + if _, err := cw.Write(cbg.CborNull); err != nil { 1271 + return err 1272 + } 1273 + } else { 1274 + if len(*t.RepoDid) > 1000000 { 1275 + return xerrors.Errorf("Value in field t.RepoDid was too long") 1276 + } 1277 + 1278 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 1279 + return err 1280 + } 1281 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 1282 + return err 1283 + } 1284 + } 1285 } 1286 1287 + // t.OwnerDid (string) (string) 1288 + if t.OwnerDid != nil { 0 0 0 0 1289 1290 + if len("ownerDid") > 1000000 { 1291 + return xerrors.Errorf("Value in field \"ownerDid\" was too long") 1292 + } 1293 1294 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("ownerDid"))); err != nil { 1295 + return err 1296 + } 1297 + if _, err := cw.WriteString(string("ownerDid")); err != nil { 1298 + return err 1299 + } 1300 + 1301 + if t.OwnerDid == nil { 1302 + if _, err := cw.Write(cbg.CborNull); err != nil { 1303 + return err 1304 + } 1305 + } else { 1306 + if len(*t.OwnerDid) > 1000000 { 1307 + return xerrors.Errorf("Value in field t.OwnerDid was too long") 1308 + } 1309 + 1310 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.OwnerDid))); err != nil { 1311 + return err 1312 + } 1313 + if _, err := cw.WriteString(string(*t.OwnerDid)); err != nil { 1314 + return err 1315 + } 1316 + } 1317 } 1318 1319 // t.RepoName (string) (string) ··· 1473 case "repoDid": 1474 1475 { 1476 + b, err := cr.ReadByte() 1477 + if err != nil { 1478 + return err 1479 + } 1480 + if b != cbg.CborNull[0] { 1481 + if err := cr.UnreadByte(); err != nil { 1482 + return err 1483 + } 1484 + 1485 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1486 + if err != nil { 1487 + return err 1488 + } 1489 + 1490 + t.RepoDid = (*string)(&sval) 1491 + } 1492 + } 1493 + // t.OwnerDid (string) (string) 1494 + case "ownerDid": 1495 + 1496 + { 1497 + b, err := cr.ReadByte() 1498 if err != nil { 1499 return err 1500 } 1501 + if b != cbg.CborNull[0] { 1502 + if err := cr.UnreadByte(); err != nil { 1503 + return err 1504 + } 1505 1506 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1507 + if err != nil { 1508 + return err 1509 + } 1510 + 1511 + t.OwnerDid = (*string)(&sval) 1512 + } 1513 } 1514 // t.RepoName (string) (string) 1515 case "repoName": ··· 5544 } 5545 5546 cw := cbg.NewCborWriter(w) 5547 + fieldCount := 5 5548 5549 + if t.Repo == nil { 5550 + fieldCount-- 5551 + } 5552 + 5553 + if t.RepoDid == nil { 5554 + fieldCount-- 5555 + } 5556 + 5557 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 5558 return err 5559 } 5560 ··· 5605 } 5606 5607 // t.Repo (string) (string) 5608 + if t.Repo != nil { 5609 + 5610 + if len("repo") > 1000000 { 5611 + return xerrors.Errorf("Value in field \"repo\" was too long") 5612 + } 5613 + 5614 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 5615 + return err 5616 + } 5617 + if _, err := cw.WriteString(string("repo")); err != nil { 5618 + return err 5619 + } 5620 + 5621 + if t.Repo == nil { 5622 + if _, err := cw.Write(cbg.CborNull); err != nil { 5623 + return err 5624 + } 5625 + } else { 5626 + if len(*t.Repo) > 1000000 { 5627 + return xerrors.Errorf("Value in field t.Repo was too long") 5628 + } 5629 + 5630 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 5631 + return err 5632 + } 5633 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 5634 + return err 5635 + } 5636 + } 5637 } 5638 5639 + // t.RepoDid (string) (string) 5640 + if t.RepoDid != nil { 5641 + 5642 + if len("repoDid") > 1000000 { 5643 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 5644 + } 5645 + 5646 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 5647 + return err 5648 + } 5649 + if _, err := cw.WriteString(string("repoDid")); err != nil { 5650 + return err 5651 + } 5652 5653 + if t.RepoDid == nil { 5654 + if _, err := cw.Write(cbg.CborNull); err != nil { 5655 + return err 5656 + } 5657 + } else { 5658 + if len(*t.RepoDid) > 1000000 { 5659 + return xerrors.Errorf("Value in field t.RepoDid was too long") 5660 + } 5661 5662 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 5663 + return err 5664 + } 5665 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 5666 + return err 5667 + } 5668 + } 5669 } 5670 5671 // t.DefaultBranch (string) (string) ··· 5760 case "repo": 5761 5762 { 5763 + b, err := cr.ReadByte() 5764 + if err != nil { 5765 + return err 5766 + } 5767 + if b != cbg.CborNull[0] { 5768 + if err := cr.UnreadByte(); err != nil { 5769 + return err 5770 + } 5771 + 5772 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5773 + if err != nil { 5774 + return err 5775 + } 5776 + 5777 + t.Repo = (*string)(&sval) 5778 + } 5779 + } 5780 + // t.RepoDid (string) (string) 5781 + case "repoDid": 5782 + 5783 + { 5784 + b, err := cr.ReadByte() 5785 if err != nil { 5786 return err 5787 } 5788 + if b != cbg.CborNull[0] { 5789 + if err := cr.UnreadByte(); err != nil { 5790 + return err 5791 + } 5792 5793 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 5794 + if err != nil { 5795 + return err 5796 + } 5797 + 5798 + t.RepoDid = (*string)(&sval) 5799 + } 5800 } 5801 // t.DefaultBranch (string) (string) 5802 case "defaultBranch": ··· 6229 } 6230 6231 cw := cbg.NewCborWriter(w) 6232 + fieldCount := 11 6233 6234 if t.Description == nil { 6235 fieldCount-- 6236 } 6237 6238 if t.Labels == nil { 6239 + fieldCount-- 6240 + } 6241 + 6242 + if t.RepoDid == nil { 6243 fieldCount-- 6244 } 6245 ··· 6432 } 6433 } 6434 6435 + // t.RepoDid (string) (string) 6436 + if t.RepoDid != nil { 6437 + 6438 + if len("repoDid") > 1000000 { 6439 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 6440 + } 6441 + 6442 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 6443 + return err 6444 + } 6445 + if _, err := cw.WriteString(string("repoDid")); err != nil { 6446 + return err 6447 + } 6448 + 6449 + if t.RepoDid == nil { 6450 + if _, err := cw.Write(cbg.CborNull); err != nil { 6451 + return err 6452 + } 6453 + } else { 6454 + if len(*t.RepoDid) > 1000000 { 6455 + return xerrors.Errorf("Value in field t.RepoDid was too long") 6456 + } 6457 + 6458 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 6459 + return err 6460 + } 6461 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 6462 + return err 6463 + } 6464 + } 6465 + } 6466 + 6467 // t.Spindle (string) (string) 6468 if t.Spindle != nil { 6469 ··· 6760 6761 } 6762 } 6763 + // t.RepoDid (string) (string) 6764 + case "repoDid": 6765 + 6766 + { 6767 + b, err := cr.ReadByte() 6768 + if err != nil { 6769 + return err 6770 + } 6771 + if b != cbg.CborNull[0] { 6772 + if err := cr.UnreadByte(); err != nil { 6773 + return err 6774 + } 6775 + 6776 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6777 + if err != nil { 6778 + return err 6779 + } 6780 + 6781 + t.RepoDid = (*string)(&sval) 6782 + } 6783 + } 6784 // t.Spindle (string) (string) 6785 case "spindle": 6786 ··· 6873 } 6874 6875 cw := cbg.NewCborWriter(w) 6876 + fieldCount := 7 6877 + 6878 + if t.Repo == nil { 6879 + fieldCount-- 6880 + } 6881 + 6882 + if t.RepoDid == nil { 6883 + fieldCount-- 6884 + } 6885 6886 if t.Tag == nil { 6887 fieldCount-- ··· 6943 } 6944 6945 // t.Repo (string) (string) 6946 + if t.Repo != nil { 6947 + 6948 + if len("repo") > 1000000 { 6949 + return xerrors.Errorf("Value in field \"repo\" was too long") 6950 + } 6951 6952 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 6953 + return err 6954 + } 6955 + if _, err := cw.WriteString(string("repo")); err != nil { 6956 + return err 6957 + } 6958 6959 + if t.Repo == nil { 6960 + if _, err := cw.Write(cbg.CborNull); err != nil { 6961 + return err 6962 + } 6963 + } else { 6964 + if len(*t.Repo) > 1000000 { 6965 + return xerrors.Errorf("Value in field t.Repo was too long") 6966 + } 6967 6968 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 6969 + return err 6970 + } 6971 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 6972 + return err 6973 + } 6974 + } 6975 } 6976 6977 // t.LexiconTypeID (string) (string) ··· 6991 } 6992 if _, err := cw.WriteString(string("sh.tangled.repo.artifact")); err != nil { 6993 return err 6994 + } 6995 + 6996 + // t.RepoDid (string) (string) 6997 + if t.RepoDid != nil { 6998 + 6999 + if len("repoDid") > 1000000 { 7000 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 7001 + } 7002 + 7003 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 7004 + return err 7005 + } 7006 + if _, err := cw.WriteString(string("repoDid")); err != nil { 7007 + return err 7008 + } 7009 + 7010 + if t.RepoDid == nil { 7011 + if _, err := cw.Write(cbg.CborNull); err != nil { 7012 + return err 7013 + } 7014 + } else { 7015 + if len(*t.RepoDid) > 1000000 { 7016 + return xerrors.Errorf("Value in field t.RepoDid was too long") 7017 + } 7018 + 7019 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 7020 + return err 7021 + } 7022 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 7023 + return err 7024 + } 7025 + } 7026 } 7027 7028 // t.Artifact (util.LexBlob) (struct) ··· 7145 case "repo": 7146 7147 { 7148 + b, err := cr.ReadByte() 7149 if err != nil { 7150 return err 7151 } 7152 + if b != cbg.CborNull[0] { 7153 + if err := cr.UnreadByte(); err != nil { 7154 + return err 7155 + } 7156 7157 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7158 + if err != nil { 7159 + return err 7160 + } 7161 + 7162 + t.Repo = (*string)(&sval) 7163 + } 7164 } 7165 // t.LexiconTypeID (string) (string) 7166 case "$type": ··· 7173 7174 t.LexiconTypeID = string(sval) 7175 } 7176 + // t.RepoDid (string) (string) 7177 + case "repoDid": 7178 + 7179 + { 7180 + b, err := cr.ReadByte() 7181 + if err != nil { 7182 + return err 7183 + } 7184 + if b != cbg.CborNull[0] { 7185 + if err := cr.UnreadByte(); err != nil { 7186 + return err 7187 + } 7188 + 7189 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7190 + if err != nil { 7191 + return err 7192 + } 7193 + 7194 + t.RepoDid = (*string)(&sval) 7195 + } 7196 + } 7197 // t.Artifact (util.LexBlob) (struct) 7198 case "artifact": 7199 ··· 7243 } 7244 7245 cw := cbg.NewCborWriter(w) 7246 + fieldCount := 5 7247 7248 + if t.Repo == nil { 7249 + fieldCount-- 7250 } 7251 7252 + if t.RepoDid == nil { 7253 + fieldCount-- 0 7254 } 7255 7256 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7257 return err 7258 } 7259 + 7260 + // t.Repo (string) (string) 7261 + if t.Repo != nil { 7262 + 7263 + if len("repo") > 1000000 { 7264 + return xerrors.Errorf("Value in field \"repo\" was too long") 7265 + } 7266 + 7267 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 7268 + return err 7269 + } 7270 + if _, err := cw.WriteString(string("repo")); err != nil { 7271 + return err 7272 + } 7273 7274 + if t.Repo == nil { 7275 + if _, err := cw.Write(cbg.CborNull); err != nil { 7276 + return err 7277 + } 7278 + } else { 7279 + if len(*t.Repo) > 1000000 { 7280 + return xerrors.Errorf("Value in field t.Repo was too long") 7281 + } 7282 7283 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 7284 + return err 7285 + } 7286 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 7287 + return err 7288 + } 7289 + } 7290 } 7291 7292 // t.LexiconTypeID (string) (string) ··· 7308 return err 7309 } 7310 7311 + // t.RepoDid (string) (string) 7312 + if t.RepoDid != nil { 7313 + 7314 + if len("repoDid") > 1000000 { 7315 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 7316 + } 7317 + 7318 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 7319 + return err 7320 + } 7321 + if _, err := cw.WriteString(string("repoDid")); err != nil { 7322 + return err 7323 + } 7324 + 7325 + if t.RepoDid == nil { 7326 + if _, err := cw.Write(cbg.CborNull); err != nil { 7327 + return err 7328 + } 7329 + } else { 7330 + if len(*t.RepoDid) > 1000000 { 7331 + return xerrors.Errorf("Value in field t.RepoDid was too long") 7332 + } 7333 + 7334 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 7335 + return err 7336 + } 7337 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 7338 + return err 7339 + } 7340 + } 7341 + } 7342 + 7343 // t.Subject (string) (string) 7344 if len("subject") > 1000000 { 7345 return xerrors.Errorf("Value in field \"subject\" was too long") ··· 7433 case "repo": 7434 7435 { 7436 + b, err := cr.ReadByte() 7437 if err != nil { 7438 return err 7439 } 7440 + if b != cbg.CborNull[0] { 7441 + if err := cr.UnreadByte(); err != nil { 7442 + return err 7443 + } 7444 7445 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7446 + if err != nil { 7447 + return err 7448 + } 7449 + 7450 + t.Repo = (*string)(&sval) 7451 + } 7452 } 7453 // t.LexiconTypeID (string) (string) 7454 case "$type": ··· 7461 7462 t.LexiconTypeID = string(sval) 7463 } 7464 + // t.RepoDid (string) (string) 7465 + case "repoDid": 7466 + 7467 + { 7468 + b, err := cr.ReadByte() 7469 + if err != nil { 7470 + return err 7471 + } 7472 + if b != cbg.CborNull[0] { 7473 + if err := cr.UnreadByte(); err != nil { 7474 + return err 7475 + } 7476 + 7477 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7478 + if err != nil { 7479 + return err 7480 + } 7481 + 7482 + t.RepoDid = (*string)(&sval) 7483 + } 7484 + } 7485 // t.Subject (string) (string) 7486 case "subject": 7487 ··· 7522 } 7523 7524 cw := cbg.NewCborWriter(w) 7525 + fieldCount := 8 7526 7527 if t.Body == nil { 7528 fieldCount-- ··· 7536 fieldCount-- 7537 } 7538 7539 + if t.Repo == nil { 7540 + fieldCount-- 7541 + } 7542 + 7543 + if t.RepoDid == nil { 7544 + fieldCount-- 7545 + } 7546 + 7547 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7548 return err 7549 } ··· 7581 } 7582 7583 // t.Repo (string) (string) 7584 + if t.Repo != nil { 0 0 7585 7586 + if len("repo") > 1000000 { 7587 + return xerrors.Errorf("Value in field \"repo\" was too long") 7588 + } 0 0 0 7589 7590 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 7591 + return err 7592 + } 7593 + if _, err := cw.WriteString(string("repo")); err != nil { 7594 + return err 7595 + } 7596 7597 + if t.Repo == nil { 7598 + if _, err := cw.Write(cbg.CborNull); err != nil { 7599 + return err 7600 + } 7601 + } else { 7602 + if len(*t.Repo) > 1000000 { 7603 + return xerrors.Errorf("Value in field t.Repo was too long") 7604 + } 7605 + 7606 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 7607 + return err 7608 + } 7609 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 7610 + return err 7611 + } 7612 + } 7613 } 7614 7615 // t.LexiconTypeID (string) (string) ··· 7652 } 7653 if _, err := cw.WriteString(string(t.Title)); err != nil { 7654 return err 7655 + } 7656 + 7657 + // t.RepoDid (string) (string) 7658 + if t.RepoDid != nil { 7659 + 7660 + if len("repoDid") > 1000000 { 7661 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 7662 + } 7663 + 7664 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 7665 + return err 7666 + } 7667 + if _, err := cw.WriteString(string("repoDid")); err != nil { 7668 + return err 7669 + } 7670 + 7671 + if t.RepoDid == nil { 7672 + if _, err := cw.Write(cbg.CborNull); err != nil { 7673 + return err 7674 + } 7675 + } else { 7676 + if len(*t.RepoDid) > 1000000 { 7677 + return xerrors.Errorf("Value in field t.RepoDid was too long") 7678 + } 7679 + 7680 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 7681 + return err 7682 + } 7683 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 7684 + return err 7685 + } 7686 + } 7687 } 7688 7689 // t.Mentions ([]string) (slice) ··· 7849 case "repo": 7850 7851 { 7852 + b, err := cr.ReadByte() 7853 if err != nil { 7854 return err 7855 } 7856 + if b != cbg.CborNull[0] { 7857 + if err := cr.UnreadByte(); err != nil { 7858 + return err 7859 + } 7860 7861 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7862 + if err != nil { 7863 + return err 7864 + } 7865 + 7866 + t.Repo = (*string)(&sval) 7867 + } 7868 } 7869 // t.LexiconTypeID (string) (string) 7870 case "$type": ··· 7887 } 7888 7889 t.Title = string(sval) 7890 + } 7891 + // t.RepoDid (string) (string) 7892 + case "repoDid": 7893 + 7894 + { 7895 + b, err := cr.ReadByte() 7896 + if err != nil { 7897 + return err 7898 + } 7899 + if b != cbg.CborNull[0] { 7900 + if err := cr.UnreadByte(); err != nil { 7901 + return err 7902 + } 7903 + 7904 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7905 + if err != nil { 7906 + return err 7907 + } 7908 + 7909 + t.RepoDid = (*string)(&sval) 7910 + } 7911 } 7912 // t.Mentions ([]string) (slice) 7913 case "mentions": ··· 9511 } 9512 9513 cw := cbg.NewCborWriter(w) 9514 + fieldCount := 4 9515 9516 if t.Repo == nil { 9517 + fieldCount-- 9518 + } 9519 + 9520 + if t.RepoDid == nil { 9521 fieldCount-- 9522 } 9523 ··· 9602 if _, err := cw.WriteString(string(t.Branch)); err != nil { 9603 return err 9604 } 9605 + 9606 + // t.RepoDid (string) (string) 9607 + if t.RepoDid != nil { 9608 + 9609 + if len("repoDid") > 1000000 { 9610 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 9611 + } 9612 + 9613 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 9614 + return err 9615 + } 9616 + if _, err := cw.WriteString(string("repoDid")); err != nil { 9617 + return err 9618 + } 9619 + 9620 + if t.RepoDid == nil { 9621 + if _, err := cw.Write(cbg.CborNull); err != nil { 9622 + return err 9623 + } 9624 + } else { 9625 + if len(*t.RepoDid) > 1000000 { 9626 + return xerrors.Errorf("Value in field t.RepoDid was too long") 9627 + } 9628 + 9629 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 9630 + return err 9631 + } 9632 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 9633 + return err 9634 + } 9635 + } 9636 + } 9637 return nil 9638 } 9639 ··· 9662 9663 n := extra 9664 9665 + nameBuf := make([]byte, 7) 9666 for i := uint64(0); i < n; i++ { 9667 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 9668 if err != nil { ··· 9721 9722 t.Branch = string(sval) 9723 } 9724 + // t.RepoDid (string) (string) 9725 + case "repoDid": 9726 + 9727 + { 9728 + b, err := cr.ReadByte() 9729 + if err != nil { 9730 + return err 9731 + } 9732 + if b != cbg.CborNull[0] { 9733 + if err := cr.UnreadByte(); err != nil { 9734 + return err 9735 + } 9736 + 9737 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 9738 + if err != nil { 9739 + return err 9740 + } 9741 + 9742 + t.RepoDid = (*string)(&sval) 9743 + } 9744 + } 9745 9746 default: 9747 // Field doesn't exist on this type, so ignore it ··· 9924 } 9925 9926 cw := cbg.NewCborWriter(w) 9927 + fieldCount := 3 9928 9929 + if t.Repo == nil { 9930 + fieldCount-- 9931 } 9932 9933 + if t.RepoDid == nil { 9934 + fieldCount-- 0 9935 } 9936 9937 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 0 0 0 9938 return err 9939 } 9940 9941 + // t.Repo (string) (string) 9942 + if t.Repo != nil { 9943 + 9944 + if len("repo") > 1000000 { 9945 + return xerrors.Errorf("Value in field \"repo\" was too long") 9946 + } 9947 9948 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repo"))); err != nil { 9949 + return err 9950 + } 9951 + if _, err := cw.WriteString(string("repo")); err != nil { 9952 + return err 9953 + } 9954 + 9955 + if t.Repo == nil { 9956 + if _, err := cw.Write(cbg.CborNull); err != nil { 9957 + return err 9958 + } 9959 + } else { 9960 + if len(*t.Repo) > 1000000 { 9961 + return xerrors.Errorf("Value in field t.Repo was too long") 9962 + } 9963 + 9964 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Repo))); err != nil { 9965 + return err 9966 + } 9967 + if _, err := cw.WriteString(string(*t.Repo)); err != nil { 9968 + return err 9969 + } 9970 + } 9971 } 9972 9973 // t.Branch (string) (string) ··· 9992 if _, err := cw.WriteString(string(t.Branch)); err != nil { 9993 return err 9994 } 9995 + 9996 + // t.RepoDid (string) (string) 9997 + if t.RepoDid != nil { 9998 + 9999 + if len("repoDid") > 1000000 { 10000 + return xerrors.Errorf("Value in field \"repoDid\" was too long") 10001 + } 10002 + 10003 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("repoDid"))); err != nil { 10004 + return err 10005 + } 10006 + if _, err := cw.WriteString(string("repoDid")); err != nil { 10007 + return err 10008 + } 10009 + 10010 + if t.RepoDid == nil { 10011 + if _, err := cw.Write(cbg.CborNull); err != nil { 10012 + return err 10013 + } 10014 + } else { 10015 + if len(*t.RepoDid) > 1000000 { 10016 + return xerrors.Errorf("Value in field t.RepoDid was too long") 10017 + } 10018 + 10019 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.RepoDid))); err != nil { 10020 + return err 10021 + } 10022 + if _, err := cw.WriteString(string(*t.RepoDid)); err != nil { 10023 + return err 10024 + } 10025 + } 10026 + } 10027 return nil 10028 } 10029 ··· 10052 10053 n := extra 10054 10055 + nameBuf := make([]byte, 7) 10056 for i := uint64(0); i < n; i++ { 10057 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 10058 if err != nil { ··· 10072 case "repo": 10073 10074 { 10075 + b, err := cr.ReadByte() 10076 if err != nil { 10077 return err 10078 } 10079 + if b != cbg.CborNull[0] { 10080 + if err := cr.UnreadByte(); err != nil { 10081 + return err 10082 + } 10083 10084 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10085 + if err != nil { 10086 + return err 10087 + } 10088 + 10089 + t.Repo = (*string)(&sval) 10090 + } 10091 } 10092 // t.Branch (string) (string) 10093 case "branch": ··· 10099 } 10100 10101 t.Branch = string(sval) 10102 + } 10103 + // t.RepoDid (string) (string) 10104 + case "repoDid": 10105 + 10106 + { 10107 + b, err := cr.ReadByte() 10108 + if err != nil { 10109 + return err 10110 + } 10111 + if b != cbg.CborNull[0] { 10112 + if err := cr.UnreadByte(); err != nil { 10113 + return err 10114 + } 10115 + 10116 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 10117 + if err != nil { 10118 + return err 10119 + } 10120 + 10121 + t.RepoDid = (*string)(&sval) 10122 + } 10123 } 10124 10125 default:

+4 -3

api/tangled/feedstar.go

··· 17 } // 18 // RECORDTYPE: FeedStar 19 type FeedStar struct { 20 - LexiconTypeID string `json:"$type,const=sh.tangled.feed.star" cborgen:"$type,const=sh.tangled.feed.star"` 21 - CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 - Subject string `json:"subject" cborgen:"subject"` 0 23 }

··· 17 } // 18 // RECORDTYPE: FeedStar 19 type FeedStar struct { 20 + LexiconTypeID string `json:"$type,const=sh.tangled.feed.star" cborgen:"$type,const=sh.tangled.feed.star"` 21 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 + Subject *string `json:"subject,omitempty" cborgen:"subject,omitempty"` 23 + SubjectDid *string `json:"subjectDid,omitempty" cborgen:"subjectDid,omitempty"` 24 }

+4 -2

api/tangled/gitrefUpdate.go

··· 25 NewSha string `json:"newSha" cborgen:"newSha"` 26 // oldSha: old SHA of this ref 27 OldSha string `json:"oldSha" cborgen:"oldSha"` 0 0 28 // ref: Ref being updated 29 Ref string `json:"ref" cborgen:"ref"` 30 - // repoDid: did of the owner of the repo 31 - RepoDid string `json:"repoDid" cborgen:"repoDid"` 32 // repoName: name of the repo 33 RepoName string `json:"repoName" cborgen:"repoName"` 34 }

··· 25 NewSha string `json:"newSha" cborgen:"newSha"` 26 // oldSha: old SHA of this ref 27 OldSha string `json:"oldSha" cborgen:"oldSha"` 28 + // ownerDid: did of the owner of the repo 29 + OwnerDid *string `json:"ownerDid,omitempty" cborgen:"ownerDid,omitempty"` 30 // ref: Ref being updated 31 Ref string `json:"ref" cborgen:"ref"` 32 + // repoDid: DID of the repo itself 33 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 34 // repoName: name of the repo 35 RepoName string `json:"repoName" cborgen:"repoName"` 36 }

+2 -1

api/tangled/repoartifact.go

··· 25 // name: name of the artifact 26 Name string `json:"name" cborgen:"name"` 27 // repo: repo that this artifact is being uploaded to 28 - Repo string `json:"repo" cborgen:"repo"` 0 29 // tag: hash of the tag object that this artifact is attached to (only annotated tags are supported) 30 Tag util.LexBytes `json:"tag,omitempty" cborgen:"tag,omitempty"` 31 }

··· 25 // name: name of the artifact 26 Name string `json:"name" cborgen:"name"` 27 // repo: repo that this artifact is being uploaded to 28 + Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 29 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 30 // tag: hash of the tag object that this artifact is attached to (only annotated tags are supported) 31 Tag util.LexBytes `json:"tag,omitempty" cborgen:"tag,omitempty"` 32 }

+3 -2

api/tangled/repocollaborator.go

··· 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.collaborator" cborgen:"$type,const=sh.tangled.repo.collaborator"` 21 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 // repo: repo to add this user to 23 - Repo string `json:"repo" cborgen:"repo"` 24 - Subject string `json:"subject" cborgen:"subject"` 0 25 }

··· 20 LexiconTypeID string `json:"$type,const=sh.tangled.repo.collaborator" cborgen:"$type,const=sh.tangled.repo.collaborator"` 21 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 22 // repo: repo to add this user to 23 + Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 24 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 25 + Subject string `json:"subject" cborgen:"subject"` 26 }

+14 -4

api/tangled/repocreate.go

··· 18 type RepoCreate_Input struct { 19 // defaultBranch: Default branch to push to 20 DefaultBranch *string `json:"defaultBranch,omitempty" cborgen:"defaultBranch,omitempty"` 0 0 0 0 21 // rkey: Rkey of the repository record 22 Rkey string `json:"rkey" cborgen:"rkey"` 23 // source: A source URL to clone from, populate this when forking or importing a repository. 24 Source *string `json:"source,omitempty" cborgen:"source,omitempty"` 0 0 0 0 0 25 } 26 27 // RepoCreate calls the XRPC method "sh.tangled.repo.create". 28 - func RepoCreate(ctx context.Context, c util.LexClient, input *RepoCreate_Input) error { 29 - if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.create", nil, input, nil); err != nil { 30 - return err 0 31 } 32 33 - return nil 34 }

··· 18 type RepoCreate_Input struct { 19 // defaultBranch: Default branch to push to 20 DefaultBranch *string `json:"defaultBranch,omitempty" cborgen:"defaultBranch,omitempty"` 21 + // name: Name of the repository 22 + Name string `json:"name" cborgen:"name"` 23 + // repoDid: Optional user-provided did:web to use as the repo identity instead of minting a did:plc. 24 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 25 // rkey: Rkey of the repository record 26 Rkey string `json:"rkey" cborgen:"rkey"` 27 // source: A source URL to clone from, populate this when forking or importing a repository. 28 Source *string `json:"source,omitempty" cborgen:"source,omitempty"` 29 + } 30 + 31 + // RepoCreate_Output is the output of a sh.tangled.repo.create call. 32 + type RepoCreate_Output struct { 33 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 34 } 35 36 // RepoCreate calls the XRPC method "sh.tangled.repo.create". 37 + func RepoCreate(ctx context.Context, c util.LexClient, input *RepoCreate_Input) (*RepoCreate_Output, error) { 38 + var out RepoCreate_Output 39 + if err := c.LexDo(ctx, util.Procedure, "application/json", "sh.tangled.repo.create", nil, input, &out); err != nil { 40 + return nil, err 41 } 42 43 + return &out, nil 44 }

+2 -1

api/tangled/repoissue.go

··· 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 References []string `json:"references,omitempty" cborgen:"references,omitempty"` 25 - Repo string `json:"repo" cborgen:"repo"` 0 26 Title string `json:"title" cborgen:"title"` 27 }

··· 22 CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 References []string `json:"references,omitempty" cborgen:"references,omitempty"` 25 + Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 26 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 27 Title string `json:"title" cborgen:"title"` 28 }

+7 -5

api/tangled/repopull.go

··· 33 34 // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema. 35 type RepoPull_Source struct { 36 - Branch string `json:"branch" cborgen:"branch"` 37 - Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 38 - Sha string `json:"sha" cborgen:"sha"` 0 39 } 40 41 // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema. 42 type RepoPull_Target struct { 43 - Branch string `json:"branch" cborgen:"branch"` 44 - Repo string `json:"repo" cborgen:"repo"` 0 45 }

··· 33 34 // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema. 35 type RepoPull_Source struct { 36 + Branch string `json:"branch" cborgen:"branch"` 37 + Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 38 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 39 + Sha string `json:"sha" cborgen:"sha"` 40 } 41 42 // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema. 43 type RepoPull_Target struct { 44 + Branch string `json:"branch" cborgen:"branch"` 45 + Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 46 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 47 }

+6 -4

api/tangled/tangledpipeline.go

··· 66 67 // Pipeline_TriggerRepo is a "triggerRepo" in the sh.tangled.pipeline schema. 68 type Pipeline_TriggerRepo struct { 69 - DefaultBranch string `json:"defaultBranch" cborgen:"defaultBranch"` 70 - Did string `json:"did" cborgen:"did"` 71 - Knot string `json:"knot" cborgen:"knot"` 72 - Repo string `json:"repo" cborgen:"repo"` 0 0 73 } 74 75 // Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema.

··· 66 67 // Pipeline_TriggerRepo is a "triggerRepo" in the sh.tangled.pipeline schema. 68 type Pipeline_TriggerRepo struct { 69 + DefaultBranch string `json:"defaultBranch" cborgen:"defaultBranch"` 70 + Did string `json:"did" cborgen:"did"` 71 + Knot string `json:"knot" cborgen:"knot"` 72 + Repo *string `json:"repo,omitempty" cborgen:"repo,omitempty"` 73 + // repoDid: DID of the repo itself 74 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 75 } 76 77 // Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema.

+2

api/tangled/tangledrepo.go

··· 26 Labels []string `json:"labels,omitempty" cborgen:"labels,omitempty"` 27 // name: name of the repo 28 Name string `json:"name" cborgen:"name"` 0 0 29 // source: source of the repo 30 Source *string `json:"source,omitempty" cborgen:"source,omitempty"` 31 // spindle: CI runner to send jobs to and receive results from

··· 26 Labels []string `json:"labels,omitempty" cborgen:"labels,omitempty"` 27 // name: name of the repo 28 Name string `json:"name" cborgen:"name"` 29 + // repoDid: DID of the repo itself, if assigned 30 + RepoDid *string `json:"repoDid,omitempty" cborgen:"repoDid,omitempty"` 31 // source: source of the repo 32 Source *string `json:"source,omitempty" cborgen:"source,omitempty"` 33 // spindle: CI runner to send jobs to and receive results from

+9

lexicons/actor/profile.json

··· 60 "maxGraphemes": 40, 61 "maxLength": 400 62 }, 0 0 0 0 0 0 0 0 0 63 "pinnedRepositories": { 64 "type": "array", 65 "description": "Any ATURI, it is up to appviews to validate these fields.",

··· 60 "maxGraphemes": 40, 61 "maxLength": 400 62 }, 63 + "pinnedRepositoryDids": { 64 + "type": "array", 65 + "minLength": 0, 66 + "maxLength": 6, 67 + "items": { 68 + "type": "string", 69 + "format": "did" 70 + } 71 + }, 72 "pinnedRepositories": { 73 "type": "array", 74 "description": "Any ATURI, it is up to appviews to validate these fields.",

+4 -1

lexicons/feed/star.json

··· 10 "record": { 11 "type": "object", 12 "required": [ 13 - "subject", 14 "createdAt" 15 ], 16 "properties": { 17 "subject": { 18 "type": "string", 19 "format": "at-uri" 0 0 0 0 20 }, 21 "createdAt": { 22 "type": "string",

··· 10 "record": { 11 "type": "object", 12 "required": [ 0 13 "createdAt" 14 ], 15 "properties": { 16 "subject": { 17 "type": "string", 18 "format": "at-uri" 19 + }, 20 + "subjectDid": { 21 + "type": "string", 22 + "format": "did" 23 }, 24 "createdAt": { 25 "type": "string",

+6 -2

lexicons/git/refUpdate.json

··· 11 "required": [ 12 "ref", 13 "committerDid", 14 - "repoDid", 15 "repoName", 16 "oldSha", 17 "newSha", ··· 29 "description": "did of the user that pushed this ref", 30 "format": "did" 31 }, 0 0 0 0 0 32 "repoDid": { 33 "type": "string", 34 - "description": "did of the owner of the repo", 35 "format": "did" 36 }, 37 "repoName": {

··· 11 "required": [ 12 "ref", 13 "committerDid", 0 14 "repoName", 15 "oldSha", 16 "newSha", ··· 28 "description": "did of the user that pushed this ref", 29 "format": "did" 30 }, 31 + "ownerDid": { 32 + "type": "string", 33 + "description": "did of the owner of the repo", 34 + "format": "did" 35 + }, 36 "repoDid": { 37 "type": "string", 38 + "description": "DID of the repo itself", 39 "format": "did" 40 }, 41 "repoName": {

+5 -1

lexicons/issue/issue.json

··· 9 "key": "tid", 10 "record": { 11 "type": "object", 12 - "required": ["repo", "title", "createdAt"], 13 "properties": { 14 "repo": { 15 "type": "string", 16 "format": "at-uri" 0 0 0 0 17 }, 18 "title": { 19 "type": "string"

··· 9 "key": "tid", 10 "record": { 11 "type": "object", 12 + "required": ["title", "createdAt"], 13 "properties": { 14 "repo": { 15 "type": "string", 16 "format": "at-uri" 17 + }, 18 + "repoDid": { 19 + "type": "string", 20 + "format": "did" 21 }, 22 "title": { 23 "type": "string"

+5 -1

lexicons/pipeline/pipeline.json

··· 66 "required": [ 67 "knot", 68 "did", 69 - "repo", 70 "defaultBranch" 71 ], 72 "properties": { ··· 75 }, 76 "did": { 77 "type": "string", 0 0 0 0 0 78 "format": "did" 79 }, 80 "repo": {

··· 66 "required": [ 67 "knot", 68 "did", 0 69 "defaultBranch" 70 ], 71 "properties": { ··· 74 }, 75 "did": { 76 "type": "string", 77 + "format": "did" 78 + }, 79 + "repoDid": { 80 + "type": "string", 81 + "description": "DID of the repo itself", 82 "format": "did" 83 }, 84 "repo": {

+8 -1

lexicons/pulls/pull.json

··· 65 "target": { 66 "type": "object", 67 "required": [ 68 - "repo", 69 "branch" 70 ], 71 "properties": { 72 "repo": { 73 "type": "string", 74 "format": "at-uri" 0 0 0 0 75 }, 76 "branch": { 77 "type": "string" ··· 96 "repo": { 97 "type": "string", 98 "format": "at-uri" 0 0 0 0 99 } 100 } 101 }

··· 65 "target": { 66 "type": "object", 67 "required": [ 0 68 "branch" 69 ], 70 "properties": { 71 "repo": { 72 "type": "string", 73 "format": "at-uri" 74 + }, 75 + "repoDid": { 76 + "type": "string", 77 + "format": "did" 78 }, 79 "branch": { 80 "type": "string" ··· 99 "repo": { 100 "type": "string", 101 "format": "at-uri" 102 + }, 103 + "repoDid": { 104 + "type": "string", 105 + "format": "did" 106 } 107 } 108 }

+4 -1

lexicons/repo/artifact.json

··· 11 "type": "object", 12 "required": [ 13 "name", 14 - "repo", 15 "tag", 16 "createdAt", 17 "artifact" ··· 25 "type": "string", 26 "format": "at-uri", 27 "description": "repo that this artifact is being uploaded to" 0 0 0 0 28 }, 29 "tag": { 30 "type": "bytes",

··· 11 "type": "object", 12 "required": [ 13 "name", 0 14 "tag", 15 "createdAt", 16 "artifact" ··· 24 "type": "string", 25 "format": "at-uri", 26 "description": "repo that this artifact is being uploaded to" 27 + }, 28 + "repoDid": { 29 + "type": "string", 30 + "format": "did" 31 }, 32 "tag": { 33 "type": "bytes",

+4 -1

lexicons/repo/collaborator.json

··· 11 "type": "object", 12 "required": [ 13 "subject", 14 - "repo", 15 "createdAt" 16 ], 17 "properties": { ··· 23 "type": "string", 24 "description": "repo to add this user to", 25 "format": "at-uri" 0 0 0 0 26 }, 27 "createdAt": { 28 "type": "string",

··· 11 "type": "object", 12 "required": [ 13 "subject", 0 14 "createdAt" 15 ], 16 "properties": { ··· 22 "type": "string", 23 "description": "repo to add this user to", 24 "format": "at-uri" 25 + }, 26 + "repoDid": { 27 + "type": "string", 28 + "format": "did" 29 }, 30 "createdAt": { 31 "type": "string",

+23 -1

lexicons/repo/create.json

··· 10 "schema": { 11 "type": "object", 12 "required": [ 13 - "rkey" 0 14 ], 15 "properties": { 16 "rkey": { 17 "type": "string", 18 "description": "Rkey of the repository record" 19 }, 0 0 0 0 20 "defaultBranch": { 21 "type": "string", 22 "description": "Default branch to push to" ··· 24 "source": { 25 "type": "string", 26 "description": "A source URL to clone from, populate this when forking or importing a repository." 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 27 } 28 } 29 }

··· 10 "schema": { 11 "type": "object", 12 "required": [ 13 + "rkey", 14 + "name" 15 ], 16 "properties": { 17 "rkey": { 18 "type": "string", 19 "description": "Rkey of the repository record" 20 }, 21 + "name": { 22 + "type": "string", 23 + "description": "Name of the repository" 24 + }, 25 "defaultBranch": { 26 "type": "string", 27 "description": "Default branch to push to" ··· 29 "source": { 30 "type": "string", 31 "description": "A source URL to clone from, populate this when forking or importing a repository." 32 + }, 33 + "repoDid": { 34 + "type": "string", 35 + "format": "did", 36 + "description": "Optional user-provided did:web to use as the repo identity instead of minting a did:plc." 37 + } 38 + } 39 + } 40 + }, 41 + "output": { 42 + "encoding": "application/json", 43 + "schema": { 44 + "type": "object", 45 + "properties": { 46 + "repoDid": { 47 + "type": "string", 48 + "format": "did" 49 } 50 } 51 }

+5

lexicons/repo/repo.json

··· 60 "format": "at-uri" 61 } 62 }, 0 0 0 0 0 63 "createdAt": { 64 "type": "string", 65 "format": "datetime"

··· 60 "format": "at-uri" 61 } 62 }, 63 + "repoDid": { 64 + "type": "string", 65 + "format": "did", 66 + "description": "DID of the repo itself, if assigned" 67 + }, 68 "createdAt": { 69 "type": "string", 70 "format": "datetime"