appview: remove `ResolvedRepo` for eternity

Signed-off-by: Seongmin Lee <[e-mail]>

appview/issues/issues.go

···
 
 	labelDefs, err := db.GetLabelDefinitions(
 		rp.db,
-		db.FilterIn("at_uri", f.Repo.Labels),
+		db.FilterIn("at_uri", f.Labels),
 		db.FilterContains("scope", tangled.RepoIssueNSID),
 	)
 	if err != nil {
···
 	rp.notifier.DeleteIssue(r.Context(), issue)
 
 	// return to all issues page
-	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 	rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")
 }
 
···
 		// notify about the issue closure
 		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
 
-		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
 		return
 	} else {
···
 		// notify about the issue reopen
 		rp.notifier.NewIssueState(r.Context(), syntax.DID(user.Did), issue)
 
-		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
 		return
 	} else {
···
 	}
 	rp.notifier.NewIssueComment(r.Context(), &comment, mentions)
 
-	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 	rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d#comment-%d", ownerSlashRepo, issue.IssueId, commentId))
 }
 
···
 
 	labelDefs, err := db.GetLabelDefinitions(
 		rp.db,
-		db.FilterIn("at_uri", f.Repo.Labels),
+		db.FilterIn("at_uri", f.Labels),
 		db.FilterContains("scope", tangled.RepoIssueNSID),
 	)
 	if err != nil {
···
 			Open:    true,
 			Did:     user.Did,
 			Created: time.Now(),
-			Repo:    &f.Repo,
+			Repo:    f,
 		}
 
 		if err := rp.validator.ValidateIssue(issue); err != nil {
···
 		}
 		rp.notifier.NewIssue(r.Context(), issue, mentions)
 
-		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", ownerSlashRepo, issue.IssueId))
 		return
 	}

appview/issues/opengraph.go

···
 
 	// Get owner handle for avatar
 	var ownerHandle string
-	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Repo.Did)
+	owner, err := rp.idResolver.ResolveIdent(r.Context(), f.Did)
 	if err != nil {
-		ownerHandle = f.Repo.Did
+		ownerHandle = f.Did
 	} else {
 		ownerHandle = "@" + owner.Handle.String()
 	}
 
-	card, err := rp.drawIssueSummaryCard(issue, &f.Repo, commentCount, ownerHandle)
+	card, err := rp.drawIssueSummaryCard(issue, f, commentCount, ownerHandle)
 	if err != nil {
 		log.Println("failed to draw issue summary card", err)
 		http.Error(w, "failed to draw issue summary card", http.StatusInternalServerError)

appview/middleware/middleware.go

···
 				return
 			}
 
-			fullName := reporesolver.GetBaseRepoPath(r, &f.Repo)
+			fullName := reporesolver.GetBaseRepoPath(r, f)
 
 			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
 				if r.URL.Query().Get("go-get") == "1" {

appview/pulls/opengraph.go

···
 		filesChanged = niceDiff.Stat.FilesChanged
 	}
 
-	card, err := s.drawPullSummaryCard(pull, &f.Repo, commentCount, diffStats, filesChanged)
+	card, err := s.drawPullSummaryCard(pull, f, commentCount, diffStats, filesChanged)
 	if err != nil {
 		log.Println("failed to draw pull summary card", err)
 		http.Error(w, "failed to draw pull summary card", http.StatusInternalServerError)

appview/pulls/pulls.go

···
 			return
 		}
 
