commit 3b2409e95a28df2eadf72b50497d1b2bde6d44ab · julien.rbrt.fr/tangled-core

+649 -8

api/tangled/cbor_gen.go

···

       6938
       6938
        
       	}

     

       6939
       6939
        
       

     

       6940
       6940
        
       	cw := cbg.NewCborWriter(w)

     

       6941
       6941
       -
       	fieldCount := 5

     

       6941
       6941
       +
       	fieldCount := 7

     

       6942
       6942
        
       

     

       6943
       6943
        
       	if t.Body == nil {

     

       6944
       6944
       +
       		fieldCount--

     

       6945
       6945
       +
       	}

     

       6946
       6946
       +
       

     

       6947
       6947
       +
       	if t.Mentions == nil {

     

       6948
       6948
       +
       		fieldCount--

     

       6949
       6949
       +
       	}

     

       6950
       6950
       +
       

     

       6951
       6951
       +
       	if t.References == nil {

     

       6944
       6952
        
       		fieldCount--

     

       6945
       6953
        
       	}

     

       6946
       6954
        
       

     
···

       7045
       7053
        
       		return err

     

       7046
       7054
        
       	}

     

       7047
       7055
        
       

     

       7056
       7056
       +
       	// t.Mentions ([]string) (slice)

     

       7057
       7057
       +
       	if t.Mentions != nil {

     

       7058
       7058
       +
       

     

       7059
       7059
       +
       		if len("mentions") > 1000000 {

     

       7060
       7060
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       7061
       7061
       +
       		}

     

       7062
       7062
       +
       

     

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

     

       7064
       7064
       +
       			return err

     

       7065
       7065
       +
       		}

     

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

     

       7067
       7067
       +
       			return err

     

       7068
       7068
       +
       		}

     

       7069
       7069
       +
       

     

       7070
       7070
       +
       		if len(t.Mentions) > 8192 {

     

       7071
       7071
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       7072
       7072
       +
       		}

     

       7073
       7073
       +
       

     

       7074
       7074
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       7075
       7075
       +
       			return err

     

       7076
       7076
       +
       		}

     

       7077
       7077
       +
       		for _, v := range t.Mentions {

     

       7078
       7078
       +
       			if len(v) > 1000000 {

     

       7079
       7079
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7080
       7080
       +
       			}

     

       7081
       7081
       +
       

     

       7082
       7082
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7083
       7083
       +
       				return err

     

       7084
       7084
       +
       			}

     

       7085
       7085
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7086
       7086
       +
       				return err

     

       7087
       7087
       +
       			}

     

       7088
       7088
       +
       

     

       7089
       7089
       +
       		}

     

       7090
       7090
       +
       	}

     

       7091
       7091
       +
       

     

       7048
       7092
        
       	// t.CreatedAt (string) (string)

     

       7049
       7093
        
       	if len("createdAt") > 1000000 {

     

       7050
       7094
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

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

     

       7068
       7112
        
       		return err

     

       7069
       7113
        
       	}

     

       7114
       7114
       +
       

     

       7115
       7115
       +
       	// t.References ([]string) (slice)

     

       7116
       7116
       +
       	if t.References != nil {

     

       7117
       7117
       +
       

     

       7118
       7118
       +
       		if len("references") > 1000000 {

     

       7119
       7119
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       7120
       7120
       +
       		}

     

       7121
       7121
       +
       

     

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

     

       7123
       7123
       +
       			return err

     

       7124
       7124
       +
       		}

     

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

     

       7126
       7126
       +
       			return err

     

       7127
       7127
       +
       		}

     

       7128
       7128
       +
       

     

       7129
       7129
       +
       		if len(t.References) > 8192 {

     

       7130
       7130
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       7131
       7131
       +
       		}

     

       7132
       7132
       +
       

     

       7133
       7133
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       7134
       7134
       +
       			return err

     

       7135
       7135
       +
       		}

     

       7136
       7136
       +
       		for _, v := range t.References {

     

       7137
       7137
       +
       			if len(v) > 1000000 {

     

       7138
       7138
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7139
       7139
       +
       			}

     

       7140
       7140
       +
       

     

       7141
       7141
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7142
       7142
       +
       				return err

     

       7143
       7143
       +
       			}

     

       7144
       7144
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7145
       7145
       +
       				return err

     

       7146
       7146
       +
       			}

     

       7147
       7147
       +
       

     

       7148
       7148
       +
       		}

     

       7149
       7149
       +
       	}

     

       7070
       7150
        
       	return nil

     

       7071
       7151
        
       }

     

       7072
       7152
        
       

     
···

       7095
       7175
        
       

     

       7096
       7176
        
       	n := extra

     

       7097
       7177
        
       

     

       7098
       7098
       -
       	nameBuf := make([]byte, 9)

     

       7178
       7178
       +
       	nameBuf := make([]byte, 10)

     

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

     

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

     

       7101
       7181
        
       		if err != nil {

     
···

       7164
       7244
        
       				}

     

       7165
       7245
        
       

     

       7166
       7246
        
       				t.Title = string(sval)

     

       7247
       7247
       +
       			}

     

       7248
       7248
       +
       			// t.Mentions ([]string) (slice)

     

       7249
       7249
       +
       		case "mentions":

     

       7250
       7250
       +
       

     

       7251
       7251
       +
       			maj, extra, err = cr.ReadHeader()

     

       7252
       7252
       +
       			if err != nil {

     

       7253
       7253
       +
       				return err

     

       7254
       7254
       +
       			}

     

       7255
       7255
       +
       

     

       7256
       7256
       +
       			if extra > 8192 {

     

       7257
       7257
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       7258
       7258
       +
       			}

     

       7259
       7259
       +
       

     

       7260
       7260
       +
       			if maj != cbg.MajArray {

     

       7261
       7261
       +
       				return fmt.Errorf("expected cbor array")

     

       7262
       7262
       +
       			}

     

       7263
       7263
       +
       

     

       7264
       7264
       +
       			if extra > 0 {

     

       7265
       7265
       +
       				t.Mentions = make([]string, extra)

     

       7266
       7266
       +
       			}

     

       7267
       7267
       +
       

     

       7268
       7268
       +
       			for i := 0; i < int(extra); i++ {

     

       7269
       7269
       +
       				{

     

       7270
       7270
       +
       					var maj byte

     

       7271
       7271
       +
       					var extra uint64

     

       7272
       7272
       +
       					var err error

     

       7273
       7273
       +
       					_ = maj

     

       7274
       7274
       +
       					_ = extra

     

       7275
       7275
       +
       					_ = err

     

       7276
       7276
       +
       

     

       7277
       7277
       +
       					{

     

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

     

       7279
       7279
       +
       						if err != nil {

     

       7280
       7280
       +
       							return err

     

       7281
       7281
       +
       						}

     

       7282
       7282
       +
       

     

       7283
       7283
       +
       						t.Mentions[i] = string(sval)

     

       7284
       7284
       +
       					}

     

       7285
       7285
       +
       

     

       7286
       7286
       +
       				}

     

       7167
       7287
        
       			}

     

       7168
       7288
        
       			// t.CreatedAt (string) (string)

     

       7169
       7289
        
       		case "createdAt":

     
