@supatype/cli 0.1.0-alpha.8 → 0.1.0

package/src/commands/push.ts

@@ -1,17 +1,34 @@
 import type { Command } from "commander"
 import { mkdirSync, writeFileSync } from "node:fs"
-import { createInterface } from "node:readline"
 import { join } from "node:path"
 import { loadConfig, loadSchemaAst } from "../config.js"
-import { connectionString, resolveRuntimeProvider, schemaPathFromProject, serverBaseUrl } from "../project-config.js"
-import { isCloudLinked, pushSchemaToLinkedProject } from "./cloud.js"
-import { ensureEngine, engineRequest, type DiffResult, type Operation } from "../engine-client.js"
-import { printDiffWarnings } from "../diff-output.js"
+import { resolveRuntimeProvider, schemaPathFromProject, serverBaseUrl } from "../project-config.js"
+import { ensureEngine, engineRequest, type DiffResult } from "../engine-client.js"
+import { printDiffOperations, printDiffWarnings } from "../diff-output.js"
 import { signJwt } from "../jwt.js"
-import { provisionBuckets } from "../storage-provision.js"
+import { provisionBucketsFromAst } from "../storage-provision.js"
+import type { ExtractedSchemaAstV2 } from "../schema-ast-v2.js"
 import { promptFirstAdminUser } from "./admin.js"
 import { withAdminRoles } from "../studio-admin-roles.js"
+import { restoreSystemRelationTargets } from "../restore-system-relation-targets.js"
 import type { SupatypeProjectConfig } from "../project-config.js"
+import {
+  resolveTarget,
+  targetSchemaDiff,
+  targetSchemaPush,
+  schemaPgSchema,
+  type DeployTarget,
+} from "../resolve-target.js"
+import { loadProjectLink } from "../link.js"
+import {
+  buildSchemaSourcesPayload,
+  cacheSchemaSourcesLocally,
+  resolvePushedBy,
+} from "../schema-sources.js"
+import { confirm, logSkippedConfirm } from "../ui/confirm.js"
+import { info, plain } from "../ui/messages.js"
+import { withSpinner } from "../ui/progress.js"
+import { isInteractive } from "../ui/interactive.js"
 
 const DEV_JWT_SECRET = "super-secret-jwt-token-with-at-least-32-characters-long"
 
@@ -23,202 +40,158 @@ export function registerPush(program: Command): void {
     )
     .option("--yes", "Skip confirmation prompts for destructive changes")
     .option("--connection <url>", "Database connection URL (overrides config)")