-		mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)
-		branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)
+		mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
+		branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
 		resubmitResult := pages.Unknown
 		if user.Did == pull.OwnerDid {
-			resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)
+			resubmitResult = s.resubmitCheck(r, f, pull, stack)
 		}
 
 		s.pages.PullActionsFragment(w, pages.PullActionsParams{
···
 	stack, _ := r.Context().Value("stack").(models.Stack)
 	abandonedPulls, _ := r.Context().Value("abandonedPulls").([]*models.Pull)
 
-	mergeCheckResponse := s.mergeCheck(r, &f.Repo, pull, stack)
-	branchDeleteStatus := s.branchDeleteStatus(r, &f.Repo, pull)
+	mergeCheckResponse := s.mergeCheck(r, f, pull, stack)
+	branchDeleteStatus := s.branchDeleteStatus(r, f, pull)
 	resubmitResult := pages.Unknown
 	if user != nil && user.Did == pull.OwnerDid {
-		resubmitResult = s.resubmitCheck(r, &f.Repo, pull, stack)
+		resubmitResult = s.resubmitCheck(r, f, pull, stack)
 	}
 
 	m := make(map[string]models.Pipeline)
···
 
 	labelDefs, err := db.GetLabelDefinitions(
 		s.db,
-		db.FilterIn("at_uri", f.Repo.Labels),
+		db.FilterIn("at_uri", f.Labels),
 		db.FilterContains("scope", tangled.RepoPullNSID),
 	)
 	if err != nil {
···
 
 	labelDefs, err := db.GetLabelDefinitions(
 		s.db,
-		db.FilterIn("at_uri", f.Repo.Labels),
+		db.FilterIn("at_uri", f.Labels),
 		db.FilterContains("scope", tangled.RepoPullNSID),
 	)
 	if err != nil {
···
 		}
 		s.notifier.NewPullComment(r.Context(), comment, mentions)
 
-		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+		ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 		s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d#comment-%d", ownerSlashRepo, pull.PullId, commentId))
 		return
 	}
···
 				s.pages.Notice(w, "pull", "This knot doesn't support branch-based pull requests. Try another way?")
 				return
 			}
-			s.handleBranchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, sourceBranch, isStacked)
+			s.handleBranchBasedPull(w, r, f, user, title, body, targetBranch, sourceBranch, isStacked)
 		} else if isForkBased {
 			if !caps.PullRequests.ForkSubmissions {
 				s.pages.Notice(w, "pull", "This knot doesn't support fork-based pull requests. Try another way?")
 				return
 			}
-			s.handleForkBasedPull(w, r, &f.Repo, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
+			s.handleForkBasedPull(w, r, f, user, fromFork, title, body, targetBranch, sourceBranch, isStacked)
 		} else if isPatchBased {
 			if !caps.PullRequests.PatchSubmissions {
 				s.pages.Notice(w, "pull", "This knot doesn't support patch-based pull requests. Send your patch over email.")
 				return
 			}
-			s.handlePatchBasedPull(w, r, &f.Repo, user, title, body, targetBranch, patch, isStacked)
+			s.handlePatchBasedPull(w, r, f, user, title, body, targetBranch, patch, isStacked)
 		}
 		return
 	}
···
 
 	patch := r.FormValue("patch")
 
-	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, "", "")
+	s.resubmitPullHelper(w, r, f, user, pull, patch, "", "")
 }
 
 func (s *Pulls) resubmitBranch(w http.ResponseWriter, r *http.Request) {
···
 	patch := comparison.FormatPatchRaw
 	combined := comparison.CombinedPatchRaw
 
-	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)
+	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
 }
 
 func (s *Pulls) resubmitFork(w http.ResponseWriter, r *http.Request) {
···
 	patch := comparison.FormatPatchRaw
 	combined := comparison.CombinedPatchRaw
 
-	s.resubmitPullHelper(w, r, &f.Repo, user, pull, patch, combined, sourceRev)
+	s.resubmitPullHelper(w, r, f, user, pull, patch, combined, sourceRev)
 }
 
 func (s *Pulls) resubmitPullHelper(
···
 		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
 	}
 
-	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
 }
 
···
 		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
 	}
 
-	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
 }
 
···
 		s.notifier.NewPullState(r.Context(), syntax.DID(user.Did), p)
 	}
 
-	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 	s.pages.HxLocation(w, fmt.Sprintf("/%s/pulls/%d", ownerSlashRepo, pull.PullId))
 }
 

appview/repo/artifact.go

···
 		return
 	}
 
-	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)
+	tag, err := rp.resolveTag(r.Context(), f, tagParam)
 	if err != nil {
 		log.Println("failed to resolve tag", err)
 		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")
···
 	tagParam := chi.URLParam(r, "tag")
 	filename := chi.URLParam(r, "file")
 
-	tag, err := rp.resolveTag(r.Context(), &f.Repo, tagParam)
+	tag, err := rp.resolveTag(r.Context(), f, tagParam)
 	if err != nil {
 		log.Println("failed to resolve tag", err)
 		rp.pages.Notice(w, "upload", "failed to upload artifact, error in tag resolution")

appview/repo/blob.go

···
 	xrpcc := &indigoxrpc.Client{
 		Host: host,
 	}
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)
+	repo := fmt.Sprintf("%s/%s", f.Did, f.Name)
 	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)