···

       7176
       7296
        
       

     

       7177
       7297
        
       				t.CreatedAt = string(sval)

     

       7178
       7298
        
       			}

     

       7299
       7299
       +
       			// t.References ([]string) (slice)

     

       7300
       7300
       +
       		case "references":

     

       7301
       7301
       +
       

     

       7302
       7302
       +
       			maj, extra, err = cr.ReadHeader()

     

       7303
       7303
       +
       			if err != nil {

     

       7304
       7304
       +
       				return err

     

       7305
       7305
       +
       			}

     

       7306
       7306
       +
       

     

       7307
       7307
       +
       			if extra > 8192 {

     

       7308
       7308
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       7309
       7309
       +
       			}

     

       7310
       7310
       +
       

     

       7311
       7311
       +
       			if maj != cbg.MajArray {

     

       7312
       7312
       +
       				return fmt.Errorf("expected cbor array")

     

       7313
       7313
       +
       			}

     

       7314
       7314
       +
       

     

       7315
       7315
       +
       			if extra > 0 {

     

       7316
       7316
       +
       				t.References = make([]string, extra)

     

       7317
       7317
       +
       			}

     

       7318
       7318
       +
       

     

       7319
       7319
       +
       			for i := 0; i < int(extra); i++ {

     

       7320
       7320
       +
       				{

     

       7321
       7321
       +
       					var maj byte

     

       7322
       7322
       +
       					var extra uint64

     

       7323
       7323
       +
       					var err error

     

       7324
       7324
       +
       					_ = maj

     

       7325
       7325
       +
       					_ = extra

     

       7326
       7326
       +
       					_ = err

     

       7327
       7327
       +
       

     

       7328
       7328
       +
       					{

     

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

     

       7330
       7330
       +
       						if err != nil {

     

       7331
       7331
       +
       							return err

     

       7332
       7332
       +
       						}

     

       7333
       7333
       +
       

     

       7334
       7334
       +
       						t.References[i] = string(sval)

     

       7335
       7335
       +
       					}

     

       7336
       7336
       +
       

     

       7337
       7337
       +
       				}

     

       7338
       7338
       +
       			}

     

       7179
       7339
        
       

     

       7180
       7340
        
       		default:

     

       7181
       7341
        
       			// Field doesn't exist on this type, so ignore it

     
···

       7194
       7354
        
       	}

     

       7195
       7355
        
       

     

       7196
       7356
        
       	cw := cbg.NewCborWriter(w)

     

       7197
       7197
       -
       	fieldCount := 5

     

       7357
       7357
       +
       	fieldCount := 7

     

       7358
       7358
       +
       

     

       7359
       7359
       +
       	if t.Mentions == nil {

     

       7360
       7360
       +
       		fieldCount--

     

       7361
       7361
       +
       	}

     

       7362
       7362
       +
       

     

       7363
       7363
       +
       	if t.References == nil {

     

       7364
       7364
       +
       		fieldCount--

     

       7365
       7365
       +
       	}

     

       7198
       7366
        
       

     

       7199
       7367
        
       	if t.ReplyTo == nil {

     

       7200
       7368
        
       		fieldCount--

     
···

       7301
       7469
        
       		}

     

       7302
       7470
        
       	}

     

       7303
       7471
        
       

     

       7472
       7472
       +
       	// t.Mentions ([]string) (slice)

     

       7473
       7473
       +
       	if t.Mentions != nil {

     

       7474
       7474
       +
       

     

       7475
       7475
       +
       		if len("mentions") > 1000000 {

     

       7476
       7476
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       7477
       7477
       +
       		}

     

       7478
       7478
       +
       

     

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

     

       7480
       7480
       +
       			return err

     

       7481
       7481
       +
       		}

     

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

     

       7483
       7483
       +
       			return err

     

       7484
       7484
       +
       		}

     

       7485
       7485
       +
       

     

       7486
       7486
       +
       		if len(t.Mentions) > 8192 {

     

       7487
       7487
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       7488
       7488
       +
       		}

     

       7489
       7489
       +
       

     

       7490
       7490
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       7491
       7491
       +
       			return err

     

       7492
       7492
       +
       		}

     

       7493
       7493
       +
       		for _, v := range t.Mentions {

     

       7494
       7494
       +
       			if len(v) > 1000000 {

     

       7495
       7495
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7496
       7496
       +
       			}

     

       7497
       7497
       +
       

     

       7498
       7498
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7499
       7499
       +
       				return err

     

       7500
       7500
       +
       			}

     

       7501
       7501
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7502
       7502
       +
       				return err

     

       7503
       7503
       +
       			}

     

       7504
       7504
       +
       

     

       7505
       7505
       +
       		}

     

       7506
       7506
       +
       	}

     

       7507
       7507
       +
       

     

       7304
       7508
        
       	// t.CreatedAt (string) (string)

     

       7305
       7509
        
       	if len("createdAt") > 1000000 {

     

       7306
       7510
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

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

     

       7324
       7528
        
       		return err

     

       7325
       7529
        
       	}

     

       7530
       7530
       +
       

     

       7531
       7531
       +
       	// t.References ([]string) (slice)

     

       7532
       7532
       +
       	if t.References != nil {

     

       7533
       7533
       +
       

     

       7534
       7534
       +
       		if len("references") > 1000000 {

     

       7535
       7535
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       7536
       7536
       +
       		}

     

       7537
       7537
       +
       

     

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

     

       7539
       7539
       +
       			return err

     

       7540
       7540
       +
       		}

     

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

     

       7542
       7542
       +
       			return err

     

       7543
       7543
       +
       		}

     

       7544
       7544
       +
       

     

       7545
       7545
       +
       		if len(t.References) > 8192 {

     

       7546
       7546
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       7547
       7547
       +
       		}

     

       7548
       7548
       +
       

     

       7549
       7549
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       7550
       7550
       +
       			return err

     

       7551
       7551
       +
       		}

     

       7552
       7552
       +
       		for _, v := range t.References {

     

       7553
       7553
       +
       			if len(v) > 1000000 {

     

       7554
       7554
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       7555
       7555
       +
       			}

     

       7556
       7556
       +
       

     

       7557
       7557
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       7558
       7558
       +
       				return err

     

       7559
       7559
       +
       			}

     

       7560
       7560
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       7561
       7561
       +
       				return err

     

       7562
       7562
       +
       			}

     

       7563
       7563
       +
       

     

       7564
       7564
       +
       		}

     

       7565
       7565
       +
       	}

     

       7326
       7566
        
       	return nil

     

       7327
       7567
        
       }

     

       7328
       7568
        
       

     
···

       7351
       7591
        
       

     

       7352
       7592
        
       	n := extra

     

       7353
       7593
        
       

     

       7354
       7354
       -
       	nameBuf := make([]byte, 9)

     

       7594
       7594
       +
       	nameBuf := make([]byte, 10)

     

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

     

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

     

       7357
       7597
        
       		if err != nil {

     
···

       7419
       7659
        
       					}

     

       7420
       7660
        
       

     

       7421
       7661
        
       					t.ReplyTo = (*string)(&sval)

     

       7662
       7662
       +
       				}

     

       7663
       7663
       +
       			}

     

       7664
       7664
       +
       			// t.Mentions ([]string) (slice)

     

       7665
       7665
       +
       		case "mentions":

     

       7666
       7666
       +
       

     

       7667
       7667
       +
       			maj, extra, err = cr.ReadHeader()

     

       7668
       7668
       +
       			if err != nil {

     

       7669
       7669
       +
       				return err

     

       7670
       7670
       +
       			}

     

       7671
       7671
       +
       

     

       7672
       7672
       +
       			if extra > 8192 {

     

       7673
       7673
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       7674
       7674
       +
       			}

     

       7675
       7675
       +
       

     

       7676
       7676
       +
       			if maj != cbg.MajArray {

     

       7677
       7677
       +
       				return fmt.Errorf("expected cbor array")

     

       7678
       7678
       +
       			}

     

       7679
       7679
       +
       

     

       7680
       7680
       +
       			if extra > 0 {

     

       7681
       7681
       +
       				t.Mentions = make([]string, extra)

     

       7682
       7682
       +
       			}

     

       7683
       7683
       +
       

     

       7684
       7684
       +
       			for i := 0; i < int(extra); i++ {

     

       7685
       7685
       +
       				{

     

       7686
       7686
       +
       					var maj byte

     

       7687
       7687
       +
       					var extra uint64

     

       7688
       7688
       +
       					var err error

     

       7689
       7689
       +
       					_ = maj

     

       7690
       7690
       +
       					_ = extra

     

       7691
       7691
       +
       					_ = err

     

       7692
       7692
       +
       

     

       7693
       7693
       +
       					{

     

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

     

       7695
       7695
       +
       						if err != nil {

     

       7696
       7696
       +
       							return err

     

       7697
       7697
       +
       						}

     

       7698
       7698
       +
       

     

       7699
       7699
       +
       						t.Mentions[i] = string(sval)

     

       7700
       7700
       +
       					}

     

       7701
       7701
       +
       

     

       7422
       7702
        
       				}

     

       7423
       7703
        
       			}

     

       7424
       7704
        
       			// t.CreatedAt (string) (string)

     
