appview,lexicons: atprotate the mentions & references #761

+487 -6

api/tangled/cbor_gen.go

··· 6744 6744 } 6745 6745 6746 6746 cw := cbg.NewCborWriter(w) 6747 6747 - fieldCount := 5 6747 6747 + fieldCount := 7 6748 6748 6749 6749 if t.Body == nil { 6750 6750 fieldCount-- 6751 6751 } 6752 6752 6753 6753 + if t.Mentions == nil { 6754 6754 + fieldCount-- 6755 6755 + } 6756 6756 + 6757 6757 + if t.References == nil { 6758 6758 + fieldCount-- 6759 6759 + } 6760 6760 + 6753 6761 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6754 6762 return err 6755 6763 } ··· 6851 6859 return err 6852 6860 } 6853 6861 6862 6862 + // t.Mentions ([]string) (slice) 6863 6863 + if t.Mentions != nil { 6864 6864 + 6865 6865 + if len("mentions") > 1000000 { 6866 6866 + return xerrors.Errorf("Value in field \"mentions\" was too long") 6867 6867 + } 6868 6868 + 6869 6869 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil { 6870 6870 + return err 6871 6871 + } 6872 6872 + if _, err := cw.WriteString(string("mentions")); err != nil { 6873 6873 + return err 6874 6874 + } 6875 6875 + 6876 6876 + if len(t.Mentions) > 8192 { 6877 6877 + return xerrors.Errorf("Slice value in field t.Mentions was too long") 6878 6878 + } 6879 6879 + 6880 6880 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil { 6881 6881 + return err 6882 6882 + } 6883 6883 + for _, v := range t.Mentions { 6884 6884 + if len(v) > 1000000 { 6885 6885 + return xerrors.Errorf("Value in field v was too long") 6886 6886 + } 6887 6887 + 6888 6888 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 6889 6889 + return err 6890 6890 + } 6891 6891 + if _, err := cw.WriteString(string(v)); err != nil { 6892 6892 + return err 6893 6893 + } 6894 6894 + 6895 6895 + } 6896 6896 + } 6897 6897 + 6854 6898 // t.CreatedAt (string) (string) 6855 6899 if len("createdAt") > 1000000 { 6856 6900 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 6873 6917 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6874 6918 return err 6875 6919 } 6920 6920 + 6921 6921 + // t.References ([]string) (slice) 6922 6922 + if t.References != nil { 6923 6923 + 6924 6924 + if len("references") > 1000000 { 6925 6925 + return xerrors.Errorf("Value in field \"references\" was too long") 6926 6926 + } 6927 6927 + 6928 6928 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil { 6929 6929 + return err 6930 6930 + } 6931 6931 + if _, err := cw.WriteString(string("references")); err != nil { 6932 6932 + return err 6933 6933 + } 6934 6934 + 6935 6935 + if len(t.References) > 8192 { 6936 6936 + return xerrors.Errorf("Slice value in field t.References was too long") 6937 6937 + } 6938 6938 + 6939 6939 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil { 6940 6940 + return err 6941 6941 + } 6942 6942 + for _, v := range t.References { 6943 6943 + if len(v) > 1000000 { 6944 6944 + return xerrors.Errorf("Value in field v was too long") 6945 6945 + } 6946 6946 + 6947 6947 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 6948 6948 + return err 6949 6949 + } 6950 6950 + if _, err := cw.WriteString(string(v)); err != nil { 6951 6951 + return err 6952 6952 + } 6953 6953 + 6954 6954 + } 6955 6955 + } 6876 6956 return nil 6877 6957 } 6878 6958 ··· 6901 6981 6902 6982 n := extra 6903 6983 6904 6904 - nameBuf := make([]byte, 9) 6984 6984 + nameBuf := make([]byte, 10) 6905 6985 for i := uint64(0); i < n; i++ { 6906 6986 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6907 6987 if err != nil { ··· 6971 7051 6972 7052 t.Title = string(sval) 6973 7053 } 7054 7054 + // t.Mentions ([]string) (slice) 7055 7055 + case "mentions": 7056 7056 + 7057 7057 + maj, extra, err = cr.ReadHeader() 7058 7058 + if err != nil { 7059 7059 + return err 7060 7060 + } 7061 7061 + 7062 7062 + if extra > 8192 { 7063 7063 + return fmt.Errorf("t.Mentions: array too large (%d)", extra) 7064 7064 + } 7065 7065 + 7066 7066 + if maj != cbg.MajArray { 7067 7067 + return fmt.Errorf("expected cbor array") 7068 7068 + } 7069 7069 + 7070 7070 + if extra > 0 { 7071 7071 + t.Mentions = make([]string, extra) 7072 7072 + } 7073 7073 + 7074 7074 + for i := 0; i < int(extra); i++ { 7075 7075 + { 7076 7076 + var maj byte 7077 7077 + var extra uint64 7078 7078 + var err error 7079 7079 + _ = maj 7080 7080 + _ = extra 7081 7081 + _ = err 7082 7082 + 7083 7083 + { 7084 7084 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7085 7085 + if err != nil { 7086 7086 + return err 7087 7087 + } 7088 7088 + 7089 7089 + t.Mentions[i] = string(sval) 7090 7090 + } 7091 7091 + 7092 7092 + } 7093 7093 + } 6974 7094 // t.CreatedAt (string) (string) 6975 7095 case "createdAt": 6976 7096 ··· 6982 7102 6983 7103 t.CreatedAt = string(sval) 6984 7104 } 7105 7105 + // t.References ([]string) (slice) 7106 7106 + case "references": 7107 7107 + 7108 7108 + maj, extra, err = cr.ReadHeader() 7109 7109 + if err != nil { 7110 7110 + return err 7111 7111 + } 7112 7112 + 7113 7113 + if extra > 8192 { 7114 7114 + return fmt.Errorf("t.References: array too large (%d)", extra) 7115 7115 + } 7116 7116 + 7117 7117 + if maj != cbg.MajArray { 7118 7118 + return fmt.Errorf("expected cbor array") 7119 7119 + } 7120 7120 + 7121 7121 + if extra > 0 { 7122 7122 + t.References = make([]string, extra) 7123 7123 + } 7124 7124 + 7125 7125 + for i := 0; i < int(extra); i++ { 7126 7126 + { 7127 7127 + var maj byte 7128 7128 + var extra uint64 7129 7129 + var err error 7130 7130 + _ = maj 7131 7131 + _ = extra 7132 7132 + _ = err 7133 7133 + 7134 7134 + { 7135 7135 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7136 7136 + if err != nil { 7137 7137 + return err 7138 7138 + } 7139 7139 + 7140 7140 + t.References[i] = string(sval) 7141 7141 + } 7142 7142 + 7143 7143 + } 7144 7144 + } 6985 7145 6986 7146 default: 6987 7147 // Field doesn't exist on this type, so ignore it ··· 7000 7160 } 7001 7161 7002 7162 cw := cbg.NewCborWriter(w) 7003 7003 - fieldCount := 5 7163 7163 + fieldCount := 7 7164 7164 + 7165 7165 + if t.Mentions == nil { 7166 7166 + fieldCount-- 7167 7167 + } 7168 7168 + 7169 7169 + if t.References == nil { 7170 7170 + fieldCount-- 7171 7171 + } 7004 7172 7005 7173 if t.ReplyTo == nil { 7006 7174 fieldCount-- ··· 7107 7275 } 7108 7276 } 7109 7277 7278 7278 + // t.Mentions ([]string) (slice) 7279 7279 + if t.Mentions != nil { 7280 7280 + 7281 7281 + if len("mentions") > 1000000 { 7282 7282 + return xerrors.Errorf("Value in field \"mentions\" was too long") 7283 7283 + } 7284 7284 + 7285 7285 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil { 7286 7286 + return err 7287 7287 + } 7288 7288 + if _, err := cw.WriteString(string("mentions")); err != nil { 7289 7289 + return err 7290 7290 + } 7291 7291 + 7292 7292 + if len(t.Mentions) > 8192 { 7293 7293 + return xerrors.Errorf("Slice value in field t.Mentions was too long") 7294 7294 + } 7295 7295 + 7296 7296 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil { 7297 7297 + return err 7298 7298 + } 7299 7299 + for _, v := range t.Mentions { 7300 7300 + if len(v) > 1000000 { 7301 7301 + return xerrors.Errorf("Value in field v was too long") 7302 7302 + } 7303 7303 + 7304 7304 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 7305 7305 + return err 7306 7306 + } 7307 7307 + if _, err := cw.WriteString(string(v)); err != nil { 7308 7308 + return err 7309 7309 + } 7310 7310 + 7311 7311 + } 7312 7312 + } 7313 7313 + 7110 7314 // t.CreatedAt (string) (string) 7111 7315 if len("createdAt") > 1000000 { 7112 7316 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 7129 7333 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7130 7334 return err 7131 7335 } 7336 7336 + 7337 7337 + // t.References ([]string) (slice) 7338 7338 + if t.References != nil { 7339 7339 + 7340 7340 + if len("references") > 1000000 { 7341 7341 + return xerrors.Errorf("Value in field \"references\" was too long") 7342 7342 + } 7343 7343 + 7344 7344 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil { 7345 7345 + return err 7346 7346 + } 7347 7347 + if _, err := cw.WriteString(string("references")); err != nil { 7348 7348 + return err 7349 7349 + } 7350 7350 + 7351 7351 + if len(t.References) > 8192 { 7352 7352 + return xerrors.Errorf("Slice value in field t.References was too long") 7353 7353 + } 7354 7354 + 7355 7355 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil { 7356 7356 + return err 7357 7357 + } 7358 7358 + for _, v := range t.References { 7359 7359 + if len(v) > 1000000 { 7360 7360 + return xerrors.Errorf("Value in field v was too long") 7361 7361 + } 7362 7362 + 7363 7363 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 7364 7364 + return err 7365 7365 + } 7366 7366 + if _, err := cw.WriteString(string(v)); err != nil { 7367 7367 + return err 7368 7368 + } 7369 7369 + 7370 7370 + } 7371 7371 + } 7132 7372 return nil 7133 7373 } 7134 7374 ··· 7157 7397 7158 7398 n := extra 7159 7399 7160 7160 - nameBuf := make([]byte, 9) 7400 7400 + nameBuf := make([]byte, 10) 7161 7401 for i := uint64(0); i < n; i++ { 7162 7402 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7163 7403 if err != nil { ··· 7227 7467 t.ReplyTo = (*string)(&sval) 7228 7468 } 7229 7469 } 7470 7470 + // t.Mentions ([]string) (slice) 7471 7471 + case "mentions": 7472 7472 + 7473 7473 + maj, extra, err = cr.ReadHeader() 7474 7474 + if err != nil { 7475 7475 + return err 7476 7476 + } 7477 7477 + 7478 7478 + if extra > 8192 { 7479 7479 + return fmt.Errorf("t.Mentions: array too large (%d)", extra) 7480 7480 + } 7481 7481 + 7482 7482 + if maj != cbg.MajArray { 7483 7483 + return fmt.Errorf("expected cbor array") 7484 7484 + } 7485 7485 + 7486 7486 + if extra > 0 { 7487 7487 + t.Mentions = make([]string, extra) 7488 7488 + } 7489 7489 + 7490 7490 + for i := 0; i < int(extra); i++ { 7491 7491 + { 7492 7492 + var maj byte 7493 7493 + var extra uint64 7494 7494 + var err error 7495 7495 + _ = maj 7496 7496 + _ = extra 7497 7497 + _ = err 7498 7498 + 7499 7499 + { 7500 7500 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7501 7501 + if err != nil { 7502 7502 + return err 7503 7503 + } 7504 7504 + 7505 7505 + t.Mentions[i] = string(sval) 7506 7506 + } 7507 7507 + 7508 7508 + } 7509 7509 + } 7230 7510 // t.CreatedAt (string) (string) 7231 7511 case "createdAt": 7232 7512 ··· 7238 7518 7239 7519 t.CreatedAt = string(sval) 7240 7520 } 7521 7521 + // t.References ([]string) (slice) 7522 7522 + case "references": 7523 7523 + 7524 7524 + maj, extra, err = cr.ReadHeader() 7525 7525 + if err != nil { 7526 7526 + return err 7527 7527 + } 7528 7528 + 7529 7529 + if extra > 8192 { 7530 7530 + return fmt.Errorf("t.References: array too large (%d)", extra) 7531 7531 + } 7532 7532 + 7533 7533 + if maj != cbg.MajArray { 7534 7534 + return fmt.Errorf("expected cbor array") 7535 7535 + } 7536 7536 + 7537 7537 + if extra > 0 { 7538 7538 + t.References = make([]string, extra) 7539 7539 + } 7540 7540 + 7541 7541 + for i := 0; i < int(extra); i++ { 7542 7542 + { 7543 7543 + var maj byte 7544 7544 + var extra uint64 7545 7545 + var err error 7546 7546 + _ = maj 7547 7547 + _ = extra 7548 7548 + _ = err 7549 7549 + 7550 7550 + { 7551 7551 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 7552 7552 + if err != nil { 7553 7553 + return err 7554 7554 + } 7555 7555 + 7556 7556 + t.References[i] = string(sval) 7557 7557 + } 7558 7558 + 7559 7559 + } 7560 7560 + } 7241 7561 7242 7562 default: 7243 7563 // Field doesn't exist on this type, so ignore it ··· 7755 8075 } 7756 8076 7757 8077 cw := cbg.NewCborWriter(w) 8078 8078 + fieldCount := 6 7758 8079 7759 7759 - if _, err := cw.Write([]byte{164}); err != nil { 8080 8080 + if t.Mentions == nil { 8081 8081 + fieldCount-- 8082 8082 + } 8083 8083 + 8084 8084 + if t.References == nil { 8085 8085 + fieldCount-- 8086 8086 + } 8087 8087 + 8088 8088 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 7760 8089 return err 7761 8090 } 7762 8091 ··· 7825 8154 return err 7826 8155 } 7827 8156 8157 8157 + // t.Mentions ([]string) (slice) 8158 8158 + if t.Mentions != nil { 8159 8159 + 8160 8160 + if len("mentions") > 1000000 { 8161 8161 + return xerrors.Errorf("Value in field \"mentions\" was too long") 8162 8162 + } 8163 8163 + 8164 8164 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("mentions"))); err != nil { 8165 8165 + return err 8166 8166 + } 8167 8167 + if _, err := cw.WriteString(string("mentions")); err != nil { 8168 8168 + return err 8169 8169 + } 8170 8170 + 8171 8171 + if len(t.Mentions) > 8192 { 8172 8172 + return xerrors.Errorf("Slice value in field t.Mentions was too long") 8173 8173 + } 8174 8174 + 8175 8175 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil { 8176 8176 + return err 8177 8177 + } 8178 8178 + for _, v := range t.Mentions { 8179 8179 + if len(v) > 1000000 { 8180 8180 + return xerrors.Errorf("Value in field v was too long") 8181 8181 + } 8182 8182 + 8183 8183 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 8184 8184 + return err 8185 8185 + } 8186 8186 + if _, err := cw.WriteString(string(v)); err != nil { 8187 8187 + return err 8188 8188 + } 8189 8189 + 8190 8190 + } 8191 8191 + } 8192 8192 + 7828 8193 // t.CreatedAt (string) (string) 7829 8194 if len("createdAt") > 1000000 { 7830 8195 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 7847 8212 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 7848 8213 return err 7849 8214 } 8215 8215 + 8216 8216 + // t.References ([]string) (slice) 8217 8217 + if t.References != nil { 8218 8218 + 8219 8219 + if len("references") > 1000000 { 8220 8220 + return xerrors.Errorf("Value in field \"references\" was too long") 8221 8221 + } 8222 8222 + 8223 8223 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("references"))); err != nil { 8224 8224 + return err 8225 8225 + } 8226 8226 + if _, err := cw.WriteString(string("references")); err != nil { 8227 8227 + return err 8228 8228 + } 8229 8229 + 8230 8230 + if len(t.References) > 8192 { 8231 8231 + return xerrors.Errorf("Slice value in field t.References was too long") 8232 8232 + } 8233 8233 + 8234 8234 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil { 8235 8235 + return err 8236 8236 + } 8237 8237 + for _, v := range t.References { 8238 8238 + if len(v) > 1000000 { 8239 8239 + return xerrors.Errorf("Value in field v was too long") 8240 8240 + } 8241 8241 + 8242 8242 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 8243 8243 + return err 8244 8244 + } 8245 8245 + if _, err := cw.WriteString(string(v)); err != nil { 8246 8246 + return err 8247 8247 + } 8248 8248 + 8249 8249 + } 8250 8250 + } 7850 8251 return nil 7851 8252 } 7852 8253 ··· 7875 8276 7876 8277 n := extra 7877 8278 7878 7878 - nameBuf := make([]byte, 9) 8279 8279 + nameBuf := make([]byte, 10) 7879 8280 for i := uint64(0); i < n; i++ { 7880 8281 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 7881 8282 if err != nil { ··· 7924 8325 7925 8326 t.LexiconTypeID = string(sval) 7926 8327 } 8328 8328 + // t.Mentions ([]string) (slice) 8329 8329 + case "mentions": 8330 8330 + 8331 8331 + maj, extra, err = cr.ReadHeader() 8332 8332 + if err != nil { 8333 8333 + return err 8334 8334 + } 8335 8335 + 8336 8336 + if extra > 8192 { 8337 8337 + return fmt.Errorf("t.Mentions: array too large (%d)", extra) 8338 8338 + } 8339 8339 + 8340 8340 + if maj != cbg.MajArray { 8341 8341 + return fmt.Errorf("expected cbor array") 8342 8342 + } 8343 8343 + 8344 8344 + if extra > 0 { 8345 8345 + t.Mentions = make([]string, extra) 8346 8346 + } 8347 8347 + 8348 8348 + for i := 0; i < int(extra); i++ { 8349 8349 + { 8350 8350 + var maj byte 8351 8351 + var extra uint64 8352 8352 + var err error 8353 8353 + _ = maj 8354 8354 + _ = extra 8355 8355 + _ = err 8356 8356 + 8357 8357 + { 8358 8358 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8359 8359 + if err != nil { 8360 8360 + return err 8361 8361 + } 8362 8362 + 8363 8363 + t.Mentions[i] = string(sval) 8364 8364 + } 8365 8365 + 8366 8366 + } 8367 8367 + } 7927 8368 // t.CreatedAt (string) (string) 7928 8369 case "createdAt": 7929 8370 ··· 7935 8376 7936 8377 t.CreatedAt = string(sval) 7937 8378 } 8379 8379 + // t.References ([]string) (slice) 8380 8380 + case "references": 8381 8381 + 8382 8382 + maj, extra, err = cr.ReadHeader() 8383 8383 + if err != nil { 8384 8384 + return err 8385 8385 + } 8386 8386 + 8387 8387 + if extra > 8192 { 8388 8388 + return fmt.Errorf("t.References: array too large (%d)", extra) 8389 8389 + } 8390 8390 + 8391 8391 + if maj != cbg.MajArray { 8392 8392 + return fmt.Errorf("expected cbor array") 8393 8393 + } 8394 8394 + 8395 8395 + if extra > 0 { 8396 8396 + t.References = make([]string, extra) 8397 8397 + } 8398 8398 + 8399 8399 + for i := 0; i < int(extra); i++ { 8400 8400 + { 8401 8401 + var maj byte 8402 8402 + var extra uint64 8403 8403 + var err error 8404 8404 + _ = maj 8405 8405 + _ = extra 8406 8406 + _ = err 8407 8407 + 8408 8408 + { 8409 8409 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 8410 8410 + if err != nil { 8411 8411 + return err 8412 8412 + } 8413 8413 + 8414 8414 + t.References[i] = string(sval) 8415 8415 + } 8416 8416 + 8417 8417 + } 8418 8418 + } 7938 8419 7939 8420 default: 7940 8421 // Field doesn't exist on this type, so ignore it

