Containr/app/backend/internal/database/sqlcdb/services_meta.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: services_meta.sql

package sqlcdb

import (
	"context"
	"database/sql"
	"encoding/json"

	"github.com/google/uuid"
)

const deleteEnvVarsForService = `-- name: DeleteEnvVarsForService :exec
DELETE FROM environment_variables WHERE service_id = $1
`

func (q *Queries) DeleteEnvVarsForService(ctx context.Context, serviceID uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteEnvVarsForService, serviceID)
	return err
}

const failInterruptedDeployments = `-- name: FailInterruptedDeployments :exec
UPDATE deployments SET status = 'failed', error = 'Interrupted by server restart', completed_at = NOW(), updated_at = NOW()
WHERE status IN ('queued', 'pending', 'building', 'deploying', 'rolling_back')
`

func (q *Queries) FailInterruptedDeployments(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, failInterruptedDeployments)
	return err
}

const getEnvironmentProjectID = `-- name: GetEnvironmentProjectID :one
SELECT project_id FROM environments WHERE id = $1
`

func (q *Queries) GetEnvironmentProjectID(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, getEnvironmentProjectID, id)
	var project_id uuid.UUID
	err := row.Scan(&project_id)
	return project_id, err
}

const getNodeAgentName = `-- name: GetNodeAgentName :one
SELECT name FROM node_agents WHERE id = $1
`

func (q *Queries) GetNodeAgentName(ctx context.Context, id string) (string, error) {
	row := q.db.QueryRowContext(ctx, getNodeAgentName, id)
	var name string
	err := row.Scan(&name)
	return name, err
}

const getProjectReadAccess = `-- name: GetProjectReadAccess :one
SELECT is_approved, owner_id::text FROM projects WHERE id = $1
`

type GetProjectReadAccessRow struct {
	IsApproved bool   `json:"is_approved"`
	OwnerID    string `json:"owner_id"`
}

func (q *Queries) GetProjectReadAccess(ctx context.Context, id uuid.UUID) (GetProjectReadAccessRow, error) {
	row := q.db.QueryRowContext(ctx, getProjectReadAccess, id)
	var i GetProjectReadAccessRow
	err := row.Scan(&i.IsApproved, &i.OwnerID)
	return i, err
}

const getServiceNameProjectPort = `-- name: GetServiceNameProjectPort :one
SELECT name, project_id::text, COALESCE(port, 0)::int AS port
FROM services WHERE id::text = $1
`

type GetServiceNameProjectPortRow struct {
	Name      string `json:"name"`
	ProjectID string `json:"project_id"`
	Port      int32  `json:"port"`
}

func (q *Queries) GetServiceNameProjectPort(ctx context.Context, id uuid.UUID) (GetServiceNameProjectPortRow, error) {
	row := q.db.QueryRowContext(ctx, getServiceNameProjectPort, id)
	var i GetServiceNameProjectPortRow
	err := row.Scan(&i.Name, &i.ProjectID, &i.Port)
	return i, err
}

const getServiceNodeID = `-- name: GetServiceNodeID :one
SELECT node_id FROM services WHERE id = $1
`

func (q *Queries) GetServiceNodeID(ctx context.Context, id uuid.UUID) (sql.NullString, error) {
	row := q.db.QueryRowContext(ctx, getServiceNodeID, id)
	var node_id sql.NullString
	err := row.Scan(&node_id)
	return node_id, err
}

const getServicePlacementTags = `-- name: GetServicePlacementTags :one
SELECT placement_tags FROM services WHERE id = $1
`

func (q *Queries) GetServicePlacementTags(ctx context.Context, id uuid.UUID) (json.RawMessage, error) {
	row := q.db.QueryRowContext(ctx, getServicePlacementTags, id)
	var placement_tags json.RawMessage
	err := row.Scan(&placement_tags)
	return placement_tags, err
}

const getServiceProjectAndStatus = `-- name: GetServiceProjectAndStatus :one
SELECT s.project_id, COALESCE(s.status, '') AS status
FROM services s WHERE s.id = $1
`

type GetServiceProjectAndStatusRow struct {
	ProjectID uuid.UUID `json:"project_id"`
	Status    string    `json:"status"`
}

func (q *Queries) GetServiceProjectAndStatus(ctx context.Context, id uuid.UUID) (GetServiceProjectAndStatusRow, error) {
	row := q.db.QueryRowContext(ctx, getServiceProjectAndStatus, id)
	var i GetServiceProjectAndStatusRow
	err := row.Scan(&i.ProjectID, &i.Status)
	return i, err
}

const getServiceProjectID = `-- name: GetServiceProjectID :one
SELECT project_id FROM services WHERE id = $1
`

func (q *Queries) GetServiceProjectID(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, getServiceProjectID, id)
	var project_id uuid.UUID
	err := row.Scan(&project_id)
	return project_id, err
}

const getServiceSleep = `-- name: GetServiceSleep :one
SELECT COALESCE(sleep_enabled, false) AS sleep_enabled, COALESCE(sleep_idle_minutes, 15) AS sleep_idle_minutes
FROM services WHERE id = $1
`