···

       7431
       7711
        
       				}

     

       7432
       7712
        
       

     

       7433
       7713
        
       				t.CreatedAt = string(sval)

     

       7714
       7714
       +
       			}

     

       7715
       7715
       +
       			// t.References ([]string) (slice)

     

       7716
       7716
       +
       		case "references":

     

       7717
       7717
       +
       

     

       7718
       7718
       +
       			maj, extra, err = cr.ReadHeader()

     

       7719
       7719
       +
       			if err != nil {

     

       7720
       7720
       +
       				return err

     

       7721
       7721
       +
       			}

     

       7722
       7722
       +
       

     

       7723
       7723
       +
       			if extra > 8192 {

     

       7724
       7724
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       7725
       7725
       +
       			}

     

       7726
       7726
       +
       

     

       7727
       7727
       +
       			if maj != cbg.MajArray {

     

       7728
       7728
       +
       				return fmt.Errorf("expected cbor array")

     

       7729
       7729
       +
       			}

     

       7730
       7730
       +
       

     

       7731
       7731
       +
       			if extra > 0 {

     

       7732
       7732
       +
       				t.References = make([]string, extra)

     

       7733
       7733
       +
       			}

     

       7734
       7734
       +
       

     

       7735
       7735
       +
       			for i := 0; i < int(extra); i++ {

     

       7736
       7736
       +
       				{

     

       7737
       7737
       +
       					var maj byte

     

       7738
       7738
       +
       					var extra uint64

     

       7739
       7739
       +
       					var err error

     

       7740
       7740
       +
       					_ = maj

     

       7741
       7741
       +
       					_ = extra

     

       7742
       7742
       +
       					_ = err

     

       7743
       7743
       +
       

     

       7744
       7744
       +
       					{

     

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

     

       7746
       7746
       +
       						if err != nil {

     

       7747
       7747
       +
       							return err

     

       7748
       7748
       +
       						}

     

       7749
       7749
       +
       

     

       7750
       7750
       +
       						t.References[i] = string(sval)

     

       7751
       7751
       +
       					}

     

       7752
       7752
       +
       

     

       7753
       7753
       +
       				}

     

       7434
       7754
        
       			}

     

       7435
       7755
        
       

     

       7436
       7756
        
       		default:

     
···

       7614
       7934
        
       	}

     

       7615
       7935
        
       

     

       7616
       7936
        
       	cw := cbg.NewCborWriter(w)

     

       7617
       7617
       -
       	fieldCount := 7

     

       7937
       7937
       +
       	fieldCount := 9

     

       7618
       7938
        
       

     

       7619
       7939
        
       	if t.Body == nil {

     

       7940
       7940
       +
       		fieldCount--

     

       7941
       7941
       +
       	}

     

       7942
       7942
       +
       

     

       7943
       7943
       +
       	if t.Mentions == nil {

     

       7944
       7944
       +
       		fieldCount--

     

       7945
       7945
       +
       	}

     

       7946
       7946
       +
       

     

       7947
       7947
       +
       	if t.References == nil {

     

       7620
       7948
        
       		fieldCount--

     

       7621
       7949
        
       	}

     

       7622
       7950
        
       

     
···

       7760
       8088
        
       		return err

     

       7761
       8089
        
       	}

     

       7762
       8090
        
       

     

       8091
       8091
       +
       	// t.Mentions ([]string) (slice)

     

       8092
       8092
       +
       	if t.Mentions != nil {

     

       8093
       8093
       +
       

     

       8094
       8094
       +
       		if len("mentions") > 1000000 {

     

       8095
       8095
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       8096
       8096
       +
       		}

     

       8097
       8097
       +
       

     

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

     

       8099
       8099
       +
       			return err

     

       8100
       8100
       +
       		}

     

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

     

       8102
       8102
       +
       			return err

     

       8103
       8103
       +
       		}

     

       8104
       8104
       +
       

     

       8105
       8105
       +
       		if len(t.Mentions) > 8192 {

     

       8106
       8106
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       8107
       8107
       +
       		}

     

       8108
       8108
       +
       

     

       8109
       8109
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       8110
       8110
       +
       			return err

     

       8111
       8111
       +
       		}

     

       8112
       8112
       +
       		for _, v := range t.Mentions {

     

       8113
       8113
       +
       			if len(v) > 1000000 {

     

       8114
       8114
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8115
       8115
       +
       			}

     

       8116
       8116
       +
       

     

       8117
       8117
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8118
       8118
       +
       				return err

     

       8119
       8119
       +
       			}

     

       8120
       8120
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8121
       8121
       +
       				return err

     

       8122
       8122
       +
       			}

     

       8123
       8123
       +
       

     

       8124
       8124
       +
       		}

     

       8125
       8125
       +
       	}

     

       8126
       8126
       +
       

     

       7763
       8127
        
       	// t.CreatedAt (string) (string)

     

       7764
       8128
        
       	if len("createdAt") > 1000000 {

     

       7765
       8129
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

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

     

       7783
       8147
        
       		return err

     

       7784
       8148
        
       	}

     

       8149
       8149
       +
       

     

       8150
       8150
       +
       	// t.References ([]string) (slice)

     

       8151
       8151
       +
       	if t.References != nil {

     

       8152
       8152
       +
       

     

       8153
       8153
       +
       		if len("references") > 1000000 {

     

       8154
       8154
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       8155
       8155
       +
       		}

     

       8156
       8156
       +
       

     

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

     

       8158
       8158
       +
       			return err

     

       8159
       8159
       +
       		}

     

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

     

       8161
       8161
       +
       			return err

     

       8162
       8162
       +
       		}

     

       8163
       8163
       +
       

     

       8164
       8164
       +
       		if len(t.References) > 8192 {

     

       8165
       8165
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       8166
       8166
       +
       		}

     

       8167
       8167
       +
       

     

       8168
       8168
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       8169
       8169
       +
       			return err

     

       8170
       8170
       +
       		}

     

       8171
       8171
       +
       		for _, v := range t.References {

     

       8172
       8172
       +
       			if len(v) > 1000000 {

     

       8173
       8173
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8174
       8174
       +
       			}

     

       8175
       8175
       +
       

     

       8176
       8176
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8177
       8177
       +
       				return err

     

       8178
       8178
       +
       			}

     

       8179
       8179
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8180
       8180
       +
       				return err

     

       8181
       8181
       +
       			}

     

       8182
       8182
       +
       

     

       8183
       8183
       +
       		}

     

       8184
       8184
       +
       	}

     

       7785
       8185
        
       	return nil

     

       7786
       8186
        
       }

     

       7787
       8187
        
       

     
