@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/commands/migrate.ts

@@ -1,11 +1,73 @@
 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"
+import { confirm } from "../ui/confirm.js"
+import { info, plain, warn } from "../ui/messages.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) {
+        info("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)" : ""
+        plain(
+          `${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")
@@ -20,28 +82,49 @@ export function registerMigrate(program: Command): void {
         schema: "public",
         action: "pending",
       })
-      console.log(result.message ?? "Migrations applied.")
+      info(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",
-      })
-      console.log(result.message ?? "Rolled back.")
+      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 })
+      info(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(
@@ -52,10 +135,11 @@ export function registerMigrate(program: Command): void {
     .action(async (opts: { yes?: boolean; connection?: string }) => {
       if (!opts.yes) {
         const confirmed = await confirm(
-          "This will DROP all managed tables and re-apply the schema. Proceed? [y/N] ",
+          "This will DROP all managed tables and re-apply the schema. Proceed?",
+          { default: false },
         )
         if (!confirmed) {
-          console.log("Aborted.")
+          plain("Aborted.")
           return
         }
       }
@@ -72,16 +156,72 @@ export function registerMigrate(program: Command): void {
         schema: "public",
         force: true,
       })
-      console.log(result.message ?? "Reset complete.")
+      info(result.message ?? "Reset complete.")
     })
 }
 
-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 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) {
+    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) {
+    info("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(
+      `Restore ${manifest.fileCount} schema files from database snapshot (${sizeKb} KB)?\n  ${fileList}`,
+      { default: true },
+    )
+  }
+
+  if (!proceed) {
+    info("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) {
+    warn(`${orphan} not in snapshot — review manually`)
+  }
+
+  info(`Restored schema files from migration ${label}.`)
+  info(`Backup saved to ${backupDir}`)
+
+  const postDiff = await targetSchemaDiff(target, ast, { schema: pgSchema })
+  if ((postDiff.operations ?? []).length === 0) {
+    info("Schema matches database after restore.")
+  } else {
+    info("Run `supatype diff` — schema may still differ from database.")
+  }
 }

package/src/commands/pg.ts

@@ -11,6 +11,8 @@ import { homedir } from "node:os"
 import { join } from "node:path"
 import { loadConfig } from "../config.js"
 import { resolveBinary } from "../binary-cache.js"
+import { confirm } from "../ui/confirm.js"
+import { info, plain } from "../ui/messages.js"
 import {
   initdb,
   start as pgStart,
@@ -32,9 +34,7 @@ export function registerPg(program: Command): void {
       initdb(opts)
       pgStart(opts)
       await waitReady(opts, 10_000)
-      console.log(
-        `[supatype] Postgres started on port ${opts.port} (data: ${opts.dataDir})`,
-      )
+      info(`Postgres started on port ${opts.port} (data: ${opts.dataDir})`)
     })
 
   // ── stop ─────────────────────────────────────────────────────────────────
@@ -44,7 +44,7 @@ export function registerPg(program: Command): void {
       const config = loadConfig()
       const opts = await pgOpts(config)
       pgStop(opts)
-      console.log("[supatype] Postgres stopped.")
+      info("Postgres stopped.")
     })
 
   // ── reset ─────────────────────────────────────────────────────────────────
@@ -56,17 +56,12 @@ export function registerPg(program: Command): void {
       const pgOpts_ = await pgOpts(config)
 
       if (!opts.force) {
-        const readline = await import("node:readline")
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
-        const answer = await new Promise<string>((resolve) =>
-          rl.question(
-            `This will DELETE all data in ${pgOpts_.dataDir}. Continue? [y/N] `,
-            resolve,
-          ),
+        const ok = await confirm(
+          `This will DELETE all data in ${pgOpts_.dataDir}. Continue?`,
+          { default: false },
         )
-        rl.close()
-        if (answer.toLowerCase() !== "y") {
-          console.log("Aborted.")
+        if (!ok) {
+          plain("Aborted.")
           return
         }
       }
@@ -74,13 +69,13 @@ export function registerPg(program: Command): void {
       pgStop(pgOpts_)
       if (existsSync(pgOpts_.dataDir)) {
         rmSync(pgOpts_.dataDir, { recursive: true, force: true })
-        console.log(`[supatype] Data directory removed: ${pgOpts_.dataDir}`)
+        info(`Data directory removed: ${pgOpts_.dataDir}`)
       }
       mkdirSync(pgOpts_.dataDir, { recursive: true })
       initdb(pgOpts_)
       pgStart(pgOpts_)
       await waitReady(pgOpts_, 10_000)
-      console.log("[supatype] Postgres reset and started.")
+      info("Postgres reset and started.")
     })
 
   // ── psql ─────────────────────────────────────────────────────────────────
@@ -118,9 +113,9 @@ async function pgOpts(
   const pgCacheDir = await (async () => {
     const override = config.overrides?.postgres_dir
     if (override) return join(override, "bin")
-    const { cachePath, currentPlatform } = await import("../binary-cache.js")
+    const { cachePath, currentPlatform, resolveVersionFor } = await import("../binary-cache.js")
     const platform = currentPlatform()
-    const version = config.versions.postgres
+    const version = await resolveVersionFor("postgres", config)
     return join(cachePath("postgres", version), `pg-${version}`, "bin")
   })()
 

package/src/commands/plugins.ts

@@ -2,6 +2,8 @@ import type { Command } from "commander"
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from "node:fs"
 import { resolve, join } from "node:path"
 import { spawnSync } from "node:child_process"
+import { error, info, plain, warn } from "../ui/messages.js"
+import { nextSteps } from "../ui/next-steps.js"
 
 // ─── Registration ────────────────────────────────────────────────────────────
 
@@ -61,27 +63,30 @@ function listPlugins(cwd: string): void {
   const plugins = discoverInstalledPlugins(cwd)
 
   if (plugins.length === 0) {
-    console.log("No Supatype plugins installed.")
-    console.log("\nSearch for plugins:  npx supatype plugins search <query>")
-    console.log("Create a plugin:    npx supatype plugins create")
+    info("No Supatype plugins installed.")
+    nextSteps("Try:", [
+      "Search for plugins:  npx supatype plugins search <query>",
+      "Create a plugin:    npx supatype plugins create",
+    ])
     return
   }
 
-  console.log("Installed plugins:\n")
-  console.log(`  ${"Name".padEnd(35)} ${"Type".padEnd(14)} ${"Version".padEnd(12)} Status`)
-  console.log(`  ${"─".repeat(35)} ${"─".repeat(14)} ${"─".repeat(12)} ${"─".repeat(15)}`)
+  plain("Installed plugins:\n")
+  plain(`  ${"Name".padEnd(35)} ${"Type".padEnd(14)} ${"Version".padEnd(12)} Status`)
+  plain(`  ${"─".repeat(35)} ${"─".repeat(14)} ${"─".repeat(12)} ${"─".repeat(15)}`)
 
   for (const p of plugins) {
     const types = p.supatype?.types?.join(", ") ?? "unknown"
     const status = p.compatible ? "active" : "incompatible"
-    console.log(`  ${p.name.padEnd(35)} ${types.padEnd(14)} ${p.version.padEnd(12)} ${status}`)
+    plain(`  ${p.name.padEnd(35)} ${types.padEnd(14)} ${p.version.padEnd(12)} ${status}`)
   }
 }
 
 // ─── Search ──────────────────────────────────────────────────────────────────
 
 async function searchPlugins(query: string): Promise<void> {
-  console.log(`Searching npm for "${query}" supatype plugins...\n`)
+  info(`Searching npm for "${query}" supatype plugins...`)
+  plain()
 
   try {
     const searchUrl = `https://registry.npmjs.org/-/v1/search?text=supatype-plugin+${encodeURIComponent(query)}&size=20`
@@ -90,7 +95,7 @@ async function searchPlugins(query: string): Promise<void> {
     })
 
     if (!res.ok) {
-      console.error(`Search failed: ${res.statusText}`)
+      error(`Search failed: ${res.statusText}`)
       return
     }
 
@@ -107,31 +112,33 @@ async function searchPlugins(query: string): Promise<void> {
     }
 
     if (data.objects.length === 0) {
-      console.log("No plugins found.")
-      console.log("\nTry a different search term, or create your own plugin:")
-      console.log("  npx supatype plugins create")
+      info("No plugins found.")
+      nextSteps("Try:", [
+        "Try a different search term, or create your own plugin:",
+        "  npx supatype plugins create",
+      ])
       return
     }
 
-    console.log(`  ${"Package".padEnd(40)} ${"Version".padEnd(12)} Description`)
-    console.log(`  ${"─".repeat(40)} ${"─".repeat(12)} ${"─".repeat(40)}`)
+    plain(`  ${"Package".padEnd(40)} ${"Version".padEnd(12)} Description`)
+    plain(`  ${"─".repeat(40)} ${"─".repeat(12)} ${"─".repeat(40)}`)
 
     for (const obj of data.objects) {
       const pkg = obj.package
       const desc = (pkg.description ?? "").slice(0, 50)
-      console.log(`  ${pkg.name.padEnd(40)} ${pkg.version.padEnd(12)} ${desc}`)
+      plain(`  ${pkg.name.padEnd(40)} ${pkg.version.padEnd(12)} ${desc}`)
     }
 
-    console.log(`\nInstall: npx supatype plugins add <package-name>`)
+    info("Install: npx supatype plugins add <package-name>")
   } catch (err) {
-    console.error(`Error: ${err instanceof Error ? err.message : "unknown"}`)
+    error(`Error: ${err instanceof Error ? err.message : "unknown"}`)
   }
 }
 
 // ─── Add ─────────────────────────────────────────────────────────────────────
 
 function addPlugin(cwd: string, pkg: string): void {
-  console.log(`Installing ${pkg}...`)
+  info(`Installing ${pkg}...`)
 
   // Detect package manager
   const pm = detectPackageManager(cwd)
@@ -145,7 +152,7 @@ function addPlugin(cwd: string, pkg: string): void {
   })
 
   if (result.status !== 0) {
-    console.error(`Failed to install ${pkg}`)
+    error(`Failed to install ${pkg}`)
     process.exit(1)
   }
 
