@supatype/cli 0.1.0-alpha.10 → 0.1.0-alpha.12

package/src/commands/migrate.ts

@@ -1,11 +1,72 @@
 import type { Command } from "commander"
 import { createInterface } from "node:readline"
+import { join } from "node:path"
 import { loadConfig, loadSchemaAst } from "../config.js"
-import { connectionString, schemaPathFromProject } from "../project-config.js"
+import { connectionString, projectRootFromConfig, schemaPathFromProject } from "../project-config.js"
 import { ensureEngine, engineRequest } from "../engine-client.js"
+import { loadProjectLink } from "../link.js"
+import {
+  resolveTarget,
+  targetSchemaDiff,
+  targetSchemaRollback,
+  targetListMigrations,
+  schemaPgSchema,
+  type SchemaRollbackResult,
+} from "../resolve-target.js"
+import {
+  restoreSchemaSourcesFromGz,
+  findOrphanSchemaFiles,
+  type SchemaSourcesManifest,
+} from "../schema-sources.js"
 
 export function registerMigrate(program: Command): void {
-  // migrate — apply all pending migrations
+  const migrations = program
+    .command("migrations")
+    .description("Migration history utilities")
+
+  migrations
+    .command("list")
+    .description("List applied migrations with schema snapshot metadata")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess (skip control plane)")
+    .action(async (opts: { connection?: string; env?: string; direct?: boolean }) => {
+      const cwd = process.cwd()
+      const link = loadProjectLink(cwd)
+      const useDirect = opts.direct || Boolean(opts.connection)
+
+      let target
+      if (link && !useDirect && !opts.connection) {
+        target = resolveTarget(cwd, { env: opts.env })
+      } else {
+        target = resolveTarget(cwd, {
+          env: opts.env,
+          direct: true,
+          connection: opts.connection,
+        })
+      }
+
+      const list = await targetListMigrations(target)
+      if (list.length === 0) {
+        console.log("No migrations applied.")
+        return
+      }
+
+      for (const m of list) {
+        const manifest = m.schemaSourcesManifest
+        const size =
+          manifest?.compressedBytes !== undefined
+            ? `${(manifest.compressedBytes / 1024).toFixed(1)} KB`
+            : "—"
+        const files = manifest?.fileCount ?? "—"
+        const author = manifest?.pushedBy ?? "—"
+        const rolled = m.rolledBack ? " (rolled back)" : ""
+        console.log(
+          `${m.name}${rolled}\n  applied: ${m.appliedAt}  status: ${m.status}\n  author: ${author}  files: ${files}  snapshot: ${size}`,
+        )
+      }
+    })
+
   program
     .command("migrate")
     .description("Apply pending migrations from the migration history")
@@ -23,25 +84,46 @@ export function registerMigrate(program: Command): void {
       console.log(result.message ?? "Migrations applied.")
     })
 
-  // rollback — undo the last applied migration
   program
     .command("rollback")
     .description("Roll back the last applied migration")
     .option("--connection <url>", "Database connection URL (overrides config)")