···
 		return
 	}
 
-	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 
 	// Use XRPC response directly instead of converting to internal types
 	var breadcrumbs [][]string
···
 	}
 
 	// Create the blob view
-	blobView := NewBlobView(resp, rp.config, &f.Repo, ref, filePath, r.URL.Query())
+	blobView := NewBlobView(resp, rp.config, f, ref, filePath, r.URL.Query())
 
 	user := rp.oauth.GetUser(r)
 
···
 	if !rp.config.Core.Dev {
 		scheme = "https"
 	}
-	repo := fmt.Sprintf("%s/%s", f.Did, f.Repo.Name)
+	repo := f.DidSlashRepo()
 	baseURL := &url.URL{
 		Scheme: scheme,
 		Host:   f.Knot,

appview/repo/feed.go

···
 	}
 	ownerSlashRepo := repoOwnerId.Handle.String() + "/" + f.Name
 
-	feed, err := rp.getRepoFeed(r.Context(), &f.Repo, ownerSlashRepo)
+	feed, err := rp.getRepoFeed(r.Context(), f, ownerSlashRepo)
 	if err != nil {
 		log.Println("failed to get repo feed:", err)
 		rp.pages.Error500(w)

appview/repo/index.go

···
 	user := rp.oauth.GetUser(r)
 
 	// Build index response from multiple XRPC calls
-	result, err := rp.buildIndexResponse(r.Context(), xrpcc, &f.Repo, ref)
+	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
 	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {
 		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {
 			l.Error("failed to call XRPC repo.index", "err", err)
···
 	}
 
 	// TODO: a bit dirty
-	languageInfo, err := rp.getLanguageInfo(r.Context(), l, &f.Repo, xrpcc, result.Ref, ref == "")
+	languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")
 	if err != nil {
 		l.Warn("failed to compute language percentages", "err", err)
 		// non-fatal
···
 	for _, c := range commitsTrunc {
 		shas = append(shas, c.Hash.String())
 	}
-	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
+	pipelines, err := getPipelineStatuses(rp.db, f, shas)
 	if err != nil {
 		l.Error("failed to fetch pipeline statuses", "err", err)
 		// non-fatal

appview/repo/log.go

···
 	for _, c := range xrpcResp.Commits {
 		shas = append(shas, c.Hash.String())
 	}
-	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
+	pipelines, err := getPipelineStatuses(rp.db, f, shas)
 	if err != nil {
 		l.Error("failed to getPipelineStatuses", "err", err)
 		// non-fatal
···
 	}
 
 	user := rp.oauth.GetUser(r)
-	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, []string{result.Diff.Commit.This})
+	pipelines, err := getPipelineStatuses(rp.db, f, []string{result.Diff.Commit.This})
 	if err != nil {
 		l.Error("failed to getPipelineStatuses", "err", err)
 		// non-fatal

appview/repo/opengraph.go

···
 		})
 	}
 
-	card, err := rp.drawRepoSummaryCard(&f.Repo, languageStats)
+	card, err := rp.drawRepoSummaryCard(f, languageStats)
 	if err != nil {
 		log.Println("failed to draw repo summary card", err)
 		http.Error(w, "failed to draw repo summary card", http.StatusInternalServerError)

appview/repo/repo.go

···
 		}
 	}
 
-	newRepo := f.Repo
+	newRepo := *f
 	newRepo.Spindle = newSpindle
 	record := newRepo.AsRecord()
 
···
 	l.Info("wrote label record to PDS")
 
 	// update the repo to subscribe to this label
-	newRepo := f.Repo
+	newRepo := *f
 	newRepo.Labels = append(newRepo.Labels, aturi)
 	repoRecord := newRepo.AsRecord()
 
···
 	}
 
 	// update repo record to remove the label reference
-	newRepo := f.Repo
+	newRepo := *f
 	var updated []string
 	removedAt := label.AtUri().String()
 	for _, l := range newRepo.Labels {
···
 		return
 	}
 
-	newRepo := f.Repo
+	newRepo := *f
 	newRepo.Labels = append(newRepo.Labels, labelAts...)
 
 	// dedup
···
 		return
 	}
 