-    .action(async (opts: { yes?: boolean; connection?: string }) => {
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess (skip control plane)")
+    .option("--local", "Alias for --direct")
+    .action(async (opts: {
+      yes?: boolean
+      connection?: string
+      env?: string
+      direct?: boolean
+      local?: boolean
+    }) => {
       const cwd = process.cwd()
-
-      if (isCloudLinked(cwd)) {
-        if (opts.connection) {
-          console.error("--connection is not allowed when linked to a cloud project (credentials stay server-side).")
-          process.exit(1)
-        }
-        await pushSchemaToLinkedProject(cwd, { force: opts.yes ?? true })
-        return
-      }
-
       const config = loadConfig(cwd)
-
-      // Docker provider: the compose Postgres isn't published to the host, so
-      // apply the schema through the in-compose schema-engine (unless the user
-      // gave an explicit --connection to a reachable database).
-      if (!opts.connection && resolveRuntimeProvider(config) === "docker") {
-        const { pushSchemaDocker } = await import("../dev-compose.js")
-        await pushSchemaDocker(cwd, config)
-        return
-      }
-
-      const connection = opts.connection ?? connectionString(config)
-
-      await ensureEngine()
-
-      console.log("Loading schema...")
+      const pgSchema = schemaPgSchema(cwd)
       const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
 
-      console.log("Diffing against database...")
-      const diff = await engineRequest<DiffResult>("/diff", {
-        ast,
-        database_url: connection,
-        schema: "public",
-      })
-
-      const ops = diff.operations ?? []
-      printDiffWarnings(diff)
-
-      if (ops.length === 0) {
-        console.log(
-          "Schema matches the database (no DDL). Syncing Studio metadata...",
-        )
-      } else {
-        printDiff(ops)
-
-        const risky = ops.filter(
-          (o) => o.risk === "cautious" || o.risk === "destructive" || o.risk === "warn" || o.risk === "danger",
-        )
-        if (risky.length > 0 && !opts.yes) {
-          const confirmed = await confirm(
-            `\n${risky.length} risky operation(s) above (type changes or data loss). Proceed? [y/N] `,
-          )
-          if (!confirmed) {
-            console.log("Aborted.")
-            return
-          }
-        }
-      }
-
-      console.log(ops.length > 0 ? "\nApplying migration..." : "\nSyncing with engine...")
-      const pushResult = await engineRequest<{
-        message?: string
-        status?: string
-        admin_refreshed?: boolean
-      }>("/push", {
-        ast,
-        database_url: connection,
-        schema: "public",
-        force: true,
-      })
-      if (pushResult.status === "up_to_date") {
-        console.log(
-          pushResult.admin_refreshed
-            ? "Database schema unchanged — Studio metadata synced."
-            : "Schema is up to date.",
-        )
-      } else {
-        console.log(pushResult.message ?? "Migration applied.")
-      }
-
-      await writeLocalAdminConfig(ast, config)
+      const linked = loadProjectLink(cwd)
+      const useDirect = opts.direct || opts.local || Boolean(opts.connection)
 
-      // After a DDL migration, check if this is the first push and offer to create an
-      // admin user if none exist (Gap Appendices task 48).
-      if (ops.length > 0) {
-        await promptFirstAdminUser(connection)
+      if (linked && !useDirect && !opts.connection) {
+        const target = resolveTarget(cwd, { env: opts.env })
+        await pushViaTarget(cwd, config, target, ast, pgSchema, opts.yes ?? false)
+        return
       }
 
-      // Provision storage buckets declared in the schema.
-      const baseUrl = serverBaseUrl(config)
-      const serviceRoleKey =
-        process.env["SUPATYPE_SERVICE_ROLE_KEY"] ??
-        (config.server.mode === "dev"
-          ? signJwt({ role: "service_role", iss: "supatype", iat: Math.floor(Date.now() / 1000) }, DEV_JWT_SECRET)
-          : undefined)
-
-      if (baseUrl && serviceRoleKey) {
-        const parsedAst = await engineRequest<{
-          storageBuckets?: Array<{
-            id: string
-            public: boolean
-            accessMode?: "public" | "private" | "custom"
-            allowedMimeTypes?: string[]
-            fileSizeLimit?: number
-            s3BucketPolicy?: string
-          }>
-        }>("/parse", { ast })
-        const buckets = (parsedAst.storageBuckets ?? []).map((b) => ({
-          id: b.id,
-          public: b.public,
-          ...(b.accessMode !== undefined && { access_mode: b.accessMode }),
-          ...(b.allowedMimeTypes != null && { allowed_mime_types: b.allowedMimeTypes }),
-          ...(b.fileSizeLimit != null && { file_size_limit: b.fileSizeLimit }),
-          ...(b.s3BucketPolicy != null &&
-            b.s3BucketPolicy !== "" && { s3_bucket_policy: b.s3BucketPolicy }),
-        }))
-        if (buckets.length > 0) {
-          console.log("Provisioning storage buckets...")
-          await provisionBuckets(`${baseUrl}/storage/v1`, serviceRoleKey, buckets)
+      if (!opts.connection && !useDirect && resolveRuntimeProvider(config) === "docker") {
+        const localTarget = resolveTarget(cwd, { env: opts.env })
+        if (localTarget.mode === "local" && localTarget.token) {
+          await pushViaTarget(cwd, config, localTarget, ast, pgSchema, opts.yes ?? false)
+          return
         }
+        const { pushSchemaDocker } = await import("../dev-compose.js")
+        await withSpinner("Applying schema via Docker Compose", () => pushSchemaDocker(cwd, config))
+        return
       }
 
-      if (config.output?.types ?? config.output?.client) {
-        console.log("Generating types...")
-        const genBody: Record<string, unknown> = { ast, lang: "typescript" }
-        if (config.output?.types) genBody["types_path"] = config.output.types
-        if (config.output?.client) genBody["client_path"] = config.output.client
-
-        const genResult = await engineRequest<{ code?: string; message?: string }>("/generate", genBody)
-        console.log(genResult.message ?? "Types generated.")
-      }
-
-      const studioBase = baseUrl?.replace(/\/$/, "") ?? ""
-      if (studioBase) {
-        console.log(`\nStudio: ${studioBase}/studio/ — sign in with the admin user you created.`)
-      } else {
-        console.log("\nDone.")
-      }
+      const target = resolveTarget(cwd, {
+        env: opts.env,
+        direct: true,
+        connection: opts.connection,
+      })
+      await pushViaTarget(cwd, config, target, ast, pgSchema, opts.yes ?? false)
     })
 }
 
-function printDiff(ops: Operation[]): void {
-  const symbol: Record<string, string> = {
-    safe: "+",
-    warn: "~",
-    cautious: "~",
-    danger: "!",
-    destructive: "!",
-  }
-  console.log(`\n${ops.length} change(s) planned:\n`)
-  for (const op of ops) {
-    const riskKey = op.risk ?? "safe"
-    const s = symbol[riskKey] ?? "?"
-    const label = op.warning ?? op.description ?? formatOperation(op)
-    console.log(`  [${s}] ${label}`)
+async function pushViaTarget(
+  cwd: string,
+  config: SupatypeProjectConfig,
+  target: DeployTarget,
+  ast: unknown,
+  pgSchema: string,
+  skipConfirm: boolean,
+): Promise<void> {
+  const diff = await withSpinner("Diffing against database", () =>
+    targetSchemaDiff(target, ast, { schema: pgSchema }),
+  )
+  const ops = diff.operations ?? []
+  printDiffWarnings(diff)
+
+  if (ops.length === 0) {
+    info("Schema matches the database (no DDL). Syncing Studio metadata...")
+  } else {
+    printDiffOperations({ operations: ops })
+    const risky = ops.filter(
+      (o) => o.risk === "cautious" || o.risk === "destructive" || o.risk === "warn" || o.risk === "danger",
+    )
+    if (risky.length > 0 && !skipConfirm) {
+      if (!isInteractive()) {
+        logSkippedConfirm(`${risky.length} risky operation(s) require confirmation`)
+        plain("Aborted.")
+        return
+      }
+      const confirmed = await confirm(
+        `${risky.length} risky operation(s) above. Proceed?`,
+        { default: false },
+      )
+      if (!confirmed) {
+        plain("Aborted.")
+        return
+      }
+    }
   }
-}
 
-function formatOperation(op: Operation): string {
-  if (typeof op.description === "string" && op.description.trim().length > 0) {
-    return op.description
+  const pushResult = await withSpinner(
+    ops.length > 0 ? "Applying migration" : "Syncing with engine",
+    () =>
+      targetSchemaPush(target, ast, {
+        force: true,
+        schema: pgSchema,
+        schemaSources: buildSchemaSourcesPayload(cwd, resolvePushedBy()),
+      }),
+  )
+
+  if ((pushResult as { status?: string }).status === "up_to_date") {
+    info("Schema is up to date.")
+  } else {
+    info((pushResult as { message?: string }).message ?? "Migration applied.")
+    const migrationName = (pushResult as { name?: string }).name
+    const schemaSources = buildSchemaSourcesPayload(cwd, resolvePushedBy())
+    if (migrationName && schemaSources) {
+      cacheSchemaSourcesLocally(cwd, migrationName, schemaSources.gz)
+    }
   }
 
-  const kind = typeof op.kind === "string" ? op.kind : "operation"
-  const raw = op as unknown as Record<string, unknown>
-  const table = raw["table"]
-  const column = raw["column"]
-
-  if (typeof table === "string" && typeof column === "string") {
-    return `${kind} ${table}.${column}`
+  if (target.mode === "direct" || target.mode === "local") {
+    await writeLocalAdminConfig(ast, config)
+    if (ops.length > 0 && target.databaseUrl) {
+      await promptFirstAdminUser(target.databaseUrl)
+    }
+    await generateTypesLocal(ast, config)
+    await provisionLocalStorage(ast, config)
+  } else {
+    info(`Pushed to ${target.mode} (${target.environment}).`)
   }
-  if (typeof table === "string") {
-    return `${kind} ${table}`
+
+  const baseUrl = (serverBaseUrl(config) ?? "").replace(/\/$/, "")
+  if (baseUrl) {
+    plain(`\nStudio: ${baseUrl}/studio/`)
   }
+}
 
-  // Last resort: show operation kind with compact payload.
-  return `${kind} ${JSON.stringify(op)}`
+async function generateTypesLocal(ast: unknown, config: SupatypeProjectConfig): Promise<void> {
+  if (!config.output?.types && !config.output?.client) return
+  await withSpinner("Generating types", async () => {
+    await ensureEngine()
+    const genBody: Record<string, unknown> = { ast, lang: "typescript" }
+    if (config.output?.types) genBody["types_path"] = config.output.types
+    if (config.output?.client) genBody["client_path"] = config.output.client
+    const genResult = await engineRequest<{ message?: string }>("/generate", genBody)
+    return genResult.message ?? "Types generated."
+  }).then((msg) => info(msg))
 }
 
-async function confirm(prompt: string): Promise<boolean> {
-  const rl = createInterface({ input: process.stdin, output: process.stdout })
-  return new Promise((resolve) => {
-    rl.question(prompt, (answer) => {
-      rl.close()
-      resolve(answer.toLowerCase() === "y")
-    })
-  })
+async function provisionLocalStorage(ast: unknown, config: SupatypeProjectConfig): Promise<void> {
+  const baseUrl = serverBaseUrl(config)
+  const serviceRoleKey =
+    process.env["SUPATYPE_SERVICE_ROLE_KEY"] ??
+    process.env["SERVICE_ROLE_KEY"] ??
+    (config.server.mode === "dev"
+      ? signJwt({ role: "service_role", iss: "supatype", iat: Math.floor(Date.now() / 1000) }, DEV_JWT_SECRET)
+      : undefined)
+  if (!baseUrl || !serviceRoleKey) return
+  await ensureEngine()
+  const parsedAst = await engineRequest<Pick<ExtractedSchemaAstV2, "storageBuckets">>("/parse", { ast })
+  await provisionBucketsFromAst(parsedAst, `${baseUrl}/storage/v1`, serviceRoleKey)
 }
 
-/** Write `.supatype/admin-config.json` for local Studio (same layout as `supatype dev`). */
 async function writeLocalAdminConfig(ast: unknown, config: SupatypeProjectConfig): Promise<void> {
   const cwd = process.cwd()
   const dir = join(cwd, ".supatype")
   mkdirSync(dir, { recursive: true })
+  await ensureEngine()
   const admin = withAdminRoles(await engineRequest<unknown>("/admin", { ast }), config)
+  restoreSystemRelationTargets(admin, ast)
   writeFileSync(join(dir, "admin-config.json"), `${JSON.stringify(admin, null, 2)}\n`)
 }

package/src/commands/seed.ts

@@ -5,6 +5,7 @@ import { isLinkedToCloudProject } from "../binary-cache.js"
 import { loadConfig } from "../config.js"
 import { projectRootFromConfig } from "../project-config.js"
 import { runTsFile } from "../tsx-runner.js"
+import { error, info } from "../ui/messages.js"
 
 const SEED_EXT = /\.(ts|mts|tsx)$/
 
@@ -31,8 +32,8 @@ export function registerSeed(program: Command): void {
       const cwd = process.cwd()
       const config = loadConfig(cwd)
       if (isLinkedToCloudProject(cwd, config) && !opts.force) {
-        console.error(
-          "[supatype] This project is linked to Supatype Cloud. Refusing to run seeds locally.\n" +
+        error(
+          "This project is linked to Supatype Cloud. Refusing to run seeds locally.\n" +
             "  Pass --force only if you intend to target this linked project (advanced).",
         )
         process.exit(1)
@@ -53,12 +54,12 @@ export function registerSeed(program: Command): void {
 
       const missing = paths.filter((p) => !existsSync(p))
       if (missing.length > 0) {
-        console.error(`Seed file(s) not found:\n  ${missing.join("\n  ")}`)
+        error(`Seed file(s) not found:\n  ${missing.join("\n  ")}`)
         process.exit(1)
       }
 
       for (const seedFile of paths) {
-        console.log(`[supatype] Running ${seedFile}...`)
+        info(`Running ${seedFile}...`)
         const result = runTsFile(seedFile, { cwd, stdio: "inherit" })
         if (result.exitCode !== 0) {
           process.exit(result.exitCode)