-    .action(async (opts: { connection?: string }) => {
-      const config = loadConfig()
-      const connection = opts.connection ?? connectionString(config)
+    .option("--env <name>", "Target environment when linked")
+    .option("--direct", "Use local engine subprocess (skip control plane)")
+    .option("--sync-schema", "Restore schema source files from DB snapshot without prompting")
+    .option("--no-sync-schema", "Revert database only; do not restore schema files")
+    .action(async (opts: {
+      connection?: string
+      env?: string
+      direct?: boolean
+      syncSchema?: boolean
+      noSyncSchema?: boolean
+    }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const pgSchema = schemaPgSchema(cwd)
+      const link = loadProjectLink(cwd)
+      const useDirect = opts.direct || Boolean(opts.connection)
 
-      await ensureEngine()
-      const result = await engineRequest<{ message?: string }>("/migrations", {
-        database_url: connection,
-        schema: "public",
-        action: "rollback",
-      })
+      let target
+      if (link && !useDirect && !opts.connection) {
+        target = resolveTarget(cwd, { env: opts.env })
+      } else {
+        target = resolveTarget(cwd, {
+          env: opts.env,
+          direct: true,
+          connection: opts.connection,
+        })
+      }
+
+      const result = await targetSchemaRollback(target, { schema: pgSchema })
       console.log(result.message ?? "Rolled back.")
+
+      if (!opts.noSyncSchema) {
+        await offerSchemaRestore(cwd, config, target, result, pgSchema, opts.syncSchema ?? false)
+      }
     })
 
-  // reset — drop all tables and re-apply from scratch
   program
     .command("reset")
     .description(
@@ -76,12 +158,78 @@ export function registerMigrate(program: Command): void {
     })
 }
 
+async function offerSchemaRestore(
+  cwd: string,
+  config: ReturnType<typeof loadConfig>,
+  target: ReturnType<typeof resolveTarget>,
+  result: SchemaRollbackResult,
+  pgSchema: string,
+  autoSync: boolean,
+): Promise<void> {
+  const manifest = result.schemaSourcesManifest as SchemaSourcesManifest | undefined
+  const gzB64 = result.schemaSourcesBase64
+
+  if (!gzB64 || !manifest) {
+    console.warn(
+      "No schema source snapshot on the restored migration (legacy push). Run `supatype pull` to draft from DB if needed.",
+    )
+    return
+  }
+
+  const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+  const diff = await targetSchemaDiff(target, ast, { schema: pgSchema })
+  const drift = (diff.operations ?? []).length > 0
+
+  if (!drift && !autoSync) {
+    console.log("Schema files match reverted database (no restore needed).")
+    return
+  }
+
+  const fileList = manifest.files.map((f) => f.path).join(", ")
+  const sizeKb = (manifest.compressedBytes / 1024).toFixed(1)
+  const label = result.restoredMigrationName ?? result.name
+
+  let proceed = autoSync
+  if (!proceed) {
+    proceed = await confirm(
+      `\nRolled back migration ${result.name}.\nRestore ${manifest.fileCount} schema files from database snapshot (${sizeKb} KB)?\n  ${fileList}\n  [Y/n] `,
+    )
+  }
+
+  if (!proceed) {
+    console.log("Skipped schema file restore. Run `supatype diff` to review drift.")
+    return
+  }
+
+  const root = projectRootFromConfig(config, cwd)
+  const backupDir = join(cwd, ".supatype", "schema-backups", `${Date.now()}`)
+  const gz = Buffer.from(gzB64, "base64")
+  restoreSchemaSourcesFromGz(gz, manifest, root, { backupDir })
+
+  const manifestPaths = new Set(manifest.files.map((f) => f.path))
+  const orphans = findOrphanSchemaFiles(root, manifest.entryPoint, manifestPaths)
+  for (const orphan of orphans) {
+    console.warn(`Warning: ${orphan} not in snapshot — review manually`)
+  }
+
+  console.log(`Restored schema files from migration ${label}.`)
+  console.log(`Backup saved to ${backupDir}`)
+
+  const postDiff = await targetSchemaDiff(target, ast, { schema: pgSchema })
+  if ((postDiff.operations ?? []).length === 0) {
+    console.log("Schema matches database after restore.")
+  } else {
+    console.log("Run `supatype diff` — schema may still differ from database.")
+  }
+}
+
 async function confirm(prompt: string): Promise<boolean> {
   const rl = createInterface({ input: process.stdin, output: process.stdout })
-  return new Promise((resolve) => {
+  return new Promise((resolveConfirm) => {
     rl.question(prompt, (answer) => {
       rl.close()
-      resolve(answer.toLowerCase() === "y")
+      const trimmed = answer.trim().toLowerCase()
+      resolveConfirm(trimmed === "" || trimmed === "y" || trimmed === "yes")
     })
   })
 }

package/src/commands/pull.ts

@@ -1,17 +1,45 @@
 import type { Command } from "commander"
-import { ensureEngine } from "../engine-client.js"
+import { writeFileSync } from "node:fs"
+import { loadConfig } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
+import { ensureEngine, engineRequest } from "../engine-client.js"
+import { resolveHostEngineDatabaseUrl } from "../dev-compose.js"
+import { databaseStateToSchemaScaffold, type DatabaseStateJson } from "../pull-utils.js"
 
 export function registerPull(program: Command): void {
   program
     .command("pull")
-    .description(
-      "Introspect an existing Postgres database (deprecated in type-first mode)",
-    )
-    .action(async () => {
+    .description("Scaffold schema/index.ts from live database introspection (draft — review before push)")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .option("--out <path>", "Write scaffold to file (default: stdout)")
+    .option("--dry-run", "Print scaffold to stdout without writing files")
+    .action(async (opts: { connection?: string; out?: string; dryRun?: boolean }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const connection = await resolveHostEngineDatabaseUrl(cwd, config, opts.connection)
+      const pgSchema = config.schema?.pg_schema ?? "public"
+
       await ensureEngine()
-      throw new Error(
-        "The legacy `supatype pull` schema generator has been removed.\n" +
-          "Use type-based models with @supatype/types and run `supatype generate`.",
-      )
+
+      console.error("Introspecting database...")
+      const state = await engineRequest<DatabaseStateJson>("/introspect", {
+        database_url: connection,
+        schema: pgSchema,
+      })
+
+      const scaffold = databaseStateToSchemaScaffold(state)
+      const defaultOut = schemaPathFromProject(config, cwd)
+
+      if (opts.dryRun || !opts.out) {
+        console.log(scaffold)
+        if (!opts.dryRun && !opts.out) {
+          console.error("\n(draft printed to stdout — use --out to write a file)")
+        }
+        return
+      }
+
+      writeFileSync(opts.out ?? defaultOut, scaffold, "utf8")
+      console.log(`Wrote draft schema to ${opts.out ?? defaultOut}`)
+      console.log("Review access rules and relations, then run `supatype generate`.")
     })
 }

package/src/commands/push.ts

@@ -3,16 +3,29 @@ 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"
 
 const DEV_JWT_SECRET = "super-secret-jwt-token-with-at-least-32-characters-long"
 
@@ -24,202 +37,155 @@ 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()
+      const config = loadConfig(cwd)
+      const pgSchema = schemaPgSchema(cwd)
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), 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 })
+      const linked = loadProjectLink(cwd)
+      const useDirect = opts.direct || opts.local || Boolean(opts.connection)
+
+      if (linked && !useDirect && !opts.connection) {
+        const target = resolveTarget(cwd, { env: opts.env })
+        await pushViaTarget(cwd, config, target, ast, pgSchema, opts.yes ?? false)
         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") {
+      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 pushSchemaDocker(cwd, config)
         return
       }
 
-      const connection = opts.connection ?? connectionString(config)
-
-      await ensureEngine()
-
-      console.log("Loading schema...")
-      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 target = resolveTarget(cwd, {
+        env: opts.env,
+        direct: true,
+        connection: opts.connection,
       })
-
-      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)
-
-      // 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)
-      }
-
-      // 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 (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.")
-      }
+      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> {
+  console.log("Diffing against database...")
+  const diff = await targetSchemaDiff(target, ast, { schema: pgSchema })
+  const ops = diff.operations ?? []
+  printDiffWarnings(diff)
+
+  if (ops.length === 0) {
+    console.log("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) {
+      const confirmed = await confirm(
+        `\n${risky.length} risky operation(s) above. Proceed? [y/N] `,
+      )
+      if (!confirmed) {
+        console.log("Aborted.")
+        return
+      }
+    }
   }
-}
 
