`6aaaf84`

S30: orgs schema + members + invitations + principals + sqlc

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

SHA: 6aaaf843ed80b05bcb67826b05510f2421de2b37
Parents: 6e99c48
Tree: 64e64fd

21 changed files

Status	File	+
M	`internal/auth/policy/sqlc/models.go`	259
M	`internal/checks/sqlc/models.go`	259
M	`internal/issues/sqlc/models.go`	259
M	`internal/meta/sqlc/models.go`	259
A	`internal/migrationsfs/migrations/0034_orgs.sql`	215
M	`internal/notif/sqlc/models.go`	175
A	`internal/orgs/queries/invitations.sql`	80
A	`internal/orgs/queries/members.sql`	45
A	`internal/orgs/queries/orgs.sql`	64
A	`internal/orgs/sqlc/db.go`	25
A	`internal/orgs/sqlc/invitations.sql.go`	378
A	`internal/orgs/sqlc/members.sql.go`	200
C	`internal/orgs/sqlc/models.go`	0
A	`internal/orgs/sqlc/orgs.sql.go`	267
A	`internal/orgs/sqlc/querier.go`	75
M	`internal/pulls/sqlc/models.go`	259
M	`internal/repos/sqlc/models.go`	259
M	`internal/social/sqlc/models.go`	259
M	`internal/users/sqlc/models.go`	259
M	`internal/worker/sqlc/models.go`	259
M	`sqlc.yaml`	32

internal/auth/policy/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/checks/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/issues/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/meta/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/migrationsfs/migrations/0034_orgs.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
 +--
 +-- S30 — Organizations.
 +--
 +-- Schema overview:
 +--
 +--   orgs              — first-class principals that can own repos.
 +--   org_members       — (org, user) ↔ role; PK on the pair so a user
 +--                       holds exactly one role per org.
 +--   org_invitations   — pending invites by username OR email; one of
 +--                       target_user_id / target_email is set.
 +--   principals        — single source of truth for /{slug} resolution.
 +--                       Maintained by triggers on users + orgs so a
 +--                       slug collision is structurally impossible.
 +--
 +-- The `repos.owner_org_id` column already exists from 0017 with the
 +-- right XOR CHECK constraint; this migration just adds the FK once
 +-- the orgs table exists.
++
 +-- +goose Up
++
 +-- ─── orgs ───────────────────────────────────────────────────────────
 +CREATE TYPE org_plan AS ENUM ('free', 'team', 'enterprise');
++
 +CREATE TABLE orgs (
 +    id                       bigserial   PRIMARY KEY,
 +    slug                     citext      NOT NULL UNIQUE,
 +    display_name             text        NOT NULL DEFAULT '',
 +    description              text        NOT NULL DEFAULT '',
 +    avatar_object_key        text,
 +    location                 text        NOT NULL DEFAULT '',
 +    website                  text        NOT NULL DEFAULT '',
 +    billing_email            text        NOT NULL DEFAULT '',
 +    plan                     org_plan    NOT NULL DEFAULT 'free',
 +    allow_member_repo_create boolean     NOT NULL DEFAULT true,
 +    created_by_user_id       bigint      REFERENCES users(id) ON DELETE SET NULL,
 +    suspended_at             timestamptz,
 +    suspended_reason         text,
 +    deleted_at               timestamptz,
 +    created_at               timestamptz NOT NULL DEFAULT now(),
 +    updated_at               timestamptz NOT NULL DEFAULT now(),
++
 +    CONSTRAINT orgs_slug_length CHECK (char_length(slug::text) BETWEEN 1 AND 39),
 +    CONSTRAINT orgs_description_length CHECK (char_length(description) <= 350)
 +);
++
 +CREATE INDEX orgs_deleted_at_idx ON orgs (deleted_at) WHERE deleted_at IS NOT NULL;
 +CREATE INDEX orgs_suspended_at_idx ON orgs (suspended_at) WHERE suspended_at IS NOT NULL;
++
 +CREATE TRIGGER set_updated_at BEFORE UPDATE ON orgs
 +    FOR EACH ROW EXECUTE FUNCTION tg_set_updated_at();
++
 +-- ─── org_members ───────────────────────────────────────────────────
 +CREATE TYPE org_role AS ENUM ('owner', 'member');
++
 +CREATE TABLE org_members (
 +    org_id              bigint      NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
 +    user_id             bigint      NOT NULL REFERENCES users(id) ON DELETE CASCADE,
 +    role                org_role    NOT NULL DEFAULT 'member',
 +    invited_by_user_id  bigint      REFERENCES users(id) ON DELETE SET NULL,
 +    joined_at           timestamptz NOT NULL DEFAULT now(),
++
 +    PRIMARY KEY (org_id, user_id)
 +);
++
 +CREATE INDEX org_members_user_idx ON org_members (user_id);
 +CREATE INDEX org_members_role_idx ON org_members (org_id, role);
++
 +-- ─── org_invitations ───────────────────────────────────────────────
 +CREATE TABLE org_invitations (
 +    id                   bigserial   PRIMARY KEY,
 +    org_id               bigint      NOT NULL REFERENCES orgs(id) ON DELETE CASCADE,
 +    invited_by_user_id   bigint      REFERENCES users(id) ON DELETE SET NULL,
 +    target_user_id       bigint      REFERENCES users(id) ON DELETE CASCADE,
 +    target_email         citext,
 +    role                 org_role    NOT NULL DEFAULT 'member',
 +    token_hash           bytea       NOT NULL UNIQUE,
 +    expires_at           timestamptz NOT NULL,
 +    accepted_at          timestamptz,
 +    declined_at          timestamptz,
 +    canceled_at          timestamptz,
 +    created_at           timestamptz NOT NULL DEFAULT now(),
++
 +    CONSTRAINT org_invites_target_xor CHECK (
 +        (target_user_id IS NOT NULL AND target_email IS NULL)
 +     OR (target_user_id IS NULL     AND target_email IS NOT NULL)
 +    )
 +);
++
 +CREATE INDEX org_invites_org_pending_idx
 +    ON org_invitations (org_id)
 +    WHERE accepted_at IS NULL AND declined_at IS NULL AND canceled_at IS NULL;
++
 +CREATE INDEX org_invites_target_user_idx
 +    ON org_invitations (target_user_id)
 +    WHERE target_user_id IS NOT NULL;
++
 +CREATE INDEX org_invites_target_email_idx
 +    ON org_invitations (target_email)
 +    WHERE target_email IS NOT NULL;
++
 +-- ─── principals ────────────────────────────────────────────────────
 +-- Unifies the /{slug} URL space across users and orgs. Maintained by
 +-- AFTER triggers on users + orgs so the row is always coherent.
 +-- One row per (slug, kind, id); slug PK enforces global uniqueness
 +-- across both tables — a slug collision is structurally impossible.
 +CREATE TYPE principal_kind AS ENUM ('user', 'org');
++
 +CREATE TABLE principals (
 +    slug citext         PRIMARY KEY,
 +    kind principal_kind NOT NULL,
 +    id   bigint         NOT NULL,
++
 +    -- Sanity index for "all orgs" / "all users" sweeps.
 +    CONSTRAINT principals_id_kind_idx UNIQUE (kind, id)
 +);
++
 +-- Backfill from existing users.
 +INSERT INTO principals (slug, kind, id)
 +SELECT username, 'user'::principal_kind, id
 +FROM users
 +WHERE deleted_at IS NULL
 +ON CONFLICT (slug) DO NOTHING;