+7 -5

api/tangled/issuecomment.go

··· 17 17 } // 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" cborgen:"body"` 22 22 - CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 - Issue string `json:"issue" cborgen:"issue"` 24 24 - ReplyTo *string `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"` 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue.comment" cborgen:"$type,const=sh.tangled.repo.issue.comment"` 21 21 + Body string `json:"body" cborgen:"body"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 + Issue string `json:"issue" cborgen:"issue"` 24 24 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 25 25 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 26 26 + ReplyTo *string `json:"replyTo,omitempty" cborgen:"replyTo,omitempty"` 25 27 }

+6 -4

api/tangled/pullcomment.go

··· 17 17 } // 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" cborgen:"body"` 22 22 - CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 - Pull string `json:"pull" cborgen:"pull"` 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" cborgen:"body"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 24 + Pull string `json:"pull" cborgen:"pull"` 25 25 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 24 26 }

+7 -5

api/tangled/repoissue.go

··· 17 17 } // 18 18 // RECORDTYPE: RepoIssue 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" cborgen:"createdAt"` 23 23 - Repo string `json:"repo" cborgen:"repo"` 24 24 - Title string `json:"title" cborgen:"title"` 20 20 + LexiconTypeID string `json:"$type,const=sh.tangled.repo.issue" cborgen:"$type,const=sh.tangled.repo.issue"` 21 21 + Body *string `json:"body,omitempty" cborgen:"body,omitempty"` 22 22 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 + Mentions []string `json:"mentions,omitempty" cborgen:"mentions,omitempty"` 24 24 + References []string `json:"references,omitempty" cborgen:"references,omitempty"` 25 25 + Repo string `json:"repo" cborgen:"repo"` 26 26 + Title string `json:"title" cborgen:"title"` 25 27 }

