appview: reporesolver: pass entire `Repo` object through context

There is no reason for `ResolvedRepo` to not directly inherit `Repo`

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

appview/issues/issues.go

···
 		return
 	}
 
-	issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt, issueIdInt)
+	issue, comments, err := db.GetIssueWithComments(rp.db, f.RepoAt(), issueIdInt)
 	if err != nil {
 		log.Println("failed to get issue and comments", err)
 		rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
 		return
 	}
 
-	issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+	issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
 	if err != nil {
 		log.Println("failed to get issue", err)
 		rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
 			return
 		}
 
-		err = db.CloseIssue(rp.db, f.RepoAt, issueIdInt)
+		err = db.CloseIssue(rp.db, f.RepoAt(), issueIdInt)
 		if err != nil {
 			log.Println("failed to close issue", err)
 			rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
 		return
 	}
 
-	issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+	issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
 	if err != nil {
 		log.Println("failed to get issue", err)
 		rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")
···
 	isIssueOwner := user.Did == issue.OwnerDid
 
 	if isCollaborator || isIssueOwner {
-		err := db.ReopenIssue(rp.db, f.RepoAt, issueIdInt)
+		err := db.ReopenIssue(rp.db, f.RepoAt(), issueIdInt)
 		if err != nil {
 			log.Println("failed to reopen issue", err)
 			rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")
···
 
 		err := db.NewIssueComment(rp.db, &db.Comment{
 			OwnerDid:  user.Did,
-			RepoAt:    f.RepoAt,
+			RepoAt:    f.RepoAt(),
 			Issue:     issueIdInt,
 			CommentId: commentId,
 			Body:      body,
···
 		createdAt := time.Now().Format(time.RFC3339)
 		commentIdInt64 := int64(commentId)
 		ownerDid := user.Did
-		issueAt, err := db.GetIssueAt(rp.db, f.RepoAt, issueIdInt)
+		issueAt, err := db.GetIssueAt(rp.db, f.RepoAt(), issueIdInt)
 		if err != nil {
 			log.Println("failed to get issue at", err)
 			rp.pages.Notice(w, "issue-comment", "Failed to create comment.")
 			return
 		}
 
-		atUri := f.RepoAt.String()
+		atUri := f.RepoAt().String()
 		client, err := rp.oauth.AuthorizedClient(r)
 		if err != nil {
 			log.Println("failed to get authorized client", err)
···
 		return
 	}
 
-	issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+	issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
 	if err != nil {
 		log.Println("failed to get issue", err)
 		rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
 		return
 	}
 
-	comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+	comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
 	if err != nil {
 		http.Error(w, "bad comment id", http.StatusBadRequest)
 		return
···
 		return
 	}
 
-	issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+	issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
 	if err != nil {
 		log.Println("failed to get issue", err)
 		rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
 		return
 	}
 
-	comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+	comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
 	if err != nil {
 		http.Error(w, "bad comment id", http.StatusBadRequest)
 		return
···
 		return
 	}
 
-	issue, err := db.GetIssue(rp.db, f.RepoAt, issueIdInt)
+	issue, err := db.GetIssue(rp.db, f.RepoAt(), issueIdInt)
 	if err != nil {
 		log.Println("failed to get issue", err)
 		rp.pages.Notice(w, "issues", "Failed to load issue. Try again later.")
···
 		return
 	}
 
-	comment, err := db.GetComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+	comment, err := db.GetComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
 	if err != nil {
 		http.Error(w, "bad comment id", http.StatusBadRequest)
 		return
···
 
 	// optimistic deletion
 	deleted := time.Now()
-	err = db.DeleteComment(rp.db, f.RepoAt, issueIdInt, commentIdInt)
+	err = db.DeleteComment(rp.db, f.RepoAt(), issueIdInt, commentIdInt)
 	if err != nil {
 		log.Println("failed to delete comment")
 		rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "failed to delete comment")
···
 		return
 	}
 
-	issues, err := db.GetIssues(rp.db, f.RepoAt, isOpen, page)
+	issues, err := db.GetIssues(rp.db, f.RepoAt(), isOpen, page)
 	if err != nil {
 		log.Println("failed to get issues", err)
 		rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")
···
 		}
 
 		issue := &db.Issue{
-			RepoAt:   f.RepoAt,
+			RepoAt:   f.RepoAt(),
 			Rkey:     tid.TID(),
 			Title:    title,
 			Body:     body,
···
 			rp.pages.Notice(w, "issues", "Failed to create issue.")
 			return
 		}
-		atUri := f.RepoAt.String()
+		atUri := f.RepoAt().String()
 		_, err = client.RepoPutRecord(r.Context(), &comatproto.RepoPutRecord_Input{
 			Collection: tangled.RepoIssueNSID,
 			Repo:       user.Did,

appview/middleware/middleware.go

···
 	"slices"
 	"strconv"
 	"strings"
-	"time"
 
 	"github.com/bluesky-social/indigo/atproto/identity"
 	"github.com/go-chi/chi/v5"
···
 				return
 			}
 
-			ctx := context.WithValue(req.Context(), "knot", repo.Knot)
-			ctx = context.WithValue(ctx, "repoAt", repo.AtUri)
-			ctx = context.WithValue(ctx, "repoDescription", repo.Description)
-			ctx = context.WithValue(ctx, "repoSpindle", repo.Spindle)
-			ctx = context.WithValue(ctx, "repoAddedAt", repo.Created.Format(time.RFC3339))
+			ctx := context.WithValue(req.Context(), "repo", repo)
 			next.ServeHTTP(w, req.WithContext(ctx))
 		})
 	}
···
 				return
 			}
 
-			pr, err := db.GetPull(mw.db, f.RepoAt, prIdInt)
+			pr, err := db.GetPull(mw.db, f.RepoAt(), prIdInt)
 			if err != nil {
 				log.Println("failed to get pull and comments", err)
 				return
···
 				return
 			}
 
-			fullName := f.OwnerHandle() + "/" + f.RepoName
+			fullName := f.OwnerHandle() + "/" + f.Name
 
 			if r.Header.Get("User-Agent") == "Go-http-client/1.1" {
 				if r.URL.Query().Get("go-get") == "1" {

appview/pulls/pulls.go

···
 		patch = mergeable.CombinedPatch()
 	}
 
-	resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch)
+	resp, err := ksClient.MergeCheck([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch)
 	if err != nil {
 		log.Println("failed to check for mergeability:", err)
 		return types.MergeCheckResponse{
···
 		// pulls within the same repo
 		knot = f.Knot
 		ownerDid = f.OwnerDid()
-		repoName = f.RepoName
+		repoName = f.Name
 	}
 
 	us, err := knotclient.NewUnsignedClient(knot, s.config.Core.Dev)
···
 
 	pulls, err := db.GetPulls(
 		s.db,
-		db.FilterEq("repo_at", f.RepoAt),
+		db.FilterEq("repo_at", f.RepoAt()),
 		db.FilterEq("state", state),
 	)
 	if err != nil {
···
 		createdAt := time.Now().Format(time.RFC3339)
 		ownerDid := user.Did
 
-		pullAt, err := db.GetPullAt(s.db, f.RepoAt, pull.PullId)
+		pullAt, err := db.GetPullAt(s.db, f.RepoAt(), pull.PullId)
 		if err != nil {
 			log.Println("failed to get pull at", err)
 			s.pages.Notice(w, "pull-comment", "Failed to create comment.")
 			return
 		}
 
-		atUri := f.RepoAt.String()
+		atUri := f.RepoAt().String()
 		client, err := s.oauth.AuthorizedClient(r)
 		if err != nil {
 			log.Println("failed to get authorized client", err)
···
 
 		comment := &db.PullComment{
 			OwnerDid:     user.Did,
-			RepoAt:       f.RepoAt.String(),
+			RepoAt:       f.RepoAt().String(),
 			PullId:       pull.PullId,
 			Body:         body,
 			CommentAt:    atResp.Uri,
···
 			return
 		}
 
-		result, err := us.Branches(f.OwnerDid(), f.RepoName)
+		result, err := us.Branches(f.OwnerDid(), f.Name)
 		if err != nil {
 			log.Println("failed to fetch branches", err)
 			return
···
 		return
 	}
 
-	comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, targetBranch, sourceBranch)
+	comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, targetBranch, sourceBranch)
 	if err != nil {
 		log.Println("failed to compare", err)
 		s.pages.Notice(w, "pull", err.Error())
···
 		Body:         body,
 		TargetBranch: targetBranch,
 		OwnerDid:     user.Did,
-		RepoAt:       f.RepoAt,
+		RepoAt:       f.RepoAt(),
 		Rkey:         rkey,
 		Submissions: []*db.PullSubmission{
 			&initialSubmission,
···
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
 		return
 	}
-	pullId, err := db.NextPullId(tx, f.RepoAt)
+	pullId, err := db.NextPullId(tx, f.RepoAt())
 	if err != nil {
 		log.Println("failed to get pull id", err)
 		s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
···
 			Val: &tangled.RepoPull{
 				Title:        title,
 				PullId:       int64(pullId),
-				TargetRepo:   string(f.RepoAt),
+				TargetRepo:   string(f.RepoAt()),
 				TargetBranch: targetBranch,
 				Patch:        patch,
 				Source:       recordPullSource,
···
 		return
 	}
 
-	result, err := us.Branches(f.OwnerDid(), f.RepoName)
+	result, err := us.Branches(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 		return
 	}
 
-	targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.RepoName)
+	targetResult, err := targetBranchesClient.Branches(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver for target branches", err)
 		return
···
 		return
 	}
 
-	comparison, err := ksClient.Compare(f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.PullSource.Branch)
+	comparison, err := ksClient.Compare(f.OwnerDid(), f.Name, pull.TargetBranch, pull.PullSource.Branch)
 	if err != nil {
 		log.Printf("compare request failed: %s", err)
 		s.pages.Notice(w, "resubmit-error", err.Error())
···
 			Val: &tangled.RepoPull{
 				Title:        pull.Title,
 				PullId:       int64(pull.PullId),
-				TargetRepo:   string(f.RepoAt),
+				TargetRepo:   string(f.RepoAt()),
 				TargetBranch: pull.TargetBranch,
 				Patch:        patch, // new patch
 				Source:       recordPullSource,
···
 	}
 
 	// Merge the pull request
-	resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.RepoName, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address)
+	resp, err := ksClient.Merge([]byte(patch), f.OwnerDid(), f.Name, pull.TargetBranch, pull.Title, pull.Body, ident.Handle.String(), email.Address)
 	if err != nil {
 		log.Printf("failed to merge pull request: %s", err)
 		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
 	defer tx.Rollback()
 
 	for _, p := range pullsToMerge {
-		err := db.MergePull(tx, f.RepoAt, p.PullId)
+		err := db.MergePull(tx, f.RepoAt(), p.PullId)
 		if err != nil {
 			log.Printf("failed to update pull request status in database: %s", err)
 			s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
···
 		return
 	}
 
-	s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.RepoName, pull.PullId))
+	s.pages.HxLocation(w, fmt.Sprintf("/@%s/%s/pulls/%d", f.OwnerHandle(), f.Name, pull.PullId))
 }
 
 func (s *Pulls) ClosePull(w http.ResponseWriter, r *http.Request) {
···
 
 	for _, p := range pullsToClose {
 		// Close the pull in the database
-		err = db.ClosePull(tx, f.RepoAt, p.PullId)
+		err = db.ClosePull(tx, f.RepoAt(), p.PullId)
 		if err != nil {
 			log.Println("failed to close pull", err)
 			s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
 
 	for _, p := range pullsToReopen {
 		// Close the pull in the database
-		err = db.ReopenPull(tx, f.RepoAt, p.PullId)
+		err = db.ReopenPull(tx, f.RepoAt(), p.PullId)
 		if err != nil {
 			log.Println("failed to close pull", err)
 			s.pages.Notice(w, "pull-close", "Failed to close pull.")
···
 			Body:         body,
 			TargetBranch: targetBranch,
 			OwnerDid:     user.Did,
-			RepoAt:       f.RepoAt,
+			RepoAt:       f.RepoAt(),
 			Rkey:         rkey,
 			Submissions: []*db.PullSubmission{
 				&initialSubmission,

appview/repo/artifact.go

···
 				Artifact:  uploadBlobResp.Blob,
 				CreatedAt: createdAt.Format(time.RFC3339),
 				Name:      handler.Filename,
-				Repo:      f.RepoAt.String(),
+				Repo:      f.RepoAt().String(),
 				Tag:       tag.Tag.Hash[:],
 			},
 		},
···
 	artifact := db.Artifact{
 		Did:       user.Did,
 		Rkey:      rkey,
-		RepoAt:    f.RepoAt,
+		RepoAt:    f.RepoAt(),
 		Tag:       tag.Tag.Hash,
 		CreatedAt: createdAt,
 		BlobCid:   cid.Cid(uploadBlobResp.Blob.Ref),
···
 
 	artifacts, err := db.GetArtifact(
 		rp.db,
-		db.FilterEq("repo_at", f.RepoAt),
+		db.FilterEq("repo_at", f.RepoAt()),
 		db.FilterEq("tag", tag.Tag.Hash[:]),
 		db.FilterEq("name", filename),
 	)
···
 
 	artifacts, err := db.GetArtifact(
 		rp.db,
-		db.FilterEq("repo_at", f.RepoAt),
+		db.FilterEq("repo_at", f.RepoAt()),
 		db.FilterEq("tag", tag[:]),
 		db.FilterEq("name", filename),
 	)
···
 	defer tx.Rollback()
 
 	err = db.DeleteArtifact(tx,
-		db.FilterEq("repo_at", f.RepoAt),
+		db.FilterEq("repo_at", f.RepoAt()),
 		db.FilterEq("tag", artifact.Tag[:]),
 		db.FilterEq("name", filename),
 	)
···
 		return nil, err
 	}
 
-	result, err := us.Tags(f.OwnerDid(), f.RepoName)
+	result, err := us.Tags(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return nil, err

appview/repo/index.go

···
 		return
 	}
 
-	result, err := us.Index(f.OwnerDid(), f.RepoName, ref)
+	result, err := us.Index(f.OwnerDid(), f.Name, ref)
 	if err != nil {
 		rp.pages.Error503(w)
 		log.Println("failed to reach knotserver", err)
···
 	// first attempt to fetch from db
 	langs, err := db.GetRepoLanguages(
 		rp.db,
-		db.FilterEq("repo_at", f.RepoAt),
+		db.FilterEq("repo_at", f.RepoAt()),
 		db.FilterEq("ref", f.Ref),
 	)
 
 	if err != nil || langs == nil {
 		// non-fatal, fetch langs from ks
-		ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.RepoName, f.Ref)
+		ls, err := signedClient.RepoLanguages(f.OwnerDid(), f.Name, f.Ref)
 		if err != nil {
 			return nil, err
 		}
···
 
 		for l, s := range ls.Languages {
 			langs = append(langs, db.RepoLanguage{
-				RepoAt:       f.RepoAt,
+				RepoAt:       f.RepoAt(),
 				Ref:          f.Ref,
 				IsDefaultRef: isDefaultRef,
 				Language:     l,
···
 	hiddenRef := fmt.Sprintf("hidden/%s/%s", f.Ref, f.Ref)
 
 	var status types.AncestorCheckResponse
-	forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt), repoInfo.Name, f.Ref, hiddenRef)
+	forkSyncableResp, err := signedClient.RepoForkAheadBehind(user.Did, string(f.RepoAt()), repoInfo.Name, f.Ref, hiddenRef)
 	if err != nil {
 		log.Printf("failed to check if fork is ahead/behind: %s", err)
 		return nil, err

appview/repo/repo.go

···
 	} else {
 		uri = "https"
 	}
-	url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.RepoName, url.PathEscape(refParam))
+	url := fmt.Sprintf("%s://%s/%s/%s/archive/%s.tar.gz", uri, f.Knot, f.OwnerDid(), f.Name, url.PathEscape(refParam))
 
 	http.Redirect(w, r, url, http.StatusFound)
 }
···
 		return
 	}
 
-	repolog, err := us.Log(f.OwnerDid(), f.RepoName, ref, page)
+	repolog, err := us.Log(f.OwnerDid(), f.Name, ref, page)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
 	}
 
-	tagResult, err := us.Tags(f.OwnerDid(), f.RepoName)
+	tagResult, err := us.Tags(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 		tagMap[hash] = append(tagMap[hash], tag.Name)
 	}
 
-	branchResult, err := us.Branches(f.OwnerDid(), f.RepoName)
+	branchResult, err := us.Branches(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 		return
 	}
 
-	repoAt := f.RepoAt
+	repoAt := f.RepoAt()
 	rkey := repoAt.RecordKey().String()
 	if rkey == "" {
 		log.Println("invalid aturi for repo", err)
···
 			Record: &lexutil.LexiconTypeDecoder{
 				Val: &tangled.Repo{
 					Knot:        f.Knot,
-					Name:        f.RepoName,
+					Name:        f.Name,
 					Owner:       user.Did,
-					CreatedAt:   f.CreatedAt,
+					CreatedAt:   f.Created.Format(time.RFC3339),
 					Description: &newDescription,
 					Spindle:     &f.Spindle,
 				},
···
 		return
 	}
 
-	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref))
+	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/commit/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref))
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 	if !rp.config.Core.Dev {
 		protocol = "https"
 	}
-	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, treePath))
+	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/tree/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, treePath))
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 	user := rp.oauth.GetUser(r)
 
 	var breadcrumbs [][]string
