appview: use less `RepoInfo` for `ResolvedRepo`

`RepoInfo` is mostly designed for rendering, don't use it for service
logic.

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

appview/issues/issues.go

···
 	l := rp.logger.With("handler", "DeleteIssue")
 	noticeId := "issue-actions-error"
 
-	user := rp.oauth.GetUser(r)
-
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 	rp.notifier.DeleteIssue(r.Context(), issue)
 
 	// return to all issues page
-	rp.pages.HxRedirect(w, "/"+f.RepoInfo(user).FullName()+"/issues")
+	ownerSlashRepo := reporesolver.GetBaseRepoPath(r, &f.Repo)
+	rp.pages.HxRedirect(w, "/"+ownerSlashRepo+"/issues")
 }
 
 func (rp *Issues) CloseIssue(w http.ResponseWriter, r *http.Request) {

appview/pipelines/pipelines.go

···
 		return
 	}
 
-	repoInfo := f.RepoInfo(user)
-
 	ps, err := db.GetPipelineStatuses(
 		p.db,
 		30,
-		db.FilterEq("repo_owner", repoInfo.OwnerDid),
-		db.FilterEq("repo_name", repoInfo.Name),
-		db.FilterEq("knot", repoInfo.Knot),
+		db.FilterEq("repo_owner", f.Did),
+		db.FilterEq("repo_name", f.Name),
+		db.FilterEq("knot", f.Knot),
 	)
 	if err != nil {
 		l.Error("failed to query db", "err", err)
···
 
 	p.pages.Pipelines(w, pages.PipelinesParams{
 		LoggedInUser: user,
-		RepoInfo:     repoInfo,
+		RepoInfo:     f.RepoInfo(user),
 		Pipelines:    ps,
 	})
 }
···
 		return
 	}
 
