nel.pet
Signed-off-by: nelind nel.n.lindberg@gmail.com
+202
-1
api/tangled/cbor_gen.go
+202
-1
api/tangled/cbor_gen.go
···
6741
6742
return nil
6743
}
6744
func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
6745
if t == nil {
6746
_, err := w.Write(cbg.CborNull)
···
6882
}
6883
6884
cw := cbg.NewCborWriter(w)
6885
-
fieldCount := 7
6886
6887
if t.Body == nil {
6888
fieldCount--
···
6892
fieldCount--
6893
}
6894
6895
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6896
return err
6897
}
···
7050
if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7051
return err
7052
}
7053
return nil
7054
}
7055
···
7199
7200
t.CreatedAt = string(sval)
7201
}
7202
7203
default:
7204
// Field doesn't exist on this type, so ignore it
···
6741
6742
return nil
6743
}
6744
+
func (t *RepoPull_StackInfo) MarshalCBOR(w io.Writer) error {
6745
+
if t == nil {
6746
+
_, err := w.Write(cbg.CborNull)
6747
+
return err
6748
+
}
6749
+
6750
+
cw := cbg.NewCborWriter(w)
6751
+
fieldCount := 2
6752
+
6753
+
if t.Parent == nil {
6754
+
fieldCount--
6755
+
}
6756
+
6757
+
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
6758
+
return err
6759
+
}
6760
+
6761
+
// t.Parent (string) (string)
6762
+
if t.Parent != nil {
6763
+
6764
+
if len("parent") > 1000000 {
6765
+
return xerrors.Errorf("Value in field \"parent\" was too long")
6766
+
}
6767
+
6768
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("parent"))); err != nil {
6769
+
return err
6770
+
}
6771
+
if _, err := cw.WriteString(string("parent")); err != nil {
6772
+
return err
6773
+
}
6774
+
6775
+
if t.Parent == nil {
6776
+
if _, err := cw.Write(cbg.CborNull); err != nil {
6777
+
return err
6778
+
}
6779
+
} else {
6780
+
if len(*t.Parent) > 1000000 {
6781
+
return xerrors.Errorf("Value in field t.Parent was too long")
6782
+
}
6783
+
6784
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Parent))); err != nil {
6785
+
return err
6786
+
}
6787
+
if _, err := cw.WriteString(string(*t.Parent)); err != nil {
6788
+
return err
6789
+
}
6790
+
}
6791
+
}
6792
+
6793
+
// t.ChangeId (string) (string)
6794
+
if len("changeId") > 1000000 {
6795
+
return xerrors.Errorf("Value in field \"changeId\" was too long")
6796
+
}
6797
+
6798
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changeId"))); err != nil {
6799
+
return err
6800
+
}
6801
+
if _, err := cw.WriteString(string("changeId")); err != nil {
6802
+
return err
6803
+
}
6804
+
6805
+
if len(t.ChangeId) > 1000000 {
6806
+
return xerrors.Errorf("Value in field t.ChangeId was too long")
6807
+
}
6808
+
6809
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChangeId))); err != nil {
6810
+
return err
6811
+
}
6812
+
if _, err := cw.WriteString(string(t.ChangeId)); err != nil {
6813
+
return err
6814
+
}
6815
+
return nil
6816
+
}
6817
+
6818
+
func (t *RepoPull_StackInfo) UnmarshalCBOR(r io.Reader) (err error) {
6819
+
*t = RepoPull_StackInfo{}
6820
+
6821
+
cr := cbg.NewCborReader(r)
6822
+
6823
+
maj, extra, err := cr.ReadHeader()
6824
+
if err != nil {
6825
+
return err
6826
+
}
6827
+
defer func() {
6828
+
if err == io.EOF {
6829
+
err = io.ErrUnexpectedEOF
6830
+
}
6831
+
}()
6832
+
6833
+
if maj != cbg.MajMap {
6834
+
return fmt.Errorf("cbor input should be of type map")
6835
+
}
6836
+
6837
+
if extra > cbg.MaxLength {
6838
+
return fmt.Errorf("RepoPull_StackInfo: map struct too large (%d)", extra)
6839
+
}
6840
+
6841
+
n := extra
6842
+
6843
+
nameBuf := make([]byte, 8)
6844
+
for i := uint64(0); i < n; i++ {
6845
+
nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)
6846
+
if err != nil {
6847
+
return err
6848
+
}
6849
+
6850
+
if !ok {
6851
+
// Field doesn't exist on this type, so ignore it
6852
+
if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {
6853
+
return err
6854
+
}
6855
+
continue
6856
+
}
6857
+
6858
+
switch string(nameBuf[:nameLen]) {
6859
+
// t.Parent (string) (string)
6860
+
case "parent":
6861
+
6862
+
{
6863
+
b, err := cr.ReadByte()
6864
+
if err != nil {
6865
+
return err
6866
+
}
6867
+
if b != cbg.CborNull[0] {
6868
+
if err := cr.UnreadByte(); err != nil {
6869
+
return err
6870
+
}
6871
+
6872
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
6873
+
if err != nil {
6874
+
return err
6875
+
}
6876
+
6877
+
t.Parent = (*string)(&sval)
6878
+
}
6879
+
}
6880
+
// t.ChangeId (string) (string)
6881
+
case "changeId":
6882
+
6883
+
{
6884
+
sval, err := cbg.ReadStringWithMax(cr, 1000000)
6885
+
if err != nil {
6886
+
return err
6887
+
}
6888
+
6889
+
t.ChangeId = string(sval)
6890
+
}
6891
+
6892
+
default:
6893
+
// Field doesn't exist on this type, so ignore it
6894
+
if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {
6895
+
return err
6896
+
}
6897
+
}
6898
+
}
6899
+
6900
+
return nil
6901
+
}
6902
func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error {
6903
if t == nil {
6904
_, err := w.Write(cbg.CborNull)
···
7040
}
7041
7042
cw := cbg.NewCborWriter(w)
7043
+
fieldCount := 8
7044
7045
if t.Body == nil {
7046
fieldCount--
···
7050
fieldCount--
7051
}
7052
7053
+
if t.StackInfo == nil {
7054
+
fieldCount--
7055
+
}
7056
+
7057
if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {
7058
return err
7059
}
···
7212
if _, err := cw.WriteString(string(t.CreatedAt)); err != nil {
7213
return err
7214
}
7215
+
7216
+
// t.StackInfo (tangled.RepoPull_StackInfo) (struct)
7217
+
if t.StackInfo != nil {
7218
+
7219
+
if len("stackInfo") > 1000000 {
7220
+
return xerrors.Errorf("Value in field \"stackInfo\" was too long")
7221
+
}
7222
+
7223
+
if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stackInfo"))); err != nil {
7224
+
return err
7225
+
}
7226
+
if _, err := cw.WriteString(string("stackInfo")); err != nil {
7227
+
return err
7228
+
}
7229
+
7230
+
if err := t.StackInfo.MarshalCBOR(cw); err != nil {
7231
+
return err
7232
+
}
7233
+
}
7234
return nil
7235
}
7236
···
7380
7381
t.CreatedAt = string(sval)
7382
}
7383
+
// t.StackInfo (tangled.RepoPull_StackInfo) (struct)
7384
+
case "stackInfo":
7385
+
7386
+
{
7387
+
7388
+
b, err := cr.ReadByte()
7389
+
if err != nil {
7390
+
return err
7391
+
}
7392
+
if b != cbg.CborNull[0] {
7393
+
if err := cr.UnreadByte(); err != nil {
7394
+
return err
7395
+
}
7396
+
t.StackInfo = new(RepoPull_StackInfo)
7397
+
if err := t.StackInfo.UnmarshalCBOR(cr); err != nil {
7398
+
return xerrors.Errorf("unmarshaling t.StackInfo pointer: %w", err)
7399
+
}
7400
+
}
7401
+
7402
+
}
7403
7404
default:
7405
// Field doesn't exist on this type, so ignore it
+16
-7
api/tangled/repopull.go
+16
-7
api/tangled/repopull.go
···
17
} //
18
// RECORDTYPE: RepoPull
19
type RepoPull struct {
20
-
LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`
21
-
Body *string `json:"body,omitempty" cborgen:"body,omitempty"`
22
-
CreatedAt string `json:"createdAt" cborgen:"createdAt"`
23
-
Patch string `json:"patch" cborgen:"patch"`
24
-
Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`
25
-
Target *RepoPull_Target `json:"target" cborgen:"target"`
26
-
Title string `json:"title" cborgen:"title"`
27
}
28
29
// RepoPull_Source is a "source" in the sh.tangled.repo.pull schema.
···
33
Sha string `json:"sha" cborgen:"sha"`
34
}
35
36
// RepoPull_Target is a "target" in the sh.tangled.repo.pull schema.
37
type RepoPull_Target struct {
38
Branch string `json:"branch" cborgen:"branch"`
···
17
} //
18
// RECORDTYPE: RepoPull
19
type RepoPull struct {
20
+
LexiconTypeID string `json:"$type,const=sh.tangled.repo.pull" cborgen:"$type,const=sh.tangled.repo.pull"`
21
+
Body *string `json:"body,omitempty" cborgen:"body,omitempty"`
22
+
CreatedAt string `json:"createdAt" cborgen:"createdAt"`
23
+
Patch string `json:"patch" cborgen:"patch"`
24
+
Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"`
25
+
StackInfo *RepoPull_StackInfo `json:"stackInfo,omitempty" cborgen:"stackInfo,omitempty"`
26
+
Target *RepoPull_Target `json:"target" cborgen:"target"`
27
+
Title string `json:"title" cborgen:"title"`
28
}
29
30
// RepoPull_Source is a "source" in the sh.tangled.repo.pull schema.
···
34
Sha string `json:"sha" cborgen:"sha"`
35
}
36
37
+
// RepoPull_StackInfo is a "stackInfo" in the sh.tangled.repo.pull schema.
38
+
type RepoPull_StackInfo struct {
39
+
// changeId: Change ID of this commit/change. Principly also available in the patch itself as a line in the commit footer.
40
+
ChangeId string `json:"changeId" cborgen:"changeId"`
41
+
// parent: AT-URI of the PR for the parent commit/change in the change stack.
42
+
Parent *string `json:"parent,omitempty" cborgen:"parent,omitempty"`
43
+
}
44
+
45
// RepoPull_Target is a "target" in the sh.tangled.repo.pull schema.
46
type RepoPull_Target struct {
47
Branch string `json:"branch" cborgen:"branch"`
+7
appview/db/db.go
+7
appview/db/db.go
+38
-10
appview/db/pulls.go
+38
-10
appview/db/pulls.go
···
72
// stacking
73
StackId string // nullable string
74
ChangeId string // nullable string
75
ParentChangeId string // nullable string
76
77
// meta
···
91
}
92
93
record := tangled.RepoPull{
94
-
Title: p.Title,
95
-
Body: &p.Body,
96
-
CreatedAt: p.Created.Format(time.RFC3339),
97
Target: &tangled.RepoPull_Target{
98
Repo: p.RepoAt.String(),
99
Branch: p.TargetBranch,
100
},
101
-
Patch: p.LatestPatch(),
102
-
Source: source,
103
}
104
return record
105
}
···
255
}
256
}
257
258
-
var stackId, changeId, parentChangeId *string
259
if pull.StackId != "" {
260
stackId = &pull.StackId
261
}
262
if pull.ChangeId != "" {
263
changeId = &pull.ChangeId
264
}
265
if pull.ParentChangeId != "" {
266
parentChangeId = &pull.ParentChangeId
267
}
···
269
_, err = tx.Exec(
270
`
271
insert into pulls (
272
-
repo_at, owner_did, pull_id, title, target_branch, body, rkey, state, source_branch, source_repo_at, stack_id, change_id, parent_change_id
273
)
274
-
values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
275
pull.RepoAt,
276
pull.OwnerDid,
277
pull.PullId,
···
284
sourceRepoAt,
285
stackId,
286
changeId,
287
parentChangeId,
288
)
289
if err != nil {
···
341
source_repo_at,
342
stack_id,
343
change_id,
344
parent_change_id
345
from
346
pulls
···
356
for rows.Next() {
357
var pull Pull
358
var createdAt string
359
-
var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString
360
err := rows.Scan(
361
&pull.OwnerDid,
362
&pull.RepoAt,
···
371
&sourceRepoAt,
372
&stackId,
373
&changeId,
374
&parentChangeId,
375
)
376
if err != nil {
···
402
if changeId.Valid {
403
pull.ChangeId = changeId.String
404
}
405
if parentChangeId.Valid {
406
pull.ParentChangeId = parentChangeId.String
407
}
···
530
source_repo_at,
531
stack_id,
532
change_id,
533
parent_change_id
534
from
535
pulls
···
540
541
var pull Pull
542
var createdAt string
543
-
var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString
544
err := row.Scan(
545
&pull.OwnerDid,
546
&pull.PullId,
···
555
&sourceRepoAt,
556
&stackId,
557
&changeId,
558
&parentChangeId,
559
)
560
if err != nil {
561
return nil, err
562
}
563
···
587
if changeId.Valid {
588
pull.ChangeId = changeId.String
589
}
590
if parentChangeId.Valid {
591
pull.ParentChangeId = parentChangeId.String
592
}
···
72
// stacking
73
StackId string // nullable string
74
ChangeId string // nullable string
75
+
ParentAt *syntax.ATURI
76
ParentChangeId string // nullable string
77
78
// meta
···
92
}
93
94
record := tangled.RepoPull{
95
+
Title: p.Title,
96
+
Body: &p.Body,
97
+
CreatedAt: p.Created.Format(time.RFC3339),
98
Target: &tangled.RepoPull_Target{
99
Repo: p.RepoAt.String(),
100
Branch: p.TargetBranch,
101
},
102
+
Patch: p.LatestPatch(),
103
+
Source: source,
104
+
StackInfo: &tangled.RepoPull_StackInfo{
105
+
ChangeId: p.ChangeId,
106
+
Parent: (*string)(p.ParentAt),
107
+
},
108
}
109
return record
110
}
···
260
}
261
}
262
263
+
var stackId, changeId, parentAt, parentChangeId *string
264
if pull.StackId != "" {
265
stackId = &pull.StackId
266
}
267
if pull.ChangeId != "" {
268
changeId = &pull.ChangeId
269
}
270
+
if pull.ParentAt != nil {
271
+
parentAt = (*string)(pull.ParentAt)
272
+
}
273
if pull.ParentChangeId != "" {
274
parentChangeId = &pull.ParentChangeId
275
}
···
277
_, err = tx.Exec(
278
`
279
insert into pulls (
280
+
repo_at, owner_did, pull_id, title, target_branch, body, rkey, state, source_branch, source_repo_at, stack_id, change_id, parent_at, parent_change_id
281
)
282
+
values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
283
pull.RepoAt,
284
pull.OwnerDid,
285
pull.PullId,
···
292
sourceRepoAt,
293
stackId,
294
changeId,
295
+
parentAt,
296
parentChangeId,
297
)
298
if err != nil {
···
350
source_repo_at,
351
stack_id,
352
change_id,
353
+
parent_at,
354
parent_change_id
355
from
356
pulls
···
366
for rows.Next() {
367
var pull Pull
368
var createdAt string
369
+
var sourceBranch, sourceRepoAt, stackId, changeId, parentAt, parentChangeId sql.NullString
370
err := rows.Scan(
371
&pull.OwnerDid,
372
&pull.RepoAt,
···
381
&sourceRepoAt,
382
&stackId,
383
&changeId,
384
+
&parentAt,
385
&parentChangeId,
386
)
387
if err != nil {
···
413
if changeId.Valid {
414
pull.ChangeId = changeId.String
415
}
416
+
if parentAt.Valid {
417
+
parentAtParsed, err := syntax.ParseATURI(parentAt.String)
418
+
if err != nil {
419
+
return nil, err
420
+
}
421
+
pull.ParentAt = &parentAtParsed
422
+
}
423
if parentChangeId.Valid {
424
pull.ParentChangeId = parentChangeId.String
425
}
···
548
source_repo_at,
549
stack_id,
550
change_id,
551
+
parent_at,
552
parent_change_id
553
from
554
pulls
···
559
560
var pull Pull
561
var createdAt string
562
+
var sourceBranch, sourceRepoAt, stackId, changeId, parentAt, parentChangeId sql.NullString
563
err := row.Scan(
564
&pull.OwnerDid,
565
&pull.PullId,
···
574
&sourceRepoAt,
575
&stackId,
576
&changeId,
577
+
&parentAt,
578
&parentChangeId,
579
)
580
if err != nil {
581
+
fmt.Printf("its the place you think it is and heres the row %s\n", row)
582
return nil, err
583
}
584
···
608
if changeId.Valid {
609
pull.ChangeId = changeId.String
610
}
611
+
if parentAt.Valid {
612
+
parsedParentAt, err := syntax.ParseATURI(parentAt.String)
613
+
if err != nil {
614
+
return nil, err
615
+
}
616
+
pull.ParentAt = &parsedParentAt
617
+
}
618
if parentChangeId.Valid {
619
pull.ParentChangeId = parentChangeId.String
620
}
+31
-2
appview/pulls/pulls.go
+31
-2
appview/pulls/pulls.go
···
1693
newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)
1694
if err != nil {
1695
log.Println("failed to create resubmitted stack", err)
1696
-
s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
1697
return
1698
}
1699
1700
// find the diff between the stacks, first, map them by changeId
1701
origById := make(map[string]*db.Pull)
1702
newById := make(map[string]*db.Pull)
1703
for _, p := range origStack {
1704
origById[p.ChangeId] = p
1705
}
1706
for _, p := range newStack {
1707
newById[p.ChangeId] = p
1708
}
1709
···
1751
// we still need to update the hash in submission.Patch and submission.SourceRev
1752
if patchutil.Equal(newFiles, origFiles) &&
1753
origHeader.Title == newHeader.Title &&
1754
-
origHeader.Body == newHeader.Body {
1755
unchanged[op.ChangeId] = struct{}{}
1756
} else {
1757
updated[op.ChangeId] = struct{}{}
···
1825
1826
record := op.AsRecord()
1827
record.Patch = submission.Patch
1828
1829
writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
1830
RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{
···
2173
// the stack is identified by a UUID
2174
var stack db.Stack
2175
parentChangeId := ""
2176
for _, fp := range formatPatches {
2177
// all patches must have a jj change-id
2178
changeId, err := fp.ChangeId()
···
2203
2204
StackId: stackId,
2205
ChangeId: changeId,
2206
ParentChangeId: parentChangeId,
2207
}
2208
2209
stack = append(stack, &pull)
2210
2211
parentChangeId = changeId
2212
}
2213
2214
return stack, nil
···
1693
newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId)
1694
if err != nil {
1695
log.Println("failed to create resubmitted stack", err)
1696
+
s.pages.Notice(w, "pull-resubmit-error", "Failed to merge pull request. Try again later.")
1697
return
1698
}
1699
1700
// find the diff between the stacks, first, map them by changeId
1701
origById := make(map[string]*db.Pull)
1702
newById := make(map[string]*db.Pull)
1703
+
chIdToAtUri := make(map[string]*syntax.ATURI)
1704
for _, p := range origStack {
1705
origById[p.ChangeId] = p
1706
+
1707
+
// build map from change id to existing at uris
1708
+
pAtUri, err := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, p.Rkey))
1709
+
if err != nil {
1710
+
log.Println(
1711
+
"failed to parse string %s into an AT URI while resubmitting stack. this should not be possible",
1712
+
fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, p.Rkey))
1713
+
s.pages.Notice(w, "pull-resubmit-error", "Failed to merge pull request. Try again later.")
1714
+
return
1715
+
}
1716
+
chIdToAtUri[p.ChangeId] = &pAtUri
1717
}
1718
for _, p := range newStack {
1719
+
// if change id has already been given a PR use its at uri instead of the newly created (and thus incorrect)
1720
+
// one made by newStack
1721
+
if ppAt, ok := chIdToAtUri[p.ParentChangeId]; ok {
1722
+
p.ParentAt = ppAt
1723
+
}
1724
+
1725
newById[p.ChangeId] = p
1726
}
1727
···
1769
// we still need to update the hash in submission.Patch and submission.SourceRev
1770
if patchutil.Equal(newFiles, origFiles) &&
1771
origHeader.Title == newHeader.Title &&
1772
+
origHeader.Body == newHeader.Body &&
1773
+
op.ParentChangeId == np.ParentChangeId {
1774
unchanged[op.ChangeId] = struct{}{}
1775
} else {
1776
updated[op.ChangeId] = struct{}{}
···
1844
1845
record := op.AsRecord()
1846
record.Patch = submission.Patch
1847
+
record.StackInfo.Parent = (*string)(np.ParentAt)
1848
1849
writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{
1850
RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{
···
2193
// the stack is identified by a UUID
2194
var stack db.Stack
2195
parentChangeId := ""
2196
+
var parentAt *syntax.ATURI = nil
2197
for _, fp := range formatPatches {
2198
// all patches must have a jj change-id
2199
changeId, err := fp.ChangeId()
···
2224
2225
StackId: stackId,
2226
ChangeId: changeId,
2227
+
ParentAt: parentAt,
2228
ParentChangeId: parentChangeId,
2229
}
2230
2231
stack = append(stack, &pull)
2232
2233
parentChangeId = changeId
2234
+
// this is a bit of an ugly way to create the ATURI but its the best we can do with the data flow here
2235
+
parsedParentAt, err := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, pull.Rkey));
2236
+
parentAt = &parsedParentAt
2237
+
if (err != nil) {
2238
+
return nil, fmt.Errorf("failed to parse string %s into an AT URI. this should not be possible",
2239
+
fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, pull.Rkey))
2240
+
}
2241
}
2242
2243
return stack, nil
+1
cmd/gen.go
+1
cmd/gen.go
+21
lexicons/pulls/pull.json
+21
lexicons/pulls/pull.json
···
29
"patch": {
30
"type": "string"
31
},
32
+
"stackInfo": {
33
+
"type": "ref",
34
+
"ref": "#stackInfo"
35
+
},
36
"source": {
37
"type": "ref",
38
"ref": "#source"
···
80
"format": "at-uri"
81
}
82
}
83
+
},
84
+
"stackInfo": {
85
+
"type": "object",
86
+
"required": [
87
+
"changeId"
88
+
],
89
+
"properties": {
90
+
"changeId": {
91
+
"type": "string",
92
+
"description": "Change ID of this commit/change."
93
+
},
94
+
"parent": {
95
+
"type": "string",
96
+
"description": "AT-URI of the PR for the parent commit/change in the change stack.",
97
+
"format": "at-uri"
98
+
}
99
+
}
100
}
101
}
102
}