lexicons: pulls: add stack information to pull records #405

+202 -1

api/tangled/cbor_gen.go

··· 6392 6392 6393 6393 return nil 6394 6394 } 6395 6395 + func (t *RepoPull_StackInfo) MarshalCBOR(w io.Writer) error { 6396 6396 + if t == nil { 6397 6397 + _, err := w.Write(cbg.CborNull) 6398 6398 + return err 6399 6399 + } 6400 6400 + 6401 6401 + cw := cbg.NewCborWriter(w) 6402 6402 + fieldCount := 2 6403 6403 + 6404 6404 + if t.Parent == nil { 6405 6405 + fieldCount-- 6406 6406 + } 6407 6407 + 6408 6408 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6409 6409 + return err 6410 6410 + } 6411 6411 + 6412 6412 + // t.Parent (string) (string) 6413 6413 + if t.Parent != nil { 6414 6414 + 6415 6415 + if len("parent") > 1000000 { 6416 6416 + return xerrors.Errorf("Value in field \"parent\" was too long") 6417 6417 + } 6418 6418 + 6419 6419 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("parent"))); err != nil { 6420 6420 + return err 6421 6421 + } 6422 6422 + if _, err := cw.WriteString(string("parent")); err != nil { 6423 6423 + return err 6424 6424 + } 6425 6425 + 6426 6426 + if t.Parent == nil { 6427 6427 + if _, err := cw.Write(cbg.CborNull); err != nil { 6428 6428 + return err 6429 6429 + } 6430 6430 + } else { 6431 6431 + if len(*t.Parent) > 1000000 { 6432 6432 + return xerrors.Errorf("Value in field t.Parent was too long") 6433 6433 + } 6434 6434 + 6435 6435 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Parent))); err != nil { 6436 6436 + return err 6437 6437 + } 6438 6438 + if _, err := cw.WriteString(string(*t.Parent)); err != nil { 6439 6439 + return err 6440 6440 + } 6441 6441 + } 6442 6442 + } 6443 6443 + 6444 6444 + // t.ChangeId (string) (string) 6445 6445 + if len("changeId") > 1000000 { 6446 6446 + return xerrors.Errorf("Value in field \"changeId\" was too long") 6447 6447 + } 6448 6448 + 6449 6449 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("changeId"))); err != nil { 6450 6450 + return err 6451 6451 + } 6452 6452 + if _, err := cw.WriteString(string("changeId")); err != nil { 6453 6453 + return err 6454 6454 + } 6455 6455 + 6456 6456 + if len(t.ChangeId) > 1000000 { 6457 6457 + return xerrors.Errorf("Value in field t.ChangeId was too long") 6458 6458 + } 6459 6459 + 6460 6460 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.ChangeId))); err != nil { 6461 6461 + return err 6462 6462 + } 6463 6463 + if _, err := cw.WriteString(string(t.ChangeId)); err != nil { 6464 6464 + return err 6465 6465 + } 6466 6466 + return nil 6467 6467 + } 6468 6468 + 6469 6469 + func (t *RepoPull_StackInfo) UnmarshalCBOR(r io.Reader) (err error) { 6470 6470 + *t = RepoPull_StackInfo{} 6471 6471 + 6472 6472 + cr := cbg.NewCborReader(r) 6473 6473 + 6474 6474 + maj, extra, err := cr.ReadHeader() 6475 6475 + if err != nil { 6476 6476 + return err 6477 6477 + } 6478 6478 + defer func() { 6479 6479 + if err == io.EOF { 6480 6480 + err = io.ErrUnexpectedEOF 6481 6481 + } 6482 6482 + }() 6483 6483 + 6484 6484 + if maj != cbg.MajMap { 6485 6485 + return fmt.Errorf("cbor input should be of type map") 6486 6486 + } 6487 6487 + 6488 6488 + if extra > cbg.MaxLength { 6489 6489 + return fmt.Errorf("RepoPull_StackInfo: map struct too large (%d)", extra) 6490 6490 + } 6491 6491 + 6492 6492 + n := extra 6493 6493 + 6494 6494 + nameBuf := make([]byte, 8) 6495 6495 + for i := uint64(0); i < n; i++ { 6496 6496 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 6497 6497 + if err != nil { 6498 6498 + return err 6499 6499 + } 6500 6500 + 6501 6501 + if !ok { 6502 6502 + // Field doesn't exist on this type, so ignore it 6503 6503 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 6504 6504 + return err 6505 6505 + } 6506 6506 + continue 6507 6507 + } 6508 6508 + 6509 6509 + switch string(nameBuf[:nameLen]) { 6510 6510 + // t.Parent (string) (string) 6511 6511 + case "parent": 6512 6512 + 6513 6513 + { 6514 6514 + b, err := cr.ReadByte() 6515 6515 + if err != nil { 6516 6516 + return err 6517 6517 + } 6518 6518 + if b != cbg.CborNull[0] { 6519 6519 + if err := cr.UnreadByte(); err != nil { 6520 6520 + return err 6521 6521 + } 6522 6522 + 6523 6523 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6524 6524 + if err != nil { 6525 6525 + return err 6526 6526 + } 6527 6527 + 6528 6528 + t.Parent = (*string)(&sval) 6529 6529 + } 6530 6530 + } 6531 6531 + // t.ChangeId (string) (string) 6532 6532 + case "changeId": 6533 6533 + 6534 6534 + { 6535 6535 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 6536 6536 + if err != nil { 6537 6537 + return err 6538 6538 + } 6539 6539 + 6540 6540 + t.ChangeId = string(sval) 6541 6541 + } 6542 6542 + 6543 6543 + default: 6544 6544 + // Field doesn't exist on this type, so ignore it 6545 6545 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 6546 6546 + return err 6547 6547 + } 6548 6548 + } 6549 6549 + } 6550 6550 + 6551 6551 + return nil 6552 6552 + } 6395 6553 func (t *RepoPull_Target) MarshalCBOR(w io.Writer) error { 6396 6554 if t == nil { 6397 6555 _, err := w.Write(cbg.CborNull) ··· 6533 6691 } 6534 6692 6535 6693 cw := cbg.NewCborWriter(w) 6536 6536 - fieldCount := 7 6694 6694 + fieldCount := 8 6537 6695 6538 6696 if t.Body == nil { 6539 6697 fieldCount-- ··· 6543 6701 fieldCount-- 6544 6702 } 6545 6703 6704 6704 + if t.StackInfo == nil { 6705 6705 + fieldCount-- 6706 6706 + } 6707 6707 + 6546 6708 if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 6547 6709 return err 6548 6710 } ··· 6701 6863 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 6702 6864 return err 6703 6865 } 6866 6866 + 6867 6867 + // t.StackInfo (tangled.RepoPull_StackInfo) (struct) 6868 6868 + if t.StackInfo != nil { 6869 6869 + 6870 6870 + if len("stackInfo") > 1000000 { 6871 6871 + return xerrors.Errorf("Value in field \"stackInfo\" was too long") 6872 6872 + } 6873 6873 + 6874 6874 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("stackInfo"))); err != nil { 6875 6875 + return err 6876 6876 + } 6877 6877 + if _, err := cw.WriteString(string("stackInfo")); err != nil { 6878 6878 + return err 6879 6879 + } 6880 6880 + 6881 6881 + if err := t.StackInfo.MarshalCBOR(cw); err != nil { 6882 6882 + return err 6883 6883 + } 6884 6884 + } 6704 6885 return nil 6705 6886 } 6706 6887 ··· 6850 7031 6851 7032 t.CreatedAt = string(sval) 6852 7033 } 7034 7034 + // t.StackInfo (tangled.RepoPull_StackInfo) (struct) 7035 7035 + case "stackInfo": 7036 7036 + 7037 7037 + { 7038 7038 + 7039 7039 + b, err := cr.ReadByte() 7040 7040 + if err != nil { 7041 7041 + return err 7042 7042 + } 7043 7043 + if b != cbg.CborNull[0] { 7044 7044 + if err := cr.UnreadByte(); err != nil { 7045 7045 + return err 7046 7046 + } 7047 7047 + t.StackInfo = new(RepoPull_StackInfo) 7048 7048 + if err := t.StackInfo.UnmarshalCBOR(cr); err != nil { 7049 7049 + return xerrors.Errorf("unmarshaling t.StackInfo pointer: %w", err) 7050 7050 + } 7051 7051 + } 7052 7052 + 7053 7053 + } 6853 7054 6854 7055 default: 6855 7056 // Field doesn't exist on this type, so ignore it