type GetServiceSleepRow struct {
	SleepEnabled     bool  `json:"sleep_enabled"`
	SleepIdleMinutes int32 `json:"sleep_idle_minutes"`
}

func (q *Queries) GetServiceSleep(ctx context.Context, id uuid.UUID) (GetServiceSleepRow, error) {
	row := q.db.QueryRowContext(ctx, getServiceSleep, id)
	var i GetServiceSleepRow
	err := row.Scan(&i.SleepEnabled, &i.SleepIdleMinutes)
	return i, err
}

const getServiceSpread = `-- name: GetServiceSpread :one
SELECT COALESCE(spread, false) FROM services WHERE id = $1
`

func (q *Queries) GetServiceSpread(ctx context.Context, id uuid.UUID) (bool, error) {
	row := q.db.QueryRowContext(ctx, getServiceSpread, id)
	var spread bool
	err := row.Scan(&spread)
	return spread, err
}

const getServiceTraefikLabels = `-- name: GetServiceTraefikLabels :one
SELECT traefik_labels FROM services WHERE id = $1
`

func (q *Queries) GetServiceTraefikLabels(ctx context.Context, id uuid.UUID) (json.RawMessage, error) {
	row := q.db.QueryRowContext(ctx, getServiceTraefikLabels, id)
	var traefik_labels json.RawMessage
	err := row.Scan(&traefik_labels)
	return traefik_labels, err
}

const getServiceVolumes = `-- name: GetServiceVolumes :one
SELECT volumes FROM services WHERE id = $1
`

func (q *Queries) GetServiceVolumes(ctx context.Context, id uuid.UUID) (json.RawMessage, error) {
	row := q.db.QueryRowContext(ctx, getServiceVolumes, id)
	var volumes json.RawMessage
	err := row.Scan(&volumes)
	return volumes, err
}

const listAgentHealthRows = `-- name: ListAgentHealthRows :many
SELECT id, COALESCE(name, hostname, id::text) AS name, COALESCE(status, '') AS status,
       COALESCE(last_heartbeat < $1, TRUE)::bool AS stale, auto_prune
FROM node_agents
`

type ListAgentHealthRowsRow struct {
	ID        string `json:"id"`
	Name      string `json:"name"`
	Status    string `json:"status"`
	Stale     bool   `json:"stale"`
	AutoPrune bool   `json:"auto_prune"`
}

func (q *Queries) ListAgentHealthRows(ctx context.Context, lastHeartbeat sql.NullTime) ([]ListAgentHealthRowsRow, error) {
	rows, err := q.db.QueryContext(ctx, listAgentHealthRows, lastHeartbeat)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAgentHealthRowsRow{}
	for rows.Next() {
		var i ListAgentHealthRowsRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Status,
			&i.Stale,
			&i.AutoPrune,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listSecretEnvVars = `-- name: ListSecretEnvVars :many
SELECT id, value FROM environment_variables WHERE is_secret = TRUE
`

type ListSecretEnvVarsRow struct {
	ID    uuid.UUID `json:"id"`
	Value string    `json:"value"`
}

func (q *Queries) ListSecretEnvVars(ctx context.Context) ([]ListSecretEnvVarsRow, error) {
	rows, err := q.db.QueryContext(ctx, listSecretEnvVars)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListSecretEnvVarsRow{}
	for rows.Next() {
		var i ListSecretEnvVarsRow
		if err := rows.Scan(&i.ID, &i.Value); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const projectMemberExists = `-- name: ProjectMemberExists :one
SELECT EXISTS(SELECT 1 FROM project_members WHERE project_id = $1 AND user_id = $2)
`

type ProjectMemberExistsParams struct {
	ProjectID uuid.UUID `json:"project_id"`
	UserID    uuid.UUID `json:"user_id"`
}

func (q *Queries) ProjectMemberExists(ctx context.Context, arg ProjectMemberExistsParams) (bool, error) {
	row := q.db.QueryRowContext(ctx, projectMemberExists, arg.ProjectID, arg.UserID)
	var exists bool
	err := row.Scan(&exists)
	return exists, err
}

const setAgentStatus = `-- name: SetAgentStatus :exec
UPDATE node_agents SET status = $1, updated_at = NOW() WHERE id = $2
`

type SetAgentStatusParams struct {
	Status sql.NullString `json:"status"`
	ID     string         `json:"id"`
}

func (q *Queries) SetAgentStatus(ctx context.Context, arg SetAgentStatusParams) error {
	_, err := q.db.ExecContext(ctx, setAgentStatus, arg.Status, arg.ID)
	return err
}

const updateEnvVarValue = `-- name: UpdateEnvVarValue :exec
UPDATE environment_variables SET value = $1, updated_at = NOW() WHERE id = $2
`

type UpdateEnvVarValueParams struct {
	Value string    `json:"value"`
	ID    uuid.UUID `json:"id"`
}

func (q *Queries) UpdateEnvVarValue(ctx context.Context, arg UpdateEnvVarValueParams) error {
	_, err := q.db.ExecContext(ctx, updateEnvVarValue, arg.Value, arg.ID)
	return err
}