++
 +-- +goose StatementBegin
 +CREATE OR REPLACE FUNCTION tg_principals_user_sync() RETURNS trigger AS $$
 +BEGIN
 +    IF TG_OP = 'DELETE' THEN
 +        DELETE FROM principals WHERE kind = 'user' AND id = OLD.id;
 +        RETURN OLD;
 +    END IF;
 +    IF TG_OP = 'INSERT' THEN
 +        INSERT INTO principals (slug, kind, id)
 +        VALUES (NEW.username, 'user', NEW.id);
 +        RETURN NEW;
 +    END IF;
 +    -- UPDATE: handle username change + soft-delete flip.
 +    IF NEW.deleted_at IS NOT NULL AND OLD.deleted_at IS NULL THEN
 +        DELETE FROM principals WHERE kind = 'user' AND id = NEW.id;
 +        RETURN NEW;
 +    END IF;
 +    IF NEW.deleted_at IS NULL AND OLD.deleted_at IS NOT NULL THEN
 +        INSERT INTO principals (slug, kind, id)
 +        VALUES (NEW.username, 'user', NEW.id)
 +        ON CONFLICT (slug) DO UPDATE SET kind = EXCLUDED.kind, id = EXCLUDED.id;
 +        RETURN NEW;
 +    END IF;
 +    IF NEW.username <> OLD.username THEN
 +        UPDATE principals SET slug = NEW.username
 +            WHERE kind = 'user' AND id = NEW.id;
 +    END IF;
 +    RETURN NEW;
 +END;
 +$$ LANGUAGE plpgsql;
 +-- +goose StatementEnd
++
 +-- +goose StatementBegin
 +CREATE OR REPLACE FUNCTION tg_principals_org_sync() RETURNS trigger AS $$
 +BEGIN
 +    IF TG_OP = 'DELETE' THEN
 +        DELETE FROM principals WHERE kind = 'org' AND id = OLD.id;
 +        RETURN OLD;
 +    END IF;
 +    IF TG_OP = 'INSERT' THEN
 +        INSERT INTO principals (slug, kind, id)
 +        VALUES (NEW.slug, 'org', NEW.id);
 +        RETURN NEW;
 +    END IF;
 +    IF NEW.deleted_at IS NOT NULL AND OLD.deleted_at IS NULL THEN
 +        DELETE FROM principals WHERE kind = 'org' AND id = NEW.id;
 +        RETURN NEW;
 +    END IF;
 +    IF NEW.deleted_at IS NULL AND OLD.deleted_at IS NOT NULL THEN
 +        INSERT INTO principals (slug, kind, id)
 +        VALUES (NEW.slug, 'org', NEW.id)
 +        ON CONFLICT (slug) DO UPDATE SET kind = EXCLUDED.kind, id = EXCLUDED.id;
 +        RETURN NEW;
 +    END IF;
 +    IF NEW.slug <> OLD.slug THEN
 +        UPDATE principals SET slug = NEW.slug
 +            WHERE kind = 'org' AND id = NEW.id;
 +    END IF;
 +    RETURN NEW;
 +END;
 +$$ LANGUAGE plpgsql;
 +-- +goose StatementEnd
++
 +CREATE TRIGGER tg_principals_user_sync_iud
 +    AFTER INSERT OR UPDATE OR DELETE ON users
 +    FOR EACH ROW EXECUTE FUNCTION tg_principals_user_sync();
++
 +CREATE TRIGGER tg_principals_org_sync_iud
 +    AFTER INSERT OR UPDATE OR DELETE ON orgs
 +    FOR EACH ROW EXECUTE FUNCTION tg_principals_org_sync();
++
 +-- ─── repos.owner_org_id FK ─────────────────────────────────────────
 +-- The column existed from 0017 with the XOR CHECK already in place;
 +-- adding the actual FK only now that the target table exists.
 +ALTER TABLE repos
 +    ADD CONSTRAINT repos_owner_org_id_fkey
 +        FOREIGN KEY (owner_org_id) REFERENCES orgs(id) ON DELETE CASCADE;
++
 +-- +goose Down
 +ALTER TABLE repos DROP CONSTRAINT IF EXISTS repos_owner_org_id_fkey;
 +DROP TRIGGER IF EXISTS tg_principals_org_sync_iud ON orgs;
 +DROP TRIGGER IF EXISTS tg_principals_user_sync_iud ON users;
 +DROP FUNCTION IF EXISTS tg_principals_org_sync();
 +DROP FUNCTION IF EXISTS tg_principals_user_sync();
 +DROP TABLE IF EXISTS principals;
 +DROP TYPE IF EXISTS principal_kind;
 +DROP TABLE IF EXISTS org_invitations;
 +DROP TABLE IF EXISTS org_members;
 +DROP TYPE IF EXISTS org_role;
 +DROP TABLE IF EXISTS orgs;
 +DROP TYPE IF EXISTS org_plan;

internal/notif/sqlc/models.gomodified

  	return string(ns.NotificationThreadKind), nil
+ }
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	UpdatedAt       pgtype.Timestamptz
+ }
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/orgs/queries/invitations.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
++
 +-- ─── org_invitations ───────────────────────────────────────────────
++
 +-- name: CreateOrgInvitation :one
 +INSERT INTO org_invitations (
 +    org_id, invited_by_user_id, target_user_id, target_email,
 +    role, token_hash, expires_at
 +) VALUES (
 +    $1, $2, sqlc.narg(target_user_id)::bigint, sqlc.narg(target_email)::citext,
 +    $3, $4, $5
 +)
 +RETURNING *;
++
 +-- name: GetOrgInvitationByTokenHash :one
 +SELECT * FROM org_invitations WHERE token_hash = $1;
++
 +-- name: GetOrgInvitationByID :one
 +SELECT * FROM org_invitations WHERE id = $1;
++
 +-- name: ListPendingInvitationsForOrg :many
 +SELECT i.*, u.username AS target_username, ib.username AS invited_by_username
 +FROM org_invitations i
 +LEFT JOIN users u  ON u.id  = i.target_user_id
 +LEFT JOIN users ib ON ib.id = i.invited_by_user_id
 +WHERE i.org_id = $1
 +  AND i.accepted_at IS NULL
 +  AND i.declined_at IS NULL
 +  AND i.canceled_at IS NULL
 +  AND i.expires_at > now()
 +ORDER BY i.created_at DESC;
++
 +-- name: ListPendingInvitationsForUser :many
 +-- Two flavors: by user_id (already-claimed invites) and by email
 +-- (claim-on-signup). Caller unions the two lookups when surfacing
 +-- to the user.
 +SELECT i.*, o.slug AS org_slug, o.display_name AS org_display_name
 +FROM org_invitations i
 +JOIN orgs o ON o.id = i.org_id
 +WHERE i.target_user_id = $1
 +  AND i.accepted_at IS NULL
 +  AND i.declined_at IS NULL
 +  AND i.canceled_at IS NULL
 +  AND i.expires_at > now()
 +  AND o.deleted_at IS NULL
 +ORDER BY i.created_at DESC;
++
 +-- name: ListPendingInvitationsForEmail :many
 +SELECT i.*, o.slug AS org_slug, o.display_name AS org_display_name
 +FROM org_invitations i
 +JOIN orgs o ON o.id = i.org_id
 +WHERE i.target_email = $1
 +  AND i.accepted_at IS NULL
 +  AND i.declined_at IS NULL
 +  AND i.canceled_at IS NULL
 +  AND i.expires_at > now()
 +  AND o.deleted_at IS NULL
 +ORDER BY i.created_at DESC;
++
 +-- name: AcceptOrgInvitation :exec
 +UPDATE org_invitations SET accepted_at = now() WHERE id = $1;
++
 +-- name: DeclineOrgInvitation :exec
 +UPDATE org_invitations SET declined_at = now() WHERE id = $1;
++
 +-- name: CancelOrgInvitation :exec
 +UPDATE org_invitations SET canceled_at = now() WHERE id = $1;
++
 +-- name: GetExistingPendingInvitation :one
 +-- Idempotency check before creating a new invite — so a re-issued
 +-- invite to the same target doesn't accumulate stale rows.
 +SELECT * FROM org_invitations
 +WHERE org_id = $1
 +  AND ( (target_user_id = sqlc.narg(target_user_id)::bigint)
 +     OR (target_email   = sqlc.narg(target_email)::citext) )
 +  AND accepted_at IS NULL
 +  AND declined_at IS NULL
 +  AND canceled_at IS NULL
 +  AND expires_at > now()
 +LIMIT 1;

