appview/db: split star subjects #824

merged
opened by boltless.me targeting master from sl/uzmtowmlwkvz

renamed starred_by_did column to did

remove foreign key constraints from repo_at column to support targetting non-ingested repository or sh.tangled.string. the column isn't renamed yet because I'm afraid to break somewhere with that rename. We really need some test code here.

Signed-off-by: Seongmin Lee git@boltless.me

Changed files
+118 -137
appview
db
models
notify
db
posthog
pages
templates
timeline
fragments
state
+39
appview/db/db.go
···
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
+
})
+
return &DB{
db,
logger,
+3 -3
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...)
+39 -99
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
+3 -13
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,
+3 -3
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)
+14 -5
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
+
}
+1 -1
appview/models/timeline.go
···
type TimelineEvent struct {
*Repo
*Follow
-
*Star
+
*RepoStar
EventAt time.Time
+6 -1
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"
+2 -2
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()},
})
+2 -2
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 }}
+3 -5
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{
+3 -3
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)