appview: prefer models.Repo over ResolvedRepo internally #812

+47 -49

appview/pulls/pulls.go

··· 115 115 return 116 116 } 117 117 118 118 - mergeCheckResponse := s.mergeCheck(r, f, pull, stack) 119 119 - branchDeleteStatus := s.branchDeleteStatus(r, f, pull) 118 118 + mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack) 119 119 + branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull) 120 120 resubmitResult := pages.Unknown 121 121 if user.Did == pull.OwnerDid { 122 122 - resubmitResult = s.resubmitCheck(r, f, pull, stack) 122 122 + resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack) 123 123 } 124 124 125 125 s.pages.PullActionsFragment(w, pages.PullActionsParams{ ··· 155 155 stack, _ := r.Context().Value("stack").(models.Stack) 156 156 abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull) 157 157 158 158 - mergeCheckResponse := s.mergeCheck(r, f, pull, stack) 159 159 - branchDeleteStatus := s.branchDeleteStatus(r, f, pull) 158 158 + mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack) 159 159 + branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull) 160 160 resubmitResult := pages.Unknown 161 161 if user != nil && user.Did == pull.OwnerDid { 162 162 - resubmitResult = s.resubmitCheck(r, f, pull, stack) 162 162 + resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack) 163 163 } 164 164 165 165 m := make(map[string]models.Pipeline) ··· 237 237 }) 238 238 } 239 239 240 240 - func (s *Pulls) mergeCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse { 240 240 + func (s *Pulls) mergeCheck(r *http.Request, f *models.Repo, pull *models.Pull, stack models.Stack) types.MergeCheckResponse { 241 241 if pull.State == models.PullMerged { 242 242 return types.MergeCheckResponse{} 243 243 } ··· 304 304 return result 305 305 } 306 306 307 307 - func (s *Pulls) branchDeleteStatus(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull) *models.BranchDeleteStatus { 307 307 + func (s *Pulls) branchDeleteStatus(r *http.Request, repo *models.Repo, pull *models.Pull) *models.BranchDeleteStatus { 308 308 if pull.State != models.PullMerged { 309 309 return nil 310 310 } ··· 315 315 } 316 316 317 317 var branch string 318 318 - var repo *models.Repo 319 318 // check if the branch exists 320 319 // NOTE: appview could cache branches/tags etc. for every repo by listening for gitRefUpdates 321 320 if pull.IsBranchBased() { 322 321 branch = pull.PullSource.Branch 323 323 - repo = &f.Repo 324 322 } else if pull.IsForkBased() { 325 323 branch = pull.PullSource.Branch 326 324 repo = pull.PullSource.Repo ··· 359 357 } 360 358 } 361 359 362 362 - func (s *Pulls) resubmitCheck(r *http.Request, f *reporesolver.ResolvedRepo, pull *models.Pull, stack models.Stack) pages.ResubmitResult { 360 360 + func (s *Pulls) resubmitCheck(r *http.Request, repo *models.Repo, pull *models.Pull, stack models.Stack) pages.ResubmitResult { 363 361 if pull.State == models.PullMerged || pull.State == models.PullDeleted || pull.PullSource == nil { 364 362 return pages.Unknown 365 363 } ··· 379 377 repoName = sourceRepo.Name 380 378 } else { 381 379 // pulls within the same repo 382 382 - knot = f.Knot 383 383 - ownerDid = f.Did 384 384 - repoName = f.Name 380 380 + knot = repo.Knot 381 381 + ownerDid = repo.Did 382 382 + repoName = repo.Name 385 383 } 386 384 387 385 scheme := "http" ··· 393 391 Host: host, 394 392 } 395 393 396 396 - repo := fmt.Sprintf("%s/%s", ownerDid, repoName) 397 397 - branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, repo) 394 394 + didSlashName := fmt.Sprintf("%s/%s", ownerDid, repoName) 395 395 + branchResp, err := tangled.RepoBranch(r.Context(), xrpcc, pull.PullSource.Branch, didSlashName) 398 396 if err != nil { 399 397 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 400 398 log.Println("failed to call XRPC repo.branches", xrpcerr) ··· 951 949 s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?") 952 950 return 953 951 } 954 954 - s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked) 952 952 + s.handleBranchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, sourceBranch, isStacked) 955 953 } else if isForkBased { 956 954 if !caps.PullRequests.ForkSubmissions { 957 955 s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?") 958 956 return 959 957 } 960 960 - s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked) 958 958 + s.handleForkBasedPull(w, r, &f.Repo, user, fromFork, title, body, targetBranch, sourceBranch, isStacked) 961 959 } else if isPatchBased { 962 960 if !caps.PullRequests.PatchSubmissions { 963 961 s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.") 964 962 return 965 963 } 966 966 - s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked) 964 964 + s.handlePatchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, patch, isStacked) 967 965 } 968 966 return 969 967 } ··· 972 970 func (s *Pulls) handleBranchBasedPull( 973 971 w http.ResponseWriter, 974 972 r *http.Request, 975 975 - f *reporesolver.ResolvedRepo, 973 973 + repo *models.Repo, 976 974 user *oauth.User, 977 975 title, 978 976 body, ··· 984 982 if !s.config.Core.Dev { 985 983 scheme = "https" 986 984 } 987 987 - host := fmt.Sprintf("%s://%s", scheme, f.Knot) 985 985 + host := fmt.Sprintf("%s://%s", scheme, repo.Knot) 988 986 xrpcc := &indigoxrpc.Client{ 989 987 Host: host, 990 988 } 991 989 992 992 - repo := fmt.Sprintf("%s/%s", f.Did, f.Name) 993 993 - xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, targetBranch, sourceBranch) 990 990 + didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 991 991 + xrpcBytes, err := tangled.RepoCompare(r.Context(), xrpcc, didSlashRepo, targetBranch, sourceBranch) 994 992 if err != nil { 995 993 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 996 994 log.Println("failed to call XRPC repo.compare", xrpcerr) ··· 1027 1025 Sha: comparison.Rev2, 1028 1026 } 1029 1027 1030 1030 - s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1028 1028 + s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1031 1029 } 1032 1030 1033 1033 - func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) { 1031 1031 + func (s *Pulls) handlePatchBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, title, body, targetBranch, patch string, isStacked bool) { 1034 1032 if err := s.validator.ValidatePatch(&patch); err != nil { 1035 1033 s.logger.Error("patch validation failed", "err", err) 1036 1034 s.pages.Notice(w, "pull", "Invalid patch format. Please provide a valid diff.") 1037 1035 return 1038 1036 } 1039 1037 1040 1040 - s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked) 1038 1038 + s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, "", "", nil, nil, isStacked) 1041 1039 } 1042 1040 1043 1043 - func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, f *reporesolver.ResolvedRepo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) { 1041 1041 + func (s *Pulls) handleForkBasedPull(w http.ResponseWriter, r *http.Request, repo *models.Repo, user *oauth.User, forkRepo string, title, body, targetBranch, sourceBranch string, isStacked bool) { 1044 1042 repoString := strings.SplitN(forkRepo, "/", 2) 1045 1043 forkOwnerDid := repoString[0] 1046 1044 repoName := repoString[1] ··· 1142 1140 Sha: sourceRev, 1143 1141 } 1144 1142 1145 1145 - s.createPullRequest(w, r, f, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1143 1143 + s.createPullRequest(w, r, repo, user, title, body, targetBranch, patch, combined, sourceRev, pullSource, recordPullSource, isStacked) 1146 1144 } 1147 1145 1148 1146 func (s *Pulls) createPullRequest( 1149 1147 w http.ResponseWriter, 1150 1148 r *http.Request, 1151 1151 - f *reporesolver.ResolvedRepo, 1149 1149 + repo *models.Repo, 1152 1150 user *oauth.User, 1153 1151 title, body, targetBranch string, 1154 1152 patch string, ··· 1163 1161 s.createStackedPullRequest( 1164 1162 w, 1165 1163 r, 1166 1166 - f, 1164 1164 + repo, 1167 1165 user, 1168 1166 targetBranch, 1169 1167 patch, ··· 1220 1218 Body: body, 1221 1219 TargetBranch: targetBranch, 1222 1220 OwnerDid: user.Did, 1223 1223 - RepoAt: f.RepoAt(), 1221 1221 + RepoAt: repo.RepoAt(), 1224 1222 Rkey: rkey, 1225 1223 Submissions: []*models.PullSubmission{ 1226 1224 &initialSubmission, ··· 1233 1231 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") 1234 1232 return 1235 1233 } 1236 1236 - pullId, err := db.NextPullId(tx, f.RepoAt()) 1234 1234 + pullId, err := db.NextPullId(tx, repo.RepoAt()) 1237 1235 if err != nil { 1238 1236 log.Println("failed to get pull id", err) 1239 1237 s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.") ··· 1248 1246 Val: &tangled.RepoPull{ 1249 1247 Title: title, 1250 1248 Target: &tangled.RepoPull_Target{ 1251 1251 - Repo: string(f.RepoAt()), 1249 1249 + Repo: string(repo.RepoAt()), 1252 1250 Branch: targetBranch, 1253 1251 }, 1254 1252 Patch: patch, ··· 1271 1269 1272 1270 s.notifier.NewPull(r.Context(), pull) 1273 1271 1274 1274 - ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo) 1272 1272 + ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo) 1275 1273 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pullId)) 1276 1274 } 1277 1275 1278 1276 func (s *Pulls) createStackedPullRequest( 1279 1277 w http.ResponseWriter, 1280 1278 r *http.Request, 1281 1281 - f *reporesolver.ResolvedRepo, 1279 1279 + repo *models.Repo, 1282 1280 user *oauth.User, 1283 1281 targetBranch string, 1284 1282 patch string, ··· 1310 1308 1311 1309 // build a stack out of this patch 1312 1310 stackId := uuid.New() 1313 1313 - stack, err := newStack(f, user, targetBranch, patch, pullSource, stackId.String()) 1311 1311 + stack, err := newStack(repo, user, targetBranch, patch, pullSource, stackId.String()) 1314 1312 if err != nil { 1315 1313 log.Println("failed to create stack", err) 1316 1314 s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create stack: %v", err)) ··· 1373 1371 return 1374 1372 } 1375 1373 1376 1376 - ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo) 1374 1374 + ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo) 1377 1375 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls", ownerSlashRepo)) 1378 1376 } 1379 1377 ··· 1645 1643 1646 1644 patch := r.FormValue("patch") 1647 1645 1648 1648 - s.resubmitPullHelper(w, r, f, user, pull, patch, "", "") 1646 1646 + s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, "", "") 1649 1647 } 1650 1648 1651 1649 func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) { ··· 1710 1708 patch := comparison.FormatPatchRaw 1711 1709 combined := comparison.CombinedPatchRaw 1712 1710 1713 1713 - s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev) 1711 1711 + s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev) 1714 1712 } 1715 1713 1716 1714 func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) { ··· 1807 1805 patch := comparison.FormatPatchRaw 1808 1806 combined := comparison.CombinedPatchRaw 1809 1807 1810 1810 - s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev) 1808 1808 + s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev) 1811 1809 } 1812 1810 1813 1811 func (s *Pulls) resubmitPullHelper( 1814 1812 w http.ResponseWriter, 1815 1813 r *http.Request, 1816 1816 - f *reporesolver.ResolvedRepo, 1814 1814 + repo *models.Repo, 1817 1815 user *oauth.User, 1818 1816 pull *models.Pull, 1819 1817 patch string, ··· 1822 1820 ) { 1823 1821 if pull.IsStacked() { 1824 1822 log.Println("resubmitting stacked PR") 1825 1825 - s.resubmitStackedPullHelper(w, r, f, user, pull, patch, pull.StackId) 1823 1823 + s.resubmitStackedPullHelper(w, r, repo, user, pull, patch, pull.StackId) 1826 1824 return 1827 1825 } 1828 1826 ··· 1902 1900 Val: &tangled.RepoPull{ 1903 1901 Title: pull.Title, 1904 1902 Target: &tangled.RepoPull_Target{ 1905 1905 - Repo: string(f.RepoAt()), 1903 1903 + Repo: string(repo.RepoAt()), 1906 1904 Branch: pull.TargetBranch, 1907 1905 }, 1908 1906 Patch: patch, // new patch ··· 1923 1921 return 1924 1922 } 1925 1923 1926 1926 - ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo) 1924 1924 + ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo) 1927 1925 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId)) 1928 1926 } 1929 1927 1930 1928 func (s *Pulls) resubmitStackedPullHelper( 1931 1929 w http.ResponseWriter, 1932 1930 r *http.Request, 1933 1933 - f *reporesolver.ResolvedRepo, 1931 1931 + repo *models.Repo, 1934 1932 user *oauth.User, 1935 1933 pull *models.Pull, 1936 1934 patch string, ··· 1939 1937 targetBranch := pull.TargetBranch 1940 1938 1941 1939 origStack, _ := r.Context().Value("stack").(models.Stack) 1942 1942 - newStack, err := newStack(f, user, targetBranch, patch, pull.PullSource, stackId) 1940 1940 + newStack, err := newStack(repo, user, targetBranch, patch, pull.PullSource, stackId) 1943 1941 if err != nil { 1944 1942 log.Println("failed to create resubmitted stack", err) 1945 1943 s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.") ··· 2117 2115 return 2118 2116 } 2119 2117 2120 2120 - ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo) 2118 2118 + ownerSlashRepo := reporesolver.GetBaseRepoPath(r, repo) 2121 2119 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId)) 2122 2120 } 2123 2121 ··· 2387 2385 s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId)) 2388 2386 } 2389 2387 2390 2390 - func newStack(f *reporesolver.ResolvedRepo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) { 2388 2388 + func newStack(repo *models.Repo, user *oauth.User, targetBranch, patch string, pullSource *models.PullSource, stackId string) (models.Stack, error) { 2391 2389 formatPatches, err := patchutil.ExtractPatches(patch) 2392 2390 if err != nil { 2393 2391 return nil, fmt.Errorf("Failed to extract patches: %v", err) ··· 2422 2420 Body: body, 2423 2421 TargetBranch: targetBranch, 2424 2422 OwnerDid: user.Did, 2425 2425 - RepoAt: f.RepoAt(), 2423 2423 + RepoAt: repo.RepoAt(), 2426 2424 Rkey: rkey, 2427 2425 Submissions: []*models.PullSubmission{ 2428 2426 &initialSubmission,

+3 -4

appview/repo/artifact.go

··· 14 14 "tangled.org/core/appview/db" 15 15 "tangled.org/core/appview/models" 16 16 "tangled.org/core/appview/pages" 17 17 - "tangled.org/core/appview/reporesolver" 18 17 "tangled.org/core/appview/xrpcclient" 19 18 "tangled.org/core/tid" 20 19 "tangled.org/core/types" ··· 39 38 return 40 39 } 41 40 42 42 - tag, err := rp.resolveTag(r.Context(), f, tagParam) 41 41 + tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam) 43 42 if err != nil { 44 43 log.Println("failed to resolve tag", err) 45 44 rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution") ··· 147 146 tagParam := chi.URLParam(r, "tag") 148 147 filename := chi.URLParam(r, "file") 149 148 150 150 - tag, err := rp.resolveTag(r.Context(), f, tagParam) 149 149 + tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam) 151 150 if err != nil { 152 151 log.Println("failed to resolve tag", err) 153 152 rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution") ··· 297 296 w.Write([]byte{}) 298 297 } 299 298 300 300 - func (rp *Repo) resolveTag(ctx context.Context, f *reporesolver.ResolvedRepo, tagParam string) (*types.TagReference, error) { 299 299 + func (rp *Repo) resolveTag(ctx context.Context, f *models.Repo, tagParam string) (*types.TagReference, error) { 301 300 tagParam, err := url.QueryUnescape(tagParam) 302 301 if err != nil { 303 302 return nil, err

+6 -6

appview/repo/blob.go

··· 74 74 } 75 75 76 76 // Create the blob view 77 77 - blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query()) 77 77 + blobView := NewBlobView(resp, rp.config, &f.Repo, ref, filePath, r.URL.Query()) 78 78 79 79 user := rp.oauth.GetUser(r) 80 80 ··· 178 178 } 179 179 180 180 // NewBlobView creates a BlobView from the XRPC response 181 181 - func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, f *reporesolver.ResolvedRepo, ref, filePath string, queryParams url.Values) models.BlobView { 181 181 + func NewBlobView(resp *tangled.RepoBlob_Output, config *config.Config, repo *models.Repo, ref, filePath string, queryParams url.Values) models.BlobView { 182 182 view := models.BlobView{ 183 183 Contents: "", 184 184 Lines: 0, ··· 200 200 201 201 // Determine if binary 202 202 if resp.IsBinary != nil && *resp.IsBinary { 203 203 - view.ContentSrc = generateBlobURL(config, f, ref, filePath) 203 203 + view.ContentSrc = generateBlobURL(config, repo, ref, filePath) 204 204 ext := strings.ToLower(filepath.Ext(resp.Path)) 205 205 206 206 switch ext { ··· 252 252 return view 253 253 } 254 254 255 255 - func generateBlobURL(config *config.Config, f *reporesolver.ResolvedRepo, ref, filePath string) string { 255 255 + func generateBlobURL(config *config.Config, repo *models.Repo, ref, filePath string) string { 256 256 scheme := "http" 257 257 if !config.Core.Dev { 258 258 scheme = "https" 259 259 } 260 260 261 261 - repoName := fmt.Sprintf("%s/%s", f.Did, f.Name) 261 261 + repoName := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 262 262 baseURL := &url.URL{ 263 263 Scheme: scheme, 264 264 - Host: f.Knot, 264 264 + Host: repo.Knot, 265 265 Path: "/xrpc/sh.tangled.repo.blob", 266 266 } 267 267 query := baseURL.Query()

+14 -15

appview/repo/index.go

··· 22 22 "tangled.org/core/appview/db" 23 23 "tangled.org/core/appview/models" 24 24 "tangled.org/core/appview/pages" 25 25 - "tangled.org/core/appview/reporesolver" 26 25 "tangled.org/core/appview/xrpcclient" 27 26 "tangled.org/core/types" 28 27 ··· 54 53 user := rp.oauth.GetUser(r) 55 54 56 55 // Build index response from multiple XRPC calls 57 57 - result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref) 56 56 + result, err := rp.buildIndexResponse(r.Context(), xrpcc, &f.Repo, ref) 58 57 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 59 58 if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) { 60 59 l.Error("failed to call XRPC repo.index", "err", err) ··· 129 128 } 130 129 131 130 // TODO: a bit dirty 132 132 - languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "") 131 131 + languageInfo, err := rp.getLanguageInfo(r.Context(), l, &f.Repo, xrpcc, result.Ref, ref == "") 133 132 if err != nil { 134 133 l.Warn("failed to compute language percentages", "err", err) 135 134 // non-fatal ··· 164 163 func (rp *Repo) getLanguageInfo( 165 164 ctx context.Context, 166 165 l *slog.Logger, 167 167 - f *reporesolver.ResolvedRepo, 166 166 + repo *models.Repo, 168 167 xrpcc *indigoxrpc.Client, 169 168 currentRef string, 170 169 isDefaultRef bool, ··· 172 171 // first attempt to fetch from db 173 172 langs, err := db.GetRepoLanguages( 174 173 rp.db, 175 175 - db.FilterEq("repo_at", f.RepoAt()), 174 174 + db.FilterEq("repo_at", repo.RepoAt()), 176 175 db.FilterEq("ref", currentRef), 177 176 ) 178 177 179 178 if err != nil || langs == nil { 180 179 // non-fatal, fetch langs from ks via XRPC 181 181 - repo := fmt.Sprintf("%s/%s", f.Did, f.Name) 182 182 - ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo) 180 180 + didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 181 181 + ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, didSlashRepo) 183 182 if err != nil { 184 183 if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil { 185 184 l.Error("failed to call XRPC repo.languages", "err", xrpcerr) ··· 194 193 195 194 for _, lang := range ls.Languages { 196 195 langs = append(langs, models.RepoLanguage{ 197 197 - RepoAt: f.RepoAt(), 196 196 + RepoAt: repo.RepoAt(), 198 197 Ref: currentRef, 199 198 IsDefaultRef: isDefaultRef, 200 199 Language: lang.Name, ··· 209 208 defer tx.Rollback() 210 209 211 210 // update appview's cache 212 212 - err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs) 211 211 + err = db.UpdateRepoLanguages(tx, repo.RepoAt(), currentRef, langs) 213 212 if err != nil { 214 213 // non-fatal 215 214 l.Error("failed to cache lang results", "err", err) ··· 254 253 } 255 254 256 255 // buildIndexResponse creates a RepoIndexResponse by combining multiple xrpc calls in parallel 257 257 - func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, f *reporesolver.ResolvedRepo, ref string) (*types.RepoIndexResponse, error) { 258 258 - repo := fmt.Sprintf("%s/%s", f.Did, f.Name) 256 256 + func (rp *Repo) buildIndexResponse(ctx context.Context, xrpcc *indigoxrpc.Client, repo *models.Repo, ref string) (*types.RepoIndexResponse, error) { 257 257 + didSlashRepo := fmt.Sprintf("%s/%s", repo.Did, repo.Name) 259 258 260 259 // first get branches to determine the ref if not specified 261 261 - branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, repo) 260 260 + branchesBytes, err := tangled.RepoBranches(ctx, xrpcc, "", 0, didSlashRepo) 262 261 if err != nil { 263 262 return nil, fmt.Errorf("failed to call repoBranches: %w", err) 264 263 } ··· 302 301 wg.Add(1) 303 302 go func() { 304 303 defer wg.Done() 305 305 - tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, repo) 304 304 + tagsBytes, err := tangled.RepoTags(ctx, xrpcc, "", 0, didSlashRepo) 306 305 if err != nil { 307 306 errs = errors.Join(errs, fmt.Errorf("failed to call repoTags: %w", err)) 308 307 return ··· 317 316 wg.Add(1) 318 317 go func() { 319 318 defer wg.Done() 320 320 - resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, repo) 319 319 + resp, err := tangled.RepoTree(ctx, xrpcc, "", ref, didSlashRepo) 321 320 if err != nil { 322 321 errs = errors.Join(errs, fmt.Errorf("failed to call repoTree: %w", err)) 323 322 return ··· 329 328 wg.Add(1) 330 329 go func() { 331 330 defer wg.Done() 332 332 - logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, repo) 331 331 + logBytes, err := tangled.RepoLog(ctx, xrpcc, "", 50, "", ref, didSlashRepo) 333 332 if err != nil { 334 333 errs = errors.Join(errs, fmt.Errorf("failed to call repoLog: %w", err)) 335 334 return