`a396715`

S21: issues migration 0022 + queries + sqlc regen

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

SHA: a3967159c7bd68a6795ca5548b0af15f1d5ed5d1
Parents: abcf5b8
Tree: 62f190d

12 changed files

Status	File	+
M	`internal/auth/policy/sqlc/models.go`	305
A	`internal/issues/queries/issues.sql`	214
A	`internal/issues/sqlc/db.go`	25
A	`internal/issues/sqlc/issues.sql.go`	973
C	`internal/issues/sqlc/models.go`	0
A	`internal/issues/sqlc/querier.go`	74
M	`internal/meta/sqlc/models.go`	305
A	`internal/migrationsfs/migrations/0022_issues.sql`	192
M	`internal/repos/sqlc/models.go`	305
M	`internal/users/sqlc/models.go`	305
M	`internal/worker/sqlc/models.go`	305
M	`sqlc.yaml`	16

internal/auth/policy/sqlc/models.gomodified

  	return string(ns.CollabRole), nil
+ }
 +type IssueKind string
++
 +const (
 +	IssueKindIssue IssueKind = "issue"
 +	IssueKindPr    IssueKind = "pr"
 +)
++
 +func (e *IssueKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueKind(s)
 +	case string:
 +		*e = IssueKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueKind struct {
 +	IssueKind IssueKind
 +	Valid     bool // Valid is true if IssueKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueKind), nil
 +}
++
 +type IssueRefSource string
++
 +const (
 +	IssueRefSourceCommentBody   IssueRefSource = "comment_body"
 +	IssueRefSourceIssueBody     IssueRefSource = "issue_body"
 +	IssueRefSourceCommitMessage IssueRefSource = "commit_message"
 +)
++
 +func (e *IssueRefSource) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueRefSource(s)
 +	case string:
 +		*e = IssueRefSource(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueRefSource: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueRefSource struct {
 +	IssueRefSource IssueRefSource
 +	Valid          bool // Valid is true if IssueRefSource is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueRefSource) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueRefSource, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueRefSource.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueRefSource) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueRefSource), nil
 +}
++
 +type IssueState string
++
 +const (
 +	IssueStateOpen   IssueState = "open"
 +	IssueStateClosed IssueState = "closed"
 +)
++
 +func (e *IssueState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueState(s)
 +	case string:
 +		*e = IssueState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueState struct {
 +	IssueState IssueState
 +	Valid      bool // Valid is true if IssueState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueState), nil
 +}
++
 +type IssueStateReason string
++
 +const (
 +	IssueStateReasonCompleted  IssueStateReason = "completed"
 +	IssueStateReasonNotPlanned IssueStateReason = "not_planned"
 +	IssueStateReasonReopened   IssueStateReason = "reopened"
 +	IssueStateReasonDuplicate  IssueStateReason = "duplicate"
 +)
++
 +func (e *IssueStateReason) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueStateReason(s)
 +	case string:
 +		*e = IssueStateReason(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueStateReason: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueStateReason struct {
 +	IssueStateReason IssueStateReason
 +	Valid            bool // Valid is true if IssueStateReason is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueStateReason) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueStateReason, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueStateReason.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueStateReason) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueStateReason), nil
 +}
++
 +type MilestoneState string
++
 +const (
 +	MilestoneStateOpen   MilestoneState = "open"
 +	MilestoneStateClosed MilestoneState = "closed"
 +)
++
 +func (e *MilestoneState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = MilestoneState(s)
 +	case string:
 +		*e = MilestoneState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for MilestoneState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullMilestoneState struct {
 +	MilestoneState MilestoneState
 +	Valid          bool // Valid is true if MilestoneState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullMilestoneState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.MilestoneState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.MilestoneState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullMilestoneState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.MilestoneState), nil
 +}
++
  type RepoVisibility string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Issue struct {
 +	ID                int64
 +	RepoID            int64
 +	Number            int64
 +	Kind              IssueKind
 +	Title             string
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	AuthorUserID      pgtype.Int8
 +	State             IssueState
 +	StateReason       NullIssueStateReason
 +	Locked            bool
 +	LockReason        pgtype.Text
 +	MilestoneID       pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +	ClosedAt          pgtype.Timestamptz
 +	ClosedByUserID    pgtype.Int8
 +}
++
 +type IssueAssignee struct {
 +	IssueID          int64
 +	UserID           int64
 +	AssignedAt       pgtype.Timestamptz
 +	AssignedByUserID pgtype.Int8
 +}
++
 +type IssueComment struct {
 +	ID                int64
 +	IssueID           int64
 +	AuthorUserID      pgtype.Int8
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type IssueEvent struct {
 +	ID          int64
 +	IssueID     int64
 +	ActorUserID pgtype.Int8
 +	Kind        string
 +	Meta        []byte
 +	RefTargetID pgtype.Int8
 +	CreatedAt   pgtype.Timestamptz
 +}
++
 +type IssueLabel struct {
 +	IssueID         int64
 +	LabelID         int64
 +	AppliedAt       pgtype.Timestamptz
 +	AppliedByUserID pgtype.Int8
 +}
++
 +type IssueReference struct {
 +	ID             int64
 +	SourceIssueID  pgtype.Int8
 +	TargetIssueID  int64
 +	SourceKind     IssueRefSource
 +	SourceObjectID pgtype.Int8
 +	CreatedAt      pgtype.Timestamptz
 +}
++
  type Job struct {
  	ID          int64
  	Kind        string
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Label struct {
 +	ID          int64
 +	RepoID      int64
 +	Name        string
 +	Color       string
 +	Description string
 +	CreatedAt   pgtype.Timestamptz
 +}
++
  type Meta struct {
  	Key       string
  	Value     []byte
  	UpdatedAt pgtype.Timestamptz
+ }
 +type Milestone struct {
 +	ID          int64
 +	RepoID      int64
 +	Title       string
 +	Description string
 +	State       MilestoneState
 +	DueOn       pgtype.Timestamptz
 +	CreatedAt   pgtype.Timestamptz
 +	ClosedAt    pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	AddedByUserID pgtype.Int8
+ }
 +type RepoIssueCounter struct {
 +	RepoID     int64
 +	NextNumber int64
 +}
++
  type RepoRedirect struct {
  	OldOwnerUserID pgtype.Int8
  	OldOwnerOrgID  pgtype.Int8

internal/issues/queries/issues.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
++
 +-- ─── per-repo numbering ───────────────────────────────────────────────
++
 +-- name: EnsureRepoIssueCounter :exec
 +-- Lazy-initialize the counter row. Idempotent — invoked from repo
 +-- create AND from the first issue insert (defensive in case someone
 +-- migrates an old repo that predates S21).
 +INSERT INTO repo_issue_counter (repo_id, next_number)
 +VALUES ($1, 1)
 +ON CONFLICT (repo_id) DO NOTHING;
++
 +-- name: AllocateIssueNumber :one
 +-- UPDATE … RETURNING is concurrency-safe: each row update is
 +-- serialized by the row lock; concurrent transactions see different
 +-- values. The caller wraps this in the same tx as the issue insert.
 +UPDATE repo_issue_counter
 +SET next_number = next_number + 1
 +WHERE repo_id = $1
 +RETURNING (next_number - 1)::bigint AS allocated;
++
++
 +-- ─── issues ──────────────────────────────────────────────────────────
++
 +-- name: CreateIssue :one
 +INSERT INTO issues (
 +    repo_id, number, kind, title, body, author_user_id
 +) VALUES (
 +    $1, $2, $3, $4, $5, sqlc.narg(author_user_id)::bigint
 +)
 +RETURNING *;
++
 +-- name: GetIssueByNumber :one
 +SELECT * FROM issues
 +WHERE repo_id = $1 AND number = $2;
++
 +-- name: GetIssueByID :one
 +SELECT * FROM issues WHERE id = $1;
++
 +-- name: ListIssues :many
 +-- Filterable list. Caller passes a state filter (open/closed/all
 +-- where 'all' is encoded as NULL); label/assignee/author/milestone
 +-- filtering happens after this query in Go for v1 — see the
 +-- internal/issues/list.go composer. Per-page hardcoded at 25 in the
 +-- handler; offset is the (page-1)*25.
 +SELECT * FROM issues
 +WHERE repo_id = $1
 +  AND (sqlc.narg(state_filter)::text IS NULL OR state::text = sqlc.narg(state_filter)::text)
 +  AND kind = COALESCE(sqlc.narg(kind)::issue_kind, 'issue')
 +ORDER BY updated_at DESC
 +LIMIT $2 OFFSET $3;
++
 +-- name: CountIssues :one
 +SELECT count(*)::bigint FROM issues
 +WHERE repo_id = $1
 +  AND (sqlc.narg(state_filter)::text IS NULL OR state::text = sqlc.narg(state_filter)::text)
 +  AND kind = COALESCE(sqlc.narg(kind)::issue_kind, 'issue');
++
 +-- name: UpdateIssueTitleBody :exec
 +UPDATE issues
 +SET title = $2, body = $3, body_html_cached = $4, edited_at = now(), updated_at = now()
 +WHERE id = $1;
++
 +-- name: SetIssueState :exec
 +UPDATE issues
 +SET state = $2,
 +    state_reason = sqlc.narg(state_reason)::issue_state_reason,
 +    closed_at = CASE WHEN $2::issue_state = 'closed' THEN now() ELSE NULL END,
 +    closed_by_user_id = sqlc.narg(closed_by_user_id)::bigint,
 +    updated_at = now()
 +WHERE id = $1;
++
 +-- name: SetIssueLock :exec
 +UPDATE issues
 +SET locked = $2, lock_reason = sqlc.narg(lock_reason)::text, updated_at = now()
 +WHERE id = $1;
++
 +-- name: SetIssueMilestone :exec
 +UPDATE issues
 +SET milestone_id = sqlc.narg(milestone_id)::bigint, updated_at = now()
 +WHERE id = $1;
++
++
 +-- ─── comments ────────────────────────────────────────────────────────
++
 +-- name: CreateIssueComment :one
 +INSERT INTO issue_comments (issue_id, author_user_id, body, body_html_cached)
 +VALUES ($1, sqlc.narg(author_user_id)::bigint, $2, $3)
 +RETURNING *;
++
 +-- name: ListIssueComments :many
 +SELECT * FROM issue_comments
 +WHERE issue_id = $1
 +ORDER BY created_at ASC;
++
 +-- name: GetIssueComment :one
 +SELECT * FROM issue_comments WHERE id = $1;
++
 +-- name: UpdateIssueCommentBody :exec
 +UPDATE issue_comments
 +SET body = $2, body_html_cached = $3, edited_at = now(), updated_at = now()
 +WHERE id = $1;
++
 +-- name: DeleteIssueComment :exec
 +DELETE FROM issue_comments WHERE id = $1;
++
++
 +-- ─── assignees ───────────────────────────────────────────────────────
++
 +-- name: AssignUserToIssue :exec
 +INSERT INTO issue_assignees (issue_id, user_id, assigned_by_user_id)
 +VALUES ($1, $2, sqlc.narg(assigned_by_user_id)::bigint)
 +ON CONFLICT (issue_id, user_id) DO NOTHING;
++
 +-- name: UnassignUserFromIssue :exec
 +DELETE FROM issue_assignees WHERE issue_id = $1 AND user_id = $2;
++
 +-- name: ListIssueAssignees :many
 +SELECT a.issue_id, a.user_id, a.assigned_at, u.username, u.display_name
 +FROM issue_assignees a
 +JOIN users u ON u.id = a.user_id
 +WHERE a.issue_id = $1
 +ORDER BY a.assigned_at;
++
++
 +-- ─── labels ──────────────────────────────────────────────────────────
++
 +-- name: CreateLabel :one
 +INSERT INTO labels (repo_id, name, color, description)
 +VALUES ($1, $2, $3, $4)
 +RETURNING *;
++
 +-- name: ListLabels :many
 +SELECT * FROM labels WHERE repo_id = $1 ORDER BY name;
++
 +-- name: GetLabelByName :one
 +SELECT * FROM labels WHERE repo_id = $1 AND name = $2;
++
 +-- name: UpdateLabel :exec
 +UPDATE labels
 +SET name = $2, color = $3, description = $4
 +WHERE id = $1;
++
 +-- name: DeleteLabel :exec
 +DELETE FROM labels WHERE id = $1;
++
++
 +-- ─── issue ↔ label ───────────────────────────────────────────────────
++
 +-- name: AddIssueLabel :exec
 +INSERT INTO issue_labels (issue_id, label_id, applied_by_user_id)
 +VALUES ($1, $2, sqlc.narg(applied_by_user_id)::bigint)
 +ON CONFLICT (issue_id, label_id) DO NOTHING;
++
 +-- name: RemoveIssueLabel :exec
 +DELETE FROM issue_labels WHERE issue_id = $1 AND label_id = $2;
++
 +-- name: ListLabelsOnIssue :many
 +SELECT l.id, l.repo_id, l.name, l.color, l.description, l.created_at
 +FROM issue_labels il
 +JOIN labels l ON l.id = il.label_id
 +WHERE il.issue_id = $1
 +ORDER BY l.name;
++
++
 +-- ─── milestones ──────────────────────────────────────────────────────
++
 +-- name: CreateMilestone :one
 +INSERT INTO milestones (repo_id, title, description, due_on)
 +VALUES ($1, $2, $3, sqlc.narg(due_on)::timestamptz)
 +RETURNING *;
++
 +-- name: ListMilestones :many
 +SELECT * FROM milestones WHERE repo_id = $1 ORDER BY state, due_on NULLS LAST, title;
++
 +-- name: GetMilestone :one
 +SELECT * FROM milestones WHERE id = $1;
++
 +-- name: UpdateMilestone :exec
 +UPDATE milestones SET title = $2, description = $3, due_on = sqlc.narg(due_on)::timestamptz WHERE id = $1;
++
 +-- name: SetMilestoneState :exec
 +UPDATE milestones SET state = $2, closed_at = CASE WHEN $2::milestone_state = 'closed' THEN now() ELSE NULL END WHERE id = $1;
++
 +-- name: DeleteMilestone :exec
 +DELETE FROM milestones WHERE id = $1;
++
 +-- name: MilestoneIssueCounts :one
 +-- Open + closed counts for the milestone progress bar.
 +SELECT
 +    count(*) FILTER (WHERE state = 'open')::int   AS open_count,
 +    count(*) FILTER (WHERE state = 'closed')::int AS closed_count
 +FROM issues
 +WHERE milestone_id = $1;
++
++
 +-- ─── events + references ─────────────────────────────────────────────
++
 +-- name: InsertIssueEvent :one
 +INSERT INTO issue_events (issue_id, actor_user_id, kind, meta, ref_target_id)
 +VALUES ($1, sqlc.narg(actor_user_id)::bigint, $2, $3, sqlc.narg(ref_target_id)::bigint)
 +RETURNING *;
++
 +-- name: ListIssueEvents :many
 +SELECT * FROM issue_events
 +WHERE issue_id = $1
 +ORDER BY created_at ASC;
++
 +-- name: InsertIssueReference :exec
 +INSERT INTO issue_references (
 +    source_issue_id, target_issue_id, source_kind, source_object_id
 +) VALUES (
 +    sqlc.narg(source_issue_id)::bigint, $1, $2, sqlc.narg(source_object_id)::bigint
 +);

internal/issues/sqlc/db.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
++
 +package issuesdb
++
 +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/issues/sqlc/issues.sql.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
 +// source: issues.sql
++
 +package issuesdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +const addIssueLabel = `-- name: AddIssueLabel :exec
++
 +INSERT INTO issue_labels (issue_id, label_id, applied_by_user_id)
 +VALUES ($1, $2, $3::bigint)
 +ON CONFLICT (issue_id, label_id) DO NOTHING
 +`
++
 +type AddIssueLabelParams struct {
 +	IssueID         int64
 +	LabelID         int64
 +	AppliedByUserID pgtype.Int8
 +}
++
 +// ─── issue ↔ label ───────────────────────────────────────────────────
 +func (q *Queries) AddIssueLabel(ctx context.Context, db DBTX, arg AddIssueLabelParams) error {
 +	_, err := db.Exec(ctx, addIssueLabel, arg.IssueID, arg.LabelID, arg.AppliedByUserID)
 +	return err
 +}
++
 +const allocateIssueNumber = `-- name: AllocateIssueNumber :one
 +UPDATE repo_issue_counter
 +SET next_number = next_number + 1
 +WHERE repo_id = $1
 +RETURNING (next_number - 1)::bigint AS allocated
 +`
++
 +// UPDATE … RETURNING is concurrency-safe: each row update is
 +// serialized by the row lock; concurrent transactions see different
 +// values. The caller wraps this in the same tx as the issue insert.
 +func (q *Queries) AllocateIssueNumber(ctx context.Context, db DBTX, repoID int64) (int64, error) {
 +	row := db.QueryRow(ctx, allocateIssueNumber, repoID)
 +	var allocated int64
 +	err := row.Scan(&allocated)
 +	return allocated, err
 +}
++
 +const assignUserToIssue = `-- name: AssignUserToIssue :exec
++
 +INSERT INTO issue_assignees (issue_id, user_id, assigned_by_user_id)
 +VALUES ($1, $2, $3::bigint)
 +ON CONFLICT (issue_id, user_id) DO NOTHING
 +`
++
 +type AssignUserToIssueParams struct {
 +	IssueID          int64
 +	UserID           int64
 +	AssignedByUserID pgtype.Int8
 +}
++
 +// ─── assignees ───────────────────────────────────────────────────────
 +func (q *Queries) AssignUserToIssue(ctx context.Context, db DBTX, arg AssignUserToIssueParams) error {
 +	_, err := db.Exec(ctx, assignUserToIssue, arg.IssueID, arg.UserID, arg.AssignedByUserID)
 +	return err
 +}
++
 +const countIssues = `-- name: CountIssues :one
 +SELECT count(*)::bigint FROM issues
 +WHERE repo_id = $1
 +  AND ($2::text IS NULL OR state::text = $2::text)
 +  AND kind = COALESCE($3::issue_kind, 'issue')
 +`
++
 +type CountIssuesParams struct {
 +	RepoID      int64
 +	StateFilter pgtype.Text
 +	Kind        NullIssueKind
 +}
++
 +func (q *Queries) CountIssues(ctx context.Context, db DBTX, arg CountIssuesParams) (int64, error) {
 +	row := db.QueryRow(ctx, countIssues, arg.RepoID, arg.StateFilter, arg.Kind)
 +	var column_1 int64
 +	err := row.Scan(&column_1)
 +	return column_1, err
 +}
++
 +const createIssue = `-- name: CreateIssue :one
++
 +INSERT INTO issues (
 +    repo_id, number, kind, title, body, author_user_id
 +) VALUES (
 +    $1, $2, $3, $4, $5, $6::bigint
 +)
 +RETURNING id, repo_id, number, kind, title, body, body_html_cached, md_pipeline_version, author_user_id, state, state_reason, locked, lock_reason, milestone_id, created_at, updated_at, edited_at, closed_at, closed_by_user_id
 +`
++
 +type CreateIssueParams struct {
 +	RepoID       int64
 +	Number       int64
 +	Kind         IssueKind
 +	Title        string
 +	Body         string
 +	AuthorUserID pgtype.Int8
 +}
++
 +// ─── issues ──────────────────────────────────────────────────────────
 +func (q *Queries) CreateIssue(ctx context.Context, db DBTX, arg CreateIssueParams) (Issue, error) {
 +	row := db.QueryRow(ctx, createIssue,
 +		arg.RepoID,
 +		arg.Number,
 +		arg.Kind,
 +		arg.Title,
 +		arg.Body,
 +		arg.AuthorUserID,
 +	)
 +	var i Issue
 +	err := row.Scan(
 +		&i.ID,
 +		&i.RepoID,
 +		&i.Number,
 +		&i.Kind,
 +		&i.Title,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.MdPipelineVersion,
 +		&i.AuthorUserID,
 +		&i.State,
 +		&i.StateReason,
 +		&i.Locked,
 +		&i.LockReason,
 +		&i.MilestoneID,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +		&i.EditedAt,
 +		&i.ClosedAt,
 +		&i.ClosedByUserID,
 +	)
 +	return i, err
 +}
++
 +const createIssueComment = `-- name: CreateIssueComment :one
++
 +INSERT INTO issue_comments (issue_id, author_user_id, body, body_html_cached)
 +VALUES ($1, $4::bigint, $2, $3)
 +RETURNING id, issue_id, author_user_id, body, body_html_cached, md_pipeline_version, created_at, updated_at, edited_at
 +`
++
 +type CreateIssueCommentParams struct {
 +	IssueID        int64
 +	Body           string
 +	BodyHtmlCached pgtype.Text
 +	AuthorUserID   pgtype.Int8
 +}
++
 +// ─── comments ────────────────────────────────────────────────────────
 +func (q *Queries) CreateIssueComment(ctx context.Context, db DBTX, arg CreateIssueCommentParams) (IssueComment, error) {
 +	row := db.QueryRow(ctx, createIssueComment,
 +		arg.IssueID,
 +		arg.Body,
 +		arg.BodyHtmlCached,
 +		arg.AuthorUserID,
 +	)
 +	var i IssueComment
 +	err := row.Scan(
 +		&i.ID,
 +		&i.IssueID,
 +		&i.AuthorUserID,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.MdPipelineVersion,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +		&i.EditedAt,
 +	)
 +	return i, err
 +}
++
 +const createLabel = `-- name: CreateLabel :one
++
 +INSERT INTO labels (repo_id, name, color, description)
 +VALUES ($1, $2, $3, $4)
 +RETURNING id, repo_id, name, color, description, created_at
 +`
++
 +type CreateLabelParams struct {
 +	RepoID      int64
 +	Name        string
 +	Color       string
 +	Description string
 +}
++
 +// ─── labels ──────────────────────────────────────────────────────────
 +func (q *Queries) CreateLabel(ctx context.Context, db DBTX, arg CreateLabelParams) (Label, error) {
 +	row := db.QueryRow(ctx, createLabel,
 +		arg.RepoID,
 +		arg.Name,
 +		arg.Color,
 +		arg.Description,
 +	)
 +	var i Label
 +	err := row.Scan(
 +		&i.ID,
 +		&i.RepoID,
 +		&i.Name,
 +		&i.Color,
 +		&i.Description,
 +		&i.CreatedAt,
 +	)
 +	return i, err
 +}
++
 +const createMilestone = `-- name: CreateMilestone :one
++
 +INSERT INTO milestones (repo_id, title, description, due_on)
 +VALUES ($1, $2, $3, $4::timestamptz)
 +RETURNING id, repo_id, title, description, state, due_on, created_at, closed_at
 +`
++
 +type CreateMilestoneParams struct {
 +	RepoID      int64
 +	Title       string
 +	Description string
 +	DueOn       pgtype.Timestamptz
 +}
++
 +// ─── milestones ──────────────────────────────────────────────────────
 +func (q *Queries) CreateMilestone(ctx context.Context, db DBTX, arg CreateMilestoneParams) (Milestone, error) {
 +	row := db.QueryRow(ctx, createMilestone,
 +		arg.RepoID,
 +		arg.Title,
 +		arg.Description,
 +		arg.DueOn,
 +	)
 +	var i Milestone
 +	err := row.Scan(
 +		&i.ID,
 +		&i.RepoID,
 +		&i.Title,
 +		&i.Description,
 +		&i.State,
 +		&i.DueOn,
 +		&i.CreatedAt,
 +		&i.ClosedAt,
 +	)
 +	return i, err
 +}
++
 +const deleteIssueComment = `-- name: DeleteIssueComment :exec
 +DELETE FROM issue_comments WHERE id = $1
 +`
++
 +func (q *Queries) DeleteIssueComment(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, deleteIssueComment, id)
 +	return err
 +}
++
 +const deleteLabel = `-- name: DeleteLabel :exec
 +DELETE FROM labels WHERE id = $1
 +`
++
 +func (q *Queries) DeleteLabel(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, deleteLabel, id)
 +	return err
 +}
++
 +const deleteMilestone = `-- name: DeleteMilestone :exec
 +DELETE FROM milestones WHERE id = $1
 +`
++
 +func (q *Queries) DeleteMilestone(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, deleteMilestone, id)
 +	return err
 +}
++
 +const ensureRepoIssueCounter = `-- name: EnsureRepoIssueCounter :exec
++
++
 +INSERT INTO repo_issue_counter (repo_id, next_number)
 +VALUES ($1, 1)
 +ON CONFLICT (repo_id) DO NOTHING
 +`
++
 +// SPDX-License-Identifier: AGPL-3.0-or-later
 +// ─── per-repo numbering ───────────────────────────────────────────────
 +// Lazy-initialize the counter row. Idempotent — invoked from repo
 +// create AND from the first issue insert (defensive in case someone
 +// migrates an old repo that predates S21).
 +func (q *Queries) EnsureRepoIssueCounter(ctx context.Context, db DBTX, repoID int64) error {
 +	_, err := db.Exec(ctx, ensureRepoIssueCounter, repoID)
 +	return err
 +}
++
 +const getIssueByID = `-- name: GetIssueByID :one
 +SELECT id, repo_id, number, kind, title, body, body_html_cached, md_pipeline_version, author_user_id, state, state_reason, locked, lock_reason, milestone_id, created_at, updated_at, edited_at, closed_at, closed_by_user_id FROM issues WHERE id = $1
 +`
++
 +func (q *Queries) GetIssueByID(ctx context.Context, db DBTX, id int64) (Issue, error) {
 +	row := db.QueryRow(ctx, getIssueByID, id)
 +	var i Issue
 +	err := row.Scan(
 +		&i.ID,
 +		&i.RepoID,
 +		&i.Number,
 +		&i.Kind,
 +		&i.Title,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.MdPipelineVersion,
 +		&i.AuthorUserID,
 +		&i.State,
 +		&i.StateReason,
 +		&i.Locked,
 +		&i.LockReason,
 +		&i.MilestoneID,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +		&i.EditedAt,
 +		&i.ClosedAt,
 +		&i.ClosedByUserID,
 +	)
 +	return i, err
 +}
++
 +const getIssueByNumber = `-- name: GetIssueByNumber :one
 +SELECT id, repo_id, number, kind, title, body, body_html_cached, md_pipeline_version, author_user_id, state, state_reason, locked, lock_reason, milestone_id, created_at, updated_at, edited_at, closed_at, closed_by_user_id FROM issues
 +WHERE repo_id = $1 AND number = $2
 +`
++
 +type GetIssueByNumberParams struct {
 +	RepoID int64
 +	Number int64
 +}
++
 +func (q *Queries) GetIssueByNumber(ctx context.Context, db DBTX, arg GetIssueByNumberParams) (Issue, error) {
 +	row := db.QueryRow(ctx, getIssueByNumber, arg.RepoID, arg.Number)
 +	var i Issue
 +	err := row.Scan(
 +		&i.ID,
 +		&i.RepoID,
 +		&i.Number,
 +		&i.Kind,
 +		&i.Title,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.MdPipelineVersion,
 +		&i.AuthorUserID,
 +		&i.State,
 +		&i.StateReason,
 +		&i.Locked,
 +		&i.LockReason,
 +		&i.MilestoneID,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +		&i.EditedAt,
 +		&i.ClosedAt,
 +		&i.ClosedByUserID,
 +	)
 +	return i, err
 +}
++
 +const getIssueComment = `-- name: GetIssueComment :one
 +SELECT id, issue_id, author_user_id, body, body_html_cached, md_pipeline_version, created_at, updated_at, edited_at FROM issue_comments WHERE id = $1
 +`
++
 +func (q *Queries) GetIssueComment(ctx context.Context, db DBTX, id int64) (IssueComment, error) {
 +	row := db.QueryRow(ctx, getIssueComment, id)
 +	var i IssueComment
 +	err := row.Scan(
 +		&i.ID,
 +		&i.IssueID,
 +		&i.AuthorUserID,
 +		&i.Body,
 +		&i.BodyHtmlCached,
 +		&i.MdPipelineVersion,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +		&i.EditedAt,
 +	)
 +	return i, err
 +}
++
 +const getLabelByName = `-- name: GetLabelByName :one
 +SELECT id, repo_id, name, color, description, created_at FROM labels WHERE repo_id = $1 AND name = $2
 +`
++
 +type GetLabelByNameParams struct {
 +	RepoID int64
 +	Name   string
 +}
++
 +func (q *Queries) GetLabelByName(ctx context.Context, db DBTX, arg GetLabelByNameParams) (Label, error) {
 +	row := db.QueryRow(ctx, getLabelByName, arg.RepoID, arg.Name)
 +	var i Label
 +	err := row.Scan(
 +		&i.ID,
 +		&i.RepoID,
 +		&i.Name,
 +		&i.Color,
 +		&i.Description,
 +		&i.CreatedAt,
 +	)
 +	return i, err
 +}
++
 +const getMilestone = `-- name: GetMilestone :one
 +SELECT id, repo_id, title, description, state, due_on, created_at, closed_at FROM milestones WHERE id = $1
 +`
++
 +func (q *Queries) GetMilestone(ctx context.Context, db DBTX, id int64) (Milestone, error) {
 +	row := db.QueryRow(ctx, getMilestone, id)
 +	var i Milestone
 +	err := row.Scan(
 +		&i.ID,
 +		&i.RepoID,
 +		&i.Title,
 +		&i.Description,
 +		&i.State,
 +		&i.DueOn,
 +		&i.CreatedAt,
 +		&i.ClosedAt,
 +	)
 +	return i, err
 +}
++
 +const insertIssueEvent = `-- name: InsertIssueEvent :one
++
 +INSERT INTO issue_events (issue_id, actor_user_id, kind, meta, ref_target_id)
 +VALUES ($1, $4::bigint, $2, $3, $5::bigint)
 +RETURNING id, issue_id, actor_user_id, kind, meta, ref_target_id, created_at
 +`
++
 +type InsertIssueEventParams struct {
 +	IssueID     int64
 +	Kind        string
 +	Meta        []byte
 +	ActorUserID pgtype.Int8
 +	RefTargetID pgtype.Int8
 +}
++
 +// ─── events + references ─────────────────────────────────────────────
 +func (q *Queries) InsertIssueEvent(ctx context.Context, db DBTX, arg InsertIssueEventParams) (IssueEvent, error) {
 +	row := db.QueryRow(ctx, insertIssueEvent,
 +		arg.IssueID,
 +		arg.Kind,
 +		arg.Meta,
 +		arg.ActorUserID,
 +		arg.RefTargetID,
 +	)
 +	var i IssueEvent
 +	err := row.Scan(
 +		&i.ID,
 +		&i.IssueID,
 +		&i.ActorUserID,
 +		&i.Kind,
 +		&i.Meta,
 +		&i.RefTargetID,
 +		&i.CreatedAt,
 +	)
 +	return i, err
 +}
++
 +const insertIssueReference = `-- name: InsertIssueReference :exec
 +INSERT INTO issue_references (
 +    source_issue_id, target_issue_id, source_kind, source_object_id
 +) VALUES (
 +    $3::bigint, $1, $2, $4::bigint
 +)
 +`
++
 +type InsertIssueReferenceParams struct {
 +	TargetIssueID  int64
 +	SourceKind     IssueRefSource
 +	SourceIssueID  pgtype.Int8
 +	SourceObjectID pgtype.Int8
 +}
++
 +func (q *Queries) InsertIssueReference(ctx context.Context, db DBTX, arg InsertIssueReferenceParams) error {
 +	_, err := db.Exec(ctx, insertIssueReference,
 +		arg.TargetIssueID,
 +		arg.SourceKind,
 +		arg.SourceIssueID,
 +		arg.SourceObjectID,
 +	)
 +	return err
 +}
++
 +const listIssueAssignees = `-- name: ListIssueAssignees :many
 +SELECT a.issue_id, a.user_id, a.assigned_at, u.username, u.display_name
 +FROM issue_assignees a
 +JOIN users u ON u.id = a.user_id
 +WHERE a.issue_id = $1
 +ORDER BY a.assigned_at
 +`
++
 +type ListIssueAssigneesRow struct {
 +	IssueID     int64
 +	UserID      int64
 +	AssignedAt  pgtype.Timestamptz
 +	Username    string
 +	DisplayName string
 +}
++
 +func (q *Queries) ListIssueAssignees(ctx context.Context, db DBTX, issueID int64) ([]ListIssueAssigneesRow, error) {
 +	rows, err := db.Query(ctx, listIssueAssignees, issueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListIssueAssigneesRow{}
 +	for rows.Next() {
 +		var i ListIssueAssigneesRow
 +		if err := rows.Scan(
 +			&i.IssueID,
 +			&i.UserID,
 +			&i.AssignedAt,
 +			&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 listIssueComments = `-- name: ListIssueComments :many
 +SELECT id, issue_id, author_user_id, body, body_html_cached, md_pipeline_version, created_at, updated_at, edited_at FROM issue_comments
 +WHERE issue_id = $1
 +ORDER BY created_at ASC
 +`
++
 +func (q *Queries) ListIssueComments(ctx context.Context, db DBTX, issueID int64) ([]IssueComment, error) {
 +	rows, err := db.Query(ctx, listIssueComments, issueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []IssueComment{}
 +	for rows.Next() {
 +		var i IssueComment
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.IssueID,
 +			&i.AuthorUserID,
 +			&i.Body,
 +			&i.BodyHtmlCached,
 +			&i.MdPipelineVersion,
 +			&i.CreatedAt,
 +			&i.UpdatedAt,
 +			&i.EditedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listIssueEvents = `-- name: ListIssueEvents :many
 +SELECT id, issue_id, actor_user_id, kind, meta, ref_target_id, created_at FROM issue_events
 +WHERE issue_id = $1
 +ORDER BY created_at ASC
 +`
++
 +func (q *Queries) ListIssueEvents(ctx context.Context, db DBTX, issueID int64) ([]IssueEvent, error) {
 +	rows, err := db.Query(ctx, listIssueEvents, issueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []IssueEvent{}
 +	for rows.Next() {
 +		var i IssueEvent
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.IssueID,
 +			&i.ActorUserID,
 +			&i.Kind,
 +			&i.Meta,
 +			&i.RefTargetID,
 +			&i.CreatedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listIssues = `-- name: ListIssues :many
 +SELECT id, repo_id, number, kind, title, body, body_html_cached, md_pipeline_version, author_user_id, state, state_reason, locked, lock_reason, milestone_id, created_at, updated_at, edited_at, closed_at, closed_by_user_id FROM issues
 +WHERE repo_id = $1
 +  AND ($4::text IS NULL OR state::text = $4::text)
 +  AND kind = COALESCE($5::issue_kind, 'issue')
 +ORDER BY updated_at DESC
 +LIMIT $2 OFFSET $3
 +`
++
 +type ListIssuesParams struct {
 +	RepoID      int64
 +	Limit       int32
 +	Offset      int32
 +	StateFilter pgtype.Text
 +	Kind        NullIssueKind
 +}
++
 +// Filterable list. Caller passes a state filter (open/closed/all
 +// where 'all' is encoded as NULL); label/assignee/author/milestone
 +// filtering happens after this query in Go for v1 — see the
 +// internal/issues/list.go composer. Per-page hardcoded at 25 in the
 +// handler; offset is the (page-1)*25.
 +func (q *Queries) ListIssues(ctx context.Context, db DBTX, arg ListIssuesParams) ([]Issue, error) {
 +	rows, err := db.Query(ctx, listIssues,
 +		arg.RepoID,
 +		arg.Limit,
 +		arg.Offset,
 +		arg.StateFilter,
 +		arg.Kind,
 +	)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []Issue{}
 +	for rows.Next() {
 +		var i Issue
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.RepoID,
 +			&i.Number,
 +			&i.Kind,
 +			&i.Title,
 +			&i.Body,
 +			&i.BodyHtmlCached,
 +			&i.MdPipelineVersion,
 +			&i.AuthorUserID,
 +			&i.State,
 +			&i.StateReason,
 +			&i.Locked,
 +			&i.LockReason,
 +			&i.MilestoneID,
 +			&i.CreatedAt,
 +			&i.UpdatedAt,
 +			&i.EditedAt,
 +			&i.ClosedAt,
 +			&i.ClosedByUserID,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listLabels = `-- name: ListLabels :many
 +SELECT id, repo_id, name, color, description, created_at FROM labels WHERE repo_id = $1 ORDER BY name
 +`
++
 +func (q *Queries) ListLabels(ctx context.Context, db DBTX, repoID int64) ([]Label, error) {
 +	rows, err := db.Query(ctx, listLabels, repoID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []Label{}
 +	for rows.Next() {
 +		var i Label
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.RepoID,
 +			&i.Name,
 +			&i.Color,
 +			&i.Description,
 +			&i.CreatedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listLabelsOnIssue = `-- name: ListLabelsOnIssue :many
 +SELECT l.id, l.repo_id, l.name, l.color, l.description, l.created_at
 +FROM issue_labels il
 +JOIN labels l ON l.id = il.label_id
 +WHERE il.issue_id = $1
 +ORDER BY l.name
 +`
++
 +func (q *Queries) ListLabelsOnIssue(ctx context.Context, db DBTX, issueID int64) ([]Label, error) {
 +	rows, err := db.Query(ctx, listLabelsOnIssue, issueID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []Label{}
 +	for rows.Next() {
 +		var i Label
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.RepoID,
 +			&i.Name,
 +			&i.Color,
 +			&i.Description,
 +			&i.CreatedAt,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listMilestones = `-- name: ListMilestones :many
 +SELECT id, repo_id, title, description, state, due_on, created_at, closed_at FROM milestones WHERE repo_id = $1 ORDER BY state, due_on NULLS LAST, title
 +`
++
 +func (q *Queries) ListMilestones(ctx context.Context, db DBTX, repoID int64) ([]Milestone, error) {
 +	rows, err := db.Query(ctx, listMilestones, repoID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []Milestone{}
 +	for rows.Next() {
 +		var i Milestone
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.RepoID,
 +			&i.Title,
 +			&i.Description,
 +			&i.State,
 +			&i.DueOn,
 +			&i.CreatedAt,
 +			&i.ClosedAt,
 +		); 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,
 +    count(*) FILTER (WHERE state = 'closed')::int AS closed_count
 +FROM issues
 +WHERE milestone_id = $1
 +`
++
 +type MilestoneIssueCountsRow struct {
 +	OpenCount   int32
 +	ClosedCount int32
 +}
++
 +// Open + closed counts for the milestone progress bar.
 +func (q *Queries) MilestoneIssueCounts(ctx context.Context, db DBTX, milestoneID pgtype.Int8) (MilestoneIssueCountsRow, error) {
 +	row := db.QueryRow(ctx, milestoneIssueCounts, milestoneID)
 +	var i MilestoneIssueCountsRow
 +	err := row.Scan(&i.OpenCount, &i.ClosedCount)
 +	return i, err
 +}
++
 +const removeIssueLabel = `-- name: RemoveIssueLabel :exec
 +DELETE FROM issue_labels WHERE issue_id = $1 AND label_id = $2
 +`
++
 +type RemoveIssueLabelParams struct {
 +	IssueID int64
 +	LabelID int64
 +}
++
 +func (q *Queries) RemoveIssueLabel(ctx context.Context, db DBTX, arg RemoveIssueLabelParams) error {
 +	_, err := db.Exec(ctx, removeIssueLabel, arg.IssueID, arg.LabelID)
 +	return err
 +}
++
 +const setIssueLock = `-- name: SetIssueLock :exec
 +UPDATE issues
 +SET locked = $2, lock_reason = $3::text, updated_at = now()
 +WHERE id = $1
 +`
++
 +type SetIssueLockParams struct {
 +	ID         int64
 +	Locked     bool
 +	LockReason pgtype.Text
 +}
++
 +func (q *Queries) SetIssueLock(ctx context.Context, db DBTX, arg SetIssueLockParams) error {
 +	_, err := db.Exec(ctx, setIssueLock, arg.ID, arg.Locked, arg.LockReason)
 +	return err
 +}
++
 +const setIssueMilestone = `-- name: SetIssueMilestone :exec
 +UPDATE issues
 +SET milestone_id = $2::bigint, updated_at = now()
 +WHERE id = $1
 +`
++
 +type SetIssueMilestoneParams struct {
 +	ID          int64
 +	MilestoneID pgtype.Int8
 +}
++
 +func (q *Queries) SetIssueMilestone(ctx context.Context, db DBTX, arg SetIssueMilestoneParams) error {
 +	_, err := db.Exec(ctx, setIssueMilestone, arg.ID, arg.MilestoneID)
 +	return err
 +}
++
 +const setIssueState = `-- name: SetIssueState :exec
 +UPDATE issues
 +SET state = $2,
 +    state_reason = $3::issue_state_reason,
 +    closed_at = CASE WHEN $2::issue_state = 'closed' THEN now() ELSE NULL END,
 +    closed_by_user_id = $4::bigint,
 +    updated_at = now()
 +WHERE id = $1
 +`
++
 +type SetIssueStateParams struct {
 +	ID             int64
 +	State          IssueState
 +	StateReason    NullIssueStateReason
 +	ClosedByUserID pgtype.Int8
 +}
++
 +func (q *Queries) SetIssueState(ctx context.Context, db DBTX, arg SetIssueStateParams) error {
 +	_, err := db.Exec(ctx, setIssueState,
 +		arg.ID,
 +		arg.State,
 +		arg.StateReason,
 +		arg.ClosedByUserID,
 +	)
 +	return err
 +}
++
 +const setMilestoneState = `-- name: SetMilestoneState :exec
 +UPDATE milestones SET state = $2, closed_at = CASE WHEN $2::milestone_state = 'closed' THEN now() ELSE NULL END WHERE id = $1
 +`
++
 +type SetMilestoneStateParams struct {
 +	ID    int64
 +	State MilestoneState
 +}
++
 +func (q *Queries) SetMilestoneState(ctx context.Context, db DBTX, arg SetMilestoneStateParams) error {
 +	_, err := db.Exec(ctx, setMilestoneState, arg.ID, arg.State)
 +	return err
 +}
++
 +const unassignUserFromIssue = `-- name: UnassignUserFromIssue :exec
 +DELETE FROM issue_assignees WHERE issue_id = $1 AND user_id = $2
 +`
++
 +type UnassignUserFromIssueParams struct {
 +	IssueID int64
 +	UserID  int64
 +}
++
 +func (q *Queries) UnassignUserFromIssue(ctx context.Context, db DBTX, arg UnassignUserFromIssueParams) error {
 +	_, err := db.Exec(ctx, unassignUserFromIssue, arg.IssueID, arg.UserID)
 +	return err
 +}
++
 +const updateIssueCommentBody = `-- name: UpdateIssueCommentBody :exec
 +UPDATE issue_comments
 +SET body = $2, body_html_cached = $3, edited_at = now(), updated_at = now()
 +WHERE id = $1
 +`
++
 +type UpdateIssueCommentBodyParams struct {
 +	ID             int64
 +	Body           string
 +	BodyHtmlCached pgtype.Text
 +}
++
 +func (q *Queries) UpdateIssueCommentBody(ctx context.Context, db DBTX, arg UpdateIssueCommentBodyParams) error {
 +	_, err := db.Exec(ctx, updateIssueCommentBody, arg.ID, arg.Body, arg.BodyHtmlCached)
 +	return err
 +}
++
 +const updateIssueTitleBody = `-- name: UpdateIssueTitleBody :exec
 +UPDATE issues
 +SET title = $2, body = $3, body_html_cached = $4, edited_at = now(), updated_at = now()
 +WHERE id = $1
 +`
++
 +type UpdateIssueTitleBodyParams struct {
 +	ID             int64
 +	Title          string
 +	Body           string
 +	BodyHtmlCached pgtype.Text
 +}
++
 +func (q *Queries) UpdateIssueTitleBody(ctx context.Context, db DBTX, arg UpdateIssueTitleBodyParams) error {
 +	_, err := db.Exec(ctx, updateIssueTitleBody,
 +		arg.ID,
 +		arg.Title,
 +		arg.Body,
 +		arg.BodyHtmlCached,
 +	)
 +	return err
 +}
++
 +const updateLabel = `-- name: UpdateLabel :exec
 +UPDATE labels
 +SET name = $2, color = $3, description = $4
 +WHERE id = $1
 +`
++
 +type UpdateLabelParams struct {
 +	ID          int64
 +	Name        string
 +	Color       string
 +	Description string
 +}
++
 +func (q *Queries) UpdateLabel(ctx context.Context, db DBTX, arg UpdateLabelParams) error {
 +	_, err := db.Exec(ctx, updateLabel,
 +		arg.ID,
 +		arg.Name,
 +		arg.Color,
 +		arg.Description,
 +	)
 +	return err
 +}
++
 +const updateMilestone = `-- name: UpdateMilestone :exec
 +UPDATE milestones SET title = $2, description = $3, due_on = $4::timestamptz WHERE id = $1
 +`
++
 +type UpdateMilestoneParams struct {
 +	ID          int64
 +	Title       string
 +	Description string
 +	DueOn       pgtype.Timestamptz
 +}
++
 +func (q *Queries) UpdateMilestone(ctx context.Context, db DBTX, arg UpdateMilestoneParams) error {
 +	_, err := db.Exec(ctx, updateMilestone,
 +		arg.ID,
 +		arg.Title,
 +		arg.Description,
 +		arg.DueOn,
 +	)
 +	return err
 +}

internal/auth/policy/sqlc/models.go → internal/issues/sqlc/models.gocopied (58% similarity)

  // versions:
  //   sqlc v1.31.1
 -package policydb
 +package issuesdb
  import (
  	"database/sql/driver"
  	return string(ns.CollabRole), nil
+ }
 +type IssueKind string
++
 +const (
 +	IssueKindIssue IssueKind = "issue"
 +	IssueKindPr    IssueKind = "pr"
 +)
++
 +func (e *IssueKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueKind(s)
 +	case string:
 +		*e = IssueKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueKind struct {
 +	IssueKind IssueKind
 +	Valid     bool // Valid is true if IssueKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueKind), nil
 +}
++
 +type IssueRefSource string
++
 +const (
 +	IssueRefSourceCommentBody   IssueRefSource = "comment_body"
 +	IssueRefSourceIssueBody     IssueRefSource = "issue_body"
 +	IssueRefSourceCommitMessage IssueRefSource = "commit_message"
 +)
++
 +func (e *IssueRefSource) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueRefSource(s)
 +	case string:
 +		*e = IssueRefSource(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueRefSource: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueRefSource struct {
 +	IssueRefSource IssueRefSource
 +	Valid          bool // Valid is true if IssueRefSource is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueRefSource) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueRefSource, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueRefSource.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueRefSource) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueRefSource), nil
 +}
++
 +type IssueState string
++
 +const (
 +	IssueStateOpen   IssueState = "open"
 +	IssueStateClosed IssueState = "closed"
 +)
++
 +func (e *IssueState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueState(s)
 +	case string:
 +		*e = IssueState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueState struct {
 +	IssueState IssueState
 +	Valid      bool // Valid is true if IssueState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueState), nil
 +}
++
 +type IssueStateReason string
++
 +const (
 +	IssueStateReasonCompleted  IssueStateReason = "completed"
 +	IssueStateReasonNotPlanned IssueStateReason = "not_planned"
 +	IssueStateReasonReopened   IssueStateReason = "reopened"
 +	IssueStateReasonDuplicate  IssueStateReason = "duplicate"
 +)
++
 +func (e *IssueStateReason) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueStateReason(s)
 +	case string:
 +		*e = IssueStateReason(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueStateReason: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueStateReason struct {
 +	IssueStateReason IssueStateReason
 +	Valid            bool // Valid is true if IssueStateReason is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueStateReason) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueStateReason, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueStateReason.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueStateReason) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueStateReason), nil
 +}
++
 +type MilestoneState string
++
 +const (
 +	MilestoneStateOpen   MilestoneState = "open"
 +	MilestoneStateClosed MilestoneState = "closed"
 +)
++
 +func (e *MilestoneState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = MilestoneState(s)
 +	case string:
 +		*e = MilestoneState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for MilestoneState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullMilestoneState struct {
 +	MilestoneState MilestoneState
 +	Valid          bool // Valid is true if MilestoneState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullMilestoneState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.MilestoneState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.MilestoneState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullMilestoneState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.MilestoneState), nil
 +}
++
  type RepoVisibility string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Issue struct {
 +	ID                int64
 +	RepoID            int64
 +	Number            int64
 +	Kind              IssueKind
 +	Title             string
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	AuthorUserID      pgtype.Int8
 +	State             IssueState
 +	StateReason       NullIssueStateReason
 +	Locked            bool
 +	LockReason        pgtype.Text
 +	MilestoneID       pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +	ClosedAt          pgtype.Timestamptz
 +	ClosedByUserID    pgtype.Int8
 +}
++
 +type IssueAssignee struct {
 +	IssueID          int64
 +	UserID           int64
 +	AssignedAt       pgtype.Timestamptz
 +	AssignedByUserID pgtype.Int8
 +}
++
 +type IssueComment struct {
 +	ID                int64
 +	IssueID           int64
 +	AuthorUserID      pgtype.Int8
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type IssueEvent struct {
 +	ID          int64
 +	IssueID     int64
 +	ActorUserID pgtype.Int8
 +	Kind        string
 +	Meta        []byte
 +	RefTargetID pgtype.Int8
 +	CreatedAt   pgtype.Timestamptz
 +}
++
 +type IssueLabel struct {
 +	IssueID         int64
 +	LabelID         int64
 +	AppliedAt       pgtype.Timestamptz
 +	AppliedByUserID pgtype.Int8
 +}
++
 +type IssueReference struct {
 +	ID             int64
 +	SourceIssueID  pgtype.Int8
 +	TargetIssueID  int64
 +	SourceKind     IssueRefSource
 +	SourceObjectID pgtype.Int8
 +	CreatedAt      pgtype.Timestamptz
 +}
++
  type Job struct {
  	ID          int64
  	Kind        string
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Label struct {
 +	ID          int64
 +	RepoID      int64
 +	Name        string
 +	Color       string
 +	Description string
 +	CreatedAt   pgtype.Timestamptz
 +}
++
  type Meta struct {
  	Key       string
  	Value     []byte
  	UpdatedAt pgtype.Timestamptz
+ }
 +type Milestone struct {
 +	ID          int64
 +	RepoID      int64
 +	Title       string
 +	Description string
 +	State       MilestoneState
 +	DueOn       pgtype.Timestamptz
 +	CreatedAt   pgtype.Timestamptz
 +	ClosedAt    pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	AddedByUserID pgtype.Int8
+ }
 +type RepoIssueCounter struct {
 +	RepoID     int64
 +	NextNumber int64
 +}
++
  type RepoRedirect struct {
  	OldOwnerUserID pgtype.Int8
  	OldOwnerOrgID  pgtype.Int8

internal/issues/sqlc/querier.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
++
 +package issuesdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +type Querier interface {
 +	// ─── issue ↔ label ───────────────────────────────────────────────────
 +	AddIssueLabel(ctx context.Context, db DBTX, arg AddIssueLabelParams) error
 +	// UPDATE … RETURNING is concurrency-safe: each row update is
 +	// serialized by the row lock; concurrent transactions see different
 +	// values. The caller wraps this in the same tx as the issue insert.
 +	AllocateIssueNumber(ctx context.Context, db DBTX, repoID int64) (int64, error)
 +	// ─── assignees ───────────────────────────────────────────────────────
 +	AssignUserToIssue(ctx context.Context, db DBTX, arg AssignUserToIssueParams) error
 +	CountIssues(ctx context.Context, db DBTX, arg CountIssuesParams) (int64, error)
 +	// ─── issues ──────────────────────────────────────────────────────────
 +	CreateIssue(ctx context.Context, db DBTX, arg CreateIssueParams) (Issue, error)
 +	// ─── comments ────────────────────────────────────────────────────────
 +	CreateIssueComment(ctx context.Context, db DBTX, arg CreateIssueCommentParams) (IssueComment, error)
 +	// ─── labels ──────────────────────────────────────────────────────────
 +	CreateLabel(ctx context.Context, db DBTX, arg CreateLabelParams) (Label, error)
 +	// ─── milestones ──────────────────────────────────────────────────────
 +	CreateMilestone(ctx context.Context, db DBTX, arg CreateMilestoneParams) (Milestone, error)
 +	DeleteIssueComment(ctx context.Context, db DBTX, id int64) error
 +	DeleteLabel(ctx context.Context, db DBTX, id int64) error
 +	DeleteMilestone(ctx context.Context, db DBTX, id int64) error
 +	// SPDX-License-Identifier: AGPL-3.0-or-later
 +	// ─── per-repo numbering ───────────────────────────────────────────────
 +	// Lazy-initialize the counter row. Idempotent — invoked from repo
 +	// create AND from the first issue insert (defensive in case someone
 +	// migrates an old repo that predates S21).
 +	EnsureRepoIssueCounter(ctx context.Context, db DBTX, repoID int64) error
 +	GetIssueByID(ctx context.Context, db DBTX, id int64) (Issue, error)
 +	GetIssueByNumber(ctx context.Context, db DBTX, arg GetIssueByNumberParams) (Issue, error)
 +	GetIssueComment(ctx context.Context, db DBTX, id int64) (IssueComment, error)
 +	GetLabelByName(ctx context.Context, db DBTX, arg GetLabelByNameParams) (Label, error)
 +	GetMilestone(ctx context.Context, db DBTX, id int64) (Milestone, error)
 +	// ─── events + references ─────────────────────────────────────────────
 +	InsertIssueEvent(ctx context.Context, db DBTX, arg InsertIssueEventParams) (IssueEvent, error)
 +	InsertIssueReference(ctx context.Context, db DBTX, arg InsertIssueReferenceParams) error
 +	ListIssueAssignees(ctx context.Context, db DBTX, issueID int64) ([]ListIssueAssigneesRow, error)
 +	ListIssueComments(ctx context.Context, db DBTX, issueID int64) ([]IssueComment, error)
 +	ListIssueEvents(ctx context.Context, db DBTX, issueID int64) ([]IssueEvent, error)
 +	// Filterable list. Caller passes a state filter (open/closed/all
 +	// where 'all' is encoded as NULL); label/assignee/author/milestone
 +	// filtering happens after this query in Go for v1 — see the
 +	// internal/issues/list.go composer. Per-page hardcoded at 25 in the
 +	// handler; offset is the (page-1)*25.
 +	ListIssues(ctx context.Context, db DBTX, arg ListIssuesParams) ([]Issue, error)
 +	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)
 +	// 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
 +	SetIssueLock(ctx context.Context, db DBTX, arg SetIssueLockParams) error
 +	SetIssueMilestone(ctx context.Context, db DBTX, arg SetIssueMilestoneParams) error
 +	SetIssueState(ctx context.Context, db DBTX, arg SetIssueStateParams) error
 +	SetMilestoneState(ctx context.Context, db DBTX, arg SetMilestoneStateParams) error
 +	UnassignUserFromIssue(ctx context.Context, db DBTX, arg UnassignUserFromIssueParams) error
 +	UpdateIssueCommentBody(ctx context.Context, db DBTX, arg UpdateIssueCommentBodyParams) error
 +	UpdateIssueTitleBody(ctx context.Context, db DBTX, arg UpdateIssueTitleBodyParams) error
 +	UpdateLabel(ctx context.Context, db DBTX, arg UpdateLabelParams) error
 +	UpdateMilestone(ctx context.Context, db DBTX, arg UpdateMilestoneParams) error
 +}
++
 +var _ Querier = (*Queries)(nil)

internal/meta/sqlc/models.gomodified

  	return string(ns.CollabRole), nil
+ }
 +type IssueKind string
++
 +const (
 +	IssueKindIssue IssueKind = "issue"
 +	IssueKindPr    IssueKind = "pr"
 +)
++
 +func (e *IssueKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueKind(s)
 +	case string:
 +		*e = IssueKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueKind struct {
 +	IssueKind IssueKind
 +	Valid     bool // Valid is true if IssueKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueKind), nil
 +}
++
 +type IssueRefSource string
++
 +const (
 +	IssueRefSourceCommentBody   IssueRefSource = "comment_body"
 +	IssueRefSourceIssueBody     IssueRefSource = "issue_body"
 +	IssueRefSourceCommitMessage IssueRefSource = "commit_message"
 +)
++
 +func (e *IssueRefSource) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueRefSource(s)
 +	case string:
 +		*e = IssueRefSource(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueRefSource: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueRefSource struct {
 +	IssueRefSource IssueRefSource
 +	Valid          bool // Valid is true if IssueRefSource is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueRefSource) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueRefSource, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueRefSource.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueRefSource) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueRefSource), nil
 +}
++
 +type IssueState string
++
 +const (
 +	IssueStateOpen   IssueState = "open"
 +	IssueStateClosed IssueState = "closed"
 +)
++
 +func (e *IssueState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueState(s)
 +	case string:
 +		*e = IssueState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueState struct {
 +	IssueState IssueState
 +	Valid      bool // Valid is true if IssueState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueState), nil
 +}
++
 +type IssueStateReason string
++
 +const (
 +	IssueStateReasonCompleted  IssueStateReason = "completed"
 +	IssueStateReasonNotPlanned IssueStateReason = "not_planned"
 +	IssueStateReasonReopened   IssueStateReason = "reopened"
 +	IssueStateReasonDuplicate  IssueStateReason = "duplicate"
 +)
++
 +func (e *IssueStateReason) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueStateReason(s)
 +	case string:
 +		*e = IssueStateReason(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueStateReason: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueStateReason struct {
 +	IssueStateReason IssueStateReason
 +	Valid            bool // Valid is true if IssueStateReason is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueStateReason) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueStateReason, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueStateReason.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueStateReason) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueStateReason), nil
 +}
++
 +type MilestoneState string
++
 +const (
 +	MilestoneStateOpen   MilestoneState = "open"
 +	MilestoneStateClosed MilestoneState = "closed"
 +)
++
 +func (e *MilestoneState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = MilestoneState(s)
 +	case string:
 +		*e = MilestoneState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for MilestoneState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullMilestoneState struct {
 +	MilestoneState MilestoneState
 +	Valid          bool // Valid is true if MilestoneState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullMilestoneState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.MilestoneState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.MilestoneState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullMilestoneState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.MilestoneState), nil
 +}
++
  type RepoVisibility string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Issue struct {
 +	ID                int64
 +	RepoID            int64
 +	Number            int64
 +	Kind              IssueKind
 +	Title             string
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	AuthorUserID      pgtype.Int8
 +	State             IssueState
 +	StateReason       NullIssueStateReason
 +	Locked            bool
 +	LockReason        pgtype.Text
 +	MilestoneID       pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +	ClosedAt          pgtype.Timestamptz
 +	ClosedByUserID    pgtype.Int8
 +}
++
 +type IssueAssignee struct {
 +	IssueID          int64
 +	UserID           int64
 +	AssignedAt       pgtype.Timestamptz
 +	AssignedByUserID pgtype.Int8
 +}
++
 +type IssueComment struct {
 +	ID                int64
 +	IssueID           int64
 +	AuthorUserID      pgtype.Int8
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type IssueEvent struct {
 +	ID          int64
 +	IssueID     int64
 +	ActorUserID pgtype.Int8
 +	Kind        string
 +	Meta        []byte
 +	RefTargetID pgtype.Int8
 +	CreatedAt   pgtype.Timestamptz
 +}
++
 +type IssueLabel struct {
 +	IssueID         int64
 +	LabelID         int64
 +	AppliedAt       pgtype.Timestamptz
 +	AppliedByUserID pgtype.Int8
 +}
++
 +type IssueReference struct {
 +	ID             int64
 +	SourceIssueID  pgtype.Int8
 +	TargetIssueID  int64
 +	SourceKind     IssueRefSource
 +	SourceObjectID pgtype.Int8
 +	CreatedAt      pgtype.Timestamptz
 +}
++
  type Job struct {
  	ID          int64
  	Kind        string
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Label struct {
 +	ID          int64
 +	RepoID      int64
 +	Name        string
 +	Color       string
 +	Description string
 +	CreatedAt   pgtype.Timestamptz
 +}
++
  type Meta struct {
  	Key       string
  	Value     []byte
  	UpdatedAt pgtype.Timestamptz
+ }
 +type Milestone struct {
 +	ID          int64
 +	RepoID      int64
 +	Title       string
 +	Description string
 +	State       MilestoneState
 +	DueOn       pgtype.Timestamptz
 +	CreatedAt   pgtype.Timestamptz
 +	ClosedAt    pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	AddedByUserID pgtype.Int8
+ }
 +type RepoIssueCounter struct {
 +	RepoID     int64
 +	NextNumber int64
 +}
++
  type RepoRedirect struct {
  	OldOwnerUserID pgtype.Int8
  	OldOwnerOrgID  pgtype.Int8

internal/migrationsfs/migrations/0022_issues.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
 +--
 +-- S21 issues subsystem. Eight tables plus the per-repo counter:
 +--
 +--   repo_issue_counter   — per-repo monotonic numbering for issues+PRs
 +--   issues               — the row; `kind` discriminator covers PRs (S22)
 +--   issue_comments       — per-issue threaded comments
 +--   issue_assignees      — many-to-many issue ↔ user
 +--   labels               — repo-scoped labels (default set seeded on create)
 +--   issue_labels         — many-to-many issue ↔ label
 +--   milestones           — repo-scoped milestones
 +--   issue_events         — generic polymorphic timeline (label/assign/etc.)
 +--   issue_references     — cross-reference index (comment/body/commit → issue)
 +--
 +-- The `kind` discriminator on `issues` ('issue'|'pr') is in from day 1
 +-- so PR rows in S22 are first-class and don't require a schema split.
 +-- PR-specific fields live in a `pull_requests` table keyed on issue_id
 +-- (built in S22).
++
 +-- +goose Up
++
 +CREATE TYPE issue_kind         AS ENUM ('issue', 'pr');
 +CREATE TYPE issue_state        AS ENUM ('open', 'closed');
 +CREATE TYPE issue_state_reason AS ENUM ('completed', 'not_planned', 'reopened', 'duplicate');
 +CREATE TYPE milestone_state    AS ENUM ('open', 'closed');
 +CREATE TYPE issue_ref_source   AS ENUM ('comment_body', 'issue_body', 'commit_message');
++
 +-- Per-repo monotonic counter. Allocation is one row UPDATE inside the
 +-- creating transaction so concurrent inserts can't collide. Issues +
 +-- PRs share the counter (matches GitHub's #N space).
 +CREATE TABLE repo_issue_counter (
 +    repo_id     bigint  PRIMARY KEY REFERENCES repos(id) ON DELETE CASCADE,
 +    next_number bigint  NOT NULL DEFAULT 1
 +);
++
 +CREATE TABLE issues (
 +    id                  bigserial         PRIMARY KEY,
 +    repo_id             bigint            NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
 +    number              bigint            NOT NULL,
 +    kind                issue_kind        NOT NULL DEFAULT 'issue',
 +    title               text              NOT NULL,
 +    body                text              NOT NULL DEFAULT '',
 +    body_html_cached    text,
 +    md_pipeline_version int               NOT NULL DEFAULT 1,
 +    author_user_id      bigint            REFERENCES users(id) ON DELETE SET NULL,
 +    state               issue_state       NOT NULL DEFAULT 'open',
 +    state_reason        issue_state_reason,
 +    locked              boolean           NOT NULL DEFAULT false,
 +    lock_reason         text,
 +    milestone_id        bigint, -- FK added below after milestones exists
 +    created_at          timestamptz       NOT NULL DEFAULT now(),
 +    updated_at          timestamptz       NOT NULL DEFAULT now(),
 +    edited_at           timestamptz,
 +    closed_at           timestamptz,
 +    closed_by_user_id   bigint            REFERENCES users(id) ON DELETE SET NULL,
++
 +    CONSTRAINT issues_title_length CHECK (char_length(title) BETWEEN 1 AND 256),
 +    CONSTRAINT issues_body_length  CHECK (char_length(body)  <= 65535),
++
 +    UNIQUE (repo_id, number)
 +);
++
 +CREATE INDEX issues_repo_state_updated_idx
 +    ON issues (repo_id, state, updated_at DESC);
 +CREATE INDEX issues_repo_kind_state_idx
 +    ON issues (repo_id, kind, state);
 +CREATE INDEX issues_author_idx ON issues (author_user_id);
++
 +CREATE TRIGGER set_updated_at BEFORE UPDATE ON issues
 +    FOR EACH ROW EXECUTE FUNCTION tg_set_updated_at();
++
++
 +CREATE TABLE issue_comments (
 +    id                  bigserial   PRIMARY KEY,
 +    issue_id            bigint      NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    author_user_id      bigint      REFERENCES users(id) ON DELETE SET NULL,
 +    body                text        NOT NULL,
 +    body_html_cached    text,
 +    md_pipeline_version int         NOT NULL DEFAULT 1,
 +    created_at          timestamptz NOT NULL DEFAULT now(),
 +    updated_at          timestamptz NOT NULL DEFAULT now(),
 +    edited_at           timestamptz,
++
 +    CONSTRAINT issue_comments_body_length CHECK (char_length(body) BETWEEN 1 AND 65535)
 +);
++
 +CREATE INDEX issue_comments_issue_idx ON issue_comments (issue_id, created_at);
++
 +CREATE TRIGGER set_updated_at BEFORE UPDATE ON issue_comments
 +    FOR EACH ROW EXECUTE FUNCTION tg_set_updated_at();
++
++
 +CREATE TABLE issue_assignees (
 +    issue_id            bigint      NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    user_id             bigint      NOT NULL REFERENCES users(id) ON DELETE CASCADE,
 +    assigned_at         timestamptz NOT NULL DEFAULT now(),
 +    assigned_by_user_id bigint      REFERENCES users(id) ON DELETE SET NULL,
++
 +    PRIMARY KEY (issue_id, user_id)
 +);
++
 +CREATE INDEX issue_assignees_user_idx ON issue_assignees (user_id);
++
++
 +CREATE TABLE labels (
 +    id          bigserial   PRIMARY KEY,
 +    repo_id     bigint      NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
 +    name        citext      NOT NULL,
 +    color       text        NOT NULL DEFAULT 'd0d7de',
 +    description text        NOT NULL DEFAULT '',
 +    created_at  timestamptz NOT NULL DEFAULT now(),
++
 +    CONSTRAINT labels_name_length CHECK (char_length(name::text) BETWEEN 1 AND 50),
 +    CONSTRAINT labels_color_format CHECK (color ~ '^[0-9a-fA-F]{6}$'),
++
 +    UNIQUE (repo_id, name)
 +);
++
++
 +CREATE TABLE issue_labels (
 +    issue_id           bigint      NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    label_id           bigint      NOT NULL REFERENCES labels(id) ON DELETE CASCADE,
 +    applied_at         timestamptz NOT NULL DEFAULT now(),
 +    applied_by_user_id bigint      REFERENCES users(id) ON DELETE SET NULL,
++
 +    PRIMARY KEY (issue_id, label_id)
 +);
++
 +CREATE INDEX issue_labels_label_idx ON issue_labels (label_id);
++
++
 +CREATE TABLE milestones (
 +    id          bigserial         PRIMARY KEY,
 +    repo_id     bigint            NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
 +    title       text              NOT NULL,
 +    description text              NOT NULL DEFAULT '',
 +    state       milestone_state   NOT NULL DEFAULT 'open',
 +    due_on      timestamptz,
 +    created_at  timestamptz       NOT NULL DEFAULT now(),
 +    closed_at   timestamptz,
++
 +    CONSTRAINT milestones_title_length CHECK (char_length(title) BETWEEN 1 AND 200),
++
 +    UNIQUE (repo_id, title)
 +);
++
 +ALTER TABLE issues ADD CONSTRAINT issues_milestone_fk
 +    FOREIGN KEY (milestone_id) REFERENCES milestones(id) ON DELETE SET NULL;
++
++
 +CREATE TABLE issue_events (
 +    id            bigserial   PRIMARY KEY,
 +    issue_id      bigint      NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    actor_user_id bigint      REFERENCES users(id) ON DELETE SET NULL,
 +    kind          text        NOT NULL,
 +    meta          jsonb       NOT NULL DEFAULT '{}'::jsonb,
 +    ref_target_id bigint, -- denormalized when the event references another issue
 +    created_at    timestamptz NOT NULL DEFAULT now()
 +);
++
 +CREATE INDEX issue_events_issue_idx ON issue_events (issue_id, created_at);
++
++
 +CREATE TABLE issue_references (
 +    id                bigserial   PRIMARY KEY,
 +    source_issue_id   bigint      REFERENCES issues(id) ON DELETE SET NULL,
 +    target_issue_id   bigint      NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
 +    source_kind       issue_ref_source NOT NULL,
 +    source_object_id  bigint, -- comment_id when source_kind=comment_body; issue_id when issue_body; push_event_id when commit_message
 +    created_at        timestamptz NOT NULL DEFAULT now()
 +);
++
 +CREATE INDEX issue_references_target_idx ON issue_references (target_issue_id, created_at);
 +CREATE INDEX issue_references_source_idx ON issue_references (source_issue_id, source_kind);
++
++
 +-- +goose Down
 +DROP TABLE IF EXISTS issue_references;
 +DROP TABLE IF EXISTS issue_events;
 +ALTER TABLE issues DROP CONSTRAINT IF EXISTS issues_milestone_fk;
 +DROP TABLE IF EXISTS milestones;
 +DROP TABLE IF EXISTS issue_labels;
 +DROP TABLE IF EXISTS labels;
 +DROP TABLE IF EXISTS issue_assignees;
 +DROP TABLE IF EXISTS issue_comments;
 +DROP TABLE IF EXISTS issues;
 +DROP TABLE IF EXISTS repo_issue_counter;
 +DROP TYPE IF EXISTS issue_ref_source;
 +DROP TYPE IF EXISTS milestone_state;
 +DROP TYPE IF EXISTS issue_state_reason;
 +DROP TYPE IF EXISTS issue_state;
 +DROP TYPE IF EXISTS issue_kind;

internal/repos/sqlc/models.gomodified

  	return string(ns.CollabRole), nil
+ }
 +type IssueKind string
++
 +const (
 +	IssueKindIssue IssueKind = "issue"
 +	IssueKindPr    IssueKind = "pr"
 +)
++
 +func (e *IssueKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueKind(s)
 +	case string:
 +		*e = IssueKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueKind struct {
 +	IssueKind IssueKind
 +	Valid     bool // Valid is true if IssueKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueKind), nil
 +}
++
 +type IssueRefSource string
++
 +const (
 +	IssueRefSourceCommentBody   IssueRefSource = "comment_body"
 +	IssueRefSourceIssueBody     IssueRefSource = "issue_body"
 +	IssueRefSourceCommitMessage IssueRefSource = "commit_message"
 +)
++
 +func (e *IssueRefSource) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueRefSource(s)
 +	case string:
 +		*e = IssueRefSource(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueRefSource: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueRefSource struct {
 +	IssueRefSource IssueRefSource
 +	Valid          bool // Valid is true if IssueRefSource is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueRefSource) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueRefSource, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueRefSource.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueRefSource) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueRefSource), nil
 +}
++
 +type IssueState string
++
 +const (
 +	IssueStateOpen   IssueState = "open"
 +	IssueStateClosed IssueState = "closed"
 +)
++
 +func (e *IssueState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueState(s)
 +	case string:
 +		*e = IssueState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueState struct {
 +	IssueState IssueState
 +	Valid      bool // Valid is true if IssueState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueState), nil
 +}
++
 +type IssueStateReason string
++
 +const (
 +	IssueStateReasonCompleted  IssueStateReason = "completed"
 +	IssueStateReasonNotPlanned IssueStateReason = "not_planned"
 +	IssueStateReasonReopened   IssueStateReason = "reopened"
 +	IssueStateReasonDuplicate  IssueStateReason = "duplicate"
 +)
++
 +func (e *IssueStateReason) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueStateReason(s)
 +	case string:
 +		*e = IssueStateReason(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueStateReason: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueStateReason struct {
 +	IssueStateReason IssueStateReason
 +	Valid            bool // Valid is true if IssueStateReason is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueStateReason) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueStateReason, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueStateReason.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueStateReason) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueStateReason), nil
 +}
++
 +type MilestoneState string
++
 +const (
 +	MilestoneStateOpen   MilestoneState = "open"
 +	MilestoneStateClosed MilestoneState = "closed"
 +)
++
 +func (e *MilestoneState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = MilestoneState(s)
 +	case string:
 +		*e = MilestoneState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for MilestoneState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullMilestoneState struct {
 +	MilestoneState MilestoneState
 +	Valid          bool // Valid is true if MilestoneState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullMilestoneState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.MilestoneState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.MilestoneState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullMilestoneState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.MilestoneState), nil
 +}
++
  type RepoVisibility string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Issue struct {
 +	ID                int64
 +	RepoID            int64
 +	Number            int64
 +	Kind              IssueKind
 +	Title             string
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	AuthorUserID      pgtype.Int8
 +	State             IssueState
 +	StateReason       NullIssueStateReason
 +	Locked            bool
 +	LockReason        pgtype.Text
 +	MilestoneID       pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +	ClosedAt          pgtype.Timestamptz
 +	ClosedByUserID    pgtype.Int8
 +}
++
 +type IssueAssignee struct {
 +	IssueID          int64
 +	UserID           int64
 +	AssignedAt       pgtype.Timestamptz
 +	AssignedByUserID pgtype.Int8
 +}
++
 +type IssueComment struct {
 +	ID                int64
 +	IssueID           int64
 +	AuthorUserID      pgtype.Int8
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type IssueEvent struct {
 +	ID          int64
 +	IssueID     int64
 +	ActorUserID pgtype.Int8
 +	Kind        string
 +	Meta        []byte
 +	RefTargetID pgtype.Int8
 +	CreatedAt   pgtype.Timestamptz
 +}
++
 +type IssueLabel struct {
 +	IssueID         int64
 +	LabelID         int64
 +	AppliedAt       pgtype.Timestamptz
 +	AppliedByUserID pgtype.Int8
 +}
++
 +type IssueReference struct {
 +	ID             int64
 +	SourceIssueID  pgtype.Int8
 +	TargetIssueID  int64
 +	SourceKind     IssueRefSource
 +	SourceObjectID pgtype.Int8
 +	CreatedAt      pgtype.Timestamptz
 +}
++
  type Job struct {
  	ID          int64
  	Kind        string
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Label struct {
 +	ID          int64
 +	RepoID      int64
 +	Name        string
 +	Color       string
 +	Description string
 +	CreatedAt   pgtype.Timestamptz
 +}
++
  type Meta struct {
  	Key       string
  	Value     []byte
  	UpdatedAt pgtype.Timestamptz
+ }
 +type Milestone struct {
 +	ID          int64
 +	RepoID      int64
 +	Title       string
 +	Description string
 +	State       MilestoneState
 +	DueOn       pgtype.Timestamptz
 +	CreatedAt   pgtype.Timestamptz
 +	ClosedAt    pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	AddedByUserID pgtype.Int8
+ }
 +type RepoIssueCounter struct {
 +	RepoID     int64
 +	NextNumber int64
 +}
++
  type RepoRedirect struct {
  	OldOwnerUserID pgtype.Int8
  	OldOwnerOrgID  pgtype.Int8

internal/users/sqlc/models.gomodified

  	return string(ns.CollabRole), nil
+ }
 +type IssueKind string
++
 +const (
 +	IssueKindIssue IssueKind = "issue"
 +	IssueKindPr    IssueKind = "pr"
 +)
++
 +func (e *IssueKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueKind(s)
 +	case string:
 +		*e = IssueKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueKind struct {
 +	IssueKind IssueKind
 +	Valid     bool // Valid is true if IssueKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueKind), nil
 +}
++
 +type IssueRefSource string
++
 +const (
 +	IssueRefSourceCommentBody   IssueRefSource = "comment_body"
 +	IssueRefSourceIssueBody     IssueRefSource = "issue_body"
 +	IssueRefSourceCommitMessage IssueRefSource = "commit_message"
 +)
++
 +func (e *IssueRefSource) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueRefSource(s)
 +	case string:
 +		*e = IssueRefSource(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueRefSource: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueRefSource struct {
 +	IssueRefSource IssueRefSource
 +	Valid          bool // Valid is true if IssueRefSource is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueRefSource) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueRefSource, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueRefSource.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueRefSource) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueRefSource), nil
 +}
++
 +type IssueState string
++
 +const (
 +	IssueStateOpen   IssueState = "open"
 +	IssueStateClosed IssueState = "closed"
 +)
++
 +func (e *IssueState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueState(s)
 +	case string:
 +		*e = IssueState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueState struct {
 +	IssueState IssueState
 +	Valid      bool // Valid is true if IssueState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueState), nil
 +}
++
 +type IssueStateReason string
++
 +const (
 +	IssueStateReasonCompleted  IssueStateReason = "completed"
 +	IssueStateReasonNotPlanned IssueStateReason = "not_planned"
 +	IssueStateReasonReopened   IssueStateReason = "reopened"
 +	IssueStateReasonDuplicate  IssueStateReason = "duplicate"
 +)
++
 +func (e *IssueStateReason) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueStateReason(s)
 +	case string:
 +		*e = IssueStateReason(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueStateReason: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueStateReason struct {
 +	IssueStateReason IssueStateReason
 +	Valid            bool // Valid is true if IssueStateReason is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueStateReason) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueStateReason, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueStateReason.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueStateReason) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueStateReason), nil
 +}
++
 +type MilestoneState string
++
 +const (
 +	MilestoneStateOpen   MilestoneState = "open"
 +	MilestoneStateClosed MilestoneState = "closed"
 +)
++
 +func (e *MilestoneState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = MilestoneState(s)
 +	case string:
 +		*e = MilestoneState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for MilestoneState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullMilestoneState struct {
 +	MilestoneState MilestoneState
 +	Valid          bool // Valid is true if MilestoneState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullMilestoneState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.MilestoneState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.MilestoneState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullMilestoneState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.MilestoneState), nil
 +}
++
  type RepoVisibility string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Issue struct {
 +	ID                int64
 +	RepoID            int64
 +	Number            int64
 +	Kind              IssueKind
 +	Title             string
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	AuthorUserID      pgtype.Int8
 +	State             IssueState
 +	StateReason       NullIssueStateReason
 +	Locked            bool
 +	LockReason        pgtype.Text
 +	MilestoneID       pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +	ClosedAt          pgtype.Timestamptz
 +	ClosedByUserID    pgtype.Int8
 +}
++
 +type IssueAssignee struct {
 +	IssueID          int64
 +	UserID           int64
 +	AssignedAt       pgtype.Timestamptz
 +	AssignedByUserID pgtype.Int8
 +}
++
 +type IssueComment struct {
 +	ID                int64
 +	IssueID           int64
 +	AuthorUserID      pgtype.Int8
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type IssueEvent struct {
 +	ID          int64
 +	IssueID     int64
 +	ActorUserID pgtype.Int8
 +	Kind        string
 +	Meta        []byte
 +	RefTargetID pgtype.Int8
 +	CreatedAt   pgtype.Timestamptz
 +}
++
 +type IssueLabel struct {
 +	IssueID         int64
 +	LabelID         int64
 +	AppliedAt       pgtype.Timestamptz
 +	AppliedByUserID pgtype.Int8
 +}
++
 +type IssueReference struct {
 +	ID             int64
 +	SourceIssueID  pgtype.Int8
 +	TargetIssueID  int64
 +	SourceKind     IssueRefSource
 +	SourceObjectID pgtype.Int8
 +	CreatedAt      pgtype.Timestamptz
 +}
++
  type Job struct {
  	ID          int64
  	Kind        string
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Label struct {
 +	ID          int64
 +	RepoID      int64
 +	Name        string
 +	Color       string
 +	Description string
 +	CreatedAt   pgtype.Timestamptz
 +}
++
  type Meta struct {
  	Key       string
  	Value     []byte
  	UpdatedAt pgtype.Timestamptz
+ }
 +type Milestone struct {
 +	ID          int64
 +	RepoID      int64
 +	Title       string
 +	Description string
 +	State       MilestoneState
 +	DueOn       pgtype.Timestamptz
 +	CreatedAt   pgtype.Timestamptz
 +	ClosedAt    pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	AddedByUserID pgtype.Int8
+ }
 +type RepoIssueCounter struct {
 +	RepoID     int64
 +	NextNumber int64
 +}
++
  type RepoRedirect struct {
  	OldOwnerUserID pgtype.Int8
  	OldOwnerOrgID  pgtype.Int8

internal/worker/sqlc/models.gomodified

  	return string(ns.CollabRole), nil
+ }
 +type IssueKind string
++
 +const (
 +	IssueKindIssue IssueKind = "issue"
 +	IssueKindPr    IssueKind = "pr"
 +)
++
 +func (e *IssueKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueKind(s)
 +	case string:
 +		*e = IssueKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueKind struct {
 +	IssueKind IssueKind
 +	Valid     bool // Valid is true if IssueKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueKind), nil
 +}
++
 +type IssueRefSource string
++
 +const (
 +	IssueRefSourceCommentBody   IssueRefSource = "comment_body"
 +	IssueRefSourceIssueBody     IssueRefSource = "issue_body"
 +	IssueRefSourceCommitMessage IssueRefSource = "commit_message"
 +)
++
 +func (e *IssueRefSource) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueRefSource(s)
 +	case string:
 +		*e = IssueRefSource(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueRefSource: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueRefSource struct {
 +	IssueRefSource IssueRefSource
 +	Valid          bool // Valid is true if IssueRefSource is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueRefSource) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueRefSource, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueRefSource.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueRefSource) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueRefSource), nil
 +}
++
 +type IssueState string
++
 +const (
 +	IssueStateOpen   IssueState = "open"
 +	IssueStateClosed IssueState = "closed"
 +)
++
 +func (e *IssueState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueState(s)
 +	case string:
 +		*e = IssueState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueState struct {
 +	IssueState IssueState
 +	Valid      bool // Valid is true if IssueState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueState), nil
 +}
++
 +type IssueStateReason string
++
 +const (
 +	IssueStateReasonCompleted  IssueStateReason = "completed"
 +	IssueStateReasonNotPlanned IssueStateReason = "not_planned"
 +	IssueStateReasonReopened   IssueStateReason = "reopened"
 +	IssueStateReasonDuplicate  IssueStateReason = "duplicate"
 +)
++
 +func (e *IssueStateReason) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = IssueStateReason(s)
 +	case string:
 +		*e = IssueStateReason(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for IssueStateReason: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullIssueStateReason struct {
 +	IssueStateReason IssueStateReason
 +	Valid            bool // Valid is true if IssueStateReason is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullIssueStateReason) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.IssueStateReason, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.IssueStateReason.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullIssueStateReason) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.IssueStateReason), nil
 +}
++
 +type MilestoneState string
++
 +const (
 +	MilestoneStateOpen   MilestoneState = "open"
 +	MilestoneStateClosed MilestoneState = "closed"
 +)
++
 +func (e *MilestoneState) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = MilestoneState(s)
 +	case string:
 +		*e = MilestoneState(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for MilestoneState: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullMilestoneState struct {
 +	MilestoneState MilestoneState
 +	Valid          bool // Valid is true if MilestoneState is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullMilestoneState) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.MilestoneState, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.MilestoneState.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullMilestoneState) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.MilestoneState), nil
 +}
++
  type RepoVisibility string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Issue struct {
 +	ID                int64
 +	RepoID            int64
 +	Number            int64
 +	Kind              IssueKind
 +	Title             string
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	AuthorUserID      pgtype.Int8
 +	State             IssueState
 +	StateReason       NullIssueStateReason
 +	Locked            bool
 +	LockReason        pgtype.Text
 +	MilestoneID       pgtype.Int8
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +	ClosedAt          pgtype.Timestamptz
 +	ClosedByUserID    pgtype.Int8
 +}
++
 +type IssueAssignee struct {
 +	IssueID          int64
 +	UserID           int64
 +	AssignedAt       pgtype.Timestamptz
 +	AssignedByUserID pgtype.Int8
 +}
++
 +type IssueComment struct {
 +	ID                int64
 +	IssueID           int64
 +	AuthorUserID      pgtype.Int8
 +	Body              string
 +	BodyHtmlCached    pgtype.Text
 +	MdPipelineVersion int32
 +	CreatedAt         pgtype.Timestamptz
 +	UpdatedAt         pgtype.Timestamptz
 +	EditedAt          pgtype.Timestamptz
 +}
++
 +type IssueEvent struct {
 +	ID          int64
 +	IssueID     int64
 +	ActorUserID pgtype.Int8
 +	Kind        string
 +	Meta        []byte
 +	RefTargetID pgtype.Int8
 +	CreatedAt   pgtype.Timestamptz
 +}
++
 +type IssueLabel struct {
 +	IssueID         int64
 +	LabelID         int64
 +	AppliedAt       pgtype.Timestamptz
 +	AppliedByUserID pgtype.Int8
 +}
++
 +type IssueReference struct {
 +	ID             int64
 +	SourceIssueID  pgtype.Int8
 +	TargetIssueID  int64
 +	SourceKind     IssueRefSource
 +	SourceObjectID pgtype.Int8
 +	CreatedAt      pgtype.Timestamptz
 +}
++
  type Job struct {
  	ID          int64
  	Kind        string
  	CreatedAt   pgtype.Timestamptz
+ }
 +type Label struct {
 +	ID          int64
 +	RepoID      int64
 +	Name        string
 +	Color       string
 +	Description string
 +	CreatedAt   pgtype.Timestamptz
 +}
++
  type Meta struct {
  	Key       string
  	Value     []byte
  	UpdatedAt pgtype.Timestamptz
+ }
 +type Milestone struct {
 +	ID          int64
 +	RepoID      int64
 +	Title       string
 +	Description string
 +	State       MilestoneState
 +	DueOn       pgtype.Timestamptz
 +	CreatedAt   pgtype.Timestamptz
 +	ClosedAt    pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	AddedByUserID pgtype.Int8
+ }
 +type RepoIssueCounter struct {
 +	RepoID     int64
 +	NextNumber int64
 +}
++
  type RepoRedirect struct {
  	OldOwnerUserID pgtype.Int8
  	OldOwnerOrgID  pgtype.Int8

sqlc.yamlmodified

          emit_empty_slices: true
          emit_methods_with_db_argument: true
 +  - engine: postgresql
 +    schema: internal/migrationsfs/migrations
 +    queries: internal/issues/queries
 +    gen:
 +      go:
 +        package: issuesdb
 +        out: internal/issues/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
++
    - engine: postgresql
      schema: internal/migrationsfs/migrations
      queries: internal/auth/policy/queries