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

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

package db

import (
	"context"

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

const getTemplateBuild = `-- name: GetTemplateBuild :one
SELECT id, name, base_template, recipe, healthcheck, vcpus, memory_mb, status, current_step, total_steps, logs, error, sandbox_id, host_id, created_at, started_at, completed_at, template_id, team_id, skip_pre_post, default_user, default_env, metadata FROM template_builds WHERE id = $1
`

func (q *Queries) GetTemplateBuild(ctx context.Context, id pgtype.UUID) (TemplateBuild, error) {
	row := q.db.QueryRow(ctx, getTemplateBuild, id)
	var i TemplateBuild
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.BaseTemplate,
		&i.Recipe,
		&i.Healthcheck,
		&i.Vcpus,
		&i.MemoryMb,
		&i.Status,
		&i.CurrentStep,
		&i.TotalSteps,
		&i.Logs,
		&i.Error,
		&i.SandboxID,
		&i.HostID,
		&i.CreatedAt,
		&i.StartedAt,
		&i.CompletedAt,
		&i.TemplateID,
		&i.TeamID,
		&i.SkipPrePost,
		&i.DefaultUser,
		&i.DefaultEnv,
		&i.Metadata,
	)
	return i, err
}

const insertTemplateBuild = `-- name: InsertTemplateBuild :one
INSERT INTO template_builds (id, name, base_template, recipe, healthcheck, vcpus, memory_mb, status, total_steps, template_id, team_id, skip_pre_post)
VALUES ($1, $2, $3, $4, $5, $6, $7, 'pending', $8, $9, $10, $11)
RETURNING id, name, base_template, recipe, healthcheck, vcpus, memory_mb, status, current_step, total_steps, logs, error, sandbox_id, host_id, created_at, started_at, completed_at, template_id, team_id, skip_pre_post, default_user, default_env, metadata
`

type InsertTemplateBuildParams struct {
	ID           pgtype.UUID `json:"id"`
	Name         string      `json:"name"`
	BaseTemplate string      `json:"base_template"`
	Recipe       []byte      `json:"recipe"`
	Healthcheck  string      `json:"healthcheck"`
	Vcpus        int32       `json:"vcpus"`
	MemoryMb     int32       `json:"memory_mb"`
	TotalSteps   int32       `json:"total_steps"`
	TemplateID   pgtype.UUID `json:"template_id"`
	TeamID       pgtype.UUID `json:"team_id"`
	SkipPrePost  bool        `json:"skip_pre_post"`
}

func (q *Queries) InsertTemplateBuild(ctx context.Context, arg InsertTemplateBuildParams) (TemplateBuild, error) {
	row := q.db.QueryRow(ctx, insertTemplateBuild,
		arg.ID,
		arg.Name,
		arg.BaseTemplate,
		arg.Recipe,
		arg.Healthcheck,
		arg.Vcpus,
		arg.MemoryMb,
		arg.TotalSteps,
		arg.TemplateID,
		arg.TeamID,
		arg.SkipPrePost,
	)
	var i TemplateBuild
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.BaseTemplate,
		&i.Recipe,
		&i.Healthcheck,
		&i.Vcpus,
		&i.MemoryMb,
		&i.Status,
		&i.CurrentStep,
		&i.TotalSteps,
		&i.Logs,
		&i.Error,
		&i.SandboxID,
		&i.HostID,
		&i.CreatedAt,
		&i.StartedAt,
		&i.CompletedAt,
		&i.TemplateID,
		&i.TeamID,
		&i.SkipPrePost,
		&i.DefaultUser,
		&i.DefaultEnv,
		&i.Metadata,
	)
	return i, err
}

const listTemplateBuilds = `-- name: ListTemplateBuilds :many
SELECT id, name, base_template, recipe, healthcheck, vcpus, memory_mb, status, current_step, total_steps, logs, error, sandbox_id, host_id, created_at, started_at, completed_at, template_id, team_id, skip_pre_post, default_user, default_env, metadata FROM template_builds ORDER BY created_at DESC
`

