`142e85f`

Add profile activity and stars data

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 days ago

SHA: 142e85f42dc9ca77ee8893b54f0b1b89b1a2a2f3
Parents: 5381fe8
Tree: ed1824e

8 changed files

Status	File	+	-
M	`internal/issues/queries/issues.sql`	21	0
M	`internal/issues/sqlc/issues.sql.go`	86	0
M	`internal/issues/sqlc/querier.go`	4	0
M	`internal/social/queries/stars.sql`	4	1
M	`internal/social/sqlc/stars.sql.go`	6	1
M	`internal/web/handlers/profile/overview.go`	328	0
M	`internal/web/handlers/profile/profile_test.go`	108	1
M	`internal/web/handlers/profile/stars_tab.go`	206	37

internal/issues/queries/issues.sqlmodified

  WHERE issue_id = $1
  ORDER BY created_at ASC;
 +-- name: ListProfileAuthoredIssuesForUser :many
 +-- Cross-repository profile contribution activity. The handler performs the
 +-- final repo visibility gate with policy.IsVisibleTo so private issues and
 +-- PRs never leak through the public profile timeline.
 +SELECT
 +    i.id, i.repo_id, i.number, i.kind, i.title, i.state, i.created_at, i.closed_at,
 +    pr.merged_at,
 +    r.name AS repo_name, r.visibility, r.owner_user_id, r.owner_org_id,
 +    COALESCE(u.username, o.slug)::text AS owner_slug
 +FROM issues i
 +JOIN repos r ON r.id = i.repo_id
 +LEFT JOIN pull_requests pr ON pr.issue_id = i.id
 +LEFT JOIN users u ON u.id = r.owner_user_id
 +LEFT JOIN orgs o ON o.id = r.owner_org_id
 +WHERE i.author_user_id = $1
 +  AND i.created_at >= $2
 +  AND i.created_at < $3
 +  AND r.deleted_at IS NULL
 +ORDER BY i.created_at DESC, i.id DESC
 +LIMIT $4;
++
  -- name: InsertIssueReference :exec
  INSERT INTO issue_references (
      source_issue_id, target_issue_id, source_kind, source_object_id

internal/issues/sqlc/issues.sql.gomodified

  	return items, nil
+ }
 +const listProfileAuthoredIssuesForUser = `-- name: ListProfileAuthoredIssuesForUser :many
 +SELECT
 +    i.id, i.repo_id, i.number, i.kind, i.title, i.state, i.created_at, i.closed_at,
 +    pr.merged_at,
 +    r.name AS repo_name, r.visibility, r.owner_user_id, r.owner_org_id,
 +    COALESCE(u.username, o.slug)::text AS owner_slug
 +FROM issues i
 +JOIN repos r ON r.id = i.repo_id
 +LEFT JOIN pull_requests pr ON pr.issue_id = i.id
 +LEFT JOIN users u ON u.id = r.owner_user_id
 +LEFT JOIN orgs o ON o.id = r.owner_org_id
 +WHERE i.author_user_id = $1
 +  AND i.created_at >= $2
 +  AND i.created_at < $3
 +  AND r.deleted_at IS NULL
 +ORDER BY i.created_at DESC, i.id DESC
 +LIMIT $4
 +`
++
 +type ListProfileAuthoredIssuesForUserParams struct {
 +	AuthorUserID pgtype.Int8
 +	CreatedAt    pgtype.Timestamptz
 +	CreatedAt_2  pgtype.Timestamptz
 +	Limit        int32
 +}
++
 +type ListProfileAuthoredIssuesForUserRow struct {
 +	ID          int64
 +	RepoID      int64
 +	Number      int64
 +	Kind        IssueKind
 +	Title       string
 +	State       IssueState
 +	CreatedAt   pgtype.Timestamptz
 +	ClosedAt    pgtype.Timestamptz
 +	MergedAt    pgtype.Timestamptz
 +	RepoName    string
 +	Visibility  RepoVisibility
 +	OwnerUserID pgtype.Int8
 +	OwnerOrgID  pgtype.Int8
 +	OwnerSlug   string
 +}
