+18 -18

appview/issues/issues.go

··· 72 72 return 73 73 } 74 74 75 75 - issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt, issueIdInt) 75 75 + issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt(), issueIdInt) 76 76 if err != nil { 77 77 log.Println("failed to get issue and comments", err) 78 78 rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") ··· 126 126 return 127 127 } 128 128 129 129 - issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt) 129 129 + issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 130 130 if err != nil { 131 131 log.Println("failed to get issue", err) 132 132 rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") ··· 170 170 return 171 171 } 172 172 173 173 - err = db.CloseIssue(rp.db, f.RepoAt, issueIdInt) 173 173 + err = db.CloseIssue(rp.db, f.RepoAt(), issueIdInt) 174 174 if err != nil { 175 175 log.Println("failed to close issue", err) 176 176 rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") ··· 202 202 return 203 203 } 204 204 205 205 - issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt) 205 205 + issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 206 206 if err != nil { 207 207 log.Println("failed to get issue", err) 208 208 rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.") ··· 219 219 isIssueOwner := user.Did == issue.OwnerDid 220 220 221 221 if isCollaborator || isIssueOwner { 222 222 - err := db.ReopenIssue(rp.db, f.RepoAt, issueIdInt) 222 222 + err := db.ReopenIssue(rp.db, f.RepoAt(), issueIdInt) 223 223 if err != nil { 224 224 log.Println("failed to reopen issue", err) 225 225 rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.") ··· 263 263 264 264 err := db.NewIssueComment(rp.db, &db.Comment{ 265 265 OwnerDid: user.Did, 266 266 - RepoAt: f.RepoAt, 266 266 + RepoAt: f.RepoAt(), 267 267 Issue: issueIdInt, 268 268 CommentId: commentId, 269 269 Body: body, ··· 278 278 createdAt := time.Now().Format(time.RFC3339) 279 279 commentIdInt64 := int64(commentId) 280 280 ownerDid := user.Did 281 281 - issueAt, err := db.GetIssueAt(rp.db, f.RepoAt, issueIdInt) 281 281 + issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt) 282 282 if err != nil { 283 283 log.Println("failed to get issue at", err) 284 284 rp.pages.Notice(w, "issue-comment", "Failed to create comment.") 285 285 return 286 286 } 287 287 288 288 - atUri := f.RepoAt.String() 288 288 + atUri := f.RepoAt().String() 289 289 client, err := rp.oauth.AuthorizedClient(r) 290 290 if err != nil { 291 291 log.Println("failed to get authorized client", err) ··· 342 342 return 343 343 } 344 344 345 345 - issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt) 345 345 + issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 346 346 if err != nil { 347 347 log.Println("failed to get issue", err) 348 348 rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 349 349 return 350 350 } 351 351 352 352 - comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt) 352 352 + comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 353 353 if err != nil { 354 354 http.Error(w, "bad comment id", http.StatusBadRequest) 355 355 return ··· 387 387 return 388 388 } 389 389 390 390 - issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt) 390 390 + issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 391 391 if err != nil { 392 392 log.Println("failed to get issue", err) 393 393 rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") 394 394 return 395 395 } 396 396 397 397 - comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt) 397 397 + comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 398 398 if err != nil { 399 399 http.Error(w, "bad comment id", http.StatusBadRequest) 400 400 return ··· 505 505 return 506 506 } 507 507 508 508 - issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt) 508 508 + issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt) 509 509 if err != nil { 510 510 log.Println("failed to get issue", err) 511 511 rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.") ··· 520 520 return 521 521 } 522 522 523 523 - comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt) 523 523 + comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 524 524 if err != nil { 525 525 http.Error(w, "bad comment id", http.StatusBadRequest) 526 526 return ··· 538 538 539 539 // optimistic deletion 540 540 deleted := time.Now() 541 541 - err = db.DeleteComment(rp.db, f.RepoAt, issueIdInt, commentIdInt) 541 541 + err = db.DeleteComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt) 542 542 if err != nil { 543 543 log.Println("failed to delete comment") 544 544 rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment") ··· 602 602 return 603 603 } 604 604 605 605 - issues, err := db.GetIssues(rp.db, f.RepoAt, isOpen, page) 605 605 + issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page) 606 606 if err != nil { 607 607 log.Println("failed to get issues", err) 608 608 rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.") ··· 649 649 } 650 650 651 651 issue := &db.Issue{ 652 652 - RepoAt: f.RepoAt, 652 652 + RepoAt: f.RepoAt(), 653 653 Rkey: tid.TID(), 654 654 Title: title, 655 655 Body: body, ··· 668 668 rp.pages.Notice(w, "issues", "Failed to create issue.") 669 669 return 670 670 } 671 671 - atUri := f.RepoAt.String() 671 671 + atUri := f.RepoAt().String() 672 672 _, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{ 673 673 Collection: tangled.RepoIssueNSID, 674 674 Repo: user.Did,

+3 -8

appview/middleware/middleware.go

··· 9 9 "slices" 10 10 "strconv" 11 11 "strings" 12 12 - "time" 13 12 14 13 "github.com/bluesky-social/indigo/atproto/identity" 15 14 "github.com/go-chi/chi/v5" ··· 222 221 return 223 222 } 224 223 225 225 - ctx := context.WithValue(req.Context(), "knot", repo.Knot) 226 226 - ctx = context.WithValue(ctx, "repoAt", repo.AtUri) 227 227 - ctx = context.WithValue(ctx, "repoDescription", repo.Description) 228 228 - ctx = context.WithValue(ctx, "repoSpindle", repo.Spindle) 229 229 - ctx = context.WithValue(ctx, "repoAddedAt", repo.Created.Format(time.RFC3339)) 224 224 + ctx := context.WithValue(req.Context(), "repo", repo) 230 225 next.ServeHTTP(w, req.WithContext(ctx)) 231 226 }) 232 227 } ··· 251 246 return 252 247 } 253 248 254 254 - pr, err := db.GetPull(mw.db, f.RepoAt, prIdInt) 249 249 + pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt) 255 250 if err != nil { 256 251 log.Println("failed to get pull and comments", err) 257 252 return ··· 292 287 return 293 288 } 294 289 295 295 - fullName := f.OwnerHandle() + "/" + f.RepoName 290 290 + fullName := f.OwnerHandle() + "/" + f.Name 296 291 297 292 if r.Header.Get("User-Agent") == "Go-http-client/1.1" { 298 293 if r.URL.Query().Get("go-get") == "1" {

+21 -21

appview/pulls/pulls.go

··· 246 246 patch = mergeable.CombinedPatch() 247 247 } 248 248 249 249 - resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch) 249 249 + resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch) 250 250 if err != nil { 251 251 log.Println("failed to check for mergeability:", err) 252 252 return types.MergeCheckResponse{ ··· 307 307 // pulls within the same repo 308 308 knot = f.Knot 309 309 ownerDid = f.OwnerDid() 310 310 - repoName = f.RepoName 310 310 + repoName = f.Name 311 311 } 312 312 313 313 us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev) ··· 483 483 484 484 pulls, err := db.GetPulls( 485 485 s.db, 486 486 - db.FilterEq("repo_at", f.RepoAt), 486 486 + db.FilterEq("repo_at", f.RepoAt()), 487 487 db.FilterEq("state", state), 488 488 ) 489 489 if err != nil { ··· 610 610 createdAt := time.Now().Format(time.RFC3339) 611 611 ownerDid := user.Did 612 612 613 613 - pullAt, err := db.GetPullAt(s.db, f.RepoAt, pull.PullId) 613 613 + pullAt, err := db.GetPullAt(s.db, f.RepoAt(), pull.PullId) 614 614 if err != nil { 615 615 log.Println("failed to get pull at", err) 616 616 s.pages.Notice(w, "pull-comment", "Failed to create comment.") 617 617 return 618 618 } 619 619 620 620 - atUri := f.RepoAt.String() 620 620 + atUri := f.RepoAt().String() 621 621 client, err := s.oauth.AuthorizedClient(r) 622 622 if err != nil { 623 623 log.Println("failed to get authorized client", err) ··· 646 646 647 647 comment := &db.PullComment{ 648 648 OwnerDid: user.Did, 649 649 - RepoAt: f.RepoAt.String(), 649 649 + RepoAt: f.RepoAt().String(), 650 650 PullId: pull.PullId, 651 651 Body: body, 652 652 CommentAt: atResp.Uri, ··· 692 692 return 693 693 } 694 694 695 695 - result, err := us.Branches(f.OwnerDid(), f.RepoName) 695 695 + result, err := us.Branches(f.OwnerDid(), f.Name) 696 696 if err != nil { 697 697 log.Println("failed to fetch branches", err) 698 698 return ··· 816 816 return 817 817 } 818 818 819 819 - comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch) 819 819 + comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, targetBranch, sourceBranch) 820 820 if err != nil { 821 821 log.Println("failed to compare", err) 822 822 s.pages.Notice(w, "pull", err.Error()) ··· 1007 1007 Body: body, 1008 1008 TargetBranch: targetBranch, 1009 1009 OwnerDid: user.Did, 1010 1010 - RepoAt: f.RepoAt, 1010 1010 + RepoAt: f.RepoAt(), 1011 1011 Rkey: rkey, 1012 1012 Submissions: []*db.PullSubmission{ 1013 1013 &initialSubmission, ··· 1020 1020 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1021 1021 return 1022 1022 } 1023 1023 - pullId, err := db.NextPullId(tx, f.RepoAt) 1023 1023 + pullId, err := db.NextPullId(tx, f.RepoAt()) 1024 1024 if err != nil { 1025 1025 log.Println("failed to get pull id", err) 1026 1026 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") ··· 1035 1035 Val: &tangled.RepoPull{ 1036 1036 Title: title, 1037 1037 PullId: int64(pullId), 1038 1038 - TargetRepo: string(f.RepoAt), 1038 1038 + TargetRepo: string(f.RepoAt()), 1039 1039 TargetBranch: targetBranch, 1040 1040 Patch: patch, 1041 1041 Source: recordPullSource, ··· 1213 1213 return 1214 1214 } 1215 1215 1216 1216 - result, err := us.Branches(f.OwnerDid(), f.RepoName) 1216 1216 + result, err := us.Branches(f.OwnerDid(), f.Name) 1217 1217 if err != nil { 1218 1218 log.Println("failed to reach knotserver", err) 1219 1219 return ··· 1297 1297 return 1298 1298 } 1299 1299 1300 1300 - targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName) 1300 1300 + targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.Name) 1301 1301 if err != nil { 1302 1302 log.Println("failed to reach knotserver for target branches", err) 1303 1303 return ··· 1413 1413 return 1414 1414 } 1415 1415 1416 1416 - comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch) 1416 1416 + comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, pull.TargetBranch, pull.PullSource.Branch) 1417 1417 if err != nil { 1418 1418 log.Printf("compare request failed: %s", err) 1419 1419 s.pages.Notice(w, "resubmit-error", err.Error()) ··· 1597 1597 Val: &tangled.RepoPull{ 1598 1598 Title: pull.Title, 1599 1599 PullId: int64(pull.PullId), 1600 1600 - TargetRepo: string(f.RepoAt), 1600 1600 + TargetRepo: string(f.RepoAt()), 1601 1601 TargetBranch: pull.TargetBranch, 1602 1602 Patch: patch, // new patch 1603 1603 Source: recordPullSource, ··· 1934 1934 } 1935 1935 1936 1936 // Merge the pull request 1937 1937 - resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address) 1937 1937 + resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address) 1938 1938 if err != nil { 1939 1939 log.Printf("failed to merge pull request: %s", err) 1940 1940 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") ··· 1956 1956 defer tx.Rollback() 1957 1957 1958 1958 for _, p := range pullsToMerge { 1959 1959 - err := db.MergePull(tx, f.RepoAt, p.PullId) 1959 1959 + err := db.MergePull(tx, f.RepoAt(), p.PullId) 1960 1960 if err != nil { 1961 1961 log.Printf("failed to update pull request status in database: %s", err) 1962 1962 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") ··· 1972 1972 return 1973 1973 } 1974 1974 1975 1975 - s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.RepoName, pull.PullId)) 1975 1975 + s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId)) 1976 1976 } 1977 1977 1978 1978 func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) { ··· 2024 2024 2025 2025 for _, p := range pullsToClose { 2026 2026 // Close the pull in the database 2027 2027 - err = db.ClosePull(tx, f.RepoAt, p.PullId) 2027 2027 + err = db.ClosePull(tx, f.RepoAt(), p.PullId) 2028 2028 if err != nil { 2029 2029 log.Println("failed to close pull", err) 2030 2030 s.pages.Notice(w, "pull-close", "Failed to close pull.") ··· 2092 2092 2093 2093 for _, p := range pullsToReopen { 2094 2094 // Close the pull in the database 2095 2095 - err = db.ReopenPull(tx, f.RepoAt, p.PullId) 2095 2095 + err = db.ReopenPull(tx, f.RepoAt(), p.PullId) 2096 2096 if err != nil { 2097 2097 log.Println("failed to close pull", err) 2098 2098 s.pages.Notice(w, "pull-close", "Failed to close pull.") ··· 2144 2144 Body: body, 2145 2145 TargetBranch: targetBranch, 2146 2146 OwnerDid: user.Did, 2147 2147 - RepoAt: f.RepoAt, 2147 2147 + RepoAt: f.RepoAt(), 2148 2148 Rkey: rkey, 2149 2149 Submissions: []*db.PullSubmission{ 2150 2150 &initialSubmission,

+6 -6

appview/repo/artifact.go

··· 76 76 Artifact: uploadBlobResp.Blob, 77 77 CreatedAt: createdAt.Format(time.RFC3339), 78 78 Name: handler.Filename, 79 79 - Repo: f.RepoAt.String(), 79 79 + Repo: f.RepoAt().String(), 80 80 Tag: tag.Tag.Hash[:], 81 81 }, 82 82 }, ··· 100 100 artifact := db.Artifact{ 101 101 Did: user.Did, 102 102 Rkey: rkey, 103 103 - RepoAt: f.RepoAt, 103 103 + RepoAt: f.RepoAt(), 104 104 Tag: tag.Tag.Hash, 105 105 CreatedAt: createdAt, 106 106 BlobCid: cid.Cid(uploadBlobResp.Blob.Ref), ··· 155 155 156 156 artifacts, err := db.GetArtifact( 157 157 rp.db, 158 158 - db.FilterEq("repo_at", f.RepoAt), 158 158 + db.FilterEq("repo_at", f.RepoAt()), 159 159 db.FilterEq("tag", tag.Tag.Hash[:]), 160 160 db.FilterEq("name", filename), 161 161 ) ··· 197 197 198 198 artifacts, err := db.GetArtifact( 199 199 rp.db, 200 200 - db.FilterEq("repo_at", f.RepoAt), 200 200 + db.FilterEq("repo_at", f.RepoAt()), 201 201 db.FilterEq("tag", tag[:]), 202 202 db.FilterEq("name", filename), 203 203 ) ··· 239 239 defer tx.Rollback() 240 240 241 241 err = db.DeleteArtifact(tx, 242 242 - db.FilterEq("repo_at", f.RepoAt), 242 242 + db.FilterEq("repo_at", f.RepoAt()), 243 243 db.FilterEq("tag", artifact.Tag[:]), 244 244 db.FilterEq("name", filename), 245 245 ) ··· 270 270 return nil, err 271 271 } 272 272 273 273 - result, err := us.Tags(f.OwnerDid(), f.RepoName) 273 273 + result, err := us.Tags(f.OwnerDid(), f.Name) 274 274 if err != nil { 275 275 log.Println("failed to reach knotserver", err) 276 276 return nil, err

+5 -5

appview/repo/index.go

··· 37 37 return 38 38 } 39 39 40 40 - result, err := us.Index(f.OwnerDid(), f.RepoName, ref) 40 40 + result, err := us.Index(f.OwnerDid(), f.Name, ref) 41 41 if err != nil { 42 42 rp.pages.Error503(w) 43 43 log.Println("failed to reach knotserver", err) ··· 166 166 // first attempt to fetch from db 167 167 langs, err := db.GetRepoLanguages( 168 168 rp.db, 169 169 - db.FilterEq("repo_at", f.RepoAt), 169 169 + db.FilterEq("repo_at", f.RepoAt()), 170 170 db.FilterEq("ref", f.Ref), 171 171 ) 172 172 173 173 if err != nil || langs == nil { 174 174 // non-fatal, fetch langs from ks 175 175 - ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.RepoName, f.Ref) 175 175 + ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, f.Ref) 176 176 if err != nil { 177 177 return nil, err 178 178 } ··· 182 182 183 183 for l, s := range ls.Languages { 184 184 langs = append(langs, db.RepoLanguage{ 185 185 - RepoAt: f.RepoAt, 185 185 + RepoAt: f.RepoAt(), 186 186 Ref: f.Ref, 187 187 IsDefaultRef: isDefaultRef, 188 188 Language: l, ··· 279 279 hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref) 280 280 281 281 var status types.AncestorCheckResponse 282 282 - forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt), repoInfo.Name, f.Ref, hiddenRef) 282 282 + forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, f.Ref, hiddenRef) 283 283 if err != nil { 284 284 log.Printf("failed to check if fork is ahead/behind: %s", err) 285 285 return nil, err

+45 -46

appview/repo/repo.go

··· 95 95 } else { 96 96 uri = "https" 97 97 } 98 98 - url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.RepoName, url.PathEscape(refParam)) 98 98 + url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.Name, url.PathEscape(refParam)) 99 99 100 100 http.Redirect(w, r, url, http.StatusFound) 101 101 } ··· 123 123 return 124 124 } 125 125 126 126 - repolog, err := us.Log(f.OwnerDid(), f.RepoName, ref, page) 126 126 + repolog, err := us.Log(f.OwnerDid(), f.Name, ref, page) 127 127 if err != nil { 128 128 log.Println("failed to reach knotserver", err) 129 129 return 130 130 } 131 131 132 132 - tagResult, err := us.Tags(f.OwnerDid(), f.RepoName) 132 132 + tagResult, err := us.Tags(f.OwnerDid(), f.Name) 133 133 if err != nil { 134 134 log.Println("failed to reach knotserver", err) 135 135 return ··· 144 144 tagMap[hash] = append(tagMap[hash], tag.Name) 145 145 } 146 146 147 147 - branchResult, err := us.Branches(f.OwnerDid(), f.RepoName) 147 147 + branchResult, err := us.Branches(f.OwnerDid(), f.Name) 148 148 if err != nil { 149 149 log.Println("failed to reach knotserver", err) 150 150 return ··· 212 212 return 213 213 } 214 214 215 215 - repoAt := f.RepoAt 215 215 + repoAt := f.RepoAt() 216 216 rkey := repoAt.RecordKey().String() 217 217 if rkey == "" { 218 218 log.Println("invalid aturi for repo", err) ··· 262 262 Record: &lexutil.LexiconTypeDecoder{ 263 263 Val: &tangled.Repo{ 264 264 Knot: f.Knot, 265 265 - Name: f.RepoName, 265 265 + Name: f.Name, 266 266 Owner: user.Did, 267 267 - CreatedAt: f.CreatedAt, 267 267 + CreatedAt: f.Created.Format(time.RFC3339), 268 268 Description: &newDescription, 269 269 Spindle: &f.Spindle, 270 270 }, ··· 310 310 return 311 311 } 312 312 313 313 - resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref)) 313 313 + resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref)) 314 314 if err != nil { 315 315 log.Println("failed to reach knotserver", err) 316 316 return ··· 375 375 if !rp.config.Core.Dev { 376 376 protocol = "https" 377 377 } 378 378 - resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, treePath)) 378 378 + resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, treePath)) 379 379 if err != nil { 380 380 log.Println("failed to reach knotserver", err) 381 381 return ··· 405 405 user := rp.oauth.GetUser(r) 406 406 407 407 var breadcrumbs [][]string 408 408 - breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)}) 408 408 + breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)}) 409 409 if treePath != "" { 410 410 for idx, elem := range strings.Split(treePath, "/") { 411 411 breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)}) ··· 436 436 return 437 437 } 438 438 439 439 - result, err := us.Tags(f.OwnerDid(), f.RepoName) 439 439 + result, err := us.Tags(f.OwnerDid(), f.Name) 440 440 if err != nil { 441 441 log.Println("failed to reach knotserver", err) 442 442 return 443 443 } 444 444 445 445 - artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt)) 445 445 + artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt())) 446 446 if err != nil { 447 447 log.Println("failed grab artifacts", err) 448 448 return ··· 493 493 return 494 494 } 495 495 496 496 - result, err := us.Branches(f.OwnerDid(), f.RepoName) 496 496 + result, err := us.Branches(f.OwnerDid(), f.Name) 497 497 if err != nil { 498 498 log.Println("failed to reach knotserver", err) 499 499 return ··· 522 522 if !rp.config.Core.Dev { 523 523 protocol = "https" 524 524 } 525 525 - resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath)) 525 525 + resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath)) 526 526 if err != nil { 527 527 log.Println("failed to reach knotserver", err) 528 528 return ··· 542 542 } 543 543 544 544 var breadcrumbs [][]string 545 545 - breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)}) 545 545 + breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)}) 546 546 if filePath != "" { 547 547 for idx, elem := range strings.Split(filePath, "/") { 548 548 breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)}) ··· 575 575 576 576 // fetch the actual binary content like in RepoBlobRaw 577 577 578 578 - blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath) 578 578 + blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Name, ref, filePath) 579 579 contentSrc = blobURL 580 580 if !rp.config.Core.Dev { 581 581 contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL) ··· 612 612 if !rp.config.Core.Dev { 613 613 protocol = "https" 614 614 } 615 615 - blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath) 615 615 + blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath) 616 616 resp, err := http.Get(blobURL) 617 617 if err != nil { 618 618 log.Println("failed to reach knotserver:", err) ··· 668 668 return 669 669 } 670 670 671 671 - repoAt := f.RepoAt 671 671 + repoAt := f.RepoAt() 672 672 rkey := repoAt.RecordKey().String() 673 673 if rkey == "" { 674 674 fail("Failed to resolve repo. Try again later", err) ··· 722 722 Record: &lexutil.LexiconTypeDecoder{ 723 723 Val: &tangled.Repo{ 724 724 Knot: f.Knot, 725 725 - Name: f.RepoName, 725 725 + Name: f.Name, 726 726 Owner: user.Did, 727 727 - CreatedAt: f.CreatedAt, 727 727 + CreatedAt: f.Created.Format(time.RFC3339), 728 728 Description: &f.Description, 729 729 Spindle: spindlePtr, 730 730 }, ··· 805 805 Record: &lexutil.LexiconTypeDecoder{ 806 806 Val: &tangled.RepoCollaborator{ 807 807 Subject: collaboratorIdent.DID.String(), 808 808 - Repo: string(f.RepoAt), 808 808 + Repo: string(f.RepoAt()), 809 809 CreatedAt: createdAt.Format(time.RFC3339), 810 810 }}, 811 811 }) ··· 830 830 return 831 831 } 832 832 833 833 - ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.RepoName, collaboratorIdent.DID.String()) 833 833 + ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.Name, collaboratorIdent.DID.String()) 834 834 if err != nil { 835 835 fail("Knot was unreachable.", err) 836 836 return ··· 864 864 Did: syntax.DID(currentUser.Did), 865 865 Rkey: rkey, 866 866 SubjectDid: collaboratorIdent.DID, 867 867 - RepoAt: f.RepoAt, 867 867 + RepoAt: f.RepoAt(), 868 868 Created: createdAt, 869 869 }) 870 870 if err != nil { ··· 902 902 log.Println("failed to get authorized client", err) 903 903 return 904 904 } 905 905 - repoRkey := f.RepoAt.RecordKey().String() 906 905 _, err = xrpcClient.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{ 907 906 Collection: tangled.RepoNSID, 908 907 Repo: user.Did, 909 909 - Rkey: repoRkey, 908 908 + Rkey: f.Rkey, 910 909 }) 911 910 if err != nil { 912 911 log.Printf("failed to delete record: %s", err) 913 912 rp.pages.Notice(w, "settings-delete", "Failed to delete repository from PDS.") 914 913 return 915 914 } 916 916 - log.Println("removed repo record ", f.RepoAt.String()) 915 915 + log.Println("removed repo record ", f.RepoAt().String()) 917 916 918 917 secret, err := db.GetRegistrationKey(rp.db, f.Knot) 919 918 if err != nil { ··· 927 926 return 928 927 } 929 928 930 930 - ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.RepoName) 929 929 + ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.Name) 931 930 if err != nil { 932 931 log.Printf("failed to make request to %s: %s", f.Knot, err) 933 932 return ··· 973 972 } 974 973 975 974 // remove repo from db 976 976 - err = db.RemoveRepo(tx, f.OwnerDid(), f.RepoName) 975 975 + err = db.RemoveRepo(tx, f.OwnerDid(), f.Name) 977 976 if err != nil { 978 977 rp.pages.Notice(w, "settings-delete", "Failed to update appview") 979 978 return ··· 1022 1021 return 1023 1022 } 1024 1023 1025 1025 - ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.RepoName, branch) 1024 1024 + ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.Name, branch) 1026 1025 if err != nil { 1027 1026 log.Printf("failed to make request to %s: %s", f.Knot, err) 1028 1027 return ··· 1090 1089 r.Context(), 1091 1090 spindleClient, 1092 1091 &tangled.RepoAddSecret_Input{ 1093 1093 - Repo: f.RepoAt.String(), 1092 1092 + Repo: f.RepoAt().String(), 1094 1093 Key: key, 1095 1094 Value: value, 1096 1095 }, ··· 1108 1107 r.Context(), 1109 1108 spindleClient, 1110 1109 &tangled.RepoRemoveSecret_Input{ 1111 1111 - Repo: f.RepoAt.String(), 1110 1110 + Repo: f.RepoAt().String(), 1112 1111 Key: key, 1113 1112 }, 1114 1113 ) ··· 1170 1169 // return 1171 1170 // } 1172 1171 1173 1173 - // result, err := us.Branches(f.OwnerDid(), f.RepoName) 1172 1172 + // result, err := us.Branches(f.OwnerDid(), f.Name) 1174 1173 // if err != nil { 1175 1174 // log.Println("failed to reach knotserver", err) 1176 1175 // return ··· 1192 1191 // oauth.WithDev(rp.config.Core.Dev), 1193 1192 // ); err != nil { 1194 1193 // log.Println("failed to create spindle client", err) 1195 1195 - // } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil { 1194 1194 + // } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil { 1196 1195 // log.Println("failed to fetch secrets", err) 1197 1196 // } else { 1198 1197 // secrets = resp.Secrets ··· 1221 1220 return 1222 1221 } 1223 1222 1224 1224 - result, err := us.Branches(f.OwnerDid(), f.RepoName) 1223 1223 + result, err := us.Branches(f.OwnerDid(), f.Name) 1225 1224 if err != nil { 1226 1225 log.Println("failed to reach knotserver", err) 1227 1226 return ··· 1275 1274 oauth.WithDev(rp.config.Core.Dev), 1276 1275 ); err != nil { 1277 1276 log.Println("failed to create spindle client", err) 1278 1278 - } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil { 1277 1277 + } else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil { 1279 1278 log.Println("failed to fetch secrets", err) 1280 1279 } else { 1281 1280 secrets = resp.Secrets ··· 1343 1342 } else { 1344 1343 uri = "https" 1345 1344 } 1346 1346 - forkName := fmt.Sprintf("%s", f.RepoName) 1347 1347 - forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName) 1345 1345 + forkName := fmt.Sprintf("%s", f.Name) 1346 1346 + forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name) 1348 1347 1349 1348 _, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, f.Ref) 1350 1349 if err != nil { ··· 1394 1393 return 1395 1394 } 1396 1395 1397 1397 - forkName := fmt.Sprintf("%s", f.RepoName) 1396 1396 + forkName := fmt.Sprintf("%s", f.Name) 1398 1397 1399 1398 // this check is *only* to see if the forked repo name already exists 1400 1399 // in the user's account. 1401 1401 - existingRepo, err := db.GetRepo(rp.db, user.Did, f.RepoName) 1400 1400 + existingRepo, err := db.GetRepo(rp.db, user.Did, f.Name) 1402 1401 if err != nil { 1403 1402 if errors.Is(err, sql.ErrNoRows) { 1404 1403 // no existing repo with this name found, we can use the name as is ··· 1429 1428 } else { 1430 1429 uri = "https" 1431 1430 } 1432 1432 - forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName) 1433 1433 - sourceAt := f.RepoAt.String() 1431 1431 + forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name) 1432 1432 + sourceAt := f.RepoAt().String() 1434 1433 1435 1434 rkey := tid.TID() 1436 1435 repo := &db.Repo{ ··· 1550 1549 return 1551 1550 } 1552 1551 1553 1553 - result, err := us.Branches(f.OwnerDid(), f.RepoName) 1552 1552 + result, err := us.Branches(f.OwnerDid(), f.Name) 1554 1553 if err != nil { 1555 1554 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1556 1555 log.Println("failed to reach knotserver", err) ··· 1580 1579 head = queryHead 1581 1580 } 1582 1581 1583 1583 - tags, err := us.Tags(f.OwnerDid(), f.RepoName) 1582 1582 + tags, err := us.Tags(f.OwnerDid(), f.Name) 1584 1583 if err != nil { 1585 1584 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1586 1585 log.Println("failed to reach knotserver", err) ··· 1642 1641 return 1643 1642 } 1644 1643 1645 1645 - branches, err := us.Branches(f.OwnerDid(), f.RepoName) 1644 1644 + branches, err := us.Branches(f.OwnerDid(), f.Name) 1646 1645 if err != nil { 1647 1646 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1648 1647 log.Println("failed to reach knotserver", err) 1649 1648 return 1650 1649 } 1651 1650 1652 1652 - tags, err := us.Tags(f.OwnerDid(), f.RepoName) 1651 1651 + tags, err := us.Tags(f.OwnerDid(), f.Name) 1653 1652 if err != nil { 1654 1653 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1655 1654 log.Println("failed to reach knotserver", err) 1656 1655 return 1657 1656 } 1658 1657 1659 1659 - formatPatch, err := us.Compare(f.OwnerDid(), f.RepoName, base, head) 1658 1658 + formatPatch, err := us.Compare(f.OwnerDid(), f.Name, base, head) 1660 1659 if err != nil { 1661 1660 rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.") 1662 1661 log.Println("failed to compare", err)

