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>
2026-10-28 07:41:27 +00:00 · 2026-10-10 03:19:02 +02:00
14 changed files with 758 additions and 2794 deletions
@@ -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
@@ -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)
-	total, _ := q.CountDeploymentsForService(c.Request.Context(), serviceID)
+	var total int
+	_ = db.(*database.DB).QueryRow(
+		`SELECT COUNT(*) FROM deployments WHERE service_id = $1`, serviceID,
+	).Scan(&total)

-	rows, err := q.ListDeploymentsForService(c.Request.Context(), sqlcdb.ListDeploymentsForServiceParams{
-		ServiceID: serviceID, Limit: int32(limit), Offset: int32(offset)})
+	rows, err := db.(*database.DB).Query(
+		`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))
-	for _, r := range rows {
-		deployments = append(deployments, 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,
-		}))
+	var deployments []DeploymentModel
+	for rows.Next() {
+		var d DeploymentModel
+		err := rows.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,
+		)
+		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)
-	total, err := q.CountAccessibleDeployments(c.Request.Context(), sqlcdb.CountAccessibleDeploymentsParams{
-		OwnerID: userID, Column2: isAdmin})
-	if err != nil {
+	var total int
+	if err := db.(*database.DB).QueryRow(
+		`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)`,
+		userID, isAdmin,
+	).Scan(&total); err != nil {
 		total = 0
 	}

-	rows, err := q.ListRecentAccessibleDeployments(c.Request.Context(), sqlcdb.ListRecentAccessibleDeploymentsParams{
-		OwnerID: userID, Column2: isAdmin, Limit: int32(limit), Offset: int32(offset)})
+	rows, err := db.(*database.DB).Query(
+		`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))
-	for _, r := range rows {
-		deployments = append(deployments, RecentDeployment{
-			ID: r.ID, ServiceID: r.ServiceID, ServiceName: r.ServiceName,
-			ProjectName: r.ProjectName, Status: r.Status.String, ImageName: r.ImageName,
-			StartedAt: timePtrNT(r.StartedAt), CompletedAt: timePtrNT(r.CompletedAt),
-			CreatedAt: r.CreatedAt.Time,
-		})
+	deployments := []RecentDeployment{}
+	for rows.Next() {
+		var d RecentDeployment
+		if err := rows.Scan(&d.ID, &d.ServiceID, &d.ServiceName, &d.ProjectName,
+			&d.Status, &d.ImageName, &d.StartedAt, &d.CompletedAt, &d.CreatedAt); 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),
 	})
 }

@@ -265,27 +230,38 @@ func handleCreateDeployment(c *gin.Context) {
 		return
 	}