internal/orgs/queries/members.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
++
 +-- ─── org_members ───────────────────────────────────────────────────
++
 +-- name: AddOrgMember :exec
 +-- Idempotent on (org_id, user_id): re-adding a member is a no-op
 +-- rather than an error. The role is taken from the supplied row when
 +-- the member is new; existing rows keep their current role (use
 +-- ChangeOrgMemberRole to update).
 +INSERT INTO org_members (org_id, user_id, role, invited_by_user_id)
 +VALUES ($1, $2, $3, sqlc.narg(invited_by_user_id)::bigint)
 +ON CONFLICT (org_id, user_id) DO NOTHING;
++
 +-- name: RemoveOrgMember :exec
 +DELETE FROM org_members WHERE org_id = $1 AND user_id = $2;
++
 +-- name: ChangeOrgMemberRole :exec
 +UPDATE org_members SET role = $3 WHERE org_id = $1 AND user_id = $2;
++
 +-- name: GetOrgMember :one
 +SELECT * FROM org_members WHERE org_id = $1 AND user_id = $2;
++
 +-- name: ListOrgMembers :many
 +-- Members of an org with usernames + roles for the people page.
 +SELECT m.org_id, m.user_id, m.role, m.invited_by_user_id, m.joined_at,
 +       u.username, u.display_name
 +FROM org_members m
 +JOIN users u ON u.id = m.user_id
 +WHERE m.org_id = $1
 +  AND u.deleted_at IS NULL
 +ORDER BY m.role ASC, u.username ASC;
++
 +-- name: CountOrgOwners :one
 +-- Used by the last-owner protection: refuses to remove or demote the
 +-- only owner. Caller compares `count = 1` before allowing the change.
 +SELECT count(*) FROM org_members WHERE org_id = $1 AND role = 'owner';
++
 +-- name: ListOrgsForUser :many
 +-- Profile-page input: every org a user is a member of, with role.
 +SELECT m.org_id, m.role, o.slug, o.display_name, o.avatar_object_key
 +FROM org_members m
 +JOIN orgs o ON o.id = m.org_id
 +WHERE m.user_id = $1
 +  AND o.deleted_at IS NULL
 +ORDER BY o.slug ASC;

internal/orgs/queries/orgs.sqladded

 +-- SPDX-License-Identifier: AGPL-3.0-or-later
++
 +-- ─── orgs ──────────────────────────────────────────────────────────
++
 +-- name: CreateOrg :one
 +-- Inserts a new org. The trigger on `orgs` populates `principals` for
 +-- /{slug} resolution; the caller adds the creator as owner in the same
 +-- tx (separate query so the orchestrator owns ordering).
 +INSERT INTO orgs (slug, display_name, description, billing_email, created_by_user_id)
 +VALUES ($1, $2, $3, $4, sqlc.narg(created_by_user_id)::bigint)
 +RETURNING *;
++
 +-- name: GetOrgByID :one
 +SELECT * FROM orgs WHERE id = $1;
++
 +-- name: GetOrgBySlug :one
 +-- Slug is citext so the comparison is case-insensitive. Soft-deleted
 +-- orgs are filtered out so a slug freed by deletion is invisible to
 +-- normal lookups (the resolver still sees the row via the deleted_at
 +-- column for grace-period restore).
 +SELECT * FROM orgs
 +WHERE slug = $1
 +  AND deleted_at IS NULL;
++
 +-- name: GetOrgBySlugIncludingDeleted :one
 +SELECT * FROM orgs WHERE slug = $1;
++
 +-- name: UpdateOrgProfile :exec
 +UPDATE orgs
 +   SET display_name = $2,
 +       description  = $3,
 +       location     = $4,
 +       website      = $5,
 +       billing_email = $6,
 +       updated_at   = now()
 + WHERE id = $1;
++
 +-- name: SetOrgAvatarKey :exec
 +UPDATE orgs SET avatar_object_key = $2, updated_at = now() WHERE id = $1;
++
 +-- name: SetOrgAllowMemberRepoCreate :exec
 +UPDATE orgs SET allow_member_repo_create = $2, updated_at = now() WHERE id = $1;
++
 +-- name: SetOrgSuspended :exec
 +UPDATE orgs
 +   SET suspended_at = CASE WHEN $2::boolean THEN now() ELSE NULL END,
 +       suspended_reason = CASE WHEN $2::boolean THEN $3 ELSE NULL END,
 +       updated_at = now()
 + WHERE id = $1;
++
 +-- name: SoftDeleteOrg :exec
 +UPDATE orgs SET deleted_at = now(), updated_at = now() WHERE id = $1;
++
 +-- name: RestoreOrg :exec
 +UPDATE orgs SET deleted_at = NULL, updated_at = now() WHERE id = $1;
++
 +-- ─── principals (read-only from this domain) ───────────────────────
