appview/db: split star subjects

- rename `starred_by_did` column to `did`
- rename `repo_at` column to `subject_at` and removed foreign key
constraints.
- rename `RepoAt` field to `SubjectAt`
- remove `Repo` field and split `models.Star` to `RepoStar` and
`StringStar` as now there can be two kinds of reverse mappings.

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

appview/db/db.go

···
 		-- indexes for better performance
 		create index if not exists idx_notifications_recipient_created on notifications(recipient_did, created desc);
 		create index if not exists idx_notifications_recipient_read on notifications(recipient_did, read);
-		create index if not exists idx_stars_created on stars(created);
-		create index if not exists idx_stars_repo_at_created on stars(repo_at, created);
 	`)
 	if err != nil {
 		return nil, err
···
 	runMigration(conn, logger, "add-usermentioned-preference", func(tx *sql.Tx) error {
 		_, err := tx.Exec(`
 			alter table notification_preferences add column user_mentioned integer not null default 1;
+		`)
+		return err
+	})
+
+	// remove the foreign key constraints from stars.
+	runMigration(conn, logger, "generalize-stars-subject", func(tx *sql.Tx) error {
+		_, err := tx.Exec(`
+			create table stars_new (
+				id integer primary key autoincrement,
+				did text not null,
+				rkey text not null,
+
+				subject_at text not null,
+
+				created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')),
+				unique(did, rkey),
+				unique(did, subject_at)
+			);
+
+			insert into stars_new (
+				id,
+				did,
+				rkey,
+				subject_at,
+				created
+			)
+			select
+				id,
+				starred_by_did,
+				rkey,
+				repo_at,
+				created
+			from stars;
+
+			drop table stars;
+			alter table stars_new rename to stars;
+
+			create index if not exists idx_stars_created on stars(created);
+			create index if not exists idx_stars_subject_at_created on stars(subject_at, created);
 		`)
 		return err
 	})

appview/db/repos.go

···
 
 	starCountQuery := fmt.Sprintf(
 		`select
-			repo_at, count(1)
+			subject_at, count(1)
 		from stars
-		where repo_at in (%s)
-		group by repo_at`,
+		where subject_at in (%s)
+		group by subject_at`,
 		inClause,
 	)
 	rows, err = e.Query(starCountQuery, args...)

appview/db/star.go

···
 )
 
 func AddStar(e Execer, star *models.Star) error {
-	query := `insert or ignore into stars (starred_by_did, repo_at, rkey) values (?, ?, ?)`
+	query := `insert or ignore into stars (did, subject_at, rkey) values (?, ?, ?)`
 	_, err := e.Exec(
 		query,
-		star.StarredByDid,
+		star.Did,
 		star.RepoAt.String(),
 		star.Rkey,
 	)
···
 }
 
 // Get a star record