+25 -58

appview/reporesolver/resolver.go

··· 12 12 "strings" 13 13 14 14 "github.com/bluesky-social/indigo/atproto/identity" 15 15 - "github.com/bluesky-social/indigo/atproto/syntax" 16 15 securejoin "github.com/cyphar/filepath-securejoin" 17 16 "github.com/go-chi/chi/v5" 18 17 "tangled.sh/tangled.sh/core/appview/config" ··· 26 25 ) 27 26 28 27 type ResolvedRepo struct { 29 29 - Knot string 28 28 + db.Repo 30 29 OwnerId identity.Identity 31 31 - RepoName string 32 32 - RepoAt syntax.ATURI 33 33 - Description string 34 34 - Spindle string 35 35 - CreatedAt string 36 30 Ref string 37 31 CurrentDir string 38 32 ··· 51 45 } 52 46 53 47 func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) { 54 54 - repoName := chi.URLParam(r, "repo") 55 55 - knot, ok := r.Context().Value("knot").(string) 48 48 + repo, ok := r.Context().Value("repo").(*db.Repo) 56 49 if !ok { 57 57 - log.Println("malformed middleware") 50 50 + log.Println("malformed middleware: `repo` not exist in context") 58 51 return nil, fmt.Errorf("malformed middleware") 59 52 } 60 53 id, ok := r.Context().Value("resolvedId").(identity.Identity) ··· 63 56 return nil, fmt.Errorf("malformed middleware") 64 57 } 65 58 66 66 - repoAt, ok := r.Context().Value("repoAt").(string) 67 67 - if !ok { 68 68 - log.Println("malformed middleware") 69 69 - return nil, fmt.Errorf("malformed middleware") 70 70 - } 71 71 - 72 72 - parsedRepoAt, err := syntax.ParseATURI(repoAt) 73 73 - if err != nil { 74 74 - log.Println("malformed repo at-uri") 75 75 - return nil, fmt.Errorf("malformed middleware") 76 76 - } 77 77 - 78 59 ref := chi.URLParam(r, "ref") 79 60 80 61 if ref == "" { 81 81 - us, err := knotclient.NewUnsignedClient(knot, rr.config.Core.Dev) 62 62 + us, err := knotclient.NewUnsignedClient(repo.Knot, rr.config.Core.Dev) 82 63 if err != nil { 83 64 return nil, err 84 65 } 85 66 86 86 - defaultBranch, err := us.DefaultBranch(id.DID.String(), repoName) 67 67 + defaultBranch, err := us.DefaultBranch(id.DID.String(), repo.Name) 87 68 if err != nil { 88 69 return nil, err 89 70 } ··· 93 74 94 75 currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath(), ref)) 95 76 96 96 - // pass through values from the middleware 97 97 - description, ok := r.Context().Value("repoDescription").(string) 98 98 - addedAt, ok := r.Context().Value("repoAddedAt").(string) 99 99 - spindle, ok := r.Context().Value("repoSpindle").(string) 100 100 - 101 77 return &ResolvedRepo{ 102 102 - Knot: knot, 103 103 - OwnerId: id, 104 104 - RepoName: repoName, 105 105 - RepoAt: parsedRepoAt, 106 106 - Description: description, 107 107 - CreatedAt: addedAt, 108 108 - Ref: ref, 109 109 - CurrentDir: currentDir, 110 110 - Spindle: spindle, 78 78 + Repo: *repo, 79 79 + OwnerId: id, 80 80 + Ref: ref, 81 81 + CurrentDir: currentDir, 111 82 112 83 rr: rr, 113 84 }, nil ··· 126 97 127 98 var p string 128 99 if handle != "" && !handle.IsInvalidHandle() { 129 129 - p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.RepoName) 100 100 + p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.Name) 130 101 } else { 131 131 - p, _ = securejoin.SecureJoin(f.OwnerDid(), f.RepoName) 102 102 + p, _ = securejoin.SecureJoin(f.OwnerDid(), f.Name) 132 103 } 133 104 134 134 - return p 135 135 - } 136 136 - 137 137 - func (f *ResolvedRepo) DidSlashRepo() string { 138 138 - p, _ := securejoin.SecureJoin(f.OwnerDid(), f.RepoName) 139 105 return p 140 106 } 141 107 ··· 187 153 // this function is a bit weird since it now returns RepoInfo from an entirely different 188 154 // package. we should refactor this or get rid of RepoInfo entirely. 189 155 func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo { 156 156 + repoAt := f.RepoAt() 190 157 isStarred := false 191 158 if user != nil { 192 192 - isStarred = db.GetStarStatus(f.rr.execer, user.Did, syntax.ATURI(f.RepoAt)) 159 159 + isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt) 193 160 } 194 161 195 195 - starCount, err := db.GetStarCount(f.rr.execer, f.RepoAt) 162 162 + starCount, err := db.GetStarCount(f.rr.execer, repoAt) 196 163 if err != nil { 197 197 - log.Println("failed to get star count for ", f.RepoAt) 164 164 + log.Println("failed to get star count for ", repoAt) 198 165 } 199 199 - issueCount, err := db.GetIssueCount(f.rr.execer, f.RepoAt) 166 166 + issueCount, err := db.GetIssueCount(f.rr.execer, repoAt) 200 167 if err != nil { 201 201 - log.Println("failed to get issue count for ", f.RepoAt) 168 168 + log.Println("failed to get issue count for ", repoAt) 202 169 } 203 203 - pullCount, err := db.GetPullCount(f.rr.execer, f.RepoAt) 170 170 + pullCount, err := db.GetPullCount(f.rr.execer, repoAt) 204 171 if err != nil { 205 205 - log.Println("failed to get issue count for ", f.RepoAt) 172 172 + log.Println("failed to get issue count for ", repoAt) 206 173 } 207 207 - source, err := db.GetRepoSource(f.rr.execer, f.RepoAt) 174 174 + source, err := db.GetRepoSource(f.rr.execer, repoAt) 208 175 if errors.Is(err, sql.ErrNoRows) { 209 176 source = "" 210 177 } else if err != nil { 211 211 - log.Println("failed to get repo source for ", f.RepoAt, err) 178 178 + log.Println("failed to get repo source for ", repoAt, err) 212 179 } 213 180 214 181 var sourceRepo *db.Repo ··· 233 200 if err != nil { 234 201 log.Printf("failed to create unsigned client for %s: %v", knot, err) 235 202 } else { 236 236 - result, err := us.Branches(f.OwnerDid(), f.RepoName) 203 203 + result, err := us.Branches(f.OwnerDid(), f.Name) 237 204 if err != nil { 238 238 - log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.RepoName, err) 205 205 + log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.Name, err) 239 206 } 240 207 241 208 if len(result.Branches) == 0 { ··· 246 213 repoInfo := repoinfo.RepoInfo{ 247 214 OwnerDid: f.OwnerDid(), 248 215 OwnerHandle: f.OwnerHandle(), 249 249 - Name: f.RepoName, 250 250 - RepoAt: f.RepoAt, 216 216 + Name: f.Name, 217 217 + RepoAt: repoAt, 251 218 Description: f.Description, 252 219 Ref: f.Ref, 253 220 IsStarred: isStarred,