···

       7810
       8210
        
       

     

       7811
       8211
        
       	n := extra

     

       7812
       8212
        
       

     

       7813
       7813
       -
       	nameBuf := make([]byte, 9)

     

       8213
       8213
       +
       	nameBuf := make([]byte, 10)

     

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

     

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

     

       7816
       8216
        
       		if err != nil {

     
···

       7919
       8319
        
       					}

     

       7920
       8320
        
       				}

     

       7921
       8321
        
       

     

       8322
       8322
       +
       			}

     

       8323
       8323
       +
       			// t.Mentions ([]string) (slice)

     

       8324
       8324
       +
       		case "mentions":

     

       8325
       8325
       +
       

     

       8326
       8326
       +
       			maj, extra, err = cr.ReadHeader()

     

       8327
       8327
       +
       			if err != nil {

     

       8328
       8328
       +
       				return err

     

       8329
       8329
       +
       			}

     

       8330
       8330
       +
       

     

       8331
       8331
       +
       			if extra > 8192 {

     

       8332
       8332
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       8333
       8333
       +
       			}

     

       8334
       8334
       +
       

     

       8335
       8335
       +
       			if maj != cbg.MajArray {

     

       8336
       8336
       +
       				return fmt.Errorf("expected cbor array")

     

       8337
       8337
       +
       			}

     

       8338
       8338
       +
       

     

       8339
       8339
       +
       			if extra > 0 {

     

       8340
       8340
       +
       				t.Mentions = make([]string, extra)

     

       8341
       8341
       +
       			}

     

       8342
       8342
       +
       

     

       8343
       8343
       +
       			for i := 0; i < int(extra); i++ {

     

       8344
       8344
       +
       				{

     

       8345
       8345
       +
       					var maj byte

     

       8346
       8346
       +
       					var extra uint64

     

       8347
       8347
       +
       					var err error

     

       8348
       8348
       +
       					_ = maj

     

       8349
       8349
       +
       					_ = extra

     

       8350
       8350
       +
       					_ = err

     

       8351
       8351
       +
       

     

       8352
       8352
       +
       					{

     

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

     

       8354
       8354
       +
       						if err != nil {

     

       8355
       8355
       +
       							return err

     

       8356
       8356
       +
       						}

     

       8357
       8357
       +
       

     

       8358
       8358
       +
       						t.Mentions[i] = string(sval)

     

       8359
       8359
       +
       					}

     

       8360
       8360
       +
       

     

       8361
       8361
       +
       				}

     

       7922
       8362
        
       			}

     

       7923
       8363
        
       			// t.CreatedAt (string) (string)

     

       7924
       8364
        
       		case "createdAt":

     
···

       7931
       8371
        
       

     

       7932
       8372
        
       				t.CreatedAt = string(sval)

     

       7933
       8373
        
       			}

     

       8374
       8374
       +
       			// t.References ([]string) (slice)

     

       8375
       8375
       +
       		case "references":

     

       8376
       8376
       +
       

     

       8377
       8377
       +
       			maj, extra, err = cr.ReadHeader()

     

       8378
       8378
       +
       			if err != nil {

     

       8379
       8379
       +
       				return err

     

       8380
       8380
       +
       			}

     

       8381
       8381
       +
       

     

       8382
       8382
       +
       			if extra > 8192 {

     

       8383
       8383
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       8384
       8384
       +
       			}

     

       8385
       8385
       +
       

     

       8386
       8386
       +
       			if maj != cbg.MajArray {

     

       8387
       8387
       +
       				return fmt.Errorf("expected cbor array")

     

       8388
       8388
       +
       			}

     

       8389
       8389
       +
       

     

       8390
       8390
       +
       			if extra > 0 {

     

       8391
       8391
       +
       				t.References = make([]string, extra)

     

       8392
       8392
       +
       			}

     

       8393
       8393
       +
       

     

       8394
       8394
       +
       			for i := 0; i < int(extra); i++ {

     

       8395
       8395
       +
       				{

     

       8396
       8396
       +
       					var maj byte

     

       8397
       8397
       +
       					var extra uint64

     

       8398
       8398
       +
       					var err error

     

       8399
       8399
       +
       					_ = maj

     

       8400
       8400
       +
       					_ = extra

     

       8401
       8401
       +
       					_ = err

     

       8402
       8402
       +
       

     

       8403
       8403
       +
       					{

     

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

     

       8405
       8405
       +
       						if err != nil {

     

       8406
       8406
       +
       							return err

     

       8407
       8407
       +
       						}

     

       8408
       8408
       +
       

     

       8409
       8409
       +
       						t.References[i] = string(sval)

     

       8410
       8410
       +
       					}

     

       8411
       8411
       +
       

     

       8412
       8412
       +
       				}

     

       8413
       8413
       +
       			}

     

       7934
       8414
        
       

     

       7935
       8415
        
       		default:

     

       7936
       8416
        
       			// Field doesn't exist on this type, so ignore it

     
···

       7949
       8429
        
       	}

     

       7950
       8430
        
       

     

       7951
       8431
        
       	cw := cbg.NewCborWriter(w)

     

       8432
       8432
       +
       	fieldCount := 6

     

       7952
       8433
        
       

     

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

     

       8434
       8434
       +
       	if t.Mentions == nil {

     

       8435
       8435
       +
       		fieldCount--

     

       8436
       8436
       +
       	}

     

       8437
       8437
       +
       

     

       8438
       8438
       +
       	if t.References == nil {

     

       8439
       8439
       +
       		fieldCount--

     

       8440
       8440
       +
       	}

     

       8441
       8441
       +
       

     

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

     

       7954
       8443
        
       		return err

     

       7955
       8444
        
       	}

     

       7956
       8445
        
       

     
···

       8019
       8508
        
       		return err

     

       8020
       8509
        
       	}

     

       8021
       8510
        
       

     

       8511
       8511
       +
       	// t.Mentions ([]string) (slice)

     

       8512
       8512
       +
       	if t.Mentions != nil {

     

       8513
       8513
       +
       

     

       8514
       8514
       +
       		if len("mentions") > 1000000 {

     

       8515
       8515
       +
       			return xerrors.Errorf("Value in field \"mentions\" was too long")

     

       8516
       8516
       +
       		}

     

       8517
       8517
       +
       

     

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

     

       8519
       8519
       +
       			return err

     

       8520
       8520
       +
       		}

     

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

     

       8522
       8522
       +
       			return err

     

       8523
       8523
       +
       		}

     

       8524
       8524
       +
       

     

       8525
       8525
       +
       		if len(t.Mentions) > 8192 {

     

       8526
       8526
       +
       			return xerrors.Errorf("Slice value in field t.Mentions was too long")

     

       8527
       8527
       +
       		}

     

       8528
       8528
       +
       

     

       8529
       8529
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Mentions))); err != nil {

     

       8530
       8530
       +
       			return err

     

       8531
       8531
       +
       		}

     

       8532
       8532
       +
       		for _, v := range t.Mentions {

     

       8533
       8533
       +
       			if len(v) > 1000000 {

     

       8534
       8534
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8535
       8535
       +
       			}

     

       8536
       8536
       +
       

     

       8537
       8537
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8538
       8538
       +
       				return err

     

       8539
       8539
       +
       			}

     

       8540
       8540
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8541
       8541
       +
       				return err

     

       8542
       8542
       +
       			}

     

       8543
       8543
       +
       

     

       8544
       8544
       +
       		}

     

       8545
       8545
       +
       	}

     

       8546
       8546
       +
       

     

       8022
       8547
        
       	// t.CreatedAt (string) (string)

     

       8023
       8548
        
       	if len("createdAt") > 1000000 {

     

       8024
       8549
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

       8040
       8565
        
       	}

     

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

     

       8042
       8567
        
       		return err

     

       8568
       8568
       +
       	}

     

       8569
       8569
       +
       

     

       8570
       8570
       +
       	// t.References ([]string) (slice)

     

       8571
       8571
       +
       	if t.References != nil {

     

       8572
       8572
       +
       

     

       8573
       8573
       +
       		if len("references") > 1000000 {

     

       8574
       8574
       +
       			return xerrors.Errorf("Value in field \"references\" was too long")

     

       8575
       8575
       +
       		}

     

       8576
       8576
       +
       

     

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

     

       8578
       8578
       +
       			return err

     

       8579
       8579
       +
       		}

     

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

     

       8581
       8581
       +
       			return err

     

       8582
       8582
       +
       		}

     

       8583
       8583
       +
       

     

       8584
       8584
       +
       		if len(t.References) > 8192 {

     

       8585
       8585
       +
       			return xerrors.Errorf("Slice value in field t.References was too long")

     

       8586
       8586
       +
       		}

     

       8587
       8587
       +
       

     

       8588
       8588
       +
       		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.References))); err != nil {

     

       8589
       8589
       +
       			return err

     

       8590
       8590
       +
       		}

     

       8591
       8591
       +
       		for _, v := range t.References {

     

       8592
       8592
       +
       			if len(v) > 1000000 {

     

       8593
       8593
       +
       				return xerrors.Errorf("Value in field v was too long")

     

       8594
       8594
       +
       			}

     

       8595
       8595
       +
       

     

       8596
       8596
       +
       			if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       8597
       8597
       +
       				return err

     

       8598
       8598
       +
       			}

     

       8599
       8599
       +
       			if _, err := cw.WriteString(string(v)); err != nil {

     

       8600
       8600
       +
       				return err

     

       8601
       8601
       +
       			}

     

       8602
       8602
       +
       

     

       8603
       8603
       +
       		}

     

       8043
       8604
        
       	}

     

       8044
       8605
        
       	return nil

     

       8045
       8606
        
       }

     