+16 -7

api/tangled/repopull.go

··· 17 17 } // 18 18 // RECORDTYPE: RepoPull 19 19 type RepoPull struct { 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 - Patch string `json:"patch" cborgen:"patch"` 24 24 - Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"` 25 25 - Target *RepoPull_Target `json:"target" cborgen:"target"` 26 26 - Title string `json:"title" cborgen:"title"` 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 + Patch string `json:"patch" cborgen:"patch"` 24 24 + Source *RepoPull_Source `json:"source,omitempty" cborgen:"source,omitempty"` 25 25 + StackInfo *RepoPull_StackInfo `json:"stackInfo,omitempty" cborgen:"stackInfo,omitempty"` 26 26 + Target *RepoPull_Target `json:"target" cborgen:"target"` 27 27 + Title string `json:"title" cborgen:"title"` 27 28 } 28 29 29 30 // RepoPull_Source is a "source" in the sh.tangled.repo.pull schema. ··· 33 34 Sha string `json:"sha" cborgen:"sha"` 34 35 } 35 36 37 37 + // RepoPull_StackInfo is a "stackInfo" in the sh.tangled.repo.pull schema. 38 38 + type RepoPull_StackInfo struct { 39 39 + // changeId: Change ID of this commit/change. Principly also available in the patch itself as a line in the commit footer. 40 40 + ChangeId string `json:"changeId" cborgen:"changeId"` 41 41 + // parent: AT-URI of the PR for the parent commit/change in the change stack. 42 42 + Parent *string `json:"parent,omitempty" cborgen:"parent,omitempty"` 43 43 + } 44 44 + 36 45 // RepoPull_Target is a "target" in the sh.tangled.repo.pull schema. 37 46 type RepoPull_Target struct { 38 47 Branch string `json:"branch" cborgen:"branch"`