-function formatOperation(op: Operation): string {
-  if (typeof op.description === "string" && op.description.trim().length > 0) {
-    return op.description
+  console.log(ops.length > 0 ? "\nApplying migration..." : "\nSyncing with engine...")
+  const schemaSources = buildSchemaSourcesPayload(cwd, resolvePushedBy())
+  const pushResult = await targetSchemaPush(target, ast, {
+    force: true,
+    schema: pgSchema,
+    schemaSources,
+  })
+  if ((pushResult as { status?: string }).status === "up_to_date") {
+    console.log("Schema is up to date.")
+  } else {
+    console.log((pushResult as { message?: string }).message ?? "Migration applied.")
+    const migrationName = (pushResult as { name?: string }).name
+    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 {
+    console.log(`Pushed to ${target.mode} (${target.environment}).`)
   }
-  if (typeof table === "string") {
-    return `${kind} ${table}`
+
+  const baseUrl = (serverBaseUrl(config) ?? "").replace(/\/$/, "")
+  if (baseUrl) {
+    console.log(`\nStudio: ${baseUrl}/studio/`)
   }
+}
+
+async function generateTypesLocal(ast: unknown, config: SupatypeProjectConfig): Promise<void> {
+  if (!config.output?.types && !config.output?.client) return
+  console.log("Generating types...")
+  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)
+  console.log(genResult.message ?? "Types generated.")
+}
 
-  // Last resort: show operation kind with compact payload.
-  return `${kind} ${JSON.stringify(op)}`
+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)
 }
 
 async function confirm(prompt: string): Promise<boolean> {
   const rl = createInterface({ input: process.stdin, output: process.stdout })
-  return new Promise((resolve) => {
+  return new Promise((resolveConfirm) => {
     rl.question(prompt, (answer) => {
       rl.close()
-      resolve(answer.toLowerCase() === "y")
+      resolveConfirm(answer.toLowerCase() === "y")
     })
   })
 }
 
-/** 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`)