S26: socialdb sqlc bucket; extend repos SELECTs with star/watcher counts

Status	File	+	-
M	`internal/repos/queries/repos.sql`	8	4
M	`internal/repos/sqlc/models.go`	70	0
M	`internal/repos/sqlc/repos.sql.go`	16	4
A	`internal/social/queries/events.sql`	32	0
A	`internal/social/queries/stars.sql`	56	0
A	`internal/social/queries/watches.sql`	55	0
A	`internal/social/sqlc/db.go`	25	0
A	`internal/social/sqlc/events.sql.go`	155	0
C	`internal/social/sqlc/models.go`	0	0
A	`internal/social/sqlc/querier.go`	66	0
A	`internal/social/sqlc/stars.sql.go`	210	0
A	`internal/social/sqlc/watches.sql.go`	196	0
M	`sqlc.yaml`	16	0

internal/repos/queries/repos.sqlmodified

            default_branch, is_archived, archived_at, deleted_at,
            disk_used_bytes, fork_of_repo_id, license_key, primary_language,
            has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method;
++          allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++          star_count, watcher_count;
  -- name: GetRepoByID :one
  SELECT id, owner_user_id, owner_org_id, name, description, visibility,
         default_branch, is_archived, archived_at, deleted_at,
         disk_used_bytes, fork_of_repo_id, license_key, primary_language,
         has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method
++       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++       star_count, watcher_count
  FROM repos
  WHERE id = $1;
         default_branch, is_archived, archived_at, deleted_at,
         disk_used_bytes, fork_of_repo_id, license_key, primary_language,
         has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method
++       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++       star_count, watcher_count
  FROM repos
  WHERE owner_user_id = $1 AND name = $2 AND deleted_at IS NULL;
         default_branch, is_archived, archived_at, deleted_at,
         disk_used_bytes, fork_of_repo_id, license_key, primary_language,
         has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method
++       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++       star_count, watcher_count
  FROM repos
  WHERE owner_user_id = $1 AND deleted_at IS NULL
  ORDER BY updated_at DESC;

internal/repos/sqlc/models.gomodified

  	return string(ns.TransferStatus), nil
+ }
++type WatchLevel string
++
++const (
++	WatchLevelAll           WatchLevel = "all"
++	WatchLevelParticipating WatchLevel = "participating"
++	WatchLevelIgnore        WatchLevel = "ignore"
++)
++
++func (e *WatchLevel) Scan(src interface{}) error {
++	switch s := src.(type) {
++	case []byte:
++		*e = WatchLevel(s)
++	case string:
++		*e = WatchLevel(s)
++	default:
++		return fmt.Errorf("unsupported scan type for WatchLevel: %T", src)
++	}
++	return nil
++}
++
++type NullWatchLevel struct {
++	WatchLevel WatchLevel
++	Valid      bool // Valid is true if WatchLevel is not NULL
++}
++
++// Scan implements the Scanner interface.
++func (ns *NullWatchLevel) Scan(value interface{}) error {
++	if value == nil {
++		ns.WatchLevel, ns.Valid = "", false
++		return nil
++	}
++	ns.Valid = true
++	return ns.WatchLevel.Scan(value)
++}
++
++// Value implements the driver Valuer interface.
++func (ns NullWatchLevel) Value() (driver.Value, error) {
++	if !ns.Valid {
++		return nil, nil
++	}
++	return string(ns.WatchLevel), nil
++}
++
  type AuthAuditLog struct {
  	ID         int64
  	ActorID    pgtype.Int8
  	UpdatedAt  pgtype.Timestamptz
+ }
++type DomainEvent struct {
++	ID          int64
++	ActorUserID pgtype.Int8
++	Kind        string
++	RepoID      pgtype.Int8
++	SourceKind  string
++	SourceID    int64
++	Public      bool
++	Payload     []byte
++	CreatedAt   pgtype.Timestamptz
++}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	AllowRebaseMerge   bool
  	AllowMergeCommit   bool
  	DefaultMergeMethod PrMergeMethod
++	StarCount          int64
++	WatcherCount       int64
+ }
  type RepoCollaborator struct {
  	CanceledAt      pgtype.Timestamptz
+ }
++type Star struct {
++	UserID    int64
++	RepoID    int64
++	StarredAt pgtype.Timestamptz
++}
++
  type User struct {
  	ID                int64
  	Username          string
  	ChangedAt   pgtype.Timestamptz
+ }
++type Watch struct {
++	UserID    int64
++	RepoID    int64
++	Level     WatchLevel
++	UpdatedAt pgtype.Timestamptz
++}
++
  type WebhookEventsPending struct {
  	ID        int64
  	RepoID    int64

internal/repos/sqlc/repos.sql.gomodified

            default_branch, is_archived, archived_at, deleted_at,
            disk_used_bytes, fork_of_repo_id, license_key, primary_language,
            has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method
++          allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++          star_count, watcher_count
  `
  type CreateRepoParams struct {
  		&i.AllowRebaseMerge,
  		&i.AllowMergeCommit,
  		&i.DefaultMergeMethod,
++		&i.StarCount,
++		&i.WatcherCount,
  	)
  	return i, err
  }
         default_branch, is_archived, archived_at, deleted_at,
         disk_used_bytes, fork_of_repo_id, license_key, primary_language,
         has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method
++       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++       star_count, watcher_count
  FROM repos
  WHERE id = $1
  `
  		&i.AllowRebaseMerge,
  		&i.AllowMergeCommit,
  		&i.DefaultMergeMethod,
++		&i.StarCount,
++		&i.WatcherCount,
  	)
  	return i, err
  }
         default_branch, is_archived, archived_at, deleted_at,
         disk_used_bytes, fork_of_repo_id, license_key, primary_language,
         has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method