+9

appview/db/db.go

··· 561 561 email_notifications integer not null default 0 562 562 ); 563 563 564 564 + create table if not exists references ( 565 565 + id integer primary key autoincrement, 566 566 + from_at text not null, 567 567 + to_at text not null, 568 568 + unique (from, to) 569 569 + ); 570 570 + 564 571 create table if not exists migrations ( 565 572 id integer primary key autoincrement, 566 573 name text unique ··· 571 578 create index if not exists idx_notifications_recipient_read on notifications(recipient_did, read); 572 579 create index if not exists idx_stars_created on stars(created); 573 580 create index if not exists idx_stars_repo_at_created on stars(repo_at, created); 581 581 + create index if not exists idx_references_from_at on references(from_at); 582 582 + create index if not exists idx_references_to_at on references(to_at); 574 583 `) 575 584 if err != nil { 576 585 return nil, err

+73 -18

appview/db/issues.go

··· 10 10 "time" 11 11 12 12 "github.com/bluesky-social/indigo/atproto/syntax" 13 13 + "tangled.org/core/api/tangled" 13 14 "tangled.org/core/appview/models" 14 15 "tangled.org/core/appview/pagination" 15 16 ) ··· 69 70 returning rowid, issue_id 70 71 `, issue.RepoAt, issue.Did, issue.Rkey, newIssueId, issue.Title, issue.Body) 71 72 72 72 - return row.Scan(&issue.Id, &issue.IssueId) 73 73 + err = row.Scan(&issue.Id, &issue.IssueId) 74 74 + if err != nil { 75 75 + return fmt.Errorf("scan row: %w", err) 76 76 + } 77 77 + 78 78 + if err := putReferences(tx, issue.AtUri(), issue.References); err != nil { 79 79 + return fmt.Errorf("put references: %w", err) 80 80 + } 81 81 + return nil 73 82 } 74 83 75 84 func updateIssue(tx *sql.Tx, issue *models.Issue) error { ··· 79 88 set title = ?, body = ?, edited = ? 80 89 where did = ? and rkey = ? 81 90 `, issue.Title, issue.Body, time.Now().Format(time.RFC3339), issue.Did, issue.Rkey) 82 82 - return err 91 91 + if err != nil { 92 92 + return err 93 93 + } 94 94 + 95 95 + if err := putReferences(tx, issue.AtUri(), issue.References); err != nil { 96 96 + return fmt.Errorf("put references: %w", err) 97 97 + } 98 98 + return nil 83 99 } 84 100 85 101 func GetIssuesPaginated(e Execer, page pagination.Page, filters ...filter) ([]models.Issue, error) { ··· 234 250 } 235 251 } 236 252 253 253 + // collect references for each issue 254 254 + allReferencs, err := GetReferencesAll(e, FilterIn("from_at", issueAts)) 255 255 + if err != nil { 256 256 + return nil, fmt.Errorf("failed to query references: %w", err) 257 257 + } 258 258 + for issueAt, references := range allReferencs { 259 259 + if issue, ok := issueMap[issueAt.String()]; ok { 260 260 + issue.References = references 261 261 + } 262 262 + } 263 263 + 237 264 var issues []models.Issue 238 265 for _, i := range issueMap { 239 266 issues = append(issues, *i) ··· 323 350 return ids, nil 324 351 } 325 352 326 326 - func AddIssueComment(e Execer, c models.IssueComment) (int64, error) { 327 327 - result, err := e.Exec( 353 353 + func AddIssueComment(tx *sql.Tx, c models.IssueComment) (int64, error) { 354 354 + result, err := tx.Exec( 328 355 `insert into issue_comments ( 329 356 did, 330 357 rkey, ··· 358 385 return 0, err 359 386 } 360 387 388 388 + if err := putReferences(tx, c.AtUri(), c.References); err != nil { 389 389 + return 0, fmt.Errorf("put references: %w", err) 390 390 + } 391 391 + 361 392 id, err := result.LastInsertId() 362 393 if err != nil { 363 394 return 0, err ··· 386 417 } 387 418 388 419 func GetIssueComments(e Execer, filters ...filter) ([]models.IssueComment, error) { 389 389 - var comments []models.IssueComment 420 420 + commentMap := make(map[string]*models.IssueComment) 390 421 391 422 var conditions []string 392 423 var args []any ··· 465 496 comment.ReplyTo = &replyTo.V 466 497 } 467 498 468 468 - comments = append(comments, comment) 499 499 + atUri := comment.AtUri().String() 500 500 + commentMap[atUri] = &comment 469 501 } 470 502 471 503 if err = rows.Err(); err != nil { 472 504 return nil, err 473 505 } 474 506 507 507 + // collect references for each comments 508 508 + commentAts := slices.Collect(maps.Keys(commentMap)) 509 509 + allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts)) 510 510 + if err != nil { 511 511 + return nil, fmt.Errorf("failed to query references: %w", err) 512 512 + } 513 513 + for commentAt, references := range allReferencs { 514 514 + if comment, ok := commentMap[commentAt.String()]; ok { 515 515 + comment.References = references 516 516 + } 517 517 + } 518 518 + 519 519 + var comments []models.IssueComment 520 520 + for _, c := range commentMap { 521 521 + comments = append(comments, *c) 522 522 + } 523 523 + 524 524 + sort.Slice(comments, func(i, j int) bool { 525 525 + return comments[i].Created.After(comments[j].Created) 526 526 + }) 527 527 + 475 528 return comments, nil 476 529 } 477 530 478 478 - func DeleteIssues(e Execer, filters ...filter) error { 479 479 - var conditions []string 480 480 - var args []any 481 481 - for _, filter := range filters { 482 482 - conditions = append(conditions, filter.Condition()) 483 483 - args = append(args, filter.Arg()...) 531 531 + func DeleteIssues(tx *sql.Tx, did, rkey string) error { 532 532 + _, err := tx.Exec( 533 533 + `delete from issues 534 534 + where did = ? and rkey = ?`, 535 535 + did, 536 536 + rkey, 537 537 + ) 538 538 + if err != nil { 539 539 + return fmt.Errorf("delete issue: %w", err) 484 540 } 485 541 486 486 - whereClause := "" 487 487 - if conditions != nil { 488 488 - whereClause = " where " + strings.Join(conditions, " and ") 542 542 + uri := syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", did, tangled.RepoIssueNSID, rkey)) 543 543 + err = deleteReferences(tx, uri) 544 544 + if err != nil { 545 545 + return fmt.Errorf("delete references: %w", err) 489 546 } 490 547 491 491 - query := fmt.Sprintf(`delete from issues %s`, whereClause) 492 492 - _, err := e.Exec(query, args...) 493 493 - return err 548 548 + return nil 494 549 } 495 550 496 551 func CloseIssues(e Execer, filters ...filter) error {

