forked from wrenn/wrenn
pptx704
a5ad3731f2
Moves 12 packages from internal/ to pkg/ (config, id, validate, events, db, auth, lifecycle, scheduler, channels, audit, service) so they can be imported by the enterprise repo as a Go module dependency. Introduces pkg/cpextension (shared Extension interface + ServerContext) and pkg/cpserver (Run() entrypoint with functional options) so the enterprise main.go can call cpserver.Run(cpserver.WithExtensions(...)) without duplicating the 20-step server bootstrap. Adds db/migrations/embed.go for go:embed access to OSS SQL migrations from the enterprise module. cmd/control-plane/main.go is reduced to a 10-line wrapper around cpserver.Run.
388 lines
9.8 KiB
Go
388 lines
9.8 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.30.0
|
|
// source: templates.sql
|
|
|
|
package db
|
|
|
|
import (
|
|
"context"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const deleteTemplate = `-- name: DeleteTemplate :exec
|
|
DELETE FROM templates WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteTemplate(ctx context.Context, id pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteTemplate, id)
|
|
return err
|
|
}
|
|
|
|
const deleteTemplateByTeam = `-- name: DeleteTemplateByTeam :exec
|
|
DELETE FROM templates WHERE name = $1 AND team_id = $2
|
|
`
|
|
|
|
type DeleteTemplateByTeamParams struct {
|
|
Name string `json:"name"`
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
}
|
|
|
|
func (q *Queries) DeleteTemplateByTeam(ctx context.Context, arg DeleteTemplateByTeamParams) error {
|
|
_, err := q.db.Exec(ctx, deleteTemplateByTeam, arg.Name, arg.TeamID)
|
|
return err
|
|
}
|
|
|
|
const deleteTemplatesByTeam = `-- name: DeleteTemplatesByTeam :exec
|
|
DELETE FROM templates WHERE team_id = $1
|
|
`
|
|
|
|
// Bulk delete all templates owned by a team (for team soft-delete cleanup).
|
|
func (q *Queries) DeleteTemplatesByTeam(ctx context.Context, teamID pgtype.UUID) error {
|
|
_, err := q.db.Exec(ctx, deleteTemplatesByTeam, teamID)
|
|
return err
|
|
}
|
|
|
|
const getPlatformTemplateByName = `-- name: GetPlatformTemplateByName :one
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE team_id = '00000000-0000-0000-0000-000000000000' AND name = $1
|
|
`
|
|
|
|
// Check if a global (platform) template exists with the given name.
|
|
func (q *Queries) GetPlatformTemplateByName(ctx context.Context, name string) (Template, error) {
|
|
row := q.db.QueryRow(ctx, getPlatformTemplateByName, name)
|
|
var i Template
|
|
err := row.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&i.DefaultUser,
|
|
&i.DefaultEnv,
|
|
&i.Metadata,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getTemplate = `-- name: GetTemplate :one
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) GetTemplate(ctx context.Context, id pgtype.UUID) (Template, error) {
|
|
row := q.db.QueryRow(ctx, getTemplate, id)
|
|
var i Template
|
|
err := row.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&i.DefaultUser,
|
|
&i.DefaultEnv,
|
|
&i.Metadata,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getTemplateByName = `-- name: GetTemplateByName :one
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE team_id = $1 AND name = $2
|
|
`
|
|
|
|
type GetTemplateByNameParams struct {
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
// Look up a template by team_id and name (exact team match, no global fallback).
|
|
func (q *Queries) GetTemplateByName(ctx context.Context, arg GetTemplateByNameParams) (Template, error) {
|
|
row := q.db.QueryRow(ctx, getTemplateByName, arg.TeamID, arg.Name)
|
|
var i Template
|
|
err := row.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&i.DefaultUser,
|
|
&i.DefaultEnv,
|
|
&i.Metadata,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getTemplateByTeam = `-- name: GetTemplateByTeam :one
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE name = $1 AND (team_id = $2 OR team_id = '00000000-0000-0000-0000-000000000000')
|
|
`
|
|
|
|
type GetTemplateByTeamParams struct {
|
|
Name string `json:"name"`
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
}
|
|
|
|
// Platform templates (team_id = 00000000-...) are visible to all teams.
|
|
func (q *Queries) GetTemplateByTeam(ctx context.Context, arg GetTemplateByTeamParams) (Template, error) {
|
|
row := q.db.QueryRow(ctx, getTemplateByTeam, arg.Name, arg.TeamID)
|
|
var i Template
|
|
err := row.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&i.DefaultUser,
|
|
&i.DefaultEnv,
|
|
&i.Metadata,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const insertTemplate = `-- name: InsertTemplate :one
|
|
INSERT INTO templates (id, name, type, vcpus, memory_mb, size_bytes, team_id, default_user, default_env, metadata)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
|
RETURNING name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata
|
|
`
|
|
|
|
type InsertTemplateParams struct {
|
|
ID pgtype.UUID `json:"id"`
|
|
Name string `json:"name"`
|
|
Type string `json:"type"`
|
|
Vcpus int32 `json:"vcpus"`
|
|
MemoryMb int32 `json:"memory_mb"`
|
|
SizeBytes int64 `json:"size_bytes"`
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
DefaultUser string `json:"default_user"`
|
|
DefaultEnv []byte `json:"default_env"`
|
|
Metadata []byte `json:"metadata"`
|
|
}
|
|
|
|
func (q *Queries) InsertTemplate(ctx context.Context, arg InsertTemplateParams) (Template, error) {
|
|
row := q.db.QueryRow(ctx, insertTemplate,
|
|
arg.ID,
|
|
arg.Name,
|
|
arg.Type,
|
|
arg.Vcpus,
|
|
arg.MemoryMb,
|
|
arg.SizeBytes,
|
|
arg.TeamID,
|
|
arg.DefaultUser,
|
|
arg.DefaultEnv,
|
|
arg.Metadata,
|
|
)
|
|
var i Template
|
|
err := row.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&i.DefaultUser,
|
|
&i.DefaultEnv,
|
|
&i.Metadata,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const listTemplates = `-- name: ListTemplates :many
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListTemplates(ctx context.Context) ([]Template, error) {
|
|
rows, err := q.db.Query(ctx, listTemplates)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Template
|
|
for rows.Next() {
|
|
var i Template
|
|
if err := rows.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&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 listTemplatesByTeam = `-- name: ListTemplatesByTeam :many
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE (team_id = $1 OR team_id = '00000000-0000-0000-0000-000000000000') ORDER BY created_at DESC
|
|
`
|
|
|
|
// Platform templates are visible to all teams.
|
|
func (q *Queries) ListTemplatesByTeam(ctx context.Context, teamID pgtype.UUID) ([]Template, error) {
|
|
rows, err := q.db.Query(ctx, listTemplatesByTeam, teamID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Template
|
|
for rows.Next() {
|
|
var i Template
|
|
if err := rows.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&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 listTemplatesByTeamAndType = `-- name: ListTemplatesByTeamAndType :many
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE (team_id = $1 OR team_id = '00000000-0000-0000-0000-000000000000') AND type = $2 ORDER BY created_at DESC
|
|
`
|
|
|
|
type ListTemplatesByTeamAndTypeParams struct {
|
|
TeamID pgtype.UUID `json:"team_id"`
|
|
Type string `json:"type"`
|
|
}
|
|
|
|
// Platform templates are visible to all teams.
|
|
func (q *Queries) ListTemplatesByTeamAndType(ctx context.Context, arg ListTemplatesByTeamAndTypeParams) ([]Template, error) {
|
|
rows, err := q.db.Query(ctx, listTemplatesByTeamAndType, arg.TeamID, arg.Type)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Template
|
|
for rows.Next() {
|
|
var i Template
|
|
if err := rows.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&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 listTemplatesByTeamOnly = `-- name: ListTemplatesByTeamOnly :many
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE team_id = $1 ORDER BY created_at DESC
|
|
`
|
|
|
|
// List templates owned by a specific team (NOT including platform templates).
|
|
func (q *Queries) ListTemplatesByTeamOnly(ctx context.Context, teamID pgtype.UUID) ([]Template, error) {
|
|
rows, err := q.db.Query(ctx, listTemplatesByTeamOnly, teamID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Template
|
|
for rows.Next() {
|
|
var i Template
|
|
if err := rows.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&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 listTemplatesByType = `-- name: ListTemplatesByType :many
|
|
SELECT name, type, vcpus, memory_mb, size_bytes, created_at, team_id, id, default_user, default_env, metadata FROM templates WHERE type = $1 ORDER BY created_at DESC
|
|
`
|
|
|
|
func (q *Queries) ListTemplatesByType(ctx context.Context, type_ string) ([]Template, error) {
|
|
rows, err := q.db.Query(ctx, listTemplatesByType, type_)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Template
|
|
for rows.Next() {
|
|
var i Template
|
|
if err := rows.Scan(
|
|
&i.Name,
|
|
&i.Type,
|
|
&i.Vcpus,
|
|
&i.MemoryMb,
|
|
&i.SizeBytes,
|
|
&i.CreatedAt,
|
|
&i.TeamID,
|
|
&i.ID,
|
|
&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
|
|
}
|