+7

appview/db/db.go

··· 678 678 return err 679 679 }) 680 680 681 681 + runMigration(conn, "add-parent-at-for-stacks-to-pulls", func(tx *sql.Tx) error { 682 682 + _, err := tx.Exec(` 683 683 + alter table pulls add column parent_at text; 684 684 + `) 685 685 + return err 686 686 + }) 687 687 + 681 688 return &DB{db}, nil 682 689 } 683 690

+37 -10

appview/db/pulls.go

··· 72 72 // stacking 73 73 StackId string // nullable string 74 74 ChangeId string // nullable string 75 75 + ParentAt *syntax.ATURI 75 76 ParentChangeId string // nullable string 76 77 77 78 // meta ··· 91 92 } 92 93 93 94 record := tangled.RepoPull{ 94 94 - Title: p.Title, 95 95 - Body: &p.Body, 96 96 - CreatedAt: p.Created.Format(time.RFC3339), 95 95 + Title: p.Title, 96 96 + Body: &p.Body, 97 97 + CreatedAt: p.Created.Format(time.RFC3339), 97 98 Target: &tangled.RepoPull_Target{ 98 99 Repo: p.RepoAt.String(), 99 100 Branch: p.TargetBranch, 100 101 }, 101 101 - Patch: p.LatestPatch(), 102 102 - Source: source, 102 102 + Patch: p.LatestPatch(), 103 103 + Source: source, 104 104 + StackInfo: &tangled.RepoPull_StackInfo{ 105 105 + ChangeId: p.ChangeId, 106 106 + Parent: (*string)(p.ParentAt), 107 107 + }, 103 108 } 104 109 return record 105 110 } ··· 255 260 } 256 261 } 257 262 258 258 - var stackId, changeId, parentChangeId *string 263 263 + var stackId, changeId, parentAt, parentChangeId *string 259 264 if pull.StackId != "" { 260 265 stackId = &pull.StackId 261 266 } 262 267 if pull.ChangeId != "" { 263 268 changeId = &pull.ChangeId 264 269 } 270 270 + if pull.ParentAt != nil { 271 271 + parentAt = (*string)(pull.ParentAt) 272 272 + } 265 273 if pull.ParentChangeId != "" { 266 274 parentChangeId = &pull.ParentChangeId 267 275 } ··· 269 277 _, err = tx.Exec( 270 278 ` 271 279 insert into pulls ( 272 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 280 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 273 281 ) 274 274 - values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, 282 282 + values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, 275 283 pull.RepoAt, 276 284 pull.OwnerDid, 277 285 pull.PullId, ··· 284 292 sourceRepoAt, 285 293 stackId, 286 294 changeId, 295 295 + parentAt, 287 296 parentChangeId, 288 297 ) 289 298 if err != nil { ··· 345 354 source_repo_at, 346 355 stack_id, 347 356 change_id, 357 357 + parent_at, 348 358 parent_change_id 349 359 from 350 360 pulls ··· 363 373 for rows.Next() { 364 374 var pull Pull 365 375 var createdAt string 366 366 - var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString 376 376 + var sourceBranch, sourceRepoAt, stackId, changeId, parentAt, parentChangeId sql.NullString 367 377 err := rows.Scan( 368 378 &pull.OwnerDid, 369 379 &pull.RepoAt, ··· 378 388 &sourceRepoAt, 379 389 &stackId, 380 390 &changeId, 391 391 + &parentAt, 381 392 &parentChangeId, 382 393 ) 383 394 if err != nil { ··· 409 420 if changeId.Valid { 410 421 pull.ChangeId = changeId.String 411 422 } 423 423 + if parentAt.Valid { 424 424 + parentAtParsed, err := syntax.ParseATURI(parentAt.String) 425 425 + if err != nil { 426 426 + return nil, err 427 427 + } 428 428 + pull.ParentAt = &parentAtParsed 429 429 + } 412 430 if parentChangeId.Valid { 413 431 pull.ParentChangeId = parentChangeId.String 414 432 } ··· 549 567 source_repo_at, 550 568 stack_id, 551 569 change_id, 570 570 + parent_at, 552 571 parent_change_id 553 572 from 554 573 pulls ··· 559 578 560 579 var pull Pull 561 580 var createdAt string 562 562 - var sourceBranch, sourceRepoAt, stackId, changeId, parentChangeId sql.NullString 581 581 + var sourceBranch, sourceRepoAt, stackId, changeId, parentAt, parentChangeId sql.NullString 563 582 err := row.Scan( 564 583 &pull.OwnerDid, 565 584 &pull.PullId, ··· 574 593 &sourceRepoAt, 575 594 &stackId, 576 595 &changeId, 596 596 + &parentAt, 577 597 &parentChangeId, 578 598 ) 579 599 if err != nil { ··· 606 626 if changeId.Valid { 607 627 pull.ChangeId = changeId.String 608 628 } 629 629 + if parentAt.Valid { 630 630 + parsedParentAt, err := syntax.ParseATURI(parentAt.String) 631 631 + if err != nil { 632 632 + return nil, err 633 633 + } 634 634 + pull.ParentAt = &parsedParentAt 635 635 + } 609 636 if parentChangeId.Valid { 610 637 pull.ParentChangeId = parentChangeId.String 611 638 }