+30 -4

appview/db/pulls.go

··· 492 492 } 493 493 defer rows.Close() 494 494 495 495 - var comments []models.PullComment 495 495 + commentMap := make(map[string]*models.PullComment) 496 496 for rows.Next() { 497 497 var comment models.PullComment 498 498 var createdAt string ··· 514 514 comment.Created = t 515 515 } 516 516 517 517 - comments = append(comments, comment) 517 517 + atUri := comment.AtUri().String() 518 518 + commentMap[atUri] = &comment 518 519 } 519 520 520 521 if err := rows.Err(); err != nil { 521 522 return nil, err 522 523 } 523 524 525 525 + // collect references for each comments 526 526 + commentAts := slices.Collect(maps.Keys(commentMap)) 527 527 + allReferencs, err := GetReferencesAll(e, FilterIn("from_at", commentAts)) 528 528 + if err != nil { 529 529 + return nil, fmt.Errorf("failed to query references: %w", err) 530 530 + } 531 531 + for commentAt, references := range allReferencs { 532 532 + if comment, ok := commentMap[commentAt.String()]; ok { 533 533 + comment.References = references 534 534 + } 535 535 + } 536 536 + 537 537 + var comments []models.PullComment 538 538 + for _, c := range commentMap { 539 539 + comments = append(comments, *c) 540 540 + } 541 541 + 542 542 + sort.Slice(comments, func(i, j int) bool { 543 543 + return comments[i].Created.After(comments[j].Created) 544 544 + }) 545 545 + 524 546 return comments, nil 525 547 } 526 548 ··· 600 622 return pulls, nil 601 623 } 602 624 603 603 - func NewPullComment(e Execer, comment *models.PullComment) (int64, error) { 625 625 + func NewPullComment(tx *sql.Tx, comment *models.PullComment) (int64, error) { 604 626 query := `insert into pull_comments (owner_did, repo_at, submission_id, comment_at, pull_id, body) values (?, ?, ?, ?, ?, ?)` 605 605 - res, err := e.Exec( 627 627 + res, err := tx.Exec( 606 628 query, 607 629 comment.OwnerDid, 608 630 comment.RepoAt, ··· 620 642 return 0, err 621 643 } 622 644 645 645 + if err := putReferences(tx, comment.AtUri(), comment.References); err != nil { 646 646 + return 0, fmt.Errorf("put references: %w", err) 647 647 + } 648 648 + 623 649 return i, nil 624 650 } 625 651