-	breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
+	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
 	if treePath != "" {
 		for idx, elem := range strings.Split(treePath, "/") {
 			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
 		return
 	}
 
-	result, err := us.Tags(f.OwnerDid(), f.RepoName)
+	result, err := us.Tags(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
 	}
 
-	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt))
+	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))
 	if err != nil {
 		log.Println("failed grab artifacts", err)
 		return
···
 		return
 	}
 
-	result, err := us.Branches(f.OwnerDid(), f.RepoName)
+	result, err := us.Branches(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 	if !rp.config.Core.Dev {
 		protocol = "https"
 	}
-	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath))
+	resp, err := http.Get(fmt.Sprintf("%s://%s/%s/%s/blob/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath))
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 	}
 
 	var breadcrumbs [][]string
-	breadcrumbs = append(breadcrumbs, []string{f.RepoName, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
+	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), ref)})
 	if filePath != "" {
 		for idx, elem := range strings.Split(filePath, "/") {
 			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], elem)})
···
 
 		// fetch the actual binary content like in RepoBlobRaw
 
-		blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath)
+		blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Name, ref, filePath)
 		contentSrc = blobURL
 		if !rp.config.Core.Dev {
 			contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)
···
 	if !rp.config.Core.Dev {
 		protocol = "https"
 	}