++
 +-- name: ResolvePrincipal :one
 +-- Single-query /{slug} resolver. Returns the (kind, id) tuple that
 +-- /{slug}/* routes use to dispatch to the user-profile or org-profile
 +-- handler. Both kinds share the slug PK so collisions are
 +-- impossible at the DB layer.
 +SELECT slug, kind, id FROM principals WHERE slug = $1;

internal/orgs/sqlc/db.goadded

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

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
 +// source: invitations.sql
++
 +package orgsdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +const acceptOrgInvitation = `-- name: AcceptOrgInvitation :exec
 +UPDATE org_invitations SET accepted_at = now() WHERE id = $1
 +`
++
 +func (q *Queries) AcceptOrgInvitation(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, acceptOrgInvitation, id)
 +	return err
 +}
++
 +const cancelOrgInvitation = `-- name: CancelOrgInvitation :exec
 +UPDATE org_invitations SET canceled_at = now() WHERE id = $1
 +`
++
 +func (q *Queries) CancelOrgInvitation(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, cancelOrgInvitation, id)
 +	return err
 +}
++
 +const createOrgInvitation = `-- name: CreateOrgInvitation :one
++
++
 +INSERT INTO org_invitations (
 +    org_id, invited_by_user_id, target_user_id, target_email,
 +    role, token_hash, expires_at
 +) VALUES (
 +    $1, $2, $6::bigint, $7::citext,
 +    $3, $4, $5
 +)
 +RETURNING id, org_id, invited_by_user_id, target_user_id, target_email, role, token_hash, expires_at, accepted_at, declined_at, canceled_at, created_at
 +`
++
 +type CreateOrgInvitationParams struct {
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +}
++
 +// SPDX-License-Identifier: AGPL-3.0-or-later
 +// ─── org_invitations ───────────────────────────────────────────────
 +func (q *Queries) CreateOrgInvitation(ctx context.Context, db DBTX, arg CreateOrgInvitationParams) (OrgInvitation, error) {
 +	row := db.QueryRow(ctx, createOrgInvitation,
 +		arg.OrgID,
 +		arg.InvitedByUserID,
 +		arg.Role,
 +		arg.TokenHash,
 +		arg.ExpiresAt,
 +		arg.TargetUserID,
 +		arg.TargetEmail,
 +	)
 +	var i OrgInvitation
 +	err := row.Scan(
 +		&i.ID,
 +		&i.OrgID,
 +		&i.InvitedByUserID,
 +		&i.TargetUserID,
 +		&i.TargetEmail,
 +		&i.Role,
 +		&i.TokenHash,
 +		&i.ExpiresAt,
 +		&i.AcceptedAt,
 +		&i.DeclinedAt,
 +		&i.CanceledAt,
 +		&i.CreatedAt,
 +	)
 +	return i, err
 +}
++
 +const declineOrgInvitation = `-- name: DeclineOrgInvitation :exec
 +UPDATE org_invitations SET declined_at = now() WHERE id = $1
 +`
++
 +func (q *Queries) DeclineOrgInvitation(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, declineOrgInvitation, id)
 +	return err
 +}
++
 +const getExistingPendingInvitation = `-- name: GetExistingPendingInvitation :one
 +SELECT id, org_id, invited_by_user_id, target_user_id, target_email, role, token_hash, expires_at, accepted_at, declined_at, canceled_at, created_at FROM org_invitations
 +WHERE org_id = $1
 +  AND ( (target_user_id = $2::bigint)
 +     OR (target_email   = $3::citext) )
 +  AND accepted_at IS NULL
 +  AND declined_at IS NULL
 +  AND canceled_at IS NULL
 +  AND expires_at > now()
 +LIMIT 1
 +`
++
 +type GetExistingPendingInvitationParams struct {
 +	OrgID        int64
 +	TargetUserID pgtype.Int8
 +	TargetEmail  pgtype.Text
 +}
++
 +// Idempotency check before creating a new invite — so a re-issued
 +// invite to the same target doesn't accumulate stale rows.
 +func (q *Queries) GetExistingPendingInvitation(ctx context.Context, db DBTX, arg GetExistingPendingInvitationParams) (OrgInvitation, error) {
 +	row := db.QueryRow(ctx, getExistingPendingInvitation, arg.OrgID, arg.TargetUserID, arg.TargetEmail)
 +	var i OrgInvitation
 +	err := row.Scan(
 +		&i.ID,
 +		&i.OrgID,
 +		&i.InvitedByUserID,
 +		&i.TargetUserID,
 +		&i.TargetEmail,
 +		&i.Role,
 +		&i.TokenHash,
 +		&i.ExpiresAt,
 +		&i.AcceptedAt,
 +		&i.DeclinedAt,
 +		&i.CanceledAt,
 +		&i.CreatedAt,
 +	)
 +	return i, err
 +}
++
 +const getOrgInvitationByID = `-- name: GetOrgInvitationByID :one
 +SELECT id, org_id, invited_by_user_id, target_user_id, target_email, role, token_hash, expires_at, accepted_at, declined_at, canceled_at, created_at FROM org_invitations WHERE id = $1
 +`
++
 +func (q *Queries) GetOrgInvitationByID(ctx context.Context, db DBTX, id int64) (OrgInvitation, error) {
 +	row := db.QueryRow(ctx, getOrgInvitationByID, id)
 +	var i OrgInvitation
 +	err := row.Scan(
 +		&i.ID,
 +		&i.OrgID,
 +		&i.InvitedByUserID,
 +		&i.TargetUserID,
 +		&i.TargetEmail,
 +		&i.Role,
 +		&i.TokenHash,
 +		&i.ExpiresAt,
 +		&i.AcceptedAt,
 +		&i.DeclinedAt,
 +		&i.CanceledAt,
 +		&i.CreatedAt,
 +	)
 +	return i, err
 +}
++
 +const getOrgInvitationByTokenHash = `-- name: GetOrgInvitationByTokenHash :one
 +SELECT id, org_id, invited_by_user_id, target_user_id, target_email, role, token_hash, expires_at, accepted_at, declined_at, canceled_at, created_at FROM org_invitations WHERE token_hash = $1
 +`
++
 +func (q *Queries) GetOrgInvitationByTokenHash(ctx context.Context, db DBTX, tokenHash []byte) (OrgInvitation, error) {
 +	row := db.QueryRow(ctx, getOrgInvitationByTokenHash, tokenHash)
 +	var i OrgInvitation
 +	err := row.Scan(
 +		&i.ID,
 +		&i.OrgID,
 +		&i.InvitedByUserID,
 +		&i.TargetUserID,
 +		&i.TargetEmail,
 +		&i.Role,
 +		&i.TokenHash,
 +		&i.ExpiresAt,
 +		&i.AcceptedAt,
 +		&i.DeclinedAt,
 +		&i.CanceledAt,
 +		&i.CreatedAt,
 +	)
 +	return i, err
 +}
++
 +const listPendingInvitationsForEmail = `-- name: ListPendingInvitationsForEmail :many
 +SELECT i.id, i.org_id, i.invited_by_user_id, i.target_user_id, i.target_email, i.role, i.token_hash, i.expires_at, i.accepted_at, i.declined_at, i.canceled_at, i.created_at, o.slug AS org_slug, o.display_name AS org_display_name
 +FROM org_invitations i
 +JOIN orgs o ON o.id = i.org_id
 +WHERE i.target_email = $1
 +  AND i.accepted_at IS NULL
 +  AND i.declined_at IS NULL
 +  AND i.canceled_at IS NULL
 +  AND i.expires_at > now()
 +  AND o.deleted_at IS NULL
 +ORDER BY i.created_at DESC
 +`
++
 +type ListPendingInvitationsForEmailRow struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +	OrgSlug         string
 +	OrgDisplayName  string
 +}
++
 +func (q *Queries) ListPendingInvitationsForEmail(ctx context.Context, db DBTX, targetEmail pgtype.Text) ([]ListPendingInvitationsForEmailRow, error) {
 +	rows, err := db.Query(ctx, listPendingInvitationsForEmail, targetEmail)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListPendingInvitationsForEmailRow{}
 +	for rows.Next() {
 +		var i ListPendingInvitationsForEmailRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.OrgID,
 +			&i.InvitedByUserID,
 +			&i.TargetUserID,
 +			&i.TargetEmail,
 +			&i.Role,
 +			&i.TokenHash,
 +			&i.ExpiresAt,
 +			&i.AcceptedAt,
 +			&i.DeclinedAt,
 +			&i.CanceledAt,
 +			&i.CreatedAt,
 +			&i.OrgSlug,
 +			&i.OrgDisplayName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPendingInvitationsForOrg = `-- name: ListPendingInvitationsForOrg :many
 +SELECT i.id, i.org_id, i.invited_by_user_id, i.target_user_id, i.target_email, i.role, i.token_hash, i.expires_at, i.accepted_at, i.declined_at, i.canceled_at, i.created_at, u.username AS target_username, ib.username AS invited_by_username
 +FROM org_invitations i
 +LEFT JOIN users u  ON u.id  = i.target_user_id
 +LEFT JOIN users ib ON ib.id = i.invited_by_user_id
 +WHERE i.org_id = $1
 +  AND i.accepted_at IS NULL
 +  AND i.declined_at IS NULL
 +  AND i.canceled_at IS NULL
 +  AND i.expires_at > now()
 +ORDER BY i.created_at DESC
 +`
++
 +type ListPendingInvitationsForOrgRow struct {
 +	ID                int64
 +	OrgID             int64
 +	InvitedByUserID   pgtype.Int8
 +	TargetUserID      pgtype.Int8
 +	TargetEmail       pgtype.Text
 +	Role              OrgRole
 +	TokenHash         []byte
 +	ExpiresAt         pgtype.Timestamptz
 +	AcceptedAt        pgtype.Timestamptz
 +	DeclinedAt        pgtype.Timestamptz
 +	CanceledAt        pgtype.Timestamptz
 +	CreatedAt         pgtype.Timestamptz
 +	TargetUsername    pgtype.Text
 +	InvitedByUsername pgtype.Text
 +}
++
 +func (q *Queries) ListPendingInvitationsForOrg(ctx context.Context, db DBTX, orgID int64) ([]ListPendingInvitationsForOrgRow, error) {
 +	rows, err := db.Query(ctx, listPendingInvitationsForOrg, orgID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListPendingInvitationsForOrgRow{}
 +	for rows.Next() {
 +		var i ListPendingInvitationsForOrgRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.OrgID,
 +			&i.InvitedByUserID,
 +			&i.TargetUserID,
 +			&i.TargetEmail,
 +			&i.Role,
 +			&i.TokenHash,
 +			&i.ExpiresAt,
 +			&i.AcceptedAt,
 +			&i.DeclinedAt,
 +			&i.CanceledAt,
 +			&i.CreatedAt,
 +			&i.TargetUsername,
 +			&i.InvitedByUsername,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const listPendingInvitationsForUser = `-- name: ListPendingInvitationsForUser :many
 +SELECT i.id, i.org_id, i.invited_by_user_id, i.target_user_id, i.target_email, i.role, i.token_hash, i.expires_at, i.accepted_at, i.declined_at, i.canceled_at, i.created_at, o.slug AS org_slug, o.display_name AS org_display_name
 +FROM org_invitations i
 +JOIN orgs o ON o.id = i.org_id
 +WHERE i.target_user_id = $1
 +  AND i.accepted_at IS NULL
 +  AND i.declined_at IS NULL
 +  AND i.canceled_at IS NULL
 +  AND i.expires_at > now()
 +  AND o.deleted_at IS NULL
 +ORDER BY i.created_at DESC
 +`
++
 +type ListPendingInvitationsForUserRow struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +	OrgSlug         string
 +	OrgDisplayName  string
 +}
++
 +// Two flavors: by user_id (already-claimed invites) and by email
 +// (claim-on-signup). Caller unions the two lookups when surfacing
 +// to the user.
 +func (q *Queries) ListPendingInvitationsForUser(ctx context.Context, db DBTX, targetUserID pgtype.Int8) ([]ListPendingInvitationsForUserRow, error) {
 +	rows, err := db.Query(ctx, listPendingInvitationsForUser, targetUserID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListPendingInvitationsForUserRow{}
 +	for rows.Next() {
 +		var i ListPendingInvitationsForUserRow
 +		if err := rows.Scan(
 +			&i.ID,
 +			&i.OrgID,
 +			&i.InvitedByUserID,
 +			&i.TargetUserID,
 +			&i.TargetEmail,
 +			&i.Role,
 +			&i.TokenHash,
 +			&i.ExpiresAt,
 +			&i.AcceptedAt,
 +			&i.DeclinedAt,
 +			&i.CanceledAt,
 +			&i.CreatedAt,
 +			&i.OrgSlug,
 +			&i.OrgDisplayName,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}

internal/orgs/sqlc/members.sql.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
 +// source: members.sql
++
 +package orgsdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +const addOrgMember = `-- name: AddOrgMember :exec
++
++
 +INSERT INTO org_members (org_id, user_id, role, invited_by_user_id)
 +VALUES ($1, $2, $3, $4::bigint)
 +ON CONFLICT (org_id, user_id) DO NOTHING
 +`
++
 +type AddOrgMemberParams struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +}
++
 +// SPDX-License-Identifier: AGPL-3.0-or-later
 +// ─── org_members ───────────────────────────────────────────────────
 +// Idempotent on (org_id, user_id): re-adding a member is a no-op
 +// rather than an error. The role is taken from the supplied row when
 +// the member is new; existing rows keep their current role (use
 +// ChangeOrgMemberRole to update).
 +func (q *Queries) AddOrgMember(ctx context.Context, db DBTX, arg AddOrgMemberParams) error {
 +	_, err := db.Exec(ctx, addOrgMember,
 +		arg.OrgID,
 +		arg.UserID,
 +		arg.Role,
 +		arg.InvitedByUserID,
 +	)
 +	return err
 +}
++
 +const changeOrgMemberRole = `-- name: ChangeOrgMemberRole :exec
 +UPDATE org_members SET role = $3 WHERE org_id = $1 AND user_id = $2
 +`
++
 +type ChangeOrgMemberRoleParams struct {
 +	OrgID  int64
 +	UserID int64
 +	Role   OrgRole
 +}
++
 +func (q *Queries) ChangeOrgMemberRole(ctx context.Context, db DBTX, arg ChangeOrgMemberRoleParams) error {
 +	_, err := db.Exec(ctx, changeOrgMemberRole, arg.OrgID, arg.UserID, arg.Role)
 +	return err
 +}
++
 +const countOrgOwners = `-- name: CountOrgOwners :one
 +SELECT count(*) FROM org_members WHERE org_id = $1 AND role = 'owner'
 +`
++
 +// Used by the last-owner protection: refuses to remove or demote the
 +// only owner. Caller compares `count = 1` before allowing the change.
 +func (q *Queries) CountOrgOwners(ctx context.Context, db DBTX, orgID int64) (int64, error) {
 +	row := db.QueryRow(ctx, countOrgOwners, orgID)
 +	var count int64
 +	err := row.Scan(&count)
 +	return count, err
 +}
++
 +const getOrgMember = `-- name: GetOrgMember :one
 +SELECT org_id, user_id, role, invited_by_user_id, joined_at FROM org_members WHERE org_id = $1 AND user_id = $2
 +`
++
 +type GetOrgMemberParams struct {
 +	OrgID  int64
 +	UserID int64
 +}
++
 +func (q *Queries) GetOrgMember(ctx context.Context, db DBTX, arg GetOrgMemberParams) (OrgMember, error) {
 +	row := db.QueryRow(ctx, getOrgMember, arg.OrgID, arg.UserID)
 +	var i OrgMember
 +	err := row.Scan(
 +		&i.OrgID,
 +		&i.UserID,
 +		&i.Role,
 +		&i.InvitedByUserID,
 +		&i.JoinedAt,
 +	)
 +	return i, err
 +}
++
 +const listOrgMembers = `-- name: ListOrgMembers :many
 +SELECT m.org_id, m.user_id, m.role, m.invited_by_user_id, m.joined_at,
 +       u.username, u.display_name
 +FROM org_members m
 +JOIN users u ON u.id = m.user_id
 +WHERE m.org_id = $1
 +  AND u.deleted_at IS NULL
 +ORDER BY m.role ASC, u.username ASC
 +`
++
 +type ListOrgMembersRow struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +	Username        string
 +	DisplayName     string
 +}
++
 +// Members of an org with usernames + roles for the people page.
 +func (q *Queries) ListOrgMembers(ctx context.Context, db DBTX, orgID int64) ([]ListOrgMembersRow, error) {
 +	rows, err := db.Query(ctx, listOrgMembers, orgID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListOrgMembersRow{}
 +	for rows.Next() {
 +		var i ListOrgMembersRow
 +		if err := rows.Scan(
 +			&i.OrgID,
 +			&i.UserID,
 +			&i.Role,
 +			&i.InvitedByUserID,
 +			&i.JoinedAt,
 +			&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 listOrgsForUser = `-- name: ListOrgsForUser :many
 +SELECT m.org_id, m.role, o.slug, o.display_name, o.avatar_object_key
 +FROM org_members m
 +JOIN orgs o ON o.id = m.org_id
 +WHERE m.user_id = $1
 +  AND o.deleted_at IS NULL
 +ORDER BY o.slug ASC
 +`
++
 +type ListOrgsForUserRow struct {
 +	OrgID           int64
 +	Role            OrgRole
 +	Slug            string
 +	DisplayName     string
 +	AvatarObjectKey pgtype.Text
 +}
++
 +// Profile-page input: every org a user is a member of, with role.
 +func (q *Queries) ListOrgsForUser(ctx context.Context, db DBTX, userID int64) ([]ListOrgsForUserRow, error) {
 +	rows, err := db.Query(ctx, listOrgsForUser, userID)
 +	if err != nil {
 +		return nil, err
 +	}
 +	defer rows.Close()
 +	items := []ListOrgsForUserRow{}
 +	for rows.Next() {
 +		var i ListOrgsForUserRow
 +		if err := rows.Scan(
 +			&i.OrgID,
 +			&i.Role,
 +			&i.Slug,
 +			&i.DisplayName,
 +			&i.AvatarObjectKey,
 +		); err != nil {
 +			return nil, err
 +		}
 +		items = append(items, i)
 +	}
 +	if err := rows.Err(); err != nil {
 +		return nil, err
 +	}
 +	return items, nil
 +}
++
 +const removeOrgMember = `-- name: RemoveOrgMember :exec
 +DELETE FROM org_members WHERE org_id = $1 AND user_id = $2
 +`
++
 +type RemoveOrgMemberParams struct {
 +	OrgID  int64
 +	UserID int64
 +}
++
 +func (q *Queries) RemoveOrgMember(ctx context.Context, db DBTX, arg RemoveOrgMemberParams) error {
 +	_, err := db.Exec(ctx, removeOrgMember, arg.OrgID, arg.UserID)
 +	return err
 +}

internal/notif/sqlc/models.go → internal/orgs/sqlc/models.gocopied (89% similarity)

  // versions:
  //   sqlc v1.31.1
 -package notifdb
 +package orgsdb
  import (
  	"database/sql/driver"
  	return string(ns.NotificationThreadKind), nil
+ }
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	UpdatedAt       pgtype.Timestamptz
+ }
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/orgs/sqlc/orgs.sql.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
 +// source: orgs.sql
++
 +package orgsdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +const createOrg = `-- name: CreateOrg :one
++
++
 +INSERT INTO orgs (slug, display_name, description, billing_email, created_by_user_id)
 +VALUES ($1, $2, $3, $4, $5::bigint)
 +RETURNING id, slug, display_name, description, avatar_object_key, location, website, billing_email, plan, allow_member_repo_create, created_by_user_id, suspended_at, suspended_reason, deleted_at, created_at, updated_at
 +`
++
 +type CreateOrgParams struct {
 +	Slug            string
 +	DisplayName     string
 +	Description     string
 +	BillingEmail    string
 +	CreatedByUserID pgtype.Int8
 +}
++
 +// SPDX-License-Identifier: AGPL-3.0-or-later
 +// ─── orgs ──────────────────────────────────────────────────────────
 +// Inserts a new org. The trigger on `orgs` populates `principals` for
 +// /{slug} resolution; the caller adds the creator as owner in the same
 +// tx (separate query so the orchestrator owns ordering).
 +func (q *Queries) CreateOrg(ctx context.Context, db DBTX, arg CreateOrgParams) (Org, error) {
 +	row := db.QueryRow(ctx, createOrg,
 +		arg.Slug,
 +		arg.DisplayName,
 +		arg.Description,
 +		arg.BillingEmail,
 +		arg.CreatedByUserID,
 +	)
 +	var i Org
 +	err := row.Scan(
 +		&i.ID,
 +		&i.Slug,
 +		&i.DisplayName,
 +		&i.Description,
 +		&i.AvatarObjectKey,
 +		&i.Location,
 +		&i.Website,
 +		&i.BillingEmail,
 +		&i.Plan,
 +		&i.AllowMemberRepoCreate,
 +		&i.CreatedByUserID,
 +		&i.SuspendedAt,
 +		&i.SuspendedReason,
 +		&i.DeletedAt,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +	)
 +	return i, err
 +}
++
 +const getOrgByID = `-- name: GetOrgByID :one
 +SELECT id, slug, display_name, description, avatar_object_key, location, website, billing_email, plan, allow_member_repo_create, created_by_user_id, suspended_at, suspended_reason, deleted_at, created_at, updated_at FROM orgs WHERE id = $1
 +`
++
 +func (q *Queries) GetOrgByID(ctx context.Context, db DBTX, id int64) (Org, error) {
 +	row := db.QueryRow(ctx, getOrgByID, id)
 +	var i Org
 +	err := row.Scan(
 +		&i.ID,
 +		&i.Slug,
 +		&i.DisplayName,
 +		&i.Description,
 +		&i.AvatarObjectKey,
 +		&i.Location,
 +		&i.Website,
 +		&i.BillingEmail,
 +		&i.Plan,
 +		&i.AllowMemberRepoCreate,
 +		&i.CreatedByUserID,
 +		&i.SuspendedAt,
 +		&i.SuspendedReason,
 +		&i.DeletedAt,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +	)
 +	return i, err
 +}
++
 +const getOrgBySlug = `-- name: GetOrgBySlug :one
 +SELECT id, slug, display_name, description, avatar_object_key, location, website, billing_email, plan, allow_member_repo_create, created_by_user_id, suspended_at, suspended_reason, deleted_at, created_at, updated_at FROM orgs
 +WHERE slug = $1
 +  AND deleted_at IS NULL
 +`
++
 +// Slug is citext so the comparison is case-insensitive. Soft-deleted
 +// orgs are filtered out so a slug freed by deletion is invisible to
 +// normal lookups (the resolver still sees the row via the deleted_at
 +// column for grace-period restore).
 +func (q *Queries) GetOrgBySlug(ctx context.Context, db DBTX, slug string) (Org, error) {
 +	row := db.QueryRow(ctx, getOrgBySlug, slug)
 +	var i Org
 +	err := row.Scan(
 +		&i.ID,
 +		&i.Slug,
 +		&i.DisplayName,
 +		&i.Description,
 +		&i.AvatarObjectKey,
 +		&i.Location,
 +		&i.Website,
 +		&i.BillingEmail,
 +		&i.Plan,
 +		&i.AllowMemberRepoCreate,
 +		&i.CreatedByUserID,
 +		&i.SuspendedAt,
 +		&i.SuspendedReason,
 +		&i.DeletedAt,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +	)
 +	return i, err
 +}
++
 +const getOrgBySlugIncludingDeleted = `-- name: GetOrgBySlugIncludingDeleted :one
 +SELECT id, slug, display_name, description, avatar_object_key, location, website, billing_email, plan, allow_member_repo_create, created_by_user_id, suspended_at, suspended_reason, deleted_at, created_at, updated_at FROM orgs WHERE slug = $1
 +`
++
 +func (q *Queries) GetOrgBySlugIncludingDeleted(ctx context.Context, db DBTX, slug string) (Org, error) {
 +	row := db.QueryRow(ctx, getOrgBySlugIncludingDeleted, slug)
 +	var i Org
 +	err := row.Scan(
 +		&i.ID,
 +		&i.Slug,
 +		&i.DisplayName,
 +		&i.Description,
 +		&i.AvatarObjectKey,
 +		&i.Location,
 +		&i.Website,
 +		&i.BillingEmail,
 +		&i.Plan,
 +		&i.AllowMemberRepoCreate,
 +		&i.CreatedByUserID,
 +		&i.SuspendedAt,
 +		&i.SuspendedReason,
 +		&i.DeletedAt,
 +		&i.CreatedAt,
 +		&i.UpdatedAt,
 +	)
 +	return i, err
 +}
++
 +const resolvePrincipal = `-- name: ResolvePrincipal :one
++
 +SELECT slug, kind, id FROM principals WHERE slug = $1
 +`
++
 +// ─── principals (read-only from this domain) ───────────────────────
 +// Single-query /{slug} resolver. Returns the (kind, id) tuple that
 +// /{slug}/* routes use to dispatch to the user-profile or org-profile
 +// handler. Both kinds share the slug PK so collisions are
 +// impossible at the DB layer.
 +func (q *Queries) ResolvePrincipal(ctx context.Context, db DBTX, slug string) (Principal, error) {
 +	row := db.QueryRow(ctx, resolvePrincipal, slug)
 +	var i Principal
 +	err := row.Scan(&i.Slug, &i.Kind, &i.ID)
 +	return i, err
 +}
++
 +const restoreOrg = `-- name: RestoreOrg :exec
 +UPDATE orgs SET deleted_at = NULL, updated_at = now() WHERE id = $1
 +`
++
 +func (q *Queries) RestoreOrg(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, restoreOrg, id)
 +	return err
 +}
++
 +const setOrgAllowMemberRepoCreate = `-- name: SetOrgAllowMemberRepoCreate :exec
 +UPDATE orgs SET allow_member_repo_create = $2, updated_at = now() WHERE id = $1
 +`
++
 +type SetOrgAllowMemberRepoCreateParams struct {
 +	ID                    int64
 +	AllowMemberRepoCreate bool
 +}
++
 +func (q *Queries) SetOrgAllowMemberRepoCreate(ctx context.Context, db DBTX, arg SetOrgAllowMemberRepoCreateParams) error {
 +	_, err := db.Exec(ctx, setOrgAllowMemberRepoCreate, arg.ID, arg.AllowMemberRepoCreate)
 +	return err
 +}
++
 +const setOrgAvatarKey = `-- name: SetOrgAvatarKey :exec
 +UPDATE orgs SET avatar_object_key = $2, updated_at = now() WHERE id = $1
 +`
++
 +type SetOrgAvatarKeyParams struct {
 +	ID              int64
 +	AvatarObjectKey pgtype.Text
 +}
++
 +func (q *Queries) SetOrgAvatarKey(ctx context.Context, db DBTX, arg SetOrgAvatarKeyParams) error {
 +	_, err := db.Exec(ctx, setOrgAvatarKey, arg.ID, arg.AvatarObjectKey)
 +	return err
 +}
++
 +const setOrgSuspended = `-- name: SetOrgSuspended :exec
 +UPDATE orgs
 +   SET suspended_at = CASE WHEN $2::boolean THEN now() ELSE NULL END,
 +       suspended_reason = CASE WHEN $2::boolean THEN $3 ELSE NULL END,
 +       updated_at = now()
 + WHERE id = $1
 +`
++
 +type SetOrgSuspendedParams struct {
 +	ID              int64
 +	Column2         bool
 +	SuspendedReason pgtype.Text
 +}
++
 +func (q *Queries) SetOrgSuspended(ctx context.Context, db DBTX, arg SetOrgSuspendedParams) error {
 +	_, err := db.Exec(ctx, setOrgSuspended, arg.ID, arg.Column2, arg.SuspendedReason)
 +	return err
 +}
++
 +const softDeleteOrg = `-- name: SoftDeleteOrg :exec
 +UPDATE orgs SET deleted_at = now(), updated_at = now() WHERE id = $1
 +`
++
 +func (q *Queries) SoftDeleteOrg(ctx context.Context, db DBTX, id int64) error {
 +	_, err := db.Exec(ctx, softDeleteOrg, id)
 +	return err
 +}
++
 +const updateOrgProfile = `-- name: UpdateOrgProfile :exec
 +UPDATE orgs
 +   SET display_name = $2,
 +       description  = $3,
 +       location     = $4,
 +       website      = $5,
 +       billing_email = $6,
 +       updated_at   = now()
 + WHERE id = $1
 +`
++
 +type UpdateOrgProfileParams struct {
 +	ID           int64
 +	DisplayName  string
 +	Description  string
 +	Location     string
 +	Website      string
 +	BillingEmail string
 +}
++
 +func (q *Queries) UpdateOrgProfile(ctx context.Context, db DBTX, arg UpdateOrgProfileParams) error {
 +	_, err := db.Exec(ctx, updateOrgProfile,
 +		arg.ID,
 +		arg.DisplayName,
 +		arg.Description,
 +		arg.Location,
 +		arg.Website,
 +		arg.BillingEmail,
 +	)
 +	return err
 +}

internal/orgs/sqlc/querier.goadded

 +// Code generated by sqlc. DO NOT EDIT.
 +// versions:
 +//   sqlc v1.31.1
++
 +package orgsdb
++
 +import (
 +	"context"
++
 +	"github.com/jackc/pgx/v5/pgtype"
 +)
++
 +type Querier interface {
 +	AcceptOrgInvitation(ctx context.Context, db DBTX, id int64) error
 +	// SPDX-License-Identifier: AGPL-3.0-or-later
 +	// ─── org_members ───────────────────────────────────────────────────
 +	// Idempotent on (org_id, user_id): re-adding a member is a no-op
 +	// rather than an error. The role is taken from the supplied row when
 +	// the member is new; existing rows keep their current role (use
 +	// ChangeOrgMemberRole to update).
 +	AddOrgMember(ctx context.Context, db DBTX, arg AddOrgMemberParams) error
 +	CancelOrgInvitation(ctx context.Context, db DBTX, id int64) error
 +	ChangeOrgMemberRole(ctx context.Context, db DBTX, arg ChangeOrgMemberRoleParams) error
 +	// Used by the last-owner protection: refuses to remove or demote the
 +	// only owner. Caller compares `count = 1` before allowing the change.
 +	CountOrgOwners(ctx context.Context, db DBTX, orgID int64) (int64, error)
 +	// SPDX-License-Identifier: AGPL-3.0-or-later
 +	// ─── orgs ──────────────────────────────────────────────────────────
 +	// Inserts a new org. The trigger on `orgs` populates `principals` for
 +	// /{slug} resolution; the caller adds the creator as owner in the same
 +	// tx (separate query so the orchestrator owns ordering).
 +	CreateOrg(ctx context.Context, db DBTX, arg CreateOrgParams) (Org, error)
 +	// SPDX-License-Identifier: AGPL-3.0-or-later
 +	// ─── org_invitations ───────────────────────────────────────────────
 +	CreateOrgInvitation(ctx context.Context, db DBTX, arg CreateOrgInvitationParams) (OrgInvitation, error)
 +	DeclineOrgInvitation(ctx context.Context, db DBTX, id int64) error
 +	// Idempotency check before creating a new invite — so a re-issued
 +	// invite to the same target doesn't accumulate stale rows.
 +	GetExistingPendingInvitation(ctx context.Context, db DBTX, arg GetExistingPendingInvitationParams) (OrgInvitation, error)
 +	GetOrgByID(ctx context.Context, db DBTX, id int64) (Org, error)
 +	// Slug is citext so the comparison is case-insensitive. Soft-deleted
 +	// orgs are filtered out so a slug freed by deletion is invisible to
 +	// normal lookups (the resolver still sees the row via the deleted_at
 +	// column for grace-period restore).
 +	GetOrgBySlug(ctx context.Context, db DBTX, slug string) (Org, error)
 +	GetOrgBySlugIncludingDeleted(ctx context.Context, db DBTX, slug string) (Org, error)
 +	GetOrgInvitationByID(ctx context.Context, db DBTX, id int64) (OrgInvitation, error)
 +	GetOrgInvitationByTokenHash(ctx context.Context, db DBTX, tokenHash []byte) (OrgInvitation, error)
 +	GetOrgMember(ctx context.Context, db DBTX, arg GetOrgMemberParams) (OrgMember, error)
 +	// Members of an org with usernames + roles for the people page.
 +	ListOrgMembers(ctx context.Context, db DBTX, orgID int64) ([]ListOrgMembersRow, error)
 +	// Profile-page input: every org a user is a member of, with role.
 +	ListOrgsForUser(ctx context.Context, db DBTX, userID int64) ([]ListOrgsForUserRow, error)
 +	ListPendingInvitationsForEmail(ctx context.Context, db DBTX, targetEmail pgtype.Text) ([]ListPendingInvitationsForEmailRow, error)
 +	ListPendingInvitationsForOrg(ctx context.Context, db DBTX, orgID int64) ([]ListPendingInvitationsForOrgRow, error)
 +	// Two flavors: by user_id (already-claimed invites) and by email
 +	// (claim-on-signup). Caller unions the two lookups when surfacing
 +	// to the user.
 +	ListPendingInvitationsForUser(ctx context.Context, db DBTX, targetUserID pgtype.Int8) ([]ListPendingInvitationsForUserRow, error)
 +	RemoveOrgMember(ctx context.Context, db DBTX, arg RemoveOrgMemberParams) error
 +	// ─── principals (read-only from this domain) ───────────────────────
 +	// Single-query /{slug} resolver. Returns the (kind, id) tuple that
 +	// /{slug}/* routes use to dispatch to the user-profile or org-profile
 +	// handler. Both kinds share the slug PK so collisions are
 +	// impossible at the DB layer.
 +	ResolvePrincipal(ctx context.Context, db DBTX, slug string) (Principal, error)
 +	RestoreOrg(ctx context.Context, db DBTX, id int64) error
 +	SetOrgAllowMemberRepoCreate(ctx context.Context, db DBTX, arg SetOrgAllowMemberRepoCreateParams) error
 +	SetOrgAvatarKey(ctx context.Context, db DBTX, arg SetOrgAvatarKeyParams) error
 +	SetOrgSuspended(ctx context.Context, db DBTX, arg SetOrgSuspendedParams) error
 +	SoftDeleteOrg(ctx context.Context, db DBTX, id int64) error
 +	UpdateOrgProfile(ctx context.Context, db DBTX, arg UpdateOrgProfileParams) error
 +}
++
 +var _ Querier = (*Queries)(nil)

internal/pulls/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/repos/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/social/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/users/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

internal/worker/sqlc/models.gomodified

  	return string(ns.MilestoneState), nil
+ }
 +type NotificationThreadKind string
++
 +const (
 +	NotificationThreadKindIssue NotificationThreadKind = "issue"
 +	NotificationThreadKindPr    NotificationThreadKind = "pr"
 +)
++
 +func (e *NotificationThreadKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = NotificationThreadKind(s)
 +	case string:
 +		*e = NotificationThreadKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for NotificationThreadKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullNotificationThreadKind struct {
 +	NotificationThreadKind NotificationThreadKind
 +	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullNotificationThreadKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.NotificationThreadKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.NotificationThreadKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullNotificationThreadKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.NotificationThreadKind), nil
 +}
++
 +type OrgPlan string
++
 +const (
 +	OrgPlanFree       OrgPlan = "free"
 +	OrgPlanTeam       OrgPlan = "team"
 +	OrgPlanEnterprise OrgPlan = "enterprise"
 +)
++
 +func (e *OrgPlan) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgPlan(s)
 +	case string:
 +		*e = OrgPlan(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgPlan: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgPlan struct {
 +	OrgPlan OrgPlan
 +	Valid   bool // Valid is true if OrgPlan is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgPlan) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgPlan, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgPlan.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgPlan) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgPlan), nil
 +}
++
 +type OrgRole string
++
 +const (
 +	OrgRoleOwner  OrgRole = "owner"
 +	OrgRoleMember OrgRole = "member"
 +)
++
 +func (e *OrgRole) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = OrgRole(s)
 +	case string:
 +		*e = OrgRole(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for OrgRole: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullOrgRole struct {
 +	OrgRole OrgRole
 +	Valid   bool // Valid is true if OrgRole is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullOrgRole) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.OrgRole, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.OrgRole.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullOrgRole) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.OrgRole), nil
 +}
++
  type PrFileStatus string
  const (
  	return string(ns.PrReviewState), nil
+ }
 +type PrincipalKind string
++
 +const (
 +	PrincipalKindUser PrincipalKind = "user"
 +	PrincipalKindOrg  PrincipalKind = "org"
 +)
++
 +func (e *PrincipalKind) Scan(src interface{}) error {
 +	switch s := src.(type) {
 +	case []byte:
 +		*e = PrincipalKind(s)
 +	case string:
 +		*e = PrincipalKind(s)
 +	default:
 +		return fmt.Errorf("unsupported scan type for PrincipalKind: %T", src)
 +	}
 +	return nil
 +}
++
 +type NullPrincipalKind struct {
 +	PrincipalKind PrincipalKind
 +	Valid         bool // Valid is true if PrincipalKind is not NULL
 +}
++
 +// Scan implements the Scanner interface.
 +func (ns *NullPrincipalKind) Scan(value interface{}) error {
 +	if value == nil {
 +		ns.PrincipalKind, ns.Valid = "", false
 +		return nil
 +	}
 +	ns.Valid = true
 +	return ns.PrincipalKind.Scan(value)
 +}
++
 +// Value implements the driver Valuer interface.
 +func (ns NullPrincipalKind) Value() (driver.Value, error) {
 +	if !ns.Valid {
 +		return nil, nil
 +	}
 +	return string(ns.PrincipalKind), nil
 +}
++
  type RepoInitStatus string
  const (
  	CreatedAt   pgtype.Timestamptz
+ }
 +type DomainEventsProcessed struct {
 +	Consumer    string
 +	LastEventID int64
 +	UpdatedAt   pgtype.Timestamptz
 +}
++
  type EmailVerification struct {
  	ID          int64
  	UserEmailID int64
  	ClosedAt    pgtype.Timestamptz
+ }
 +type Notification struct {
 +	ID              int64
 +	RecipientUserID int64
 +	Kind            string
 +	Reason          string
 +	RepoID          pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SourceEventID   pgtype.Int8
 +	Unread          bool
 +	LastEventAt     pgtype.Timestamptz
 +	LastActorUserID pgtype.Int8
 +	Summary         []byte
 +	CreatedAt       pgtype.Timestamptz
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type NotificationEmailLog struct {
 +	ID              int64
 +	RecipientUserID int64
 +	NotificationID  pgtype.Int8
 +	ThreadKind      NullNotificationThreadKind
 +	ThreadID        pgtype.Int8
 +	SentAt          pgtype.Timestamptz
 +	MessageID       pgtype.Text
 +}
++
 +type NotificationThread struct {
 +	RecipientUserID int64
 +	ThreadKind      NotificationThreadKind
 +	ThreadID        int64
 +	Subscribed      bool
 +	Reason          string
 +	UpdatedAt       pgtype.Timestamptz
 +}
++
 +type Org struct {
 +	ID                    int64
 +	Slug                  string
 +	DisplayName           string
 +	Description           string
 +	AvatarObjectKey       pgtype.Text
 +	Location              string
 +	Website               string
 +	BillingEmail          string
 +	Plan                  OrgPlan
 +	AllowMemberRepoCreate bool
 +	CreatedByUserID       pgtype.Int8
 +	SuspendedAt           pgtype.Timestamptz
 +	SuspendedReason       pgtype.Text
 +	DeletedAt             pgtype.Timestamptz
 +	CreatedAt             pgtype.Timestamptz
 +	UpdatedAt             pgtype.Timestamptz
 +}
++
 +type OrgInvitation struct {
 +	ID              int64
 +	OrgID           int64
 +	InvitedByUserID pgtype.Int8
 +	TargetUserID    pgtype.Int8
 +	TargetEmail     pgtype.Text
 +	Role            OrgRole
 +	TokenHash       []byte
 +	ExpiresAt       pgtype.Timestamptz
 +	AcceptedAt      pgtype.Timestamptz
 +	DeclinedAt      pgtype.Timestamptz
 +	CanceledAt      pgtype.Timestamptz
 +	CreatedAt       pgtype.Timestamptz
 +}
++
 +type OrgMember struct {
 +	OrgID           int64
 +	UserID          int64
 +	Role            OrgRole
 +	InvitedByUserID pgtype.Int8
 +	JoinedAt        pgtype.Timestamptz
 +}
++
  type PasswordReset struct {
  	ID        int64
  	UserID    int64
  	SatisfiedByReviewID pgtype.Int8
+ }
 +type Principal struct {
 +	Slug string
 +	Kind PrincipalKind
 +	ID   int64
 +}
++
  type PullRequest struct {
  	IssueID            int64
  	BaseRef            string

sqlc.yamlmodified

          emit_exact_table_names: false
          emit_empty_slices: true
          emit_methods_with_db_argument: true
++
 +  - engine: postgresql
 +    schema: internal/migrationsfs/migrations
 +    queries: internal/notif/queries
 +    gen:
 +      go:
 +        package: notifdb
 +        out: internal/notif/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/orgs/queries
 +    gen:
 +      go:
 +        package: orgsdb
 +        out: internal/orgs/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