+78

appview/db/reference.go

··· 101 101 } 102 102 uris = append(uris, uri) 103 103 } 104 104 + if err := rows.Err(); err != nil { 105 105 + return nil, fmt.Errorf("iterate rows: %w", err) 106 106 + } 107 107 + 104 108 return uris, nil 105 109 } 106 110 ··· 170 174 } 171 175 return uris, nil 172 176 } 177 177 + 178 178 + func putReferences(tx *sql.Tx, fromAt syntax.ATURI, references []syntax.ATURI) error { 179 179 + err := deleteReferences(tx, fromAt) 180 180 + if err != nil { 181 181 + return fmt.Errorf("delete old references: %w", err) 182 182 + } 183 183 + 184 184 + values := make([]string, 0, len(references)) 185 185 + args := make([]any, 0, len(references)*2) 186 186 + for _, ref := range references { 187 187 + values = append(values, "(?, ?)") 188 188 + args = append(args, fromAt, ref) 189 189 + } 190 190 + _, err = tx.Exec( 191 191 + fmt.Sprintf( 192 192 + `insert into references (from, at) 193 193 + values %s`, 194 194 + strings.Join(values, ","), 195 195 + ), 196 196 + args..., 197 197 + ) 198 198 + if err != nil { 199 199 + return fmt.Errorf("insert new references: %w", err) 200 200 + } 201 201 + return nil 202 202 + } 203 203 + 204 204 + func deleteReferences(tx *sql.Tx, fromAt syntax.ATURI) error { 205 205 + _, err := tx.Exec(`delete from references where from_at = ?`, fromAt) 206 206 + return err 207 207 + } 208 208 + 209 209 + func GetReferencesAll(e Execer, filters ...filter) (map[syntax.ATURI][]syntax.ATURI, error) { 210 210 + var ( 211 211 + conditions []string 212 212 + args []any 213 213 + ) 214 214 + for _, filter := range filters { 215 215 + conditions = append(conditions, filter.Condition()) 216 216 + args = append(args, filter.Arg()...) 217 217 + } 218 218 + 219 219 + whereClause := "" 220 220 + if conditions != nil { 221 221 + whereClause = " where " + strings.Join(conditions, " and ") 222 222 + } 223 223 + 224 224 + rows, err := e.Query( 225 225 + fmt.Sprintf( 226 226 + `select from_at, to_at from references %s`, 227 227 + whereClause, 228 228 + ), 229 229 + ) 230 230 + if err != nil { 231 231 + return nil, fmt.Errorf("query references: %w", err) 232 232 + } 233 233 + defer rows.Close() 234 234 + 235 235 + result := make(map[syntax.ATURI][]syntax.ATURI) 236 236 + 237 237 + for rows.Next() { 238 238 + var from, to syntax.ATURI 239 239 + if err := rows.Scan(&from, &to); err != nil { 240 240 + return nil, fmt.Errorf("scan row: %w", err) 241 241 + } 242 242 + 243 243 + result[from] = append(result[from], to) 244 244 + } 245 245 + if err := rows.Err(); err != nil { 246 246 + return nil, fmt.Errorf("iterate rows: %w", err) 247 247 + } 248 248 + 249 249 + return result, nil 250 250 + }

