refactor(db): port service clone/move ops to sqlc

Tranche 2: cloneServiceRow's INSERT...SELECT (volumes and traefik_labels
now read straight from the source row — traefik_labels was silently
dropped before, and the jsonb param round-trip goes away), domain and
variable copies, name-conflict counts, move UPDATE, project owner check.
Also fixes serviceWriteAccess: user_id is a context string, not a
uuid.UUID — the tranche-1 cast silently failed owner checks for
non-admins. Live tests cover the domain invariants and a full clone
round-trip (config, domains, variables).

Generated with [Devin](https://devin.ai)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>

ROADMAP2.md

@@ -537,7 +537,7 @@ and wired refs, one click or one CLI call.
   workspace, CLI `environments` + MCP parity. Per-env vars/domains ride the
   service's own scope (one env per service); promote ships via preview
   promote.
-- [ ] **sqlc port** — ~265 raw `database/sql` sites → `sqlc/queries/`. Done in tranches (dynamic queries stay raw). Tranches merged: metrics storage + service domains (#75), service clone/move ops (#76), preview environments (#77), deployments + rollback (#78). Remaining: runtime, compliance, cron, git, security, auth, sleeper, scanner, gateway, and smaller files.
+- [ ] **sqlc port** — ~300 raw `database/sql` sites → `sqlc/queries/`. Done in tranches (dynamic queries stay raw): metrics storage + service domains ported.
 - [ ] **Tests** — canvas/wizard frontend coverage, deployment/template/
   webhook table tests, Playwright e2e golden path.
 - [x] **First-run wizard** — public `GET /setup/status` + authed

app/backend/internal/api/cron.go

@@ -65,47 +65,13 @@ type UpdateCronJobRequest struct {
 	Retention int    `json:"retention"`
 }
 
-// cronJobFrom maps the sqlc row onto the string-ID API model.
-func cronJobFrom(j sqlcdb.CronJob) CronJob {
-	return CronJob{
-		ID:         j.ID.String(),
-		ProjectID:  j.ProjectID.String(),
-		ServiceID:  j.ServiceID.String(),
-		Name:       j.Name,
-		Schedule:   j.Schedule,
-		Command:    j.Command,
-		Timezone:   j.Timezone.String,
-		Enabled:    j.Enabled.Bool,
-		LastRunAt:  timePtrNT(j.LastRunAt),
-		NextRunAt:  timePtrNT(j.NextRunAt),
-		LastStatus: j.LastStatus.String,
-		LastOutput: j.LastOutput.String,
-		Retention:  int(j.Retention.Int32),
-		CreatedAt:  j.CreatedAt.Time,
-		UpdatedAt:  j.UpdatedAt.Time,
-	}
-}
-
-// cronExecutionFrom maps the sqlc row onto the string-ID API model.
-func cronExecutionFrom(e sqlcdb.CronExecution) CronExecution {
-	return CronExecution{
-		ID:         e.ID.String(),
-		CronJobID:  e.CronJobID.String(),
-		StartedAt:  e.StartedAt,
-		FinishedAt: timePtrNT(e.FinishedAt),
-		Status:     e.Status.String,
-		Output:     e.Output.String,
-		Error:      e.Error.String,
-	}
-}
-
 // cronJobProjectID resolves the project a cron job belongs to.
 func cronJobProjectID(db *database.DB, jobID string) (uuid.UUID, bool) {
-	id, err := uuid.Parse(jobID)
+	var projectID uuid.UUID
-	if err != nil {
+	err := db.QueryRow(
-		return uuid.Nil, false
+		`SELECT cj.project_id FROM cron_jobs cj WHERE cj.id = $1`,
-	}
+		jobID,
-	projectID, err := sqlcdb.New(db.DB).GetCronJobProjectID(context.Background(), id)
+	).Scan(&projectID)
 	if err != nil {
 		return uuid.Nil, false
 	}
@@ -171,14 +137,15 @@ func handleCreateCronJob(c *gin.Context) {
 		return
 	}
 
-	svcID, err := uuid.Parse(req.ServiceID)
+	var ownerCheck string
-	if err != nil {
+	err := db.QueryRow(
-		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
+		`SELECT p.owner_id FROM projects p 
-		return
+		 JOIN services s ON s.project_id = p.id 
-	}
+		 WHERE s.id = $1`,
-	ownerCheck, err := sqlcdb.New(db.DB).GetCronOwnerViaService(context.Background(), svcID)
+		req.ServiceID,
+	).Scan(&ownerCheck)
 
-	if err != nil || (ownerCheck.String() != userID && !contextIsAdmin(c)) {
+	if err != nil || (ownerCheck != userID && !contextIsAdmin(c)) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return
 	}
@@ -211,20 +178,11 @@ func handleCreateCronJob(c *gin.Context) {
 		UpdatedAt: time.Now(),
 	}
 
-	err = sqlcdb.New(db.DB).InsertCronJob(context.Background(), sqlcdb.InsertCronJobParams{
+	_, err = db.Exec(
-		ID:        uuid.MustParse(job.ID),
+		`INSERT INTO cron_jobs (id, project_id, service_id, name, schedule, command, timezone, enabled, next_run_at, retention, created_at, updated_at)
-		ProjectID: uuid.MustParse(job.ProjectID),
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`,
-		ServiceID: uuid.MustParse(job.ServiceID),
+		job.ID, job.ProjectID, job.ServiceID, job.Name, job.Schedule, job.Command, job.Timezone, job.Enabled, job.NextRunAt, job.Retention, job.CreatedAt, job.UpdatedAt,
-		Name:      job.Name,
+	)
-		Schedule:  job.Schedule,
-		Command:   job.Command,
-		Timezone:  sql.NullString{String: job.Timezone, Valid: true},
-		Enabled:   sql.NullBool{Bool: job.Enabled, Valid: true},
-		NextRunAt: ntPtr(job.NextRunAt),
-		Retention: sql.NullInt32{Int32: int32(job.Retention), Valid: true},
-		CreatedAt: sql.NullTime{Time: job.CreatedAt, Valid: true},
-		UpdatedAt: sql.NullTime{Time: job.UpdatedAt, Valid: true},
-	})
 
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create cron job"})
@@ -243,17 +201,22 @@ func handleGetCronJob(c *gin.Context) {
 	db := c.MustGet("db").(*database.DB)
 	jobID := c.Param("id")
 
-	jid, err := uuid.Parse(jobID)
+	var job CronJob
+	err := db.QueryRow(
+		`SELECT cj.id, cj.project_id, cj.service_id, cj.name, cj.schedule, cj.timezone,
+		        cj.enabled, cj.last_run_at, cj.next_run_at, cj.last_status, cj.last_output,
+		        cj.retention, cj.created_at, cj.updated_at
+		 FROM cron_jobs cj
+		 WHERE cj.id = $1`,
+		jobID,
+	).Scan(&job.ID, &job.ProjectID, &job.ServiceID, &job.Name, &job.Schedule, &job.Timezone,
+		&job.Enabled, &job.LastRunAt, &job.NextRunAt, &job.LastStatus, &job.LastOutput,
+		&job.Retention, &job.CreatedAt, &job.UpdatedAt)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Cron job not found"})
 		return
 	}
-	row, err := sqlcdb.New(db.DB).GetCronJob(context.Background(), jid)
-	if err != nil {
-		c.JSON(http.StatusNotFound, gin.H{"error": "Cron job not found"})
-		return
-	}
-	job := cronJobFrom(row)
 
 	projectID, found := cronJobProjectID(db, jobID)
 	if !found {
@@ -279,14 +242,15 @@ func handleUpdateCronJob(c *gin.Context) {
 		return
 	}
 
-	jid, err := uuid.Parse(jobID)
+	var ownerCheck string
-	if err != nil {
+	err := db.QueryRow(
-		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
+		`SELECT p.owner_id FROM cron_jobs cj
-		return
+		 JOIN projects p ON cj.project_id = p.id
-	}
+		 WHERE cj.id = $1`,
-	ownerCheck, err := sqlcdb.New(db.DB).GetCronJobOwner(context.Background(), jid)
+		jobID,
+	).Scan(&ownerCheck)
 
-	if err != nil || (ownerCheck.String() != userID && !contextIsAdmin(c)) {
+	if err != nil || (ownerCheck != userID && !contextIsAdmin(c)) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return
 	}
@@ -348,19 +312,21 @@ func handleDeleteCronJob(c *gin.Context) {
 	db := c.MustGet("db").(*database.DB)
 	jobID := c.Param("id")
 
-	jid, err := uuid.Parse(jobID)
+	var ownerCheck string
+	err := db.QueryRow(
+		`SELECT p.owner_id FROM cron_jobs cj
+		 JOIN projects p ON cj.project_id = p.id
+		 WHERE cj.id = $1`,
+		jobID,
+	).Scan(&ownerCheck)
+
+	if err != nil || (ownerCheck != userID && !contextIsAdmin(c)) {
+		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
+		return
+	}
+
+	_, err = db.Exec("DELETE FROM cron_jobs WHERE id = $1", jobID)
 	if err != nil {
-		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
-		return
-	}
-	ownerCheck, err := sqlcdb.New(db.DB).GetCronJobOwner(context.Background(), jid)
-
-	if err != nil || (ownerCheck.String() != userID && !contextIsAdmin(c)) {
-		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
-		return
-	}
-
-	if err := sqlcdb.New(db.DB).DeleteCronJob(context.Background(), jid); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete cron job"})
 		return
 	}
@@ -384,20 +350,29 @@ func handleGetCronExecutions(c *gin.Context) {
 		return
 	}
 
-	jid, err := uuid.Parse(jobID)
+	rows, err := db.Query(
-	if err != nil {
+		`SELECT id, cron_job_id, started_at, finished_at, status, output, error
-		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch executions"})
+		 FROM cron_executions 
-		return
+		 WHERE cron_job_id = $1 
-	}
+		 ORDER BY started_at DESC 
-	rows, err := sqlcdb.New(db.DB).ListCronExecutions(context.Background(), jid)
+		 LIMIT 100`,
+		jobID,
+	)
+
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to fetch executions"})
 		return
 	}
+	defer rows.Close()
 
 	var executions []CronExecution
-	for _, e := range rows {
+	for rows.Next() {
-		executions = append(executions, cronExecutionFrom(e))
+		var exec CronExecution
+		err := rows.Scan(&exec.ID, &exec.CronJobID, &exec.StartedAt, &exec.FinishedAt, &exec.Status, &exec.Output, &exec.Error)
+		if err != nil {
+			continue
+		}
+		executions = append(executions, exec)
 	}
 
 	c.JSON(http.StatusOK, gin.H{"executions": executions})
@@ -408,33 +383,29 @@ func handleTriggerCronJob(c *gin.Context) {
 	db := c.MustGet("db").(*database.DB)
 	jobID := c.Param("id")
 
-	jid, err := uuid.Parse(jobID)
+	var job CronJob
-	if err != nil {
+	var ownerCheck string
+	err := db.QueryRow(
+		`SELECT cj.service_id, cj.command, cj.schedule, cj.timezone, cj.retention, p.owner_id
+		 FROM cron_jobs cj
+		 JOIN projects p ON cj.project_id = p.id
+		 WHERE cj.id = $1`,
+		jobID,
+	).Scan(&job.ServiceID, &job.Command, &job.Schedule, &job.Timezone, &job.Retention, &ownerCheck)
+
+	if err != nil || (ownerCheck != userID && !contextIsAdmin(c)) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return
 	}
-	trig, err := sqlcdb.New(db.DB).GetCronJobForTrigger(context.Background(), jid)
-	if err != nil || (trig.OwnerID.String() != userID && !contextIsAdmin(c)) {
-		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
-		return
-	}
-	job := CronJob{
-		ServiceID: trig.ServiceID.String(),
-		Command:   trig.Command,
-		Schedule:  trig.Schedule,
-		Timezone:  trig.Timezone.String,
-		Retention: int(trig.Retention.Int32),
-	}
 
 	execID := uuid.New().String()
 	now := time.Now()
 
-	_ = sqlcdb.New(db.DB).InsertCronExecution(context.Background(), sqlcdb.InsertCronExecutionParams{
+	_, err = db.Exec(
-		ID:        uuid.MustParse(execID),
+		`INSERT INTO cron_executions (id, cron_job_id, started_at, status)
-		CronJobID: jid,
+		 VALUES ($1, $2, $3, $4)`,
-		StartedAt: now,
+		execID, jobID, now, "running",
-		Status:    sql.NullString{String: "running", Valid: true},
+	)
-	})
 
 	dockerClient, _ := c.Get("docker_client")
 	dockerCli, _ := dockerClient.(*docker.Client)
@@ -487,25 +458,39 @@ func StartCronScheduler(ctx context.Context, db *database.DB, dockerClient *dock
 }
 
 func runDueCronJobs(db *database.DB, dockerClient *docker.Client) {
-	q := sqlcdb.New(db.DB)
+	rows, err := db.Query(
-	jobs, err := q.ListDueCronJobs(context.Background())
+		`SELECT id, project_id, service_id, name, schedule, command, timezone, enabled, retention
+		 FROM cron_jobs
+		 WHERE enabled = TRUE AND next_run_at IS NOT NULL AND next_run_at <= NOW()`)
 	if err != nil {
 		log.Printf("cron scheduler: failed to list due jobs: %v", err)
 		return
 	}
+	defer rows.Close()
+
+	type dueJob struct {
+		CronJob
+		Command string
+	}
+	var jobs []dueJob
+	for rows.Next() {
+		var j dueJob
+		if err := rows.Scan(&j.ID, &j.ProjectID, &j.ServiceID, &j.Name, &j.Schedule,
+			&j.Command, &j.Timezone, &j.Enabled, &j.Retention); err != nil {
+			continue
+		}
+		jobs = append(jobs, j)
+	}
 
 	for _, j := range jobs {
 		execID := uuid.New().String()
-		if err := q.InsertCronExecution(context.Background(), sqlcdb.InsertCronExecutionParams{
+		if _, err := db.Exec(
-			ID:        uuid.MustParse(execID),
+			`INSERT INTO cron_executions (id, cron_job_id, started_at, status) VALUES ($1, $2, $3, $4)`,
-			CronJobID: j.ID,
+			execID, j.ID, time.Now(), "running"); err != nil {
-			StartedAt: time.Now(),
-			Status:    sql.NullString{String: "running", Valid: true},
-		}); err != nil {
 			log.Printf("cron scheduler: failed to record execution for %s: %v", j.ID, err)
 			continue
 		}
-		go executeCronJob(db, dockerClient, j.ID.String(), j.ServiceID.String(), execID, j.Command, j.Schedule, j.Timezone.String, int(j.Retention.Int32))
+		go executeCronJob(db, dockerClient, j.ID, j.ServiceID, execID, j.Command, j.Schedule, j.Timezone, j.Retention)
 	}
 }
 
@@ -599,32 +584,23 @@ func executeCronJob(db *database.DB, dockerClient *docker.Client, jobID, service
 	}
 
 	now := time.Now()
-	q := sqlcdb.New(db.DB)
+	db.Exec(
-	if eid, err := uuid.Parse(execID); err == nil {
+		`UPDATE cron_executions SET finished_at = $1, status = $2, output = $3, error = $4 WHERE id = $5`,
-		_ = q.FinishCronExecution(context.Background(), sqlcdb.FinishCronExecutionParams{
+		now, status, output, errText, execID,
-			FinishedAt: sql.NullTime{Time: now, Valid: true},
+	)
-			Status:     sql.NullString{String: status, Valid: true},
-			Output:     sql.NullString{String: output, Valid: true},
-			Error:      sql.NullString{String: errText, Valid: true},
-			ID:         eid,
-		})
-	}
 
 	next, _ := calculateNextRun(schedule, timezone)
-	if jid, err := uuid.Parse(jobID); err == nil {
+	db.Exec(
-		_ = q.UpdateCronJobRun(context.Background(), sqlcdb.UpdateCronJobRunParams{
+		`UPDATE cron_jobs SET last_run_at = $1, last_status = $2, last_output = $3, next_run_at = $4 WHERE id = $5`,
-			LastRunAt:  sql.NullTime{Time: now, Valid: true},
+		now, status, output, next, jobID,
-			LastStatus: sql.NullString{String: status, Valid: true},
+	)
-			LastOutput: sql.NullString{String: output, Valid: true},
-			NextRunAt:  ntPtr(next),
-			ID:         jid,
-		})
 
-		if retention > 0 {
+	if retention > 0 {
-			_ = q.TrimCronExecutions(context.Background(), sqlcdb.TrimCronExecutionsParams{
+		db.Exec(
-				CronJobID: jid,
+			`DELETE FROM cron_executions WHERE cron_job_id = $1 AND id NOT IN (
-				Limit:     int32(retention),
+				SELECT id FROM cron_executions WHERE cron_job_id = $1
-			})
+				ORDER BY started_at DESC LIMIT $2)`,
-		}
+			jobID, retention,
+		)
 	}
 }

app/backend/internal/api/cron_test.go

@@ -1,16 +1,9 @@
 package api
 
 import (
-	"context"
-	"database/sql"
 	"strings"
 	"testing"
 	"time"
-
-	"containr/internal/database"
-	"containr/internal/database/sqlcdb"
-
-	"github.com/google/uuid"
 )
 
 func TestCalculateNextRun(t *testing.T) {
@@ -71,123 +64,3 @@ func TestCalculateNextRunTimezone(t *testing.T) {
 		t.Logf("utc next: %v / tokyo next: %v", utcNext, tokyoNext)
 	}
 }
-
-// TestCronLiveInvariants exercises the cron.sql queries on live Postgres:
-// insert/read/owner join, execution lifecycle, run bookkeeping, retention trim.
-func TestCronLiveInvariants(t *testing.T) {
-	dsn := testDSNString(t)
-	db, err := database.NewConnection(dsn)
-	if err != nil {
-		t.Fatalf("connect: %v", err)
-	}
-	defer db.Close()
-	ctx := context.Background()
-	q := sqlcdb.New(db.DB)
-
-	userID := uuid.New()
-	projectID := uuid.New()
-	envID := uuid.New()
-	serviceID := uuid.New()
-	jobID := uuid.New()
-	suffix := strings.ReplaceAll(jobID.String()[:8], "-", "")
-	must := func(err error) {
-		t.Helper()
-		if err != nil {
-			t.Fatalf("setup: %v", err)
-		}
-	}
-	_, err = db.Exec(`INSERT INTO users (id, email, password_hash, name) VALUES ($1, $2, 'x', 'test')`,
-		userID, "cron-"+suffix+"@test.local")
-	must(err)
-	_, err = db.Exec(`INSERT INTO projects (id, name, owner_id, is_approved) VALUES ($1, $2, $3, true)`,
-		projectID, "cron-"+suffix, userID)
-	must(err)
-	_, err = db.Exec(`INSERT INTO environments (id, name, project_id) VALUES ($1, 'production', $2)`,
-		envID, projectID)
-	must(err)
-	_, err = db.Exec(`INSERT INTO services (id, name, project_id, environment_id, service_type, source_type)
-		VALUES ($1, $2, $3, $4, 'web', 'image')`,
-		serviceID, "cron-"+suffix, projectID, envID)
-	must(err)
-	defer func() { _, _ = db.Exec(`DELETE FROM users WHERE id = $1`, userID) }()
-
-	next, err := calculateNextRun("0 4 * * *", "UTC")
-	if err != nil {
-		t.Fatalf("schedule: %v", err)
-	}
-	must(q.InsertCronJob(ctx, sqlcdb.InsertCronJobParams{
-		ID: jobID, ProjectID: projectID, ServiceID: serviceID,
-		Name: "job-" + suffix, Schedule: "0 4 * * *", Command: "echo hi",
-		Timezone:  sql.NullString{String: "UTC", Valid: true},
-		Enabled:   sql.NullBool{Bool: true, Valid: true},
-		NextRunAt: ntPtr(next),
-	}))
-	job, err := q.GetCronJob(ctx, jobID)
-	if err != nil || job.Name != "job-"+suffix || job.Command != "echo hi" {
-		t.Fatalf("job: %v %+v", err, job)
-	}
-	owner, err := q.GetCronJobOwner(ctx, jobID)
-	if err != nil || owner != userID {
-		t.Fatalf("owner: %v %v", err, owner)
-	}
-	owner2, err := q.GetCronOwnerViaService(ctx, serviceID)
-	if err != nil || owner2 != userID {
-		t.Fatalf("owner via service: %v %v", err, owner2)
-	}
-	pid, err := q.GetCronJobProjectID(ctx, jobID)
-	if err != nil || pid != projectID {
-		t.Fatalf("project: %v %v", err, pid)
-	}
-
-	// Trigger-shaped read.
-	trig, err := q.GetCronJobForTrigger(ctx, jobID)
-	if err != nil || trig.ServiceID != serviceID || trig.OwnerID != userID {
-		t.Fatalf("trigger: %v %+v", err, trig)
-	}
-
-	// Execution lifecycle + retention trim.
-	for i := 0; i < 3; i++ {
-		execID := uuid.New()
-		must(q.InsertCronExecution(ctx, sqlcdb.InsertCronExecutionParams{
-			ID: execID, CronJobID: jobID,
-			StartedAt: time.Now().Add(time.Duration(i) * time.Second),
-			Status:    sql.NullString{String: "running", Valid: true},
-		}))
-		must(q.FinishCronExecution(ctx, sqlcdb.FinishCronExecutionParams{
-			FinishedAt: sql.NullTime{Time: time.Now(), Valid: true},
-			Status:     sql.NullString{String: "success", Valid: true},
-			Output:     sql.NullString{String: "ok", Valid: true},
-			Error:      sql.NullString{String: "", Valid: true},
-			ID:         execID,
-		}))
-	}
-	execs, err := q.ListCronExecutions(ctx, jobID)
-	if err != nil || len(execs) != 3 {
-		t.Fatalf("execs: %v %d", err, len(execs))
-	}
-	if execs[0].Status.String != "success" || !execs[0].FinishedAt.Valid {
-		t.Fatalf("exec row: %+v", execs[0])
-	}
-	must(q.TrimCronExecutions(ctx, sqlcdb.TrimCronExecutionsParams{CronJobID: jobID, Limit: 1}))
-	execs, _ = q.ListCronExecutions(ctx, jobID)
-	if len(execs) != 1 {
-		t.Fatalf("trim kept %d, want 1", len(execs))
-	}
-
-	must(q.UpdateCronJobRun(ctx, sqlcdb.UpdateCronJobRunParams{
-		LastRunAt:  sql.NullTime{Time: time.Now(), Valid: true},
-		LastStatus: sql.NullString{String: "success", Valid: true},
-		LastOutput: sql.NullString{String: "ok", Valid: true},
-		NextRunAt:  ntPtr(next),
-		ID:         jobID,
-	}))
-	job, _ = q.GetCronJob(ctx, jobID)
-	if job.LastStatus.String != "success" || !job.LastRunAt.Valid {
-		t.Fatalf("post-run job: %+v", job)
-	}
-
-	must(q.DeleteCronJob(ctx, jobID))
-	if _, err := q.GetCronJob(ctx, jobID); err == nil {
-		t.Fatal("deleted job still readable")
-	}
-}

app/backend/internal/api/deployments.go

@@ -2,14 +2,12 @@ package api
 
 import (
 	"containr/internal/database"
-	"containr/internal/database/sqlcdb"
 	"containr/internal/deployment"
 	"containr/internal/deployqueue"
 	"containr/internal/docker"
 	"containr/internal/source"
 	"containr/internal/types"
 	"context"
-	"database/sql"
 	"errors"
 	"fmt"
 	"log/slog"
@@ -39,72 +37,6 @@ type DeploymentModel struct {
 	UpdatedAt   time.Time  `json:"updated_at" db:"updated_at"`
 }
 
-// deploymentRowShape carries the deployment columns shared by the
-// generated list/detail/rollback row types.
-type deploymentRowShape struct {
-	ID          uuid.UUID
-	ServiceID   uuid.UUID
-	CommitHash  sql.NullString
-	Status      sql.NullString
-	ImageName   sql.NullString
-	ImageTag    sql.NullString
-	BuildLog    sql.NullString
-	RuntimeLog  sql.NullString
-	Error       sql.NullString
-	StartedAt   sql.NullTime
-	CompletedAt sql.NullTime
-	CreatedAt   sql.NullTime
-	UpdatedAt   sql.NullTime
-}
-
-func strPtrNS(v sql.NullString) *string {
-	if !v.Valid {
-		return nil
-	}
-	s := v.String
-	return &s
-}
-
-func ptrStr(s *string) string {
-	if s == nil {
-		return ""
-	}
-	return *s
-}
-
-func timePtrNT(v sql.NullTime) *time.Time {
-	if !v.Valid {
-		return nil
-	}
-	t := v.Time
-	return &t
-}
-
-func ntPtr(t *time.Time) sql.NullTime {
-	if t == nil {
-		return sql.NullTime{}
-	}
-	return sql.NullTime{Time: *t, Valid: true}
-}
-
-func deploymentModelFrom(r deploymentRowShape) DeploymentModel {
-	return DeploymentModel{
-		ID:          r.ID,
-		ServiceID:   r.ServiceID,
-		CommitHash:  strPtrNS(r.CommitHash),
-		Status:      r.Status.String,
-		ImageName:   r.ImageName.String,
-		ImageTag:    r.ImageTag.String,
-		BuildLog:    r.BuildLog.String,
-		RuntimeLog:  r.RuntimeLog.String,
-		Error:       strPtrNS(r.Error),
-		StartedAt:   timePtrNT(r.StartedAt),
-		CompletedAt: timePtrNT(r.CompletedAt),
-		CreatedAt:   r.CreatedAt.Time,
-		UpdatedAt:   r.UpdatedAt.Time,
-	}
-}
-
 type CreateDeploymentRequest struct {
 	CommitHash string            `json:"commit_hash"`
 	Branch     string            `json:"branch"`
@@ -152,29 +84,44 @@ func handleGetDeployments(c *gin.Context) {
 
 	offset, limit := pageWindow(c, 50, 100)
 
-	q := sqlcdb.New(db.(*database.DB).DB)
+	var total int
-	total, _ := q.CountDeploymentsForService(c.Request.Context(), serviceID)
+	_ = db.(*database.DB).QueryRow(
+		`SELECT COUNT(*) FROM deployments WHERE service_id = $1`, serviceID,
+	).Scan(&total)
 
-	rows, err := q.ListDeploymentsForService(c.Request.Context(), sqlcdb.ListDeploymentsForServiceParams{
+	rows, err := db.(*database.DB).Query(
-		ServiceID: serviceID, Limit: int32(limit), Offset: int32(offset)})
+		`SELECT id, service_id, commit_hash, status, image_name, image_tag,
+		        build_log, runtime_log, error, started_at, completed_at, created_at, updated_at
+		 FROM deployments
+		 WHERE service_id = $1
+		 ORDER BY created_at DESC
+		 LIMIT $2 OFFSET $3`,
+		serviceID, limit, offset,
+	)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve deployments"})
 		return
 	}
+	defer rows.Close()
 
-	deployments := make([]DeploymentModel, 0, len(rows))
+	var deployments []DeploymentModel
-	for _, r := range rows {
+	for rows.Next() {
-		deployments = append(deployments, deploymentModelFrom(deploymentRowShape{
+		var d DeploymentModel
-			ID: r.ID, ServiceID: r.ServiceID, CommitHash: r.CommitHash, Status: r.Status,
+		err := rows.Scan(
-			ImageName: r.ImageName, ImageTag: r.ImageTag, BuildLog: r.BuildLog,
+			&d.ID, &d.ServiceID, &d.CommitHash, &d.Status, &d.ImageName, &d.ImageTag,
-			RuntimeLog: r.RuntimeLog, Error: r.Error, StartedAt: r.StartedAt,
+			&d.BuildLog, &d.RuntimeLog, &d.Error, &d.StartedAt, &d.CompletedAt,
-			CompletedAt: r.CompletedAt, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
+			&d.CreatedAt, &d.UpdatedAt,
-		}))
+		)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to scan deployment"})
+			return
+		}
+		deployments = append(deployments, d)
 	}
 
 	c.JSON(http.StatusOK, gin.H{
 		"deployments": deployments,
-		"pagination":  paginationMeta(offset, limit, int(total)),
+		"pagination":  paginationMeta(offset, limit, total),
 	})
 }
 
@@ -205,33 +152,51 @@ func handleGetRecentDeployments(c *gin.Context) {
 
 	offset, limit := pageWindow(c, 10, 50)
 
-	q := sqlcdb.New(db.(*database.DB).DB)
+	var total int
-	total, err := q.CountAccessibleDeployments(c.Request.Context(), sqlcdb.CountAccessibleDeploymentsParams{
+	if err := db.(*database.DB).QueryRow(
-		OwnerID: userID, Column2: isAdmin})
+		`SELECT COUNT(*)
-	if err != nil {
+		 FROM deployments d
+		 JOIN services s ON s.id = d.service_id
+		 JOIN projects p ON p.id = s.project_id
+		 WHERE p.is_approved OR p.owner_id = $1 OR $2::bool
+		    OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $1)`,
+		userID, isAdmin,
+	).Scan(&total); err != nil {
 		total = 0
 	}
 
-	rows, err := q.ListRecentAccessibleDeployments(c.Request.Context(), sqlcdb.ListRecentAccessibleDeploymentsParams{
+	rows, err := db.(*database.DB).Query(
-		OwnerID: userID, Column2: isAdmin, Limit: int32(limit), Offset: int32(offset)})
+		`SELECT d.id, d.service_id, s.name, p.name, d.status,
+		        COALESCE(d.image_name, ''), d.started_at, d.completed_at, d.created_at
+		 FROM deployments d
+		 JOIN services s ON s.id = d.service_id
+		 JOIN projects p ON p.id = s.project_id
+		 WHERE p.is_approved OR p.owner_id = $1 OR $2::bool
+		    OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $1)
+		 ORDER BY d.created_at DESC
+		 LIMIT $3 OFFSET $4`,
+		userID, isAdmin, limit, offset,
+	)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve deployments"})
 		return
 	}
+	defer rows.Close()
 
-	deployments := make([]RecentDeployment, 0, len(rows))
+	deployments := []RecentDeployment{}
-	for _, r := range rows {
+	for rows.Next() {
-		deployments = append(deployments, RecentDeployment{
+		var d RecentDeployment
-			ID: r.ID, ServiceID: r.ServiceID, ServiceName: r.ServiceName,
+		if err := rows.Scan(&d.ID, &d.ServiceID, &d.ServiceName, &d.ProjectName,
-			ProjectName: r.ProjectName, Status: r.Status.String, ImageName: r.ImageName,
+			&d.Status, &d.ImageName, &d.StartedAt, &d.CompletedAt, &d.CreatedAt); err != nil {
-			StartedAt: timePtrNT(r.StartedAt), CompletedAt: timePtrNT(r.CompletedAt),
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to scan deployment"})
-			CreatedAt: r.CreatedAt.Time,
+			return
-		})
+		}
+		deployments = append(deployments, d)
 	}
 
 	c.JSON(http.StatusOK, gin.H{
 		"deployments": deployments,
-		"pagination":  paginationMeta(offset, limit, int(total)),
+		"pagination":  paginationMeta(offset, limit, total),
 	})
 }
 
@@ -265,27 +230,38 @@ func handleCreateDeployment(c *gin.Context) {
 		return
 	}
 
-	ctx := c.Request.Context()
+	var service Service
-	q := sqlcdb.New(db.(*database.DB).DB)
+	var projectOwner string
-	sr, err := q.GetServiceForDeployWithOwner(ctx, serviceID)
+	err = db.(*database.DB).QueryRow(
+		`SELECT s.id, s.project_id, s.name, s.type, s.status, s.image, s.command,
+		        s.environment, s.git_repo, s.git_branch, s.build_path, s.cpu, s.memory,
+		        COALESCE(s.replicas, 1), COALESCE(s.port, 0),
+		        COALESCE(s.domain, ''), COALESCE(s.healthcheck_path, ''),
+		        COALESCE(s.restart_policy, 'unless-stopped'),
+		        COALESCE(s.builder, 'auto'), COALESCE(s.cpu_reserve, ''),
+		        COALESCE(s.memory_reserve, ''), COALESCE(s.static_build_cmd, ''),
+		        COALESCE(s.static_dir, ''),
+		        s.created_at, s.updated_at, p.owner_id
+		 FROM services s
+		 JOIN projects p ON s.project_id = p.id
+		 WHERE s.id = $1`,
+		serviceID,
+	).Scan(
+		&service.ID, &service.ProjectID, &service.Name, &service.Type, &service.Status,
+		&service.Image, &service.Command, &service.Environment, &service.GitRepo,
+		&service.GitBranch, &service.BuildPath, &service.CPU, &service.Memory,
+		&service.Replicas, &service.Port, &service.Domain, &service.HealthCheckPath,
+		&service.RestartPolicy, &service.Builder, &service.CPUReserve,
+		&service.MemoryReserve, &service.StaticBuildCmd, &service.StaticDir,
+		&service.CreatedAt, &service.UpdatedAt, &projectOwner,
+	)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Service not found"})
 		return
 	}
-	service := serviceForDeployFromRow(sqlcdb.GetServiceForDeployRow{
-		ID: sr.ID, ProjectID: sr.ProjectID, Name: sr.Name, Type: sr.Type,
-		Status: sr.Status, Image: sr.Image, Command: sr.Command,
-		Environment: sr.Environment, GitRepo: sr.GitRepo, GitBranch: sr.GitBranch,
-		BuildPath: sr.BuildPath, Cpu: sr.Cpu, Memory: sr.Memory,
-		Replicas: sr.Replicas, Port: sr.Port, Domain: sr.Domain,
-		HealthcheckPath: sr.HealthcheckPath, RestartPolicy: sr.RestartPolicy,
-		Builder: sr.Builder, CpuReserve: sr.CpuReserve, MemoryReserve: sr.MemoryReserve,
-		StaticBuildCmd: sr.StaticBuildCmd, StaticDir: sr.StaticDir,
-		CreatedAt: sr.CreatedAt, UpdatedAt: sr.UpdatedAt,
-	})
-	projectOwner := sr.OwnerID
 
-	if projectOwner.String() != userID.(string) {
+	if projectOwner != userID.(string) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return
 	}
@@ -311,17 +287,12 @@ func handleCreateDeployment(c *gin.Context) {
 		UpdatedAt:  now,
 	}
 
-	err = q.InsertDeployment(ctx, sqlcdb.InsertDeploymentParams{
+	_, err = db.(*database.DB).Exec(
-		ID:         d.ID,
+		`INSERT INTO deployments
-		ServiceID:  d.ServiceID,
+		 (id, service_id, version, commit_hash, status, image_name, image_tag, created_at, updated_at)
-		Version:    fmt.Sprintf("v%d", now.Unix()),
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
-		CommitHash: sql.NullString{String: ptrStr(d.CommitHash), Valid: d.CommitHash != nil},
+		d.ID, d.ServiceID, fmt.Sprintf("v%d", now.Unix()), d.CommitHash, d.Status, d.ImageName, d.ImageTag, d.CreatedAt, d.UpdatedAt,
-		Status:     sql.NullString{String: d.Status, Valid: true},
+	)
-		ImageName:  sql.NullString{String: d.ImageName, Valid: true},
-		ImageTag:   sql.NullString{String: d.ImageTag, Valid: true},
-		CreatedAt:  sql.NullTime{Time: d.CreatedAt, Valid: true},
-		UpdatedAt:  sql.NullTime{Time: d.UpdatedAt, Valid: true},
-	})
 
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create deployment"})
@@ -332,20 +303,20 @@ func handleCreateDeployment(c *gin.Context) {
 	if !exists || engine == nil {
 		unavailableErr := "Deployment engine unavailable. Docker may not be configured on this server."
 		completedAt := time.Now()
-		_ = q.FailDeployment(ctx, sqlcdb.FailDeploymentParams{
+		_, _ = db.(*database.DB).Exec(
-			Error:       sql.NullString{String: unavailableErr, Valid: true},
+			`UPDATE deployments
-			CompletedAt: sql.NullTime{Time: completedAt, Valid: true},
+			 SET status = 'failed', error = $1, completed_at = $2, updated_at = $2
-			ID:          d.ID,
+			 WHERE id = $3`,
-		})
+			unavailableErr, completedAt, d.ID,
+		)
 		d.Status = "failed"
 		d.Error = &unavailableErr
 		d.CompletedAt = &completedAt
 	} else {
-		err = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+		_, err = db.(*database.DB).Exec(
-			Status:    sql.NullString{String: "building", Valid: true},
+			`UPDATE services SET status = 'building', updated_at = $1 WHERE id = $2`,
-			UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
+			time.Now(), serviceID,
-			ID:        serviceID,
+		)
-		})
 		if err != nil {
 			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update service status"})
 			return
@@ -360,17 +331,14 @@ func handleCreateDeployment(c *gin.Context) {
 		})
 		if pos > 0 {
 			d.Status = "queued"
-			now := time.Now()
+			_, _ = db.(*database.DB).Exec(
-			_ = q.SetDeploymentStatus(ctx, sqlcdb.SetDeploymentStatusParams{
+				`UPDATE deployments SET status = 'queued', updated_at = $1 WHERE id = $2`,
-				Status:    sql.NullString{String: "queued", Valid: true},
+				time.Now(), d.ID,
-				UpdatedAt: sql.NullTime{Time: now, Valid: true},
+			)
-				ID:        d.ID,
+			_, _ = db.(*database.DB).Exec(
-			})
+				`UPDATE services SET status = 'queued', updated_at = $1 WHERE id = $2`,
-			_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+				time.Now(), serviceID,
-				Status:    sql.NullString{String: "queued", Valid: true},
+			)
-				UpdatedAt: sql.NullTime{Time: now, Valid: true},
-				ID:        serviceID,
-			})
 		}
 	}
 
@@ -412,7 +380,6 @@ func runDeploymentAndSyncWithImage(
 ) {
 	ctx, cancel := context.WithTimeout(parentCtx, 30*time.Minute)
 	defer cancel()
-	q := sqlcdb.New(db.DB)
 
 	// The checkout and any shipped artifacts die with this deployment.
 	var artifactIDs []string
@@ -425,11 +392,10 @@ func runDeploymentAndSyncWithImage(
 	}()
 	failDeploy := func(msg string) {
 		failedAt := time.Now()
-		_ = q.FailDeployment(ctx, sqlcdb.FailDeploymentParams{
+		_, _ = db.Exec(
-			Error:       sql.NullString{String: msg, Valid: true},
+			`UPDATE deployments SET status = 'failed', error = $1, completed_at = $2, updated_at = $2 WHERE id = $3`,
-			CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
+			msg, failedAt, dbDeployment.ID,
-			ID:          dbDeployment.ID,
+		)
-		})
 	}
 
 	sourcePath := strings.TrimSpace(service.BuildPath)
@@ -457,10 +423,11 @@ func runDeploymentAndSyncWithImage(
 		replicas = 1
 	}
 
+	var publishedPort int32
 	// Best effort: reuse the host port from the last live deployment so public
 	// URLs survive redeploys. Column exists post-migration; older DBs get
 	// ephemeral ports.
-	publishedPort, _ := q.GetServicePublishedPort(ctx, service.ID)
+	_ = db.QueryRow(`SELECT published_port FROM services WHERE id = $1`, service.ID).Scan(&publishedPort)
 
 	publicPort := int32(service.Port)
 	if service.Builder == "static" && publicPort == 0 {
@@ -484,9 +451,7 @@ func runDeploymentAndSyncWithImage(
 	// remote builds package it into a context artifact the node builds.
 	if service.GitRepo != "" && imageOverride == "" {
 		var ownerID string
-		if o, err := q.GetProjectOwner(ctx, service.ProjectID); err == nil {
+		_ = db.QueryRow(`SELECT owner_id FROM projects WHERE id = $1`, service.ProjectID).Scan(&ownerID)
-			ownerID = o.String()
-		}
 		branch := req.Branch
 		if branch == "" {
 			branch = service.GitBranch
@@ -570,9 +535,7 @@ func runDeploymentAndSyncWithImage(
 			}
 		} else {
 			var ownerID string
-			if o, err := q.GetProjectOwner(ctx, service.ProjectID); err == nil {
+			_ = db.QueryRow(`SELECT owner_id FROM projects WHERE id = $1`, service.ProjectID).Scan(&ownerID)
-				ownerID = o.String()
-			}
 			auth := registryAuthFor(db, ownerID, image)
 			deployReq.BuildConfig = &deployment.BuildConfig{
 				BuildType:     "prebuilt",
@@ -642,11 +605,10 @@ func runDeploymentAndSyncWithImage(
 
 	if msg := capacityCheck(parentCtx, db, engine.DockerClient(), service, replicas); msg != "" {
 		failedAt := time.Now()
-		_ = q.FailDeployment(ctx, sqlcdb.FailDeploymentParams{
+		_, _ = db.Exec(
-			Error:       sql.NullString{String: msg, Valid: true},
+			`UPDATE deployments SET status = 'failed', error = $1, completed_at = $2, updated_at = $2 WHERE id = $3`,
-			CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
+			msg, failedAt, dbDeployment.ID,
-			ID:          dbDeployment.ID,
+		)
-		})
 		return
 	}
 
@@ -654,16 +616,16 @@ func runDeploymentAndSyncWithImage(
 	if err != nil {
 		failedAt := time.Now()
 		failure := "Failed to start deployment engine: " + err.Error()
-		_ = q.FailDeployment(ctx, sqlcdb.FailDeploymentParams{
+		_, _ = db.Exec(
-			Error:       sql.NullString{String: failure, Valid: true},
+			`UPDATE deployments
-			CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
+			 SET status = 'failed', error = $1, completed_at = $2, updated_at = $2
-			ID:          dbDeployment.ID,
+			 WHERE id = $3`,
-		})
+			failure, failedAt, dbDeployment.ID,
-		_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+		)
-			Status:    sql.NullString{String: "failed", Valid: true},
+		_, _ = db.Exec(
-			UpdatedAt: sql.NullTime{Time: failedAt, Valid: true},
+			`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`,
-			ID:        service.ID,
+			failedAt, service.ID,
-		})
+		)
 		return
 	}
 
@@ -678,17 +640,16 @@ func runDeploymentAndSyncWithImage(
 			if errors.Is(ctx.Err(), context.Canceled) {
 				finalStatus, finalErr = "cancelled", "Deployment cancelled"
 			}
-			_ = q.CompleteDeployment(ctx, sqlcdb.CompleteDeploymentParams{
+			_, _ = db.Exec(
-				Status:      sql.NullString{String: finalStatus, Valid: true},
+				`UPDATE deployments
-				Error:       sql.NullString{String: finalErr, Valid: true},
+				 SET status = $1, error = $2, completed_at = $3, updated_at = $3
-				CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
+				 WHERE id = $4`,
-				ID:          dbDeployment.ID,
+				finalStatus, finalErr, failedAt, dbDeployment.ID,
-			})
+			)
-			_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+			_, _ = db.Exec(
-				Status:    sql.NullString{String: finalStatus, Valid: true},
+				`UPDATE services SET status = $1, updated_at = $2 WHERE id = $3`,
-				UpdatedAt: sql.NullTime{Time: failedAt, Valid: true},
+				finalStatus, failedAt, service.ID,
-				ID:        service.ID,
+			)
-			})
 			return
 		case <-syncTicker.C:
 			current, getErr := engine.GetDeployment(engineDeployment.ID)
@@ -699,36 +660,49 @@ func runDeploymentAndSyncWithImage(
 			dbStatus := mapEngineStatusToDBStatus(current.Status)
 			imageName, imageTag := splitImageReference(current.ImageName, dbDeployment.ImageTag)
 
-			now := time.Now()
+			var dbError interface{}
-			_ = q.SyncDeploymentProgress(ctx, sqlcdb.SyncDeploymentProgressParams{
+			if current.Error != "" {
-				Status:      sql.NullString{String: dbStatus, Valid: true},
+				dbError = current.Error
-				ImageName:   sql.NullString{String: imageName, Valid: true},
+			}
-				ImageTag:    sql.NullString{String: imageTag, Valid: true},
+
-				BuildLog:    sql.NullString{String: current.BuildLog, Valid: true},
+			_, _ = db.Exec(
-				RuntimeLog:  sql.NullString{String: current.DeployLog, Valid: true},
+				`UPDATE deployments
-				Error:       sql.NullString{String: current.Error, Valid: current.Error != ""},
+				 SET status = $1,
-				StartedAt:   ntPtr(current.StartedAt),
+				     image_name = $2,
-				CompletedAt: ntPtr(current.CompletedAt),
+				     image_tag = $3,
-				UpdatedAt:   sql.NullTime{Time: now, Valid: true},
+				     build_log = $4,
-				ID:          dbDeployment.ID,
+				     runtime_log = $5,
-			})
+				     error = $6,
+				     started_at = $7,
+				     completed_at = $8,
+				     updated_at = $9
+				 WHERE id = $10`,
+				dbStatus,
+				imageName,
+				imageTag,
+				current.BuildLog,
+				current.DeployLog,
+				dbError,
+				current.StartedAt,
+				current.CompletedAt,
+				time.Now(),
+				dbDeployment.ID,
+			)
 
 			switch dbStatus {
 			case "deployed":
-				_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+				_, _ = db.Exec(
-					Status:    sql.NullString{String: "running", Valid: true},
+					`UPDATE services SET status = 'running', updated_at = $1 WHERE id = $2`,
-					UpdatedAt: sql.NullTime{Time: now, Valid: true},
+					time.Now(), service.ID,
-					ID:        service.ID,
+				)
-				})
 				insertUserNotification(db, userID, "deployment", "Deployment succeeded",
 					fmt.Sprintf("Service %s is now running.", service.Name), "service", service.ID.String())
 				return
 			case "failed":
-				_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+				_, _ = db.Exec(
-					Status:    sql.NullString{String: "failed", Valid: true},
+					`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`,
-					UpdatedAt: sql.NullTime{Time: now, Valid: true},
+					time.Now(), service.ID,
-					ID:        service.ID,
+				)
-				})
 				body := fmt.Sprintf("Service %s failed to deploy.", service.Name)
 				if current.Error != "" {
 					body = fmt.Sprintf("Service %s failed to deploy: %s", service.Name, current.Error)
@@ -780,16 +754,21 @@ func handleCancelDeployment(c *gin.Context) {
 		return
 	}
 
-	ctx := c.Request.Context()
+	var status, owner string
-	q := sqlcdb.New(db.(*database.DB).DB)
+	var serviceID uuid.UUID
-	access, err := q.GetDeploymentAccess(ctx, deploymentID)
+	err = db.(*database.DB).QueryRow(
+		`SELECT d.status, d.service_id, p.owner_id
+		 FROM deployments d
+		 JOIN services s ON d.service_id = s.id
+		 JOIN projects p ON s.project_id = p.id
+		 WHERE d.id = $1`,
+		deploymentID,
+	).Scan(&status, &serviceID, &owner)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Deployment not found", "code": "NOT_FOUND"})
 		return
 	}
-	serviceID := access.ServiceID
+	if owner != userID.(string) && !contextIsAdmin(c) {
-	status := access.Status.String
-	if access.OwnerID.String() != userID.(string) && !contextIsAdmin(c) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied", "code": "FORBIDDEN"})
 		return
 	}
@@ -803,17 +782,14 @@ func handleCancelDeployment(c *gin.Context) {
 	switch getDeployQueue(c).Cancel(serviceID, deploymentID) {
 	case deployqueue.WasQueued:
 		now := time.Now()
-		_ = q.CompleteDeployment(ctx, sqlcdb.CompleteDeploymentParams{
+		_, _ = db.(*database.DB).Exec(
-			Status:      sql.NullString{String: "cancelled", Valid: true},
+			`UPDATE deployments SET status = 'cancelled', error = 'Deployment cancelled', completed_at = $1, updated_at = $1 WHERE id = $2`,
-			Error:       sql.NullString{String: "Deployment cancelled", Valid: true},
+			now, deploymentID,
-			CompletedAt: sql.NullTime{Time: now, Valid: true},
+		)
-			ID:          deploymentID,
+		_, _ = db.(*database.DB).Exec(
-		})
+			`UPDATE services SET status = 'cancelled', updated_at = $1 WHERE id = $2`,
-		_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+			now, serviceID,
-			Status:    sql.NullString{String: "cancelled", Valid: true},
+		)
-			UpdatedAt: sql.NullTime{Time: now, Valid: true},
-			ID:        serviceID,
-		})
 		c.JSON(http.StatusOK, gin.H{"status": "cancelled"})
 	case deployqueue.WasActive:
 		c.JSON(http.StatusAccepted, gin.H{"status": "cancelling"})
@@ -856,18 +832,27 @@ func handleGetDeployment(c *gin.Context) {
 		return
 	}
 
-	r, err := sqlcdb.New(db.(*database.DB).DB).GetDeploymentWithProject(c.Request.Context(), deploymentID)
+	var d DeploymentModel
+	var projectID uuid.UUID
+	err = db.(*database.DB).QueryRow(
+		`SELECT d.id, d.service_id, d.commit_hash, d.status, d.image_name, d.image_tag,
+		        d.build_log, d.runtime_log, d.error, d.started_at, d.completed_at,
+		        d.created_at, d.updated_at, p.id
+		 FROM deployments d
+		 JOIN services s ON d.service_id = s.id
+		 JOIN projects p ON s.project_id = p.id
+		 WHERE d.id = $1`,
+		deploymentID,
+	).Scan(
+		&d.ID, &d.ServiceID, &d.CommitHash, &d.Status, &d.ImageName, &d.ImageTag,
+		&d.BuildLog, &d.RuntimeLog, &d.Error, &d.StartedAt, &d.CompletedAt,
+		&d.CreatedAt, &d.UpdatedAt, &projectID,
+	)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Deployment not found"})
 		return
 	}
-	projectID := r.ProjectID
-	d := deploymentModelFrom(deploymentRowShape{
-		ID: r.ID, ServiceID: r.ServiceID, CommitHash: r.CommitHash, Status: r.Status,
-		ImageName: r.ImageName, ImageTag: r.ImageTag, BuildLog: r.BuildLog,
-		RuntimeLog: r.RuntimeLog, Error: r.Error, StartedAt: r.StartedAt,
-		CompletedAt: r.CompletedAt, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
-	})
 
 	if _, allowed := projectReadAccess(c, db.(*database.DB), projectID); !allowed {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Deployment not found"})
@@ -897,23 +882,33 @@ func handleRollbackDeployment(c *gin.Context) {
 		return
 	}
 
-	ctx := c.Request.Context()
+	var targetDeployment DeploymentModel
-	q := sqlcdb.New(db.(*database.DB).DB)
+	var serviceID uuid.UUID
-	r, err := q.GetDeploymentForRollback(ctx, deploymentID)
+	var ownerCheck string
+
+	err = db.(*database.DB).QueryRow(
+		`SELECT d.id, d.service_id, d.commit_hash, d.status, d.image_name, d.image_tag, 
+		        d.build_log, d.runtime_log, d.error, d.started_at, d.completed_at, 
+		        d.created_at, d.updated_at, p.owner_id
+		 FROM deployments d
+		 JOIN services s ON d.service_id = s.id
+		 JOIN projects p ON s.project_id = p.id
+		 WHERE d.id = $1`,
+		deploymentID,
+	).Scan(
+		&targetDeployment.ID, &serviceID, &targetDeployment.CommitHash, &targetDeployment.Status,
+		&targetDeployment.ImageName, &targetDeployment.ImageTag, &targetDeployment.BuildLog,
+		&targetDeployment.RuntimeLog, &targetDeployment.Error, &targetDeployment.StartedAt,
+		&targetDeployment.CompletedAt, &targetDeployment.CreatedAt, &targetDeployment.UpdatedAt,
+		&ownerCheck,
+	)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Deployment not found"})
 		return
 	}
-	serviceID := r.ServiceID
-	targetDeployment := deploymentModelFrom(deploymentRowShape{
-		ID: r.ID, ServiceID: r.ServiceID, CommitHash: r.CommitHash, Status: r.Status,
-		ImageName: r.ImageName, ImageTag: r.ImageTag, BuildLog: r.BuildLog,
-		RuntimeLog: r.RuntimeLog, Error: r.Error, StartedAt: r.StartedAt,
-		CompletedAt: r.CompletedAt, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
-	})
-	ownerCheck := r.OwnerID
 
-	if ownerCheck.String() != userID.(string) && !contextIsAdmin(c) {
+	if ownerCheck != userID.(string) && !contextIsAdmin(c) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return
 	}
@@ -936,28 +931,23 @@ func handleRollbackDeployment(c *gin.Context) {
 		UpdatedAt:  now,
 	}
 
-	err = q.InsertDeployment(ctx, sqlcdb.InsertDeploymentParams{
+	_, err = db.(*database.DB).Exec(
-		ID:         rollback.ID,
+		`INSERT INTO deployments
-		ServiceID:  rollback.ServiceID,
+		 (id, service_id, version, commit_hash, status, image_name, image_tag, created_at, updated_at)
-		Version:    fmt.Sprintf("rollback-%d", now.Unix()),
+		 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
-		CommitHash: sql.NullString{String: ptrStr(rollback.CommitHash), Valid: rollback.CommitHash != nil},
+		rollback.ID, rollback.ServiceID, fmt.Sprintf("rollback-%d", now.Unix()), rollback.CommitHash, rollback.Status,
-		Status:     sql.NullString{String: rollback.Status, Valid: true},
+		rollback.ImageName, rollback.ImageTag, rollback.CreatedAt, rollback.UpdatedAt,
-		ImageName:  sql.NullString{String: rollback.ImageName, Valid: true},
+	)
-		ImageTag:   sql.NullString{String: rollback.ImageTag, Valid: true},
-		CreatedAt:  sql.NullTime{Time: rollback.CreatedAt, Valid: true},
-		UpdatedAt:  sql.NullTime{Time: rollback.UpdatedAt, Valid: true},
-	})
 
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create rollback deployment"})
 		return
 	}
 
-	err = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+	_, err = db.(*database.DB).Exec(
-		Status:    sql.NullString{String: "building", Valid: true},
+		`UPDATE services SET status = 'building', updated_at = $1 WHERE id = $2`,
-		UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
+		time.Now(), serviceID,
-		ID:        serviceID,
+	)
-	})
 
 	// Real rollback: redeploy the target deployment's image.
 	engineValue, _ := c.Get("deployment_engine")
@@ -973,18 +963,36 @@ func handleRollbackDeployment(c *gin.Context) {
 		if engine == nil {
 			reason = "Deployment engine unavailable. Docker may not be configured on this server."
 		}
-		_ = q.FailDeployment(ctx, sqlcdb.FailDeploymentParams{
+		_, _ = db.(*database.DB).Exec(
-			Error:       sql.NullString{String: reason, Valid: true},
+			`UPDATE deployments SET status = 'failed', error = $1, completed_at = $2, updated_at = $2 WHERE id = $3`,
-			CompletedAt: sql.NullTime{Time: completedAt, Valid: true},
+			reason, completedAt, rollbackID,
-			ID:          rollbackID,
+		)
-		})
+		_, _ = db.(*database.DB).Exec(
-		_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
+			`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`,
-			Status:    sql.NullString{String: "failed", Valid: true},
+			completedAt, serviceID,
-			UpdatedAt: sql.NullTime{Time: completedAt, Valid: true},
+		)
-			ID:        serviceID,
-		})
 	} else {
-		service, _ := loadServiceForDeploy(db.(*database.DB), serviceID)
+		var service Service
+		_ = db.(*database.DB).QueryRow(
+			`SELECT s.id, s.project_id, s.name, s.type, s.status, s.image, s.command,
+			        s.environment, s.git_repo, s.git_branch, s.build_path, s.cpu, s.memory,
+			        COALESCE(s.replicas, 1), COALESCE(s.port, 0),
+			        COALESCE(s.domain, ''), COALESCE(s.healthcheck_path, ''),
+			        COALESCE(s.restart_policy, 'unless-stopped'),
+			        COALESCE(s.builder, 'auto'), COALESCE(s.cpu_reserve, ''),
+			        COALESCE(s.memory_reserve, ''), COALESCE(s.static_build_cmd, ''),
+			        COALESCE(s.static_dir, ''),
+			        s.created_at, s.updated_at
+			 FROM services s WHERE s.id = $1`, serviceID,
+		).Scan(
+			&service.ID, &service.ProjectID, &service.Name, &service.Type, &service.Status,
+			&service.Image, &service.Command, &service.Environment, &service.GitRepo,
+			&service.GitBranch, &service.BuildPath, &service.CPU, &service.Memory,
+			&service.Replicas, &service.Port, &service.Domain, &service.HealthCheckPath,
+			&service.RestartPolicy, &service.Builder, &service.CPUReserve,
+			&service.MemoryReserve, &service.StaticBuildCmd, &service.StaticDir,
+			&service.CreatedAt, &service.UpdatedAt,
+		)
 
 		rollbackReq := CreateDeploymentRequest{
 			CommitHash: func() string {

app/backend/internal/api/domains_test.go

@@ -2,11 +2,9 @@ package api
 
 import (
 	"context"
-	"database/sql"
 	"os"
 	"strings"
 	"testing"
-	"time"
 
 	"containr/internal/database"
 	"containr/internal/database/sqlcdb"
@@ -225,377 +223,3 @@ func TestCloneServiceRowLive(t *testing.T) {
 		t.Fatalf("vars not cloned: %v %q", err, varVal)
 	}
 }
-
-// Live preview-environment test: generated queries must preserve the
-// access-check join, the status-sync CASE, and the sweep listing.
-func TestPreviewEnvironmentsLiveInvariants(t *testing.T) {
-	dsn := testDSNString(t)
-	db, err := database.NewConnection(dsn)
-	if err != nil {
-		t.Fatalf("connect: %v", err)
-	}
-	defer db.Close()
-	ctx := context.Background()
-	q := sqlcdb.New(db.DB)
-
-	userID := uuid.New()
-	projectID := uuid.New()
-	envID := uuid.New()
-	srcID := uuid.New()
-	cloneID := uuid.New()
-	previewID := uuid.New()
-	suffix := strings.ReplaceAll(previewID.String()[:8], "-", "")
-	must := func(err error) {
-		t.Helper()
-		if err != nil {
-			t.Fatalf("setup: %v", err)
-		}
-	}
-	_, err = db.Exec(`INSERT INTO users (id, email, password_hash, name) VALUES ($1, $2, 'x', 'test')`,
-		userID, "prev-"+suffix+"@test.local")
-	must(err)
-	_, err = db.Exec(`INSERT INTO projects (id, name, owner_id, is_approved) VALUES ($1, $2, $3, true)`,
-		projectID, "prev-"+suffix, userID)
-	must(err)
-	_, err = db.Exec(`INSERT INTO environments (id, name, project_id) VALUES ($1, 'production', $2)`,
-		envID, projectID)
-	must(err)
-	for _, p := range [][3]interface{}{{srcID, "src-" + suffix, "running"}, {cloneID, "clone-" + suffix, "running"}} {
-		_, err = db.Exec(`INSERT INTO services (id, name, project_id, environment_id, service_type, source_type, status)
-			VALUES ($1, $2, $3, $4, 'web', 'image', $5)`,
-			p[0], p[1], projectID, envID, p[2])
-		must(err)
-	}
-	defer func() { _, _ = db.Exec(`DELETE FROM users WHERE id = $1`, userID) }()
-
-	must(q.CreatePreviewEnvironment(ctx, sqlcdb.CreatePreviewEnvironmentParams{
-		ID:               previewID,
-		ProjectID:        projectID,
-		ServiceID:        srcID,
-		PreviewServiceID: uuid.NullUUID{UUID: cloneID, Valid: true},
-		BranchName:       "feat-" + suffix,
-		Environment:      "preview-feat-" + suffix,
-		Status:           "building",
-		ExpiresAt:        time.Now().Add(-time.Hour), // already past TTL → sweepable
-	}))
-
-	// List + service join.
-	rows, err := q.ListPreviewEnvironmentsForProject(ctx, projectID)
-	if err != nil || len(rows) != 1 {
-		t.Fatalf("list: %v %d", err, len(rows))
-	}
-	if rows[0].ID != previewID || !rows[0].SvcID.Valid || rows[0].ServiceName.String != "src-"+suffix {
-		t.Fatalf("list row: %+v", rows[0])
-	}
-
-	// Access-check join: owner reads; a stranger does not.
-	if _, err := q.GetPreviewEnvironment(ctx, sqlcdb.GetPreviewEnvironmentParams{
-		ID: previewID, OwnerID: userID}); err != nil {
-		t.Fatalf("owner read: %v", err)
-	}
-	if _, err := q.GetPreviewEnvironment(ctx, sqlcdb.GetPreviewEnvironmentParams{
-		ID: previewID, OwnerID: uuid.New()}); err != nil {
-		t.Fatalf("approved project should be public-read: %v", err)
-	}
-
-	// Status sync folds clone's 'running' into the preview row.
-	if err := q.SyncPreviewStatuses(ctx); err != nil {
-		t.Fatalf("sync: %v", err)
-	}
-	var status string
-	if err := db.QueryRow(`SELECT status FROM preview_environments WHERE id = $1`, previewID).Scan(&status); err != nil {
-		t.Fatalf("read status: %v", err)
-	}
-	if status != "running" {
-		t.Fatalf("status after sync = %q, want running", status)
-	}
-
-	// TTL sweep picks it up (expired at insert), marks expired.
-	sweep, err := q.ListSweepablePreviews(ctx)
-	if err != nil {
-		t.Fatalf("sweep list: %v", err)
-	}
-	found := false
-	for _, s := range sweep {
-		if s.ID == previewID && s.PreviewServiceID.UUID == cloneID {
-			found = true
-		}
-	}
-	if !found {
-		t.Fatalf("sweepable list missing preview: %+v", sweep)
-	}
-	must(q.MarkPreviewEnvironmentStatus(ctx, sqlcdb.MarkPreviewEnvironmentStatusParams{Status: "expired", ID: previewID}))
-	sweep, _ = q.ListSweepablePreviews(ctx)
-	for _, s := range sweep {
-		if s.ID == previewID {
-			t.Fatal("expired preview still sweepable")
-		}
-	}
-
-	// Owner lookup and delete.
-	owner, err := q.GetPreviewEnvironmentOwner(ctx, previewID)
-	if err != nil || owner != userID {
-		t.Fatalf("owner: %v %v", owner, err)
-	}
-	must(q.DeletePreviewEnvironment(ctx, previewID))
-}
-
-// Live deployment lifecycle: generated queries preserve list ordering,
-// the access join, and the status-transition writes.
-func TestDeploymentsLiveInvariants(t *testing.T) {
-	dsn := testDSNString(t)
-	db, err := database.NewConnection(dsn)
-	if err != nil {
-		t.Fatalf("connect: %v", err)
-	}
-	defer db.Close()
-	ctx := context.Background()
-	q := sqlcdb.New(db.DB)
-
-	userID := uuid.New()
-	projectID := uuid.New()
-	envID := uuid.New()
-	serviceID := uuid.New()
-	deployID := uuid.New()
-	suffix := strings.ReplaceAll(deployID.String()[:8], "-", "")
-	must := func(err error) {
-		t.Helper()
-		if err != nil {
-			t.Fatalf("setup: %v", err)
-		}
-	}
-	_, err = db.Exec(`INSERT INTO users (id, email, password_hash, name) VALUES ($1, $2, 'x', 'test')`,
-		userID, "dep-"+suffix+"@test.local")
-	must(err)
-	_, err = db.Exec(`INSERT INTO projects (id, name, owner_id, is_approved) VALUES ($1, $2, $3, true)`,
-		projectID, "dep-"+suffix, userID)
-	must(err)
-	_, err = db.Exec(`INSERT INTO environments (id, name, project_id) VALUES ($1, 'production', $2)`,
-		envID, projectID)
-	must(err)
-	_, err = db.Exec(`INSERT INTO services (id, name, project_id, environment_id, service_type, source_type, status)
-		VALUES ($1, $2, $3, $4, 'web', 'image', 'running')`,
-		serviceID, "dep-"+suffix, projectID, envID)
-	must(err)
-	defer func() { _, _ = db.Exec(`DELETE FROM users WHERE id = $1`, userID) }()
-
-	must(q.InsertDeployment(ctx, sqlcdb.InsertDeploymentParams{
-		ID:        deployID,
-		ServiceID: serviceID,
-		Version:   "v1-" + suffix,
-		Status:    sql.NullString{String: "pending", Valid: true},
-	}))
-	total, err := q.CountDeploymentsForService(ctx, serviceID)
-	if err != nil || total != 1 {
-		t.Fatalf("count: %v %d", err, total)
-	}
-	rows, err := q.ListDeploymentsForService(ctx, sqlcdb.ListDeploymentsForServiceParams{
-		ServiceID: serviceID, Limit: 10, Offset: 0})
-	if err != nil || len(rows) != 1 || rows[0].ID != deployID {
-		t.Fatalf("list: %v %+v", err, rows)
-	}
-
-	// Access join returns owner.
-	access, err := q.GetDeploymentAccess(ctx, deployID)
-	if err != nil || access.OwnerID != userID || access.ServiceID != serviceID {
-		t.Fatalf("access: %v %+v", err, access)
-	}
-
-	// Recent feed honors the access predicate.
-	feed, err := q.ListRecentAccessibleDeployments(ctx, sqlcdb.ListRecentAccessibleDeploymentsParams{
-		OwnerID: userID, Limit: 10, Offset: 0})
-	if err != nil {
-		t.Fatalf("feed: %v", err)
-	}
-	found := false
-	for _, d := range feed {
-		if d.ID == deployID && d.ServiceName == "dep-"+suffix {
-			found = true
-		}
-	}
-	if !found {
-		t.Fatalf("feed missing deployment: %+v", feed)
-	}
-
-	// Status transitions.
-	must(q.SetDeploymentStatus(ctx, sqlcdb.SetDeploymentStatusParams{
-		Status: sql.NullString{String: "queued", Valid: true}, UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true}, ID: deployID}))
-	must(q.SyncDeploymentProgress(ctx, sqlcdb.SyncDeploymentProgressParams{
-		Status:    sql.NullString{String: "deployed", Valid: true},
-		ImageName: sql.NullString{String: "nginx", Valid: true},
-		ImageTag:  sql.NullString{String: "alpine", Valid: true},
-		UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
-		ID:        deployID,
-	}))
-	r, err := q.GetDeploymentWithProject(ctx, deployID)
-	if err != nil {
-		t.Fatalf("get: %v", err)
-	}
-	if r.Status.String != "deployed" || r.ImageName.String != "nginx" || r.ProjectID != projectID {
-		t.Fatalf("post-sync row: %+v", r)
-	}
-	must(q.FailDeployment(ctx, sqlcdb.FailDeploymentParams{
-		Error:       sql.NullString{String: "boom", Valid: true},
-		CompletedAt: sql.NullTime{Time: time.Now(), Valid: true},
-		ID:          deployID,
-	}))
-	r, _ = q.GetDeploymentWithProject(ctx, deployID)
-	if r.Status.String != "failed" || r.Error.String != "boom" {
-		t.Fatalf("post-fail row: %+v", r)
-	}
-}
-
-// TestRuntimeLiveInvariants exercises the runtime.sql queries: the
-// legacy-column COALESCE chain in GetServiceRuntimeWithOwner, the
-// deployed-image concat, and the conditional published-port update.
-func TestRuntimeLiveInvariants(t *testing.T) {
-	dsn := testDSNString(t)
-	db, err := database.NewConnection(dsn)
-	if err != nil {
-		t.Fatalf("connect: %v", err)
-	}
-	defer db.Close()
-	ctx := context.Background()
-	q := sqlcdb.New(db.DB)
-
-	userID := uuid.New()
-	projectID := uuid.New()
-	envID := uuid.New()
-	serviceID := uuid.New()
-	suffix := strings.ReplaceAll(serviceID.String()[:8], "-", "")
-	must := func(err error) {
-		t.Helper()
-		if err != nil {
-			t.Fatalf("setup: %v", err)
-		}
-	}
-	_, err = db.Exec(`INSERT INTO users (id, email, password_hash, name) VALUES ($1, $2, 'x', 'test')`,
-		userID, "rt-"+suffix+"@test.local")
-	must(err)
-	_, err = db.Exec(`INSERT INTO projects (id, name, owner_id, is_approved) VALUES ($1, $2, $3, true)`,
-		projectID, "rt-"+suffix, userID)
-	must(err)
-	_, err = db.Exec(`INSERT INTO environments (id, name, project_id) VALUES ($1, 'production', $2)`,
-		envID, projectID)
-	must(err)
-	// Only legacy columns populated — the COALESCE chain must surface them.
-	_, err = db.Exec(`INSERT INTO services (id, name, project_id, environment_id, service_type, source_type,
-		source_url, image_name, start_command, port) VALUES ($1, $2, $3, $4, 'worker', 'git', $5, $6, 'run.sh', 8080)`,
-		serviceID, "rt-"+suffix, projectID, envID, "https://git.example/x.git", "repo/img:latest")
-	must(err)
-	defer func() { _, _ = db.Exec(`DELETE FROM users WHERE id = $1`, userID) }()
-
-	row, err := q.GetServiceRuntimeWithOwner(ctx, serviceID)
-	if err != nil {
-		t.Fatalf("runtime row: %v", err)
-	}
-	if row.Type != "worker" || row.Image != "repo/img:latest" || row.Command != "run.sh" ||
-		row.GitRepo != "https://git.example/x.git" || row.OwnerID != userID {
-		t.Fatalf("COALESCE chain lost legacy columns: %+v", row)
-	}
-	svc := serviceFromRuntimeRow(row)
-	if svc.Type != "worker" || svc.Image != "repo/img:latest" || svc.Port != 8080 {
-		t.Fatalf("mapped service wrong: %+v", svc)
-	}
-
-	// Sibling refs + port lookup.
-	refs, err := q.ListProjectServiceRefs(ctx, projectID)
-	if err != nil || len(refs) != 1 || refs[0].Name != "rt-"+suffix {
-		t.Fatalf("refs: %v %+v", err, refs)
-	}
-	port, err := q.GetServicePort(ctx, serviceID)
-	if err != nil || port != 8080 {
-		t.Fatalf("port: %v %d", err, port)
-	}
-
-	// Variables round-trip.
-	_, err = db.Exec(`INSERT INTO environment_variables (id, service_id, key, value, is_secret)
-		VALUES (gen_random_uuid(), $1, 'API_KEY', 'shh', true), (gen_random_uuid(), $1, 'PLAIN', 'p', false)`,
-		serviceID)
-	must(err)
-	vars, err := q.ListServiceVariablesWithSecret(ctx, serviceID)
-	if err != nil || len(vars) != 2 {
-		t.Fatalf("vars: %v %+v", err, vars)
-	}
-	vals, err := q.ListServiceVariableValues(ctx, serviceID)
-	if err != nil || len(vals) != 2 {
-		t.Fatalf("vals: %v %+v", err, vals)
-	}
-	got, err := q.GetServiceVariableValue(ctx, sqlcdb.GetServiceVariableValueParams{ServiceID: serviceID, Key: "API_KEY"})
-	if err != nil || got != "shh" {
-		t.Fatalf("var value: %v %q", err, got)
-	}
-
-	// Node agent listing through container_instances.
-	_, err = db.Exec(`INSERT INTO node_agents (id, name, hostname, ip_address, port) VALUES ($1, $2, 'h', '127.0.0.1', 9999)`,
-		"agent-"+suffix, "agent-"+suffix)
-	must(err)
-	_, err = db.Exec(`INSERT INTO container_instances (id, name, image, project_id, service_id, node_agent_id)
-		VALUES ($1, 'c', 'img', $2, $3, $4)`,
-		"ci-"+suffix, projectID.String(), serviceID.String(), "agent-"+suffix)
-	must(err)
-	agents, err := q.ListNodeAgentsForService(ctx, serviceID.String())
-	if err != nil || len(agents) != 1 || agents[0] != "agent-"+suffix {
-		t.Fatalf("agents: %v %+v", err, agents)
-	}
-
-	// Last deployed image: only 'deployed' rows, latest first.
-	d1, d2 := uuid.New(), uuid.New()
-	must(q.InsertDeployment(ctx, sqlcdb.InsertDeploymentParams{
-		ID: d1, ServiceID: serviceID, Version: "v1",
-		Status: sql.NullString{String: "failed", Valid: true},
-	}))
-	must(q.InsertDeployment(ctx, sqlcdb.InsertDeploymentParams{
-		ID: d2, ServiceID: serviceID, Version: "v2",
-		Status: sql.NullString{String: "deployed", Valid: true},
-	}))
-	must(q.SyncDeploymentProgress(ctx, sqlcdb.SyncDeploymentProgressParams{
-		Status:    sql.NullString{String: "deployed", Valid: true},
-		ImageName: sql.NullString{String: "app", Valid: true},
-		ImageTag:  sql.NullString{String: "v2", Valid: true},
-		UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
-		ID:        d2,
-	}))
-	img, err := q.GetLastDeployedImage(ctx, serviceID)
-	if err != nil || img != "app:v2" {
-		t.Fatalf("last image: %v %q", err, img)
-	}
-
-	// Conditional published-port update: writes once, no-ops on repeat.
-	must(q.SetServicePublishedPort(ctx, sqlcdb.SetServicePublishedPortParams{PublishedPort: 30001, ID: serviceID}))
-	p, err := q.GetServicePublishedPort(ctx, serviceID)
-	if err != nil || p != 30001 {
-		t.Fatalf("published port: %v %d", err, p)
-	}
-	must(q.SetServiceReplicas(ctx, sqlcdb.SetServiceReplicasParams{
-		Replicas: 3, UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true}, ID: serviceID}))
-	row, _ = q.GetServiceRuntimeWithOwner(ctx, serviceID)
-	if row.Replicas != 3 {
-		t.Fatalf("replicas: %+v", row)
-	}
-
-	// Sleeper reads: candidate sweep + domain/status text lookups.
-	_, err = db.Exec(`UPDATE services SET sleep_enabled = true, domain = 'rt.example.com', status = 'running' WHERE id = $1`, serviceID)
-	must(err)
-	cands, err := q.ListSleepCandidates(ctx)
-	if err != nil {
-		t.Fatalf("sleep candidates: %v", err)
-	}
-	var mine *sqlcdb.ListSleepCandidatesRow
-	for i := range cands {
-		if cands[i].ID == serviceID {
-			mine = &cands[i]
-		}
-	}
-	if mine == nil || mine.SleepIdleMinutes != 15 {
-		t.Fatalf("candidate missing/idle wrong: %+v", mine)
-	}
-	dom, err := q.GetServiceDomainText(ctx, serviceID)
-	if err != nil || dom != "rt.example.com" {
-		t.Fatalf("domain text: %v %q", err, dom)
-	}
-	st, err := q.GetServiceStatusText(ctx, serviceID)
-	if err != nil || st != "running" {
-		t.Fatalf("status text: %v %q", err, st)
-	}
-}

app/backend/internal/api/preview_environments.go

@@ -40,68 +40,6 @@ type PreviewEnvironment struct {
 	DeploymentID *uuid.UUID `json:"deployment_id,omitempty"`
 }
 
-// previewRowShape is the common column set the generated preview rows
-// carry — ListPreviewEnvironmentsForProjectRow and GetPreviewEnvironmentRow
-// share it.
-type previewRowShape struct {
-	ID               uuid.UUID
-	ProjectID        uuid.UUID
-	ServiceID        uuid.UUID
-	PreviewServiceID uuid.NullUUID
-	BranchName       string
-	PrNumber         sql.NullInt32
-	Environment      string
-	Status           string
-	Url              sql.NullString
-	ExpiresAt        time.Time
-	CreatedAt        sql.NullTime
-	UpdatedAt        sql.NullTime
-	SvcID            uuid.NullUUID
-	ServiceName      sql.NullString
-	ServiceType      sql.NullString
-}
-
-func previewFromRow(r previewRowShape) PreviewEnvironment {
-	env := PreviewEnvironment{
-		ID:          r.ID,
-		ProjectID:   r.ProjectID,
-		ServiceID:   r.ServiceID,
-		BranchName:  r.BranchName,
-		Environment: r.Environment,
-		Status:      r.Status,
-		URL:         r.Url.String,
-		CreatedAt:   r.CreatedAt.Time,
-		UpdatedAt:   r.UpdatedAt.Time,
-	}
-	if r.PreviewServiceID.Valid {
-		id := r.PreviewServiceID.UUID
-		env.PreviewServiceID = &id
-	}
-	if r.PrNumber.Valid {
-		n := int(r.PrNumber.Int32)
-		env.PRNumber = &n
-	}
-	if !r.ExpiresAt.IsZero() {
-		t := r.ExpiresAt
-		env.ExpiresAt = &t
-	}
-	if r.SvcID.Valid {
-		env.Service = &Service{
-			ID:   r.SvcID.UUID,
-			Name: r.ServiceName.String,
-			Type: r.ServiceType.String,
-		}
-	}
-	return env
-}
-
-func prNumberSQL(n *int) sql.NullInt32 {
-	if n == nil {
-		return sql.NullInt32{}
-	}
-	return sql.NullInt32{Int32: int32(*n), Valid: true}
-}
-
 // CreatePreviewEnvironmentRequest represents a request to create a preview environment
 type CreatePreviewEnvironmentRequest struct {
 	ProjectID  uuid.UUID `json:"project_id"`
@@ -148,21 +86,51 @@ func handleGetPreviewEnvironments(c *gin.Context) {
 	}
 
 	// Get preview environments for the project with service info
-	rows, err := sqlcdb.New(db.(*database.DB).DB).ListPreviewEnvironmentsForProject(c.Request.Context(), projectID)
+	rows, err := db.(*database.DB).Query(
+		`SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.pr_number,
+				pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at,
+				s.id as service_id, s.name as service_name, s.type as service_type
+			FROM preview_environments pe
+			LEFT JOIN services s ON pe.service_id = s.id
+			WHERE pe.project_id = $1
+			ORDER BY pe.created_at DESC`,
+		projectID,
+	)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to retrieve preview environments"})
 		return
 	}
+	defer rows.Close()
 
-	environments := make([]PreviewEnvironment, 0, len(rows))
+	var environments []PreviewEnvironment
-	for _, r := range rows {
+	for rows.Next() {
-		environments = append(environments, previewFromRow(previewRowShape{
+		var env PreviewEnvironment
-			ID: r.ID, ProjectID: r.ProjectID, ServiceID: r.ServiceID,
+		var serviceID sql.NullString
-			PreviewServiceID: r.PreviewServiceID, BranchName: r.BranchName,
+		var serviceName sql.NullString
-			PrNumber: r.PrNumber, Environment: r.Environment, Status: r.Status,
+		var serviceType sql.NullString
-			Url: r.Url, ExpiresAt: r.ExpiresAt, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
+
-			SvcID: r.SvcID, ServiceName: r.ServiceName, ServiceType: r.ServiceType,
+		err := rows.Scan(
-		}))
+			&env.ID, &env.ProjectID, &env.ServiceID, &env.PreviewServiceID, &env.BranchName, &env.PRNumber,
+			&env.Environment, &env.Status, &env.URL, &env.ExpiresAt, &env.CreatedAt, &env.UpdatedAt,
+			&serviceID, &serviceName, &serviceType,
+		)
+		if err != nil {
+			c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to scan preview environment"})
+			return
+		}
+
+		if serviceID.Valid {
+			parsedServiceID, parseErr := uuid.Parse(serviceID.String)
+			if parseErr == nil {
+				env.Service = &Service{
+					ID:   parsedServiceID,
+					Name: serviceName.String,
+					Type: serviceType.String,
+				}
+			}
+		}
+
+		environments = append(environments, env)
 	}
 
 	c.JSON(http.StatusOK, gin.H{"preview_environments": environments})
@@ -203,37 +171,48 @@ func handleCreatePreviewEnvironment(c *gin.Context) {
 		return
 	}
 
-	ctx := c.Request.Context()
-	q := sqlcdb.New(db.(*database.DB).DB)
-
 	// Check if project exists and user has access
-	project, err := q.GetProjectBrief(ctx, req.ProjectID)
+	var project Project
+	err = db.(*database.DB).QueryRow(
+		"SELECT id, name, owner_id FROM projects WHERE id = $1",
+		req.ProjectID,
+	).Scan(&project.ID, &project.Name, &project.OwnerID)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Project not found"})
 		return
 	}
 
 	// Check if user owns the project
-	if project.OwnerID.String() != userID.(string) && !contextIsAdmin(c) {
+	if project.OwnerID != userID.(string) && !contextIsAdmin(c) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return
 	}
 
 	// Check if service exists and belongs to the project
-	service, err := q.GetServiceTypeBrief(ctx, sqlcdb.GetServiceTypeBriefParams{
+	var service Service
-		ID: req.ServiceID, ProjectID: req.ProjectID})
+	err = db.(*database.DB).QueryRow(
+		"SELECT id, name, COALESCE(type, service_type, '') FROM services WHERE id = $1 AND project_id = $2",
+		req.ServiceID, req.ProjectID,
+	).Scan(&service.ID, &service.Name, &service.Type)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Service not found or doesn't belong to this project"})
 		return
 	}
 
 	// Check if preview environment already exists for this branch and service
-	count, err := q.CountActivePreviewsForBranch(ctx, sqlcdb.CountActivePreviewsForBranchParams{
+	var count int
-		ServiceID: req.ServiceID, BranchName: req.BranchName})
+	err = db.(*database.DB).QueryRow(
+		"SELECT COUNT(*) FROM preview_environments WHERE service_id = $1 AND branch_name = $2 AND status NOT IN ('expired', 'stopped')",
+		req.ServiceID, req.BranchName,
+	).Scan(&count)
+
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to check existing preview environment"})
 		return
 	}
+
 	if count > 0 {
 		c.JSON(http.StatusConflict, gin.H{"error": "Preview environment already exists for this branch and service"})
 		return
@@ -258,23 +237,29 @@ func handleCreatePreviewEnvironment(c *gin.Context) {
 
 	// The clone's branch override is what makes it a preview — everything
 	// else (env vars, volumes, builder, resources) stays identical.
-	if err := q.UpdateServicePreviewBranch(ctx, sqlcdb.UpdateServicePreviewBranchParams{
+	if _, err := db.(*database.DB).Exec(
-		GitBranch: sql.NullString{String: req.BranchName, Valid: true}, ID: cloneID}); err != nil {
+		`UPDATE services SET git_branch = $1, domain = '', updated_at = NOW() WHERE id = $2`,
-		_ = q.DeleteServiceByID(ctx, cloneID)
+		req.BranchName, cloneID,
+	); err != nil {
+		_, _ = db.(*database.DB).Exec(`DELETE FROM services WHERE id = $1`, cloneID)
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to configure preview service"})
 		return
 	}
 	// Cloned service_domains would collide with the parent's Traefik
 	// router — previews get their own hostname or none.
-	if err := q.DeleteAllServiceDomains(ctx, cloneID); err != nil {
+	if _, err := db.(*database.DB).Exec(
-		_ = q.DeleteServiceByID(ctx, cloneID)
+		`DELETE FROM service_domains WHERE service_id = $1`, cloneID,
+	); err != nil {
+		_, _ = db.(*database.DB).Exec(`DELETE FROM services WHERE id = $1`, cloneID)
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to configure preview domains"})
 		return
 	}
 	previewHost := resolvePreviewHost(db.(*database.DB), cloneID, envName)
 	if previewHost != "" {
-		_ = q.CreatePreviewDomain(ctx, sqlcdb.CreatePreviewDomainParams{
+		_, _ = db.(*database.DB).Exec(
-			ServiceID: cloneID, Domain: previewHost})
+			`INSERT INTO service_domains (service_id, domain, is_default, cert_type) VALUES ($1, $2, true, 'tls')`,
+			cloneID, previewHost,
+		)
 	}
 
 	expiresAt := time.Now().Add(time.Duration(ttlHours) * time.Hour)
@@ -294,36 +279,30 @@ func handleCreatePreviewEnvironment(c *gin.Context) {
 		env.URL = "https://" + previewHost
 	}
 
-	err = q.CreatePreviewEnvironment(ctx, sqlcdb.CreatePreviewEnvironmentParams{
+	_, err = db.(*database.DB).Exec(
-		ID:               env.ID,
+		`INSERT INTO preview_environments
-		ProjectID:        env.ProjectID,
+			(id, project_id, service_id, preview_service_id, branch_name, pr_number, environment,
-		ServiceID:        env.ServiceID,
+			 status, url, expires_at, created_at, updated_at)
-		PreviewServiceID: uuid.NullUUID{UUID: cloneID, Valid: true},
+			VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`,
-		BranchName:       env.BranchName,
+		env.ID, env.ProjectID, env.ServiceID, cloneID, env.BranchName, env.PRNumber,
-		PrNumber:         prNumberSQL(env.PRNumber),
+		env.Environment, env.Status, env.URL, env.ExpiresAt, env.CreatedAt, env.UpdatedAt,
-		Environment:      env.Environment,
+	)
-		Status:           env.Status,
-		Url:              sql.NullString{String: env.URL, Valid: env.URL != ""},
-		ExpiresAt:        *env.ExpiresAt,
-		CreatedAt:        sql.NullTime{Time: env.CreatedAt, Valid: true},
-		UpdatedAt:        sql.NullTime{Time: env.UpdatedAt, Valid: true},
-	})
 	if err != nil {
-		_ = q.DeleteServiceByID(ctx, cloneID)
+		_, _ = db.(*database.DB).Exec(`DELETE FROM services WHERE id = $1`, cloneID)
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create preview environment"})
 		return
 	}
 
 	deploymentID := uuid.New()
-	err = q.InsertPendingDeployment(ctx, sqlcdb.InsertPendingDeploymentParams{
+	_, err = db.(*database.DB).Exec(
-		ID:         deploymentID,
+		`INSERT INTO deployments
-		ServiceID:  cloneID,
+			(id, service_id, version, commit_hash, status, created_at, updated_at)
-		Version:    "preview-" + env.Environment,
+		 VALUES ($1, $2, $3, $4, 'pending', NOW(), NOW())`,
-		CommitHash: sql.NullString{String: req.BranchName, Valid: true},
+		deploymentID, cloneID, "preview-"+env.Environment, req.BranchName,
-	})
+	)
 	if err != nil {
-		_ = q.DeletePreviewEnvironment(ctx, env.ID)
+		_, _ = db.(*database.DB).Exec(`DELETE FROM preview_environments WHERE id = $1`, env.ID)
-		_ = q.DeleteServiceByID(ctx, cloneID)
+		_, _ = db.(*database.DB).Exec(`DELETE FROM services WHERE id = $1`, cloneID)
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to provision preview deployment"})
 		return
 	}
@@ -370,20 +349,43 @@ func handleGetPreviewEnvironment(c *gin.Context) {
 
 	// Public when the parent project is approved; otherwise owner/member/admin.
 	userID := optionalUserUUID(c)
-	r, err := sqlcdb.New(db.(*database.DB).DB).GetPreviewEnvironment(
+	var env PreviewEnvironment
-		c.Request.Context(), sqlcdb.GetPreviewEnvironmentParams{
+	var serviceID sql.NullString
-			ID: envID, OwnerID: userID, Column3: contextIsAdmin(c)})
+	var serviceName sql.NullString
+	var serviceType sql.NullString
+	err = db.(*database.DB).QueryRow(
+		`SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.pr_number,
+				pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at,
+				s.id as service_id, s.name as service_name, s.type as service_type
+			FROM preview_environments pe
+			LEFT JOIN services s ON pe.service_id = s.id
+			JOIN projects p ON pe.project_id = p.id
+			WHERE pe.id = $1 AND (p.is_approved OR p.owner_id = $2 OR $3::bool
+				OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $2))`,
+		envID, userID, contextIsAdmin(c),
+	).Scan(
+		&env.ID, &env.ProjectID, &env.ServiceID, &env.PreviewServiceID, &env.BranchName, &env.PRNumber,
+		&env.Environment, &env.Status, &env.URL, &env.ExpiresAt, &env.CreatedAt, &env.UpdatedAt,
+		&serviceID, &serviceName, &serviceType,
+	)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Preview environment not found"})
 		return
 	}
-	env := previewFromRow(previewRowShape{
+
-		ID: r.ID, ProjectID: r.ProjectID, ServiceID: r.ServiceID,
+	// Populate service info if available
-		PreviewServiceID: r.PreviewServiceID, BranchName: r.BranchName,
+	if serviceID.Valid {
-		PrNumber: r.PrNumber, Environment: r.Environment, Status: r.Status,
+		parsedServiceID, parseErr := uuid.Parse(serviceID.String)
-		Url: r.Url, ExpiresAt: r.ExpiresAt, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
+		if parseErr == nil {
-		SvcID: r.SvcID, ServiceName: r.ServiceName, ServiceType: r.ServiceType,
+			env.Service = &Service{
-	})
+				ID:   parsedServiceID,
+				Name: serviceName.String,
+				Type: serviceType.String,
+			}
+		}
+	}
+
 	c.JSON(http.StatusOK, gin.H{"preview_environment": env})
 }
 
@@ -416,21 +418,24 @@ func handleUpdatePreviewEnvironment(c *gin.Context) {
 	}
 
 	// Check if preview environment exists and user has access
-	uid, _ := uuid.Parse(fmt.Sprint(userID))
+	var existingEnv PreviewEnvironment
-	q := sqlcdb.New(db.(*database.DB).DB)
+	err = db.(*database.DB).QueryRow(
-	r, err := q.GetPreviewEnvironmentForWrite(
+		`SELECT pe.id, pe.project_id, pe.service_id, pe.branch_name, pe.pr_number, 
-		c.Request.Context(), sqlcdb.GetPreviewEnvironmentForWriteParams{
+				pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at
-			ID: envID, OwnerID: uid, Column3: contextIsAdmin(c)})
+			FROM preview_environments pe
+			JOIN projects p ON pe.project_id = p.id
+			WHERE pe.id = $1 AND (p.owner_id = $2 OR $3::bool)`,
+		envID, userID, contextIsAdmin(c),
+	).Scan(
+		&existingEnv.ID, &existingEnv.ProjectID, &existingEnv.ServiceID, &existingEnv.BranchName,
+		&existingEnv.PRNumber, &existingEnv.Environment, &existingEnv.Status, &existingEnv.URL,
+		&existingEnv.ExpiresAt, &existingEnv.CreatedAt, &existingEnv.UpdatedAt,
+	)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Preview environment not found"})
 		return
 	}
-	existingEnv := previewFromRow(previewRowShape{
-		ID: r.ID, ProjectID: r.ProjectID, ServiceID: r.ServiceID,
-		BranchName: r.BranchName, PrNumber: r.PrNumber, Environment: r.Environment,
-		Status: r.Status, Url: r.Url, ExpiresAt: r.ExpiresAt,
-		CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
-	})
 
 	// Update fields if provided
 	if req.Status != "" {
@@ -450,17 +455,12 @@ func handleUpdatePreviewEnvironment(c *gin.Context) {
 	existingEnv.UpdatedAt = time.Now()
 
 	// Update preview environment in database
-	expiresAt := time.Time{}
+	_, err = db.(*database.DB).Exec(
-	if existingEnv.ExpiresAt != nil {
+		`UPDATE preview_environments 
-		expiresAt = *existingEnv.ExpiresAt
+			SET status = $1, url = $2, expires_at = $3, updated_at = $4
-	}
+			WHERE id = $5`,
-	err = q.UpdatePreviewEnvironment(c.Request.Context(), sqlcdb.UpdatePreviewEnvironmentParams{
+		existingEnv.Status, existingEnv.URL, existingEnv.ExpiresAt, existingEnv.UpdatedAt, existingEnv.ID,
-		Status:    existingEnv.Status,
+	)
-		Url:       sql.NullString{String: existingEnv.URL, Valid: existingEnv.URL != ""},
-		ExpiresAt: expiresAt,
-		UpdatedAt: sql.NullTime{Time: existingEnv.UpdatedAt, Valid: true},
-		ID:        existingEnv.ID,
-	})
 
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update preview environment"})
@@ -492,34 +492,46 @@ func handleDeletePreviewEnvironment(c *gin.Context) {
 		return
 	}
 
-	ctx := c.Request.Context()
-	q := sqlcdb.New(db.(*database.DB).DB)
-
 	// Check if preview environment exists and user has access
-	projectOwnerID, err := q.GetPreviewEnvironmentOwner(ctx, envID)
+	var projectOwnerID string
+	err = db.(*database.DB).QueryRow(
+		`SELECT p.owner_id 
+			FROM preview_environments pe
+			JOIN projects p ON pe.project_id = p.id
+			WHERE pe.id = $1`,
+		envID,
+	).Scan(&projectOwnerID)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Preview environment not found"})
 		return
 	}
 
 	// Check if user owns the project
-	if projectOwnerID.String() != userID.(string) && !contextIsAdmin(c) {
+	if projectOwnerID != userID.(string) && !contextIsAdmin(c) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return
 	}
 
 	// Tear down the clone's runtime and row — the preview is the clone.
-	if cloneID, err := q.GetPreviewServiceID(ctx, envID); err == nil && cloneID.Valid {
+	var cloneID *uuid.UUID
+	_ = db.(*database.DB).QueryRow(
+		`SELECT preview_service_id FROM preview_environments WHERE id = $1`, envID,
+	).Scan(&cloneID)
+	if cloneID != nil {
 		if engineValue, exists := c.Get("deployment_engine"); exists && engineValue != nil {
 			if engine, ok := engineValue.(*deployment.DeploymentEngine); ok {
-				removeServiceRuntime(ctx, db.(*database.DB), engine, cloneID.UUID)
+				removeServiceRuntime(c.Request.Context(), db.(*database.DB), engine, *cloneID)
 			}
 		}
-		_ = q.DeleteServiceByID(ctx, cloneID.UUID)
+		_, _ = db.(*database.DB).Exec(`DELETE FROM services WHERE id = $1`, *cloneID)
 	}
 
 	// Delete preview environment
-	err = q.DeletePreviewEnvironment(ctx, envID)
+	_, err = db.(*database.DB).Exec(
+		"DELETE FROM preview_environments WHERE id = $1",
+		envID,
+	)
 
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to delete preview environment"})
@@ -557,30 +569,22 @@ func handlePromotePreviewEnvironment(c *gin.Context) {
 		return
 	}
 
-	ctx := c.Request.Context()
-	q := sqlcdb.New(db.(*database.DB).DB)
-
 	// Get preview environment details
-	uid, _ := uuid.Parse(fmt.Sprint(userID))
+	var env PreviewEnvironment
-	r, err := q.GetPreviewEnvironmentForPromote(
+	err = db.(*database.DB).QueryRow(
-		ctx, sqlcdb.GetPreviewEnvironmentForPromoteParams{
+		`SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.environment, pe.status
-			ID: envID, OwnerID: uid, Column3: contextIsAdmin(c)})
+			FROM preview_environments pe
+			JOIN projects p ON pe.project_id = p.id
+			WHERE pe.id = $1 AND (p.owner_id = $2 OR $3::bool)`,
+		envID, userID, contextIsAdmin(c),
+	).Scan(
+		&env.ID, &env.ProjectID, &env.ServiceID, &env.PreviewServiceID, &env.BranchName, &env.Environment, &env.Status,
+	)
+
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Preview environment not found"})
 		return
 	}
-	env := PreviewEnvironment{
-		ID:          r.ID,
-		ProjectID:   r.ProjectID,
-		ServiceID:   r.ServiceID,
-		BranchName:  r.BranchName,
-		Environment: r.Environment,
-		Status:      r.Status,
-	}
-	if r.PreviewServiceID.Valid {
-		id := r.PreviewServiceID.UUID
-		env.PreviewServiceID = &id
-	}
 
 	// Check if preview environment is in a state that can be promoted
 	if env.Status != "running" {
@@ -592,12 +596,11 @@ func handlePromotePreviewEnvironment(c *gin.Context) {
 	// branch onto its own deployment track.
 	deploymentID := uuid.New()
 	promotionVersion := fmt.Sprintf("promote-%s-%d", strings.ReplaceAll(env.BranchName, "/", "-"), time.Now().Unix())
-	err = q.InsertPendingDeployment(ctx, sqlcdb.InsertPendingDeploymentParams{
+	_, err = db.(*database.DB).Exec(
-		ID:         deploymentID,
+		`INSERT INTO deployments (id, service_id, version, commit_hash, status, created_at, updated_at)
-		ServiceID:  env.ServiceID,
+		 VALUES ($1, $2, $3, $4, 'pending', NOW(), NOW())`,
-		Version:    promotionVersion,
+		deploymentID, env.ServiceID, promotionVersion, env.BranchName,
-		CommitHash: sql.NullString{String: env.BranchName, Valid: true},
+	)
-	})
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create promotion deployment"})
 		return
@@ -625,14 +628,18 @@ func handlePromotePreviewEnvironment(c *gin.Context) {
 	if env.PreviewServiceID != nil {
 		if engineValue, exists := c.Get("deployment_engine"); exists && engineValue != nil {
 			if engine, ok := engineValue.(*deployment.DeploymentEngine); ok {
-				removeServiceRuntime(ctx, db.(*database.DB), engine, *env.PreviewServiceID)
+				removeServiceRuntime(c.Request.Context(), db.(*database.DB), engine, *env.PreviewServiceID)
 			}
 		}
-		_ = q.DeleteServiceByID(ctx, *env.PreviewServiceID)
+		_, _ = db.(*database.DB).Exec(`DELETE FROM services WHERE id = $1`, *env.PreviewServiceID)
 	}
 
-	if err := q.MarkPreviewEnvironmentStatus(ctx, sqlcdb.MarkPreviewEnvironmentStatusParams{
+	if _, err := db.(*database.DB).Exec(
-		Status: "stopped", ID: env.ID}); err != nil {
+		`UPDATE preview_environments
+		 SET status = 'stopped', updated_at = NOW()
+		 WHERE id = $1`,
+		env.ID,
+	); err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to update preview environment status"})
 		return
 	}
@@ -675,27 +682,28 @@ func handleCleanupExpiredPreviewEnvironments(c *gin.Context) {
 		return
 	}
 
-	ctx := c.Request.Context()
-	q := sqlcdb.New(db.(*database.DB).DB)
-	uid, _ := uuid.Parse(fmt.Sprint(userID))
-
 	// Find expired preview environments for user's projects
-	rows, err := q.ListExpiredPreviewsForUser(ctx, sqlcdb.ListExpiredPreviewsForUserParams{
+	rows, err := db.(*database.DB).Query(
-		OwnerID: uid, Column2: contextIsAdmin(c)})
+		`SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.environment
+			FROM preview_environments pe
+			JOIN projects p ON pe.project_id = p.id
+			WHERE (p.owner_id = $1 OR $2::bool) AND pe.expires_at < NOW() AND pe.status != 'expired'`,
+		userID, contextIsAdmin(c),
+	)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to find expired preview environments"})
 		return
 	}
+	defer rows.Close()
 
-	expiredEnvs := make([]PreviewEnvironment, 0, len(rows))
+	var expiredEnvs []PreviewEnvironment
-	for _, r := range rows {
+	for rows.Next() {
-		env := PreviewEnvironment{
+		var env PreviewEnvironment
-			ID: r.ID, ProjectID: r.ProjectID, ServiceID: r.ServiceID,
+		err := rows.Scan(
-			BranchName: r.BranchName, Environment: r.Environment,
+			&env.ID, &env.ProjectID, &env.ServiceID, &env.PreviewServiceID, &env.BranchName, &env.Environment,
-		}
+		)
-		if r.PreviewServiceID.Valid {
+		if err != nil {
-			id := r.PreviewServiceID.UUID
+			continue
-			env.PreviewServiceID = &id
 		}
 		expiredEnvs = append(expiredEnvs, env)
 	}
@@ -703,17 +711,20 @@ func handleCleanupExpiredPreviewEnvironments(c *gin.Context) {
 	// Mark expired environments as expired and tear down their clones
 	cleanupCount := 0
 	for _, env := range expiredEnvs {
-		if err := q.MarkPreviewEnvironmentStatus(ctx, sqlcdb.MarkPreviewEnvironmentStatusParams{
+		_, err := db.(*database.DB).Exec(
-			Status: "expired", ID: env.ID}); err != nil {
+			"UPDATE preview_environments SET status = 'expired', updated_at = NOW() WHERE id = $1",
+			env.ID,
+		)
+		if err != nil {
 			continue
 		}
 		if env.PreviewServiceID != nil {
 			if engineValue, exists := c.Get("deployment_engine"); exists && engineValue != nil {
 				if engine, ok := engineValue.(*deployment.DeploymentEngine); ok {
-					removeServiceRuntime(ctx, db.(*database.DB), engine, *env.PreviewServiceID)
+					removeServiceRuntime(c.Request.Context(), db.(*database.DB), engine, *env.PreviewServiceID)
 				}
 			}
-			_ = q.DeleteServiceByID(ctx, *env.PreviewServiceID)
+			_, _ = db.(*database.DB).Exec(`DELETE FROM services WHERE id = $1`, *env.PreviewServiceID)
 		}
 		cleanupCount++
 	}
@@ -743,13 +754,15 @@ func resolvePreviewHost(db *database.DB, cloneID uuid.UUID, envName string) stri
 	if label == "" {
 		return ""
 	}
-	q := sqlcdb.New(db.DB)
+	var nodeID sql.NullString
-	ctx := context.Background()
+	var spread bool
-	brief, err := q.GetServicePlacementBrief(ctx, cloneID)
+	if err := db.QueryRow(
-	if err != nil {
+		`SELECT node_id, COALESCE(spread, false) FROM services WHERE id = $1`, cloneID,
+	).Scan(&nodeID, &spread); err != nil {
 		return ""
 	}
-	nodeID, spread := brief.NodeID, brief.Spread
+	q := sqlcdb.New(db.DB)
+	ctx := context.Background()
 	var base string
 	switch {
 	case nodeID.Valid && nodeID.String != "":
@@ -775,27 +788,31 @@ func resolvePreviewHost(db *database.DB, cloneID uuid.UUID, envName string) stri
 
 // loadServiceForDeploy hydrates the Service fields runDeploymentAndSync
 // needs — mirrors the loader in handleDeployService.
-func serviceForDeployFromRow(r sqlcdb.GetServiceForDeployRow) Service {
-	return Service{
-		ID: r.ID, ProjectID: r.ProjectID, Name: r.Name, Type: r.Type.String,
-		Status: r.Status.String, Image: r.Image.String, Command: r.Command.String,
-		Environment: r.Environment.String, GitRepo: r.GitRepo.String,
-		GitBranch: r.GitBranch.String, BuildPath: r.BuildPath.String,
-		CPU: r.Cpu.String, Memory: r.Memory.String,
-		Replicas: int(r.Replicas), Port: int(r.Port), Domain: r.Domain,
-		HealthCheckPath: r.HealthcheckPath, RestartPolicy: r.RestartPolicy,
-		Builder: r.Builder, CPUReserve: r.CpuReserve, MemoryReserve: r.MemoryReserve,
-		StaticBuildCmd: r.StaticBuildCmd, StaticDir: r.StaticDir,
-		CreatedAt: r.CreatedAt.Time, UpdatedAt: r.UpdatedAt.Time,
-	}
-}
-
 func loadServiceForDeploy(db *database.DB, serviceID uuid.UUID) (Service, error) {
-	r, err := sqlcdb.New(db.DB).GetServiceForDeploy(context.Background(), serviceID)
+	var service Service
-	if err != nil {
+	err := db.QueryRow(
-		return Service{}, err
+		`SELECT s.id, s.project_id, s.name, s.type, s.status, s.image, s.command,
-	}
+		        s.environment, s.git_repo, s.git_branch, s.build_path, s.cpu, s.memory,
-	return serviceForDeployFromRow(r), nil
+		        COALESCE(s.replicas, 1), COALESCE(s.port, 0),
+		        COALESCE(s.domain, ''), COALESCE(s.healthcheck_path, ''),
+		        COALESCE(s.restart_policy, 'unless-stopped'),
+		        COALESCE(s.builder, 'auto'), COALESCE(s.cpu_reserve, ''),
+		        COALESCE(s.memory_reserve, ''), COALESCE(s.static_build_cmd, ''),
+		        COALESCE(s.static_dir, ''),
+		        s.created_at, s.updated_at
+		 FROM services s
+		 WHERE s.id = $1`,
+		serviceID,
+	).Scan(
+		&service.ID, &service.ProjectID, &service.Name, &service.Type, &service.Status,
+		&service.Image, &service.Command, &service.Environment, &service.GitRepo,
+		&service.GitBranch, &service.BuildPath, &service.CPU, &service.Memory,
+		&service.Replicas, &service.Port, &service.Domain, &service.HealthCheckPath,
+		&service.RestartPolicy, &service.Builder, &service.CPUReserve,
+		&service.MemoryReserve, &service.StaticBuildCmd, &service.StaticDir,
+		&service.CreatedAt, &service.UpdatedAt,
+	)
+	return service, err
 }
 
 // StartPreviewSweeper expires preview environments past their TTL — tears
@@ -821,27 +838,54 @@ func StartPreviewSweeper(ctx context.Context, db *database.DB, engine *deploymen
 
 // sweepExpiredPreviews retires previews whose TTL elapsed.
 func sweepExpiredPreviews(ctx context.Context, db *database.DB, engine *deployment.DeploymentEngine) {
-	q := sqlcdb.New(db.DB)
+	rows, err := db.QueryContext(ctx,
-	rows, err := q.ListSweepablePreviews(ctx)
+		`SELECT id, preview_service_id FROM preview_environments
+		 WHERE expires_at < NOW() AND status NOT IN ('expired', 'stopped')`)
 	if err != nil {
 		return
 	}
 	var ids []uuid.UUID
-	for _, r := range rows {
+	var clones []uuid.UUID
-		ids = append(ids, r.ID)
+	for rows.Next() {
-		if r.PreviewServiceID.Valid {
+		var id uuid.UUID
-			removeServiceRuntime(ctx, db, engine, r.PreviewServiceID.UUID)
+		var cloneID *uuid.UUID
-			_ = q.DeleteServiceByID(ctx, r.PreviewServiceID.UUID)
+		if err := rows.Scan(&id, &cloneID); err == nil {
+			ids = append(ids, id)
+			if cloneID != nil {
+				clones = append(clones, *cloneID)
+			}
 		}
 	}
+	rows.Close()
+	for _, cloneID := range clones {
+		removeServiceRuntime(ctx, db, engine, cloneID)
+		_, _ = db.ExecContext(ctx, `DELETE FROM services WHERE id = $1`, cloneID)
+	}
 	for _, id := range ids {
-		_ = q.MarkPreviewEnvironmentStatus(ctx, sqlcdb.MarkPreviewEnvironmentStatusParams{
+		_, _ = db.ExecContext(ctx,
-			Status: "expired", ID: id})
+			`UPDATE preview_environments SET status = 'expired', updated_at = NOW() WHERE id = $1`, id)
 	}
 }
 
 // syncPreviewStatuses folds the clone's live service status into the
 // preview row so list/detail endpoints reflect the real deploy state.
 func syncPreviewStatuses(ctx context.Context, db *database.DB) {
-	_ = sqlcdb.New(db.DB).SyncPreviewStatuses(ctx)
+	_, _ = db.ExecContext(ctx, `
+		UPDATE preview_environments pe
+		SET status = derived.st, updated_at = NOW()
+		FROM (
+			SELECT pe2.id,
+				CASE
+					WHEN s.status IN ('running', 'deployed') THEN 'running'
+					WHEN s.status IN ('failed', 'error') THEN 'failed'
+					WHEN s.status IN ('building', 'deploying', 'queued', 'pending', 'cloning') THEN 'building'
+					ELSE pe2.status
+				END AS st
+			FROM preview_environments pe2
+			JOIN services s ON pe2.preview_service_id = s.id
+		) derived
+		WHERE pe.id = derived.id
+		  AND pe.status IN ('building', 'running', 'failed')
+		  AND pe.status <> derived.st
+	`)
 }

app/backend/internal/api/runtime.go

@@ -2,7 +2,6 @@ package api
 
 import (
 	"context"
-	"database/sql"
 	"fmt"
 	"net/http"
 	"regexp"
@@ -11,7 +10,6 @@ import (
 	"time"
 
 	"containr/internal/database"
-	"containr/internal/database/sqlcdb"
 	"containr/internal/deployment"
 	"containr/internal/deployqueue"
 	"containr/internal/secrets"
@@ -24,17 +22,22 @@ import (
 // service — covers pinned placements, spread replicas, and leftovers from a
 // since-cleared pin.
 func remoteAgentsForService(ctx context.Context, db *database.DB, serviceID uuid.UUID) []string {
-	ids, err := sqlcdb.New(db.DB).ListNodeAgentsForService(ctx, serviceID.String())
+	rows, err := db.Query(
+		`SELECT DISTINCT node_agent_id FROM container_instances WHERE service_id = $1`,
+		serviceID,
+	)
 	if err != nil {
 		return nil
 	}
-	out := make([]string, 0, len(ids))
+	defer rows.Close()
-	for _, id := range ids {
+	var ids []string
-		if id != "" {
+	for rows.Next() {
-			out = append(out, id)
+		var id string
+		if rows.Scan(&id) == nil && id != "" {
+			ids = append(ids, id)
 		}
 	}
-	return out
+	return ids
 }
 
 // serviceLifecycle routes a start/stop/restart action to every agent holding
@@ -96,9 +99,7 @@ func serviceRuntimeSpec(db *database.DB, service Service) (deployment.RuntimeSpe
 	// Best effort: reuse the host port from the last live deployment so the
 	// public URL survives restarts. Column exists post-migration; older DBs
 	// silently get ephemeral ports.
-	if p, err := sqlcdb.New(db.DB).GetServicePublishedPort(context.Background(), service.ID); err == nil {
+	_ = db.QueryRow(`SELECT published_port FROM services WHERE id = $1`, service.ID).Scan(&spec.PublishedPort)
-		spec.PublishedPort = p
-	}
 	if cmd := strings.TrimSpace(service.Command); cmd != "" {
 		spec.Command = strings.Fields(cmd)
 	}
@@ -136,23 +137,42 @@ var refVarPattern = regexp.MustCompile(`\$\{\{\s*([A-Za-z0-9_-]+)\.([A-Za-z_][A-
 // secrets) and expands ${{service.KEY}} references. KEY may be a variable on
 // the referenced service, or the builtins HOST (service name alias) and PORT.
 func resolveServiceEnv(db *database.DB, service Service) (map[string]string, error) {
-	q := sqlcdb.New(db.DB)
+	rows, err := db.Query(
-	vars, err := q.ListServiceVariableValues(context.Background(), service.ID)
+		`SELECT key, value FROM environment_variables WHERE service_id = $1`,
+		service.ID,
+	)
 	if err != nil {
 		return nil, err
 	}
+	defer rows.Close()
 
 	env := map[string]string{}
-	for _, v := range vars {
+	for rows.Next() {
-		env[v.Key] = secrets.Decrypt(v.Value)
+		var k, v string
+		if err := rows.Scan(&k, &v); err != nil {
+			return nil, err
+		}
+		env[k] = secrets.Decrypt(v)
 	}
 
-	refServices, err := q.ListProjectServiceRefs(context.Background(), service.ProjectID)
+	var refServices []struct{ ID, Name string }
+	svcRows, err := db.Query(
+		`SELECT id, name FROM services WHERE project_id = $1`,
+		service.ProjectID,
+	)
 	if err != nil {
 		return nil, err
 	}
+	defer svcRows.Close()
+	for svcRows.Next() {
+		var s struct{ ID, Name string }
+		if err := svcRows.Scan(&s.ID, &s.Name); err != nil {
+			return nil, err
+		}
+		refServices = append(refServices, s)
+	}
 
-	byName := map[string]uuid.UUID{}
+	byName := map[string]string{}
 	for _, s := range refServices {
 		byName[strings.ToLower(s.Name)] = s.ID
 	}
@@ -169,15 +189,17 @@ func resolveServiceEnv(db *database.DB, service Service) (map[string]string, err
 		case "HOST":
 			return serviceName, true
 		case "PORT":
-			if port, err := q.GetServicePort(context.Background(), id); err == nil && port > 0 {
+			var port int
-				return strconv.Itoa(int(port)), true
+			if err := db.QueryRow(`SELECT COALESCE(port, 0) FROM services WHERE id = $1`, id).Scan(&port); err == nil && port > 0 {
+				return strconv.Itoa(port), true
 			}
 			return "", false
 		}
-		value, err := q.GetServiceVariableValue(context.Background(), sqlcdb.GetServiceVariableValueParams{
+		var value string
-			ServiceID: id,
+		err := db.QueryRow(
-			Key:       key,
+			`SELECT value FROM environment_variables WHERE service_id = $1 AND key = $2`,
-		})
+			id, key,
+		).Scan(&value)
 		if err != nil {
 			return "", false
 		}
@@ -250,15 +272,6 @@ func parseMemoryLimit(mem string) int64 {
 	return 0
 }
 
-// setServiceStatusNow writes the stored status with a fresh updated_at.
-func setServiceStatusNow(db *database.DB, id uuid.UUID, status string) {
-	_ = sqlcdb.New(db.DB).SetServiceStatus(context.Background(), sqlcdb.SetServiceStatusParams{
-		Status:    sql.NullString{String: status, Valid: true},
-		UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
-		ID:        id,
-	})
-}
-
 func getRuntimeEngine(c *gin.Context) (*deployment.DeploymentEngine, *database.DB, bool) {
 	dbValue, exists := c.Get("db")
 	if !exists {
@@ -273,22 +286,6 @@ func getRuntimeEngine(c *gin.Context) (*deployment.DeploymentEngine, *database.D
 	return engineValue.(*deployment.DeploymentEngine), dbValue.(*database.DB), true
 }
 
-// serviceFromRuntimeRow maps the sqlc runtime row (with legacy-column
-// fallbacks applied in SQL) onto the API Service model.
-func serviceFromRuntimeRow(r sqlcdb.GetServiceRuntimeWithOwnerRow) Service {
-	return Service{
-		ID: r.ID, ProjectID: r.ProjectID, Name: r.Name, Type: r.Type,
-		Status: r.Status, Image: r.Image, Command: r.Command,
-		Environment: r.Environment, GitRepo: r.GitRepo, GitBranch: r.GitBranch,
-		BuildPath: r.BuildPath, CPU: r.Cpu, Memory: r.Memory,
-		Replicas: int(r.Replicas), Port: int(r.Port), Domain: r.Domain,
-		HealthCheckPath: r.HealthcheckPath, RestartPolicy: r.RestartPolicy,
-		Builder: r.Builder, CPUReserve: r.CpuReserve,
-		MemoryReserve: r.MemoryReserve, StaticBuildCmd: r.StaticBuildCmd,
-		StaticDir: r.StaticDir, CreatedAt: r.CreatedAt.Time, UpdatedAt: r.UpdatedAt.Time,
-	}
-}
-
 func loadOwnedService(c *gin.Context, db *database.DB) (Service, bool) {
 	serviceID, err := uuid.Parse(c.Param("id"))
 	if err != nil {
@@ -301,16 +298,43 @@ func loadOwnedService(c *gin.Context, db *database.DB) (Service, bool) {
 		return Service{}, false
 	}
 
-	row, err := sqlcdb.New(db.DB).GetServiceRuntimeWithOwner(context.Background(), serviceID)
+	var service Service
+	var owner string
+	err = db.QueryRow(
+		`SELECT s.id, s.project_id, s.name,
+		        COALESCE(s.type, s.service_type, ''), COALESCE(s.status, ''),
+		        COALESCE(s.image, s.image_name, ''), COALESCE(s.command, s.start_command, ''),
+		        COALESCE(s.environment, ''), COALESCE(s.git_repo, s.source_url, ''),
+		        COALESCE(s.git_branch, ''), COALESCE(s.build_path, ''),
+		        COALESCE(s.cpu, ''), COALESCE(s.memory, ''),
+		        COALESCE(s.replicas, 1), COALESCE(s.port, 0),
+		        COALESCE(s.domain, ''), COALESCE(s.healthcheck_path, ''),
+		        COALESCE(s.restart_policy, 'unless-stopped'),
+		        COALESCE(s.builder, 'auto'), COALESCE(s.cpu_reserve, ''),
+		        COALESCE(s.memory_reserve, ''), COALESCE(s.static_build_cmd, ''),
+		        COALESCE(s.static_dir, ''),
+		        s.created_at, s.updated_at, p.owner_id
+		 FROM services s JOIN projects p ON s.project_id = p.id
+		 WHERE s.id = $1`,
+		serviceID,
+	).Scan(
+		&service.ID, &service.ProjectID, &service.Name, &service.Type, &service.Status,
+		&service.Image, &service.Command, &service.Environment, &service.GitRepo,
+		&service.GitBranch, &service.BuildPath, &service.CPU, &service.Memory,
+		&service.Replicas, &service.Port, &service.Domain, &service.HealthCheckPath,
+		&service.RestartPolicy, &service.Builder, &service.CPUReserve,
+		&service.MemoryReserve, &service.StaticBuildCmd, &service.StaticDir,
+		&service.CreatedAt, &service.UpdatedAt, &owner,
+	)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Service not found"})
 		return Service{}, false
 	}
-	if row.OwnerID.String() != userID.(string) && !isAdminUser(db, userID.(string)) {
+	if owner != userID.(string) && !isAdminUser(db, userID.(string)) {
 		c.JSON(http.StatusForbidden, gin.H{"error": "Access denied"})
 		return Service{}, false
 	}
-	return serviceFromRuntimeRow(row), true
+	return service, true
 }
 
 // loadReadableService loads a service when the caller may read its project:
@@ -322,13 +346,39 @@ func loadReadableService(c *gin.Context, db *database.DB) (Service, bool) {
 		return Service{}, false
 	}
 
-	row, err := sqlcdb.New(db.DB).GetServiceRuntimeWithOwner(context.Background(), serviceID)
+	var service Service
+	var projectID uuid.UUID
+	err = db.QueryRow(
+		`SELECT s.id, s.project_id, s.name,
+		        COALESCE(s.type, s.service_type, ''), COALESCE(s.status, ''),
+		        COALESCE(s.image, s.image_name, ''), COALESCE(s.command, s.start_command, ''),
+		        COALESCE(s.environment, ''), COALESCE(s.git_repo, s.source_url, ''),
+		        COALESCE(s.git_branch, ''), COALESCE(s.build_path, ''),
+		        COALESCE(s.cpu, ''), COALESCE(s.memory, ''),
+		        COALESCE(s.replicas, 1), COALESCE(s.port, 0),
+		        COALESCE(s.domain, ''), COALESCE(s.healthcheck_path, ''),
+		        COALESCE(s.restart_policy, 'unless-stopped'),
+		        COALESCE(s.builder, 'auto'), COALESCE(s.cpu_reserve, ''),
+		        COALESCE(s.memory_reserve, ''), COALESCE(s.static_build_cmd, ''),
+		        COALESCE(s.static_dir, ''),
+		        s.created_at, s.updated_at, s.project_id
+		 FROM services s
+		 WHERE s.id = $1`,
+		serviceID,
+	).Scan(
+		&service.ID, &service.ProjectID, &service.Name, &service.Type, &service.Status,
+		&service.Image, &service.Command, &service.Environment, &service.GitRepo,
+		&service.GitBranch, &service.BuildPath, &service.CPU, &service.Memory,
+		&service.Replicas, &service.Port, &service.Domain, &service.HealthCheckPath,
+		&service.RestartPolicy, &service.Builder, &service.CPUReserve,
+		&service.MemoryReserve, &service.StaticBuildCmd, &service.StaticDir,
+		&service.CreatedAt, &service.UpdatedAt, &projectID,
+	)
 	if err != nil {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Service not found"})
 		return Service{}, false
 	}
-	service := serviceFromRuntimeRow(row)
+	if _, allowed := projectReadAccess(c, db, projectID); !allowed {
-	if _, allowed := projectReadAccess(c, db, service.ProjectID); !allowed {
 		c.JSON(http.StatusNotFound, gin.H{"error": "Service not found"})
 		return Service{}, false
 	}
@@ -379,7 +429,7 @@ func reconcileNow(c *gin.Context, engine *deployment.DeploymentEngine, db *datab
 		status = state.Status
 		persistPublishedPort(db, service.ID, state.Ports)
 	}
-	setServiceStatusNow(db, service.ID, status)
+	_, _ = db.Exec(`UPDATE services SET status = $1, updated_at = $2 WHERE id = $3`, status, time.Now(), service.ID)
 	c.JSON(http.StatusOK, gin.H{"runtime": state})
 	return true
 }
@@ -398,7 +448,7 @@ func handleServiceStart(c *gin.Context) {
 		c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
 		return
 	}
-	setServiceStatusNow(db, service.ID, "running")
+	_, _ = db.Exec(`UPDATE services SET status = 'running', updated_at = $1 WHERE id = $2`, time.Now(), service.ID)
 	c.JSON(http.StatusOK, gin.H{"status": "running"})
 }
 
@@ -416,7 +466,7 @@ func handleServiceStop(c *gin.Context) {
 		c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
 		return
 	}
-	setServiceStatusNow(db, service.ID, "stopped")
+	_, _ = db.Exec(`UPDATE services SET status = 'stopped', updated_at = $1 WHERE id = $2`, time.Now(), service.ID)
 	c.JSON(http.StatusOK, gin.H{"status": "stopped"})
 }
 
@@ -435,7 +485,7 @@ func handleServiceRestart(c *gin.Context) {
 		c.JSON(http.StatusBadGateway, gin.H{"error": err.Error()})
 		return
 	}
-	setServiceStatusNow(db, service.ID, "running")
+	_, _ = db.Exec(`UPDATE services SET status = 'running', updated_at = $1 WHERE id = $2`, time.Now(), service.ID)
 	c.JSON(http.StatusOK, gin.H{"status": "running"})
 }
 
@@ -455,8 +505,12 @@ func handleServiceRedeploy(c *gin.Context) {
 	image := service.Image
 	if image == "" {
 		// Git-sourced service: reuse the last successful deployment image.
-		var err error
+		err := db.QueryRow(
-		image, err = sqlcdb.New(db.DB).GetLastDeployedImage(context.Background(), service.ID)
+			`SELECT image_name || ':' || image_tag FROM deployments
+			 WHERE service_id = $1 AND status = 'deployed' AND image_name <> ''
+			 ORDER BY created_at DESC LIMIT 1`,
+			service.ID,
+		).Scan(&image)
 		if err != nil {
 			c.JSON(http.StatusBadRequest, gin.H{"error": "No deployable image yet — run a deployment first"})
 			return
@@ -502,7 +556,7 @@ func reconcileServiceJob(ctx context.Context, db *database.DB, engine *deploymen
 		if state.Status != "" {
 			status = state.Status
 		}
-		setServiceStatusNow(db, service.ID, status)
+		_, _ = db.Exec(`UPDATE services SET status = $1, updated_at = $2 WHERE id = $3`, status, time.Now(), service.ID)
 	}
 	return state, nil
 }
@@ -521,9 +575,12 @@ func enqueueServiceRedeploy(c *gin.Context, db *database.DB, service Service) bo
 	}
 	image := service.Image
 	if image == "" {
-		var err error
+		if err := db.QueryRow(
-		image, err = sqlcdb.New(db.DB).GetLastDeployedImage(context.Background(), service.ID)
+			`SELECT image_name || ':' || image_tag FROM deployments
-		if err != nil {
+			 WHERE service_id = $1 AND status = 'deployed' AND image_name <> ''
+			 ORDER BY created_at DESC LIMIT 1`,
+			service.ID,
+		).Scan(&image); err != nil {
 			return false
 		}
 	}
@@ -571,10 +628,10 @@ func persistPublishedPort(db *database.DB, serviceID uuid.UUID, ports []uint16)
 	if len(ports) == 0 {
 		return
 	}
-	_ = sqlcdb.New(db.DB).SetServicePublishedPort(context.Background(), sqlcdb.SetServicePublishedPortParams{
+	_, _ = db.Exec(
-		PublishedPort: int32(ports[0]),
+		`UPDATE services SET published_port = $1 WHERE id = $2 AND published_port <> $1`,
-		ID:            serviceID,
+		int(ports[0]), serviceID,
-	})
+	)
 }
 
 // liveServiceStatus reconciles the stored status with real container state.
@@ -597,7 +654,7 @@ func liveServiceStatus(c *gin.Context, db *database.DB, service *Service) {
 	}
 	if state.Status != service.Status {
 		service.Status = state.Status
-		setServiceStatusNow(db, service.ID, state.Status)
+		_, _ = db.Exec(`UPDATE services SET status = $1, updated_at = $2 WHERE id = $3`, state.Status, time.Now(), service.ID)
 	}
 	persistPublishedPort(db, service.ID, state.Ports)
 	if service.Domain != "" {
@@ -619,22 +676,44 @@ func runtimeScaleService(c *gin.Context, serviceID string, replicas int) error {
 		return fmt.Errorf("runtime unavailable")
 	}
 
-	q := sqlcdb.New(db.DB)
+	var service Service
-	sid, err := uuid.Parse(serviceID)
+	var owner string
+	err := db.QueryRow(
+		`SELECT s.id, s.project_id, s.name,
+		        COALESCE(s.type, s.service_type, ''), COALESCE(s.status, ''),
+		        COALESCE(s.image, s.image_name, ''), COALESCE(s.command, s.start_command, ''),
+		        COALESCE(s.environment, ''), COALESCE(s.git_repo, s.source_url, ''),
+		        COALESCE(s.git_branch, ''), COALESCE(s.build_path, ''),
+		        COALESCE(s.cpu, ''), COALESCE(s.memory, ''),
+		        COALESCE(s.replicas, 1), COALESCE(s.port, 0),
+		        COALESCE(s.domain, ''), COALESCE(s.healthcheck_path, ''),
+		        COALESCE(s.restart_policy, 'unless-stopped'),
+		        COALESCE(s.builder, 'auto'), COALESCE(s.cpu_reserve, ''),
+		        COALESCE(s.memory_reserve, ''), COALESCE(s.static_build_cmd, ''),
+		        COALESCE(s.static_dir, ''),
+		        s.created_at, s.updated_at, p.owner_id
+		 FROM services s JOIN projects p ON s.project_id = p.id
+		 WHERE s.id = $1`, serviceID,
+	).Scan(
+		&service.ID, &service.ProjectID, &service.Name, &service.Type, &service.Status,
+		&service.Image, &service.Command, &service.Environment, &service.GitRepo,
+		&service.GitBranch, &service.BuildPath, &service.CPU, &service.Memory,
+		&service.Replicas, &service.Port, &service.Domain, &service.HealthCheckPath,
+		&service.RestartPolicy, &service.Builder, &service.CPUReserve,
+		&service.MemoryReserve, &service.StaticBuildCmd, &service.StaticDir,
+		&service.CreatedAt, &service.UpdatedAt, &owner,
+	)
 	if err != nil {
 		return err
 	}
-	row, err := q.GetServiceRuntimeWithOwner(context.Background(), sid)
-	if err != nil {
-		return err
-	}
-	service := serviceFromRuntimeRow(row)
 	if service.Image == "" {
-		image, err := q.GetLastDeployedImage(context.Background(), service.ID)
+		if err := db.QueryRow(
-		if err != nil {
+			`SELECT image_name || ':' || image_tag FROM deployments
+			 WHERE service_id = $1 AND status = 'deployed' AND image_name <> ''
+			 ORDER BY created_at DESC LIMIT 1`, service.ID,
+		).Scan(&service.Image); err != nil {
 			return fmt.Errorf("no deployed image to scale")
 		}
-		service.Image = image
 	}
 
 	spec, err := serviceRuntimeSpec(db, service)
@@ -652,11 +731,7 @@ func runtimeScaleService(c *gin.Context, serviceID string, replicas int) error {
 	if state != nil {
 		persistPublishedPort(db, service.ID, state.Ports)
 	}
-	_ = q.SetServiceReplicas(context.Background(), sqlcdb.SetServiceReplicasParams{
+	_, _ = db.Exec(`UPDATE services SET replicas = $1, updated_at = $2 WHERE id = $3`, replicas, time.Now(), service.ID)
-		Replicas:  int32(replicas),
-		UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
-		ID:        service.ID,
-	})
 	return nil
 }
 
@@ -675,34 +750,47 @@ func handleServiceEnvCheck(c *gin.Context) {
 		return
 	}
 
-	q := sqlcdb.New(db.DB)
+	rows, err := db.Query(
-	vars, err := q.ListServiceVariablesWithSecret(context.Background(), service.ID)
+		`SELECT key, value, COALESCE(is_secret, false) FROM environment_variables WHERE service_id = $1`,
+		service.ID,
+	)
 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return
 	}
+	defer rows.Close()
 
 	var unresolved, empty, unreadable []string
 	var raw []struct{ key, val string }
-	for _, v := range vars {
+	for rows.Next() {
-		decrypted := secrets.Decrypt(v.Value)
+		var k, v string
-		if v.IsSecret && secrets.IsEncrypted(v.Value) && decrypted == v.Value {
+		var secret bool
+		if err := rows.Scan(&k, &v, &secret); err != nil {
+			continue
+		}
+		decrypted := secrets.Decrypt(v)
+		if secret && secrets.IsEncrypted(v) && decrypted == v {
 			// Ciphertext failed to decrypt — Decrypt returns the input.
-			unreadable = append(unreadable, v.Key)
+			unreadable = append(unreadable, k)
 			continue
 		}
 		if strings.TrimSpace(decrypted) == "" {
-			empty = append(empty, v.Key)
+			empty = append(empty, k)
 		}
-		raw = append(raw, struct{ key, val string }{v.Key, decrypted})
+		raw = append(raw, struct{ key, val string }{k, decrypted})
 	}
 
 	// Project siblings for ${{name.KEY}} resolution.
-	siblingIDs := map[string]uuid.UUID{}
+	siblingIDs := map[string]string{}
-	if refs, err := q.ListProjectServiceRefs(context.Background(), service.ProjectID); err == nil {
+	svcRows, err := db.Query(`SELECT id, name FROM services WHERE project_id = $1`, service.ProjectID)
-		for _, s := range refs {
+	if err == nil {
-			siblingIDs[strings.ToLower(s.Name)] = s.ID
+		for svcRows.Next() {
+			var id, name string
+			if err := svcRows.Scan(&id, &name); err == nil {
+				siblingIDs[strings.ToLower(name)] = id
+			}
 		}
+		svcRows.Close()
 	}
 
 	resolvable := func(serviceName, key string) bool {
@@ -714,14 +802,20 @@ func handleServiceEnvCheck(c *gin.Context) {
 			return true
 		}
 		if strings.EqualFold(key, "PORT") {
-			port, err := q.GetServicePort(context.Background(), id)
+			var port int
-			return err == nil && port > 0
+			if err := db.QueryRow(`SELECT COALESCE(port, 0) FROM services WHERE id = $1`, id).Scan(&port); err == nil {
+				return port > 0
+			}
+			return false
 		}
-		_, err := q.GetServiceVariableValue(context.Background(), sqlcdb.GetServiceVariableValueParams{
+		var n int
-			ServiceID: id,
+		if err := db.QueryRow(
-			Key:       key,
+			`SELECT COUNT(*) FROM environment_variables WHERE service_id = $1 AND key = $2`,
-		})
+			id, key,
-		return err == nil
+		).Scan(&n); err == nil {
+			return n > 0
+		}
+		return false
 	}
 
 	for _, kv := range raw {

app/backend/internal/api/sleeper.go

@@ -86,17 +86,20 @@ type sleepCandidate struct {
 }
 
 func sweepSleeping(ctx context.Context, db *database.DB, dc *docker.Client, engine *deployment.DeploymentEngine, apiPort int) {
-	sweepRows, err := sqlcdb.New(db.DB).ListSleepCandidates(ctx)
+	rows, err := db.QueryContext(ctx,
+		`SELECT id, project_id, name, COALESCE(status,''), COALESCE(sleep_idle_minutes,15)
+		 FROM services WHERE sleep_enabled AND COALESCE(status,'') IN ('running','deployed','degraded','starting')`)
 	if err != nil {
 		return
 	}
 	var candidates []sleepCandidate
-	for _, r := range sweepRows {
+	for rows.Next() {
-		candidates = append(candidates, sleepCandidate{
+		var s sleepCandidate
-			ID: r.ID, ProjectID: r.ProjectID, Name: r.Name,
+		if err := rows.Scan(&s.ID, &s.ProjectID, &s.Name, &s.Status, &s.IdleMinutes); err == nil {
-			Status: r.Status, IdleMinutes: int(r.SleepIdleMinutes),
+			candidates = append(candidates, s)
-		})
+		}
 	}
+	rows.Close()
 
 	q := sqlcdb.New(db.DB)
 	for _, svc := range candidates {
@@ -184,10 +187,11 @@ func putToSleepRemote(ctx context.Context, db *database.DB, q *sqlcdb.Queries, s
 	tracker.mu.Lock()
 	delete(tracker.activity, svc.ID)
 	tracker.mu.Unlock()
-	setServiceStatusNow(db, svc.ID, "sleeping")
+	_, _ = db.Exec(`UPDATE services SET status = 'sleeping', updated_at = $1 WHERE id = $2`, time.Now(), svc.ID)
 	log.Printf("sleep: %s (%s) remote replicas removed after idle timeout", svc.Name, svc.ID)
 
-	domain, _ := q.GetServiceDomainText(ctx, svc.ID)
+	var domain string
+	_ = db.QueryRow(`SELECT COALESCE(domain,'') FROM services WHERE id = $1`, svc.ID).Scan(&domain)
 	domains := serviceDomainNames(db, svc.ID, domain)
 	if len(domains) > 0 {
 		writeWakeIngress(svc.ID.String(), domains, apiPort)
@@ -246,10 +250,11 @@ func putToSleep(ctx context.Context, db *database.DB, dc *docker.Client, engine
 	tracker.mu.Lock()
 	delete(tracker.activity, svc.ID)
 	tracker.mu.Unlock()
-	setServiceStatusNow(db, svc.ID, "sleeping")
+	_, _ = db.Exec(`UPDATE services SET status = 'sleeping', updated_at = $1 WHERE id = $2`, time.Now(), svc.ID)
 	log.Printf("sleep: %s (%s) scaled to zero after idle timeout", svc.Name, svc.ID)
 
-	domain, _ := sqlcdb.New(db.DB).GetServiceDomainText(ctx, svc.ID)
+	var domain string
+	_ = db.QueryRow(`SELECT COALESCE(domain,'') FROM services WHERE id = $1`, svc.ID).Scan(&domain)
 	domains := serviceDomainNames(db, svc.ID, domain)
 	if len(domains) == 0 {
 		return
@@ -439,9 +444,7 @@ func pruneWakeContainers(ctx context.Context, db *database.DB, dc *docker.Client
 			}
 		}
 		var status string
-		if sid, err := uuid.Parse(svcID); err == nil {
+		_ = db.QueryRow(`SELECT COALESCE(status,'') FROM services WHERE id = $1`, svcID).Scan(&status)
-			status, _ = sqlcdb.New(db.DB).GetServiceStatusText(ctx, sid)
-		}
 		if live > 0 || status == "stopped" || status == "" {
 			_ = dc.RemoveContainer(ctx, c.ID, true)
 		}
@@ -488,11 +491,34 @@ func triggerServiceWake(c *gin.Context) (int, gin.H) {
 	if err != nil {
 		return http.StatusBadRequest, gin.H{"error": "invalid service id"}
 	}
-	row, err := sqlcdb.New(db.DB).GetServiceRuntimeWithOwner(context.Background(), id)
+	var service Service
+	err = db.QueryRow(
+		`SELECT s.id, s.project_id, s.name,
+		        COALESCE(s.type, s.service_type, ''), COALESCE(s.status, ''),
+		        COALESCE(s.image, s.image_name, ''), COALESCE(s.command, s.start_command, ''),
+		        COALESCE(s.environment, ''), COALESCE(s.git_repo, s.source_url, ''),
+		        COALESCE(s.git_branch, ''), COALESCE(s.build_path, ''),
+		        COALESCE(s.cpu, ''), COALESCE(s.memory, ''),
+		        COALESCE(s.replicas, 1), COALESCE(s.port, 0),
+		        COALESCE(s.domain, ''), COALESCE(s.healthcheck_path, ''),
+		        COALESCE(s.restart_policy, 'unless-stopped'),
+		        COALESCE(s.builder, 'auto'), COALESCE(s.cpu_reserve, ''),
+		        COALESCE(s.memory_reserve, ''), COALESCE(s.static_build_cmd, ''),
+		        COALESCE(s.static_dir, ''),
+		        s.created_at, s.updated_at
+		 FROM services s WHERE s.id = $1`, id,
+	).Scan(
+		&service.ID, &service.ProjectID, &service.Name, &service.Type, &service.Status,
+		&service.Image, &service.Command, &service.Environment, &service.GitRepo,
+		&service.GitBranch, &service.BuildPath, &service.CPU, &service.Memory,
+		&service.Replicas, &service.Port, &service.Domain, &service.HealthCheckPath,
+		&service.RestartPolicy, &service.Builder, &service.CPUReserve,
+		&service.MemoryReserve, &service.StaticBuildCmd, &service.StaticDir,
+		&service.CreatedAt, &service.UpdatedAt,
+	)
 	if err != nil {
 		return http.StatusNotFound, gin.H{"error": "service not found"}
 	}
-	service := serviceFromRuntimeRow(row)
 	if service.Status == "running" || service.Status == "deployed" {
 		return http.StatusOK, gin.H{"status": service.Status}
 	}
@@ -502,13 +528,13 @@ func triggerServiceWake(c *gin.Context) (int, gin.H) {
 		spec, err := serviceRuntimeSpec(db, service)
 		if err != nil {
 			log.Printf("wake: runtime spec for %s failed: %v", service.ID, err)
-			setServiceStatusNow(db, service.ID, "failed")
+			_, _ = db.Exec(`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`, time.Now(), service.ID)
 			return
 		}
 		state, err := engine.ReconcileService(ctx, spec)
 		if err != nil {
 			log.Printf("wake: reconcile for %s failed: %v", service.ID, err)
-			setServiceStatusNow(db, service.ID, "failed")
+			_, _ = db.Exec(`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`, time.Now(), service.ID)
 			return
 		}
 		status := "running"
@@ -516,7 +542,7 @@ func triggerServiceWake(c *gin.Context) (int, gin.H) {
 			status = state.Status
 			persistPublishedPort(db, service.ID, state.Ports)
 		}
-		setServiceStatusNow(db, service.ID, status)
+		_, _ = db.Exec(`UPDATE services SET status = $1, updated_at = $2 WHERE id = $3`, status, time.Now(), service.ID)
 	}()
 	return http.StatusAccepted, gin.H{"status": "waking"}
 }
@@ -537,6 +563,8 @@ func handleServiceSleep(c *gin.Context) {
 	if !ok {
 		return
 	}
+	var port int
+	_ = db.QueryRow(`SELECT COALESCE(port,0) FROM services WHERE id = $1`, service.ID).Scan(&port)
 	svc := sleepCandidate{
 		ID:        service.ID,
 		ProjectID: service.ProjectID,

app/backend/internal/database/sqlcdb/cron.sql.go

@@ -1,332 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.31.1
-// source: cron.sql
-
-package sqlcdb
-
-import (
-	"context"
-	"database/sql"
-	"time"
-
-	"github.com/google/uuid"
-)
-
-const deleteCronJob = `-- name: DeleteCronJob :exec
-DELETE FROM cron_jobs WHERE id = $1
-`
-
-func (q *Queries) DeleteCronJob(ctx context.Context, id uuid.UUID) error {
-	_, err := q.db.ExecContext(ctx, deleteCronJob, id)
-	return err
-}
-
-const finishCronExecution = `-- name: FinishCronExecution :exec
-UPDATE cron_executions SET finished_at = $1, status = $2, output = $3, error = $4 WHERE id = $5
-`
-
-type FinishCronExecutionParams struct {
-	FinishedAt sql.NullTime   `json:"finished_at"`
-	Status     sql.NullString `json:"status"`
-	Output     sql.NullString `json:"output"`
-	Error      sql.NullString `json:"error"`
-	ID         uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) FinishCronExecution(ctx context.Context, arg FinishCronExecutionParams) error {
-	_, err := q.db.ExecContext(ctx, finishCronExecution,
-		arg.FinishedAt,
-		arg.Status,
-		arg.Output,
-		arg.Error,
-		arg.ID,
-	)
-	return err
-}
-
-const getCronJob = `-- name: GetCronJob :one
-SELECT id, project_id, service_id, name, schedule, command, timezone,
-       enabled, last_run_at, next_run_at, last_status, last_output,
-       retention, created_at, updated_at
-FROM cron_jobs WHERE id = $1
-`
-
-func (q *Queries) GetCronJob(ctx context.Context, id uuid.UUID) (CronJob, error) {
-	row := q.db.QueryRowContext(ctx, getCronJob, id)
-	var i CronJob
-	err := row.Scan(
-		&i.ID,
-		&i.ProjectID,
-		&i.ServiceID,
-		&i.Name,
-		&i.Schedule,
-		&i.Command,
-		&i.Timezone,
-		&i.Enabled,
-		&i.LastRunAt,
-		&i.NextRunAt,
-		&i.LastStatus,
-		&i.LastOutput,
-		&i.Retention,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getCronJobForTrigger = `-- name: GetCronJobForTrigger :one
-SELECT cj.service_id, cj.command, cj.schedule, cj.timezone, cj.retention, p.owner_id
-FROM cron_jobs cj
-JOIN projects p ON cj.project_id = p.id
-WHERE cj.id = $1
-`
-
-type GetCronJobForTriggerRow struct {
-	ServiceID uuid.UUID      `json:"service_id"`
-	Command   string         `json:"command"`
-	Schedule  string         `json:"schedule"`
-	Timezone  sql.NullString `json:"timezone"`
-	Retention sql.NullInt32  `json:"retention"`
-	OwnerID   uuid.UUID      `json:"owner_id"`
-}
-
-func (q *Queries) GetCronJobForTrigger(ctx context.Context, id uuid.UUID) (GetCronJobForTriggerRow, error) {
-	row := q.db.QueryRowContext(ctx, getCronJobForTrigger, id)
-	var i GetCronJobForTriggerRow
-	err := row.Scan(
-		&i.ServiceID,
-		&i.Command,
-		&i.Schedule,
-		&i.Timezone,
-		&i.Retention,
-		&i.OwnerID,
-	)
-	return i, err
-}
-
-const getCronJobOwner = `-- name: GetCronJobOwner :one
-SELECT p.owner_id FROM cron_jobs cj
-JOIN projects p ON cj.project_id = p.id
-WHERE cj.id = $1
-`
-
-func (q *Queries) GetCronJobOwner(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
-	row := q.db.QueryRowContext(ctx, getCronJobOwner, id)
-	var owner_id uuid.UUID
-	err := row.Scan(&owner_id)
-	return owner_id, err
-}
-
-const getCronJobProjectID = `-- name: GetCronJobProjectID :one
-SELECT project_id FROM cron_jobs WHERE id = $1
-`
-
-func (q *Queries) GetCronJobProjectID(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
-	row := q.db.QueryRowContext(ctx, getCronJobProjectID, id)
-	var project_id uuid.UUID
-	err := row.Scan(&project_id)
-	return project_id, err
-}
-
-const getCronOwnerViaService = `-- name: GetCronOwnerViaService :one
-SELECT p.owner_id FROM projects p
-JOIN services s ON s.project_id = p.id
-WHERE s.id = $1
-`
-
-func (q *Queries) GetCronOwnerViaService(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
-	row := q.db.QueryRowContext(ctx, getCronOwnerViaService, id)
-	var owner_id uuid.UUID
-	err := row.Scan(&owner_id)
-	return owner_id, err
-}
-
-const insertCronExecution = `-- name: InsertCronExecution :exec
-INSERT INTO cron_executions (id, cron_job_id, started_at, status)
-VALUES ($1, $2, $3, $4)
-`
-
-type InsertCronExecutionParams struct {
-	ID        uuid.UUID      `json:"id"`
-	CronJobID uuid.UUID      `json:"cron_job_id"`
-	StartedAt time.Time      `json:"started_at"`
-	Status    sql.NullString `json:"status"`
-}
-
-func (q *Queries) InsertCronExecution(ctx context.Context, arg InsertCronExecutionParams) error {
-	_, err := q.db.ExecContext(ctx, insertCronExecution,
-		arg.ID,
-		arg.CronJobID,
-		arg.StartedAt,
-		arg.Status,
-	)
-	return err
-}
-
-const insertCronJob = `-- name: InsertCronJob :exec
-INSERT INTO cron_jobs (id, project_id, service_id, name, schedule, command, timezone, enabled, next_run_at, retention, created_at, updated_at)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
-`
-
-type InsertCronJobParams struct {
-	ID        uuid.UUID      `json:"id"`
-	ProjectID uuid.UUID      `json:"project_id"`
-	ServiceID uuid.UUID      `json:"service_id"`
-	Name      string         `json:"name"`
-	Schedule  string         `json:"schedule"`
-	Command   string         `json:"command"`
-	Timezone  sql.NullString `json:"timezone"`
-	Enabled   sql.NullBool   `json:"enabled"`
-	NextRunAt sql.NullTime   `json:"next_run_at"`
-	Retention sql.NullInt32  `json:"retention"`
-	CreatedAt sql.NullTime   `json:"created_at"`
-	UpdatedAt sql.NullTime   `json:"updated_at"`
-}
-
-func (q *Queries) InsertCronJob(ctx context.Context, arg InsertCronJobParams) error {
-	_, err := q.db.ExecContext(ctx, insertCronJob,
-		arg.ID,
-		arg.ProjectID,
-		arg.ServiceID,
-		arg.Name,
-		arg.Schedule,
-		arg.Command,
-		arg.Timezone,
-		arg.Enabled,
-		arg.NextRunAt,
-		arg.Retention,
-		arg.CreatedAt,
-		arg.UpdatedAt,
-	)
-	return err
-}
-
-const listCronExecutions = `-- name: ListCronExecutions :many
-SELECT id, cron_job_id, started_at, finished_at, status, output, error
-FROM cron_executions
-WHERE cron_job_id = $1
-ORDER BY started_at DESC
-LIMIT 100
-`
-
-func (q *Queries) ListCronExecutions(ctx context.Context, cronJobID uuid.UUID) ([]CronExecution, error) {
-	rows, err := q.db.QueryContext(ctx, listCronExecutions, cronJobID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []CronExecution{}
-	for rows.Next() {
-		var i CronExecution
-		if err := rows.Scan(
-			&i.ID,
-			&i.CronJobID,
-			&i.StartedAt,
-			&i.FinishedAt,
-			&i.Status,
-			&i.Output,
-			&i.Error,
-		); 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 listDueCronJobs = `-- name: ListDueCronJobs :many
-SELECT id, project_id, service_id, name, schedule, command, timezone, enabled, retention
-FROM cron_jobs
-WHERE enabled = TRUE AND next_run_at IS NOT NULL AND next_run_at <= NOW()
-`
-
-type ListDueCronJobsRow struct {
-	ID        uuid.UUID      `json:"id"`
-	ProjectID uuid.UUID      `json:"project_id"`
-	ServiceID uuid.UUID      `json:"service_id"`
-	Name      string         `json:"name"`
-	Schedule  string         `json:"schedule"`
-	Command   string         `json:"command"`
-	Timezone  sql.NullString `json:"timezone"`
-	Enabled   sql.NullBool   `json:"enabled"`
-	Retention sql.NullInt32  `json:"retention"`
-}
-
-func (q *Queries) ListDueCronJobs(ctx context.Context) ([]ListDueCronJobsRow, error) {
-	rows, err := q.db.QueryContext(ctx, listDueCronJobs)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListDueCronJobsRow{}
-	for rows.Next() {
-		var i ListDueCronJobsRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ProjectID,
-			&i.ServiceID,
-			&i.Name,
-			&i.Schedule,
-			&i.Command,
-			&i.Timezone,
-			&i.Enabled,
-			&i.Retention,
-		); 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 trimCronExecutions = `-- name: TrimCronExecutions :exec
-DELETE FROM cron_executions WHERE cron_executions.cron_job_id = $1 AND cron_executions.id NOT IN (
-    SELECT ce.id FROM cron_executions ce WHERE ce.cron_job_id = $1
-    ORDER BY ce.started_at DESC LIMIT $2)
-`
-
-type TrimCronExecutionsParams struct {
-	CronJobID uuid.UUID `json:"cron_job_id"`
-	Limit     int32     `json:"limit"`
-}
-
-func (q *Queries) TrimCronExecutions(ctx context.Context, arg TrimCronExecutionsParams) error {
-	_, err := q.db.ExecContext(ctx, trimCronExecutions, arg.CronJobID, arg.Limit)
-	return err
-}
-
-const updateCronJobRun = `-- name: UpdateCronJobRun :exec
-UPDATE cron_jobs SET last_run_at = $1, last_status = $2, last_output = $3, next_run_at = $4 WHERE id = $5
-`
-
-type UpdateCronJobRunParams struct {
-	LastRunAt  sql.NullTime   `json:"last_run_at"`
-	LastStatus sql.NullString `json:"last_status"`
-	LastOutput sql.NullString `json:"last_output"`
-	NextRunAt  sql.NullTime   `json:"next_run_at"`
-	ID         uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) UpdateCronJobRun(ctx context.Context, arg UpdateCronJobRunParams) error {
-	_, err := q.db.ExecContext(ctx, updateCronJobRun,
-		arg.LastRunAt,
-		arg.LastStatus,
-		arg.LastOutput,
-		arg.NextRunAt,
-		arg.ID,
-	)
-	return err
-}

app/backend/internal/database/sqlcdb/deployments.sql.go

@@ -1,536 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.31.1
-// source: deployments.sql
-
-package sqlcdb
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/google/uuid"
-)
-
-const completeDeployment = `-- name: CompleteDeployment :exec
-UPDATE deployments
-SET status = $1, error = $2, completed_at = $3, updated_at = $3
-WHERE id = $4
-`
-
-type CompleteDeploymentParams struct {
-	Status      sql.NullString `json:"status"`
-	Error       sql.NullString `json:"error"`
-	CompletedAt sql.NullTime   `json:"completed_at"`
-	ID          uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) CompleteDeployment(ctx context.Context, arg CompleteDeploymentParams) error {
-	_, err := q.db.ExecContext(ctx, completeDeployment,
-		arg.Status,
-		arg.Error,
-		arg.CompletedAt,
-		arg.ID,
-	)
-	return err
-}
-
-const countAccessibleDeployments = `-- name: CountAccessibleDeployments :one
-SELECT COUNT(*)
-FROM deployments d
-JOIN services s ON s.id = d.service_id
-JOIN projects p ON p.id = s.project_id
-WHERE p.is_approved OR p.owner_id = $1 OR $2::bool
-   OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $1)
-`
-
-type CountAccessibleDeploymentsParams struct {
-	OwnerID uuid.UUID `json:"owner_id"`
-	Column2 bool      `json:"column_2"`
-}
-
-func (q *Queries) CountAccessibleDeployments(ctx context.Context, arg CountAccessibleDeploymentsParams) (int64, error) {
-	row := q.db.QueryRowContext(ctx, countAccessibleDeployments, arg.OwnerID, arg.Column2)
-	var count int64
-	err := row.Scan(&count)
-	return count, err
-}
-
-const countDeploymentsForService = `-- name: CountDeploymentsForService :one
-SELECT COUNT(*) FROM deployments WHERE service_id = $1
-`
-
-func (q *Queries) CountDeploymentsForService(ctx context.Context, serviceID uuid.UUID) (int64, error) {
-	row := q.db.QueryRowContext(ctx, countDeploymentsForService, serviceID)
-	var count int64
-	err := row.Scan(&count)
-	return count, err
-}
-
-const failDeployment = `-- name: FailDeployment :exec
-UPDATE deployments
-SET status = 'failed', error = $1, completed_at = $2, updated_at = $2
-WHERE id = $3
-`
-
-type FailDeploymentParams struct {
-	Error       sql.NullString `json:"error"`
-	CompletedAt sql.NullTime   `json:"completed_at"`
-	ID          uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) FailDeployment(ctx context.Context, arg FailDeploymentParams) error {
-	_, err := q.db.ExecContext(ctx, failDeployment, arg.Error, arg.CompletedAt, arg.ID)
-	return err
-}
-
-const getDeploymentAccess = `-- name: GetDeploymentAccess :one
-SELECT d.status, d.service_id, p.owner_id
-FROM deployments d
-JOIN services s ON d.service_id = s.id
-JOIN projects p ON s.project_id = p.id
-WHERE d.id = $1
-`
-
-type GetDeploymentAccessRow struct {
-	Status    sql.NullString `json:"status"`
-	ServiceID uuid.UUID      `json:"service_id"`
-	OwnerID   uuid.UUID      `json:"owner_id"`
-}
-
-func (q *Queries) GetDeploymentAccess(ctx context.Context, id uuid.UUID) (GetDeploymentAccessRow, error) {
-	row := q.db.QueryRowContext(ctx, getDeploymentAccess, id)
-	var i GetDeploymentAccessRow
-	err := row.Scan(&i.Status, &i.ServiceID, &i.OwnerID)
-	return i, err
-}
-
-const getDeploymentForRollback = `-- name: GetDeploymentForRollback :one
-SELECT d.id, d.service_id, d.commit_hash, d.status, d.image_name, d.image_tag,
-       d.build_log, d.runtime_log, d.error, d.started_at, d.completed_at,
-       d.created_at, d.updated_at, p.owner_id
-FROM deployments d
-JOIN services s ON d.service_id = s.id
-JOIN projects p ON s.project_id = p.id
-WHERE d.id = $1
-`
-
-type GetDeploymentForRollbackRow struct {
-	ID          uuid.UUID      `json:"id"`
-	ServiceID   uuid.UUID      `json:"service_id"`
-	CommitHash  sql.NullString `json:"commit_hash"`
-	Status      sql.NullString `json:"status"`
-	ImageName   sql.NullString `json:"image_name"`
-	ImageTag    sql.NullString `json:"image_tag"`
-	BuildLog    sql.NullString `json:"build_log"`
-	RuntimeLog  sql.NullString `json:"runtime_log"`
-	Error       sql.NullString `json:"error"`
-	StartedAt   sql.NullTime   `json:"started_at"`
-	CompletedAt sql.NullTime   `json:"completed_at"`
-	CreatedAt   sql.NullTime   `json:"created_at"`
-	UpdatedAt   sql.NullTime   `json:"updated_at"`
-	OwnerID     uuid.UUID      `json:"owner_id"`
-}
-
-func (q *Queries) GetDeploymentForRollback(ctx context.Context, id uuid.UUID) (GetDeploymentForRollbackRow, error) {
-	row := q.db.QueryRowContext(ctx, getDeploymentForRollback, id)
-	var i GetDeploymentForRollbackRow
-	err := row.Scan(
-		&i.ID,
-		&i.ServiceID,
-		&i.CommitHash,
-		&i.Status,
-		&i.ImageName,
-		&i.ImageTag,
-		&i.BuildLog,
-		&i.RuntimeLog,
-		&i.Error,
-		&i.StartedAt,
-		&i.CompletedAt,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-		&i.OwnerID,
-	)
-	return i, err
-}
-
-const getDeploymentWithProject = `-- name: GetDeploymentWithProject :one
-SELECT d.id, d.service_id, d.commit_hash, d.status, d.image_name, d.image_tag,
-       d.build_log, d.runtime_log, d.error, d.started_at, d.completed_at,
-       d.created_at, d.updated_at, p.id AS project_id
-FROM deployments d
-JOIN services s ON d.service_id = s.id
-JOIN projects p ON s.project_id = p.id
-WHERE d.id = $1
-`
-
-type GetDeploymentWithProjectRow struct {
-	ID          uuid.UUID      `json:"id"`
-	ServiceID   uuid.UUID      `json:"service_id"`
-	CommitHash  sql.NullString `json:"commit_hash"`
-	Status      sql.NullString `json:"status"`
-	ImageName   sql.NullString `json:"image_name"`
-	ImageTag    sql.NullString `json:"image_tag"`
-	BuildLog    sql.NullString `json:"build_log"`
-	RuntimeLog  sql.NullString `json:"runtime_log"`
-	Error       sql.NullString `json:"error"`
-	StartedAt   sql.NullTime   `json:"started_at"`
-	CompletedAt sql.NullTime   `json:"completed_at"`
-	CreatedAt   sql.NullTime   `json:"created_at"`
-	UpdatedAt   sql.NullTime   `json:"updated_at"`
-	ProjectID   uuid.UUID      `json:"project_id"`
-}
-
-func (q *Queries) GetDeploymentWithProject(ctx context.Context, id uuid.UUID) (GetDeploymentWithProjectRow, error) {
-	row := q.db.QueryRowContext(ctx, getDeploymentWithProject, id)
-	var i GetDeploymentWithProjectRow
-	err := row.Scan(
-		&i.ID,
-		&i.ServiceID,
-		&i.CommitHash,
-		&i.Status,
-		&i.ImageName,
-		&i.ImageTag,
-		&i.BuildLog,
-		&i.RuntimeLog,
-		&i.Error,
-		&i.StartedAt,
-		&i.CompletedAt,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-		&i.ProjectID,
-	)
-	return i, err
-}
-
-const getServiceForDeployWithOwner = `-- name: GetServiceForDeployWithOwner :one
-SELECT s.id, s.project_id, s.name, s.type, s.status, s.image, s.command,
-       s.environment, s.git_repo, s.git_branch, s.build_path, s.cpu, s.memory,
-       COALESCE(s.replicas, 1) AS replicas, COALESCE(s.port, 0) AS port,
-       COALESCE(s.domain, '') AS domain, COALESCE(s.healthcheck_path, '') AS healthcheck_path,
-       COALESCE(s.restart_policy, 'unless-stopped') AS restart_policy,
-       COALESCE(s.builder, 'auto') AS builder, COALESCE(s.cpu_reserve, '') AS cpu_reserve,
-       COALESCE(s.memory_reserve, '') AS memory_reserve, COALESCE(s.static_build_cmd, '') AS static_build_cmd,
-       COALESCE(s.static_dir, '') AS static_dir,
-       s.created_at, s.updated_at, p.owner_id
-FROM services s
-JOIN projects p ON s.project_id = p.id
-WHERE s.id = $1
-`
-
-type GetServiceForDeployWithOwnerRow struct {
-	ID              uuid.UUID      `json:"id"`
-	ProjectID       uuid.UUID      `json:"project_id"`
-	Name            string         `json:"name"`
-	Type            sql.NullString `json:"type"`
-	Status          sql.NullString `json:"status"`
-	Image           sql.NullString `json:"image"`
-	Command         sql.NullString `json:"command"`
-	Environment     sql.NullString `json:"environment"`
-	GitRepo         sql.NullString `json:"git_repo"`
-	GitBranch       sql.NullString `json:"git_branch"`
-	BuildPath       sql.NullString `json:"build_path"`
-	Cpu             sql.NullString `json:"cpu"`
-	Memory          sql.NullString `json:"memory"`
-	Replicas        int32          `json:"replicas"`
-	Port            int32          `json:"port"`
-	Domain          string         `json:"domain"`
-	HealthcheckPath string         `json:"healthcheck_path"`
-	RestartPolicy   string         `json:"restart_policy"`
-	Builder         string         `json:"builder"`
-	CpuReserve      string         `json:"cpu_reserve"`
-	MemoryReserve   string         `json:"memory_reserve"`
-	StaticBuildCmd  string         `json:"static_build_cmd"`
-	StaticDir       string         `json:"static_dir"`
-	CreatedAt       sql.NullTime   `json:"created_at"`
-	UpdatedAt       sql.NullTime   `json:"updated_at"`
-	OwnerID         uuid.UUID      `json:"owner_id"`
-}
-
-func (q *Queries) GetServiceForDeployWithOwner(ctx context.Context, id uuid.UUID) (GetServiceForDeployWithOwnerRow, error) {
-	row := q.db.QueryRowContext(ctx, getServiceForDeployWithOwner, id)
-	var i GetServiceForDeployWithOwnerRow
-	err := row.Scan(
-		&i.ID,
-		&i.ProjectID,
-		&i.Name,
-		&i.Type,
-		&i.Status,
-		&i.Image,
-		&i.Command,
-		&i.Environment,
-		&i.GitRepo,
-		&i.GitBranch,
-		&i.BuildPath,
-		&i.Cpu,
-		&i.Memory,
-		&i.Replicas,
-		&i.Port,
-		&i.Domain,
-		&i.HealthcheckPath,
-		&i.RestartPolicy,
-		&i.Builder,
-		&i.CpuReserve,
-		&i.MemoryReserve,
-		&i.StaticBuildCmd,
-		&i.StaticDir,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-		&i.OwnerID,
-	)
-	return i, err
-}
-
-const getServicePublishedPort = `-- name: GetServicePublishedPort :one
-SELECT published_port FROM services WHERE id = $1
-`
-
-func (q *Queries) GetServicePublishedPort(ctx context.Context, id uuid.UUID) (int32, error) {
-	row := q.db.QueryRowContext(ctx, getServicePublishedPort, id)
-	var published_port int32
-	err := row.Scan(&published_port)
-	return published_port, err
-}
-
-const insertDeployment = `-- name: InsertDeployment :exec
-INSERT INTO deployments
-    (id, service_id, version, commit_hash, status, image_name, image_tag, created_at, updated_at)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-`
-
-type InsertDeploymentParams struct {
-	ID         uuid.UUID      `json:"id"`
-	ServiceID  uuid.UUID      `json:"service_id"`
-	Version    string         `json:"version"`
-	CommitHash sql.NullString `json:"commit_hash"`
-	Status     sql.NullString `json:"status"`
-	ImageName  sql.NullString `json:"image_name"`
-	ImageTag   sql.NullString `json:"image_tag"`
-	CreatedAt  sql.NullTime   `json:"created_at"`
-	UpdatedAt  sql.NullTime   `json:"updated_at"`
-}
-
-func (q *Queries) InsertDeployment(ctx context.Context, arg InsertDeploymentParams) error {
-	_, err := q.db.ExecContext(ctx, insertDeployment,
-		arg.ID,
-		arg.ServiceID,
-		arg.Version,
-		arg.CommitHash,
-		arg.Status,
-		arg.ImageName,
-		arg.ImageTag,
-		arg.CreatedAt,
-		arg.UpdatedAt,
-	)
-	return err
-}
-
-const listDeploymentsForService = `-- name: ListDeploymentsForService :many
-SELECT id, service_id, commit_hash, status, image_name, image_tag,
-       build_log, runtime_log, error, started_at, completed_at, created_at, updated_at
-FROM deployments
-WHERE service_id = $1
-ORDER BY created_at DESC
-LIMIT $2 OFFSET $3
-`
-
-type ListDeploymentsForServiceParams struct {
-	ServiceID uuid.UUID `json:"service_id"`
-	Limit     int32     `json:"limit"`
-	Offset    int32     `json:"offset"`
-}
-
-type ListDeploymentsForServiceRow struct {
-	ID          uuid.UUID      `json:"id"`
-	ServiceID   uuid.UUID      `json:"service_id"`
-	CommitHash  sql.NullString `json:"commit_hash"`
-	Status      sql.NullString `json:"status"`
-	ImageName   sql.NullString `json:"image_name"`
-	ImageTag    sql.NullString `json:"image_tag"`
-	BuildLog    sql.NullString `json:"build_log"`
-	RuntimeLog  sql.NullString `json:"runtime_log"`
-	Error       sql.NullString `json:"error"`
-	StartedAt   sql.NullTime   `json:"started_at"`
-	CompletedAt sql.NullTime   `json:"completed_at"`
-	CreatedAt   sql.NullTime   `json:"created_at"`
-	UpdatedAt   sql.NullTime   `json:"updated_at"`
-}
-
-func (q *Queries) ListDeploymentsForService(ctx context.Context, arg ListDeploymentsForServiceParams) ([]ListDeploymentsForServiceRow, error) {
-	rows, err := q.db.QueryContext(ctx, listDeploymentsForService, arg.ServiceID, arg.Limit, arg.Offset)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListDeploymentsForServiceRow{}
-	for rows.Next() {
-		var i ListDeploymentsForServiceRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ServiceID,
-			&i.CommitHash,
-			&i.Status,
-			&i.ImageName,
-			&i.ImageTag,
-			&i.BuildLog,
-			&i.RuntimeLog,
-			&i.Error,
-			&i.StartedAt,
-			&i.CompletedAt,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-		); 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 listRecentAccessibleDeployments = `-- name: ListRecentAccessibleDeployments :many
-SELECT d.id, d.service_id, s.name AS service_name, p.name AS project_name, d.status,
-       COALESCE(d.image_name, '') AS image_name, d.started_at, d.completed_at, d.created_at
-FROM deployments d
-JOIN services s ON s.id = d.service_id
-JOIN projects p ON p.id = s.project_id
-WHERE p.is_approved OR p.owner_id = $1 OR $2::bool
-   OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $1)
-ORDER BY d.created_at DESC
-LIMIT $3 OFFSET $4
-`
-
-type ListRecentAccessibleDeploymentsParams struct {
-	OwnerID uuid.UUID `json:"owner_id"`
-	Column2 bool      `json:"column_2"`
-	Limit   int32     `json:"limit"`
-	Offset  int32     `json:"offset"`
-}
-
-type ListRecentAccessibleDeploymentsRow struct {
-	ID          uuid.UUID      `json:"id"`
-	ServiceID   uuid.UUID      `json:"service_id"`
-	ServiceName string         `json:"service_name"`
-	ProjectName string         `json:"project_name"`
-	Status      sql.NullString `json:"status"`
-	ImageName   string         `json:"image_name"`
-	StartedAt   sql.NullTime   `json:"started_at"`
-	CompletedAt sql.NullTime   `json:"completed_at"`
-	CreatedAt   sql.NullTime   `json:"created_at"`
-}
-
-func (q *Queries) ListRecentAccessibleDeployments(ctx context.Context, arg ListRecentAccessibleDeploymentsParams) ([]ListRecentAccessibleDeploymentsRow, error) {
-	rows, err := q.db.QueryContext(ctx, listRecentAccessibleDeployments,
-		arg.OwnerID,
-		arg.Column2,
-		arg.Limit,
-		arg.Offset,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListRecentAccessibleDeploymentsRow{}
-	for rows.Next() {
-		var i ListRecentAccessibleDeploymentsRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ServiceID,
-			&i.ServiceName,
-			&i.ProjectName,
-			&i.Status,
-			&i.ImageName,
-			&i.StartedAt,
-			&i.CompletedAt,
-			&i.CreatedAt,
-		); 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 setDeploymentStatus = `-- name: SetDeploymentStatus :exec
-UPDATE deployments SET status = $1, updated_at = $2 WHERE id = $3
-`
-
-type SetDeploymentStatusParams struct {
-	Status    sql.NullString `json:"status"`
-	UpdatedAt sql.NullTime   `json:"updated_at"`
-	ID        uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) SetDeploymentStatus(ctx context.Context, arg SetDeploymentStatusParams) error {
-	_, err := q.db.ExecContext(ctx, setDeploymentStatus, arg.Status, arg.UpdatedAt, arg.ID)
-	return err
-}
-
-const setServiceStatus = `-- name: SetServiceStatus :exec
-UPDATE services SET status = $1, updated_at = $2 WHERE id = $3
-`
-
-type SetServiceStatusParams struct {
-	Status    sql.NullString `json:"status"`
-	UpdatedAt sql.NullTime   `json:"updated_at"`
-	ID        uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) SetServiceStatus(ctx context.Context, arg SetServiceStatusParams) error {
-	_, err := q.db.ExecContext(ctx, setServiceStatus, arg.Status, arg.UpdatedAt, arg.ID)
-	return err
-}
-
-const syncDeploymentProgress = `-- name: SyncDeploymentProgress :exec
-UPDATE deployments
-SET status = $1,
-    image_name = $2,
-    image_tag = $3,
-    build_log = $4,
-    runtime_log = $5,
-    error = $6,
-    started_at = $7,
-    completed_at = $8,
-    updated_at = $9
-WHERE id = $10
-`
-
-type SyncDeploymentProgressParams struct {
-	Status      sql.NullString `json:"status"`
-	ImageName   sql.NullString `json:"image_name"`
-	ImageTag    sql.NullString `json:"image_tag"`
-	BuildLog    sql.NullString `json:"build_log"`
-	RuntimeLog  sql.NullString `json:"runtime_log"`
-	Error       sql.NullString `json:"error"`
-	StartedAt   sql.NullTime   `json:"started_at"`
-	CompletedAt sql.NullTime   `json:"completed_at"`
-	UpdatedAt   sql.NullTime   `json:"updated_at"`
-	ID          uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) SyncDeploymentProgress(ctx context.Context, arg SyncDeploymentProgressParams) error {
-	_, err := q.db.ExecContext(ctx, syncDeploymentProgress,
-		arg.Status,
-		arg.ImageName,
-		arg.ImageTag,
-		arg.BuildLog,
-		arg.RuntimeLog,
-		arg.Error,
-		arg.StartedAt,
-		arg.CompletedAt,
-		arg.UpdatedAt,
-		arg.ID,
-	)
-	return err
-}

app/backend/internal/database/sqlcdb/models.go

@@ -98,34 +98,6 @@ type ContainerInstance struct {
 	UpdatedAt     sql.NullTime          `json:"updated_at"`
 }
 
-type CronExecution struct {
-	ID         uuid.UUID      `json:"id"`
-	CronJobID  uuid.UUID      `json:"cron_job_id"`
-	StartedAt  time.Time      `json:"started_at"`
-	FinishedAt sql.NullTime   `json:"finished_at"`
-	Status     sql.NullString `json:"status"`
-	Output     sql.NullString `json:"output"`
-	Error      sql.NullString `json:"error"`
-}
-
-type CronJob struct {
-	ID         uuid.UUID      `json:"id"`
-	ProjectID  uuid.UUID      `json:"project_id"`
-	ServiceID  uuid.UUID      `json:"service_id"`
-	Name       string         `json:"name"`
-	Schedule   string         `json:"schedule"`
-	Command    string         `json:"command"`
-	Timezone   sql.NullString `json:"timezone"`
-	Enabled    sql.NullBool   `json:"enabled"`
-	LastRunAt  sql.NullTime   `json:"last_run_at"`
-	NextRunAt  sql.NullTime   `json:"next_run_at"`
-	LastStatus sql.NullString `json:"last_status"`
-	LastOutput sql.NullString `json:"last_output"`
-	Retention  sql.NullInt32  `json:"retention"`
-	CreatedAt  sql.NullTime   `json:"created_at"`
-	UpdatedAt  sql.NullTime   `json:"updated_at"`
-}
-
 type DatabaseBackup struct {
 	ID          string         `json:"id"`
 	DatabaseID  string         `json:"database_id"`
@@ -164,22 +136,11 @@ type DatabaseService struct {
 }
 
 type Deployment struct {
-	ID            uuid.UUID      `json:"id"`
+	ID        uuid.UUID      `json:"id"`
-	ServiceID     uuid.UUID      `json:"service_id"`
+	ServiceID uuid.UUID      `json:"service_id"`
-	Version       string         `json:"version"`
+	Status    sql.NullString `json:"status"`
-	CommitHash    sql.NullString `json:"commit_hash"`
+	CreatedAt sql.NullTime   `json:"created_at"`
-	ImageDigest   sql.NullString `json:"image_digest"`
+	UpdatedAt sql.NullTime   `json:"updated_at"`
-	Status        sql.NullString `json:"status"`
-	BuildLog      sql.NullString `json:"build_log"`
-	DeploymentLog sql.NullString `json:"deployment_log"`
-	StartedAt     sql.NullTime   `json:"started_at"`
-	CompletedAt   sql.NullTime   `json:"completed_at"`
-	CreatedAt     sql.NullTime   `json:"created_at"`
-	UpdatedAt     sql.NullTime   `json:"updated_at"`
-	ImageName     sql.NullString `json:"image_name"`
-	ImageTag      sql.NullString `json:"image_tag"`
-	RuntimeLog    sql.NullString `json:"runtime_log"`
-	Error         sql.NullString `json:"error"`
 }
 
 type Environment struct {
@@ -313,21 +274,6 @@ type OutboundWebhook struct {
 	UpdatedAt sql.NullTime          `json:"updated_at"`
 }
 
-type PreviewEnvironment struct {
-	ID               uuid.UUID      `json:"id"`
-	ProjectID        uuid.UUID      `json:"project_id"`
-	ServiceID        uuid.UUID      `json:"service_id"`
-	BranchName       string         `json:"branch_name"`
-	PrNumber         sql.NullInt32  `json:"pr_number"`
-	Environment      string         `json:"environment"`
-	Status           string         `json:"status"`
-	Url              sql.NullString `json:"url"`
-	ExpiresAt        time.Time      `json:"expires_at"`
-	CreatedAt        sql.NullTime   `json:"created_at"`
-	UpdatedAt        sql.NullTime   `json:"updated_at"`
-	PreviewServiceID uuid.NullUUID  `json:"preview_service_id"`
-}
-
 type Project struct {
 	ID          uuid.UUID      `json:"id"`
 	Name        string         `json:"name"`
@@ -358,53 +304,51 @@ type Registry struct {
 }
 
 type Service struct {
-	ID               uuid.UUID       `json:"id"`
+	ID              uuid.UUID       `json:"id"`
-	Name             string          `json:"name"`
+	Name            string          `json:"name"`
-	Description      sql.NullString  `json:"description"`
+	Description     sql.NullString  `json:"description"`
-	ProjectID        uuid.UUID       `json:"project_id"`
+	ProjectID       uuid.UUID       `json:"project_id"`
-	EnvironmentID    uuid.UUID       `json:"environment_id"`
+	EnvironmentID   uuid.UUID       `json:"environment_id"`
-	ServiceType      string          `json:"service_type"`
+	ServiceType     string          `json:"service_type"`
-	SourceType       string          `json:"source_type"`
+	SourceType      string          `json:"source_type"`
-	SourceUrl        sql.NullString  `json:"source_url"`
+	SourceUrl       sql.NullString  `json:"source_url"`
-	ImageName        sql.NullString  `json:"image_name"`
+	ImageName       sql.NullString  `json:"image_name"`
-	BuildCommand     sql.NullString  `json:"build_command"`
+	BuildCommand    sql.NullString  `json:"build_command"`
-	StartCommand     sql.NullString  `json:"start_command"`
+	StartCommand    sql.NullString  `json:"start_command"`
-	CpuLimit         sql.NullInt32   `json:"cpu_limit"`
+	CpuLimit        sql.NullInt32   `json:"cpu_limit"`
-	MemoryLimit      sql.NullInt32   `json:"memory_limit"`
+	MemoryLimit     sql.NullInt32   `json:"memory_limit"`
-	PublicUrl        sql.NullString  `json:"public_url"`
+	PublicUrl       sql.NullString  `json:"public_url"`
-	HealthCheckUrl   sql.NullString  `json:"health_check_url"`
+	HealthCheckUrl  sql.NullString  `json:"health_check_url"`
-	Status           sql.NullString  `json:"status"`
+	Status          sql.NullString  `json:"status"`
-	CreatedAt        sql.NullTime    `json:"created_at"`
+	CreatedAt       sql.NullTime    `json:"created_at"`
-	UpdatedAt        sql.NullTime    `json:"updated_at"`
+	UpdatedAt       sql.NullTime    `json:"updated_at"`
-	Type             sql.NullString  `json:"type"`
+	Type            sql.NullString  `json:"type"`
-	Image            sql.NullString  `json:"image"`
+	Image           sql.NullString  `json:"image"`
-	Command          sql.NullString  `json:"command"`
+	Command         sql.NullString  `json:"command"`
-	Environment      sql.NullString  `json:"environment"`
+	Environment     sql.NullString  `json:"environment"`
-	GitRepo          sql.NullString  `json:"git_repo"`
+	GitRepo         sql.NullString  `json:"git_repo"`
-	GitBranch        sql.NullString  `json:"git_branch"`
+	GitBranch       sql.NullString  `json:"git_branch"`
-	BuildPath        sql.NullString  `json:"build_path"`
+	BuildPath       sql.NullString  `json:"build_path"`
-	Cpu              sql.NullString  `json:"cpu"`
+	Cpu             sql.NullString  `json:"cpu"`
-	Memory           sql.NullString  `json:"memory"`
+	Memory          sql.NullString  `json:"memory"`
-	Replicas         int32           `json:"replicas"`
+	Replicas        int32           `json:"replicas"`
-	Port             int32           `json:"port"`
+	Port            int32           `json:"port"`
-	Domain           string          `json:"domain"`
+	Domain          string          `json:"domain"`
-	HealthcheckPath  string          `json:"healthcheck_path"`
+	HealthcheckPath string          `json:"healthcheck_path"`
-	RestartPolicy    string          `json:"restart_policy"`
+	RestartPolicy   string          `json:"restart_policy"`
-	PublishedPort    int32           `json:"published_port"`
+	PublishedPort   int32           `json:"published_port"`
-	Volumes          json.RawMessage `json:"volumes"`
+	Volumes         json.RawMessage `json:"volumes"`
-	MaintenanceMode  bool            `json:"maintenance_mode"`
+	MaintenanceMode bool            `json:"maintenance_mode"`
-	BasicAuthUsers   string          `json:"basic_auth_users"`
+	BasicAuthUsers  string          `json:"basic_auth_users"`
-	Builder          string          `json:"builder"`
+	Builder         string          `json:"builder"`
-	CpuReserve       string          `json:"cpu_reserve"`
+	CpuReserve      string          `json:"cpu_reserve"`
-	MemoryReserve    string          `json:"memory_reserve"`
+	MemoryReserve   string          `json:"memory_reserve"`
-	StaticBuildCmd   string          `json:"static_build_cmd"`
+	StaticBuildCmd  string          `json:"static_build_cmd"`
-	StaticDir        string          `json:"static_dir"`
+	StaticDir       string          `json:"static_dir"`
-	NodeID           sql.NullString  `json:"node_id"`
+	NodeID          sql.NullString  `json:"node_id"`
-	Spread           bool            `json:"spread"`
+	Spread          bool            `json:"spread"`
-	SleepEnabled     bool            `json:"sleep_enabled"`
+	PlacementTags   json.RawMessage `json:"placement_tags"`
-	SleepIdleMinutes int32           `json:"sleep_idle_minutes"`
+	TraefikLabels   json.RawMessage `json:"traefik_labels"`
-	PlacementTags    json.RawMessage `json:"placement_tags"`
-	TraefikLabels    json.RawMessage `json:"traefik_labels"`
 }
 
 type ServiceDomain struct {

app/backend/internal/database/sqlcdb/preview_environments.sql.go

@@ -1,635 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.31.1
-// source: preview_environments.sql
-
-package sqlcdb
-
-import (
-	"context"
-	"database/sql"
-	"time"
-
-	"github.com/google/uuid"
-)
-
-const countActivePreviewsForBranch = `-- name: CountActivePreviewsForBranch :one
-SELECT COUNT(*) FROM preview_environments
-WHERE service_id = $1 AND branch_name = $2 AND status NOT IN ('expired', 'stopped')
-`
-
-type CountActivePreviewsForBranchParams struct {
-	ServiceID  uuid.UUID `json:"service_id"`
-	BranchName string    `json:"branch_name"`
-}
-
-func (q *Queries) CountActivePreviewsForBranch(ctx context.Context, arg CountActivePreviewsForBranchParams) (int64, error) {
-	row := q.db.QueryRowContext(ctx, countActivePreviewsForBranch, arg.ServiceID, arg.BranchName)
-	var count int64
-	err := row.Scan(&count)
-	return count, err
-}
-
-const createPreviewDomain = `-- name: CreatePreviewDomain :exec
-INSERT INTO service_domains (service_id, domain, is_default, cert_type) VALUES ($1, $2, true, 'tls')
-`
-
-type CreatePreviewDomainParams struct {
-	ServiceID uuid.UUID `json:"service_id"`
-	Domain    string    `json:"domain"`
-}
-
-func (q *Queries) CreatePreviewDomain(ctx context.Context, arg CreatePreviewDomainParams) error {
-	_, err := q.db.ExecContext(ctx, createPreviewDomain, arg.ServiceID, arg.Domain)
-	return err
-}
-
-const createPreviewEnvironment = `-- name: CreatePreviewEnvironment :exec
-INSERT INTO preview_environments
-    (id, project_id, service_id, preview_service_id, branch_name, pr_number, environment,
-     status, url, expires_at, created_at, updated_at)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
-`
-
-type CreatePreviewEnvironmentParams struct {
-	ID               uuid.UUID      `json:"id"`
-	ProjectID        uuid.UUID      `json:"project_id"`
-	ServiceID        uuid.UUID      `json:"service_id"`
-	PreviewServiceID uuid.NullUUID  `json:"preview_service_id"`
-	BranchName       string         `json:"branch_name"`
-	PrNumber         sql.NullInt32  `json:"pr_number"`
-	Environment      string         `json:"environment"`
-	Status           string         `json:"status"`
-	Url              sql.NullString `json:"url"`
-	ExpiresAt        time.Time      `json:"expires_at"`
-	CreatedAt        sql.NullTime   `json:"created_at"`
-	UpdatedAt        sql.NullTime   `json:"updated_at"`
-}
-
-func (q *Queries) CreatePreviewEnvironment(ctx context.Context, arg CreatePreviewEnvironmentParams) error {
-	_, err := q.db.ExecContext(ctx, createPreviewEnvironment,
-		arg.ID,
-		arg.ProjectID,
-		arg.ServiceID,
-		arg.PreviewServiceID,
-		arg.BranchName,
-		arg.PrNumber,
-		arg.Environment,
-		arg.Status,
-		arg.Url,
-		arg.ExpiresAt,
-		arg.CreatedAt,
-		arg.UpdatedAt,
-	)
-	return err
-}
-
-const deleteAllServiceDomains = `-- name: DeleteAllServiceDomains :exec
-DELETE FROM service_domains WHERE service_id = $1
-`
-
-func (q *Queries) DeleteAllServiceDomains(ctx context.Context, serviceID uuid.UUID) error {
-	_, err := q.db.ExecContext(ctx, deleteAllServiceDomains, serviceID)
-	return err
-}
-
-const deletePreviewEnvironment = `-- name: DeletePreviewEnvironment :exec
-DELETE FROM preview_environments WHERE id = $1
-`
-
-func (q *Queries) DeletePreviewEnvironment(ctx context.Context, id uuid.UUID) error {
-	_, err := q.db.ExecContext(ctx, deletePreviewEnvironment, id)
-	return err
-}
-
-const getPreviewEnvironment = `-- name: GetPreviewEnvironment :one
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.pr_number,
-       pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at,
-       s.id AS svc_id, s.name AS service_name, s.type AS service_type
-FROM preview_environments pe
-LEFT JOIN services s ON pe.service_id = s.id
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1 AND (p.is_approved OR p.owner_id = $2 OR $3::bool
-    OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $2))
-`
-
-type GetPreviewEnvironmentParams struct {
-	ID      uuid.UUID `json:"id"`
-	OwnerID uuid.UUID `json:"owner_id"`
-	Column3 bool      `json:"column_3"`
-}
-
-type GetPreviewEnvironmentRow struct {
-	ID               uuid.UUID      `json:"id"`
-	ProjectID        uuid.UUID      `json:"project_id"`
-	ServiceID        uuid.UUID      `json:"service_id"`
-	PreviewServiceID uuid.NullUUID  `json:"preview_service_id"`
-	BranchName       string         `json:"branch_name"`
-	PrNumber         sql.NullInt32  `json:"pr_number"`
-	Environment      string         `json:"environment"`
-	Status           string         `json:"status"`
-	Url              sql.NullString `json:"url"`
-	ExpiresAt        time.Time      `json:"expires_at"`
-	CreatedAt        sql.NullTime   `json:"created_at"`
-	UpdatedAt        sql.NullTime   `json:"updated_at"`
-	SvcID            uuid.NullUUID  `json:"svc_id"`
-	ServiceName      sql.NullString `json:"service_name"`
-	ServiceType      sql.NullString `json:"service_type"`
-}
-
-func (q *Queries) GetPreviewEnvironment(ctx context.Context, arg GetPreviewEnvironmentParams) (GetPreviewEnvironmentRow, error) {
-	row := q.db.QueryRowContext(ctx, getPreviewEnvironment, arg.ID, arg.OwnerID, arg.Column3)
-	var i GetPreviewEnvironmentRow
-	err := row.Scan(
-		&i.ID,
-		&i.ProjectID,
-		&i.ServiceID,
-		&i.PreviewServiceID,
-		&i.BranchName,
-		&i.PrNumber,
-		&i.Environment,
-		&i.Status,
-		&i.Url,
-		&i.ExpiresAt,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-		&i.SvcID,
-		&i.ServiceName,
-		&i.ServiceType,
-	)
-	return i, err
-}
-
-const getPreviewEnvironmentForPromote = `-- name: GetPreviewEnvironmentForPromote :one
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.environment, pe.status
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1 AND (p.owner_id = $2 OR $3::bool)
-`
-
-type GetPreviewEnvironmentForPromoteParams struct {
-	ID      uuid.UUID `json:"id"`
-	OwnerID uuid.UUID `json:"owner_id"`
-	Column3 bool      `json:"column_3"`
-}
-
-type GetPreviewEnvironmentForPromoteRow struct {
-	ID               uuid.UUID     `json:"id"`
-	ProjectID        uuid.UUID     `json:"project_id"`
-	ServiceID        uuid.UUID     `json:"service_id"`
-	PreviewServiceID uuid.NullUUID `json:"preview_service_id"`
-	BranchName       string        `json:"branch_name"`
-	Environment      string        `json:"environment"`
-	Status           string        `json:"status"`
-}
-
-func (q *Queries) GetPreviewEnvironmentForPromote(ctx context.Context, arg GetPreviewEnvironmentForPromoteParams) (GetPreviewEnvironmentForPromoteRow, error) {
-	row := q.db.QueryRowContext(ctx, getPreviewEnvironmentForPromote, arg.ID, arg.OwnerID, arg.Column3)
-	var i GetPreviewEnvironmentForPromoteRow
-	err := row.Scan(
-		&i.ID,
-		&i.ProjectID,
-		&i.ServiceID,
-		&i.PreviewServiceID,
-		&i.BranchName,
-		&i.Environment,
-		&i.Status,
-	)
-	return i, err
-}
-
-const getPreviewEnvironmentForWrite = `-- name: GetPreviewEnvironmentForWrite :one
-SELECT pe.id, pe.project_id, pe.service_id, pe.branch_name, pe.pr_number,
-       pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1 AND (p.owner_id = $2 OR $3::bool)
-`
-
-type GetPreviewEnvironmentForWriteParams struct {
-	ID      uuid.UUID `json:"id"`
-	OwnerID uuid.UUID `json:"owner_id"`
-	Column3 bool      `json:"column_3"`
-}
-
-type GetPreviewEnvironmentForWriteRow struct {
-	ID          uuid.UUID      `json:"id"`
-	ProjectID   uuid.UUID      `json:"project_id"`
-	ServiceID   uuid.UUID      `json:"service_id"`
-	BranchName  string         `json:"branch_name"`
-	PrNumber    sql.NullInt32  `json:"pr_number"`
-	Environment string         `json:"environment"`
-	Status      string         `json:"status"`
-	Url         sql.NullString `json:"url"`
-	ExpiresAt   time.Time      `json:"expires_at"`
-	CreatedAt   sql.NullTime   `json:"created_at"`
-	UpdatedAt   sql.NullTime   `json:"updated_at"`
-}
-
-func (q *Queries) GetPreviewEnvironmentForWrite(ctx context.Context, arg GetPreviewEnvironmentForWriteParams) (GetPreviewEnvironmentForWriteRow, error) {
-	row := q.db.QueryRowContext(ctx, getPreviewEnvironmentForWrite, arg.ID, arg.OwnerID, arg.Column3)
-	var i GetPreviewEnvironmentForWriteRow
-	err := row.Scan(
-		&i.ID,
-		&i.ProjectID,
-		&i.ServiceID,
-		&i.BranchName,
-		&i.PrNumber,
-		&i.Environment,
-		&i.Status,
-		&i.Url,
-		&i.ExpiresAt,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getPreviewEnvironmentOwner = `-- name: GetPreviewEnvironmentOwner :one
-SELECT p.owner_id
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1
-`
-
-func (q *Queries) GetPreviewEnvironmentOwner(ctx context.Context, id uuid.UUID) (uuid.UUID, error) {
-	row := q.db.QueryRowContext(ctx, getPreviewEnvironmentOwner, id)
-	var owner_id uuid.UUID
-	err := row.Scan(&owner_id)
-	return owner_id, err
-}
-
-const getPreviewServiceID = `-- name: GetPreviewServiceID :one
-SELECT preview_service_id FROM preview_environments WHERE id = $1
-`
-
-func (q *Queries) GetPreviewServiceID(ctx context.Context, id uuid.UUID) (uuid.NullUUID, error) {
-	row := q.db.QueryRowContext(ctx, getPreviewServiceID, id)
-	var preview_service_id uuid.NullUUID
-	err := row.Scan(&preview_service_id)
-	return preview_service_id, err
-}
-
-const getProjectBrief = `-- name: GetProjectBrief :one
-SELECT id, name, owner_id FROM projects WHERE id = $1
-`
-
-type GetProjectBriefRow struct {
-	ID      uuid.UUID `json:"id"`
-	Name    string    `json:"name"`
-	OwnerID uuid.UUID `json:"owner_id"`
-}
-
-func (q *Queries) GetProjectBrief(ctx context.Context, id uuid.UUID) (GetProjectBriefRow, error) {
-	row := q.db.QueryRowContext(ctx, getProjectBrief, id)
-	var i GetProjectBriefRow
-	err := row.Scan(&i.ID, &i.Name, &i.OwnerID)
-	return i, err
-}
-
-const getServiceForDeploy = `-- name: GetServiceForDeploy :one
-SELECT s.id, s.project_id, s.name, s.type, s.status, s.image, s.command,
-       s.environment, s.git_repo, s.git_branch, s.build_path, s.cpu, s.memory,
-       COALESCE(s.replicas, 1) AS replicas, COALESCE(s.port, 0) AS port,
-       COALESCE(s.domain, '') AS domain, COALESCE(s.healthcheck_path, '') AS healthcheck_path,
-       COALESCE(s.restart_policy, 'unless-stopped') AS restart_policy,
-       COALESCE(s.builder, 'auto') AS builder, COALESCE(s.cpu_reserve, '') AS cpu_reserve,
-       COALESCE(s.memory_reserve, '') AS memory_reserve, COALESCE(s.static_build_cmd, '') AS static_build_cmd,
-       COALESCE(s.static_dir, '') AS static_dir,
-       s.created_at, s.updated_at
-FROM services s
-WHERE s.id = $1
-`
-
-type GetServiceForDeployRow struct {
-	ID              uuid.UUID      `json:"id"`
-	ProjectID       uuid.UUID      `json:"project_id"`
-	Name            string         `json:"name"`
-	Type            sql.NullString `json:"type"`
-	Status          sql.NullString `json:"status"`
-	Image           sql.NullString `json:"image"`
-	Command         sql.NullString `json:"command"`
-	Environment     sql.NullString `json:"environment"`
-	GitRepo         sql.NullString `json:"git_repo"`
-	GitBranch       sql.NullString `json:"git_branch"`
-	BuildPath       sql.NullString `json:"build_path"`
-	Cpu             sql.NullString `json:"cpu"`
-	Memory          sql.NullString `json:"memory"`
-	Replicas        int32          `json:"replicas"`
-	Port            int32          `json:"port"`
-	Domain          string         `json:"domain"`
-	HealthcheckPath string         `json:"healthcheck_path"`
-	RestartPolicy   string         `json:"restart_policy"`
-	Builder         string         `json:"builder"`
-	CpuReserve      string         `json:"cpu_reserve"`
-	MemoryReserve   string         `json:"memory_reserve"`
-	StaticBuildCmd  string         `json:"static_build_cmd"`
-	StaticDir       string         `json:"static_dir"`
-	CreatedAt       sql.NullTime   `json:"created_at"`
-	UpdatedAt       sql.NullTime   `json:"updated_at"`
-}
-
-func (q *Queries) GetServiceForDeploy(ctx context.Context, id uuid.UUID) (GetServiceForDeployRow, error) {
-	row := q.db.QueryRowContext(ctx, getServiceForDeploy, id)
-	var i GetServiceForDeployRow
-	err := row.Scan(
-		&i.ID,
-		&i.ProjectID,
-		&i.Name,
-		&i.Type,
-		&i.Status,
-		&i.Image,
-		&i.Command,
-		&i.Environment,
-		&i.GitRepo,
-		&i.GitBranch,
-		&i.BuildPath,
-		&i.Cpu,
-		&i.Memory,
-		&i.Replicas,
-		&i.Port,
-		&i.Domain,
-		&i.HealthcheckPath,
-		&i.RestartPolicy,
-		&i.Builder,
-		&i.CpuReserve,
-		&i.MemoryReserve,
-		&i.StaticBuildCmd,
-		&i.StaticDir,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-	)
-	return i, err
-}
-
-const getServiceTypeBrief = `-- name: GetServiceTypeBrief :one
-SELECT id, name, COALESCE(type, service_type, '') AS service_type FROM services WHERE id = $1 AND project_id = $2
-`
-
-type GetServiceTypeBriefParams struct {
-	ID        uuid.UUID `json:"id"`
-	ProjectID uuid.UUID `json:"project_id"`
-}
-
-type GetServiceTypeBriefRow struct {
-	ID          uuid.UUID `json:"id"`
-	Name        string    `json:"name"`
-	ServiceType string    `json:"service_type"`
-}
-
-func (q *Queries) GetServiceTypeBrief(ctx context.Context, arg GetServiceTypeBriefParams) (GetServiceTypeBriefRow, error) {
-	row := q.db.QueryRowContext(ctx, getServiceTypeBrief, arg.ID, arg.ProjectID)
-	var i GetServiceTypeBriefRow
-	err := row.Scan(&i.ID, &i.Name, &i.ServiceType)
-	return i, err
-}
-
-const insertPendingDeployment = `-- name: InsertPendingDeployment :exec
-INSERT INTO deployments (id, service_id, version, commit_hash, status, created_at, updated_at)
-VALUES ($1, $2, $3, $4, 'pending', NOW(), NOW())
-`
-
-type InsertPendingDeploymentParams struct {
-	ID         uuid.UUID      `json:"id"`
-	ServiceID  uuid.UUID      `json:"service_id"`
-	Version    string         `json:"version"`
-	CommitHash sql.NullString `json:"commit_hash"`
-}
-
-func (q *Queries) InsertPendingDeployment(ctx context.Context, arg InsertPendingDeploymentParams) error {
-	_, err := q.db.ExecContext(ctx, insertPendingDeployment,
-		arg.ID,
-		arg.ServiceID,
-		arg.Version,
-		arg.CommitHash,
-	)
-	return err
-}
-
-const listExpiredPreviewsForUser = `-- name: ListExpiredPreviewsForUser :many
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.environment
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE (p.owner_id = $1 OR $2::bool) AND pe.expires_at < NOW() AND pe.status != 'expired'
-`
-
-type ListExpiredPreviewsForUserParams struct {
-	OwnerID uuid.UUID `json:"owner_id"`
-	Column2 bool      `json:"column_2"`
-}
-
-type ListExpiredPreviewsForUserRow struct {
-	ID               uuid.UUID     `json:"id"`
-	ProjectID        uuid.UUID     `json:"project_id"`
-	ServiceID        uuid.UUID     `json:"service_id"`
-	PreviewServiceID uuid.NullUUID `json:"preview_service_id"`
-	BranchName       string        `json:"branch_name"`
-	Environment      string        `json:"environment"`
-}
-
-func (q *Queries) ListExpiredPreviewsForUser(ctx context.Context, arg ListExpiredPreviewsForUserParams) ([]ListExpiredPreviewsForUserRow, error) {
-	rows, err := q.db.QueryContext(ctx, listExpiredPreviewsForUser, arg.OwnerID, arg.Column2)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListExpiredPreviewsForUserRow{}
-	for rows.Next() {
-		var i ListExpiredPreviewsForUserRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ProjectID,
-			&i.ServiceID,
-			&i.PreviewServiceID,
-			&i.BranchName,
-			&i.Environment,
-		); 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 listPreviewEnvironmentsForProject = `-- name: ListPreviewEnvironmentsForProject :many
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.pr_number,
-       pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at,
-       s.id AS svc_id, s.name AS service_name, s.type AS service_type
-FROM preview_environments pe
-LEFT JOIN services s ON pe.service_id = s.id
-WHERE pe.project_id = $1
-ORDER BY pe.created_at DESC
-`
-
-type ListPreviewEnvironmentsForProjectRow struct {
-	ID               uuid.UUID      `json:"id"`
-	ProjectID        uuid.UUID      `json:"project_id"`
-	ServiceID        uuid.UUID      `json:"service_id"`
-	PreviewServiceID uuid.NullUUID  `json:"preview_service_id"`
-	BranchName       string         `json:"branch_name"`
-	PrNumber         sql.NullInt32  `json:"pr_number"`
-	Environment      string         `json:"environment"`
-	Status           string         `json:"status"`
-	Url              sql.NullString `json:"url"`
-	ExpiresAt        time.Time      `json:"expires_at"`
-	CreatedAt        sql.NullTime   `json:"created_at"`
-	UpdatedAt        sql.NullTime   `json:"updated_at"`
-	SvcID            uuid.NullUUID  `json:"svc_id"`
-	ServiceName      sql.NullString `json:"service_name"`
-	ServiceType      sql.NullString `json:"service_type"`
-}
-
-func (q *Queries) ListPreviewEnvironmentsForProject(ctx context.Context, projectID uuid.UUID) ([]ListPreviewEnvironmentsForProjectRow, error) {
-	rows, err := q.db.QueryContext(ctx, listPreviewEnvironmentsForProject, projectID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListPreviewEnvironmentsForProjectRow{}
-	for rows.Next() {
-		var i ListPreviewEnvironmentsForProjectRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ProjectID,
-			&i.ServiceID,
-			&i.PreviewServiceID,
-			&i.BranchName,
-			&i.PrNumber,
-			&i.Environment,
-			&i.Status,
-			&i.Url,
-			&i.ExpiresAt,
-			&i.CreatedAt,
-			&i.UpdatedAt,
-			&i.SvcID,
-			&i.ServiceName,
-			&i.ServiceType,
-		); 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 listSweepablePreviews = `-- name: ListSweepablePreviews :many
-SELECT id, preview_service_id FROM preview_environments
-WHERE expires_at < NOW() AND status NOT IN ('expired', 'stopped')
-`
-
-type ListSweepablePreviewsRow struct {
-	ID               uuid.UUID     `json:"id"`
-	PreviewServiceID uuid.NullUUID `json:"preview_service_id"`
-}
-
-func (q *Queries) ListSweepablePreviews(ctx context.Context) ([]ListSweepablePreviewsRow, error) {
-	rows, err := q.db.QueryContext(ctx, listSweepablePreviews)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListSweepablePreviewsRow{}
-	for rows.Next() {
-		var i ListSweepablePreviewsRow
-		if err := rows.Scan(&i.ID, &i.PreviewServiceID); 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 markPreviewEnvironmentStatus = `-- name: MarkPreviewEnvironmentStatus :exec
-UPDATE preview_environments SET status = $1, updated_at = NOW() WHERE id = $2
-`
-
-type MarkPreviewEnvironmentStatusParams struct {
-	Status string    `json:"status"`
-	ID     uuid.UUID `json:"id"`
-}
-
-func (q *Queries) MarkPreviewEnvironmentStatus(ctx context.Context, arg MarkPreviewEnvironmentStatusParams) error {
-	_, err := q.db.ExecContext(ctx, markPreviewEnvironmentStatus, arg.Status, arg.ID)
-	return err
-}
-
-const syncPreviewStatuses = `-- name: SyncPreviewStatuses :exec
-UPDATE preview_environments pe
-SET status = derived.st, updated_at = NOW()
-FROM (
-    SELECT pe2.id,
-        CASE
-            WHEN s.status IN ('running', 'deployed') THEN 'running'
-            WHEN s.status IN ('failed', 'error') THEN 'failed'
-            WHEN s.status IN ('building', 'deploying', 'queued', 'pending', 'cloning') THEN 'building'
-            ELSE pe2.status
-        END AS st
-    FROM preview_environments pe2
-    JOIN services s ON pe2.preview_service_id = s.id
-) derived
-WHERE pe.id = derived.id
-  AND pe.status IN ('building', 'running', 'failed')
-  AND pe.status <> derived.st
-`
-
-func (q *Queries) SyncPreviewStatuses(ctx context.Context) error {
-	_, err := q.db.ExecContext(ctx, syncPreviewStatuses)
-	return err
-}
-
-const updatePreviewEnvironment = `-- name: UpdatePreviewEnvironment :exec
-UPDATE preview_environments
-SET status = $1, url = $2, expires_at = $3, updated_at = $4
-WHERE id = $5
-`
-
-type UpdatePreviewEnvironmentParams struct {
-	Status    string         `json:"status"`
-	Url       sql.NullString `json:"url"`
-	ExpiresAt time.Time      `json:"expires_at"`
-	UpdatedAt sql.NullTime   `json:"updated_at"`
-	ID        uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) UpdatePreviewEnvironment(ctx context.Context, arg UpdatePreviewEnvironmentParams) error {
-	_, err := q.db.ExecContext(ctx, updatePreviewEnvironment,
-		arg.Status,
-		arg.Url,
-		arg.ExpiresAt,
-		arg.UpdatedAt,
-		arg.ID,
-	)
-	return err
-}
-
-const updateServicePreviewBranch = `-- name: UpdateServicePreviewBranch :exec
-UPDATE services SET git_branch = $1, domain = '', updated_at = NOW() WHERE id = $2
-`
-
-type UpdateServicePreviewBranchParams struct {
-	GitBranch sql.NullString `json:"git_branch"`
-	ID        uuid.UUID      `json:"id"`
-}
-
-func (q *Queries) UpdateServicePreviewBranch(ctx context.Context, arg UpdateServicePreviewBranchParams) error {
-	_, err := q.db.ExecContext(ctx, updateServicePreviewBranch, arg.GitBranch, arg.ID)
-	return err
-}

app/backend/internal/database/sqlcdb/querier.go

@@ -22,12 +22,8 @@ type Querier interface {
 	CloneServiceRow(ctx context.Context, arg CloneServiceRowParams) error
 	CloneServiceVariables(ctx context.Context, arg CloneServiceVariablesParams) error
 	CompleteCommand(ctx context.Context, arg CompleteCommandParams) (AgentCommand, error)
-	CompleteDeployment(ctx context.Context, arg CompleteDeploymentParams) error
-	CountAccessibleDeployments(ctx context.Context, arg CountAccessibleDeploymentsParams) (int64, error)
-	CountActivePreviewsForBranch(ctx context.Context, arg CountActivePreviewsForBranchParams) (int64, error)
 	CountDatabaseServicesByUserAndName(ctx context.Context, arg CountDatabaseServicesByUserAndNameParams) (int64, error)
 	CountDatabasesUsingBackupTarget(ctx context.Context, targetID sql.NullString) (int64, error)
-	CountDeploymentsForService(ctx context.Context, serviceID uuid.UUID) (int64, error)
 	CountEnvironmentServices(ctx context.Context, environmentID uuid.UUID) (int64, error)
 	CountProjectsByUser(ctx context.Context, arg CountProjectsByUserParams) (int64, error)
 	CountServiceDomains(ctx context.Context, serviceID uuid.UUID) (int64, error)
@@ -45,8 +41,6 @@ type Querier interface {
 	CreateExternalDatabaseService(ctx context.Context, arg CreateExternalDatabaseServiceParams) error
 	CreateNotification(ctx context.Context, arg CreateNotificationParams) error
 	CreateOutboundWebhook(ctx context.Context, arg CreateOutboundWebhookParams) error
-	CreatePreviewDomain(ctx context.Context, arg CreatePreviewDomainParams) error
-	CreatePreviewEnvironment(ctx context.Context, arg CreatePreviewEnvironmentParams) error
 	CreateProject(ctx context.Context, arg CreateProjectParams) (Project, error)
 	CreateServiceDomain(ctx context.Context, arg CreateServiceDomainParams) (CreateServiceDomainRow, error)
 	CreateServiceFromTemplate(ctx context.Context, arg CreateServiceFromTemplateParams) error
@@ -56,15 +50,12 @@ type Querier interface {
 	CreateWebhookDelivery(ctx context.Context, arg CreateWebhookDeliveryParams) error
 	DatabaseServiceExistsByIDAndUser(ctx context.Context, arg DatabaseServiceExistsByIDAndUserParams) (bool, error)
 	DeleteAgent(ctx context.Context, id string) error
-	DeleteAllServiceDomains(ctx context.Context, serviceID uuid.UUID) error
 	DeleteBackupTargetByIDAndUser(ctx context.Context, arg DeleteBackupTargetByIDAndUserParams) error
 	DeleteBanner(ctx context.Context, id uuid.UUID) error
-	DeleteCronJob(ctx context.Context, id uuid.UUID) error
 	DeleteDatabaseServiceByID(ctx context.Context, id string) error
 	DeleteDatabaseServiceByIDAndUser(ctx context.Context, arg DeleteDatabaseServiceByIDAndUserParams) error
 	DeleteNotificationChannel(ctx context.Context, arg DeleteNotificationChannelParams) (int64, error)
 	DeleteOutboundWebhookByIDAndUser(ctx context.Context, arg DeleteOutboundWebhookByIDAndUserParams) error
-	DeletePreviewEnvironment(ctx context.Context, id uuid.UUID) error
 	DeleteProjectByID(ctx context.Context, projectID uuid.UUID) (int64, error)
 	DeleteProjectEnvironment(ctx context.Context, arg DeleteProjectEnvironmentParams) error
 	DeleteServiceByID(ctx context.Context, id uuid.UUID) error
@@ -72,8 +63,6 @@ type Querier interface {
 	DeleteServiceDomain(ctx context.Context, arg DeleteServiceDomainParams) (int64, error)
 	DeleteUserInvite(ctx context.Context, id uuid.UUID) error
 	DeleteUserTemplate(ctx context.Context, arg DeleteUserTemplateParams) (int64, error)
-	FailDeployment(ctx context.Context, arg FailDeploymentParams) error
-	FinishCronExecution(ctx context.Context, arg FinishCronExecutionParams) error
 	GetActiveAgentAuthTokenByHash(ctx context.Context, tokenHash string) (AgentAuthToken, error)
 	GetAgent(ctx context.Context, id string) (NodeAgent, error)
 	GetAgentByHostAndIP(ctx context.Context, arg GetAgentByHostAndIPParams) (NodeAgent, error)
@@ -83,28 +72,13 @@ type Querier interface {
 	GetCommandForAgent(ctx context.Context, arg GetCommandForAgentParams) (AgentCommand, error)
 	GetContainer(ctx context.Context, id string) (ContainerInstance, error)
 	GetContainerForAgent(ctx context.Context, arg GetContainerForAgentParams) (ContainerInstance, error)
-	GetCronJob(ctx context.Context, id uuid.UUID) (CronJob, error)
-	GetCronJobForTrigger(ctx context.Context, id uuid.UUID) (GetCronJobForTriggerRow, error)
-	GetCronJobOwner(ctx context.Context, id uuid.UUID) (uuid.UUID, error)
-	GetCronJobProjectID(ctx context.Context, id uuid.UUID) (uuid.UUID, error)
-	GetCronOwnerViaService(ctx context.Context, id uuid.UUID) (uuid.UUID, error)
 	GetDatabaseBackupByIDAndDatabaseAndUser(ctx context.Context, arg GetDatabaseBackupByIDAndDatabaseAndUserParams) (DatabaseBackup, error)
 	GetDatabaseServiceByID(ctx context.Context, id string) (DatabaseService, error)
 	GetDatabaseServiceByIDAndUser(ctx context.Context, arg GetDatabaseServiceByIDAndUserParams) (DatabaseService, error)
 	GetDatabaseServiceOwnerID(ctx context.Context, id string) (string, error)
-	GetDeploymentAccess(ctx context.Context, id uuid.UUID) (GetDeploymentAccessRow, error)
-	GetDeploymentForRollback(ctx context.Context, id uuid.UUID) (GetDeploymentForRollbackRow, error)
-	GetDeploymentWithProject(ctx context.Context, id uuid.UUID) (GetDeploymentWithProjectRow, error)
 	GetLastAgentCommandByType(ctx context.Context, arg GetLastAgentCommandByTypeParams) (AgentCommand, error)
-	GetLastDeployedImage(ctx context.Context, serviceID uuid.UUID) (string, error)
 	GetOutboundWebhookByID(ctx context.Context, id uuid.UUID) (OutboundWebhook, error)
 	GetOutboundWebhookByIDAndUser(ctx context.Context, arg GetOutboundWebhookByIDAndUserParams) (OutboundWebhook, error)
-	GetPreviewEnvironment(ctx context.Context, arg GetPreviewEnvironmentParams) (GetPreviewEnvironmentRow, error)
-	GetPreviewEnvironmentForPromote(ctx context.Context, arg GetPreviewEnvironmentForPromoteParams) (GetPreviewEnvironmentForPromoteRow, error)
-	GetPreviewEnvironmentForWrite(ctx context.Context, arg GetPreviewEnvironmentForWriteParams) (GetPreviewEnvironmentForWriteRow, error)
-	GetPreviewEnvironmentOwner(ctx context.Context, id uuid.UUID) (uuid.UUID, error)
-	GetPreviewServiceID(ctx context.Context, id uuid.UUID) (uuid.NullUUID, error)
-	GetProjectBrief(ctx context.Context, id uuid.UUID) (GetProjectBriefRow, error)
 	GetProjectByIDForUser(ctx context.Context, arg GetProjectByIDForUserParams) (Project, error)
 	GetProjectEnvironmentByName(ctx context.Context, arg GetProjectEnvironmentByNameParams) (Environment, error)
 	GetProjectOwner(ctx context.Context, id uuid.UUID) (uuid.UUID, error)
@@ -114,26 +88,13 @@ type Querier interface {
 	GetServiceAccess(ctx context.Context, id uuid.UUID) (GetServiceAccessRow, error)
 	GetServiceDomainDefault(ctx context.Context, serviceID uuid.UUID) (string, error)
 	GetServiceDomainFirst(ctx context.Context, serviceID uuid.UUID) (string, error)
-	GetServiceDomainText(ctx context.Context, id uuid.UUID) (string, error)
 	GetServiceEnvironment(ctx context.Context, id uuid.UUID) (string, error)
-	GetServiceForDeploy(ctx context.Context, id uuid.UUID) (GetServiceForDeployRow, error)
-	GetServiceForDeployWithOwner(ctx context.Context, id uuid.UUID) (GetServiceForDeployWithOwnerRow, error)
 	GetServicePlacementBrief(ctx context.Context, id uuid.UUID) (GetServicePlacementBriefRow, error)
-	GetServicePort(ctx context.Context, id uuid.UUID) (int32, error)
-	GetServicePublishedPort(ctx context.Context, id uuid.UUID) (int32, error)
-	GetServiceRuntimeWithOwner(ctx context.Context, id uuid.UUID) (GetServiceRuntimeWithOwnerRow, error)
-	GetServiceStatusText(ctx context.Context, id uuid.UUID) (string, error)
 	GetServiceTemplateByID(ctx context.Context, id string) (ServiceTemplate, error)
-	GetServiceTypeBrief(ctx context.Context, arg GetServiceTypeBriefParams) (GetServiceTypeBriefRow, error)
-	GetServiceVariableValue(ctx context.Context, arg GetServiceVariableValueParams) (string, error)
 	GetUserInviteByTokenHash(ctx context.Context, tokenHash string) (UserInvite, error)
 	GetUserTokenByHash(ctx context.Context, tokenHash string) (UserToken, error)
 	InsertAgentHeartbeat(ctx context.Context, arg InsertAgentHeartbeatParams) error
-	InsertCronExecution(ctx context.Context, arg InsertCronExecutionParams) error
-	InsertCronJob(ctx context.Context, arg InsertCronJobParams) error
-	InsertDeployment(ctx context.Context, arg InsertDeploymentParams) error
 	InsertNotificationChannel(ctx context.Context, arg InsertNotificationChannelParams) (NotificationChannel, error)
-	InsertPendingDeployment(ctx context.Context, arg InsertPendingDeploymentParams) error
 	InsertProjectEnvironment(ctx context.Context, arg InsertProjectEnvironmentParams) error
 	ListActiveBanners(ctx context.Context) ([]Banner, error)
 	ListAgentAuthTokens(ctx context.Context) ([]AgentAuthToken, error)
@@ -145,31 +106,23 @@ type Querier interface {
 	ListBanners(ctx context.Context) ([]Banner, error)
 	ListCommandsForAgent(ctx context.Context, nodeAgentID string) ([]AgentCommand, error)
 	ListContainersForAgent(ctx context.Context, nodeAgentID string) ([]ContainerInstance, error)
-	ListCronExecutions(ctx context.Context, cronJobID uuid.UUID) ([]CronExecution, error)
 	ListDatabaseBackupsByDatabaseAndUser(ctx context.Context, arg ListDatabaseBackupsByDatabaseAndUserParams) ([]DatabaseBackup, error)
 	ListDatabaseServicesByProject(ctx context.Context, projectID uuid.NullUUID) ([]DatabaseService, error)
 	ListDatabaseServicesByUser(ctx context.Context, userID string) ([]DatabaseService, error)
-	ListDeploymentsForService(ctx context.Context, arg ListDeploymentsForServiceParams) ([]ListDeploymentsForServiceRow, error)
-	ListDueCronJobs(ctx context.Context) ([]ListDueCronJobsRow, error)
 	ListDueDatabaseBackups(ctx context.Context) ([]ListDueDatabaseBackupsRow, error)
 	ListEnabledOutboundWebhooks(ctx context.Context) ([]OutboundWebhook, error)
-	ListExpiredPreviewsForUser(ctx context.Context, arg ListExpiredPreviewsForUserParams) ([]ListExpiredPreviewsForUserRow, error)
 	ListInstanceMetrics(ctx context.Context, arg ListInstanceMetricsParams) ([]ListInstanceMetricsRow, error)
-	ListNodeAgentsForService(ctx context.Context, serviceID string) ([]string, error)
 	ListNodeMetrics(ctx context.Context, arg ListNodeMetricsParams) ([]ListNodeMetricsRow, error)
 	ListNotificationChannelsByUser(ctx context.Context, userID uuid.UUID) ([]NotificationChannel, error)
 	ListNotificationsByUser(ctx context.Context, arg ListNotificationsByUserParams) ([]Notification, error)
 	ListOutboundWebhooksByUser(ctx context.Context, userID uuid.UUID) ([]OutboundWebhook, error)
 	ListPendingCommands(ctx context.Context, nodeAgentID string) ([]AgentCommand, error)
 	ListPendingProjects(ctx context.Context) ([]Project, error)
-	ListPreviewEnvironmentsForProject(ctx context.Context, projectID uuid.UUID) ([]ListPreviewEnvironmentsForProjectRow, error)
 	ListProjectEnvironments(ctx context.Context, projectID uuid.UUID) ([]ListProjectEnvironmentsRow, error)
-	ListProjectServiceRefs(ctx context.Context, projectID uuid.UUID) ([]ListProjectServiceRefsRow, error)
 	// Visibility model: a project is readable when it is approved for public
 	// display, when the caller owns or is a member of it, or when the caller is a
 	// platform admin. Anonymous callers pass user_id = uuid.Nil, is_admin = false.
 	ListProjectsWithStatsByUser(ctx context.Context, arg ListProjectsWithStatsByUserParams) ([]ListProjectsWithStatsByUserRow, error)
-	ListRecentAccessibleDeployments(ctx context.Context, arg ListRecentAccessibleDeploymentsParams) ([]ListRecentAccessibleDeploymentsRow, error)
 	// Base domains of every online, schedulable agent carrying the required
 	// placement tags — auto-domain candidates for spread services.
 	ListSchedulableAgentDomains(ctx context.Context, dollar_1 json.RawMessage) ([]string, error)
@@ -183,16 +136,11 @@ type Querier interface {
 	ListServiceMetrics(ctx context.Context, arg ListServiceMetricsParams) ([]ListServiceMetricsRow, error)
 	ListServiceTemplatesByCategoryForUser(ctx context.Context, arg ListServiceTemplatesByCategoryForUserParams) ([]ServiceTemplate, error)
 	ListServiceTemplatesForUser(ctx context.Context, ownerID uuid.NullUUID) ([]ServiceTemplate, error)
-	ListServiceVariableValues(ctx context.Context, serviceID uuid.UUID) ([]ListServiceVariableValuesRow, error)
-	ListServiceVariablesWithSecret(ctx context.Context, serviceID uuid.UUID) ([]ListServiceVariablesWithSecretRow, error)
-	ListSleepCandidates(ctx context.Context) ([]ListSleepCandidatesRow, error)
-	ListSweepablePreviews(ctx context.Context) ([]ListSweepablePreviewsRow, error)
 	ListUserInvites(ctx context.Context) ([]UserInvite, error)
 	ListUserTokens(ctx context.Context, userID uuid.UUID) ([]UserToken, error)
 	ListWebhookDeliveriesByWebhook(ctx context.Context, webhookID uuid.UUID) ([]WebhookDelivery, error)
 	MarkAllNotificationsReadByUser(ctx context.Context, arg MarkAllNotificationsReadByUserParams) error
 	MarkNotificationReadByIDAndUser(ctx context.Context, arg MarkNotificationReadByIDAndUserParams) error
-	MarkPreviewEnvironmentStatus(ctx context.Context, arg MarkPreviewEnvironmentStatusParams) error
 	MarkUserInviteUsed(ctx context.Context, arg MarkUserInviteUsedParams) error
 	MoveServiceProject(ctx context.Context, arg MoveServiceProjectParams) (int64, error)
 	// Resource-aware: lowest memory utilisation first, then cpu, then container
@@ -217,19 +165,12 @@ type Querier interface {
 	SetDatabaseServiceStatusAndConnectionByID(ctx context.Context, arg SetDatabaseServiceStatusAndConnectionByIDParams) error
 	SetDatabaseServiceStatusByID(ctx context.Context, arg SetDatabaseServiceStatusByIDParams) error
 	SetDatabaseServiceStatusByIDAndUser(ctx context.Context, arg SetDatabaseServiceStatusByIDAndUserParams) error
-	SetDeploymentStatus(ctx context.Context, arg SetDeploymentStatusParams) error
 	SetProjectApproved(ctx context.Context, arg SetProjectApprovedParams) (int64, error)
 	SetServiceDomainDefault(ctx context.Context, arg SetServiceDomainDefaultParams) (int64, error)
 	SetServiceLegacyDomain(ctx context.Context, arg SetServiceLegacyDomainParams) error
-	SetServicePublishedPort(ctx context.Context, arg SetServicePublishedPortParams) error
-	SetServiceReplicas(ctx context.Context, arg SetServiceReplicasParams) error
-	SetServiceStatus(ctx context.Context, arg SetServiceStatusParams) error
-	SyncDeploymentProgress(ctx context.Context, arg SyncDeploymentProgressParams) error
-	SyncPreviewStatuses(ctx context.Context) error
 	TouchAgentAuthToken(ctx context.Context, tokenHash string) error
 	TouchServiceDomainChecked(ctx context.Context, id uuid.UUID) error
 	TouchUserToken(ctx context.Context, id uuid.UUID) error
-	TrimCronExecutions(ctx context.Context, arg TrimCronExecutionsParams) error
 	UpdateAgent(ctx context.Context, arg UpdateAgentParams) (NodeAgent, error)
 	UpdateAgentHeartbeat(ctx context.Context, arg UpdateAgentHeartbeatParams) error
 	UpdateBackupTargetByIDAndUser(ctx context.Context, arg UpdateBackupTargetByIDAndUserParams) error
@@ -242,14 +183,11 @@ type Querier interface {
 	// removed replica. $4 is the cumulative rx+tx byte counter.
 	UpdateContainerStateByName(ctx context.Context, arg UpdateContainerStateByNameParams) error
 	UpdateContainerStatus(ctx context.Context, arg UpdateContainerStatusParams) error
-	UpdateCronJobRun(ctx context.Context, arg UpdateCronJobRunParams) error
 	UpdateDatabaseServiceNameAndPlanByIDAndUser(ctx context.Context, arg UpdateDatabaseServiceNameAndPlanByIDAndUserParams) error
 	UpdateDatabaseServiceNameByIDAndUser(ctx context.Context, arg UpdateDatabaseServiceNameByIDAndUserParams) error
 	UpdateDatabaseServicePlanByIDAndUser(ctx context.Context, arg UpdateDatabaseServicePlanByIDAndUserParams) error
 	UpdateOutboundWebhook(ctx context.Context, arg UpdateOutboundWebhookParams) error
-	UpdatePreviewEnvironment(ctx context.Context, arg UpdatePreviewEnvironmentParams) error
 	UpdateProjectByID(ctx context.Context, arg UpdateProjectByIDParams) (int64, error)
-	UpdateServicePreviewBranch(ctx context.Context, arg UpdateServicePreviewBranchParams) error
 	UpdateUserTemplate(ctx context.Context, arg UpdateUserTemplateParams) (int64, error)
 	UpdateWebhookDeliveryResult(ctx context.Context, arg UpdateWebhookDeliveryResultParams) error
 	UpsertEnvironmentVariable(ctx context.Context, arg UpsertEnvironmentVariableParams) error

app/backend/internal/database/sqlcdb/runtime.sql.go

@@ -1,355 +0,0 @@
-// Code generated by sqlc. DO NOT EDIT.
-// versions:
-//   sqlc v1.31.1
-// source: runtime.sql
-
-package sqlcdb
-
-import (
-	"context"
-	"database/sql"
-
-	"github.com/google/uuid"
-)
-
-const getLastDeployedImage = `-- name: GetLastDeployedImage :one
-SELECT (image_name || ':' || image_tag)::text AS image FROM deployments
-WHERE service_id = $1 AND status = 'deployed' AND image_name <> ''
-ORDER BY created_at DESC LIMIT 1
-`
-
-func (q *Queries) GetLastDeployedImage(ctx context.Context, serviceID uuid.UUID) (string, error) {
-	row := q.db.QueryRowContext(ctx, getLastDeployedImage, serviceID)
-	var image string
-	err := row.Scan(&image)
-	return image, err
-}
-
-const getServiceDomainText = `-- name: GetServiceDomainText :one
-SELECT COALESCE(domain,'') AS domain FROM services WHERE id = $1
-`
-
-func (q *Queries) GetServiceDomainText(ctx context.Context, id uuid.UUID) (string, error) {
-	row := q.db.QueryRowContext(ctx, getServiceDomainText, id)
-	var domain string
-	err := row.Scan(&domain)
-	return domain, err
-}
-
-const getServicePort = `-- name: GetServicePort :one
-SELECT COALESCE(port, 0) AS port FROM services WHERE id = $1
-`
-
-func (q *Queries) GetServicePort(ctx context.Context, id uuid.UUID) (int32, error) {
-	row := q.db.QueryRowContext(ctx, getServicePort, id)
-	var port int32
-	err := row.Scan(&port)
-	return port, err
-}
-
-const getServiceRuntimeWithOwner = `-- name: GetServiceRuntimeWithOwner :one
-SELECT s.id, s.project_id, s.name,
-       COALESCE(s.type, s.service_type, '') AS type, COALESCE(s.status, '') AS status,
-       COALESCE(s.image, s.image_name, '') AS image, COALESCE(s.command, s.start_command, '') AS command,
-       COALESCE(s.environment, '') AS environment, COALESCE(s.git_repo, s.source_url, '') AS git_repo,
-       COALESCE(s.git_branch, '') AS git_branch, COALESCE(s.build_path, '') AS build_path,
-       COALESCE(s.cpu, '') AS cpu, COALESCE(s.memory, '') AS memory,
-       COALESCE(s.replicas, 1) AS replicas, COALESCE(s.port, 0) AS port,
-       COALESCE(s.domain, '') AS domain, COALESCE(s.healthcheck_path, '') AS healthcheck_path,
-       COALESCE(s.restart_policy, 'unless-stopped') AS restart_policy,
-       COALESCE(s.builder, 'auto') AS builder, COALESCE(s.cpu_reserve, '') AS cpu_reserve,
-       COALESCE(s.memory_reserve, '') AS memory_reserve, COALESCE(s.static_build_cmd, '') AS static_build_cmd,
-       COALESCE(s.static_dir, '') AS static_dir,
-       s.created_at, s.updated_at, p.owner_id
-FROM services s
-JOIN projects p ON s.project_id = p.id
-WHERE s.id = $1
-`
-
-type GetServiceRuntimeWithOwnerRow struct {
-	ID              uuid.UUID    `json:"id"`
-	ProjectID       uuid.UUID    `json:"project_id"`
-	Name            string       `json:"name"`
-	Type            string       `json:"type"`
-	Status          string       `json:"status"`
-	Image           string       `json:"image"`
-	Command         string       `json:"command"`
-	Environment     string       `json:"environment"`
-	GitRepo         string       `json:"git_repo"`
-	GitBranch       string       `json:"git_branch"`
-	BuildPath       string       `json:"build_path"`
-	Cpu             string       `json:"cpu"`
-	Memory          string       `json:"memory"`
-	Replicas        int32        `json:"replicas"`
-	Port            int32        `json:"port"`
-	Domain          string       `json:"domain"`
-	HealthcheckPath string       `json:"healthcheck_path"`
-	RestartPolicy   string       `json:"restart_policy"`
-	Builder         string       `json:"builder"`
-	CpuReserve      string       `json:"cpu_reserve"`
-	MemoryReserve   string       `json:"memory_reserve"`
-	StaticBuildCmd  string       `json:"static_build_cmd"`
-	StaticDir       string       `json:"static_dir"`
-	CreatedAt       sql.NullTime `json:"created_at"`
-	UpdatedAt       sql.NullTime `json:"updated_at"`
-	OwnerID         uuid.UUID    `json:"owner_id"`
-}
-
-func (q *Queries) GetServiceRuntimeWithOwner(ctx context.Context, id uuid.UUID) (GetServiceRuntimeWithOwnerRow, error) {
-	row := q.db.QueryRowContext(ctx, getServiceRuntimeWithOwner, id)
-	var i GetServiceRuntimeWithOwnerRow
-	err := row.Scan(
-		&i.ID,
-		&i.ProjectID,
-		&i.Name,
-		&i.Type,
-		&i.Status,
-		&i.Image,
-		&i.Command,
-		&i.Environment,
-		&i.GitRepo,
-		&i.GitBranch,
-		&i.BuildPath,
-		&i.Cpu,
-		&i.Memory,
-		&i.Replicas,
-		&i.Port,
-		&i.Domain,
-		&i.HealthcheckPath,
-		&i.RestartPolicy,
-		&i.Builder,
-		&i.CpuReserve,
-		&i.MemoryReserve,
-		&i.StaticBuildCmd,
-		&i.StaticDir,
-		&i.CreatedAt,
-		&i.UpdatedAt,
-		&i.OwnerID,
-	)
-	return i, err
-}
-
-const getServiceStatusText = `-- name: GetServiceStatusText :one
-SELECT COALESCE(status,'') AS status FROM services WHERE id = $1
-`
-
-func (q *Queries) GetServiceStatusText(ctx context.Context, id uuid.UUID) (string, error) {
-	row := q.db.QueryRowContext(ctx, getServiceStatusText, id)
-	var status string
-	err := row.Scan(&status)
-	return status, err
-}
-
-const getServiceVariableValue = `-- name: GetServiceVariableValue :one
-SELECT value FROM environment_variables WHERE service_id = $1 AND key = $2
-`
-
-type GetServiceVariableValueParams struct {
-	ServiceID uuid.UUID `json:"service_id"`
-	Key       string    `json:"key"`
-}
-
-func (q *Queries) GetServiceVariableValue(ctx context.Context, arg GetServiceVariableValueParams) (string, error) {
-	row := q.db.QueryRowContext(ctx, getServiceVariableValue, arg.ServiceID, arg.Key)
-	var value string
-	err := row.Scan(&value)
-	return value, err
-}
-
-const listNodeAgentsForService = `-- name: ListNodeAgentsForService :many
-SELECT DISTINCT node_agent_id FROM container_instances WHERE service_id = $1
-`
-
-func (q *Queries) ListNodeAgentsForService(ctx context.Context, serviceID string) ([]string, error) {
-	rows, err := q.db.QueryContext(ctx, listNodeAgentsForService, serviceID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []string{}
-	for rows.Next() {
-		var node_agent_id string
-		if err := rows.Scan(&node_agent_id); err != nil {
-			return nil, err
-		}
-		items = append(items, node_agent_id)
-	}
-	if err := rows.Close(); err != nil {
-		return nil, err
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return items, nil
-}
-
-const listProjectServiceRefs = `-- name: ListProjectServiceRefs :many
-SELECT id, name FROM services WHERE project_id = $1
-`
-
-type ListProjectServiceRefsRow struct {
-	ID   uuid.UUID `json:"id"`
-	Name string    `json:"name"`
-}
-
-func (q *Queries) ListProjectServiceRefs(ctx context.Context, projectID uuid.UUID) ([]ListProjectServiceRefsRow, error) {
-	rows, err := q.db.QueryContext(ctx, listProjectServiceRefs, projectID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListProjectServiceRefsRow{}
-	for rows.Next() {
-		var i ListProjectServiceRefsRow
-		if err := rows.Scan(&i.ID, &i.Name); 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 listServiceVariableValues = `-- name: ListServiceVariableValues :many
-SELECT key, value FROM environment_variables WHERE service_id = $1
-`
-
-type ListServiceVariableValuesRow struct {
-	Key   string `json:"key"`
-	Value string `json:"value"`
-}
-
-func (q *Queries) ListServiceVariableValues(ctx context.Context, serviceID uuid.UUID) ([]ListServiceVariableValuesRow, error) {
-	rows, err := q.db.QueryContext(ctx, listServiceVariableValues, serviceID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListServiceVariableValuesRow{}
-	for rows.Next() {
-		var i ListServiceVariableValuesRow
-		if err := rows.Scan(&i.Key, &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 listServiceVariablesWithSecret = `-- name: ListServiceVariablesWithSecret :many
-SELECT key, value, COALESCE(is_secret, false) AS is_secret
-FROM environment_variables WHERE service_id = $1
-`
-
-type ListServiceVariablesWithSecretRow struct {
-	Key      string `json:"key"`
-	Value    string `json:"value"`
-	IsSecret bool   `json:"is_secret"`
-}
-
-func (q *Queries) ListServiceVariablesWithSecret(ctx context.Context, serviceID uuid.UUID) ([]ListServiceVariablesWithSecretRow, error) {
-	rows, err := q.db.QueryContext(ctx, listServiceVariablesWithSecret, serviceID)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListServiceVariablesWithSecretRow{}
-	for rows.Next() {
-		var i ListServiceVariablesWithSecretRow
-		if err := rows.Scan(&i.Key, &i.Value, &i.IsSecret); 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 listSleepCandidates = `-- name: ListSleepCandidates :many
-SELECT id, project_id, name, COALESCE(status,'') AS status,
-       COALESCE(sleep_idle_minutes, 15) AS sleep_idle_minutes
-FROM services
-WHERE sleep_enabled AND COALESCE(status,'') IN ('running','deployed','degraded','starting')
-`
-
-type ListSleepCandidatesRow struct {
-	ID               uuid.UUID `json:"id"`
-	ProjectID        uuid.UUID `json:"project_id"`
-	Name             string    `json:"name"`
-	Status           string    `json:"status"`
-	SleepIdleMinutes int32     `json:"sleep_idle_minutes"`
-}
-
-func (q *Queries) ListSleepCandidates(ctx context.Context) ([]ListSleepCandidatesRow, error) {
-	rows, err := q.db.QueryContext(ctx, listSleepCandidates)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-	items := []ListSleepCandidatesRow{}
-	for rows.Next() {
-		var i ListSleepCandidatesRow
-		if err := rows.Scan(
-			&i.ID,
-			&i.ProjectID,
-			&i.Name,
-			&i.Status,
-			&i.SleepIdleMinutes,
-		); 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 setServicePublishedPort = `-- name: SetServicePublishedPort :exec
-UPDATE services SET published_port = $1 WHERE id = $2 AND published_port <> $1
-`
-
-type SetServicePublishedPortParams struct {
-	PublishedPort int32     `json:"published_port"`
-	ID            uuid.UUID `json:"id"`
-}
-
-func (q *Queries) SetServicePublishedPort(ctx context.Context, arg SetServicePublishedPortParams) error {
-	_, err := q.db.ExecContext(ctx, setServicePublishedPort, arg.PublishedPort, arg.ID)
-	return err
-}
-
-const setServiceReplicas = `-- name: SetServiceReplicas :exec
-UPDATE services SET replicas = $1, updated_at = $2 WHERE id = $3
-`
-
-type SetServiceReplicasParams struct {
-	Replicas  int32        `json:"replicas"`
-	UpdatedAt sql.NullTime `json:"updated_at"`
-	ID        uuid.UUID    `json:"id"`
-}
-
-func (q *Queries) SetServiceReplicas(ctx context.Context, arg SetServiceReplicasParams) error {
-	_, err := q.db.ExecContext(ctx, setServiceReplicas, arg.Replicas, arg.UpdatedAt, arg.ID)
-	return err
-}

app/backend/sqlc/queries/cron.sql

@@ -1,58 +0,0 @@
--- name: GetCronJobProjectID :one
-SELECT project_id FROM cron_jobs WHERE id = $1;
-
--- name: GetCronOwnerViaService :one
-SELECT p.owner_id FROM projects p
-JOIN services s ON s.project_id = p.id
-WHERE s.id = $1;
-
--- name: InsertCronJob :exec
-INSERT INTO cron_jobs (id, project_id, service_id, name, schedule, command, timezone, enabled, next_run_at, retention, created_at, updated_at)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
-
--- name: GetCronJob :one
-SELECT id, project_id, service_id, name, schedule, command, timezone,
-       enabled, last_run_at, next_run_at, last_status, last_output,
-       retention, created_at, updated_at
-FROM cron_jobs WHERE id = $1;
-
--- name: GetCronJobOwner :one
-SELECT p.owner_id FROM cron_jobs cj
-JOIN projects p ON cj.project_id = p.id
-WHERE cj.id = $1;
-
--- name: DeleteCronJob :exec
-DELETE FROM cron_jobs WHERE id = $1;
-
--- name: ListCronExecutions :many
-SELECT id, cron_job_id, started_at, finished_at, status, output, error
-FROM cron_executions
-WHERE cron_job_id = $1
-ORDER BY started_at DESC
-LIMIT 100;
-
--- name: GetCronJobForTrigger :one
-SELECT cj.service_id, cj.command, cj.schedule, cj.timezone, cj.retention, p.owner_id
-FROM cron_jobs cj
-JOIN projects p ON cj.project_id = p.id
-WHERE cj.id = $1;
-
--- name: InsertCronExecution :exec
-INSERT INTO cron_executions (id, cron_job_id, started_at, status)
-VALUES ($1, $2, $3, $4);
-
--- name: ListDueCronJobs :many
-SELECT id, project_id, service_id, name, schedule, command, timezone, enabled, retention
-FROM cron_jobs
-WHERE enabled = TRUE AND next_run_at IS NOT NULL AND next_run_at <= NOW();
-
--- name: FinishCronExecution :exec
-UPDATE cron_executions SET finished_at = $1, status = $2, output = $3, error = $4 WHERE id = $5;
-
--- name: UpdateCronJobRun :exec
-UPDATE cron_jobs SET last_run_at = $1, last_status = $2, last_output = $3, next_run_at = $4 WHERE id = $5;
-
--- name: TrimCronExecutions :exec
-DELETE FROM cron_executions WHERE cron_executions.cron_job_id = $1 AND cron_executions.id NOT IN (
-    SELECT ce.id FROM cron_executions ce WHERE ce.cron_job_id = $1
-    ORDER BY ce.started_at DESC LIMIT $2);

app/backend/sqlc/queries/deployments.sql

@@ -1,105 +0,0 @@
--- name: CountDeploymentsForService :one
-SELECT COUNT(*) FROM deployments WHERE service_id = $1;
-
--- name: ListDeploymentsForService :many
-SELECT id, service_id, commit_hash, status, image_name, image_tag,
-       build_log, runtime_log, error, started_at, completed_at, created_at, updated_at
-FROM deployments
-WHERE service_id = $1
-ORDER BY created_at DESC
-LIMIT $2 OFFSET $3;
-
--- name: CountAccessibleDeployments :one
-SELECT COUNT(*)
-FROM deployments d
-JOIN services s ON s.id = d.service_id
-JOIN projects p ON p.id = s.project_id
-WHERE p.is_approved OR p.owner_id = $1 OR $2::bool
-   OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $1);
-
--- name: ListRecentAccessibleDeployments :many
-SELECT d.id, d.service_id, s.name AS service_name, p.name AS project_name, d.status,
-       COALESCE(d.image_name, '') AS image_name, d.started_at, d.completed_at, d.created_at
-FROM deployments d
-JOIN services s ON s.id = d.service_id
-JOIN projects p ON p.id = s.project_id
-WHERE p.is_approved OR p.owner_id = $1 OR $2::bool
-   OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $1)
-ORDER BY d.created_at DESC
-LIMIT $3 OFFSET $4;
-
--- name: GetServiceForDeployWithOwner :one
-SELECT s.id, s.project_id, s.name, s.type, s.status, s.image, s.command,
-       s.environment, s.git_repo, s.git_branch, s.build_path, s.cpu, s.memory,
-       COALESCE(s.replicas, 1) AS replicas, COALESCE(s.port, 0) AS port,
-       COALESCE(s.domain, '') AS domain, COALESCE(s.healthcheck_path, '') AS healthcheck_path,
-       COALESCE(s.restart_policy, 'unless-stopped') AS restart_policy,
-       COALESCE(s.builder, 'auto') AS builder, COALESCE(s.cpu_reserve, '') AS cpu_reserve,
-       COALESCE(s.memory_reserve, '') AS memory_reserve, COALESCE(s.static_build_cmd, '') AS static_build_cmd,
-       COALESCE(s.static_dir, '') AS static_dir,
-       s.created_at, s.updated_at, p.owner_id
-FROM services s
-JOIN projects p ON s.project_id = p.id
-WHERE s.id = $1;
-
--- name: InsertDeployment :exec
-INSERT INTO deployments
-    (id, service_id, version, commit_hash, status, image_name, image_tag, created_at, updated_at)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9);
-
--- name: FailDeployment :exec
-UPDATE deployments
-SET status = 'failed', error = $1, completed_at = $2, updated_at = $2
-WHERE id = $3;
-
--- name: CompleteDeployment :exec
-UPDATE deployments
-SET status = $1, error = $2, completed_at = $3, updated_at = $3
-WHERE id = $4;
-
--- name: SetDeploymentStatus :exec
-UPDATE deployments SET status = $1, updated_at = $2 WHERE id = $3;
-
--- name: SetServiceStatus :exec
-UPDATE services SET status = $1, updated_at = $2 WHERE id = $3;
-
--- name: SyncDeploymentProgress :exec
-UPDATE deployments
-SET status = $1,
-    image_name = $2,
-    image_tag = $3,
-    build_log = $4,
-    runtime_log = $5,
-    error = $6,
-    started_at = $7,
-    completed_at = $8,
-    updated_at = $9
-WHERE id = $10;
-
--- name: GetDeploymentAccess :one
-SELECT d.status, d.service_id, p.owner_id
-FROM deployments d
-JOIN services s ON d.service_id = s.id
-JOIN projects p ON s.project_id = p.id
-WHERE d.id = $1;
-
--- name: GetDeploymentWithProject :one
-SELECT d.id, d.service_id, d.commit_hash, d.status, d.image_name, d.image_tag,
-       d.build_log, d.runtime_log, d.error, d.started_at, d.completed_at,
-       d.created_at, d.updated_at, p.id AS project_id
-FROM deployments d
-JOIN services s ON d.service_id = s.id
-JOIN projects p ON s.project_id = p.id
-WHERE d.id = $1;
-
--- name: GetDeploymentForRollback :one
-SELECT d.id, d.service_id, d.commit_hash, d.status, d.image_name, d.image_tag,
-       d.build_log, d.runtime_log, d.error, d.started_at, d.completed_at,
-       d.created_at, d.updated_at, p.owner_id
-FROM deployments d
-JOIN services s ON d.service_id = s.id
-JOIN projects p ON s.project_id = p.id
-WHERE d.id = $1;
-
--- name: GetServicePublishedPort :one
-SELECT published_port FROM services WHERE id = $1;

app/backend/sqlc/queries/preview_environments.sql

@@ -1,121 +0,0 @@
--- name: ListPreviewEnvironmentsForProject :many
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.pr_number,
-       pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at,
-       s.id AS svc_id, s.name AS service_name, s.type AS service_type
-FROM preview_environments pe
-LEFT JOIN services s ON pe.service_id = s.id
-WHERE pe.project_id = $1
-ORDER BY pe.created_at DESC;
-
--- name: GetPreviewEnvironment :one
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.pr_number,
-       pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at,
-       s.id AS svc_id, s.name AS service_name, s.type AS service_type
-FROM preview_environments pe
-LEFT JOIN services s ON pe.service_id = s.id
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1 AND (p.is_approved OR p.owner_id = $2 OR $3::bool
-    OR EXISTS (SELECT 1 FROM project_members pm WHERE pm.project_id = p.id AND pm.user_id = $2));
-
--- name: GetPreviewEnvironmentForWrite :one
-SELECT pe.id, pe.project_id, pe.service_id, pe.branch_name, pe.pr_number,
-       pe.environment, pe.status, pe.url, pe.expires_at, pe.created_at, pe.updated_at
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1 AND (p.owner_id = $2 OR $3::bool);
-
--- name: GetPreviewEnvironmentForPromote :one
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.environment, pe.status
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1 AND (p.owner_id = $2 OR $3::bool);
-
--- name: GetPreviewEnvironmentOwner :one
-SELECT p.owner_id
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE pe.id = $1;
-
--- name: GetPreviewServiceID :one
-SELECT preview_service_id FROM preview_environments WHERE id = $1;
-
--- name: UpdatePreviewEnvironment :exec
-UPDATE preview_environments
-SET status = $1, url = $2, expires_at = $3, updated_at = $4
-WHERE id = $5;
-
--- name: MarkPreviewEnvironmentStatus :exec
-UPDATE preview_environments SET status = $1, updated_at = NOW() WHERE id = $2;
-
--- name: DeletePreviewEnvironment :exec
-DELETE FROM preview_environments WHERE id = $1;
-
--- name: CountActivePreviewsForBranch :one
-SELECT COUNT(*) FROM preview_environments
-WHERE service_id = $1 AND branch_name = $2 AND status NOT IN ('expired', 'stopped');
-
--- name: CreatePreviewEnvironment :exec
-INSERT INTO preview_environments
-    (id, project_id, service_id, preview_service_id, branch_name, pr_number, environment,
-     status, url, expires_at, created_at, updated_at)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
-
--- name: UpdateServicePreviewBranch :exec
-UPDATE services SET git_branch = $1, domain = '', updated_at = NOW() WHERE id = $2;
-
--- name: DeleteAllServiceDomains :exec
-DELETE FROM service_domains WHERE service_id = $1;
-
--- name: CreatePreviewDomain :exec
-INSERT INTO service_domains (service_id, domain, is_default, cert_type) VALUES ($1, $2, true, 'tls');
-
--- name: InsertPendingDeployment :exec
-INSERT INTO deployments (id, service_id, version, commit_hash, status, created_at, updated_at)
-VALUES ($1, $2, $3, $4, 'pending', NOW(), NOW());
-
--- name: ListExpiredPreviewsForUser :many
-SELECT pe.id, pe.project_id, pe.service_id, pe.preview_service_id, pe.branch_name, pe.environment
-FROM preview_environments pe
-JOIN projects p ON pe.project_id = p.id
-WHERE (p.owner_id = $1 OR $2::bool) AND pe.expires_at < NOW() AND pe.status != 'expired';
-
--- name: ListSweepablePreviews :many
-SELECT id, preview_service_id FROM preview_environments
-WHERE expires_at < NOW() AND status NOT IN ('expired', 'stopped');
-
--- name: SyncPreviewStatuses :exec
-UPDATE preview_environments pe
-SET status = derived.st, updated_at = NOW()
-FROM (
-    SELECT pe2.id,
-        CASE
-            WHEN s.status IN ('running', 'deployed') THEN 'running'
-            WHEN s.status IN ('failed', 'error') THEN 'failed'
-            WHEN s.status IN ('building', 'deploying', 'queued', 'pending', 'cloning') THEN 'building'
-            ELSE pe2.status
-        END AS st
-    FROM preview_environments pe2
-    JOIN services s ON pe2.preview_service_id = s.id
-) derived
-WHERE pe.id = derived.id
-  AND pe.status IN ('building', 'running', 'failed')
-  AND pe.status <> derived.st;
-
--- name: GetProjectBrief :one
-SELECT id, name, owner_id FROM projects WHERE id = $1;
-
--- name: GetServiceTypeBrief :one
-SELECT id, name, COALESCE(type, service_type, '') AS service_type FROM services WHERE id = $1 AND project_id = $2;
-
--- name: GetServiceForDeploy :one
-SELECT s.id, s.project_id, s.name, s.type, s.status, s.image, s.command,
-       s.environment, s.git_repo, s.git_branch, s.build_path, s.cpu, s.memory,
-       COALESCE(s.replicas, 1) AS replicas, COALESCE(s.port, 0) AS port,
-       COALESCE(s.domain, '') AS domain, COALESCE(s.healthcheck_path, '') AS healthcheck_path,
-       COALESCE(s.restart_policy, 'unless-stopped') AS restart_policy,
-       COALESCE(s.builder, 'auto') AS builder, COALESCE(s.cpu_reserve, '') AS cpu_reserve,
-       COALESCE(s.memory_reserve, '') AS memory_reserve, COALESCE(s.static_build_cmd, '') AS static_build_cmd,
-       COALESCE(s.static_dir, '') AS static_dir,
-       s.created_at, s.updated_at
-FROM services s
-WHERE s.id = $1;

app/backend/sqlc/queries/runtime.sql

@@ -1,59 +0,0 @@
--- name: ListNodeAgentsForService :many
-SELECT DISTINCT node_agent_id FROM container_instances WHERE service_id = $1;
-
--- name: ListServiceVariableValues :many
-SELECT key, value FROM environment_variables WHERE service_id = $1;
-
--- name: ListServiceVariablesWithSecret :many
-SELECT key, value, COALESCE(is_secret, false) AS is_secret
-FROM environment_variables WHERE service_id = $1;
-
--- name: ListProjectServiceRefs :many
-SELECT id, name FROM services WHERE project_id = $1;
-
--- name: GetServicePort :one
-SELECT COALESCE(port, 0) AS port FROM services WHERE id = $1;
-
--- name: GetServiceVariableValue :one
-SELECT value FROM environment_variables WHERE service_id = $1 AND key = $2;
-
--- name: GetServiceRuntimeWithOwner :one
-SELECT s.id, s.project_id, s.name,
-       COALESCE(s.type, s.service_type, '') AS type, COALESCE(s.status, '') AS status,
-       COALESCE(s.image, s.image_name, '') AS image, COALESCE(s.command, s.start_command, '') AS command,
-       COALESCE(s.environment, '') AS environment, COALESCE(s.git_repo, s.source_url, '') AS git_repo,
-       COALESCE(s.git_branch, '') AS git_branch, COALESCE(s.build_path, '') AS build_path,
-       COALESCE(s.cpu, '') AS cpu, COALESCE(s.memory, '') AS memory,
-       COALESCE(s.replicas, 1) AS replicas, COALESCE(s.port, 0) AS port,
-       COALESCE(s.domain, '') AS domain, COALESCE(s.healthcheck_path, '') AS healthcheck_path,
-       COALESCE(s.restart_policy, 'unless-stopped') AS restart_policy,
-       COALESCE(s.builder, 'auto') AS builder, COALESCE(s.cpu_reserve, '') AS cpu_reserve,
-       COALESCE(s.memory_reserve, '') AS memory_reserve, COALESCE(s.static_build_cmd, '') AS static_build_cmd,
-       COALESCE(s.static_dir, '') AS static_dir,
-       s.created_at, s.updated_at, p.owner_id
-FROM services s
-JOIN projects p ON s.project_id = p.id
-WHERE s.id = $1;
-
--- name: GetLastDeployedImage :one
-SELECT (image_name || ':' || image_tag)::text AS image FROM deployments
-WHERE service_id = $1 AND status = 'deployed' AND image_name <> ''
-ORDER BY created_at DESC LIMIT 1;
-
--- name: SetServicePublishedPort :exec
-UPDATE services SET published_port = $1 WHERE id = $2 AND published_port <> $1;
-
--- name: SetServiceReplicas :exec
-UPDATE services SET replicas = $1, updated_at = $2 WHERE id = $3;
-
--- name: ListSleepCandidates :many
-SELECT id, project_id, name, COALESCE(status,'') AS status,
-       COALESCE(sleep_idle_minutes, 15) AS sleep_idle_minutes
-FROM services
-WHERE sleep_enabled AND COALESCE(status,'') IN ('running','deployed','degraded','starting');
-
--- name: GetServiceDomainText :one
-SELECT COALESCE(domain,'') AS domain FROM services WHERE id = $1;
-
--- name: GetServiceStatusText :one
-SELECT COALESCE(status,'') AS status FROM services WHERE id = $1;

app/backend/sqlc/schema.sql

@@ -69,8 +69,6 @@ CREATE TABLE services (
     static_dir VARCHAR(255) NOT NULL DEFAULT '',
     node_id VARCHAR(255),
     spread BOOLEAN NOT NULL DEFAULT false,
-    sleep_enabled BOOLEAN NOT NULL DEFAULT false,
-    sleep_idle_minutes INTEGER NOT NULL DEFAULT 15,
     placement_tags JSONB NOT NULL DEFAULT '[]',
     traefik_labels JSONB NOT NULL DEFAULT '{}'
 );
@@ -100,37 +98,11 @@ CREATE TABLE service_domains (
 );
 
 CREATE TABLE deployments (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    id UUID PRIMARY KEY,
     service_id UUID NOT NULL REFERENCES services(id) ON DELETE CASCADE,
-    version VARCHAR(255) NOT NULL,
+    status VARCHAR(50),
-    commit_hash VARCHAR(255),
-    image_digest VARCHAR(255),
-    status VARCHAR(50) DEFAULT 'created',
-    build_log TEXT,
-    deployment_log TEXT,
-    started_at TIMESTAMPTZ,
-    completed_at TIMESTAMPTZ,
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-    image_name VARCHAR(255),
-    image_tag VARCHAR(255),
-    runtime_log TEXT,
-    error TEXT
-);
-
-CREATE TABLE preview_environments (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    project_id UUID NOT NULL,
-    service_id UUID NOT NULL,
-    branch_name VARCHAR(255) NOT NULL,
-    pr_number INTEGER,
-    environment VARCHAR(255) NOT NULL,
-    status VARCHAR(50) NOT NULL DEFAULT 'building',
-    url TEXT,
-    expires_at TIMESTAMPTZ NOT NULL,
-    created_at TIMESTAMPTZ DEFAULT now(),
-    updated_at TIMESTAMPTZ DEFAULT now(),
-    preview_service_id UUID
 );
 
 CREATE TABLE environment_variables (
@@ -461,31 +433,3 @@ CREATE TABLE instance_metrics (
     created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
     PRIMARY KEY (service_id, timestamp, instance_id)
 );
-
-CREATE TABLE cron_jobs (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    project_id UUID NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
-    service_id UUID NOT NULL REFERENCES services(id) ON DELETE CASCADE,
-    name VARCHAR(255) NOT NULL,
-    schedule VARCHAR(100) NOT NULL,
-    command TEXT NOT NULL,
-    timezone VARCHAR(50) DEFAULT 'UTC',
-    enabled BOOLEAN DEFAULT true,
-    last_run_at TIMESTAMP WITH TIME ZONE,
-    next_run_at TIMESTAMP WITH TIME ZONE,
-    last_status VARCHAR(50),
-    last_output TEXT,
-    retention INTEGER DEFAULT 30,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
-);
-
-CREATE TABLE cron_executions (
-    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-    cron_job_id UUID NOT NULL REFERENCES cron_jobs(id) ON DELETE CASCADE,
-    started_at TIMESTAMP WITH TIME ZONE NOT NULL,
-    finished_at TIMESTAMP WITH TIME ZONE,
-    status VARCHAR(50) DEFAULT 'pending',
-    output TEXT,
-    error TEXT
-);