func (q *Queries) ListTemplateBuilds(ctx context.Context) ([]TemplateBuild, error) {
	rows, err := q.db.Query(ctx, listTemplateBuilds)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []TemplateBuild
	for rows.Next() {
		var i TemplateBuild
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.BaseTemplate,
			&i.Recipe,
			&i.Healthcheck,
			&i.Vcpus,
			&i.MemoryMb,
			&i.Status,
			&i.CurrentStep,
			&i.TotalSteps,
			&i.Logs,
			&i.Error,
			&i.SandboxID,
			&i.HostID,
			&i.CreatedAt,
			&i.StartedAt,
			&i.CompletedAt,
			&i.TemplateID,
			&i.TeamID,
			&i.SkipPrePost,
			&i.DefaultUser,
			&i.DefaultEnv,
			&i.Metadata,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateBuildDefaults = `-- name: UpdateBuildDefaults :exec
UPDATE template_builds
SET default_user = $2, default_env = $3, metadata = $4
WHERE id = $1
`

type UpdateBuildDefaultsParams struct {
	ID          pgtype.UUID `json:"id"`
	DefaultUser string      `json:"default_user"`
	DefaultEnv  []byte      `json:"default_env"`
	Metadata    []byte      `json:"metadata"`
}

func (q *Queries) UpdateBuildDefaults(ctx context.Context, arg UpdateBuildDefaultsParams) error {
	_, err := q.db.Exec(ctx, updateBuildDefaults,
		arg.ID,
		arg.DefaultUser,
		arg.DefaultEnv,
		arg.Metadata,
	)
	return err
}

const updateBuildError = `-- name: UpdateBuildError :exec
UPDATE template_builds
SET error = $2, status = 'failed', completed_at = NOW()
WHERE id = $1
`

type UpdateBuildErrorParams struct {
	ID    pgtype.UUID `json:"id"`
	Error string      `json:"error"`
}

func (q *Queries) UpdateBuildError(ctx context.Context, arg UpdateBuildErrorParams) error {
	_, err := q.db.Exec(ctx, updateBuildError, arg.ID, arg.Error)
	return err
}

const updateBuildProgress = `-- name: UpdateBuildProgress :exec
UPDATE template_builds
SET current_step = $2, logs = $3
WHERE id = $1
`

type UpdateBuildProgressParams struct {
	ID          pgtype.UUID `json:"id"`
	CurrentStep int32       `json:"current_step"`
	Logs        []byte      `json:"logs"`
}

func (q *Queries) UpdateBuildProgress(ctx context.Context, arg UpdateBuildProgressParams) error {
	_, err := q.db.Exec(ctx, updateBuildProgress, arg.ID, arg.CurrentStep, arg.Logs)
	return err
}

const updateBuildSandbox = `-- name: UpdateBuildSandbox :exec
UPDATE template_builds
SET sandbox_id = $2, host_id = $3
WHERE id = $1
`

type UpdateBuildSandboxParams struct {
	ID        pgtype.UUID `json:"id"`
	SandboxID pgtype.UUID `json:"sandbox_id"`
	HostID    pgtype.UUID `json:"host_id"`
}

func (q *Queries) UpdateBuildSandbox(ctx context.Context, arg UpdateBuildSandboxParams) error {
	_, err := q.db.Exec(ctx, updateBuildSandbox, arg.ID, arg.SandboxID, arg.HostID)
	return err
}

const updateBuildStatus = `-- name: UpdateBuildStatus :one
UPDATE template_builds
SET status = $2,
    started_at   = CASE WHEN $2 = 'running'   AND started_at   IS NULL THEN NOW() ELSE started_at   END,
    completed_at = CASE WHEN $2 IN ('success', 'failed', 'cancelled') THEN NOW() ELSE completed_at END
WHERE id = $1
RETURNING id, name, base_template, recipe, healthcheck, vcpus, memory_mb, status, current_step, total_steps, logs, error, sandbox_id, host_id, created_at, started_at, completed_at, template_id, team_id, skip_pre_post, default_user, default_env, metadata
`

type UpdateBuildStatusParams struct {
	ID     pgtype.UUID `json:"id"`
	Status string      `json:"status"`
}

func (q *Queries) UpdateBuildStatus(ctx context.Context, arg UpdateBuildStatusParams) (TemplateBuild, error) {
	row := q.db.QueryRow(ctx, updateBuildStatus, arg.ID, arg.Status)
	var i TemplateBuild
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.BaseTemplate,
		&i.Recipe,
		&i.Healthcheck,
		&i.Vcpus,
		&i.MemoryMb,
		&i.Status,
		&i.CurrentStep,
		&i.TotalSteps,
		&i.Logs,
		&i.Error,
		&i.SandboxID,
		&i.HostID,
		&i.CreatedAt,
		&i.StartedAt,
		&i.CompletedAt,
		&i.TemplateID,
		&i.TeamID,
		&i.SkipPrePost,
		&i.DefaultUser,
		&i.DefaultEnv,
		&i.Metadata,
	)
	return i, err
}