++       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++       star_count, watcher_count
  FROM repos
  WHERE owner_user_id = $1 AND name = $2 AND deleted_at IS NULL
  `
  		&i.AllowRebaseMerge,
  		&i.AllowMergeCommit,
  		&i.DefaultMergeMethod,
++		&i.StarCount,
++		&i.WatcherCount,
  	)
  	return i, err
  }
         default_branch, is_archived, archived_at, deleted_at,
         disk_used_bytes, fork_of_repo_id, license_key, primary_language,
         has_issues, has_pulls, created_at, updated_at, default_branch_oid,
--       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method
++       allow_squash_merge, allow_rebase_merge, allow_merge_commit, default_merge_method,
++       star_count, watcher_count
  FROM repos
  WHERE owner_user_id = $1 AND deleted_at IS NULL
  ORDER BY updated_at DESC
  			&i.AllowRebaseMerge,
  			&i.AllowMergeCommit,
  			&i.DefaultMergeMethod,
++			&i.StarCount,
++			&i.WatcherCount,
  		); err != nil {
  			return nil, err
  		}

internal/social/queries/events.sqladded

++-- ─── domain_events ─────────────────────────────────────────────────
++
++-- name: InsertDomainEvent :one
++-- Returns the inserted row so callers that want to fire a follow-on
++-- (e.g. NOTIFY for the worker pool) have the id without a re-read.
++INSERT INTO domain_events (
++    actor_user_id, kind, repo_id, source_kind, source_id, public, payload
++) VALUES (
++    $1, $2, $3, $4, $5, $6, $7
++)
++RETURNING id, actor_user_id, kind, repo_id, source_kind, source_id, public, payload, created_at;
++
++-- name: ListPublicEventsForActor :many
++-- Public activity-feed slice for a user's profile. Returns only
++-- public rows, recency-sorted. The handler additionally filters by
++-- repo visibility against the viewer (a public event row on a repo
++-- whose visibility flipped to private must not leak).
++SELECT id, actor_user_id, kind, repo_id, source_kind, source_id, public, payload, created_at
++FROM domain_events
++WHERE actor_user_id = $1
++  AND public = true
++ORDER BY created_at DESC
++LIMIT $2 OFFSET $3;
++
++-- name: ListEventsForRepo :many
++-- Repo-scoped events, recency-sorted. No visibility filter — the
++-- caller has already established read access to the repo.
++SELECT id, actor_user_id, kind, repo_id, source_kind, source_id, public, payload, created_at
++FROM domain_events
++WHERE repo_id = $1
++ORDER BY created_at DESC
++LIMIT $2 OFFSET $3;

internal/social/queries/stars.sqladded

++-- ─── stars ─────────────────────────────────────────────────────────
++
++-- name: InsertStar :exec
++-- ON CONFLICT DO NOTHING is the idempotency guard: re-starring an
++-- already-starred repo doesn't double-increment the count (the
++-- AFTER INSERT trigger only fires on actual insert).
++INSERT INTO stars (user_id, repo_id) VALUES ($1, $2)
++ON CONFLICT (user_id, repo_id) DO NOTHING;
++
++-- name: DeleteStar :exec
++DELETE FROM stars WHERE user_id = $1 AND repo_id = $2;
++
++-- name: HasStar :one
++SELECT EXISTS (
++    SELECT 1 FROM stars WHERE user_id = $1 AND repo_id = $2
++) AS has_star;
++
++-- name: ListStargazersForRepo :many
++-- Public-repo stargazer list. Paginated by `starred_at DESC`.
++-- Excludes suspended users so they don't taint public lists. The
++-- private-repo gate is at the handler layer (policy.IsVisibleTo).
++SELECT s.user_id, s.starred_at, u.username, u.display_name
++FROM stars s
++JOIN users u ON u.id = s.user_id
++WHERE s.repo_id = $1
++  AND u.suspended_at IS NULL
++ORDER BY s.starred_at DESC
++LIMIT $2 OFFSET $3;
++
++-- name: CountStargazersForRepo :one
++SELECT COUNT(*) FROM stars s
++JOIN users u ON u.id = s.user_id
++WHERE s.repo_id = $1
++  AND u.suspended_at IS NULL;
++
++-- name: ListStarsForUser :many
++-- The "Stars" profile tab. The handler layer post-filters for repo
++-- visibility against the viewer; this query returns everything the
++-- user starred and lets the handler decide what to render. Sort axis
++-- is the spec's day-1 lean: most-recently-starred first.
++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
++FROM stars s
++JOIN repos r ON r.id = s.repo_id
++WHERE s.user_id = $1
++  AND r.deleted_at IS NULL
++ORDER BY s.starred_at DESC
++LIMIT $2 OFFSET $3;
++
++-- name: CountStarsForUser :one
++SELECT COUNT(*) FROM stars s
++JOIN repos r ON r.id = s.repo_id
++WHERE s.user_id = $1
++  AND r.deleted_at IS NULL;

internal/social/queries/watches.sqladded

++-- ─── watches ───────────────────────────────────────────────────────
++
++-- name: GetWatch :one
++SELECT user_id, repo_id, level, updated_at
++FROM watches WHERE user_id = $1 AND repo_id = $2;
++
++-- name: UpsertWatch :exec
++-- Always-write upsert. The AFTER trigger handles the watcher_count
++-- delta on transition into / out of `ignore`.
++INSERT INTO watches (user_id, repo_id, level)
++VALUES ($1, $2, $3)
++ON CONFLICT (user_id, repo_id) DO UPDATE
++    SET level = EXCLUDED.level,
++        updated_at = now();
++
++-- name: InsertWatchIfAbsent :exec
++-- Auto-watch flow: only insert if the user doesn't already have a
++-- preference. ON CONFLICT DO NOTHING preserves the user's chosen
++-- level when the trigger fires repeatedly.
++INSERT INTO watches (user_id, repo_id, level)
++VALUES ($1, $2, $3)
++ON CONFLICT (user_id, repo_id) DO NOTHING;
++
++-- name: DeleteWatch :exec
++-- Used when a user unsets their explicit preference (returning to the
++-- implicit `participating` default). Trigger drops the watcher_count
++-- when the prior level wasn't 'ignore'.
++DELETE FROM watches WHERE user_id = $1 AND repo_id = $2;
++
++-- name: ListWatchersForRepo :many
++-- Watchers list. `level <> 'ignore'` excludes users who have actively
++-- muted the repo. Excludes suspended users from public surfaces.
++SELECT w.user_id, w.level, w.updated_at, u.username, u.display_name
++FROM watches w
++JOIN users u ON u.id = w.user_id
++WHERE w.repo_id = $1
++  AND w.level <> 'ignore'
++  AND u.suspended_at IS NULL
++ORDER BY w.updated_at DESC
++LIMIT $2 OFFSET $3;
++
++-- name: CountWatchersForRepo :one
++SELECT COUNT(*) FROM watches w
++JOIN users u ON u.id = w.user_id
++WHERE w.repo_id = $1
++  AND w.level <> 'ignore'
++  AND u.suspended_at IS NULL;
++
++-- name: ListRepoWatchersByLevel :many
++-- S29 notification-routing consumer: for fan-out, get every watcher
++-- of a repo at the requested level (e.g. `level='all'` for new-issue
++-- events). This is the cross-package read; expose the user_ids
++-- without joining users — fan-out adds the user join itself.
++SELECT user_id FROM watches
++WHERE repo_id = $1 AND level = $2;

internal/social/sqlc/db.goadded

++// Code generated by sqlc. DO NOT EDIT.
++// versions:
++//   sqlc v1.31.1
++
++package socialdb
++
++import (
++	"context"
++
++	"github.com/jackc/pgx/v5"
++	"github.com/jackc/pgx/v5/pgconn"
++)
++
++type DBTX interface {
++	Exec(context.Context, string, ...interface{}) (pgconn.CommandTag, error)
++	Query(context.Context, string, ...interface{}) (pgx.Rows, error)
++	QueryRow(context.Context, string, ...interface{}) pgx.Row
++}
++
++func New() *Queries {
++	return &Queries{}
++}
++
++type Queries struct {
++}

internal/social/sqlc/events.sql.goadded

++// Code generated by sqlc. DO NOT EDIT.
++// versions:
++//   sqlc v1.31.1
++// source: events.sql
++
++package socialdb
++
++import (
++	"context"
++
++	"github.com/jackc/pgx/v5/pgtype"
++)
++
++const insertDomainEvent = `-- name: InsertDomainEvent :one
++
++INSERT INTO domain_events (
++    actor_user_id, kind, repo_id, source_kind, source_id, public, payload
++) VALUES (
++    $1, $2, $3, $4, $5, $6, $7
++)
++RETURNING id, actor_user_id, kind, repo_id, source_kind, source_id, public, payload, created_at
++`
++
++type InsertDomainEventParams struct {
++	ActorUserID pgtype.Int8
++	Kind        string
++	RepoID      pgtype.Int8
++	SourceKind  string
++	SourceID    int64
++	Public      bool
++	Payload     []byte
++}
++
++// ─── domain_events ─────────────────────────────────────────────────
++// Returns the inserted row so callers that want to fire a follow-on
++// (e.g. NOTIFY for the worker pool) have the id without a re-read.
++func (q *Queries) InsertDomainEvent(ctx context.Context, db DBTX, arg InsertDomainEventParams) (DomainEvent, error) {
++	row := db.QueryRow(ctx, insertDomainEvent,
++		arg.ActorUserID,
++		arg.Kind,
++		arg.RepoID,
++		arg.SourceKind,
++		arg.SourceID,
++		arg.Public,
++		arg.Payload,
++	)
++	var i DomainEvent
++	err := row.Scan(
++		&i.ID,
++		&i.ActorUserID,
++		&i.Kind,
++		&i.RepoID,
++		&i.SourceKind,
++		&i.SourceID,
++		&i.Public,
++		&i.Payload,
++		&i.CreatedAt,
++	)
++	return i, err
++}
++
++const listEventsForRepo = `-- name: ListEventsForRepo :many
++SELECT id, actor_user_id, kind, repo_id, source_kind, source_id, public, payload, created_at
++FROM domain_events
++WHERE repo_id = $1
++ORDER BY created_at DESC
++LIMIT $2 OFFSET $3
++`
++
++type ListEventsForRepoParams struct {
++	RepoID pgtype.Int8
++	Limit  int32
++	Offset int32
++}
++
++// Repo-scoped events, recency-sorted. No visibility filter — the
++// caller has already established read access to the repo.
++func (q *Queries) ListEventsForRepo(ctx context.Context, db DBTX, arg ListEventsForRepoParams) ([]DomainEvent, error) {
++	rows, err := db.Query(ctx, listEventsForRepo, arg.RepoID, arg.Limit, arg.Offset)
++	if err != nil {
++		return nil, err
++	}
++	defer rows.Close()
++	items := []DomainEvent{}
++	for rows.Next() {
++		var i DomainEvent
++		if err := rows.Scan(
++			&i.ID,
++			&i.ActorUserID,
++			&i.Kind,
++			&i.RepoID,
++			&i.SourceKind,
++			&i.SourceID,
++			&i.Public,
++			&i.Payload,
++			&i.CreatedAt,
++		); err != nil {
++			return nil, err
++		}
++		items = append(items, i)
++	}
++	if err := rows.Err(); err != nil {
++		return nil, err
++	}
++	return items, nil
++}
++
++const listPublicEventsForActor = `-- name: ListPublicEventsForActor :many
++SELECT id, actor_user_id, kind, repo_id, source_kind, source_id, public, payload, created_at
++FROM domain_events
++WHERE actor_user_id = $1
++  AND public = true
++ORDER BY created_at DESC
++LIMIT $2 OFFSET $3
++`
++
++type ListPublicEventsForActorParams struct {
++	ActorUserID pgtype.Int8
++	Limit       int32
++	Offset      int32
++}
++
++// Public activity-feed slice for a user's profile. Returns only
++// public rows, recency-sorted. The handler additionally filters by
++// repo visibility against the viewer (a public event row on a repo
++// whose visibility flipped to private must not leak).
++func (q *Queries) ListPublicEventsForActor(ctx context.Context, db DBTX, arg ListPublicEventsForActorParams) ([]DomainEvent, error) {
++	rows, err := db.Query(ctx, listPublicEventsForActor, arg.ActorUserID, arg.Limit, arg.Offset)
++	if err != nil {
++		return nil, err
++	}
++	defer rows.Close()
++	items := []DomainEvent{}
++	for rows.Next() {
++		var i DomainEvent
++		if err := rows.Scan(
++			&i.ID,
++			&i.ActorUserID,
++			&i.Kind,
++			&i.RepoID,
++			&i.SourceKind,
++			&i.SourceID,
++			&i.Public,
++			&i.Payload,
++			&i.CreatedAt,
++		); err != nil {
++			return nil, err
++		}
++		items = append(items, i)
++	}
++	if err := rows.Err(); err != nil {
++		return nil, err
++	}
++	return items, nil
++}

internal/repos/sqlc/models.go → internal/social/sqlc/models.gocopied (95% similarity)

  // versions:
  //   sqlc v1.31.1
--package reposdb
++package socialdb
  import (
  	"database/sql/driver"
  	return string(ns.TransferStatus), nil
+ }
++type WatchLevel string
++
++const (
++	WatchLevelAll           WatchLevel = "all"
++	WatchLevelParticipating WatchLevel = "participating"
++	WatchLevelIgnore        WatchLevel = "ignore"
++)
++
++func (e *WatchLevel) Scan(src interface{}) error {
++	switch s := src.(type) {
++	case []byte:
++		*e = WatchLevel(s)
++	case string:
++		*e = WatchLevel(s)
++	default:
++		return fmt.Errorf("unsupported scan type for WatchLevel: %T", src)
++	}
++	return nil
++}
++
++type NullWatchLevel struct {
++	WatchLevel WatchLevel
++	Valid      bool // Valid is true if WatchLevel is not NULL
++}
++
++// Scan implements the Scanner interface.
++func (ns *NullWatchLevel) Scan(value interface{}) error {
++	if value == nil {
++		ns.WatchLevel, ns.Valid = "", false
++		return nil
++	}
++	ns.Valid = true
++	return ns.WatchLevel.Scan(value)
++}
++
++// Value implements the driver Valuer interface.
++func (ns NullWatchLevel) Value() (driver.Value, error) {
++	if !ns.Valid {
++		return nil, nil
++	}
++	return string(ns.WatchLevel), nil
++}
++
  type AuthAuditLog struct {
  	ID         int64
  	ActorID    pgtype.Int8
  	UpdatedAt  pgtype.Timestamptz
+ }
++type DomainEvent struct {
++	ID          int64
++	ActorUserID pgtype.Int8
++	Kind        string
++	RepoID      pgtype.Int8
++	SourceKind  string
++	SourceID    int64
++	Public      bool
++	Payload     []byte
++	CreatedAt   pgtype.Timestamptz
++}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	AllowRebaseMerge   bool
  	AllowMergeCommit   bool
  	DefaultMergeMethod PrMergeMethod
++	StarCount          int64
++	WatcherCount       int64
+ }
  type RepoCollaborator struct {
  	CanceledAt      pgtype.Timestamptz
+ }
++type Star struct {
++	UserID    int64
++	RepoID    int64
++	StarredAt pgtype.Timestamptz
++}
++
  type User struct {
  	ID                int64
  	Username          string
  	ChangedAt   pgtype.Timestamptz
+ }
++type Watch struct {
++	UserID    int64
++	RepoID    int64
++	Level     WatchLevel
++	UpdatedAt pgtype.Timestamptz
++}
++
  type WebhookEventsPending struct {
  	ID        int64
  	RepoID    int64

internal/social/sqlc/querier.goadded

++// Code generated by sqlc. DO NOT EDIT.
++// versions:
++//   sqlc v1.31.1
++
++package socialdb
++
++import (
++	"context"
++)
++
++type Querier interface {
++	CountStargazersForRepo(ctx context.Context, db DBTX, repoID int64) (int64, error)
++	CountStarsForUser(ctx context.Context, db DBTX, userID int64) (int64, error)
++	CountWatchersForRepo(ctx context.Context, db DBTX, repoID int64) (int64, error)
++	DeleteStar(ctx context.Context, db DBTX, arg DeleteStarParams) error
++	// Used when a user unsets their explicit preference (returning to the
++	// implicit `participating` default). Trigger drops the watcher_count
++	// when the prior level wasn't 'ignore'.
++	DeleteWatch(ctx context.Context, db DBTX, arg DeleteWatchParams) error
++	// ─── watches ───────────────────────────────────────────────────────
++	GetWatch(ctx context.Context, db DBTX, arg GetWatchParams) (Watch, error)
++	HasStar(ctx context.Context, db DBTX, arg HasStarParams) (bool, error)
++	// ─── domain_events ─────────────────────────────────────────────────
++	// Returns the inserted row so callers that want to fire a follow-on
++	// (e.g. NOTIFY for the worker pool) have the id without a re-read.
++	InsertDomainEvent(ctx context.Context, db DBTX, arg InsertDomainEventParams) (DomainEvent, error)
++	// ─── stars ─────────────────────────────────────────────────────────
++	// ON CONFLICT DO NOTHING is the idempotency guard: re-starring an
++	// already-starred repo doesn't double-increment the count (the
++	// AFTER INSERT trigger only fires on actual insert).
++	InsertStar(ctx context.Context, db DBTX, arg InsertStarParams) error
++	// Auto-watch flow: only insert if the user doesn't already have a
++	// preference. ON CONFLICT DO NOTHING preserves the user's chosen
++	// level when the trigger fires repeatedly.
++	InsertWatchIfAbsent(ctx context.Context, db DBTX, arg InsertWatchIfAbsentParams) error
++	// Repo-scoped events, recency-sorted. No visibility filter — the
++	// caller has already established read access to the repo.
++	ListEventsForRepo(ctx context.Context, db DBTX, arg ListEventsForRepoParams) ([]DomainEvent, error)
++	// Public activity-feed slice for a user's profile. Returns only
++	// public rows, recency-sorted. The handler additionally filters by
++	// repo visibility against the viewer (a public event row on a repo
++	// whose visibility flipped to private must not leak).
++	ListPublicEventsForActor(ctx context.Context, db DBTX, arg ListPublicEventsForActorParams) ([]DomainEvent, error)
++	// S29 notification-routing consumer: for fan-out, get every watcher
++	// of a repo at the requested level (e.g. `level='all'` for new-issue
++	// events). This is the cross-package read; expose the user_ids
++	// without joining users — fan-out adds the user join itself.
++	ListRepoWatchersByLevel(ctx context.Context, db DBTX, arg ListRepoWatchersByLevelParams) ([]int64, error)
++	// Public-repo stargazer list. Paginated by `starred_at DESC`.
++	// Excludes suspended users so they don't taint public lists. The
++	// private-repo gate is at the handler layer (policy.IsVisibleTo).
++	ListStargazersForRepo(ctx context.Context, db DBTX, arg ListStargazersForRepoParams) ([]ListStargazersForRepoRow, error)
++	// The "Stars" profile tab. The handler layer post-filters for repo
++	// visibility against the viewer; this query returns everything the
++	// user starred and lets the handler decide what to render. Sort axis
++	// is the spec's day-1 lean: most-recently-starred first.
++	ListStarsForUser(ctx context.Context, db DBTX, arg ListStarsForUserParams) ([]ListStarsForUserRow, error)
++	// Watchers list. `level <> 'ignore'` excludes users who have actively
++	// muted the repo. Excludes suspended users from public surfaces.
++	ListWatchersForRepo(ctx context.Context, db DBTX, arg ListWatchersForRepoParams) ([]ListWatchersForRepoRow, error)
++	// Always-write upsert. The AFTER trigger handles the watcher_count
++	// delta on transition into / out of `ignore`.
++	UpsertWatch(ctx context.Context, db DBTX, arg UpsertWatchParams) error
++}
++
++var _ Querier = (*Queries)(nil)

internal/social/sqlc/stars.sql.goadded

++// Code generated by sqlc. DO NOT EDIT.
++// versions:
++//   sqlc v1.31.1
++// source: stars.sql
++
++package socialdb
++
++import (
++	"context"
++
++	"github.com/jackc/pgx/v5/pgtype"
++)
++
++const countStargazersForRepo = `-- name: CountStargazersForRepo :one
++SELECT COUNT(*) FROM stars s
++JOIN users u ON u.id = s.user_id
++WHERE s.repo_id = $1
++  AND u.suspended_at IS NULL
++`
++
++func (q *Queries) CountStargazersForRepo(ctx context.Context, db DBTX, repoID int64) (int64, error) {
++	row := db.QueryRow(ctx, countStargazersForRepo, repoID)
++	var count int64
++	err := row.Scan(&count)
++	return count, err
++}
++
++const countStarsForUser = `-- name: CountStarsForUser :one
++SELECT COUNT(*) FROM stars s
++JOIN repos r ON r.id = s.repo_id
++WHERE s.user_id = $1
++  AND r.deleted_at IS NULL
++`
++
++func (q *Queries) CountStarsForUser(ctx context.Context, db DBTX, userID int64) (int64, error) {
++	row := db.QueryRow(ctx, countStarsForUser, userID)
++	var count int64
++	err := row.Scan(&count)
++	return count, err
++}
++
++const deleteStar = `-- name: DeleteStar :exec
++DELETE FROM stars WHERE user_id = $1 AND repo_id = $2
++`
++
++type DeleteStarParams struct {
++	UserID int64
++	RepoID int64
++}
++
++func (q *Queries) DeleteStar(ctx context.Context, db DBTX, arg DeleteStarParams) error {
++	_, err := db.Exec(ctx, deleteStar, arg.UserID, arg.RepoID)
++	return err
++}
++
++const hasStar = `-- name: HasStar :one
++SELECT EXISTS (
++    SELECT 1 FROM stars WHERE user_id = $1 AND repo_id = $2
++) AS has_star
++`
++
++type HasStarParams struct {
++	UserID int64
++	RepoID int64
++}
++
++func (q *Queries) HasStar(ctx context.Context, db DBTX, arg HasStarParams) (bool, error) {
++	row := db.QueryRow(ctx, hasStar, arg.UserID, arg.RepoID)
++	var has_star bool
++	err := row.Scan(&has_star)
++	return has_star, err
++}
++
++const insertStar = `-- name: InsertStar :exec
++
++INSERT INTO stars (user_id, repo_id) VALUES ($1, $2)
++ON CONFLICT (user_id, repo_id) DO NOTHING
++`
++
++type InsertStarParams struct {
++	UserID int64
++	RepoID int64
++}
++
++// ─── stars ─────────────────────────────────────────────────────────
++// ON CONFLICT DO NOTHING is the idempotency guard: re-starring an
++// already-starred repo doesn't double-increment the count (the
++// AFTER INSERT trigger only fires on actual insert).
++func (q *Queries) InsertStar(ctx context.Context, db DBTX, arg InsertStarParams) error {
++	_, err := db.Exec(ctx, insertStar, arg.UserID, arg.RepoID)
++	return err
++}
++
++const listStargazersForRepo = `-- name: ListStargazersForRepo :many
++SELECT s.user_id, s.starred_at, u.username, u.display_name
++FROM stars s
++JOIN users u ON u.id = s.user_id
++WHERE s.repo_id = $1
++  AND u.suspended_at IS NULL
++ORDER BY s.starred_at DESC
++LIMIT $2 OFFSET $3
++`
++
++type ListStargazersForRepoParams struct {
++	RepoID int64
++	Limit  int32
++	Offset int32
++}
++
++type ListStargazersForRepoRow struct {
++	UserID      int64
++	StarredAt   pgtype.Timestamptz
++	Username    string
++	DisplayName string
++}
++
++// Public-repo stargazer list. Paginated by `starred_at DESC`.
++// Excludes suspended users so they don't taint public lists. The
++// private-repo gate is at the handler layer (policy.IsVisibleTo).
++func (q *Queries) ListStargazersForRepo(ctx context.Context, db DBTX, arg ListStargazersForRepoParams) ([]ListStargazersForRepoRow, error) {
++	rows, err := db.Query(ctx, listStargazersForRepo, arg.RepoID, arg.Limit, arg.Offset)
++	if err != nil {
++		return nil, err
++	}
++	defer rows.Close()
++	items := []ListStargazersForRepoRow{}
++	for rows.Next() {
++		var i ListStargazersForRepoRow
++		if err := rows.Scan(
++			&i.UserID,
++			&i.StarredAt,
++			&i.Username,
++			&i.DisplayName,
++		); err != nil {
++			return nil, err
++		}
++		items = append(items, i)
++	}
++	if err := rows.Err(); err != nil {
++		return nil, err
++	}
++	return items, nil
++}
++
++const listStarsForUser = `-- name: ListStarsForUser :many
++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
++FROM stars s
++JOIN repos r ON r.id = s.repo_id
++WHERE s.user_id = $1
++  AND r.deleted_at IS NULL
++ORDER BY s.starred_at DESC
++LIMIT $2 OFFSET $3
++`
++
++type ListStarsForUserParams struct {
++	UserID int64
++	Limit  int32
++	Offset int32
++}
++
++type ListStarsForUserRow struct {
++	RepoID          int64
++	StarredAt       pgtype.Timestamptz
++	RepoName        string
++	Description     string
++	Visibility      RepoVisibility
++	StarCount       int64
++	PrimaryLanguage pgtype.Text
++	UpdatedAt       pgtype.Timestamptz
++	OwnerUserID     pgtype.Int8
++	OwnerOrgID      pgtype.Int8
++}
++
++// The "Stars" profile tab. The handler layer post-filters for repo
++// visibility against the viewer; this query returns everything the
++// user starred and lets the handler decide what to render. Sort axis
++// is the spec's day-1 lean: most-recently-starred first.
++func (q *Queries) ListStarsForUser(ctx context.Context, db DBTX, arg ListStarsForUserParams) ([]ListStarsForUserRow, error) {
++	rows, err := db.Query(ctx, listStarsForUser, arg.UserID, arg.Limit, arg.Offset)
++	if err != nil {
++		return nil, err
++	}
++	defer rows.Close()
++	items := []ListStarsForUserRow{}
++	for rows.Next() {
++		var i ListStarsForUserRow
++		if err := rows.Scan(
++			&i.RepoID,
++			&i.StarredAt,
++			&i.RepoName,
++			&i.Description,
++			&i.Visibility,
++			&i.StarCount,
++			&i.PrimaryLanguage,
++			&i.UpdatedAt,
++			&i.OwnerUserID,
++			&i.OwnerOrgID,
++		); err != nil {
++			return nil, err
++		}
++		items = append(items, i)
++	}
++	if err := rows.Err(); err != nil {
++		return nil, err
++	}
++	return items, nil
++}

internal/social/sqlc/watches.sql.goadded

++// Code generated by sqlc. DO NOT EDIT.
++// versions:
++//   sqlc v1.31.1
++// source: watches.sql
++
++package socialdb
++
++import (
++	"context"
++
++	"github.com/jackc/pgx/v5/pgtype"
++)
++
++const countWatchersForRepo = `-- name: CountWatchersForRepo :one
++SELECT COUNT(*) FROM watches w
++JOIN users u ON u.id = w.user_id
++WHERE w.repo_id = $1
++  AND w.level <> 'ignore'
++  AND u.suspended_at IS NULL
++`
++
++func (q *Queries) CountWatchersForRepo(ctx context.Context, db DBTX, repoID int64) (int64, error) {
++	row := db.QueryRow(ctx, countWatchersForRepo, repoID)
++	var count int64
++	err := row.Scan(&count)
++	return count, err
++}
++
++const deleteWatch = `-- name: DeleteWatch :exec
++DELETE FROM watches WHERE user_id = $1 AND repo_id = $2
++`
++
++type DeleteWatchParams struct {
++	UserID int64
++	RepoID int64
++}
++
++// Used when a user unsets their explicit preference (returning to the
++// implicit `participating` default). Trigger drops the watcher_count
++// when the prior level wasn't 'ignore'.
++func (q *Queries) DeleteWatch(ctx context.Context, db DBTX, arg DeleteWatchParams) error {
++	_, err := db.Exec(ctx, deleteWatch, arg.UserID, arg.RepoID)
++	return err
++}
++
++const getWatch = `-- name: GetWatch :one
++
++SELECT user_id, repo_id, level, updated_at
++FROM watches WHERE user_id = $1 AND repo_id = $2
++`
++
++type GetWatchParams struct {
++	UserID int64
++	RepoID int64
++}
++
++// ─── watches ───────────────────────────────────────────────────────
++func (q *Queries) GetWatch(ctx context.Context, db DBTX, arg GetWatchParams) (Watch, error) {
++	row := db.QueryRow(ctx, getWatch, arg.UserID, arg.RepoID)
++	var i Watch
++	err := row.Scan(
++		&i.UserID,
++		&i.RepoID,
++		&i.Level,
++		&i.UpdatedAt,
++	)
++	return i, err
++}
++
++const insertWatchIfAbsent = `-- name: InsertWatchIfAbsent :exec
++INSERT INTO watches (user_id, repo_id, level)
++VALUES ($1, $2, $3)
++ON CONFLICT (user_id, repo_id) DO NOTHING
++`
++
++type InsertWatchIfAbsentParams struct {
++	UserID int64
++	RepoID int64
++	Level  WatchLevel
++}
++
++// Auto-watch flow: only insert if the user doesn't already have a
++// preference. ON CONFLICT DO NOTHING preserves the user's chosen
++// level when the trigger fires repeatedly.
++func (q *Queries) InsertWatchIfAbsent(ctx context.Context, db DBTX, arg InsertWatchIfAbsentParams) error {
++	_, err := db.Exec(ctx, insertWatchIfAbsent, arg.UserID, arg.RepoID, arg.Level)
++	return err
++}
++
++const listRepoWatchersByLevel = `-- name: ListRepoWatchersByLevel :many
++SELECT user_id FROM watches
++WHERE repo_id = $1 AND level = $2
++`
++
++type ListRepoWatchersByLevelParams struct {
++	RepoID int64
++	Level  WatchLevel
++}
++
++// S29 notification-routing consumer: for fan-out, get every watcher
++// of a repo at the requested level (e.g. `level='all'` for new-issue
++// events). This is the cross-package read; expose the user_ids
++// without joining users — fan-out adds the user join itself.
++func (q *Queries) ListRepoWatchersByLevel(ctx context.Context, db DBTX, arg ListRepoWatchersByLevelParams) ([]int64, error) {
++	rows, err := db.Query(ctx, listRepoWatchersByLevel, arg.RepoID, arg.Level)
++	if err != nil {
++		return nil, err
++	}
++	defer rows.Close()
++	items := []int64{}
++	for rows.Next() {
++		var user_id int64
++		if err := rows.Scan(&user_id); err != nil {
++			return nil, err
++		}
++		items = append(items, user_id)
++	}
++	if err := rows.Err(); err != nil {
++		return nil, err
++	}
++	return items, nil
++}
++
++const listWatchersForRepo = `-- name: ListWatchersForRepo :many
++SELECT w.user_id, w.level, w.updated_at, u.username, u.display_name
++FROM watches w
++JOIN users u ON u.id = w.user_id
++WHERE w.repo_id = $1
++  AND w.level <> 'ignore'
++  AND u.suspended_at IS NULL
++ORDER BY w.updated_at DESC
++LIMIT $2 OFFSET $3
++`
++
++type ListWatchersForRepoParams struct {
++	RepoID int64
++	Limit  int32
++	Offset int32
++}
++
++type ListWatchersForRepoRow struct {
++	UserID      int64
++	Level       WatchLevel
++	UpdatedAt   pgtype.Timestamptz
++	Username    string
++	DisplayName string
++}
++
++// Watchers list. `level <> 'ignore'` excludes users who have actively
++// muted the repo. Excludes suspended users from public surfaces.
++func (q *Queries) ListWatchersForRepo(ctx context.Context, db DBTX, arg ListWatchersForRepoParams) ([]ListWatchersForRepoRow, error) {
++	rows, err := db.Query(ctx, listWatchersForRepo, arg.RepoID, arg.Limit, arg.Offset)
++	if err != nil {
++		return nil, err
++	}
++	defer rows.Close()
++	items := []ListWatchersForRepoRow{}
++	for rows.Next() {
++		var i ListWatchersForRepoRow
++		if err := rows.Scan(
++			&i.UserID,
++			&i.Level,
++			&i.UpdatedAt,
++			&i.Username,
++			&i.DisplayName,
++		); err != nil {
++			return nil, err
++		}
++		items = append(items, i)
++	}
++	if err := rows.Err(); err != nil {
++		return nil, err
++	}
++	return items, nil
++}
++
++const upsertWatch = `-- name: UpsertWatch :exec
++INSERT INTO watches (user_id, repo_id, level)
++VALUES ($1, $2, $3)
++ON CONFLICT (user_id, repo_id) DO UPDATE
++    SET level = EXCLUDED.level,
++        updated_at = now()
++`
++
++type UpsertWatchParams struct {
++	UserID int64
++	RepoID int64
++	Level  WatchLevel
++}
++
++// Always-write upsert. The AFTER trigger handles the watcher_count
++// delta on transition into / out of `ignore`.
++func (q *Queries) UpsertWatch(ctx context.Context, db DBTX, arg UpsertWatchParams) error {
++	_, err := db.Exec(ctx, upsertWatch, arg.UserID, arg.RepoID, arg.Level)
++	return err
++}

sqlc.yamlmodified

          emit_exact_table_names: false
          emit_empty_slices: true
          emit_methods_with_db_argument: true
++
++  - engine: postgresql
++    schema: internal/migrationsfs/migrations
++    queries: internal/social/queries
++    gen:
++      go:
++        package: socialdb
++        out: internal/social/sqlc
++        sql_package: pgx/v5
++        emit_json_tags: false
++        emit_pointers_for_null_types: false
++        emit_prepared_queries: false
++        emit_interface: true
++        emit_exact_table_names: false
++        emit_empty_slices: true
++        emit_methods_with_db_argument: true

tenseleyflow/shithub / `87c9ed8`

13 changed files