-	repoInfo := f.RepoInfo(user)
-
 	pipelineId := chi.URLParam(r, "pipeline")
 	if pipelineId == "" {
 		l.Error("empty pipeline ID")
···
 	ps, err := db.GetPipelineStatuses(
 		p.db,
 		1,
-		db.FilterEq("repo_owner", repoInfo.OwnerDid),
-		db.FilterEq("repo_name", repoInfo.Name),
-		db.FilterEq("knot", repoInfo.Knot),
+		db.FilterEq("repo_owner", f.Did),
+		db.FilterEq("repo_name", f.Name),
+		db.FilterEq("knot", f.Knot),
 		db.FilterEq("id", pipelineId),
 	)
 	if err != nil {
···
 
 	p.pages.Workflow(w, pages.WorkflowParams{
 		LoggedInUser: user,
-		RepoInfo:     repoInfo,
+		RepoInfo:     f.RepoInfo(user),
 		Pipeline:     singlePipeline,
 		Workflow:     workflow,
 	})
···
 	ctx, cancel := context.WithCancel(r.Context())
 	defer cancel()
 
-	user := p.oauth.GetUser(r)
 	f, err := p.repoResolver.Resolve(r)
 	if err != nil {
 		l.Error("failed to get repo and knot", "err", err)
···
 		return
 	}
 
-	repoInfo := f.RepoInfo(user)
-
 	pipelineId := chi.URLParam(r, "pipeline")
 	workflow := chi.URLParam(r, "workflow")
 	if pipelineId == "" || workflow == "" {
···
 	ps, err := db.GetPipelineStatuses(
 		p.db,
 		1,
-		db.FilterEq("repo_owner", repoInfo.OwnerDid),
-		db.FilterEq("repo_name", repoInfo.Name),
-		db.FilterEq("knot", repoInfo.Knot),
+		db.FilterEq("repo_owner", f.Did),
+		db.FilterEq("repo_name", f.Name),
+		db.FilterEq("knot", f.Knot),
 		db.FilterEq("id", pipelineId),
 	)
 	if err != nil || len(ps) != 1 {
···
 	}
 
 	singlePipeline := ps[0]
-	spindle := repoInfo.Spindle
-	knot := repoInfo.Knot
+	spindle := f.Spindle
+	knot := f.Knot
 	rkey := singlePipeline.Rkey
 
 	if spindle == "" || knot == "" || rkey == "" {

appview/pulls/pulls.go

···
 		resubmitResult = s.resubmitCheck(r, f, pull, stack)
 	}
 
-	repoInfo := f.RepoInfo(user)
-
 	m := make(map[string]models.Pipeline)
 
 	var shas []string
···
 	ps, err := db.GetPipelineStatuses(
 		s.db,
 		len(shas),
-		db.FilterEq("repo_owner", repoInfo.OwnerDid),
-		db.FilterEq("repo_name", repoInfo.Name),
-		db.FilterEq("knot", repoInfo.Knot),
+		db.FilterEq("repo_owner", f.Did),
+		db.FilterEq("repo_name", f.Name),
+		db.FilterEq("knot", f.Knot),
 		db.FilterIn("sha", shas),
 	)
 	if err != nil {
···
 
 	s.pages.RepoSinglePull(w, pages.RepoSinglePullParams{
 		LoggedInUser:       user,
-		RepoInfo:           repoInfo,
+		RepoInfo:           f.RepoInfo(user),
 		Pull:               pull,
 		Stack:              stack,
 		AbandonedPulls:     abandonedPulls,
···
 	}
 	pulls = pulls[:n]
 
-	repoInfo := f.RepoInfo(user)
 	ps, err := db.GetPipelineStatuses(
 		s.db,
 		len(shas),
-		db.FilterEq("repo_owner", repoInfo.OwnerDid),
-		db.FilterEq("repo_name", repoInfo.Name),
-		db.FilterEq("knot", repoInfo.Knot),
+		db.FilterEq("repo_owner", f.Did),
+		db.FilterEq("repo_name", f.Name),
+		db.FilterEq("knot", f.Knot),
 		db.FilterIn("sha", shas),
 	)
 	if err != nil {

appview/repo/compare.go

···
 		return
 	}
 
-	repoinfo := f.RepoInfo(user)
-
 	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{
 		LoggedInUser: user,
-		RepoInfo:     repoinfo,
+		RepoInfo:     f.RepoInfo(user),
 		Branches:     branches,
 		Tags:         tags.Tags,
 		Base:         base,
···
 		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)
 	}
 
-	repoinfo := f.RepoInfo(user)
-
 	rp.pages.RepoCompare(w, pages.RepoCompareParams{
 		LoggedInUser: user,
-		RepoInfo:     repoinfo,
+		RepoInfo:     f.RepoInfo(user),
 		Branches:     branches.Branches,
 		Tags:         tags.Tags,
 		Base:         base,

appview/repo/index.go

···
 	}
 
 	user := rp.oauth.GetUser(r)
-	repoInfo := f.RepoInfo(user)
 
 	// Build index response from multiple XRPC calls
 	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)
···
 			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
 				LoggedInUser:     user,
 				NeedsKnotUpgrade: true,
-				RepoInfo:         repoInfo,
+				RepoInfo:         f.RepoInfo(user),
 			})
 			return
 		}
···
 	for _, c := range commitsTrunc {
 		shas = append(shas, c.Hash.String())
 	}
-	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)
+	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
 	if err != nil {
 		l.Error("failed to fetch pipeline statuses", "err", err)
 		// non-fatal
···
 
 	rp.pages.RepoIndexPage(w, pages.RepoIndexParams{
 		LoggedInUser:      user,
-		RepoInfo:          repoInfo,
+		RepoInfo:          f.RepoInfo(user),
 		TagMap:            tagMap,
 		RepoIndexResponse: *result,
 		CommitsTrunc:      commitsTrunc,

appview/repo/log.go

···
 		l.Error("failed to GetVerifiedObjectCommits", "err", err)
 	}
 
-	repoInfo := f.RepoInfo(user)
-
 	var shas []string
 	for _, c := range xrpcResp.Commits {
 		shas = append(shas, c.Hash.String())
 	}
-	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)
+	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, shas)
 	if err != nil {
 		l.Error("failed to getPipelineStatuses", "err", err)
 		// non-fatal
···
 	rp.pages.RepoLog(w, pages.RepoLogParams{
 		LoggedInUser:    user,
 		TagMap:          tagMap,
-		RepoInfo:        repoInfo,
+		RepoInfo:        f.RepoInfo(user),
 		RepoLogResponse: xrpcResp,
 		EmailToDid:      emailToDidMap,
 		VerifiedCommits: vc,
···
 	}
 
 	user := rp.oauth.GetUser(r)
-	repoInfo := f.RepoInfo(user)
-	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})
+	pipelines, err := getPipelineStatuses(rp.db, &f.Repo, []string{result.Diff.Commit.This})
 	if err != nil {
 		l.Error("failed to getPipelineStatuses", "err", err)
 		// non-fatal

appview/repo/repo.go

···
 			return
 		}
 
-		repoInfo := f.RepoInfo(user)
-		if repoInfo.Source == nil {
+		if f.Source == "" {
 			rp.pages.Notice(w, "repo", "This repository is not a fork.")
 			return
 		}
···
 			&tangled.RepoForkSync_Input{
 				Did:    user.Did,
 				Name:   f.Name,
-				Source: repoInfo.Source.RepoAt().String(),
+				Source: f.Source,
 				Branch: ref,
 			},
 		)

appview/repo/repo_util.go

···
 
 	"tangled.org/core/appview/db"
 	"tangled.org/core/appview/models"
-	"tangled.org/core/appview/pages/repoinfo"
 	"tangled.org/core/types"
 
 	"github.com/go-git/go-git/v5/plumbing/object"
···
 // golang is so blessed that it requires 35 lines of imperative code for this
 func getPipelineStatuses(
 	d *db.DB,
-	repoInfo repoinfo.RepoInfo,
+	repo *models.Repo,
 	shas []string,
 ) (map[string]models.Pipeline, error) {
 	m := make(map[string]models.Pipeline)
···
 	ps, err := db.GetPipelineStatuses(
 		d,
 		len(shas),
-		db.FilterEq("repo_owner", repoInfo.OwnerDid),
-		db.FilterEq("repo_name", repoInfo.Name),
-		db.FilterEq("knot", repoInfo.Knot),
+		db.FilterEq("repo_owner", repo.Did),
+		db.FilterEq("repo_name", repo.Name),
+		db.FilterEq("knot", repo.Knot),
 		db.FilterIn("sha", shas),
 	)
 	if err != nil {