-	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)
+	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)
 	if err != nil {
 		fail("Failed to update labels, no record found on PDS.", err)
 		return
···
 	}
 
 	// update repo record to remove the label reference
-	newRepo := f.Repo
+	newRepo := *f
 	var updated []string
 	for _, l := range newRepo.Labels {
 		if !slices.Contains(labelAts, l) {
···
 		return
 	}
 
-	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Repo.Did, f.Repo.Rkey)
+	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, f.Did, f.Rkey)
 	if err != nil {
 		fail("Failed to update labels, no record found on PDS.", err)
 		return
···
 
 	labelDefs, err := db.GetLabelDefinitions(
 		rp.db,
-		db.FilterIn("at_uri", f.Repo.Labels),
+		db.FilterIn("at_uri", f.Labels),
 		db.FilterContains("scope", subject.Collection().String()),
 	)
 	if err != nil {
···
 
 	labelDefs, err := db.GetLabelDefinitions(
 		rp.db,
-		db.FilterIn("at_uri", f.Repo.Labels),
+		db.FilterIn("at_uri", f.Labels),
 		db.FilterContains("scope", subject.Collection().String()),
 	)
 	if err != nil {
···
 			uri = "http"
 		}
 
-		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Repo.Name)
+		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.Did, f.Name)
 		l = l.With("cloneUrl", forkSourceUrl)
 
 		sourceAt := f.RepoAt().String()
···
 			Knot:        targetKnot,
 			Rkey:        rkey,
 			Source:      sourceAt,
-			Description: f.Repo.Description,
+			Description: f.Description,
 			Created:     time.Now(),
 			Labels:      rp.config.Label.DefaultLabelDefs,
 		}

appview/repo/settings.go

···
 		return
 	}
 
-	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))
+	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Labels))
 	if err != nil {
 		l.Error("failed to fetch labels", "err", err)
 		rp.pages.Error503(w)
···
 	labels = labels[:n]
 
 	subscribedLabels := make(map[string]struct{})
-	for _, l := range f.Repo.Labels {
+	for _, l := range f.Labels {
 		subscribedLabels[l] = struct{}{}
 	}
 
···
 			collaborators = append(collaborators, c)
 		}
 		return collaborators, nil
-	}(&f.Repo)
+	}(f)
 	if err != nil {
 		l.Error("failed to get collaborators", "err", err)
 	}
···
 	}
 	l.Debug("got", "topicsStr", topicStr, "topics", topics)
 
-	newRepo := f.Repo
+	newRepo := *f
 	newRepo.Description = description
 	newRepo.Website = website
 	newRepo.Topics = topics

appview/repo/tree.go

···
 		result.ReadmeFileName = xrpcResp.Readme.Filename
 		result.Readme = xrpcResp.Readme.Contents
 	}
-	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, f)
 	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,
 	// so we can safely redirect to the "parent" (which is the same file).
 	if len(result.Files) == 0 && result.Parent == treePath {

appview/reporesolver/resolver.go

···
 	"tangled.org/core/rbac"
 )
 
-type ResolvedRepo struct {
-	models.Repo
-}
-
 type RepoResolver struct {
 	config   *config.Config
 	enforcer *rbac.Enforcer
···
 }
 
 // TODO: move this out of `RepoResolver` struct
-func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
+func (rr *RepoResolver) Resolve(r *http.Request) (*models.Repo, error) {
 	repo, ok := r.Context().Value("repo").(*models.Repo)
 	if !ok {
 		log.Println("malformed middleware: `repo` not exist in context")
 		return nil, fmt.Errorf("malformed middleware")
 	}
 
-	return &ResolvedRepo{
-		Repo: *repo,
-	}, nil
+	return repo, nil
 }
 
 // 1. [x] replace `RepoInfo` to `reporesolver.GetRepoInfo(r *http.Request, repo, user)`
 // 2. [x] remove `rr`, `CurrentDir`, `Ref` fields from `ResolvedRepo`
-// 3. [ ] remove `ResolvedRepo`
+// 3. [x] remove `ResolvedRepo`
 // 4. [ ] replace reporesolver to reposervice
 func (rr *RepoResolver) GetRepoInfo(r *http.Request, user *oauth.User) repoinfo.RepoInfo {
 	ownerId, ook := r.Context().Value("resolvedId").(identity.Identity)