appview/db: refactor GetRepo to use db.Filter

Signed-off-by: oppiliappan <[e-mail]>

appview/db/repos.go

···
 	return repos, nil
 }
 
+// helper to get exactly one repo
+func GetRepo(e Execer, filters ...filter) (*Repo, error) {
+	repos, err := GetRepos(e, 0, filters...)
+	if err != nil {
+		return nil, err
+	}
+
+	if repos == nil {
+		return nil, sql.ErrNoRows
+	}
+
+	if len(repos) != 1 {
+		return nil, fmt.Errorf("too many rows returned")
+	}
+
+	return &repos[0], nil
+}
+
 func CountRepos(e Execer, filters ...filter) (int64, error) {
 	var conditions []string
 	var args []any
···
 	}
 
 	return count, nil
-}
-
-func GetRepo(e Execer, did, name string) (*Repo, error) {
-	var repo Repo
-	var description, spindle sql.NullString
-
-	row := e.QueryRow(`
-		select did, name, knot, created, description, spindle, rkey
-		from repos
-		where did = ? and name = ?
-		`,
-		did,
-		name,
-	)
-
-	var createdAt string
-	if err := row.Scan(&repo.Did, &repo.Name, &repo.Knot, &createdAt, &description, &spindle, &repo.Rkey); err != nil {
-		return nil, err
-	}
-	createdAtTime, _ := time.Parse(time.RFC3339, createdAt)
-	repo.Created = createdAtTime
-
-	if description.Valid {
-		repo.Description = description.String
-	}
-
-	if spindle.Valid {
-		repo.Spindle = spindle.String
-	}
-
-	return &repo, nil
 }
 
 func GetRepoByAtUri(e Execer, atUri string) (*Repo, error) {

appview/issues/router.go

···
 		r.With(middleware.Paginate).Get("/", i.RepoIssues)
 
 		r.Route("/{issue}", func(r chi.Router) {
-			r.Use(mw.ResolveIssue())
+			r.Use(mw.ResolveIssue)
 			r.Get("/", i.RepoSingleIssue)
 
 			// authenticated routes

appview/middleware/middleware.go

···
 				return
 			}
 
-			repo, err := db.GetRepo(mw.db, id.DID.String(), repoName)
+			repo, err := db.GetRepo(
+				mw.db,
+				db.FilterEq("did", id.DID.String()),
+				db.FilterEq("name", repoName),
+			)
 			if err != nil {
-				// invalid did or handle
-				log.Println("failed to resolve repo")
+				log.Println("failed to resolve repo", "err", err)
 				mw.pages.ErrorKnot404(w)
 				return
 			}
···
 }
 
 // middleware that is tacked on top of /{user}/{repo}/issues/{issue}
-func (mw Middleware) ResolveIssue() middlewareFunc {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			f, err := mw.repoResolver.Resolve(r)
-			if err != nil {
-				log.Println("failed to fully resolve repo", err)
-				mw.pages.ErrorKnot404(w)
-				return
-			}
+func (mw Middleware) ResolveIssue(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		f, err := mw.repoResolver.Resolve(r)
+		if err != nil {
+			log.Println("failed to fully resolve repo", err)
+			mw.pages.ErrorKnot404(w)
+			return
+		}
 
-			issueIdStr := chi.URLParam(r, "issue")
-			issueId, err := strconv.Atoi(issueIdStr)
-			if err != nil {
-				log.Println("failed to fully resolve issue ID", err)
-				mw.pages.ErrorKnot404(w)
-				return
-			}
+		issueIdStr := chi.URLParam(r, "issue")
+		issueId, err := strconv.Atoi(issueIdStr)
+		if err != nil {
+			log.Println("failed to fully resolve issue ID", err)
+			mw.pages.ErrorKnot404(w)
+			return
+		}
 
-			issues, err := db.GetIssues(
-				mw.db,
-				db.FilterEq("repo_at", f.RepoAt()),
-				db.FilterEq("issue_id", issueId),
-			)
-			if err != nil {
-				log.Println("failed to get issues", "err", err)
-				return
-			}
-			if len(issues) != 1 {
-				log.Println("got incorrect number of issues", "len(issuse)", len(issues))
-				return
-			}
-			issue := issues[0]
+		issues, err := db.GetIssues(
+			mw.db,
+			db.FilterEq("repo_at", f.RepoAt()),
+			db.FilterEq("issue_id", issueId),
+		)
+		if err != nil {
+			log.Println("failed to get issues", "err", err)
+			return
+		}
+		if len(issues) != 1 {
+			log.Println("got incorrect number of issues", "len(issuse)", len(issues))
+			return
+		}
+		issue := issues[0]
 
-			ctx := context.WithValue(r.Context(), "issue", &issue)
-			next.ServeHTTP(w, r.WithContext(ctx))
-		})
-	}
+		ctx := context.WithValue(r.Context(), "issue", &issue)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
 }
 
 // this should serve the go-import meta tag even if the path is technically

appview/pulls/pulls.go

···
 	forkOwnerDid := repoString[0]
 	forkName := repoString[1]
 	// fork repo
-	repo, err := db.GetRepo(s.db, forkOwnerDid, forkName)
+	repo, err := db.GetRepo(
+		s.db,
+		db.FilterEq("did", forkOwnerDid),
+		db.FilterEq("name", forkName),
+	)
 	if err != nil {
-		log.Println("failed to get repo", user.Did, forkVal)
+		log.Println("failed to get repo", "did", forkOwnerDid, "name", forkName, "err", err)
 		return
 	}
 

appview/repo/repo.go

···
 		forkName := 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.Name)
+		existingRepo, err := db.GetRepo(
+			rp.db,
+			db.FilterEq("did", user.Did),
+			db.FilterEq("name", 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

appview/state/state.go

···
 		}
 
 		// Check for existing repos
-		existingRepo, err := db.GetRepo(s.db, user.Did, repoName)
+		existingRepo, err := db.GetRepo(
+			s.db,
+			db.FilterEq("did", user.Did),
+			db.FilterEq("name", repoName),
+		)
 		if err == nil && existingRepo != nil {
 			l.Info("repo exists")
 			s.pages.Notice(w, "repo", fmt.Sprintf("You already have a repository by this name on %s", existingRepo.Knot))

spindle/ingester.go

···
 
 	l := s.l.With("component", "ingester", "record", tangled.RepoNSID)
 
-	l.Info("ingesting repo record")
+	l.Info("ingesting repo record", "did", did)
 
 	switch e.Commit.Operation {
 	case models.CommitOperationCreate, models.CommitOperationUpdate: