appview/models: move db.Repo* into models

- move db.{Repo,RepoStats,IssueCount,PullCount} into models
- moe auxilliary funcs like FromRecord into models

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

appview/db/collaborators.go

···
 	return err
 }
 
-func CollaboratingIn(e Execer, collaborator string) ([]Repo, error) {
+func CollaboratingIn(e Execer, collaborator string) ([]models.Repo, error) {
 	rows, err := e.Query(`select repo_at from collaborators where subject_did = ?`, collaborator)
 	if err != nil {
 		return nil, err

appview/db/issues.go

···
 	// like comment counts, parent repo etc.
 	Comments []IssueComment
 	Labels   models.LabelState
-	Repo     *Repo
+	Repo     *models.Repo
 }
 
 func (i *Issue) AtUri() syntax.ATURI {
···
 		return nil, fmt.Errorf("failed to build repo mappings: %w", err)
 	}
 
-	repoMap := make(map[string]*Repo)
+	repoMap := make(map[string]*models.Repo)
 	for i := range repos {
 		repoMap[string(repos[i].RepoAt())] = &repos[i]
 	}
···
 	return err
 }
 
-type IssueCount struct {
-	Open   int
-	Closed int
-}
-
-func GetIssueCount(e Execer, repoAt syntax.ATURI) (IssueCount, error) {
+func GetIssueCount(e Execer, repoAt syntax.ATURI) (models.IssueCount, error) {
 	row := e.QueryRow(`
 		select
 			count(case when open = 1 then 1 end) as open_count,
···
 		repoAt,
 	)
 
-	var count IssueCount
+	var count models.IssueCount
 	if err := row.Scan(&count.Open, &count.Closed); err != nil {
-		return IssueCount{0, 0}, err
+		return models.IssueCount{0, 0}, err
 	}
 
 	return count, nil

appview/db/profile.go

···
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"tangled.org/core/api/tangled"
+	"tangled.org/core/appview/models"
 )
 
 type RepoEvent struct {
-	Repo   *Repo
-	Source *Repo
+	Repo   *models.Repo
+	Source *models.Repo
 }
 
 type ProfileTimeline struct {
···
 
 	for _, repo := range repos {
 		// TODO: get this in the original query; requires COALESCE because nullable
-		var sourceRepo *Repo
+		var sourceRepo *models.Repo
 		if repo.Source != "" {
 			sourceRepo, err = GetRepoByAtUri(e, repo.Source)
 			if err != nil {

appview/db/pulls.go

···
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"tangled.org/core/api/tangled"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/patchutil"
 	"tangled.org/core/types"
 )
···
 	PullSource *PullSource
 
 	// optionally, populate this when querying for reverse mappings
-	Repo *Repo
+	Repo *models.Repo
 }
 
 func (p Pull) AsRecord() tangled.RepoPull {
···
 	RepoAt *syntax.ATURI
 
 	// optionally populate this for reverse mappings
-	Repo *Repo
+	Repo *models.Repo
 }
 
 func (p PullSource) AsRecord() tangled.RepoPull_Source {
···
 		return nil, err
 	}
 
-	var pullSourceRepo *Repo
+	var pullSourceRepo *models.Repo
 	if pull.PullSource != nil {
 		if pull.PullSource.RepoAt != nil {
 			pullSourceRepo, err = GetRepoByAtUri(e, pull.PullSource.RepoAt.String())
···
 
 	for rows.Next() {
 		var pull Pull
-		var repo Repo
+		var repo models.Repo
 		var pullCreatedAt, repoCreatedAt string
 		err := rows.Scan(
 			&pull.OwnerDid,
···
 	return err
 }
 
-type PullCount struct {
-	Open    int
-	Merged  int
-	Closed  int
-	Deleted int
-}
-
-func GetPullCount(e Execer, repoAt syntax.ATURI) (PullCount, error) {
+func GetPullCount(e Execer, repoAt syntax.ATURI) (models.PullCount, error) {
 	row := e.QueryRow(`
 		select
 			count(case when state = ? then 1 end) as open_count,
···
 		repoAt,
 	)
 
-	var count PullCount
+	var count models.PullCount
 	if err := row.Scan(&count.Open, &count.Merged, &count.Closed, &count.Deleted); err != nil {
-		return PullCount{0, 0, 0, 0}, err
+		return models.PullCount{Open: 0, Merged: 0, Closed: 0, Deleted: 0}, err
 	}
 
 	return count, nil

appview/db/repos.go

···
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
-	securejoin "github.com/cyphar/filepath-securejoin"
-	"tangled.org/core/api/tangled"
+	"tangled.org/core/appview/models"
 )
 
-type Repo struct {
-	Did         string
-	Name        string
-	Knot        string
-	Rkey        string
-	Created     time.Time
-	Description string
-	Spindle     string
-	Labels      []string
-
-	// optionally, populate this when querying for reverse mappings
-	RepoStats *RepoStats
-
-	// optional
-	Source string
-}
-
-func (r *Repo) AsRecord() tangled.Repo {
-	var source, spindle, description *string
-
-	if r.Source != "" {
-		source = &r.Source
-	}
-
-	if r.Spindle != "" {
-		spindle = &r.Spindle
-	}
-
-	if r.Description != "" {
-		description = &r.Description
-	}
-
-	return tangled.Repo{
-		Knot:        r.Knot,
-		Name:        r.Name,
-		Description: description,
-		CreatedAt:   r.Created.Format(time.RFC3339),
-		Source:      source,
-		Spindle:     spindle,
-		Labels:      r.Labels,
-	}
-}
-
-func (r Repo) RepoAt() syntax.ATURI {
-	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey))
-}
-
-func (r Repo) DidSlashRepo() string {
-	p, _ := securejoin.SecureJoin(r.Did, r.Name)
-	return p
-}
-
-func GetRepos(e Execer, limit int, filters ...filter) ([]Repo, error) {
-	repoMap := make(map[syntax.ATURI]*Repo)
+func GetRepos(e Execer, limit int, filters ...filter) ([]models.Repo, error) {
+	repoMap := make(map[syntax.ATURI]*models.Repo)
 
 	var conditions []string
 	var args []any
···
 	}
 
 	for rows.Next() {
-		var repo Repo
+		var repo models.Repo
 		var createdAt string
 		var description, source, spindle sql.NullString
 
···
 			repo.Spindle = spindle.String
 		}
 
-		repo.RepoStats = &RepoStats{}
+		repo.RepoStats = &models.RepoStats{}
 		repoMap[repo.RepoAt()] = &repo
 	}
 
···
 		return nil, fmt.Errorf("failed to execute pulls-count query: %w ", err)
 	}
 
-	var repos []Repo
+	var repos []models.Repo
 	for _, r := range repoMap {
 		repos = append(repos, *r)
 	}
 
-	slices.SortFunc(repos, func(a, b Repo) int {
+	slices.SortFunc(repos, func(a, b models.Repo) int {
 		if a.Created.After(b.Created) {
 			return -1
 		}
···
 }
 
 // helper to get exactly one repo
-func GetRepo(e Execer, filters ...filter) (*Repo, error) {
+func GetRepo(e Execer, filters ...filter) (*models.Repo, error) {
 	repos, err := GetRepos(e, 0, filters...)
 	if err != nil {
 		return nil, err
···
 	return count, nil
 }
 
-func GetRepoByAtUri(e Execer, atUri string) (*Repo, error) {
-	var repo Repo
+func GetRepoByAtUri(e Execer, atUri string) (*models.Repo, error) {
+	var repo models.Repo
 	var nullableDescription sql.NullString
 
 	row := e.QueryRow(`select did, name, knot, created, rkey, description from repos where at_uri = ?`, atUri)
···
 	return &repo, nil
 }
 
-func AddRepo(e Execer, repo *Repo) error {
+func AddRepo(e Execer, repo *models.Repo) error {
 	_, err := e.Exec(
 		`insert into repos
 		(did, name, knot, rkey, at_uri, description, source)
···
 	return nullableSource.String, nil
 }
 
-func GetForksByDid(e Execer, did string) ([]Repo, error) {
-	var repos []Repo
+func GetForksByDid(e Execer, did string) ([]models.Repo, error) {
+	var repos []models.Repo
 
 	rows, err := e.Query(
 		`select distinct r.did, r.name, r.knot, r.rkey, r.description, r.created, r.source
···
 	defer rows.Close()
 
 	for rows.Next() {
-		var repo Repo
+		var repo models.Repo
 		var createdAt string
 		var nullableDescription sql.NullString
 		var nullableSource sql.NullString
···
 	return repos, nil
 }
 
-func GetForkByDid(e Execer, did string, name string) (*Repo, error) {
-	var repo Repo
+func GetForkByDid(e Execer, did string, name string) (*models.Repo, error) {
+	var repo models.Repo
 	var createdAt string
 	var nullableDescription sql.NullString
 	var nullableSource sql.NullString
···
 	return err
 }
 
-type RepoStats struct {
-	Language   string
-	StarCount  int
-	IssueCount IssueCount
-	PullCount  PullCount
-}
-
-type RepoLabel struct {
-	Id      int64
-	RepoAt  syntax.ATURI
-	LabelAt syntax.ATURI
-}
-
-func SubscribeLabel(e Execer, rl *RepoLabel) error {
+func SubscribeLabel(e Execer, rl *models.RepoLabel) error {
 	query := `insert or ignore into repo_labels (repo_at, label_at) values (?, ?)`
 
 	_, err := e.Exec(query, rl.RepoAt.String(), rl.LabelAt.String())
···
 	return err
 }
 
-func GetRepoLabels(e Execer, filters ...filter) ([]RepoLabel, error) {
+func GetRepoLabels(e Execer, filters ...filter) ([]models.RepoLabel, error) {
 	var conditions []string
 	var args []any
 	for _, filter := range filters {
···
 	}
 	defer rows.Close()
 
-	var labels []RepoLabel
+	var labels []models.RepoLabel
 	for rows.Next() {
-		var label RepoLabel
+		var label models.RepoLabel
 
 		err := rows.Scan(&label.Id, &label.RepoAt, &label.LabelAt)
 		if err != nil {

appview/db/star.go

···
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.org/core/appview/models"
 )
 
 type Star struct {
···
 	Rkey         string
 
 	// optionally, populate this when querying for reverse mappings
-	Repo *Repo
+	Repo *models.Repo
 }
 
 func (star *Star) ResolveRepo(e Execer) error {
···
 
 	for rows.Next() {
 		var star Star
-		var repo Repo
+		var repo models.Repo
 		var starCreatedAt, repoCreatedAt string
 
 		if err := rows.Scan(
···
 }
 
 // GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week
-func GetTopStarredReposLastWeek(e Execer) ([]Repo, error) {
+func GetTopStarredReposLastWeek(e Execer) ([]models.Repo, error) {
 	// first, get the top repo URIs by star count from the last week
 	query := `
 		with recent_starred_repos as (
···
 	}
 
 	if len(repoUris) == 0 {
-		return []Repo{}, nil
+		return []models.Repo{}, nil
 	}
 
 	// get full repo data
···
 	}
 
 	// sort repos by the original trending order
-	repoMap := make(map[string]Repo)
+	repoMap := make(map[string]models.Repo)
 	for _, repo := range repos {
 		repoMap[repo.RepoAt().String()] = repo
 	}
 
-	orderedRepos := make([]Repo, 0, len(repoUris))
+	orderedRepos := make([]models.Repo, 0, len(repoUris))
 	for _, uri := range repoUris {
 		if repo, exists := repoMap[uri]; exists {
 			orderedRepos = append(orderedRepos, repo)

appview/db/timeline.go

···
 )
 
 type TimelineEvent struct {
-	*Repo
+	*models.Repo
 	*models.Follow
 	*Star
 
 	EventAt time.Time
 
 	// optional: populate only if Repo is a fork
-	Source *Repo
+	Source *models.Repo
 
 	// optional: populate only if event is Follow
 	*Profile
···
 	return events, nil
 }
 
-func fetchStarStatuses(e Execer, loggedInUserDid string, repos []Repo) (map[string]bool, error) {
+func fetchStarStatuses(e Execer, loggedInUserDid string, repos []models.Repo) (map[string]bool, error) {
 	if loggedInUserDid == "" {
 		return nil, nil
 	}
···
 	return GetStarStatuses(e, loggedInUserDid, repoAts)
 }
 
-func getRepoStarInfo(repo *Repo, starStatuses map[string]bool) (bool, int64) {
+func getRepoStarInfo(repo *models.Repo, starStatuses map[string]bool) (bool, int64) {
 	var isStarred bool
 	if starStatuses != nil {
 		isStarred = starStatuses[repo.RepoAt().String()]
···
 		}
 	}
 
-	var origRepos []Repo
+	var origRepos []models.Repo
 	if args != nil {
 		origRepos, err = GetRepos(e, 0, FilterIn("at_uri", args))
 	}
···
 		return nil, err
 	}
 
-	uriToRepo := make(map[string]Repo)
+	uriToRepo := make(map[string]models.Repo)
 	for _, r := range origRepos {
 		uriToRepo[r.RepoAt().String()] = r
 	}
···
 
 	var events []TimelineEvent
 	for _, r := range repos {
-		var source *Repo
+		var source *models.Repo
 		if r.Source != "" {
 			if origRepo, ok := uriToRepo[r.Source]; ok {
 				source = &origRepo
···
 	}
 	stars = stars[:n]
 
-	var repos []Repo
+	var repos []models.Repo
 	for _, s := range stars {
 		repos = append(repos, *s.Repo)
 	}

appview/knots/knots.go

···
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
 	"tangled.org/core/appview/middleware"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
 	"tangled.org/core/appview/serververify"
···
 	}
 
 	// organize repos by did
-	repoMap := make(map[string][]db.Repo)
+	repoMap := make(map[string][]models.Repo)
 	for _, r := range repos {
 		repoMap[r.Did] = append(repoMap[r.Did], r)
 	}

appview/models/repo.go

···
+package models
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/bluesky-social/indigo/atproto/syntax"
+	securejoin "github.com/cyphar/filepath-securejoin"
+	"tangled.org/core/api/tangled"
+)
+
+type Repo struct {
+	Did         string
+	Name        string
+	Knot        string
+	Rkey        string
+	Created     time.Time
+	Description string
+	Spindle     string
+	Labels      []string
+
+	// optionally, populate this when querying for reverse mappings
+	RepoStats *RepoStats
+
+	// optional
+	Source string
+}
+
+func (r *Repo) AsRecord() tangled.Repo {
+	var source, spindle, description *string
+
+	if r.Source != "" {
+		source = &r.Source
+	}
+
+	if r.Spindle != "" {
+		spindle = &r.Spindle
+	}
+
+	if r.Description != "" {
+		description = &r.Description
+	}
+
+	return tangled.Repo{
+		Knot:        r.Knot,
+		Name:        r.Name,
+		Description: description,
+		CreatedAt:   r.Created.Format(time.RFC3339),
+		Source:      source,
+		Spindle:     spindle,
+		Labels:      r.Labels,
+	}
+}
+
+func (r Repo) RepoAt() syntax.ATURI {
+	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", r.Did, tangled.RepoNSID, r.Rkey))
+}
+
+func (r Repo) DidSlashRepo() string {
+	p, _ := securejoin.SecureJoin(r.Did, r.Name)
+	return p
+}
+
+type RepoStats struct {
+	Language   string
+	StarCount  int
+	IssueCount IssueCount
+	PullCount  PullCount
+}
+
+type IssueCount struct {
+	Open   int
+	Closed int
+}
+
+type PullCount struct {
+	Open    int
+	Merged  int
+	Closed  int
+	Deleted int
+}
+
+type RepoLabel struct {
+	Id      int64
+	RepoAt  syntax.ATURI
+	LabelAt syntax.ATURI
+}

appview/notify/merged_notifier.go

···
 
 var _ Notifier = &mergedNotifier{}
 
-func (m *mergedNotifier) NewRepo(ctx context.Context, repo *db.Repo) {
+func (m *mergedNotifier) NewRepo(ctx context.Context, repo *models.Repo) {
 	for _, notifier := range m.notifiers {
 		notifier.NewRepo(ctx, repo)
 	}

appview/notify/notifier.go

···
 )
 
 type Notifier interface {
-	NewRepo(ctx context.Context, repo *db.Repo)
+	NewRepo(ctx context.Context, repo *models.Repo)
 
 	NewStar(ctx context.Context, star *db.Star)
 	DeleteStar(ctx context.Context, star *db.Star)
···
 
 var _ Notifier = &BaseNotifier{}
 
-func (m *BaseNotifier) NewRepo(ctx context.Context, repo *db.Repo) {}
+func (m *BaseNotifier) NewRepo(ctx context.Context, repo *models.Repo) {}
 
 func (m *BaseNotifier) NewStar(ctx context.Context, star *db.Star)    {}
 func (m *BaseNotifier) DeleteStar(ctx context.Context, star *db.Star) {}

appview/pages/pages.go

···
 type TimelineParams struct {
 	LoggedInUser *oauth.User
 	Timeline     []db.TimelineEvent
-	Repos        []db.Repo
+	Repos        []models.Repo
 }
 
 func (p *Pages) Timeline(w io.Writer, params TimelineParams) error {
···
 	LoggedInUser *oauth.User
 	Registration *db.Registration
 	Members      []string
-	Repos        map[string][]db.Repo
+	Repos        map[string][]models.Repo
 	IsOwner      bool
 }
 
···
 	LoggedInUser *oauth.User
 	Spindle      db.Spindle
 	Members      []string
-	Repos        map[string][]db.Repo
+	Repos        map[string][]models.Repo
 }
 
 func (p *Pages) SpindleDashboard(w io.Writer, params SpindleDashboardParams) error {
···
 
 type ProfileOverviewParams struct {
 	LoggedInUser       *oauth.User
-	Repos              []db.Repo
-	CollaboratingRepos []db.Repo
+	Repos              []models.Repo
+	CollaboratingRepos []models.Repo
 	ProfileTimeline    *db.ProfileTimeline
 	Card               *ProfileCard
 	Active             string
···
 
 type ProfileReposParams struct {
 	LoggedInUser *oauth.User
-	Repos        []db.Repo
+	Repos        []models.Repo
 	Card         *ProfileCard
 	Active       string
 }
···
 
 type ProfileStarredParams struct {
 	LoggedInUser *oauth.User
-	Repos        []db.Repo
+	Repos        []models.Repo
 	Card         *ProfileCard
 	Active       string
 }
···
 
 type PinnedRepo struct {
 	IsPinned bool
-	db.Repo
+	models.Repo
 }
 
 func (p *Pages) EditPinsFragment(w io.Writer, params EditPinsParams) error {
···
 type RepoStarFragmentParams struct {
 	IsStarred bool
 	RepoAt    syntax.ATURI
-	Stats     db.RepoStats
+	Stats     models.RepoStats
 }
 
 func (p *Pages) RepoStarFragment(w io.Writer, params RepoStarFragmentParams) error {
···
 
 type PullCompareForkParams struct {
 	RepoInfo repoinfo.RepoInfo
-	Forks    []db.Repo
+	Forks    []models.Repo
 	Selected string
 }
 
···
 type RepoCompareParams struct {
 	LoggedInUser *oauth.User
 	RepoInfo     repoinfo.RepoInfo
-	Forks        []db.Repo
+	Forks        []models.Repo
 	Branches     []types.Branch
 	Tags         []*types.TagReference
 	Base         string
···
 type RepoCompareNewParams struct {
 	LoggedInUser *oauth.User
 	RepoInfo     repoinfo.RepoInfo
-	Forks        []db.Repo
+	Forks        []models.Repo
 	Branches     []types.Branch
 	Tags         []*types.TagReference
 	Base         string

appview/pages/repoinfo/repoinfo.go

···
 	"strings"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
-	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/state/userutil"
 )
 
···
 	Spindle      string
 	RepoAt       syntax.ATURI
 	IsStarred    bool
-	Stats        db.RepoStats
+	Stats        models.RepoStats
 	Roles        RolesInRepo
-	Source       *db.Repo
+	Source       *models.Repo
 	SourceHandle string
 	Ref          string
 	DisableFork  bool

appview/posthog/notifier.go

···
 
 var _ notify.Notifier = &posthogNotifier{}
 
-func (n *posthogNotifier) NewRepo(ctx context.Context, repo *db.Repo) {
+func (n *posthogNotifier) NewRepo(ctx context.Context, repo *models.Repo) {
 	err := n.client.Enqueue(posthog.Capture{
 		DistinctId: repo.Did,
 		Event:      "new_repo",

appview/pulls/pulls.go

···
 	"tangled.org/core/api/tangled"
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/notify"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
···
 	}
 
 	for _, p := range pulls {
-		var pullSourceRepo *db.Repo
+		var pullSourceRepo *models.Repo
 		if p.PullSource != nil {
 			if p.PullSource.RepoAt != nil {
 				pullSourceRepo, err = db.GetRepoByAtUri(s.db, p.PullSource.RepoAt.String())

appview/repo/repo.go

···
 		return
 	}
 
-	err = db.SubscribeLabel(tx, &db.RepoLabel{
+	err = db.SubscribeLabel(tx, &models.RepoLabel{
 		RepoAt:  f.RepoAt(),
 		LabelAt: label.AtUri(),
 	})
···
 		},
 	})
 
-	err = db.SubscribeLabel(rp.db, &db.RepoLabel{
+	err = db.SubscribeLabel(rp.db, &models.RepoLabel{
 		RepoAt:  f.RepoAt(),
 		LabelAt: syntax.ATURI(labelAt),
 	})
···
 
 		// create an atproto record for this fork
 		rkey := tid.TID()
-		repo := &db.Repo{
+		repo := &models.Repo{
 			Did:         user.Did,
 			Name:        forkName,
 			Knot:        targetKnot,

appview/reporesolver/resolver.go

···
 	"github.com/go-chi/chi/v5"
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
 	"tangled.org/core/appview/pages/repoinfo"
···
 )
 
 type ResolvedRepo struct {
-	db.Repo
+	models.Repo
 	OwnerId    identity.Identity
 	CurrentDir string
 	Ref        string
···
 }
 
 func (rr *RepoResolver) Resolve(r *http.Request) (*ResolvedRepo, error) {
-	repo, ok := r.Context().Value("repo").(*db.Repo)
+	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")
···
 		log.Println("failed to get repo source for ", repoAt, err)
 	}
 
-	var sourceRepo *db.Repo
+	var sourceRepo *models.Repo
 	if source != "" {
 		sourceRepo, err = db.GetRepoByAtUri(f.rr.execer, source)
 		if err != nil {
···
 		Knot:        knot,
 		Spindle:     f.Spindle,
 		Roles:       f.RolesInRepo(user),
-		Stats: db.RepoStats{
+		Stats: models.RepoStats{
 			StarCount:  starCount,
 			IssueCount: issueCount,
 			PullCount:  pullCount,

appview/spindles/spindles.go

···
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
 	"tangled.org/core/appview/middleware"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
 	"tangled.org/core/appview/serververify"
···
 	}
 
 	// organize repos by did
-	repoMap := make(map[string][]db.Repo)
+	repoMap := make(map[string][]models.Repo)
 	for _, r := range repos {
 		repoMap[r.Did] = append(repoMap[r.Did], r)
 	}

appview/state/git_http.go

···
 
 	"github.com/bluesky-social/indigo/atproto/identity"
 	"github.com/go-chi/chi/v5"
-	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 )
 
 func (s *State) InfoRefs(w http.ResponseWriter, r *http.Request) {
 	user := r.Context().Value("resolvedId").(identity.Identity)
-	repo := r.Context().Value("repo").(*db.Repo)
+	repo := r.Context().Value("repo").(*models.Repo)
 
 	scheme := "https"
 	if s.config.Core.Dev {
···
 		http.Error(w, "failed to resolve user", http.StatusInternalServerError)
 		return
 	}
-	repo := r.Context().Value("repo").(*db.Repo)
+	repo := r.Context().Value("repo").(*models.Repo)
 
 	scheme := "https"
 	if s.config.Core.Dev {
···
 		http.Error(w, "failed to resolve user", http.StatusInternalServerError)
 		return
 	}
-	repo := r.Context().Value("repo").(*db.Repo)
+	repo := r.Context().Value("repo").(*models.Repo)
 
 	scheme := "https"
 	if s.config.Core.Dev {

appview/state/profile.go

···
 	}
 
 	// filter out ones that are pinned
-	pinnedRepos := []db.Repo{}
+	pinnedRepos := []models.Repo{}
 	for i, r := range repos {
 		// if this is a pinned repo, add it
 		if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {
···
 		l.Error("failed to fetch collaborating repos", "err", err)
 	}
 
-	pinnedCollaboratingRepos := []db.Repo{}
+	pinnedCollaboratingRepos := []models.Repo{}
 	for _, r := range collaboratingRepos {
 		// if this is a pinned repo, add it
 		if slices.Contains(profile.Profile.PinnedRepos[:], r.RepoAt()) {

appview/state/star.go

···
 	lexutil "github.com/bluesky-social/indigo/lex/util"
 	"tangled.org/core/api/tangled"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/pages"
 	"tangled.org/core/tid"
 )
···
 		s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{
 			IsStarred: true,
 			RepoAt:    subjectUri,
-			Stats: db.RepoStats{
+			Stats: models.RepoStats{
 				StarCount: starCount,
 			},
 		})
···
 		s.pages.RepoStarFragment(w, pages.RepoStarFragmentParams{
 			IsStarred: false,
 			RepoAt:    subjectUri,
-			Stats: db.RepoStats{
+			Stats: models.RepoStats{
 				StarCount: starCount,
 			},
 		})

appview/state/state.go

···
 	"tangled.org/core/appview/cache/session"
 	"tangled.org/core/appview/config"
 	"tangled.org/core/appview/db"
+	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/notify"
 	"tangled.org/core/appview/oauth"
 	"tangled.org/core/appview/pages"
···
 	tlog "tangled.org/core/log"
 	"tangled.org/core/rbac"
 	"tangled.org/core/tid"
-	// xrpcerr "tangled.org/core/xrpc/errors"
 )
 
 type State struct {
···
 
 		// create atproto record for this repo
 		rkey := tid.TID()
-		repo := &db.Repo{
+		repo := &models.Repo{
 			Did:         user.Did,
 			Name:        repoName,
 			Knot:        domain,