-	blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.RepoName, ref, filePath)
+	blobURL := fmt.Sprintf("%s://%s/%s/%s/raw/%s/%s", protocol, f.Knot, f.OwnerDid(), f.Repo.Name, ref, filePath)
 	resp, err := http.Get(blobURL)
 	if err != nil {
 		log.Println("failed to reach knotserver:", err)
···
 		return
 	}
 
-	repoAt := f.RepoAt
+	repoAt := f.RepoAt()
 	rkey := repoAt.RecordKey().String()
 	if rkey == "" {
 		fail("Failed to resolve repo. Try again later", err)
···
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.Repo{
 				Knot:        f.Knot,
-				Name:        f.RepoName,
+				Name:        f.Name,
 				Owner:       user.Did,
-				CreatedAt:   f.CreatedAt,
+				CreatedAt:   f.Created.Format(time.RFC3339),
 				Description: &f.Description,
 				Spindle:     spindlePtr,
 			},
···
 		Record: &lexutil.LexiconTypeDecoder{
 			Val: &tangled.RepoCollaborator{
 				Subject:   collaboratorIdent.DID.String(),
-				Repo:      string(f.RepoAt),
+				Repo:      string(f.RepoAt()),
 				CreatedAt: createdAt.Format(time.RFC3339),
 			}},
 	})