+22 -5

appview/ingester.go

··· 841 841 return nil 842 842 843 843 case jmodels.CommitOperationDelete: 844 844 + tx, err := ddb.BeginTx(ctx, nil) 845 845 + if err != nil { 846 846 + l.Error("failed to begin transaction", "err", err) 847 847 + return err 848 848 + } 849 849 + defer tx.Rollback() 850 850 + 844 851 if err := db.DeleteIssues( 845 845 - ddb, 846 846 - db.FilterEq("did", did), 847 847 - db.FilterEq("rkey", rkey), 852 852 + tx, 853 853 + did, 854 854 + rkey, 848 855 ); err != nil { 849 856 l.Error("failed to delete", "err", err) 850 857 return fmt.Errorf("failed to delete issue record: %w", err) 851 858 } 859 859 + if err := tx.Commit(); err != nil { 860 860 + l.Error("failed to commit txn", "err", err) 861 861 + return err 862 862 + } 852 863 853 864 return nil 854 865 } ··· 888 899 return fmt.Errorf("failed to validate comment: %w", err) 889 900 } 890 901 891 891 - _, err = db.AddIssueComment(ddb, *comment) 902 902 + tx, err := ddb.Begin() 903 903 + if err != nil { 904 904 + return fmt.Errorf("failed to start transaction: %w", err) 905 905 + } 906 906 + defer tx.Rollback() 907 907 + 908 908 + _, err = db.AddIssueComment(tx, *comment) 892 909 if err != nil { 893 910 return fmt.Errorf("failed to create issue comment: %w", err) 894 911 } 895 912 896 896 - return nil 913 913 + return tx.Commit() 897 914 898 915 case jmodels.CommitOperationDelete: 899 916 if err := db.DeleteIssueComments(

+49 -19

appview/issues/issues.go

··· 241 241 } 242 242 l = l.With("did", issue.Did, "rkey", issue.Rkey) 243 243 244 244 + tx, err := rp.db.Begin() 245 245 + if err != nil { 246 246 + l.Error("failed to start transaction", "err", err) 247 247 + rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.") 248 248 + return 249 249 + } 250 250 + defer tx.Rollback() 251 251 + 244 252 // delete from PDS 245 253 client, err := rp.oauth.AuthorizedClient(r) 246 254 if err != nil { ··· 261 269 } 262 270 263 271 // delete from db 264 264 - if err := db.DeleteIssues(rp.db, db.FilterEq("id", issue.Id)); err != nil { 272 272 + if err := db.DeleteIssues(tx, issue.Did, issue.Rkey); err != nil { 265 273 l.Error("failed to delete issue", "err", err) 266 274 rp.pages.Notice(w, noticeId, "Failed to delete issue.") 267 275 return 268 276 } 277 277 + tx.Commit() 269 278 270 279 rp.notifier.DeleteIssue(r.Context(), issue) 271 280 ··· 402 411 replyTo = &replyToUri 403 412 } 404 413 405 405 - mentions, _ := rp.refResolver.Resolve(r.Context(), body) 414 414 + mentions, references := rp.refResolver.Resolve(r.Context(), body) 406 415 407 416 comment := models.IssueComment{ 408 408 - Did: user.Did, 409 409 - Rkey: tid.TID(), 410 410 - IssueAt: issue.AtUri().String(), 411 411 - ReplyTo: replyTo, 412 412 - Body: body, 413 413 - Created: time.Now(), 417 417 + Did: user.Did, 418 418 + Rkey: tid.TID(), 419 419 + IssueAt: issue.AtUri().String(), 420 420 + ReplyTo: replyTo, 421 421 + Body: body, 422 422 + Created: time.Now(), 423 423 + Mentions: mentions, 424 424 + References: references, 414 425 } 415 426 if err = rp.validator.ValidateIssueComment(&comment); err != nil { 416 427 l.Error("failed to validate comment", "err", err) ··· 447 458 } 448 459 }() 449 460 450 450 - commentId, err := db.AddIssueComment(rp.db, comment) 461 461 + tx, err := rp.db.Begin() 462 462 + if err != nil { 463 463 + l.Error("failed to start transaction", "err", err) 464 464 + rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.") 465 465 + return 466 466 + } 467 467 + defer tx.Rollback() 468 468 + 469 469 + commentId, err := db.AddIssueComment(tx, comment) 451 470 if err != nil { 452 471 l.Error("failed to create comment", "err", err) 453 472 rp.pages.Notice(w, "issue-comment", "Failed to create comment.") ··· 569 588 newComment.Edited = &now 570 589 record := newComment.AsRecord() 571 590 572 572 - _, err = db.AddIssueComment(rp.db, newComment) 591 591 + tx, err := rp.db.Begin() 592 592 + if err != nil { 593 593 + l.Error("failed to start transaction", "err", err) 594 594 + rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") 595 595 + return 596 596 + } 597 597 + defer tx.Rollback() 598 598 + 599 599 + _, err = db.AddIssueComment(tx, newComment) 573 600 if err != nil { 574 601 l.Error("failed to perferom update-description query", "err", err) 575 602 rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.") 576 603 return 577 604 } 605 605 + tx.Commit() 578 606 579 607 // rkey is optional, it was introduced later 580 608 if newComment.Rkey != "" { ··· 881 909 }) 882 910 case http.MethodPost: 883 911 body := r.FormValue("body") 884 884 - mentions, _ := rp.refResolver.Resolve(r.Context(), body) 912 912 + mentions, references := rp.refResolver.Resolve(r.Context(), body) 885 913 886 914 issue := &models.Issue{ 887 887 - RepoAt: f.RepoAt(), 888 888 - Rkey: tid.TID(), 889 889 - Title: r.FormValue("title"), 890 890 - Body: body, 891 891 - Open: true, 892 892 - Did: user.Did, 893 893 - Created: time.Now(), 894 894 - Repo: &f.Repo, 915 915 + RepoAt: f.RepoAt(), 916 916 + Rkey: tid.TID(), 917 917 + Title: r.FormValue("title"), 918 918 + Body: body, 919 919 + Open: true, 920 920 + Did: user.Did, 921 921 + Created: time.Now(), 922 922 + Mentions: mentions, 923 923 + References: references, 924 924 + Repo: &f.Repo, 895 925 } 896 926 897 927 if err := rp.validator.ValidateIssue(issue); err != nil {

