commit ad34da2a4ab284aed7bff4df981ab143d0bd7bbc · veryroundbird.house/core

+78 -45

api/tangled/cbor_gen.go

···

       6967
       6967
        
       	}

     

       6968
       6968
        
       

     

       6969
       6969
        
       	cw := cbg.NewCborWriter(w)

     

       6970
       6970
       -
       	fieldCount := 7

     

       6970
       6970
       +
       	fieldCount := 8

     

       6971
       6971
        
       

     

       6972
       6972
        
       	if t.Description == nil {

     

       6973
       6973
        
       		fieldCount--

     

       6974
       6974
        
       	}

     

       6975
       6975
        
       

     

       6976
       6976
        
       	if t.Source == nil {

     

       6977
       6977
       +
       		fieldCount--

     

       6978
       6978
       +
       	}

     

       6979
       6979
       +
       

     

       6980
       6980
       +
       	if t.Spindle == nil {

     

       6977
       6981
        
       		fieldCount--

     

       6978
       6982
        
       	}

     

       6979
       6983
        
       

     
···

       7101
       7105
        
       		}

     

       7102
       7106
        
       	}

     

       7103
       7107
        
       

     

       7108
       7108
       +
       	// t.Spindle (string) (string)

     

       7109
       7109
       +
       	if t.Spindle != nil {

     

       7110
       7110
       +
       

     

       7111
       7111
       +
       		if len("spindle") > 1000000 {

     

       7112
       7112
       +
       			return xerrors.Errorf("Value in field \"spindle\" was too long")

     

       7113
       7113
       +
       		}

     

       7114
       7114
       +
       

     

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

     

       7116
       7116
       +
       			return err

     

       7117
       7117
       +
       		}

     

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

     

       7119
       7119
       +
       			return err

     

       7120
       7120
       +
       		}

     

       7121
       7121
       +
       

     

       7122
       7122
       +
       		if t.Spindle == nil {

     

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

     

       7124
       7124
       +
       				return err

     

       7125
       7125
       +
       			}

     

       7126
       7126
       +
       		} else {

     

       7127
       7127
       +
       			if len(*t.Spindle) > 1000000 {

     

       7128
       7128
       +
       				return xerrors.Errorf("Value in field t.Spindle was too long")

     

       7129
       7129
       +
       			}

     

       7130
       7130
       +
       

     

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

     

       7132
       7132
       +
       				return err

     

       7133
       7133
       +
       			}

     

       7134
       7134
       +
       			if _, err := cw.WriteString(string(*t.Spindle)); err != nil {

     

       7135
       7135
       +
       				return err

     

       7136
       7136
       +
       			}

     

       7137
       7137
       +
       		}

     

       7138
       7138
       +
       	}

     

       7139
       7139
       +
       

     

       7104
       7140
        
       	// t.CreatedAt (string) (string)

     

       7105
       7141
        
       	if len("createdAt") > 1000000 {

     

       7106
       7142
        
       		return xerrors.Errorf("Value in field \"createdAt\" was too long")

     
···

       7264
       7300
        
       					t.Source = (*string)(&sval)

     

       7265
       7301
        
       				}

     

       7266
       7302
        
       			}

     

       7303
       7303
       +
       			// t.Spindle (string) (string)

     

       7304
       7304
       +
       		case "spindle":

     

       7305
       7305
       +
       

     

       7306
       7306
       +
       			{

     

       7307
       7307
       +
       				b, err := cr.ReadByte()

     

       7308
       7308
       +
       				if err != nil {

     

       7309
       7309
       +
       					return err

     

       7310
       7310
       +
       				}

     

       7311
       7311
       +
       				if b != cbg.CborNull[0] {

     

       7312
       7312
       +
       					if err := cr.UnreadByte(); err != nil {

     

       7313
       7313
       +
       						return err

     

       7314
       7314
       +
       					}

     

       7315
       7315
       +
       

     

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

     

       7317
       7317
       +
       					if err != nil {

     

       7318
       7318
       +
       						return err

     

       7319
       7319
       +
       					}

     

       7320
       7320
       +
       

     

       7321
       7321
       +
       					t.Spindle = (*string)(&sval)

     

       7322
       7322
       +
       				}

     

       7323
       7323
       +
       			}

     

       7267
       7324
        
       			// t.CreatedAt (string) (string)

     

       7268
       7325
        
       		case "createdAt":

     

       7269
       7326
        
       

     
···

       7314
       7371
        
       	}

     

       7315
       7372
        
       

     

       7316
       7373
        
       	cw := cbg.NewCborWriter(w)

     

       7317
       7317
       -
       	fieldCount := 4

     

       7318
       7374
        
       

     

       7319
       7319
       -
       	if t.Instance == nil {

     

       7320
       7320
       -
       		fieldCount--

     

       7321
       7321
       -
       	}

     

       7322
       7322
       -
       

     

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

     

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

     

       7324
       7376
        
       		return err

     

       7325
       7377
        
       	}

     

       7326
       7378
        
       

     