···
 		return
 	}
 
-	ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.RepoName, collaboratorIdent.DID.String())
+	ksResp, err := ksClient.AddCollaborator(f.OwnerDid(), f.Name, collaboratorIdent.DID.String())
 	if err != nil {
 		fail("Knot was unreachable.", err)
 		return
···
 		Did:        syntax.DID(currentUser.Did),
 		Rkey:       rkey,
 		SubjectDid: collaboratorIdent.DID,
-		RepoAt:     f.RepoAt,
+		RepoAt:     f.RepoAt(),
 		Created:    createdAt,
 	})
 	if err != nil {
···
 		log.Println("failed to get authorized client", err)
 		return
 	}
-	repoRkey := f.RepoAt.RecordKey().String()
 	_, err = xrpcClient.RepoDeleteRecord(r.Context(), &comatproto.RepoDeleteRecord_Input{
 		Collection: tangled.RepoNSID,
 		Repo:       user.Did,
-		Rkey:       repoRkey,
+		Rkey:       f.Rkey,
 	})
 	if err != nil {
 		log.Printf("failed to delete record: %s", err)
 		rp.pages.Notice(w, "settings-delete", "Failed to delete repository from PDS.")
 		return
 	}
-	log.Println("removed repo record ", f.RepoAt.String())
+	log.Println("removed repo record ", f.RepoAt().String())
 
 	secret, err := db.GetRegistrationKey(rp.db, f.Knot)
 	if err != nil {
···
 		return
 	}
 