···

       8069
       8630
        
       

     

       8070
       8631
        
       	n := extra

     

       8071
       8632
        
       

     

       8072
       8072
       -
       	nameBuf := make([]byte, 9)

     

       8633
       8633
       +
       	nameBuf := make([]byte, 10)

     

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

     

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

     

       8075
       8636
        
       		if err != nil {

     
···

       8118
       8679
        
       

     

       8119
       8680
        
       				t.LexiconTypeID = string(sval)

     

       8120
       8681
        
       			}

     

       8682
       8682
       +
       			// t.Mentions ([]string) (slice)

     

       8683
       8683
       +
       		case "mentions":

     

       8684
       8684
       +
       

     

       8685
       8685
       +
       			maj, extra, err = cr.ReadHeader()

     

       8686
       8686
       +
       			if err != nil {

     

       8687
       8687
       +
       				return err

     

       8688
       8688
       +
       			}

     

       8689
       8689
       +
       

     

       8690
       8690
       +
       			if extra > 8192 {

     

       8691
       8691
       +
       				return fmt.Errorf("t.Mentions: array too large (%d)", extra)

     

       8692
       8692
       +
       			}

     

       8693
       8693
       +
       

     

       8694
       8694
       +
       			if maj != cbg.MajArray {

     

       8695
       8695
       +
       				return fmt.Errorf("expected cbor array")

     

       8696
       8696
       +
       			}

     

       8697
       8697
       +
       

     

       8698
       8698
       +
       			if extra > 0 {

     

       8699
       8699
       +
       				t.Mentions = make([]string, extra)

     

       8700
       8700
       +
       			}

     

       8701
       8701
       +
       

     

       8702
       8702
       +
       			for i := 0; i < int(extra); i++ {

     

       8703
       8703
       +
       				{

     

       8704
       8704
       +
       					var maj byte

     

       8705
       8705
       +
       					var extra uint64

     

       8706
       8706
       +
       					var err error

     

       8707
       8707
       +
       					_ = maj

     

       8708
       8708
       +
       					_ = extra

     

       8709
       8709
       +
       					_ = err

     

       8710
       8710
       +
       

     

       8711
       8711
       +
       					{

     

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

     

       8713
       8713
       +
       						if err != nil {

     

       8714
       8714
       +
       							return err

     

       8715
       8715
       +
       						}

     

       8716
       8716
       +
       

     

       8717
       8717
       +
       						t.Mentions[i] = string(sval)

     

       8718
       8718
       +
       					}

     

       8719
       8719
       +
       

     

       8720
       8720
       +
       				}

     

       8721
       8721
       +
       			}

     

       8121
       8722
        
       			// t.CreatedAt (string) (string)

     

       8122
       8723
        
       		case "createdAt":

     

       8123
       8724
        
       

     
···

       8128
       8729
        
       				}

     

       8129
       8730
        
       

     

       8130
       8731
        
       				t.CreatedAt = string(sval)

     

       8732
       8732
       +
       			}

     

       8733
       8733
       +
       			// t.References ([]string) (slice)

     

       8734
       8734
       +
       		case "references":

     

       8735
       8735
       +
       

     

       8736
       8736
       +
       			maj, extra, err = cr.ReadHeader()

     

       8737
       8737
       +
       			if err != nil {

     

       8738
       8738
       +
       				return err

     

       8739
       8739
       +
       			}

     

       8740
       8740
       +
       

     

       8741
       8741
       +
       			if extra > 8192 {

     

       8742
       8742
       +
       				return fmt.Errorf("t.References: array too large (%d)", extra)

     

       8743
       8743
       +
       			}

     

       8744
       8744
       +
       

     

       8745
       8745
       +
       			if maj != cbg.MajArray {

     

       8746
       8746
       +
       				return fmt.Errorf("expected cbor array")

     

       8747
       8747
       +
       			}

     

       8748
       8748
       +
       

     

       8749
       8749
       +
       			if extra > 0 {

     

       8750
       8750
       +
       				t.References = make([]string, extra)

     

       8751
       8751
       +
       			}

     

       8752
       8752
       +
       

     

       8753
       8753
       +
       			for i := 0; i < int(extra); i++ {

     

       8754
       8754
       +
       				{

     

       8755
       8755
       +
       					var maj byte

     

       8756
       8756
       +
       					var extra uint64

     

       8757
       8757
       +
       					var err error

     

       8758
       8758
       +
       					_ = maj

     

       8759
       8759
       +
       					_ = extra

     

       8760
       8760
       +
       					_ = err

     

       8761
       8761
       +
       

     

       8762
       8762
       +
       					{

     

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

     

       8764
       8764
       +
       						if err != nil {

     

       8765
       8765
       +
       							return err

     

       8766
       8766
       +
       						}

     

       8767
       8767
       +
       

     

       8768
       8768
       +
       						t.References[i] = string(sval)

     

       8769
       8769
       +
       					}

     

       8770
       8770
       +
       

     

       8771
       8771
       +
       				}

     

       8131
       8772
        
       			}

     

       8132
       8773
        
       

     

       8133
       8774
        
       		default:

+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
        
       }

api/tangled/repopull.go