···

       7367
       7419
        
       	}

     

       7368
       7420
        
       

     

       7369
       7421
        
       	// t.Instance (string) (string)

     

       7370
       7370
       -
       	if t.Instance != nil {

     

       7422
       7422
       +
       	if len("instance") > 1000000 {

     

       7423
       7423
       +
       		return xerrors.Errorf("Value in field \"instance\" was too long")

     

       7424
       7424
       +
       	}

     

       7371
       7425
        
       

     

       7372
       7372
       -
       		if len("instance") > 1000000 {

     

       7373
       7373
       -
       			return xerrors.Errorf("Value in field \"instance\" was too long")

     

       7374
       7374
       -
       		}

     

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

     

       7427
       7427
       +
       		return err

     

       7428
       7428
       +
       	}

     

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

     

       7430
       7430
       +
       		return err

     

       7431
       7431
       +
       	}

     

       7375
       7432
        
       

     

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

     

       7377
       7377
       -
       			return err

     

       7378
       7378
       -
       		}

     

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

     

       7380
       7380
       -
       			return err

     

       7381
       7381
       -
       		}

     

       7433
       7433
       +
       	if len(t.Instance) > 1000000 {

     

       7434
       7434
       +
       		return xerrors.Errorf("Value in field t.Instance was too long")

     

       7435
       7435
       +
       	}

     

       7382
       7436
        
       

     

       7383
       7383
       -
       		if t.Instance == nil {

     

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

     

       7385
       7385
       -
       				return err

     

       7386
       7386
       -
       			}

     

       7387
       7387
       -
       		} else {

     

       7388
       7388
       -
       			if len(*t.Instance) > 1000000 {

     

       7389
       7389
       -
       				return xerrors.Errorf("Value in field t.Instance was too long")

     

       7390
       7390
       -
       			}

     

       7391
       7391
       -
       

     

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

     

       7393
       7393
       -
       				return err

     

       7394
       7394
       -
       			}

     

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

     

       7396
       7396
       -
       				return err

     

       7397
       7397
       -
       			}

     

       7398
       7398
       -
       		}

     

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

     

       7438
       7438
       +
       		return err

     

       7439
       7439
       +
       	}

     

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

     

       7441
       7441
       +
       		return err

     

       7399
       7442
        
       	}

     

       7400
       7443
        
       

     

       7401
       7444
        
       	// t.CreatedAt (string) (string)

     
···

       7490
       7533
        
       		case "instance":

     

       7491
       7534
        
       

     

       7492
       7535
        
       			{

     

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

     

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

     

       7494
       7537
        
       				if err != nil {

     

       7495
       7538
        
       					return err

     

       7496
       7539
        
       				}

     

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

     

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

     

       7499
       7499
       -
       						return err

     

       7500
       7500
       -
       					}

     

       7501
       7540
        
       

     

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

     

       7503
       7503
       -
       					if err != nil {

     

       7504
       7504
       -
       						return err

     

       7505
       7505
       -
       					}

     

       7506
       7506
       -
       

     

       7507
       7507
       -
       					t.Instance = (*string)(&sval)

     

       7508
       7508
       -
       				}

     

       7541
       7541
       +
       				t.Instance = string(sval)

     

       7509
       7542
        
       			}

     

       7510
       7543
        
       			// t.CreatedAt (string) (string)

     

       7511
       7544
        
       		case "createdAt":

+2 -2

api/tangled/spindlemember.go

···

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

     

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

     

       22
       22
        
       	// instance: spindle instance that the subject is now a member of

     

       23
       23
       -
       	Instance *string `json:"instance,omitempty" cborgen:"instance,omitempty"`

     

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

     

       23
       23
       +
       	Instance string `json:"instance" cborgen:"instance"`

     

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

     

       25
       25
        
       }

api/tangled/tangledrepo.go

···

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

     

       28
       28
        
       	// source: source of the repo

     

       29
       29
        
       	Source *string `json:"source,omitempty" cborgen:"source,omitempty"`

     

       30
       30
       +
       	// spindle: CI runner to send jobs to and receive results from

     

       31
       31
       +
       	Spindle *string `json:"spindle,omitempty" cborgen:"spindle,omitempty"`

     

       30
       32
        
       }

lexicons/repo.json

···

       28
       28
        
                   "type": "string",

     

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

     

       30
       30
        
                 },

     

       31
       31
       +
                 "spindle": {

     

       32
       32
       +
                   "type": "string",

     

       33
       33
       +
                   "description": "CI runner to send jobs to and receive results from"

     

       34
       34
       +
                 },

     

       31
       35
        
                 "description": {

     

       32
       36
        
                   "type": "string",

     

       33
       37
        
                   "format": "datetime",

+1 -1

lexicons/spindle/member.json

···

       11
       11
        
               "type": "object",

     

       12
       12
        
               "required": [

     

       13
       13
        
                 "subject",

     

       14
       14
       -
                 "domain",

     

       14
       14
       +
                 "instance",

     

       15
       15
        
                 "createdAt"

     

       16
       16
        
               ],

     

       17
       17
        
               "properties": {