@@ -158,14 +165,14 @@ function addPlugin(cwd: string, pkg: string): void {
     if (supatype?.["pluginApi"] !== undefined) {
       const pluginApi = supatype["pluginApi"] as number
       if (pluginApi !== 1) {
-        console.warn(`\nWarning: ${pkg} targets plugin API v${pluginApi}, current is v1.`)
-        console.warn("The plugin may not work correctly.")
+        warn(`${pkg} targets plugin API v${pluginApi}, current is v1.`)
+        warn("The plugin may not work correctly.")
       }
     }
   }
 
-  console.log(`\n${pkg} installed and registered.`)
-  console.log("Run 'npx supatype plugins list' to see active plugins.")
+  info(`${pkg} installed and registered.`)
+  info("Run 'npx supatype plugins list' to see active plugins.")
 }
 
 // ─── Remove ──────────────────────────────────────────────────────────────────
@@ -177,12 +184,13 @@ function removePlugin(cwd: string, pkg: string): void {
   for (const file of schemaFiles) {
     const content = readFileSync(file, "utf8")
     if (content.includes(pkg)) {
-      console.warn(`Warning: ${pkg} appears to be referenced in ${file}`)
-      console.warn("Removing it may break your schema. Proceed with caution.\n")
+      warn(`${pkg} appears to be referenced in ${file}`)
+      warn("Removing it may break your schema. Proceed with caution.")
+      plain()
     }
   }
 
-  console.log(`Removing ${pkg}...`)
+  info(`Removing ${pkg}...`)
 
   const pm = detectPackageManager(cwd)
   const removeCmd = pm === "pnpm" ? ["pnpm", "remove", pkg]
@@ -195,11 +203,11 @@ function removePlugin(cwd: string, pkg: string): void {
   })
 
   if (result.status !== 0) {
-    console.error(`Failed to remove ${pkg}`)
+    error(`Failed to remove ${pkg}`)
     process.exit(1)
   }
 