+52 -28

appview/models/issue.go

··· 10 10 ) 11 11 12 12 type Issue struct { 13 13 - Id int64 14 14 - Did string 15 15 - Rkey string 16 16 - RepoAt syntax.ATURI 17 17 - IssueId int 18 18 - Created time.Time 19 19 - Edited *time.Time 20 20 - Deleted *time.Time 21 21 - Title string 22 22 - Body string 23 23 - Open bool 13 13 + Id int64 14 14 + Did string 15 15 + Rkey string 16 16 + RepoAt syntax.ATURI 17 17 + IssueId int 18 18 + Created time.Time 19 19 + Edited *time.Time 20 20 + Deleted *time.Time 21 21 + Title string 22 22 + Body string 23 23 + Open bool 24 24 + Mentions []syntax.DID 25 25 + References []syntax.ATURI 24 26 25 27 // optionally, populate this when querying for reverse mappings 26 28 // like comment counts, parent repo etc. ··· 34 36 } 35 37 36 38 func (i *Issue) AsRecord() tangled.RepoIssue { 39 39 + mentions := make([]string, len(i.Mentions)) 40 40 + for i, did := range i.Mentions { 41 41 + mentions[i] = string(did) 42 42 + } 43 43 + references := make([]string, len(i.References)) 44 44 + for i, uri := range i.References { 45 45 + references[i] = string(uri) 46 46 + } 37 47 return tangled.RepoIssue{ 38 38 - Repo: i.RepoAt.String(), 39 39 - Title: i.Title, 40 40 - Body: &i.Body, 41 41 - CreatedAt: i.Created.Format(time.RFC3339), 48 48 + Repo: i.RepoAt.String(), 49 49 + Title: i.Title, 50 50 + Body: &i.Body, 51 51 + Mentions: mentions, 52 52 + References: references, 53 53 + CreatedAt: i.Created.Format(time.RFC3339), 42 54 } 43 55 } 44 56 ··· 161 173 } 162 174 163 175 type IssueComment struct { 164 164 - Id int64 165 165 - Did string 166 166 - Rkey string 167 167 - IssueAt string 168 168 - ReplyTo *string 169 169 - Body string 170 170 - Created time.Time 171 171 - Edited *time.Time 172 172 - Deleted *time.Time 176 176 + Id int64 177 177 + Did string 178 178 + Rkey string 179 179 + IssueAt string 180 180 + ReplyTo *string 181 181 + Body string 182 182 + Created time.Time 183 183 + Edited *time.Time 184 184 + Deleted *time.Time 185 185 + Mentions []syntax.DID 186 186 + References []syntax.ATURI 173 187 } 174 188 175 189 func (i *IssueComment) AtUri() syntax.ATURI { ··· 177 191 } 178 192 179 193 func (i *IssueComment) AsRecord() tangled.RepoIssueComment { 194 194 + mentions := make([]string, len(i.Mentions)) 195 195 + for i, did := range i.Mentions { 196 196 + mentions[i] = string(did) 197 197 + } 198 198 + references := make([]string, len(i.References)) 199 199 + for i, uri := range i.References { 200 200 + references[i] = string(uri) 201 201 + } 180 202 return tangled.RepoIssueComment{ 181 181 - Body: i.Body, 182 182 - Issue: i.IssueAt, 183 183 - CreatedAt: i.Created.Format(time.RFC3339), 184 184 - ReplyTo: i.ReplyTo, 203 203 + Body: i.Body, 204 204 + Issue: i.IssueAt, 205 205 + CreatedAt: i.Created.Format(time.RFC3339), 206 206 + ReplyTo: i.ReplyTo, 207 207 + Mentions: mentions, 208 208 + References: references, 185 209 } 186 210 } 187 211

+26

appview/models/pull.go

··· 147 147 // content 148 148 Body string 149 149 150 150 + // meta 151 151 + Mentions []syntax.DID 152 152 + References []syntax.ATURI 153 153 + 150 154 // meta 151 155 Created time.Time 152 156 } 153 157 158 158 + func (p *PullComment) AtUri() syntax.ATURI { 159 159 + return syntax.ATURI(p.CommentAt) 160 160 + } 161 161 + 162 162 + // func (p *PullComment) AsRecord() tangled.RepoPullComment { 163 163 + // mentions := make([]string, len(p.Mentions)) 164 164 + // for i, did := range p.Mentions { 165 165 + // mentions[i] = string(did) 166 166 + // } 167 167 + // references := make([]string, len(p.References)) 168 168 + // for i, uri := range p.References { 169 169 + // references[i] = string(uri) 170 170 + // } 171 171 + // return tangled.RepoPullComment{ 172 172 + // Pull: p.PullAt, 173 173 + // Body: p.Body, 174 174 + // Mentions: mentions, 175 175 + // References: references, 176 176 + // CreatedAt: p.Created.Format(time.RFC3339), 177 177 + // } 178 178 + // } 179 179 + 154 180 func (p *Pull) LastRoundNumber() int { 155 181 return len(p.Submissions) - 1 156 182 }

+3 -1

appview/pulls/pulls.go

··· 733 733 return 734 734 } 735 735 736 736 - mentions, _ := s.refResolver.Resolve(r.Context(), body) 736 736 + mentions, references := s.refResolver.Resolve(r.Context(), body) 737 737 738 738 // Start a transaction 739 739 tx, err := s.db.BeginTx(r.Context(), nil) ··· 777 777 Body: body, 778 778 CommentAt: atResp.Uri, 779 779 SubmissionId: pull.Submissions[roundNumber].ID, 780 780 + Mentions: mentions, 781 781 + References: references, 780 782 } 781 783 782 784 // Create the pull comment in the database with the commentAt field