-	ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.RepoName)
+	ksResp, err := ksClient.RemoveRepo(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Printf("failed to make request to %s: %s", f.Knot, err)
 		return
···
 	}
 
 	// remove repo from db
-	err = db.RemoveRepo(tx, f.OwnerDid(), f.RepoName)
+	err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)
 	if err != nil {
 		rp.pages.Notice(w, "settings-delete", "Failed to update appview")
 		return
···
 		return
 	}
 
-	ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.RepoName, branch)
+	ksResp, err := ksClient.SetDefaultBranch(f.OwnerDid(), f.Name, branch)
 	if err != nil {
 		log.Printf("failed to make request to %s: %s", f.Knot, err)
 		return
···
 			r.Context(),
 			spindleClient,
 			&tangled.RepoAddSecret_Input{
-				Repo:  f.RepoAt.String(),
+				Repo:  f.RepoAt().String(),
 				Key:   key,
 				Value: value,
 			},
···
 			r.Context(),
 			spindleClient,
 			&tangled.RepoRemoveSecret_Input{
-				Repo: f.RepoAt.String(),
+				Repo: f.RepoAt().String(),
 				Key:  key,
 			},
 		)
···
 	// 	return
 	// }
 
-	// result, err := us.Branches(f.OwnerDid(), f.RepoName)
+	// result, err := us.Branches(f.OwnerDid(), f.Name)
 	// if err != nil {
 	// 	log.Println("failed to reach knotserver", err)
 	// 	return