-  console.log(`${pkg} removed.`)
+  info(`${pkg} removed.`)
 }
 
 // ─── Create ──────────────────────────────────────────────────────────────────
@@ -207,7 +215,7 @@ function removePlugin(cwd: string, pkg: string): void {
 function createPlugin(cwd: string, opts: { type: string; name?: string }): void {
   const validTypes = ["field", "composite", "provider", "widget"]
   if (!validTypes.includes(opts.type)) {
-    console.error(`Invalid plugin type "${opts.type}". Must be one of: ${validTypes.join(", ")}`)
+    error(`Invalid plugin type "${opts.type}". Must be one of: ${validTypes.join(", ")}`)
     process.exit(1)
   }
 
@@ -215,7 +223,7 @@ function createPlugin(cwd: string, opts: { type: string; name?: string }): void
   const pluginDir = resolve(cwd, name)
 
   if (existsSync(pluginDir)) {
-    console.error(`Directory "${name}" already exists.`)
+    error(`Directory "${name}" already exists.`)
     process.exit(1)
   }
 
@@ -273,16 +281,17 @@ function createPlugin(cwd: string, opts: { type: string; name?: string }): void
   const sourceContent = generatePluginTemplate(opts.type, name)
   writeFileSync(join(pluginDir, "src/index.ts"), sourceContent, "utf8")
 
-  console.log(`\nCreated plugin project: ${name}/\n`)
-  console.log("  Files:")
-  console.log(`    ${name}/package.json`)
-  console.log(`    ${name}/tsconfig.json`)
-  console.log(`    ${name}/src/index.ts`)
-  console.log(`\n  Next steps:`)
-  console.log(`    cd ${name}`)
-  console.log(`    npm install`)
-  console.log(`    npm run build`)
-  console.log(`    npx supatype plugins validate`)
+  info(`Created plugin project: ${name}/`)
+  plain("\n  Files:")
+  plain(`    ${name}/package.json`)
+  plain(`    ${name}/tsconfig.json`)
+  plain(`    ${name}/src/index.ts`)
+  nextSteps("Next steps:", [
+    `cd ${name}`,
+    "npm install",
+    "npm run build",
+    "npx supatype plugins validate",
+  ])
 }
 
 function generatePluginTemplate(type: string, name: string): string {
@@ -375,7 +384,7 @@ function validatePlugins(cwd: string): void {
   const plugins = discoverInstalledPlugins(cwd)
 
   if (plugins.length === 0) {
-    console.log("No plugins to validate.")
+    info("No plugins to validate.")
     return
   }
 
@@ -398,21 +407,21 @@ function validatePlugins(cwd: string): void {
     }
 
     if (issues.length === 0) {
-      console.log(`  ✓ ${p.name} — valid`)
+      plain(`  ✓ ${p.name} — valid`)
     } else {
       hasErrors = true
-      console.log(`  ✗ ${p.name}`)
+      plain(`  ✗ ${p.name}`)
       for (const issue of issues) {
-        console.log(`    - ${issue}`)
+        plain(`    - ${issue}`)
       }
     }
   }
 
   if (hasErrors) {
-    console.log("\nSome plugins have issues. Fix them before deploying.")
+    error("Some plugins have issues. Fix them before deploying.")
     process.exit(1)
   } else {
-    console.log("\nAll plugins are valid.")
+    info("All plugins are valid.")
   }
 }
 

package/src/commands/pull.ts

@@ -1,17 +1,46 @@
 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"
+import { info, plain } from "../ui/messages.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`.",
-      )
+
+      info("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) {
+        plain(scaffold)
+        if (!opts.dryRun && !opts.out) {
+          info("(draft printed to stdout — use --out to write a file)")
+        }
+        return
+      }
+
+      writeFileSync(opts.out ?? defaultOut, scaffold, "utf8")
+      info(`Wrote draft schema to ${opts.out ?? defaultOut}`)
+      info("Review access rules and relations, then run `supatype generate`.")
     })
 }