···

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

     

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

     

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

     

       23
       23
       +
       	Mentions      []string         `json:"mentions,omitempty" cborgen:"mentions,omitempty"`

     

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

     

       25
       25
       +
       	References    []string         `json:"references,omitempty" cborgen:"references,omitempty"`

     

       24
       26
        
       	Source        *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`

     

       25
       27
        
       	Target        *RepoPull_Target `json:"target" cborgen:"target"`

     

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

appview/db/db.go

···

       561
       561
        
       			email_notifications integer not null default 0

     

       562
       562
        
       		);

     

       563
       563
        
       

     

       564
       564
       +
       		create table if not exists reference_links (

     

       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_at, to_at)

     

       569
       569
       +
       		);

     

       570
       570
       +
       

     

       564
       571
        
       		create table if not exists migrations (

     

       565
       572
        
       			id integer primary key autoincrement,

     

       566
       573
        
       			name text unique

     
···

       569
       576
        
       		-- indexes for better performance

     

       570
       577
        
       		create index if not exists idx_notifications_recipient_created on notifications(recipient_did, created desc);

     

       571
       578
        
       		create index if not exists idx_notifications_recipient_read on notifications(recipient_did, read);

     

       579
       579
       +
       		create index if not exists idx_references_from_at on reference_links(from_at);

     

       580
       580
       +
       		create index if not exists idx_references_to_at on reference_links(to_at);

     

       572
       581
        
       	`)

     

       573
       582
        
       	if err != nil {

     

       574
       583
        
       		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 reference_links: %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 reference_links: %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 reference_links: %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,

     
···

       363
       390
        
       		return 0, err

     

       364
       391
        
       	}

     

       365
       392
        
       

     

       393
       393
       +
       	if err := putReferences(tx, c.AtUri(), c.References); err != nil {

     

       394
       394
       +
       		return 0, fmt.Errorf("put reference_links: %w", err)

     

       395
       395
       +
       	}

     

       396
       396
       +
       

     

       366
       397
        
       	return id, nil

     

       367
       398
        
       }

     

       368
       399
        
       

     