+22 -2

appview/pulls/pulls.go

··· 29 29 30 30 "github.com/bluekeyes/go-gitdiff/gitdiff" 31 31 comatproto "github.com/bluesky-social/indigo/api/atproto" 32 32 + "github.com/bluesky-social/indigo/atproto/syntax" 32 33 lexutil "github.com/bluesky-social/indigo/lex/util" 33 34 "github.com/go-chi/chi/v5" 34 35 "github.com/google/uuid" ··· 1633 1634 newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId) 1634 1635 if err != nil { 1635 1636 log.Println("failed to create resubmitted stack", err) 1636 1636 - s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") 1637 1637 + s.pages.Notice(w, "pull-resubmit-error", "Failed to merge pull request. Try again later.") 1637 1638 return 1638 1639 } 1639 1640 1640 1641 // find the diff between the stacks, first, map them by changeId 1641 1642 origById := make(map[string]*db.Pull) 1642 1643 newById := make(map[string]*db.Pull) 1644 1644 + chIdToAtUri := make(map[string]*syntax.ATURI) 1643 1645 for _, p := range origStack { 1644 1646 origById[p.ChangeId] = p 1647 1647 + 1648 1648 + // build map from change id to existing at uris (ignore error as it shouldnt be possible here) 1649 1649 + pAtUri, _ := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, p.Rkey)) 1650 1650 + chIdToAtUri[p.ChangeId] = &pAtUri 1645 1651 } 1646 1652 for _, p := range newStack { 1653 1653 + // if change id has already been given a PR use its at uri instead of the newly created (and thus incorrect) 1654 1654 + // one made by newStack 1655 1655 + if ppAt, ok := chIdToAtUri[p.ParentChangeId]; ok { 1656 1656 + p.ParentAt = ppAt 1657 1657 + } 1658 1658 + 1647 1659 newById[p.ChangeId] = p 1648 1660 } 1649 1661 ··· 1691 1703 // we still need to update the hash in submission.Patch and submission.SourceRev 1692 1704 if patchutil.Equal(newFiles, origFiles) && 1693 1705 origHeader.Title == newHeader.Title && 1694 1694 - origHeader.Body == newHeader.Body { 1706 1706 + origHeader.Body == newHeader.Body && 1707 1707 + op.ParentChangeId == np.ParentChangeId { 1695 1708 unchanged[op.ChangeId] = struct{}{} 1696 1709 } else { 1697 1710 updated[op.ChangeId] = struct{}{} ··· 1775 1788 1776 1789 record := op.AsRecord() 1777 1790 record.Patch = submission.Patch 1791 1791 + record.StackInfo.Parent = (*string)(np.ParentAt) 1778 1792 1779 1793 writes = append(writes, &comatproto.RepoApplyWrites_Input_Writes_Elem{ 1780 1794 RepoApplyWrites_Update: &comatproto.RepoApplyWrites_Update{ ··· 2123 2137 // the stack is identified by a UUID 2124 2138 var stack db.Stack 2125 2139 parentChangeId := "" 2140 2140 + var parentAt *syntax.ATURI = nil 2126 2141 for _, fp := range formatPatches { 2127 2142 // all patches must have a jj change-id 2128 2143 changeId, err := fp.ChangeId() ··· 2153 2168 2154 2169 StackId: stackId, 2155 2170 ChangeId: changeId, 2171 2171 + ParentAt: parentAt, 2156 2172 ParentChangeId: parentChangeId, 2157 2173 } 2158 2174 2159 2175 stack = append(stack, &pull) 2160 2176 2161 2177 parentChangeId = changeId 2178 2178 + // this is a bit of an ugly way to create the ATURI but its the best we can do with the data flow here 2179 2179 + // (igore error as it shouldnt be possible here) 2180 2180 + parsedParentAt, _ := syntax.ParseATURI(fmt.Sprintf("at://%s/%s/%s", user.Did, tangled.RepoPullNSID, pull.Rkey)); 2181 2181 + parentAt = &parsedParentAt 2162 2182 } 2163 2183 2164 2184 return stack, nil

+1

cmd/gen.go

··· 44 44 tangled.RepoIssueState{}, 45 45 tangled.RepoPull{}, 46 46 tangled.RepoPullComment{}, 47 47 + tangled.RepoPull_StackInfo{}, 47 48 tangled.RepoPull_Source{}, 48 49 tangled.RepoPull_Target{}, 49 50 tangled.RepoPullStatus{},

+21

lexicons/pulls/pull.json

··· 29 29 "patch": { 30 30 "type": "string" 31 31 }, 32 32 + "stackInfo": { 33 33 + "type": "ref", 34 34 + "ref": "#stackInfo" 35 35 + }, 32 36 "source": { 33 37 "type": "ref", 34 38 "ref": "#source" ··· 76 80 "format": "at-uri" 77 81 } 78 82 } 83 83 + }, 84 84 + "stackInfo": { 85 85 + "type": "object", 86 86 + "required": [ 87 87 + "changeId" 88 88 + ], 89 89 + "properties": { 90 90 + "changeId": { 91 91 + "type": "string", 92 92 + "description": "Change ID of this commit/change." 93 93 + }, 94 94 + "parent": { 95 95 + "type": "string", 96 96 + "description": "AT-URI of the PR for the parent commit/change in the change stack.", 97 97 + "format": "at-uri" 98 98 + } 99 99 + } 79 100 } 80 101 } 81 102 }