+14

lexicons/issue/comment.json

··· 29 29 "replyTo": { 30 30 "type": "string", 31 31 "format": "at-uri" 32 32 + }, 33 33 + "mentions": { 34 34 + "type": "array", 35 35 + "items": { 36 36 + "type": "string", 37 37 + "format": "did" 38 38 + } 39 39 + }, 40 40 + "references": { 41 41 + "type": "array", 42 42 + "items": { 43 43 + "type": "string", 44 44 + "format": "at-uri" 45 45 + } 32 46 } 33 47 } 34 48 }

+14

lexicons/issue/issue.json

··· 24 24 "createdAt": { 25 25 "type": "string", 26 26 "format": "datetime" 27 27 + }, 28 28 + "mentions": { 29 29 + "type": "array", 30 30 + "items": { 31 31 + "type": "string", 32 32 + "format": "did" 33 33 + } 34 34 + }, 35 35 + "references": { 36 36 + "type": "array", 37 37 + "items": { 38 38 + "type": "string", 39 39 + "format": "at-uri" 40 40 + } 27 41 } 28 42 } 29 43 }

+14

lexicons/pulls/comment.json

··· 25 25 "createdAt": { 26 26 "type": "string", 27 27 "format": "datetime" 28 28 + }, 29 29 + "mentions": { 30 30 + "type": "array", 31 31 + "items": { 32 32 + "type": "string", 33 33 + "format": "did" 34 34 + } 35 35 + }, 36 36 + "references": { 37 37 + "type": "array", 38 38 + "items": { 39 39 + "type": "string", 40 40 + "format": "at-uri" 41 41 + } 28 42 } 29 43 } 30 44 }