···
 	// 		oauth.WithDev(rp.config.Core.Dev),
 	// 	); err != nil {
 	// 		log.Println("failed to create spindle client", err)
-	// 	} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil {
+	// 	} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {
 	// 		log.Println("failed to fetch secrets", err)
 	// 	} else {
 	// 		secrets = resp.Secrets
···
 		return
 	}
 
-	result, err := us.Branches(f.OwnerDid(), f.RepoName)
+	result, err := us.Branches(f.OwnerDid(), f.Name)
 	if err != nil {
 		log.Println("failed to reach knotserver", err)
 		return
···
 			oauth.WithDev(rp.config.Core.Dev),
 		); err != nil {
 			log.Println("failed to create spindle client", err)
-		} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt.String()); err != nil {
+		} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {
 			log.Println("failed to fetch secrets", err)
 		} else {
 			secrets = resp.Secrets
···
 		} else {
 			uri = "https"
 		}
-		forkName := fmt.Sprintf("%s", f.RepoName)
-		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
+		forkName := fmt.Sprintf("%s", f.Name)
+		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
 
 		_, err = client.SyncRepoFork(user.Did, forkSourceUrl, forkName, f.Ref)
 		if err != nil {
···
 			return
 		}
 
-		forkName := fmt.Sprintf("%s", f.RepoName)
+		forkName := fmt.Sprintf("%s", f.Name)
 
 		// this check is *only* to see if the forked repo name already exists
 		// in the user's account.
