wrenn-releases/pkg/db/teams.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: teams.sql

package db

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const countTeamsAdmin = `-- name: CountTeamsAdmin :one
SELECT COUNT(*)::int AS total
FROM teams
WHERE id != '00000000-0000-0000-0000-000000000000'
`

func (q *Queries) CountTeamsAdmin(ctx context.Context) (int32, error) {
	row := q.db.QueryRow(ctx, countTeamsAdmin)
	var total int32
	err := row.Scan(&total)
	return total, err
}

const deleteTeamMember = `-- name: DeleteTeamMember :exec
DELETE FROM users_teams WHERE team_id = $1 AND user_id = $2
`

type DeleteTeamMemberParams struct {
	TeamID pgtype.UUID `json:"team_id"`
	UserID pgtype.UUID `json:"user_id"`
}

func (q *Queries) DeleteTeamMember(ctx context.Context, arg DeleteTeamMemberParams) error {
	_, err := q.db.Exec(ctx, deleteTeamMember, arg.TeamID, arg.UserID)
	return err
}

const getBYOCTeams = `-- name: GetBYOCTeams :many
SELECT id, name, slug, is_byoc, created_at, deleted_at FROM teams WHERE is_byoc = TRUE AND deleted_at IS NULL ORDER BY created_at
`

func (q *Queries) GetBYOCTeams(ctx context.Context) ([]Team, error) {
	rows, err := q.db.Query(ctx, getBYOCTeams)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Team
	for rows.Next() {
		var i Team
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Slug,
			&i.IsByoc,
			&i.CreatedAt,
			&i.DeletedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getDefaultTeamForUser = `-- name: GetDefaultTeamForUser :one
SELECT t.id, t.name, t.slug, t.is_byoc, t.created_at, t.deleted_at FROM teams t
JOIN users_teams ut ON ut.team_id = t.id
WHERE ut.user_id = $1 AND ut.is_default = TRUE AND t.deleted_at IS NULL
LIMIT 1
`

func (q *Queries) GetDefaultTeamForUser(ctx context.Context, userID pgtype.UUID) (Team, error) {
	row := q.db.QueryRow(ctx, getDefaultTeamForUser, userID)
	var i Team
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Slug,
		&i.IsByoc,
		&i.CreatedAt,
		&i.DeletedAt,
	)
	return i, err
}

const getTeam = `-- name: GetTeam :one
SELECT id, name, slug, is_byoc, created_at, deleted_at FROM teams WHERE id = $1
`

func (q *Queries) GetTeam(ctx context.Context, id pgtype.UUID) (Team, error) {
	row := q.db.QueryRow(ctx, getTeam, id)
	var i Team
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Slug,
		&i.IsByoc,
		&i.CreatedAt,
		&i.DeletedAt,
	)
	return i, err
}

const getTeamBySlug = `-- name: GetTeamBySlug :one
SELECT id, name, slug, is_byoc, created_at, deleted_at FROM teams WHERE slug = $1 AND deleted_at IS NULL
`

func (q *Queries) GetTeamBySlug(ctx context.Context, slug string) (Team, error) {
	row := q.db.QueryRow(ctx, getTeamBySlug, slug)
	var i Team
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Slug,
		&i.IsByoc,
		&i.CreatedAt,
		&i.DeletedAt,
	)
	return i, err
}

const getTeamMembers = `-- name: GetTeamMembers :many
SELECT u.id, u.name, u.email, ut.role, ut.created_at AS joined_at
FROM users_teams ut
JOIN users u ON u.id = ut.user_id
WHERE ut.team_id = $1
ORDER BY ut.created_at
`

type GetTeamMembersRow struct {
	ID       pgtype.UUID        `json:"id"`
	Name     string             `json:"name"`
	Email    string             `json:"email"`
	Role     string             `json:"role"`
	JoinedAt pgtype.Timestamptz `json:"joined_at"`
}