++
 +// Cross-repository profile contribution activity. The handler performs the
 +// final repo visibility gate with policy.IsVisibleTo so private issues and
 +// PRs never leak through the public profile timeline.
 +func (q *Queries) ListProfileAuthoredIssuesForUser(ctx context.Context, db DBTX, arg ListProfileAuthoredIssuesForUserParams) ([]ListProfileAuthoredIssuesForUserRow, error) {
 +	rows, err := db.Query(ctx, listProfileAuthoredIssuesForUser,
 +		arg.AuthorUserID,
 +		arg.CreatedAt,
 +		arg.CreatedAt_2,
 +		arg.Limit,
 +	)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListProfileAuthoredIssuesForUserRow{}
 +	for rows.Next() {
 +		var i ListProfileAuthoredIssuesForUserRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.RepoID,
 +			&i.Number,
 +			&i.Kind,
 +			&i.Title,
 +			&i.State,
 +			&i.CreatedAt,
 +			&i.ClosedAt,
 +			&i.MergedAt,
 +			&i.RepoName,
 +			&i.Visibility,
 +			&i.OwnerUserID,
 +			&i.OwnerOrgID,
 +			&i.OwnerSlug,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
  const milestoneIssueCounts = `-- name: MilestoneIssueCounts :one
  SELECT
      count(*) FILTER (WHERE state = 'open')::int   AS open_count,

internal/issues/sqlc/querier.gomodified

  	ListLabels(ctx context.Context, db DBTX, repoID int64) ([]Label, error)
  	ListLabelsOnIssue(ctx context.Context, db DBTX, issueID int64) ([]Label, error)
  	ListMilestones(ctx context.Context, db DBTX, repoID int64) ([]Milestone, error)
 +	// Cross-repository profile contribution activity. The handler performs the
 +	// final repo visibility gate with policy.IsVisibleTo so private issues and
 +	// PRs never leak through the public profile timeline.
 +	ListProfileAuthoredIssuesForUser(ctx context.Context, db DBTX, arg ListProfileAuthoredIssuesForUserParams) ([]ListProfileAuthoredIssuesForUserRow, error)
  	// Open + closed counts for the milestone progress bar.
  	MilestoneIssueCounts(ctx context.Context, db DBTX, milestoneID pgtype.Int8) (MilestoneIssueCountsRow, error)
  	RemoveIssueLabel(ctx context.Context, db DBTX, arg RemoveIssueLabelParams) error

internal/web/handlers/profile/overview.gomodified

  	"io"
  	"net/url"
  	"path"
 +	"sort"
  	"strconv"
  	"strings"
  	"time"
  	"golang.org/x/net/html"
  	"github.com/tenseleyFlow/shithub/internal/auth/policy"
 +	issuesdb "github.com/tenseleyFlow/shithub/internal/issues/sqlc"
  	mdrender "github.com/tenseleyFlow/shithub/internal/markdown"
  	orgsdb "github.com/tenseleyFlow/shithub/internal/orgs/sqlc"
  	repogit "github.com/tenseleyFlow/shithub/internal/repos/git"
  	profileContribRepoLimit  = 500
  	profileContribMaxPerRepo = 5000
  	profileReadmeMaxBytes    = 1 * 1024 * 1024
 +	profileActivityMonths    = 1
 +	profileActivityIssueRows = 1000
+ )
  type profileOrgBadge struct {
  	MonthRepoCount              int
  	HasRepositoryData           bool
  	IncludePrivateContributions bool
 +	Activity                    []profileActivityMonth
 +	HasMoreActivity             bool
+ }
  type contributionYear struct {
  	IsInWindow bool
+ }
 +type profileActivityMonth struct {
 +	Label           string
 +	Items           []profileActivityItem
 +	InitiallyHidden bool
 +}
++
 +type profileActivityItem struct {
 +	Kind    string
 +	Icon    string
 +	Summary string
 +	Total   int
 +	Repos   []profileActivityRepo
 +}
++
 +type profileActivityRepo struct {
 +	FullName      string
 +	URL           string
 +	Count         int
 +	CountLabel    string
 +	Language      string
 +	LanguageColor template.CSS
 +	DateLabel     string
 +	StateCounts   []profileActivityStateCount
 +}
++
 +type profileActivityStateCount struct {
 +	Label string
 +	Class string
 +	Count int
 +}
++
  type profileContributionRepo struct {
  	Repo                  reposdb.Repo
  	OwnerSlug             string
  	windowEnd := windowEndDay.Add(24 * time.Hour)
  	activityMonth := time.Date(windowEndDay.Year(), windowEndDay.Month(), 1, 0, 0, 0, 0, time.UTC)
  	repos := h.profileContributionRepos(ctx, user, viewer, user.IncludePrivateContributions)
 +	activity := newProfileActivityBuilder()
  	counts := map[string]int{}
  	reposWithMonthActivity := map[int64]struct{}{}
+ 				}
  				key := day.Format("2006-01-02")
  				counts[key]++
 +				activity.addCommit(day, source)
  				if day.Year() == activityMonth.Year() && day.Month() == activityMonth.Month() {
  					reposWithMonthActivity[source.Repo.ID] = struct{}{}
+ 				}
+ 			}
+ 		}
+ 	}
 +	for _, source := range repos {
 +		created := source.Repo.CreatedAt.Time.UTC()
 +		if !source.Repo.CreatedAt.Valid || created.Before(windowStart) || !created.Before(windowEnd) {
 +			continue
 +		}
 +		if source.Repo.OwnerUserID.Int64 != user.ID || source.Repo.Visibility != reposdb.RepoVisibilityPublic {
 +			continue
 +		}
 +		activity.addCreatedRepo(created, source)
 +	}
 +	h.addProfileThreadActivity(ctx, user, viewer, windowStart, windowEnd, activity)
  	weeks := make([]contributionWeek, 0, weekCount)
  	total := 0
  		MonthRepoCount:              len(reposWithMonthActivity),
  		HasRepositoryData:           h.d.RepoFS != nil && len(repos) > 0,
  		IncludePrivateContributions: user.IncludePrivateContributions,
 +		Activity:                    activity.months(profileActivityMonths),
 +		HasMoreActivity:             activity.hasMore(profileActivityMonths),
 +	}
 +}
++
 +type profileActivityEvent struct {
 +	Kind      string
 +	When      time.Time
 +	FullName  string
 +	URL       string
 +	Language  string
 +	IsPrivate bool
 +	State     string
 +}
++
 +type profileActivityBuilder struct {
 +	events []profileActivityEvent
 +}
++
 +func newProfileActivityBuilder() *profileActivityBuilder {
 +	return &profileActivityBuilder{events: make([]profileActivityEvent, 0, 64)}
 +}
++
 +func (b *profileActivityBuilder) addCommit(day time.Time, source profileContributionRepo) {
 +	isPrivate := source.Repo.Visibility == reposdb.RepoVisibilityPrivate
 +	fullName := source.OwnerSlug + "/" + source.Repo.Name
 +	url := "/" + url.PathEscape(source.OwnerSlug) + "/" + url.PathEscape(source.Repo.Name)
 +	if isPrivate {
 +		fullName = "Private repositories"
 +		url = ""
 +	}
 +	b.events = append(b.events, profileActivityEvent{
 +		Kind:      "commits",
 +		When:      day,
 +		FullName:  fullName,
 +		URL:       url,
 +		Language:  pgTextStringOrEmpty(source.Repo.PrimaryLanguage),
 +		IsPrivate: isPrivate,
 +	})
 +}
++
 +func (b *profileActivityBuilder) addCreatedRepo(day time.Time, source profileContributionRepo) {
 +	b.events = append(b.events, profileActivityEvent{
 +		Kind:     "repos",
 +		When:     day,
 +		FullName: source.OwnerSlug + "/" + source.Repo.Name,
 +		URL:      "/" + url.PathEscape(source.OwnerSlug) + "/" + url.PathEscape(source.Repo.Name),
 +		Language: pgTextStringOrEmpty(source.Repo.PrimaryLanguage),
 +	})
 +}
++
 +func (b *profileActivityBuilder) addThread(day time.Time, kind, ownerSlug, repoName, state string) {
 +	b.events = append(b.events, profileActivityEvent{
 +		Kind:     kind,
 +		When:     day,
 +		FullName: ownerSlug + "/" + repoName,
 +		URL:      "/" + url.PathEscape(ownerSlug) + "/" + url.PathEscape(repoName),
 +		State:    state,
 +	})
 +}
++
 +func (b *profileActivityBuilder) hasMore(initialMonths int) bool {
 +	return len(b.monthKeys()) > initialMonths
 +}
++
 +func (b *profileActivityBuilder) months(initialMonths int) []profileActivityMonth {
 +	keys := b.monthKeys()
 +	byMonth := map[string]map[string]map[string]*profileActivityRepo{}
 +	monthTimes := map[string]time.Time{}
 +	for _, event := range b.events {
 +		month := time.Date(event.When.UTC().Year(), event.When.UTC().Month(), 1, 0, 0, 0, 0, time.UTC)
 +		key := month.Format("2006-01")
 +		monthTimes[key] = month
 +		if byMonth[key] == nil {
 +			byMonth[key] = map[string]map[string]*profileActivityRepo{}
 +		}
 +		if byMonth[key][event.Kind] == nil {
 +			byMonth[key][event.Kind] = map[string]*profileActivityRepo{}
 +		}
 +		repoKey := event.FullName
 +		if event.IsPrivate {
 +			repoKey = "__private__"
 +		}
 +		repo := byMonth[key][event.Kind][repoKey]
 +		if repo == nil {
 +			language := event.Language
 +			if event.IsPrivate {
 +				language = ""
 +			}
 +			repo = &profileActivityRepo{
 +				FullName:      event.FullName,
 +				URL:           event.URL,
 +				Language:      language,
 +				LanguageColor: template.CSS(orgLanguageColor(language)), //nolint:gosec // server-side constant map.
 +			}
 +			byMonth[key][event.Kind][repoKey] = repo
 +		}
 +		repo.Count++
 +		if event.Kind == "repos" {
 +			repo.DateLabel = event.When.UTC().Format("Jan 2")
 +		}
 +		if event.State != "" {
 +			incrementActivityState(repo, event.State)
 +		}
 +	}
++
 +	out := make([]profileActivityMonth, 0, len(keys))
 +	for i, key := range keys {
 +		kindRepos := byMonth[key]
 +		items := make([]profileActivityItem, 0, len(kindRepos))
 +		for _, kind := range []string{"commits", "repos", "pulls", "issues"} {
 +			repos, ok := kindRepos[kind]
 +			if !ok {
 +				continue
 +			}
 +			item := profileActivityItem{
 +				Kind:  kind,
 +				Icon:  profileActivityIcon(kind),
 +				Repos: sortedActivityRepos(kind, repos),
 +			}
 +			for _, repo := range repos {
 +				item.Total += repo.Count
 +			}
 +			item.Summary = profileActivitySummary(kind, item.Total, len(repos))
 +			items = append(items, item)
 +		}
 +		out = append(out, profileActivityMonth{
 +			Label:           monthTimes[key].Format("January 2006"),
 +			Items:           items,
 +			InitiallyHidden: i >= initialMonths,
 +		})
 +	}
 +	return out
 +}
++
 +func (b *profileActivityBuilder) monthKeys() []string {
 +	seen := map[string]struct{}{}
 +	for _, event := range b.events {
 +		key := event.When.UTC().Format("2006-01")
 +		seen[key] = struct{}{}
 +	}
 +	keys := make([]string, 0, len(seen))
 +	for key := range seen {
 +		keys = append(keys, key)
 +	}
 +	sort.Sort(sort.Reverse(sort.StringSlice(keys)))
 +	return keys
 +}
++
 +func incrementActivityState(repo *profileActivityRepo, state string) {
 +	for i := range repo.StateCounts {
 +		if repo.StateCounts[i].Class == state {
 +			repo.StateCounts[i].Count++
 +			return
 +		}
 +	}
 +	repo.StateCounts = append(repo.StateCounts, profileActivityStateCount{
 +		Label: state,
 +		Class: state,
 +		Count: 1,
 +	})
 +}
++
 +func sortedActivityRepos(kind string, repos map[string]*profileActivityRepo) []profileActivityRepo {
 +	out := make([]profileActivityRepo, 0, len(repos))
 +	for _, repo := range repos {
 +		if kind == "commits" {
 +			repo.CountLabel = pluralizeCount(repo.Count, "commit", "commits")
 +		}
 +		sort.SliceStable(repo.StateCounts, func(i, j int) bool {
 +			return activityStateOrder(repo.StateCounts[i].Class) < activityStateOrder(repo.StateCounts[j].Class)
 +		})
 +		out = append(out, *repo)
 +	}
 +	sort.SliceStable(out, func(i, j int) bool {
 +		if kind == "repos" && out[i].DateLabel != out[j].DateLabel {
 +			return out[i].DateLabel > out[j].DateLabel
 +		}
 +		if out[i].Count != out[j].Count {
 +			return out[i].Count > out[j].Count
 +		}
 +		return out[i].FullName < out[j].FullName
 +	})
 +	if len(out) > 5 {
 +		return out[:5]
 +	}
 +	return out
 +}
++
 +func activityStateOrder(state string) int {
 +	switch state {
 +	case "merged":
 +		return 0
 +	case "open":
 +		return 1
 +	case "closed":
 +		return 2
 +	default:
 +		return 3
 +	}
 +}
++
 +func profileActivityIcon(kind string) string {
 +	switch kind {
 +	case "commits":
 +		return "git-commit"
 +	case "pulls":
 +		return "git-pull-request"
 +	case "issues":
 +		return "issue-opened"
 +	default:
 +		return "repo"
 +	}
 +}
++
 +func profileActivitySummary(kind string, total, repoCount int) string {
 +	switch kind {
 +	case "commits":
 +		return "Created " + pluralizeCount(total, "commit", "commits") + " in " + pluralizeCount(repoCount, "repository", "repositories")
 +	case "repos":
 +		return "Created " + pluralizeCount(total, "repository", "repositories")
 +	case "pulls":
 +		return "Opened " + pluralizeCount(total, "pull request", "pull requests") + " in " + pluralizeCount(repoCount, "repository", "repositories")
 +	case "issues":
 +		return "Opened " + pluralizeCount(total, "issue", "issues") + " in " + pluralizeCount(repoCount, "repository", "repositories")
 +	default:
 +		return pluralizeCount(total, "contribution", "contributions")
 +	}
 +}
++
 +func pluralizeCount(count int, one, many string) string {
 +	if count == 1 {
 +		return "1 " + one
 +	}
 +	return strconv.Itoa(count) + " " + many
 +}
++
 +func (h *Handlers) addProfileThreadActivity(ctx context.Context, user usersdb.User, viewer middleware.CurrentUser, windowStart, windowEnd time.Time, activity *profileActivityBuilder) {
 +	rows, err := issuesdb.New().ListProfileAuthoredIssuesForUser(ctx, h.d.Pool, issuesdb.ListProfileAuthoredIssuesForUserParams{
 +		AuthorUserID: pgtype.Int8{Int64: user.ID, Valid: true},
 +		CreatedAt:    pgtype.Timestamptz{Time: windowStart, Valid: true},
 +		CreatedAt_2:  pgtype.Timestamptz{Time: windowEnd, Valid: true},
 +		Limit:        profileActivityIssueRows,
 +	})
 +	if err != nil {
 +		h.d.Logger.WarnContext(ctx, "profile overview: list authored issues", "user_id", user.ID, "error", err)
 +		return
 +	}
 +	actor := policy.AnonymousActor()
 +	if !viewer.IsAnonymous() {
 +		actor = viewer.PolicyActor()
 +	}
 +	deps := policy.Deps{Pool: h.d.Pool}
 +	for _, row := range rows {
 +		if row.Visibility == issuesdb.RepoVisibilityPrivate && !user.IncludePrivateContributions {
 +			continue
 +		}
 +		ref := policy.RepoRef{
 +			ID:          row.RepoID,
 +			OwnerUserID: row.OwnerUserID.Int64,
 +			OwnerOrgID:  row.OwnerOrgID.Int64,
 +			Visibility:  string(row.Visibility),
 +		}
 +		if !policy.IsVisibleTo(ctx, deps, actor, ref) {
 +			continue
 +		}
 +		kind := "issues"
 +		state := "open"
 +		if row.State == issuesdb.IssueStateClosed {
 +			state = "closed"
 +		}
 +		if row.Kind == issuesdb.IssueKindPr {
 +			kind = "pulls"
 +			if row.MergedAt.Valid {
 +				state = "merged"
 +			}
 +		}
 +		activity.addThread(row.CreatedAt.Time, kind, row.OwnerSlug, row.RepoName, state)
+ 	}
+ }

internal/web/handlers/profile/profile_test.gomodified

  	tmplFS := fstest.MapFS{
  		"_layout.html":             {Data: []byte(`{{ define "layout" }}<html><head><title>{{ .Title }}</title></head><body>{{ template "page" . }}</body></html>{{ end }}`)},
  		"hello.html":               {Data: []byte(`{{ define "page" }}home{{ end }}`)},
 -		"profile/view.html":        {Data: []byte(`{{ define "page" }}USER={{.User.Username}} DISPLAY={{.User.DisplayName}}{{ if .IsSelf }} SELF=1{{ end }}{{ if .IsFollowing }} FOLLOWING=1{{ end }} FOLLOWERS={{.FollowersCount}} FOLLOWINGCOUNT={{.FollowingCount}} BIO={{.User.Bio}} VISIBLE={{.VisibleRepoCount}} ORGS={{len .Orgs}} README={{.HasProfileReadme}} CONTRIB={{.Contributions.Total}} PERIOD={{.Contributions.Period}} PRIVATE={{.Contributions.IncludePrivateContributions}} WEEKS={{len .Contributions.Weeks}} YEARS={{len .Contributions.Years}} YEARLINKS={{range .Contributions.Years}}{{.Year}}:{{.Active}}:{{.Href}};{{end}} PINS={{len .PinnedRepos}} PINNAMES={{range .PinnedRepos}}{{.Name}};{{end}} CANDIDATES={{len .PinCandidates}} CANDIDATENAMES={{range .PinCandidates}}{{.OwnerSlug}}/{{.Name}};{{end}} SELECTED={{range .PinCandidates}}{{if .IsPinned}}{{.Name}};{{end}}{{end}}{{ if .CanCustomizePins }} CUSTOMIZE=1 ACTION={{.ContributionSettingsAction}} RETURN={{.ContributionSettingsReturn}}{{ end }}{{ end }}`)},
 +		"profile/view.html":        {Data: []byte(`{{ define "page" }}USER={{.User.Username}} DISPLAY={{.User.DisplayName}}{{ if .IsSelf }} SELF=1{{ end }}{{ if .IsFollowing }} FOLLOWING=1{{ end }} FOLLOWERS={{.FollowersCount}} FOLLOWINGCOUNT={{.FollowingCount}} BIO={{.User.Bio}} VISIBLE={{.VisibleRepoCount}} ORGS={{len .Orgs}} README={{.HasProfileReadme}} CONTRIB={{.Contributions.Total}} PERIOD={{.Contributions.Period}} PRIVATE={{.Contributions.IncludePrivateContributions}} WEEKS={{len .Contributions.Weeks}} YEARS={{len .Contributions.Years}} YEARLINKS={{range .Contributions.Years}}{{.Year}}:{{.Active}}:{{.Href}};{{end}} ACTIVITY={{len .Contributions.Activity}} HASMORE={{.Contributions.HasMoreActivity}} ACTIVITYITEMS={{range .Contributions.Activity}}{{.Label}}:{{range .Items}}{{.Kind}}={{.Total}}/{{len .Repos}};{{end}}{{end}} PINS={{len .PinnedRepos}} PINNAMES={{range .PinnedRepos}}{{.Name}};{{end}} CANDIDATES={{len .PinCandidates}} CANDIDATENAMES={{range .PinCandidates}}{{.OwnerSlug}}/{{.Name}};{{end}} SELECTED={{range .PinCandidates}}{{if .IsPinned}}{{.Name}};{{end}}{{end}}{{ if .CanCustomizePins }} CUSTOMIZE=1 ACTION={{.ContributionSettingsAction}} RETURN={{.ContributionSettingsReturn}}{{ end }}{{ end }}`)},
  		"profile/follows_tab.html": {Data: []byte(`{{ define "page" }}FOLLOWTAB={{.ActiveTab}} USER={{.User.Username}} TOTAL={{len .Items}} ITEMS={{range .Items}}{{.Kind}}:{{.Username}};{{end}}{{ end }}`)},
 +		"profile/stars_tab.html":   {Data: []byte(`{{ define "page" }}STARSTAB={{.ActiveTab}} USER={{.User.Username}} DISPLAY={{.DisplayName}} TOTAL={{.StarTotal}} FILTERED={{.FilteredCount}} PAGE={{.Page}} HASNEXT={{.HasNext}} HASPREV={{.HasPrev}} STARS={{len .Stars}} ITEMS={{range .Stars}}{{.OwnerName}}/{{.RepoName}}:{{.PrimaryLanguage}}:{{.StarCount}};{{end}} LANGS={{range .LanguageOptions}}{{.}};{{end}} FILTERS={{.StarFilters.Query}}/{{.StarFilters.Type}}/{{.StarFilters.Language}}/{{.StarFilters.Sort}}{{ end }}`)},
  		"profile/suspended.html":   {Data: []byte(`{{ define "page" }}SUSPENDED={{.Username}}{{ end }}`)},
  		"orgs/profile.html":        {Data: []byte(`{{ define "page" }}ORG={{.Org.Slug}}{{ if .IsFollowing }} FOLLOWING=1{{ end }} FOLLOWERS={{.FollowerCount}} REPOS={{len .Repos}} PINS={{len .PinnedRepos}} PINNAMES={{range .PinnedRepos}}{{.Name}};{{end}} CANDIDATES={{len .PinCandidates}} SELECTED={{range .PinCandidates}}{{if .IsPinned}}{{.Name}};{{end}}{{end}} MEMBERS={{.MemberCount}} PEOPLE={{len .People}} NAMES={{range .Repos}}{{.Name}};{{end}} LANGS={{range .TopLanguages}}{{.Name}}={{.Count}};{{end}} TOPICS={{range .TopTopics}}{{.Name}}={{.Count}};{{end}} VIEWAS={{.ViewAs}}{{ if .CanCustomizePins }} CUSTOMIZE=1{{ end }}{{ end }}`)},
  		"orgs/repositories.html":   {Data: []byte(`{{ define "page" }}ORGREPOS={{.Org.Slug}} ACTIVE={{.ActiveOrgNav}} TOTAL={{.RepoCount}} FILTERED={{.FilteredCount}} PAGE={{.Page}}/{{.PageCount}} TYPE={{.SelectedType}} LANG={{.SelectedLanguage}} SORT={{.SelectedSort}} PREV={{.PrevHref}} NEXT={{.NextHref}} NAMES={{range .Repos}}{{.Name}};{{end}}{{range .PaginationPages}} P{{.Number}}={{.Current}}{{end}}{{ end }}`)},
+ 	}
+ }
 +func (e *profileEnv) insertStar(t *testing.T, userID, repoID int64, when time.Time) {
 +	t.Helper()
 +	if _, err := e.pool.Exec(context.Background(),
 +		`INSERT INTO stars (user_id, repo_id, starred_at) VALUES ($1, $2, $3)`,
 +		userID, repoID, when); err != nil {
 +		t.Fatalf("insert star: %v", err)
 +	}
 +}
++
 +func (e *profileEnv) insertIssue(t *testing.T, repoID, authorID, number int64, kind, state, title string, when time.Time) int64 {
 +	t.Helper()
 +	var issueID int64
 +	if err := e.pool.QueryRow(context.Background(),
 +		`INSERT INTO issues (repo_id, number, kind, title, author_user_id, state, created_at, updated_at)
 +		 VALUES ($1, $2, $3, $4, $5, $6, $7, $7)
 +		 RETURNING id`,
 +		repoID, number, kind, title, authorID, state, when).Scan(&issueID); err != nil {
 +		t.Fatalf("insert issue: %v", err)
 +	}
 +	return issueID
 +}
++
 +func (e *profileEnv) insertPullRequest(t *testing.T, issueID, repoID int64, mergedAt *time.Time) {
 +	t.Helper()
 +	var merged any
 +	if mergedAt != nil {
 +		merged = *mergedAt
 +	}
 +	if _, err := e.pool.Exec(context.Background(),
 +		`INSERT INTO pull_requests (issue_id, base_ref, head_ref, head_repo_id, base_oid, head_oid, merged_at)
 +		 VALUES ($1, 'trunk', 'feature/profile-activity', $2, 'base', 'head', $3)`,
 +		issueID, repoID, merged); err != nil {
 +		t.Fatalf("insert pull request: %v", err)
 +	}
 +}
++
  func (e *profileEnv) writeInitialCommit(t *testing.T, owner, repoName, authorName, authorEmail string, when time.Time) string {
  	t.Helper()
  	if e.repoFS == nil {
+ 	}
+ }
 +func TestProfile_ContributionActivityIncludesCommitsReposIssuesAndPulls(t *testing.T) {
 +	t.Parallel()
 +	env := setupProfileEnvWithRepoFS(t)
 +	alice := env.insertUser(t, "alice", "Alice Anderson", "")
 +	env.insertVerifiedEmail(t, alice.ID, "alice@example.com")
 +	currentRepoID := env.insertUserRepo(t, alice.ID, "current", "current work", "public", "Go", 0, 0)
 +	oldRepoID := env.insertUserRepo(t, alice.ID, "archive", "older work", "public", "Rust", 0, 0)
++
 +	now := time.Now().UTC()
 +	env.writeInitialCommit(t, "alice", "current", "Alice Anderson", "alice@example.com", now.AddDate(0, 0, -1))
 +	env.writeInitialCommit(t, "alice", "archive", "Alice Anderson", "alice@example.com", now.AddDate(0, -2, 0))
 +	env.insertIssue(t, currentRepoID, alice.ID, 1, "issue", "open", "Track profile activity", now.AddDate(0, 0, -3))
 +	prID := env.insertIssue(t, currentRepoID, alice.ID, 2, "pr", "closed", "Ship profile activity", now.AddDate(0, 0, -2))
 +	mergedAt := now.AddDate(0, 0, -1)
 +	env.insertPullRequest(t, prID, currentRepoID, &mergedAt)
++
 +	body := env.getAs(t, "/alice", alice)
 +	for _, want := range []string{
 +		"CONTRIB=2",
 +		"HASMORE=true",
 +		"commits=",
 +		"repos=",
 +		"issues=1/1",
 +		"pulls=1/1",
 +	} {
 +		if !strings.Contains(body, want) {
 +			t.Errorf("missing %q in body: %s", want, body)
 +		}
 +	}
 +	if strings.Contains(body, strconv.FormatInt(oldRepoID, 10)) {
 +		t.Fatalf("test template leaked implementation ids unexpectedly: %s", body)
 +	}
 +}
++
  func TestProfile_PrivateContributionsRequireOwnerOptIn(t *testing.T) {
  	t.Parallel()
  	env := setupProfileEnvWithRepoFS(t)
+ 	}
+ }
 +func TestProfile_StarsTabUsesProfileLayoutFiltersAndOrgOwners(t *testing.T) {
 +	t.Parallel()
 +	env := setupProfileEnv(t)
 +	alice := env.insertUser(t, "alice", "Alice Anderson", "")
 +	orgID := env.insertOrg(t, "acme", "Acme", "", alice)
 +	orgRepoID := env.insertOrgRepo(t, orgID, "org-tool", "org owned work", "public", "Go", 7, 0)
 +	userRepoID := env.insertUserRepo(t, alice.ID, "personal", "personal library", "public", "Rust", 2, 0)
 +	privateRepoID := env.insertUserRepo(t, alice.ID, "secret", "private work", "private", "Go", 10, 0)
++
 +	now := time.Now().UTC()
 +	env.insertStar(t, alice.ID, userRepoID, now.AddDate(0, 0, -3))
 +	env.insertStar(t, alice.ID, orgRepoID, now.AddDate(0, 0, -2))
 +	env.insertStar(t, alice.ID, privateRepoID, now.AddDate(0, 0, -1))
++
 +	body := env.getAs(t, "/alice?tab=stars&q=org&language=Go&sort=stars", usersdb.User{})
 +	for _, want := range []string{
 +		"STARSTAB=stars",
 +		"DISPLAY=Alice Anderson",
 +		"TOTAL=2",
 +		"FILTERED=1",
 +		"STARS=1",
 +		"ITEMS=acme/org-tool:Go:8;",
 +		"LANGS=Go;Rust;",
 +		"FILTERS=org/all/Go/stars",
 +	} {
 +		if !strings.Contains(body, want) {
 +			t.Fatalf("missing %q in body: %s", want, body)
 +		}
 +	}
 +	for _, notWant := range []string{"personal", "secret"} {
 +		if strings.Contains(body, notWant) {
 +			t.Fatalf("stars filter included %q unexpectedly: %s", notWant, body)
 +		}
 +	}
 +}
++
  func TestProfile_OrgPinsFallbackUntilCustomized(t *testing.T) {
  	t.Parallel()
  	env := setupProfileEnv(t)

internal/web/handlers/profile/stars_tab.gomodified

  import (
  	"fmt"
 +	"html/template"
  	"net/http"
  	"net/url"
 +	"sort"
  	"strconv"
 +	"strings"
 +	"time"
  	"github.com/jackc/pgx/v5/pgtype"
  	"github.com/tenseleyFlow/shithub/internal/web/middleware"
+ )
 -const starsTabPageSize = 30
 +const (
 +	starsTabPageSize  = 30
 +	starsTabScanLimit = 1000
 +)
++
 +type profileStarFilters struct {
 +	Query    string
 +	Type     string
 +	Language string
 +	Sort     string
 +}
++
 +type profileStarItem struct {
 +	OwnerName       string
 +	RepoName        string
 +	FullName        string
 +	URL             string
 +	Description     string
 +	Visibility      string
 +	IsPrivate       bool
 +	StarCount       int64
 +	PrimaryLanguage string
 +	LanguageColor   template.CSS
 +	UpdatedAt       time.Time
 +	StarredAt       time.Time
 +}
  // serveStarsTab renders the `/{user}?tab=stars` view.
  //
  	if page < 1 {
  		page = 1
+ 	}
 +	filters := profileStarFilters{
 +		Query:    strings.TrimSpace(r.URL.Query().Get("q")),
 +		Type:     normalizeStarType(r.URL.Query().Get("type")),
 +		Language: strings.TrimSpace(r.URL.Query().Get("language")),
 +		Sort:     normalizeStarSort(r.URL.Query().Get("sort")),
 +	}
 -	// We over-fetch a little so the per-row visibility filter can
 -	// drop private-repo rows without leaving a short page. With most
 -	// stars being public this is a no-op; for users with many private
 -	// stars the filter just trims more.
 -	const fetch = starsTabPageSize * 2
  	rows, err := socialdb.New().ListStarsForUser(r.Context(), h.d.Pool, socialdb.ListStarsForUserParams{
  		UserID: user.ID,
 -		Limit:  fetch,
 -		Offset: int32((page - 1) * starsTabPageSize),
 +		Limit:  starsTabScanLimit,
 +		Offset: 0,
  	})
  	if err != nil {
  		h.d.Logger.ErrorContext(r.Context(), "stars tab: list", "error", err)
+ 	}
  	deps := policy.Deps{Pool: h.d.Pool}
 -	visible := make([]map[string]any, 0, len(rows))
 +	visible := make([]profileStarItem, 0, len(rows))
  	for _, row := range rows {
 -		if len(visible) >= starsTabPageSize {
 -			break
 -		}
  		// Re-check visibility per row. Star is on a repo that may have
  		// flipped visibility between star-time and view-time.
  		ref := policy.RepoRef{
  		if !policy.IsVisibleTo(r.Context(), deps, actor, ref) {
  			continue
+ 		}
 -		// Resolve the owner's username for the link. The S31 org case
 -		// adds an org-username path; for now user-owned only.
 -		ownerName := ""
 -		if row.OwnerUserID.Valid {
 -			if u, err := h.q.GetUserByID(r.Context(), h.d.Pool, row.OwnerUserID.Int64); err == nil {
 -				ownerName = u.Username
 -			}
 +		ownerName := row.OwnerSlug
 +		if ownerName == "" {
 +			continue
+ 		}
 -		visible = append(visible, map[string]any{
 -			"OwnerName":       ownerName,
 -			"RepoName":        row.RepoName,
 -			"Description":     row.Description,
 -			"Visibility":      string(row.Visibility),
 -			"StarCount":       row.StarCount,
 -			"PrimaryLanguage": pgTextStringOrEmpty(row.PrimaryLanguage),
 -			"StarredAt":       row.StarredAt.Time,
 +		language := pgTextStringOrEmpty(row.PrimaryLanguage)
 +		visible = append(visible, profileStarItem{
 +			OwnerName:       ownerName,
 +			RepoName:        row.RepoName,
 +			FullName:        ownerName + "/" + row.RepoName,
 +			URL:             "/" + url.PathEscape(ownerName) + "/" + url.PathEscape(row.RepoName),
 +			Description:     row.Description,
 +			Visibility:      string(row.Visibility),
 +			IsPrivate:       row.Visibility == socialdb.RepoVisibilityPrivate,
 +			StarCount:       row.StarCount,
 +			PrimaryLanguage: language,
 +			LanguageColor:   template.CSS(orgLanguageColor(language)), //nolint:gosec // server-side constant map.
 +			UpdatedAt:       row.UpdatedAt.Time,
 +			StarredAt:       row.StarredAt.Time,
  		})
+ 	}
 +	languageOptions := starLanguageOptions(visible)
 +	filtered := filterProfileStars(visible, filters)
 +	sortProfileStars(filtered, filters.Sort)
 +	totalFiltered := len(filtered)
 +	start := (page - 1) * starsTabPageSize
 +	if start > totalFiltered {
 +		start = totalFiltered
 +	}
 +	end := start + starsTabPageSize
 +	if end > totalFiltered {
 +		end = totalFiltered
 +	}
 +	paged := filtered[start:end]
++
  	if isSelf {
  		w.Header().Set("Cache-Control", "no-cache, private")
  	} else {
+ 	}
  	avatarURL := fmt.Sprintf("/avatars/%s", url.PathEscape(user.Username))
 +	displayName := user.DisplayName
 +	if displayName == "" {
 +		displayName = user.Username
 +	}
 +	followState := h.userFollowState(r.Context(), user.ID, viewer)
  	tabs := h.tabCounts(r.Context(), user.ID, viewer)
  	data := map[string]any{
 -		"Title":     "Stars · " + user.DisplayName,
 -		"User":      user,
 -		"IsSelf":    isSelf,
 -		"AvatarURL": avatarURL,
 -		"Stars":     visible,
 -		"Page":      page,
 -		"HasNext":   len(visible) >= starsTabPageSize,
 -		"HasPrev":   page > 1,
 -		"Tabs":      tabs,
 -		"ActiveTab": "stars",
 +		"Title":            "Stars · " + displayName,
 +		"User":             user,
 +		"DisplayName":      displayName,
 +		"IsSelf":           isSelf,
 +		"AvatarURL":        avatarURL,
 +		"JoinedFormatted":  user.CreatedAt.Time.Format("January 2, 2006"),
 +		"WebsiteSafe":      safeWebsite(user.Website),
 +		"FollowersCount":   followState.FollowersCount,
 +		"FollowingCount":   followState.FollowingCount,
 +		"Orgs":             h.profileOrganizations(r.Context(), user.ID),
 +		"Stars":            paged,
 +		"StarTotal":        len(visible),
 +		"FilteredCount":    totalFiltered,
 +		"LanguageOptions":  languageOptions,
 +		"StarFilters":      filters,
 +		"Page":             page,
 +		"HasNext":          end < totalFiltered,
 +		"HasPrev":          page > 1,
 +		"NextHref":         starsPageHref(user.Username, r.URL.Query(), page+1),
 +		"PrevHref":         starsPageHref(user.Username, r.URL.Query(), page-1),
 +		"Tabs":             tabs,
 +		"ActiveTab":        "stars",
 +		"StarsSearchLabel": starsSearchLabel(filters),
+ 	}
  	w.Header().Set("Content-Type", "text/html; charset=utf-8")
  	if err := h.d.Render.RenderPage(w, r, "profile/stars_tab", data); err != nil {
+ 	}
+ }
 +func normalizeStarType(raw string) string {
 +	switch strings.ToLower(strings.TrimSpace(raw)) {
 +	case "public", "private":
 +		return strings.ToLower(strings.TrimSpace(raw))
 +	default:
 +		return "all"
 +	}
 +}
++
 +func normalizeStarSort(raw string) string {
 +	switch strings.ToLower(strings.TrimSpace(raw)) {
 +	case "recently-active", "stars":
 +		return strings.ToLower(strings.TrimSpace(raw))
 +	default:
 +		return "recently-starred"
 +	}
 +}
++
 +func starLanguageOptions(items []profileStarItem) []string {
 +	seen := map[string]struct{}{}
 +	for _, item := range items {
 +		if item.PrimaryLanguage != "" {
 +			seen[item.PrimaryLanguage] = struct{}{}
 +		}
 +	}
 +	out := make([]string, 0, len(seen))
 +	for language := range seen {
 +		out = append(out, language)
 +	}
 +	sort.Strings(out)
 +	return out
 +}
++
 +func filterProfileStars(items []profileStarItem, filters profileStarFilters) []profileStarItem {
 +	query := strings.ToLower(filters.Query)
 +	out := make([]profileStarItem, 0, len(items))
 +	for _, item := range items {
 +		if filters.Type == "public" && item.IsPrivate {
 +			continue
 +		}
 +		if filters.Type == "private" && !item.IsPrivate {
 +			continue
 +		}
 +		if filters.Language != "" && item.PrimaryLanguage != filters.Language {
 +			continue
 +		}
 +		if query != "" && !strings.Contains(strings.ToLower(item.FullName+" "+item.Description+" "+item.PrimaryLanguage), query) {
 +			continue
 +		}
 +		out = append(out, item)
 +	}
 +	return out
 +}
++
 +func sortProfileStars(items []profileStarItem, sortMode string) {
 +	sort.SliceStable(items, func(i, j int) bool {
 +		switch sortMode {
 +		case "recently-active":
 +			if !items[i].UpdatedAt.Equal(items[j].UpdatedAt) {
 +				return items[i].UpdatedAt.After(items[j].UpdatedAt)
 +			}
 +		case "stars":
 +			if items[i].StarCount != items[j].StarCount {
 +				return items[i].StarCount > items[j].StarCount
 +			}
 +		default:
 +			if !items[i].StarredAt.Equal(items[j].StarredAt) {
 +				return items[i].StarredAt.After(items[j].StarredAt)
 +			}
 +		}
 +		return items[i].FullName < items[j].FullName
 +	})
 +}
++
 +func starsPageHref(username string, values url.Values, page int) string {
 +	next := url.Values{}
 +	for key, vals := range values {
 +		if key == "page" {
 +			continue
 +		}
 +		for _, val := range vals {
 +			next.Add(key, val)
 +		}
 +	}
 +	next.Set("tab", "stars")
 +	if page > 1 {
 +		next.Set("page", strconv.Itoa(page))
 +	}
 +	return "/" + url.PathEscape(username) + "?" + next.Encode()
 +}
++
 +func starsSearchLabel(filters profileStarFilters) string {
 +	parts := make([]string, 0, 3)
 +	if filters.Query != "" {
 +		parts = append(parts, "matching "+filters.Query)
 +	}
 +	if filters.Type != "all" {
 +		parts = append(parts, filters.Type)
 +	}
 +	if filters.Language != "" {
 +		parts = append(parts, filters.Language)
 +	}
 +	if len(parts) == 0 {
 +		return "Starred repositories"
 +	}
 +	return "Starred repositories " + strings.Join(parts, ", ")
 +}
++
  // pgTextStringOrEmpty unwraps a nullable text column to "" when null.
  func pgTextStringOrEmpty(t pgtype.Text) string {
  	if !t.Valid {

  SELECT s.repo_id, s.starred_at,
         r.name AS repo_name, r.description, r.visibility,
         r.star_count, r.primary_language, r.updated_at,
 -       r.owner_user_id, r.owner_org_id
 +       r.owner_user_id, r.owner_org_id,
 +       COALESCE(u.username, o.slug)::text AS owner_slug
  FROM stars s
  JOIN repos r ON r.id = s.repo_id
 +LEFT JOIN users u ON u.id = r.owner_user_id
 +LEFT JOIN orgs o ON o.id = r.owner_org_id
  WHERE s.user_id = $1
    AND r.deleted_at IS NULL
  ORDER BY s.starred_at DESC