-		existingRepo, err := db.GetRepo(rp.db, user.Did, f.RepoName)
+		existingRepo, err := db.GetRepo(rp.db, user.Did, f.Name)
 		if err != nil {
 			if errors.Is(err, sql.ErrNoRows) {
 				// no existing repo with this name found, we can use the name as is
···
 		} else {
 			uri = "https"
 		}
-		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.RepoName)
-		sourceAt := f.RepoAt.String()
+		forkSourceUrl := fmt.Sprintf("%s://%s/%s/%s", uri, f.Knot, f.OwnerDid(), f.Repo.Name)
+		sourceAt := f.RepoAt().String()
 
 		rkey := tid.TID()
 		repo := &db.Repo{
···
 		return
 	}
 
-	result, err := us.Branches(f.OwnerDid(), f.RepoName)
+	result, err := us.Branches(f.OwnerDid(), f.Name)
 	if err != nil {
 		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
 		log.Println("failed to reach knotserver", err)
···
 		head = queryHead
 	}
 
-	tags, err := us.Tags(f.OwnerDid(), f.RepoName)
+	tags, err := us.Tags(f.OwnerDid(), f.Name)
 	if err != nil {
 		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
 		log.Println("failed to reach knotserver", err)
···
 		return
 	}
 
-	branches, err := us.Branches(f.OwnerDid(), f.RepoName)
+	branches, err := us.Branches(f.OwnerDid(), f.Name)
 	if err != nil {
 		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
 		log.Println("failed to reach knotserver", err)
 		return
 	}
 
-	tags, err := us.Tags(f.OwnerDid(), f.RepoName)
+	tags, err := us.Tags(f.OwnerDid(), f.Name)
 	if err != nil {
 		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
 		log.Println("failed to reach knotserver", err)
 		return
 	}
 
-	formatPatch, err := us.Compare(f.OwnerDid(), f.RepoName, base, head)
+	formatPatch, err := us.Compare(f.OwnerDid(), f.Name, base, head)
 	if err != nil {
 		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")
 		log.Println("failed to compare", err)

appview/reporesolver/resolver.go

···
 	"strings"
 
 	"github.com/bluesky-social/indigo/atproto/identity"
-	"github.com/bluesky-social/indigo/atproto/syntax"
 	securejoin "github.com/cyphar/filepath-securejoin"
 	"github.com/go-chi/chi/v5"
 	"tangled.sh/tangled.sh/core/appview/config"
···
 )
 
 type ResolvedRepo struct {
-	Knot        string
+	db.Repo
 	OwnerId     identity.Identity
-	RepoName    string
-	RepoAt      syntax.ATURI
-	Description string
-	Spindle     string
-	CreatedAt   string
 	Ref         string
 	CurrentDir  string
 
···
 }
 
 func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
-	repoName := chi.URLParam(r, "repo")
-	knot, ok := r.Context().Value("knot").(string)
+	repo, ok := r.Context().Value("repo").(*db.Repo)
 	if !ok {
-		log.Println("malformed middleware")
+		log.Println("malformed middleware: `repo` not exist in context")
 		return nil, fmt.Errorf("malformed middleware")
 	}
 	id, ok := r.Context().Value("resolvedId").(identity.Identity)
···
 		return nil, fmt.Errorf("malformed middleware")
 	}
 
-	repoAt, ok := r.Context().Value("repoAt").(string)
-	if !ok {
-		log.Println("malformed middleware")
-		return nil, fmt.Errorf("malformed middleware")
-	}
-
-	parsedRepoAt, err := syntax.ParseATURI(repoAt)
-	if err != nil {
-		log.Println("malformed repo at-uri")
-		return nil, fmt.Errorf("malformed middleware")
-	}
-
 	ref := chi.URLParam(r, "ref")
 
 	if ref == "" {
-		us, err := knotclient.NewUnsignedClient(knot, rr.config.Core.Dev)
+		us, err := knotclient.NewUnsignedClient(repo.Knot, rr.config.Core.Dev)
 		if err != nil {
 			return nil, err
 		}
 
-		defaultBranch, err := us.DefaultBranch(id.DID.String(), repoName)
+		defaultBranch, err := us.DefaultBranch(id.DID.String(), repo.Name)
 		if err != nil {
 			return nil, err
 		}
···
 
 	currentDir := path.Dir(extractPathAfterRef(r.URL.EscapedPath(), ref))
 
-	// pass through values from the middleware
-	description, ok := r.Context().Value("repoDescription").(string)
-	addedAt, ok := r.Context().Value("repoAddedAt").(string)
-	spindle, ok := r.Context().Value("repoSpindle").(string)
-
 	return &ResolvedRepo{
-		Knot:        knot,
-		OwnerId:     id,
-		RepoName:    repoName,
-		RepoAt:      parsedRepoAt,
-		Description: description,
-		CreatedAt:   addedAt,
-		Ref:         ref,
-		CurrentDir:  currentDir,
-		Spindle:     spindle,
+		Repo:       *repo,
+		OwnerId:    id,
+		Ref:        ref,
+		CurrentDir: currentDir,
 
 		rr: rr,
 	}, nil
···
 
 	var p string
 	if handle != "" && !handle.IsInvalidHandle() {
-		p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.RepoName)
+		p, _ = securejoin.SecureJoin(fmt.Sprintf("@%s", handle), f.Name)
 	} else {
-		p, _ = securejoin.SecureJoin(f.OwnerDid(), f.RepoName)
+		p, _ = securejoin.SecureJoin(f.OwnerDid(), f.Name)
 	}
 