-func GetStar(e Execer, starredByDid string, repoAt syntax.ATURI) (*models.Star, error) {
+func GetStar(e Execer, did string, subjectAt syntax.ATURI) (*models.Star, error) {
 	query := `
-	select starred_by_did, repo_at, created, rkey
+	select did, subject_at, created, rkey
 	from stars
-	where starred_by_did = ? and repo_at = ?`
-	row := e.QueryRow(query, starredByDid, repoAt)
+	where did = ? and subject_at = ?`
+	row := e.QueryRow(query, did, subjectAt)
 
 	var star models.Star
 	var created string
-	err := row.Scan(&star.StarredByDid, &star.RepoAt, &created, &star.Rkey)
+	err := row.Scan(&star.Did, &star.RepoAt, &created, &star.Rkey)
 	if err != nil {
 		return nil, err
 	}
···
 }
 
 // Remove a star
-func DeleteStar(e Execer, starredByDid string, repoAt syntax.ATURI) error {
-	_, err := e.Exec(`delete from stars where starred_by_did = ? and repo_at = ?`, starredByDid, repoAt)
+func DeleteStar(e Execer, did string, subjectAt syntax.ATURI) error {
+	_, err := e.Exec(`delete from stars where did = ? and subject_at = ?`, did, subjectAt)
 	return err
 }
 
 // Remove a star
-func DeleteStarByRkey(e Execer, starredByDid string, rkey string) error {
-	_, err := e.Exec(`delete from stars where starred_by_did = ? and rkey = ?`, starredByDid, rkey)
+func DeleteStarByRkey(e Execer, did string, rkey string) error {
+	_, err := e.Exec(`delete from stars where did = ? and rkey = ?`, did, rkey)
 	return err
 }
 
-func GetStarCount(e Execer, repoAt syntax.ATURI) (int, error) {
+func GetStarCount(e Execer, subjectAt syntax.ATURI) (int, error) {
 	stars := 0
 	err := e.QueryRow(
-		`select count(starred_by_did) from stars where repo_at = ?`, repoAt).Scan(&stars)
+		`select count(did) from stars where subject_at = ?`, subjectAt).Scan(&stars)
 	if err != nil {
 		return 0, err
 	}
···
 	}
 
 	query := fmt.Sprintf(`
-		SELECT repo_at
+		SELECT subject_at
 		FROM stars
-		WHERE starred_by_did = ? AND repo_at IN (%s)
+		WHERE did = ? AND subject_at IN (%s)
 	`, strings.Join(placeholders, ","))
 
 	rows, err := e.Query(query, args...)
···
 	return result, nil
 }
 
-func GetStarStatus(e Execer, userDid string, repoAt syntax.ATURI) bool {
-	statuses, err := getStarStatuses(e, userDid, []syntax.ATURI{repoAt})
+func GetStarStatus(e Execer, userDid string, subjectAt syntax.ATURI) bool {
+	statuses, err := getStarStatuses(e, userDid, []syntax.ATURI{subjectAt})
 	if err != nil {
 		return false
 	}
-	return statuses[repoAt.String()]
+	return statuses[subjectAt.String()]
 }
 
 // GetStarStatuses returns a map of repo URIs to star status for a given user
-func GetStarStatuses(e Execer, userDid string, repoAts []syntax.ATURI) (map[string]bool, error) {
-	return getStarStatuses(e, userDid, repoAts)
+func GetStarStatuses(e Execer, userDid string, subjectAts []syntax.ATURI) (map[string]bool, error) {
+	return getStarStatuses(e, userDid, subjectAts)
 }
-func GetStars(e Execer, limit int, filters ...filter) ([]models.Star, error) {
+
+// GetRepoStars return a list of stars each holding target repository.
+// If there isn't known repo with starred at-uri, those stars will be ignored.
+func GetRepoStars(e Execer, limit int, filters ...filter) ([]models.RepoStar, error) {
 	var conditions []string
 	var args []any
 	for _, filter := range filters {
···
 	}
 
 	repoQuery := fmt.Sprintf(
-		`select starred_by_did, repo_at, created, rkey
+		`select did, subject_at, created, rkey
 		from stars
 		%s
 		order by created desc
···
 	for rows.Next() {
 		var star models.Star
 		var created string
-		err := rows.Scan(&star.StarredByDid, &star.RepoAt, &created, &star.Rkey)
+		err := rows.Scan(&star.Did, &star.RepoAt, &created, &star.Rkey)
 		if err != nil {
 			return nil, err
 		}
···
 		return nil, err
 	}
 
+	var repoStars []models.RepoStar
 	for _, r := range repos {
 		if stars, ok := starMap[string(r.RepoAt())]; ok {
-			for i := range stars {
-				stars[i].Repo = &r
+			for _, star := range stars {
+				repoStars = append(repoStars, models.RepoStar{
+					Star: star,
+					Repo: &r,
+				})
 			}
 		}
 	}
 
-	var stars []models.Star
-	for _, s := range starMap {
-		stars = append(stars, s...)
-	}
-
-	slices.SortFunc(stars, func(a, b models.Star) int {
+	slices.SortFunc(repoStars, func(a, b models.RepoStar) int {
 		if a.Created.After(b.Created) {
 			return -1
 		}
···
 		return 0
 	})
 
-	return stars, nil
+	return repoStars, nil
 }
 
 func CountStars(e Execer, filters ...filter) (int64, error) {
···
 	return count, nil
 }
 
-func GetAllStars(e Execer, limit int) ([]models.Star, error) {
-	var stars []models.Star
-
-	rows, err := e.Query(`
-		select
-			s.starred_by_did,
-			s.repo_at,
-			s.rkey,
-			s.created,
-			r.did,
-			r.name,
-			r.knot,
-			r.rkey,
-			r.created
-		from stars s
-		join repos r on s.repo_at = r.at_uri
-	`)
-
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var star models.Star
-		var repo models.Repo
-		var starCreatedAt, repoCreatedAt string
-
-		if err := rows.Scan(
-			&star.StarredByDid,
-			&star.RepoAt,
-			&star.Rkey,
-			&starCreatedAt,
-			&repo.Did,
-			&repo.Name,
-			&repo.Knot,
-			&repo.Rkey,
-			&repoCreatedAt,
-		); err != nil {
-			return nil, err
-		}
-
-		star.Created, err = time.Parse(time.RFC3339, starCreatedAt)
-		if err != nil {
-			star.Created = time.Now()
-		}
-		repo.Created, err = time.Parse(time.RFC3339, repoCreatedAt)
-		if err != nil {
-			repo.Created = time.Now()
-		}
-		star.Repo = &repo
-
-		stars = append(stars, star)
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-
-	return stars, nil
-}
-
 // GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week
 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 (
-			select distinct repo_at
+			select distinct subject_at
 			from stars
 			where created >= datetime('now', '-7 days')
 		),
 		repo_star_counts as (
 			select
-				s.repo_at,
+				s.subject_at,
 				count(*) as stars_gained_last_week
 			from stars s
-			join recent_starred_repos rsr on s.repo_at = rsr.repo_at
+			join recent_starred_repos rsr on s.subject_at = rsr.subject_at
 			where s.created >= datetime('now', '-7 days')
-			group by s.repo_at
+			group by s.subject_at
 		)
-		select rsc.repo_at
+		select rsc.subject_at
 		from repo_star_counts rsc
 		order by rsc.stars_gained_last_week desc
 		limit 8

appview/db/timeline.go

···
 func getTimelineStars(e Execer, limit int, loggedInUserDid string, userIsFollowing []string) ([]models.TimelineEvent, error) {
 	filters := make([]filter, 0)
 	if userIsFollowing != nil {
-		filters = append(filters, FilterIn("starred_by_did", userIsFollowing))
+		filters = append(filters, FilterIn("did", userIsFollowing))
 	}
 
-	stars, err := GetStars(e, limit, filters...)
+	stars, err := GetRepoStars(e, limit, filters...)
 	if err != nil {
 		return nil, err
 	}
 
-	// filter star records without a repo
-	n := 0
-	for _, s := range stars {
-		if s.Repo != nil {
-			stars[n] = s
-			n++
-		}
-	}
-	stars = stars[:n]
-
 	var repos []models.Repo
 	for _, s := range stars {
 		repos = append(repos, *s.Repo)
···
 		isStarred, starCount := getRepoStarInfo(s.Repo, starStatuses)
 
 		events = append(events, models.TimelineEvent{
-			Star:      &s,
+			RepoStar:  &s,
 			EventAt:   s.Created,
 			IsStarred: isStarred,
 			StarCount: starCount,

appview/ingester.go

···
 			return err
 		}
 		err = db.AddStar(i.Db, &models.Star{
-			StarredByDid: did,
-			RepoAt:       subjectUri,
-			Rkey:         e.Commit.RKey,
+			Did:    did,
+			RepoAt: subjectUri,
+			Rkey:   e.Commit.RKey,
 		})
 	case jmodels.CommitOperationDelete:
 		err = db.DeleteStarByRkey(i.Db, did, e.Commit.RKey)

appview/models/star.go

···
 )
 
 type Star struct {
-	StarredByDid string
-	RepoAt       syntax.ATURI
-	Created      time.Time
-	Rkey         string
+	Did     string
+	RepoAt  syntax.ATURI
+	Created time.Time
+	Rkey    string
+}
 
-	// optionally, populate this when querying for reverse mappings
+// RepoStar is used for reverse mapping to repos
+type RepoStar struct {
+	Star
 	Repo *Repo
 }
+
+// StringStar is used for reverse mapping to strings
+type StringStar struct {
+	Star
+	String *String
+}

appview/models/timeline.go

···
 type TimelineEvent struct {
 	*Repo
 	*Follow
-	*Star
+	*RepoStar
 
 	EventAt time.Time
 

appview/notify/db/db.go

···
 	"slices"
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
+	"tangled.org/core/api/tangled"
 	"tangled.org/core/appview/db"
 	"tangled.org/core/appview/models"
 	"tangled.org/core/appview/notify"
···
 }
 
 func (n *databaseNotifier) NewStar(ctx context.Context, star *models.Star) {
+	if star.RepoAt.Collection().String() != tangled.RepoNSID {
+		// skip string stars for now
+		return
+	}
 	var err error
 	repo, err := db.GetRepo(n.db, db.FilterEq("at_uri", string(star.RepoAt)))
 	if err != nil {
···
 		return
 	}
 
-	actorDid := syntax.DID(star.StarredByDid)
+	actorDid := syntax.DID(star.Did)
 	recipients := []syntax.DID{syntax.DID(repo.Did)}
 	eventType := models.NotificationTypeRepoStarred
 	entityType := "repo"

appview/notify/posthog/notifier.go

···
 
 func (n *posthogNotifier) NewStar(ctx context.Context, star *models.Star) {
 	err := n.client.Enqueue(posthog.Capture{
-		DistinctId: star.StarredByDid,
+		DistinctId: star.Did,
 		Event:      "star",
 		Properties: posthog.Properties{"repo_at": star.RepoAt.String()},
 	})
···
 
 func (n *posthogNotifier) DeleteStar(ctx context.Context, star *models.Star) {
 	err := n.client.Enqueue(posthog.Capture{
-		DistinctId: star.StarredByDid,
+		DistinctId: star.Did,
 		Event:      "unstar",
 		Properties: posthog.Properties{"repo_at": star.RepoAt.String()},
 	})

appview/pages/templates/timeline/fragments/timeline.html

···
 {{ define "timeline/fragments/starEvent" }}
   {{ $root := index . 0 }}
   {{ $event := index . 1 }}
-  {{ $star := $event.Star }}
+  {{ $star := $event.RepoStar }}
   {{ with $star }}
-    {{ $starrerHandle :=  resolve .StarredByDid }}
+    {{ $starrerHandle := resolve .Did }}
     {{ $repoOwnerHandle :=  resolve .Repo.Did }}
     <div class="pl-6 py-2 bg-white dark:bg-gray-800 text-gray-600 dark:text-gray-300 flex flex-wrap items-center gap-2 text-sm">
         {{ template "user/fragments/picHandleLink" $starrerHandle }}

appview/state/profile.go

···
 		return nil, fmt.Errorf("failed to get string count: %w", err)
 	}
 
-	starredCount, err := db.CountStars(s.db, db.FilterEq("starred_by_did", did))
+	starredCount, err := db.CountStars(s.db, db.FilterEq("did", did))
 	if err != nil {
 		return nil, fmt.Errorf("failed to get starred repo count: %w", err)
 	}
···
 	}
 	l = l.With("profileDid", profile.UserDid, "profileHandle", profile.UserHandle)
 
-	stars, err := db.GetStars(s.db, 0, db.FilterEq("starred_by_did", profile.UserDid))
+	stars, err := db.GetRepoStars(s.db, 0, db.FilterEq("did", profile.UserDid))
 	if err != nil {
 		l.Error("failed to get stars", "err", err)
 		s.pages.Error500(w)
···
 	}
 	var repos []models.Repo
 	for _, s := range stars {
-		if s.Repo != nil {
-			repos = append(repos, *s.Repo)
-		}
+		repos = append(repos, *s.Repo)
 	}
 
 	err = s.pages.ProfileStarred(w, pages.ProfileStarredParams{

appview/state/star.go

···
 		log.Println("created atproto record: ", resp.Uri)
 
 		star := &models.Star{
-			StarredByDid: currentUser.Did,
-			RepoAt:       subjectUri,
-			Rkey:         rkey,
+			Did:    currentUser.Did,
+			RepoAt: subjectUri,
+			Rkey:   rkey,
 		}
 
 		err = db.AddStar(s.db, star)