-	ctx := c.Request.Context()
-	q := sqlcdb.New(db.(*database.DB).DB)
-	sr, err := q.GetServiceForDeployWithOwner(ctx, serviceID)
+	var service Service
+	var projectOwner string
+	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{
-		ID:         d.ID,
-		ServiceID:  d.ServiceID,
-		Version:    fmt.Sprintf("v%d", now.Unix()),
-		CommitHash: sql.NullString{String: ptrStr(d.CommitHash), Valid: d.CommitHash != nil},
-		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},
-	})
+	_, err = db.(*database.DB).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)`,
+		d.ID, d.ServiceID, fmt.Sprintf("v%d", now.Unix()), d.CommitHash, d.Status, d.ImageName, d.ImageTag, d.CreatedAt, d.UpdatedAt,
+	)

 	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{
-			Error:       sql.NullString{String: unavailableErr, Valid: true},
-			CompletedAt: sql.NullTime{Time: completedAt, Valid: true},
-			ID:          d.ID,
-		})
+		_, _ = db.(*database.DB).Exec(
+			`UPDATE deployments
+			 SET status = 'failed', error = $1, completed_at = $2, updated_at = $2
+			 WHERE id = $3`,
+			unavailableErr, completedAt, d.ID,
+		)
 		d.Status = "failed"
 		d.Error = &unavailableErr
 		d.CompletedAt = &completedAt
 	} else {
-		err = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
-			Status:    sql.NullString{String: "building", Valid: true},
-			UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
-			ID:        serviceID,
-		})
+		_, err = db.(*database.DB).Exec(
+			`UPDATE services SET status = 'building', updated_at = $1 WHERE id = $2`,
+			time.Now(), 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()
-			_ = q.SetDeploymentStatus(ctx, sqlcdb.SetDeploymentStatusParams{
-				Status:    sql.NullString{String: "queued", Valid: true},
-				UpdatedAt: sql.NullTime{Time: now, Valid: true},
-				ID:        d.ID,
-			})
-			_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
-				Status:    sql.NullString{String: "queued", Valid: true},
-				UpdatedAt: sql.NullTime{Time: now, Valid: true},
-				ID:        serviceID,
-			})
+			_, _ = db.(*database.DB).Exec(
+				`UPDATE deployments SET status = 'queued', updated_at = $1 WHERE id = $2`,
+				time.Now(), d.ID,
+			)
+			_, _ = db.(*database.DB).Exec(
+				`UPDATE services SET status = 'queued', updated_at = $1 WHERE id = $2`,
+				time.Now(), 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{
-			Error:       sql.NullString{String: msg, Valid: true},
-			CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
-			ID:          dbDeployment.ID,
-		})
+		_, _ = db.Exec(
+			`UPDATE deployments SET status = 'failed', error = $1, completed_at = $2, updated_at = $2 WHERE id = $3`,
+			msg, failedAt, 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 {
-			ownerID = o.String()
-		}
+		_ = db.QueryRow(`SELECT owner_id FROM projects WHERE id = $1`, service.ProjectID).Scan(&ownerID)
 		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 {
-				ownerID = o.String()
-			}
+			_ = db.QueryRow(`SELECT owner_id FROM projects WHERE id = $1`, service.ProjectID).Scan(&ownerID)
 			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{
-			Error:       sql.NullString{String: msg, Valid: true},
-			CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
-			ID:          dbDeployment.ID,
-		})
+		_, _ = db.Exec(
+			`UPDATE deployments SET status = 'failed', error = $1, completed_at = $2, updated_at = $2 WHERE id = $3`,
+			msg, failedAt, 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{
-			Error:       sql.NullString{String: failure, Valid: true},
-			CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
-			ID:          dbDeployment.ID,
-		})
-		_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
-			Status:    sql.NullString{String: "failed", Valid: true},
-			UpdatedAt: sql.NullTime{Time: failedAt, Valid: true},
-			ID:        service.ID,
-		})
+		_, _ = db.Exec(
+			`UPDATE deployments
+			 SET status = 'failed', error = $1, completed_at = $2, updated_at = $2
+			 WHERE id = $3`,
+			failure, failedAt, dbDeployment.ID,
+		)
+		_, _ = db.Exec(
+			`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`,
+			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{
-				Status:      sql.NullString{String: finalStatus, Valid: true},
-				Error:       sql.NullString{String: finalErr, Valid: true},
-				CompletedAt: sql.NullTime{Time: failedAt, Valid: true},
-				ID:          dbDeployment.ID,
-			})
-			_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
-				Status:    sql.NullString{String: finalStatus, Valid: true},
-				UpdatedAt: sql.NullTime{Time: failedAt, Valid: true},
-				ID:        service.ID,
-			})
+			_, _ = db.Exec(
+				`UPDATE deployments
+				 SET status = $1, error = $2, completed_at = $3, updated_at = $3
+				 WHERE id = $4`,
+				finalStatus, finalErr, failedAt, dbDeployment.ID,
+			)
+			_, _ = db.Exec(
+				`UPDATE services SET status = $1, updated_at = $2 WHERE id = $3`,
+				finalStatus, failedAt, 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()
-			_ = q.SyncDeploymentProgress(ctx, sqlcdb.SyncDeploymentProgressParams{
-				Status:      sql.NullString{String: dbStatus, Valid: true},
-				ImageName:   sql.NullString{String: imageName, Valid: true},
-				ImageTag:    sql.NullString{String: imageTag, Valid: true},
-				BuildLog:    sql.NullString{String: current.BuildLog, Valid: true},
-				RuntimeLog:  sql.NullString{String: current.DeployLog, Valid: true},
-				Error:       sql.NullString{String: current.Error, Valid: current.Error != ""},
-				StartedAt:   ntPtr(current.StartedAt),
-				CompletedAt: ntPtr(current.CompletedAt),
-				UpdatedAt:   sql.NullTime{Time: now, Valid: true},
-				ID:          dbDeployment.ID,
-			})
+			var dbError interface{}
+			if current.Error != "" {
+				dbError = current.Error
+			}
+
+			_, _ = db.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`,
+				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{
-					Status:    sql.NullString{String: "running", Valid: true},
-					UpdatedAt: sql.NullTime{Time: now, Valid: true},
-					ID:        service.ID,
-				})
+				_, _ = db.Exec(
+					`UPDATE services SET status = 'running', updated_at = $1 WHERE id = $2`,
+					time.Now(), 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{
-					Status:    sql.NullString{String: "failed", Valid: true},
-					UpdatedAt: sql.NullTime{Time: now, Valid: true},
-					ID:        service.ID,
-				})
+				_, _ = db.Exec(
+					`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`,
+					time.Now(), 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()
-	q := sqlcdb.New(db.(*database.DB).DB)
-	access, err := q.GetDeploymentAccess(ctx, deploymentID)
+	var status, owner string
+	var serviceID uuid.UUID
+	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
-	status := access.Status.String
-	if access.OwnerID.String() != userID.(string) && !contextIsAdmin(c) {
+	if owner != 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{
-			Status:      sql.NullString{String: "cancelled", Valid: true},
-			Error:       sql.NullString{String: "Deployment cancelled", Valid: true},
-			CompletedAt: sql.NullTime{Time: now, Valid: true},
-			ID:          deploymentID,
-		})
-		_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
-			Status:    sql.NullString{String: "cancelled", Valid: true},
-			UpdatedAt: sql.NullTime{Time: now, Valid: true},
-			ID:        serviceID,
-		})
+		_, _ = db.(*database.DB).Exec(
+			`UPDATE deployments SET status = 'cancelled', error = 'Deployment cancelled', completed_at = $1, updated_at = $1 WHERE id = $2`,
+			now, deploymentID,
+		)
+		_, _ = db.(*database.DB).Exec(
+			`UPDATE services SET status = 'cancelled', updated_at = $1 WHERE id = $2`,
+			now, 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()
-	q := sqlcdb.New(db.(*database.DB).DB)
-	r, err := q.GetDeploymentForRollback(ctx, deploymentID)
+	var targetDeployment DeploymentModel
+	var serviceID uuid.UUID
+	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{
-		ID:         rollback.ID,
-		ServiceID:  rollback.ServiceID,
-		Version:    fmt.Sprintf("rollback-%d", now.Unix()),
-		CommitHash: sql.NullString{String: ptrStr(rollback.CommitHash), Valid: rollback.CommitHash != nil},
-		Status:     sql.NullString{String: rollback.Status, Valid: true},
-		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},
-	})
+	_, err = db.(*database.DB).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)`,
+		rollback.ID, rollback.ServiceID, fmt.Sprintf("rollback-%d", now.Unix()), rollback.CommitHash, rollback.Status,
+		rollback.ImageName, rollback.ImageTag, rollback.CreatedAt, rollback.UpdatedAt,
+	)

 	if err != nil {
 		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create rollback deployment"})
 		return
 	}

-	err = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
-		Status:    sql.NullString{String: "building", Valid: true},
-		UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
-		ID:        serviceID,
-	})
+	_, err = db.(*database.DB).Exec(
+		`UPDATE services SET status = 'building', updated_at = $1 WHERE id = $2`,
+		time.Now(), 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{
-			Error:       sql.NullString{String: reason, Valid: true},
-			CompletedAt: sql.NullTime{Time: completedAt, Valid: true},
-			ID:          rollbackID,
-		})
-		_ = q.SetServiceStatus(ctx, sqlcdb.SetServiceStatusParams{
-			Status:    sql.NullString{String: "failed", Valid: true},
-			UpdatedAt: sql.NullTime{Time: completedAt, Valid: true},
-			ID:        serviceID,
-		})
+		_, _ = db.(*database.DB).Exec(
+			`UPDATE deployments SET status = 'failed', error = $1, completed_at = $2, updated_at = $2 WHERE id = $3`,
+			reason, completedAt, rollbackID,
+		)
+		_, _ = db.(*database.DB).Exec(
+			`UPDATE services SET status = 'failed', updated_at = $1 WHERE id = $2`,
+			completedAt, 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 {
@@ -2,11 +2,9 @@ package api

 import (
 	"context"
-	"database/sql"
 	"os"
 	"strings"
 	"testing"
-	"time"

 	"containr/internal/database"
 	"containr/internal/database/sqlcdb"
@@ -225,352 +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)
-	}
-}
@@ -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))
-	for _, r := range rows {
-		environments = append(environments, previewFromRow(previewRowShape{
-			ID: r.ID, ProjectID: r.ProjectID, ServiceID: r.ServiceID,
-			PreviewServiceID: r.PreviewServiceID, BranchName: r.BranchName,
-			PrNumber: r.PrNumber, Environment: r.Environment, Status: r.Status,
-			Url: r.Url, ExpiresAt: r.ExpiresAt, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
-			SvcID: r.SvcID, ServiceName: r.ServiceName, ServiceType: r.ServiceType,
-		}))
+	var environments []PreviewEnvironment
+	for rows.Next() {
+		var env PreviewEnvironment
+		var serviceID sql.NullString
+		var serviceName sql.NullString
+		var serviceType sql.NullString
+
+		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{
-		ID: req.ServiceID, ProjectID: req.ProjectID})
+	var service Service
+	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{
-		ServiceID: req.ServiceID, BranchName: req.BranchName})
+	var count int
+	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{
-		GitBranch: sql.NullString{String: req.BranchName, Valid: true}, ID: cloneID}); err != nil {
-		_ = q.DeleteServiceByID(ctx, cloneID)
+	if _, err := db.(*database.DB).Exec(
+		`UPDATE services SET git_branch = $1, domain = '', updated_at = NOW() WHERE id = $2`,
+		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 {
-		_ = q.DeleteServiceByID(ctx, cloneID)
+	if _, err := db.(*database.DB).Exec(
+		`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{
-			ServiceID: cloneID, Domain: previewHost})
+		_, _ = db.(*database.DB).Exec(
+			`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{
-		ID:               env.ID,
-		ProjectID:        env.ProjectID,
-		ServiceID:        env.ServiceID,
-		PreviewServiceID: uuid.NullUUID{UUID: cloneID, Valid: true},
-		BranchName:       env.BranchName,
-		PrNumber:         prNumberSQL(env.PRNumber),
-		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},
-	})
+	_, err = db.(*database.DB).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)`,
+		env.ID, env.ProjectID, env.ServiceID, cloneID, env.BranchName, env.PRNumber,
+		env.Environment, env.Status, env.URL, env.ExpiresAt, env.CreatedAt, env.UpdatedAt,
+	)
 	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{
-		ID:         deploymentID,
-		ServiceID:  cloneID,
-		Version:    "preview-" + env.Environment,
-		CommitHash: sql.NullString{String: req.BranchName, Valid: true},
-	})
+	_, err = db.(*database.DB).Exec(
+		`INSERT INTO deployments
+			(id, service_id, version, commit_hash, status, created_at, updated_at)
+		 VALUES ($1, $2, $3, $4, 'pending', NOW(), NOW())`,
+		deploymentID, cloneID, "preview-"+env.Environment, req.BranchName,
+	)
 	if err != nil {
-		_ = q.DeletePreviewEnvironment(ctx, env.ID)
-		_ = q.DeleteServiceByID(ctx, cloneID)
+		_, _ = db.(*database.DB).Exec(`DELETE FROM preview_environments WHERE id = $1`, env.ID)
+		_, _ = 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(
-		c.Request.Context(), sqlcdb.GetPreviewEnvironmentParams{
-			ID: envID, OwnerID: userID, Column3: contextIsAdmin(c)})
+	var env PreviewEnvironment
+	var serviceID sql.NullString
+	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,
-		PreviewServiceID: r.PreviewServiceID, BranchName: r.BranchName,
-		PrNumber: r.PrNumber, Environment: r.Environment, Status: r.Status,
-		Url: r.Url, ExpiresAt: r.ExpiresAt, CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt,
-		SvcID: r.SvcID, ServiceName: r.ServiceName, ServiceType: r.ServiceType,
-	})
+
+	// Populate service info if available
+	if serviceID.Valid {
+		parsedServiceID, parseErr := uuid.Parse(serviceID.String)
+		if parseErr == nil {
+			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))
-	q := sqlcdb.New(db.(*database.DB).DB)
-	r, err := q.GetPreviewEnvironmentForWrite(
-		c.Request.Context(), sqlcdb.GetPreviewEnvironmentForWriteParams{
-			ID: envID, OwnerID: uid, Column3: contextIsAdmin(c)})
+	var existingEnv PreviewEnvironment
+	err = db.(*database.DB).QueryRow(
+		`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)`,
+		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{}
-	if existingEnv.ExpiresAt != nil {
-		expiresAt = *existingEnv.ExpiresAt
-	}
-	err = q.UpdatePreviewEnvironment(c.Request.Context(), sqlcdb.UpdatePreviewEnvironmentParams{
-		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,
-	})
+	_, err = db.(*database.DB).Exec(
+		`UPDATE preview_environments 
+			SET status = $1, url = $2, expires_at = $3, updated_at = $4
+			WHERE id = $5`,
+		existingEnv.Status, existingEnv.URL, existingEnv.ExpiresAt, existingEnv.UpdatedAt, 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))
-	r, err := q.GetPreviewEnvironmentForPromote(
-		ctx, sqlcdb.GetPreviewEnvironmentForPromoteParams{
-			ID: envID, OwnerID: uid, Column3: contextIsAdmin(c)})
+	var env PreviewEnvironment
+	err = db.(*database.DB).QueryRow(
+		`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)`,
+		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{
-		ID:         deploymentID,
-		ServiceID:  env.ServiceID,
-		Version:    promotionVersion,
-		CommitHash: sql.NullString{String: env.BranchName, Valid: true},
-	})
+	_, err = db.(*database.DB).Exec(
+		`INSERT INTO deployments (id, service_id, version, commit_hash, status, created_at, updated_at)
+		 VALUES ($1, $2, $3, $4, 'pending', NOW(), NOW())`,
+		deploymentID, env.ServiceID, promotionVersion, env.BranchName,
+	)
 	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{
-		Status: "stopped", ID: env.ID}); err != nil {
+	if _, err := db.(*database.DB).Exec(
+		`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{
-		OwnerID: uid, Column2: contextIsAdmin(c)})
+	rows, err := db.(*database.DB).Query(
+		`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))
-	for _, r := range rows {
-		env := PreviewEnvironment{
-			ID: r.ID, ProjectID: r.ProjectID, ServiceID: r.ServiceID,
-			BranchName: r.BranchName, Environment: r.Environment,
-		}
-		if r.PreviewServiceID.Valid {
-			id := r.PreviewServiceID.UUID
-			env.PreviewServiceID = &id
+	var expiredEnvs []PreviewEnvironment
+	for rows.Next() {
+		var env PreviewEnvironment
+		err := rows.Scan(
+			&env.ID, &env.ProjectID, &env.ServiceID, &env.PreviewServiceID, &env.BranchName, &env.Environment,
+		)
+		if err != nil {
+			continue
 		}
 		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{
-			Status: "expired", ID: env.ID}); err != nil {
+		_, err := db.(*database.DB).Exec(
+			"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)
-	ctx := context.Background()
-	brief, err := q.GetServicePlacementBrief(ctx, cloneID)
-	if err != nil {
+	var nodeID sql.NullString
+	var spread bool
+	if err := db.QueryRow(
+		`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)
-	if err != nil {
-		return Service{}, err
-	}
-	return serviceForDeployFromRow(r), nil
+	var service Service
+	err := 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,
+	)
+	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 := q.ListSweepablePreviews(ctx)
+	rows, err := db.QueryContext(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 {
-		ids = append(ids, r.ID)
-		if r.PreviewServiceID.Valid {
-			removeServiceRuntime(ctx, db, engine, r.PreviewServiceID.UUID)
-			_ = q.DeleteServiceByID(ctx, r.PreviewServiceID.UUID)
+	var clones []uuid.UUID
+	for rows.Next() {
+		var id uuid.UUID
+		var cloneID *uuid.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{
-			Status: "expired", ID: id})
+		_, _ = db.ExecContext(ctx,
+			`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
+	`)
 }
@@ -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))
-	for _, id := range ids {
-		if id != "" {
-			out = append(out, id)
+	defer rows.Close()
+	var ids []string
+	for rows.Next() {
+		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 {
-		spec.PublishedPort = p
-	}
+	_ = db.QueryRow(`SELECT published_port FROM services WHERE id = $1`, service.ID).Scan(&spec.PublishedPort)
 	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)
-	vars, err := q.ListServiceVariableValues(context.Background(), service.ID)
+	rows, err := db.Query(
+		`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 {
-		env[v.Key] = secrets.Decrypt(v.Value)
+	for rows.Next() {
+		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 {
-				return strconv.Itoa(int(port)), true
+			var port int
+			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{
-			ServiceID: id,
-			Key:       key,
-		})
+		var value string
+		err := db.QueryRow(
+			`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, service.ProjectID); !allowed {
+	if _, allowed := projectReadAccess(c, db, 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
-		image, err = sqlcdb.New(db.DB).GetLastDeployedImage(context.Background(), service.ID)
+		err := db.QueryRow(
+			`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
-		image, err = sqlcdb.New(db.DB).GetLastDeployedImage(context.Background(), service.ID)
-		if err != nil {
+		if err := db.QueryRow(
+			`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); 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{
-		PublishedPort: int32(ports[0]),
-		ID:            serviceID,
-	})
+	_, _ = db.Exec(
+		`UPDATE services SET published_port = $1 WHERE id = $2 AND published_port <> $1`,
+		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)
-	sid, err := uuid.Parse(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 {
 		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 != nil {
+		if err := db.QueryRow(
+			`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{
-		Replicas:  int32(replicas),
-		UpdatedAt: sql.NullTime{Time: time.Now(), Valid: true},
-		ID:        service.ID,
-	})
+	_, _ = db.Exec(`UPDATE services SET replicas = $1, updated_at = $2 WHERE id = $3`, replicas, time.Now(), service.ID)
 	return nil
 }

@@ -675,35 +750,48 @@ func handleServiceEnvCheck(c *gin.Context) {
 		return
 	}

-	q := sqlcdb.New(db.DB)
-	vars, err := q.ListServiceVariablesWithSecret(context.Background(), service.ID)
+	rows, err := db.Query(
+		`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 {
-		decrypted := secrets.Decrypt(v.Value)
-		if v.IsSecret && secrets.IsEncrypted(v.Value) && decrypted == v.Value {
+	for rows.Next() {
+		var k, v string
+		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{}
-	if refs, err := q.ListProjectServiceRefs(context.Background(), service.ProjectID); err == nil {
-		for _, s := range refs {
-			siblingIDs[strings.ToLower(s.Name)] = s.ID
+	siblingIDs := map[string]string{}
+	svcRows, err := db.Query(`SELECT id, name FROM services WHERE project_id = $1`, service.ProjectID)
+	if err == nil {
+		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 {
 		id, ok := siblingIDs[strings.ToLower(serviceName)]
@@ -714,14 +802,20 @@ func handleServiceEnvCheck(c *gin.Context) {
 			return true
 		}
 		if strings.EqualFold(key, "PORT") {
-			port, err := q.GetServicePort(context.Background(), id)
-			return err == nil && port > 0
+			var port int
+			if err := db.QueryRow(`SELECT COALESCE(port, 0) FROM services WHERE id = $1`, id).Scan(&port); err == nil {
+				return port > 0
 			}
-		_, err := q.GetServiceVariableValue(context.Background(), sqlcdb.GetServiceVariableValueParams{
-			ServiceID: id,
-			Key:       key,
-		})
-		return err == nil
+			return false
+		}
+		var n int
+		if err := db.QueryRow(
+			`SELECT COUNT(*) FROM environment_variables WHERE service_id = $1 AND key = $2`,
+			id, key,
+		).Scan(&n); err == nil {
+			return n > 0
+		}
+		return false
 	}

 	for _, kv := range raw {
@@ -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
-}
@@ -138,20 +138,9 @@ type DatabaseService struct {
 type Deployment struct {
 	ID        uuid.UUID      `json:"id"`
 	ServiceID uuid.UUID      `json:"service_id"`
-	Version       string         `json:"version"`
-	CommitHash    sql.NullString `json:"commit_hash"`
-	ImageDigest   sql.NullString `json:"image_digest"`
 	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 {
@@ -285,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"`
@@ -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
-}
@@ -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,14 +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
 	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
@@ -71,7 +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
 	GetActiveAgentAuthTokenByHash(ctx context.Context, tokenHash string) (AgentAuthToken, error)
 	GetAgent(ctx context.Context, id string) (NodeAgent, error)
 	GetAgentByHostAndIP(ctx context.Context, arg GetAgentByHostAndIPParams) (NodeAgent, error)
@@ -85,19 +76,9 @@ type Querier interface {
 	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)
@@ -108,21 +89,12 @@ type Querier interface {
 	GetServiceDomainDefault(ctx context.Context, serviceID uuid.UUID) (string, error)
 	GetServiceDomainFirst(ctx context.Context, serviceID 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)
 	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
-	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)
@@ -137,26 +109,20 @@ type Querier interface {
 	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)
 	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)
@@ -170,15 +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)
-	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
@@ -203,15 +165,9 @@ 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
@@ -231,9 +187,7 @@ type Querier interface {
 	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
@@ -1,289 +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 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 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 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
-}
@@ -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;
@@ -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;
@@ -1,47 +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;
@@ -98,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,
-    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,
+    status VARCHAR(50),
    created_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
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()
 );

 CREATE TABLE environment_variables (