···

       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 reference_links: %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 reference_links: %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 {

+31 -5

appview/db/pulls.go

···

       432
       432
        
       	submissionIds := slices.Collect(maps.Keys(submissionMap))

     

       433
       433
        
       	comments, err := GetPullComments(e, FilterIn("submission_id", submissionIds))

     

       434
       434
        
       	if err != nil {

     

       435
       435
       -
       		return nil, err

     

       435
       435
       +
       		return nil, fmt.Errorf("failed to get pull comments: %w", err)

     

       436
       436
        
       	}

     

       437
       437
        
       	for _, comment := range comments {

     

       438
       438
        
       		if submission, ok := submissionMap[comment.SubmissionId]; ok {

     
···

       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 reference_links: %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.Before(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,

     
···

       618
       640
        
       	i, err := res.LastInsertId()

     

       619
       641
        
       	if err != nil {

     

       620
       642
        
       		return 0, err

     

       643
       643
       +
       	}

     

       644
       644
       +
       

     

       645
       645
       +
       	if err := putReferences(tx, comment.AtUri(), comment.References); err != nil {

     

       646
       646
       +
       		return 0, fmt.Errorf("put reference_links: %w", err)

     

       621
       647
        
       	}

     

       622
       648
        
       

     

       623
       649
        
       	return i, nil

+92 -14

appview/db/reference.go

···

       10
       10
        
       	"tangled.org/core/appview/models"

     

       11
       11
        
       )

     

       12
       12
        
       

     

       13
       13
       -
       // FindReferences resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs.

     

       13
       13
       +
       // ValidateReferenceLinks resolves refLinks to Issue/PR/IssueComment/PullComment ATURIs.

     

       14
       14
        
       // It will ignore missing refLinks.

     

       15
       15
       -
       func FindReferences(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       15
       15
       +
       func ValidateReferenceLinks(e Execer, refLinks []models.ReferenceLink) ([]syntax.ATURI, error) {

     

       16
       16
        
       	var (

     

       17
       17
        
       		issueRefs []models.ReferenceLink

     

       18
       18
        
       		pullRefs  []models.ReferenceLink

     
···

       27
       27
        
       	}

     

       28
       28
        
       	issueUris, err := findIssueReferences(e, issueRefs)

     

       29
       29
        
       	if err != nil {

     

       30
       30
       -
       		return nil, err

     

       30
       30
       +
       		return nil, fmt.Errorf("find issue references: %w", err)

     

       31
       31
        
       	}

     

       32
       32
        
       	pullUris, err := findPullReferences(e, pullRefs)

     

       33
       33
        
       	if err != nil {

     

       34
       34
       -
       		return nil, err

     

       34
       34
       +
       		return nil, fmt.Errorf("find pull references: %w", err)

     

       35
       35
        
       	}

     

       36
       36
        
       

     

       37
       37
        
       	return append(issueUris, pullUris...), nil

     
···

       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
        
       

     
···

       120
       124
        
       		)

     

       121
       125
        
       		select

     

       122
       126
        
       			p.owner_did, p.rkey,

     

       123
       123
       -
       			c.owner_did, c.rkey

     

       127
       127
       +
       			c.comment_at

     

       124
       128
        
       		from input inp

     

       125
       129
        
       		join repos r

     

       126
       130
        
       			on r.did = inp.owner_did

     
···

       146
       150
        
       	for rows.Next() {

     

       147
       151
        
       		// Scan rows

     

       148
       152
        
       		var pullOwner, pullRkey string

     

       149
       149
       -
       		var commentOwner, commentRkey sql.NullString

     

       153
       153
       +
       		var commentUri sql.NullString

     

       150
       154
        
       		var uri syntax.ATURI

     

       151
       151
       -
       		if err := rows.Scan(&pullOwner, &pullRkey, &commentOwner, &commentRkey); err != nil {

     

       155
       155
       +
       		if err := rows.Scan(&pullOwner, &pullRkey, &commentUri); err != nil {

     

       152
       156
        
       			return nil, err

     

       153
       157
        
       		}

     

       154
       154
       -
       		if commentOwner.Valid && commentRkey.Valid {

     

       155
       155
       -
       			uri = syntax.ATURI(fmt.Sprintf(

     

       156
       156
       -
       				"at://%s/%s/%s",

     

       157
       157
       -
       				commentOwner.String,

     

       158
       158
       -
       				tangled.RepoPullCommentNSID,

     

       159
       159
       -
       				commentRkey.String,

     

       160
       160
       -
       			))

     

       158
       158
       +
       		if commentUri.Valid {

     

       159
       159
       +
       			// no-op

     

       160
       160
       +
       			uri = syntax.ATURI(commentUri.String)

     

       161
       161
        
       		} else {

     

       162
       162
        
       			uri = syntax.ATURI(fmt.Sprintf(

     

       163
       163
        
       				"at://%s/%s/%s",

     
···

       170
       170
        
       	}

     

       171
       171
        
       	return uris, nil

     

       172
       172
        
       }

     

       173
       173
       +
       

     

       174
       174
       +
       func putReferences(tx *sql.Tx, fromAt syntax.ATURI, references []syntax.ATURI) error {

     

       175
       175
       +
       	err := deleteReferences(tx, fromAt)

     

       176
       176
       +
       	if err != nil {

     

       177
       177
       +
       		return fmt.Errorf("delete old reference_links: %w", err)

     

       178
       178
       +
       	}

     

       179
       179
       +
       	if len(references) == 0 {

     

       180
       180
       +
       		return nil

     

       181
       181
       +
       	}

     

       182
       182
       +
       

     

       183
       183
       +
       	values := make([]string, 0, len(references))

     

       184
       184
       +
       	args := make([]any, 0, len(references)*2)

     

       185
       185
       +
       	for _, ref := range references {

     

       186
       186
       +
       		values = append(values, "(?, ?)")

     

       187
       187
       +
       		args = append(args, fromAt, ref)

     

       188
       188
       +
       	}

     

       189
       189
       +
       	_, err = tx.Exec(

     

       190
       190
       +
       		fmt.Sprintf(

     

       191
       191
       +
       			`insert into reference_links (from_at, to_at)

     

       192
       192
       +
       			values %s`,

     

       193
       193
       +
       			strings.Join(values, ","),

     

       194
       194
       +
       		),

     

       195
       195
       +
       		args...,

     

       196
       196
       +
       	)

     

       197
       197
       +
       	if err != nil {

     

       198
       198
       +
       		return fmt.Errorf("insert new reference_links: %w", err)

     

       199
       199
       +
       	}

     

       200
       200
       +
       	return nil

     

       201
       201
       +
       }

     

       202
       202
       +
       

     

       203
       203
       +
       func deleteReferences(tx *sql.Tx, fromAt syntax.ATURI) error {

     

       204
       204
       +
       	_, err := tx.Exec(`delete from reference_links where from_at = ?`, fromAt)

     

       205
       205
       +
       	return err

     

       206
       206
       +
       }

     

       207
       207
       +
       

     

       208
       208
       +
       func GetReferencesAll(e Execer, filters ...filter) (map[syntax.ATURI][]syntax.ATURI, error) {

     

       209
       209
       +
       	var (

     

       210
       210
       +
       		conditions []string

     

       211
       211
       +
       		args       []any

     

       212
       212
       +
       	)

     

       213
       213
       +
       	for _, filter := range filters {

     

       214
       214
       +
       		conditions = append(conditions, filter.Condition())

     

       215
       215
       +
       		args = append(args, filter.Arg()...)

     

       216
       216
       +
       	}

     

       217
       217
       +
       

     

       218
       218
       +
       	whereClause := ""

     

       219
       219
       +
       	if conditions != nil {

     

       220
       220
       +
       		whereClause = " where " + strings.Join(conditions, " and ")

     

       221
       221
       +
       	}

     

       222
       222
       +
       

     

       223
       223
       +
       	rows, err := e.Query(

     

       224
       224
       +
       		fmt.Sprintf(

     

       225
       225
       +
       			`select from_at, to_at from reference_links %s`,

     

       226
       226
       +
       			whereClause,

     

       227
       227
       +
       		),

     

       228
       228
       +
       		args...,

     

       229
       229
       +
       	)

     

       230
       230
       +
       	if err != nil {

     

       231
       231
       +
       		return nil, fmt.Errorf("query reference_links: %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)

     

       858
       858
       +
       		}

     

       859
       859
       +
       		if err := tx.Commit(); err != nil {

     

       860
       860
       +
       			l.Error("failed to commit txn", "err", err)

     

       861
       861
       +
       			return err

     

       851
       862
        
       		}

     

       852
       863
        
       

     

       853
       864
        
       		return nil

     
···

       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(

+55 -19

appview/issues/issues.go

···

       238
       238
        
       	}

     

       239
       239
        
       	l = l.With("did", issue.Did, "rkey", issue.Rkey)

     

       240
       240
        
       

     

       241
       241
       +
       	tx, err := rp.db.Begin()

     

       242
       242
       +
       	if err != nil {

     

       243
       243
       +
       		l.Error("failed to start transaction", "err", err)

     

       244
       244
       +
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.")

     

       245
       245
       +
       		return

     

       246
       246
       +
       	}

     

       247
       247
       +
       	defer tx.Rollback()

     

       248
       248
       +
       

     

       241
       249
        
       	// delete from PDS

     

       242
       250
        
       	client, err := rp.oauth.AuthorizedClient(r)

     

       243
       251
        
       	if err != nil {

     
···

       258
       266
        
       	}

     

       259
       267
        
       

     

       260
       268
        
       	// delete from db

     

       261
       261
       -
       	if err := db.DeleteIssues(rp.db, db.FilterEq("id", issue.Id)); err != nil {

     

       269
       269
       +
       	if err := db.DeleteIssues(tx, issue.Did, issue.Rkey); err != nil {

     

       262
       270
        
       		l.Error("failed to delete issue", "err", err)

     

       263
       271
        
       		rp.pages.Notice(w, noticeId, "Failed to delete issue.")

     

       264
       272
        
       		return

     

       265
       273
        
       	}

     

       274
       274
       +
       	tx.Commit()

     

       266
       275
        
       

     

       267
       276
        
       	rp.notifier.DeleteIssue(r.Context(), issue)

     

       268
       277
        
       

     
···

       394
       403
        
       		replyTo = &replyToUri

     

       395
       404
        
       	}

     

       396
       405
        
       

     

       397
       397
       -
       	mentions, _ := rp.refResolver.Resolve(r.Context(), body)

     

       406
       406
       +
       	mentions, references := rp.refResolver.Resolve(r.Context(), body)

     

       398
       407
        
       

     

       399
       408
        
       	comment := models.IssueComment{

     

       400
       400
       -
       		Did:     user.Did,

     

       401
       401
       -
       		Rkey:    tid.TID(),

     

       402
       402
       -
       		IssueAt: issue.AtUri().String(),

     

       403
       403
       -
       		ReplyTo: replyTo,

     

       404
       404
       -
       		Body:    body,

     

       405
       405
       -
       		Created: time.Now(),

     

       409
       409
       +
       		Did:        user.Did,

     

       410
       410
       +
       		Rkey:       tid.TID(),

     

       411
       411
       +
       		IssueAt:    issue.AtUri().String(),

     

       412
       412
       +
       		ReplyTo:    replyTo,

     

       413
       413
       +
       		Body:       body,

     

       414
       414
       +
       		Created:    time.Now(),

     

       415
       415
       +
       		Mentions:   mentions,

     

       416
       416
       +
       		References: references,

     

       406
       417
        
       	}

     

       407
       418
        
       	if err = rp.validator.ValidateIssueComment(&comment); err != nil {

     

       408
       419
        
       		l.Error("failed to validate comment", "err", err)

     
···

       439
       450
        
       		}

     

       440
       451
        
       	}()

     

       441
       452
        
       

     

       442
       442
       -
       	commentId, err := db.AddIssueComment(rp.db, comment)

     

       453
       453
       +
       	tx, err := rp.db.Begin()

     

       454
       454
       +
       	if err != nil {

     

       455
       455
       +
       		l.Error("failed to start transaction", "err", err)

     

       456
       456
       +
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.")

     

       457
       457
       +
       		return

     

       458
       458
       +
       	}

     

       459
       459
       +
       	defer tx.Rollback()

     

       460
       460
       +
       

     

       461
       461
       +
       	commentId, err := db.AddIssueComment(tx, comment)

     

       443
       462
        
       	if err != nil {

     

       444
       463
        
       		l.Error("failed to create comment", "err", err)

     

       445
       464
        
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment.")

     

       446
       465
        
       		return

     

       447
       466
        
       	}

     

       467
       467
       +
       	err = tx.Commit()

     

       468
       468
       +
       	if err != nil {

     

       469
       469
       +
       		l.Error("failed to commit transaction", "err", err)

     

       470
       470
       +
       		rp.pages.Notice(w, "issue-comment", "Failed to create comment, try again later.")

     

       471
       471
       +
       		return

     

       472
       472
       +
       	}

     

       448
       473
        
       

     

       449
       474
        
       	// reset atUri to make rollback a no-op

     

       450
       475
        
       	atUri = ""

     
···

       552
       577
        
       		newComment.Edited = &now

     

       553
       578
        
       		record := newComment.AsRecord()

     

       554
       579
        
       

     

       555
       555
       -
       		_, err = db.AddIssueComment(rp.db, newComment)

     

       580
       580
       +
       		tx, err := rp.db.Begin()

     

       581
       581
       +
       		if err != nil {

     

       582
       582
       +
       			l.Error("failed to start transaction", "err", err)

     

       583
       583
       +
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       584
       584
       +
       			return

     

       585
       585
       +
       		}

     

       586
       586
       +
       		defer tx.Rollback()

     

       587
       587
       +
       

     

       588
       588
       +
       		_, err = db.AddIssueComment(tx, newComment)

     

       556
       589
        
       		if err != nil {

     

       557
       590
        
       			l.Error("failed to perferom update-description query", "err", err)

     

       558
       591
        
       			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       559
       592
        
       			return

     

       560
       593
        
       		}

     

       594
       594
       +
       		tx.Commit()

     

       561
       595
        
       

     

       562
       596
        
       		// rkey is optional, it was introduced later

     

       563
       597
        
       		if newComment.Rkey != "" {

     
···

       867
       901
        
       		})

     

       868
       902
        
       	case http.MethodPost:

     

       869
       903
        
       		body := r.FormValue("body")

     

       870
       870
       -
       		mentions, _ := rp.refResolver.Resolve(r.Context(), body)

     

       904
       904
       +
       		mentions, references := rp.refResolver.Resolve(r.Context(), body)

     

       871
       905
        
       

     

       872
       906
        
       		issue := &models.Issue{

     

       873
       873
       -
       			RepoAt:  f.RepoAt(),

     

       874
       874
       -
       			Rkey:    tid.TID(),

     

       875
       875
       -
       			Title:   r.FormValue("title"),

     

       876
       876
       -
       			Body:    body,

     

       877
       877
       -
       			Open:    true,

     

       878
       878
       -
       			Did:     user.Did,

     

       879
       879
       -
       			Created: time.Now(),

     

       880
       880
       -
       			Repo:    f,

     

       907
       907
       +
       			RepoAt:     f.RepoAt(),

     

       908
       908
       +
       			Rkey:       tid.TID(),

     

       909
       909
       +
       			Title:      r.FormValue("title"),

     

       910
       910
       +
       			Body:       body,

     

       911
       911
       +
       			Open:       true,

     

       912
       912
       +
       			Did:        user.Did,

     

       913
       913
       +
       			Created:    time.Now(),

     

       914
       914
       +
       			Mentions:   mentions,

     

       915
       915
       +
       			References: references,

     

       916
       916
       +
       			Repo:       f,

     

       881
       917
        
       		}

     

       882
       918
        
       

     

       883
       919
        
       		if err := rp.validator.ValidateIssue(issue); err != nil {

+70 -34

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
        
       

     
···

       205
       229
        
       		return nil, err

     

       206
       230
        
       	}

     

       207
       231
        
       

     

       232
       232
       +
       	i := record

     

       233
       233
       +
       	mentions := make([]syntax.DID, len(record.Mentions))

     

       234
       234
       +
       	for i, did := range record.Mentions {

     

       235
       235
       +
       		mentions[i] = syntax.DID(did)

     

       236
       236
       +
       	}

     

       237
       237
       +
       	references := make([]syntax.ATURI, len(record.References))

     

       238
       238
       +
       	for i, uri := range i.References {

     

       239
       239
       +
       		references[i] = syntax.ATURI(uri)

     

       240
       240
       +
       	}

     

       241
       241
       +
       

     

       208
       242
        
       	comment := IssueComment{

     

       209
       209
       -
       		Did:     ownerDid,

     

       210
       210
       -
       		Rkey:    rkey,

     

       211
       211
       -
       		Body:    record.Body,

     

       212
       212
       -
       		IssueAt: record.Issue,

     

       213
       213
       -
       		ReplyTo: record.ReplyTo,

     

       214
       214
       -
       		Created: created,

     

       243
       243
       +
       		Did:        ownerDid,

     

       244
       244
       +
       		Rkey:       rkey,

     

       245
       245
       +
       		Body:       record.Body,

     

       246
       246
       +
       		IssueAt:    record.Issue,

     

       247
       247
       +
       		ReplyTo:    record.ReplyTo,

     

       248
       248
       +
       		Created:    created,

     

       249
       249
       +
       		Mentions:   mentions,

     

       250
       250
       +
       		References: references,

     

       215
       251
        
       	}

     

       216
       252
        
       

     

       217
       253
        
       	return &comment, nil

+26

appview/models/pull.go

···

       148
       148
        
       	Body string

     

       149
       149
        
       

     

       150
       150
        
       	// meta

     

       151
       151
       +
       	Mentions   []syntax.DID

     

       152
       152
       +
       	References []syntax.ATURI

     

       153
       153
       +
       

     

       154
       154
       +
       	// meta

     

       151
       155
        
       	Created time.Time

     

       152
       156
        
       }

     

       157
       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
       +
       // }

     

       153
       179
        
       

     

       154
       180
        
       func (p *Pull) LastRoundNumber() int {

     

       155
       181
        
       	return len(p.Submissions) - 1

+3 -1

appview/pulls/pulls.go

···

       720
       720
        
       			return

     

       721
       721
        
       		}

     

       722
       722
        
       

     

       723
       723
       -
       		mentions, _ := s.refResolver.Resolve(r.Context(), body)

     

       723
       723
       +
       		mentions, references := s.refResolver.Resolve(r.Context(), body)

     

       724
       724
        
       

     

       725
       725
        
       		// Start a transaction

     

       726
       726
        
       		tx, err := s.db.BeginTx(r.Context(), nil)

     
···

       764
       764
        
       			Body:         body,

     

       765
       765
        
       			CommentAt:    atResp.Uri,

     

       766
       766
        
       			SubmissionId: pull.Submissions[roundNumber].ID,

     

       767
       767
       +
       			Mentions:     mentions,

     

       768
       768
       +
       			References:   references,

     

       767
       769
        
       		}

     

       768
       770
        
       

     

       769
       771
        
       		// Create the pull comment in the database with the commentAt field

+2 -2

appview/refresolver/resolver.go

···

       34
       34
        
       }

     

       35
       35
        
       

     

       36
       36
        
       func (r *Resolver) Resolve(ctx context.Context, source string) ([]syntax.DID, []syntax.ATURI) {

     

       37
       37
       -
       	l := r.logger.With("method", "find_references")

     

       37
       37
       +
       	l := r.logger.With("method", "Resolve")

     

       38
       38
        
       	rawMentions, rawRefs := markup.FindReferences(r.config.Core.AppviewHost, source)

     

       39
       39
        
       	l.Debug("found possible references", "mentions", rawMentions, "refs", rawRefs)

     

       40
       40
        
       	idents := r.idResolver.ResolveIdents(ctx, rawMentions)

     
···

       55
       55
        
       		rawRef.Handle = string(ident.DID)

     

       56
       56
        
       		resolvedRefs = append(resolvedRefs, rawRef)

     

       57
       57
        
       	}

     

       58
       58
       -
       	aturiRefs, err := db.FindReferences(r.execer, resolvedRefs)

     

       58
       58
       +
       	aturiRefs, err := db.ValidateReferenceLinks(r.execer, resolvedRefs)

     

       59
       59
        
       	if err != nil {

     

       60
       60
        
       		l.Error("failed running query", "err", err)

     

       61
       61
        
       	}

+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
        
             }

+14

lexicons/pulls/pull.json

···

       36
       36
        
                 "createdAt": {

     

       37
       37
        
                   "type": "string",

     

       38
       38
        
                   "format": "datetime"

     

       39
       39
       +
                 },

     

       40
       40
       +
                 "mentions": {

     

       41
       41
       +
                   "type": "array",

     

       42
       42
       +
                   "items": {

     

       43
       43
       +
                     "type": "string",

     

       44
       44
       +
                     "format": "did"

     

       45
       45
       +
                   }

     

       46
       46
       +
                 },

     

       47
       47
       +
                 "references": {

     

       48
       48
       +
                   "type": "array",

     

       49
       49
       +
                   "items": {

     

       50
       50
       +
                     "type": "string",

     

       51
       51
       +
                     "format": "at-uri"

     

       52
       52
       +
                   }

     

       39
       53
        
                 }

     

       40
       54
        
               }

     

       41
       55
        
             }