func (q *Queries) GetTeamMembers(ctx context.Context, teamID pgtype.UUID) ([]GetTeamMembersRow, error) {
	rows, err := q.db.Query(ctx, getTeamMembers, teamID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetTeamMembersRow
	for rows.Next() {
		var i GetTeamMembersRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Email,
			&i.Role,
			&i.JoinedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTeamMembership = `-- name: GetTeamMembership :one
SELECT user_id, team_id, is_default, role, created_at FROM users_teams WHERE user_id = $1 AND team_id = $2
`

type GetTeamMembershipParams struct {
	UserID pgtype.UUID `json:"user_id"`
	TeamID pgtype.UUID `json:"team_id"`
}

func (q *Queries) GetTeamMembership(ctx context.Context, arg GetTeamMembershipParams) (UsersTeam, error) {
	row := q.db.QueryRow(ctx, getTeamMembership, arg.UserID, arg.TeamID)
	var i UsersTeam
	err := row.Scan(
		&i.UserID,
		&i.TeamID,
		&i.IsDefault,
		&i.Role,
		&i.CreatedAt,
	)
	return i, err
}

const getTeamsForUser = `-- name: GetTeamsForUser :many
SELECT t.id, t.name, t.slug, t.is_byoc, t.created_at, t.deleted_at, ut.role
FROM teams t
JOIN users_teams ut ON ut.team_id = t.id
WHERE ut.user_id = $1 AND t.deleted_at IS NULL
ORDER BY ut.created_at
`

type GetTeamsForUserRow struct {
	ID        pgtype.UUID        `json:"id"`
	Name      string             `json:"name"`
	Slug      string             `json:"slug"`
	IsByoc    bool               `json:"is_byoc"`
	CreatedAt pgtype.Timestamptz `json:"created_at"`
	DeletedAt pgtype.Timestamptz `json:"deleted_at"`
	Role      string             `json:"role"`
}

func (q *Queries) GetTeamsForUser(ctx context.Context, userID pgtype.UUID) ([]GetTeamsForUserRow, error) {
	rows, err := q.db.Query(ctx, getTeamsForUser, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetTeamsForUserRow
	for rows.Next() {
		var i GetTeamsForUserRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Slug,
			&i.IsByoc,
			&i.CreatedAt,
			&i.DeletedAt,
			&i.Role,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const insertTeam = `-- name: InsertTeam :one
INSERT INTO teams (id, name, slug)
VALUES ($1, $2, $3)
RETURNING id, name, slug, is_byoc, created_at, deleted_at
`

type InsertTeamParams struct {
	ID   pgtype.UUID `json:"id"`
	Name string      `json:"name"`
	Slug string      `json:"slug"`
}

func (q *Queries) InsertTeam(ctx context.Context, arg InsertTeamParams) (Team, error) {
	row := q.db.QueryRow(ctx, insertTeam, arg.ID, arg.Name, arg.Slug)
	var i Team
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Slug,
		&i.IsByoc,
		&i.CreatedAt,
		&i.DeletedAt,
	)
	return i, err
}

const insertTeamMember = `-- name: InsertTeamMember :exec
INSERT INTO users_teams (user_id, team_id, is_default, role)
VALUES ($1, $2, $3, $4)
`

type InsertTeamMemberParams struct {
	UserID    pgtype.UUID `json:"user_id"`
	TeamID    pgtype.UUID `json:"team_id"`
	IsDefault bool        `json:"is_default"`
	Role      string      `json:"role"`
}

func (q *Queries) InsertTeamMember(ctx context.Context, arg InsertTeamMemberParams) error {
	_, err := q.db.Exec(ctx, insertTeamMember,
		arg.UserID,
		arg.TeamID,
		arg.IsDefault,
		arg.Role,
	)
	return err
}

const listSoleOwnedTeams = `-- name: ListSoleOwnedTeams :many
SELECT t.id FROM teams t
JOIN users_teams ut ON ut.team_id = t.id
WHERE ut.user_id = $1
  AND ut.role = 'owner'
  AND t.deleted_at IS NULL
  AND NOT EXISTS (
      SELECT 1 FROM users_teams ut2
      WHERE ut2.team_id = t.id AND ut2.user_id <> $1
  )
`

// Returns teams where the user is the owner and no other members exist.
func (q *Queries) ListSoleOwnedTeams(ctx context.Context, userID pgtype.UUID) ([]pgtype.UUID, error) {
	rows, err := q.db.Query(ctx, listSoleOwnedTeams, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []pgtype.UUID
	for rows.Next() {
		var id pgtype.UUID
		if err := rows.Scan(&id); err != nil {
			return nil, err
		}
		items = append(items, id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listTeamsAdmin = `-- name: ListTeamsAdmin :many
SELECT
    t.id,
    t.name,
    t.slug,
    t.is_byoc,
    t.created_at,
    t.deleted_at,
    (SELECT COUNT(*) FROM users_teams ut WHERE ut.team_id = t.id)::int AS member_count,
    COALESCE(owner_u.name, '') AS owner_name,
    COALESCE(owner_u.email, '') AS owner_email,
    (SELECT COUNT(*) FROM sandboxes s WHERE s.team_id = t.id AND s.status IN ('running', 'paused', 'starting'))::int AS active_sandbox_count,
    (SELECT COUNT(*) FROM channels c WHERE c.team_id = t.id)::int AS channel_count
FROM teams t
LEFT JOIN users_teams owner_ut ON owner_ut.team_id = t.id AND owner_ut.role = 'owner'
LEFT JOIN users owner_u ON owner_u.id = owner_ut.user_id
WHERE t.id != '00000000-0000-0000-0000-000000000000'
ORDER BY t.deleted_at ASC NULLS FIRST, t.created_at DESC
LIMIT $1 OFFSET $2
`

type ListTeamsAdminParams struct {
	Limit  int32 `json:"limit"`
	Offset int32 `json:"offset"`
}

type ListTeamsAdminRow struct {
	ID                 pgtype.UUID        `json:"id"`
	Name               string             `json:"name"`
	Slug               string             `json:"slug"`
	IsByoc             bool               `json:"is_byoc"`
	CreatedAt          pgtype.Timestamptz `json:"created_at"`
	DeletedAt          pgtype.Timestamptz `json:"deleted_at"`
	MemberCount        int32              `json:"member_count"`
	OwnerName          string             `json:"owner_name"`
	OwnerEmail         string             `json:"owner_email"`
	ActiveSandboxCount int32              `json:"active_sandbox_count"`
	ChannelCount       int32              `json:"channel_count"`
}

func (q *Queries) ListTeamsAdmin(ctx context.Context, arg ListTeamsAdminParams) ([]ListTeamsAdminRow, error) {
	rows, err := q.db.Query(ctx, listTeamsAdmin, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []ListTeamsAdminRow
	for rows.Next() {
		var i ListTeamsAdminRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Slug,
			&i.IsByoc,
			&i.CreatedAt,
			&i.DeletedAt,
			&i.MemberCount,
			&i.OwnerName,
			&i.OwnerEmail,
			&i.ActiveSandboxCount,
			&i.ChannelCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const setTeamBYOC = `-- name: SetTeamBYOC :exec
UPDATE teams SET is_byoc = $2 WHERE id = $1
`

type SetTeamBYOCParams struct {
	ID     pgtype.UUID `json:"id"`
	IsByoc bool        `json:"is_byoc"`
}

func (q *Queries) SetTeamBYOC(ctx context.Context, arg SetTeamBYOCParams) error {
	_, err := q.db.Exec(ctx, setTeamBYOC, arg.ID, arg.IsByoc)
	return err
}

const softDeleteTeam = `-- name: SoftDeleteTeam :exec
UPDATE teams SET deleted_at = NOW() WHERE id = $1
`

func (q *Queries) SoftDeleteTeam(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, softDeleteTeam, id)
	return err
}

const updateMemberRole = `-- name: UpdateMemberRole :exec
UPDATE users_teams SET role = $3 WHERE team_id = $1 AND user_id = $2
`

type UpdateMemberRoleParams struct {
	TeamID pgtype.UUID `json:"team_id"`
	UserID pgtype.UUID `json:"user_id"`
	Role   string      `json:"role"`
}

func (q *Queries) UpdateMemberRole(ctx context.Context, arg UpdateMemberRoleParams) error {
	_, err := q.db.Exec(ctx, updateMemberRole, arg.TeamID, arg.UserID, arg.Role)
	return err
}

const updateTeamName = `-- name: UpdateTeamName :exec
UPDATE teams SET name = $2 WHERE id = $1 AND deleted_at IS NULL
`

type UpdateTeamNameParams struct {
	ID   pgtype.UUID `json:"id"`
	Name string      `json:"name"`
}

func (q *Queries) UpdateTeamName(ctx context.Context, arg UpdateTeamNameParams) error {
	_, err := q.db.Exec(ctx, updateTeamName, arg.ID, arg.Name)
	return err
}