-	return p
-}
-
-func (f *ResolvedRepo) DidSlashRepo() string {
-	p, _ := securejoin.SecureJoin(f.OwnerDid(), f.RepoName)
 	return p
 }
 
···
 // this function is a bit weird since it now returns RepoInfo from an entirely different
 // package. we should refactor this or get rid of RepoInfo entirely.
 func (f *ResolvedRepo) RepoInfo(user *oauth.User) repoinfo.RepoInfo {
+	repoAt := f.RepoAt()
 	isStarred := false
 	if user != nil {
-		isStarred = db.GetStarStatus(f.rr.execer, user.Did, syntax.ATURI(f.RepoAt))
+		isStarred = db.GetStarStatus(f.rr.execer, user.Did, repoAt)
 	}
 
-	starCount, err := db.GetStarCount(f.rr.execer, f.RepoAt)
+	starCount, err := db.GetStarCount(f.rr.execer, repoAt)
 	if err != nil {
-		log.Println("failed to get star count for ", f.RepoAt)
+		log.Println("failed to get star count for ", repoAt)
 	}
-	issueCount, err := db.GetIssueCount(f.rr.execer, f.RepoAt)
+	issueCount, err := db.GetIssueCount(f.rr.execer, repoAt)
 	if err != nil {
-		log.Println("failed to get issue count for ", f.RepoAt)
+		log.Println("failed to get issue count for ", repoAt)
 	}
-	pullCount, err := db.GetPullCount(f.rr.execer, f.RepoAt)
+	pullCount, err := db.GetPullCount(f.rr.execer, repoAt)
 	if err != nil {
-		log.Println("failed to get issue count for ", f.RepoAt)
+		log.Println("failed to get issue count for ", repoAt)
 	}
-	source, err := db.GetRepoSource(f.rr.execer, f.RepoAt)
+	source, err := db.GetRepoSource(f.rr.execer, repoAt)
 	if errors.Is(err, sql.ErrNoRows) {
 		source = ""
 	} else if err != nil {
-		log.Println("failed to get repo source for ", f.RepoAt, err)
+		log.Println("failed to get repo source for ", repoAt, err)
 	}
 
 	var sourceRepo *db.Repo
···
 	if err != nil {
 		log.Printf("failed to create unsigned client for %s: %v", knot, err)
 	} else {
-		result, err := us.Branches(f.OwnerDid(), f.RepoName)
+		result, err := us.Branches(f.OwnerDid(), f.Name)
 		if err != nil {
-			log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.RepoName, err)
+			log.Printf("failed to get branches for %s/%s: %v", f.OwnerDid(), f.Name, err)
 		}
 
 		if len(result.Branches) == 0 {
···
 	repoInfo := repoinfo.RepoInfo{
 		OwnerDid:    f.OwnerDid(),
 		OwnerHandle: f.OwnerHandle(),
-		Name:        f.RepoName,
-		RepoAt:      f.RepoAt,
+		Name:        f.Name,
+		RepoAt:      repoAt,
 		Description: f.Description,
 		Ref:         f.Ref,
 		IsStarred:   isStarred,