@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.8

package/src/commands/migrate-from-v1.ts

@@ -0,0 +1,131 @@
+import type { Command } from "commander"
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { basename, dirname, extname, join, resolve } from "node:path"
+import ts from "typescript"
+import { loadConfig } from "../config.js"
+import { schemaPathFromProject } from "../project-config.js"
+
+export function registerMigrateFromV1(program: Command): void {
+  program
+    .command("migrate-from-v1")
+    .description("Codemod runtime model() schema DSL into RFC v2 Model<> type aliases")
+    .option("--schema <path>", "Path to v1 schema file (defaults to supatype.config.ts schema)")
+    .option("--write", "Overwrite source file instead of creating .v2.ts sibling")
+    .action((opts: { schema?: string; write?: boolean }) => {
+      const cwd = process.cwd()
+      const cfg = loadConfig(cwd)
+      const schemaPath = opts.schema !== undefined
+        ? resolve(cwd, opts.schema)
+        : schemaPathFromProject(cfg, cwd)
+      if (!existsSync(schemaPath)) {
+        throw new Error(`Schema file not found: ${schemaPath}`)
+      }
+
+      const src = readFileSync(schemaPath, "utf8")
+      const sf = ts.createSourceFile(schemaPath, src, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+      const output = codemodSource(sf)
+      const outPath = opts.write
+        ? schemaPath
+        : join(dirname(schemaPath), basename(schemaPath).replace(extname(schemaPath), ".v2.ts"))
+
+      writeFileSync(outPath, output, "utf8")
+      console.log(`v2 schema written to ${outPath}`)
+      if (!opts.write) {
+        console.log("Review TODO comments and replace unknown mappings before using this file in production.")
+      }
+    })
+}
+
+export function codemodSource(sf: ts.SourceFile): string {
+  const lines: string[] = []
+  lines.push('import type { Model, UUID, Optional } from "@supatype/types"')
+  lines.push("")
+  lines.push("// TODO(v2-migration): verify each mapped type and access rule below.")
+  lines.push("")
+
+  for (const stmt of sf.statements) {
+    if (!ts.isVariableStatement(stmt)) continue
+    if (!(ts.getModifiers(stmt)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false)) continue
+
+    for (const decl of stmt.declarationList.declarations) {
+      if (!ts.isIdentifier(decl.name) || !decl.initializer) continue
+      const modelCall = extractModelCall(decl.initializer)
+      if (!modelCall) continue
+      const fields = extractFields(modelCall.config)
+      const modelType = renderModelType(decl.name.text, fields)
+      lines.push(modelType)
+      lines.push("")
+    }
+  }
+
+  if (lines.length <= 4) {
+    lines.push("// TODO(v2-migration): no model() declarations were detected in this file.")
+  }
+
+  return lines.join("\n")
+}
+
+function extractModelCall(node: ts.Expression): { config: ts.ObjectLiteralExpression } | null {
+  if (!ts.isCallExpression(node)) return null
+  if (!ts.isIdentifier(node.expression) || node.expression.text !== "model") return null
+  const config = node.arguments[1]
+  if (!config || !ts.isObjectLiteralExpression(config)) return null
+  return { config }
+}
+
+function extractFields(config: ts.ObjectLiteralExpression): Array<{ name: string; type: string }> {
+  const fieldsProp = config.properties.find(
+    (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "fields",
+  )
+  if (!fieldsProp || !ts.isPropertyAssignment(fieldsProp) || !ts.isObjectLiteralExpression(fieldsProp.initializer)) {
+    return []
+  }
+
+  const result: Array<{ name: string; type: string }> = []
+  for (const prop of fieldsProp.initializer.properties) {
+    if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue
+    result.push({
+      name: prop.name.text,
+      type: mapFieldInitializerToType(prop.initializer),
+    })
+  }
+  return result
+}
+
+function mapFieldInitializerToType(node: ts.Expression): string {
+  if (!ts.isCallExpression(node)) return "unknown // TODO(v2-migration): unsupported field expression"
+  if (!ts.isPropertyAccessExpression(node.expression)) return "unknown // TODO(v2-migration): unsupported field expression"
+  if (!ts.isIdentifier(node.expression.expression) || node.expression.expression.text !== "field") {
+    return "unknown // TODO(v2-migration): unsupported field expression"
+  }
+
+  const kind = node.expression.name.text
+  switch (kind) {
+    case "uuid":
+      return "UUID"
+    case "text":
+    case "slug":
+    case "email":
+    case "url":
+      return "string"
+    case "integer":
+    case "smallInt":
+    case "float":
+    case "decimal":
+      return "number"
+    case "boolean":
+      return "boolean"
+    case "richText":
+    case "json":
+      return "Record<string, unknown>"
+    default:
+      return "unknown // TODO(v2-migration): map field." + kind
+  }
+}
+
+function renderModelType(name: string, fields: Array<{ name: string; type: string }>): string {
+  const fieldsBlock = fields
+    .map((field) => `  ${field.name}: ${field.type}`)
+    .join("\n")
+  return `export type ${name} = Model<{\n${fieldsBlock}\n}>`
+}

package/src/commands/migrate.ts

@@ -1,7 +1,8 @@
 import type { Command } from "commander"
 import { createInterface } from "node:readline"
-import { loadConfig } from "../config.js"
-import { ensureEngine, invokeEngine } from "../engine.js"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { connectionString, schemaPathFromProject } from "../project-config.js"
+import { ensureEngine, engineRequest } from "../engine-client.js"
 
 export function registerMigrate(program: Command): void {
   // migrate — apply all pending migrations
@@ -11,15 +12,15 @@ export function registerMigrate(program: Command): void {
     .option("--connection <url>", "Database connection URL (overrides config)")
     .action(async (opts: { connection?: string }) => {
       const config = loadConfig()
-      const connection = opts.connection ?? config.connection
+      const connection = opts.connection ?? connectionString(config)
 
       await ensureEngine()
-      const result = invokeEngine(["migrate", "--pending", "--connection", connection])
-      if (result.exitCode !== 0) {
-        console.error(result.stderr || result.stdout)
-        process.exit(1)
-      }
-      console.log(result.stdout || "Migrations applied.")
+      const result = await engineRequest<{ message?: string }>("/migrations", {
+        database_url: connection,
+        schema: "public",
+        action: "pending",
+      })
+      console.log(result.message ?? "Migrations applied.")
     })
 
   // rollback — undo the last applied migration
@@ -29,15 +30,15 @@ export function registerMigrate(program: Command): void {
     .option("--connection <url>", "Database connection URL (overrides config)")
     .action(async (opts: { connection?: string }) => {
       const config = loadConfig()
-      const connection = opts.connection ?? config.connection
+      const connection = opts.connection ?? connectionString(config)
 
       await ensureEngine()
-      const result = invokeEngine(["rollback", "--connection", connection])
-      if (result.exitCode !== 0) {
-        console.error(result.stderr || result.stdout)
-        process.exit(1)
-      }
-      console.log(result.stdout || "Rolled back.")
+      const result = await engineRequest<{ message?: string }>("/migrations", {
+        database_url: connection,
+        schema: "public",
+        action: "rollback",
+      })
+      console.log(result.message ?? "Rolled back.")
     })
 
   // reset — drop all tables and re-apply from scratch
@@ -60,15 +61,18 @@ export function registerMigrate(program: Command): void {
       }
 
       const config = loadConfig()
-      const connection = opts.connection ?? config.connection
+      const connection = opts.connection ?? connectionString(config)
+      const cwd = process.cwd()
 
       await ensureEngine()
-      const result = invokeEngine(["reset", "--connection", connection])
-      if (result.exitCode !== 0) {
-        console.error(result.stderr || result.stdout)
-        process.exit(1)
-      }
-      console.log(result.stdout || "Reset complete.")
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
+      const result = await engineRequest<{ message?: string }>("/push", {
+        ast,
+        database_url: connection,
+        schema: "public",
+        force: true,
+      })
+      console.log(result.message ?? "Reset complete.")
     })
 }
 

package/src/commands/pg.ts

@@ -0,0 +1,133 @@
+/**
+ * supatype pg — manage the native Postgres instance for a project.
+ *
+ * Commands: start, stop, reset, psql
+ */
+
+import type { Command } from "commander"
+import { spawnSync } from "node:child_process"
+import { existsSync, mkdirSync, rmSync } from "node:fs"
+import { homedir } from "node:os"
+import { join } from "node:path"
+import { loadConfig } from "../config.js"
+import { resolveBinary } from "../binary-cache.js"
+import {
+  initdb,
+  start as pgStart,
+  stop as pgStop,
+  waitReady,
+} from "../postgres-ctl.js"
+
+export function registerPg(program: Command): void {
+  const pg = program
+    .command("pg")
+    .description("Manage the native Postgres instance for the current project")
+
+  // ── start ────────────────────────────────────────────────────────────────
+  pg.command("start")
+    .description("Start Postgres for the current project")
+    .action(async () => {
+      const config = loadConfig()
+      const opts = await pgOpts(config)
+      initdb(opts)
+      pgStart(opts)
+      await waitReady(opts, 10_000)
+      console.log(
+        `[supatype] Postgres started on port ${opts.port} (data: ${opts.dataDir})`,
+      )
+    })
+
+  // ── stop ─────────────────────────────────────────────────────────────────
+  pg.command("stop")
+    .description("Stop Postgres for the current project")
+    .action(async () => {
+      const config = loadConfig()
+      const opts = await pgOpts(config)
+      pgStop(opts)
+      console.log("[supatype] Postgres stopped.")
+    })
+
+  // ── reset ─────────────────────────────────────────────────────────────────
+  pg.command("reset")
+    .description("Stop Postgres, wipe the data directory, and re-initialise")
+    .option("--force", "Skip confirmation prompt")
+    .action(async (opts: { force: boolean }) => {
+      const config = loadConfig()
+      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,
+          ),
+        )
+        rl.close()
+        if (answer.toLowerCase() !== "y") {
+          console.log("Aborted.")
+          return
+        }
+      }
+
+      pgStop(pgOpts_)
+      if (existsSync(pgOpts_.dataDir)) {
+        rmSync(pgOpts_.dataDir, { recursive: true, force: true })
+        console.log(`[supatype] 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.")
+    })
+
+  // ── psql ─────────────────────────────────────────────────────────────────
+  pg.command("psql [dbname]")
+    .description("Open a psql shell connected to the project database")
+    .action(async (dbname?: string) => {
+      const config = loadConfig()
+      const opts = await pgOpts(config)
+      const db = dbname ?? config.project.name
+      const psql = join(opts.pgBinDir, "psql")
+
+      const result = spawnSync(
+        psql,
+        ["-h", "127.0.0.1", "-p", String(opts.port), "-U", "postgres", db],
+        { stdio: "inherit" },
+      )
+      process.exit(result.status ?? 0)
+    })
+}
+
+// ---------------------------------------------------------------------------
+// Helper: build PgOptions from config
+// ---------------------------------------------------------------------------
+
+async function pgOpts(
+  config: ReturnType<typeof loadConfig>,
+): Promise<import("../postgres-ctl.js").PgOptions> {
+  const projectName = config.project.name
+  const stateRoot = join(homedir(), ".supatype", "projects", projectName)
+  const dataDir = config.database.data_dir ?? join(stateRoot, "data")
+  const logsDir = join(stateRoot, "logs")
+  mkdirSync(logsDir, { recursive: true })
+
+  // Resolve pg binary dir.
+  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 platform = currentPlatform()
+    const version = config.versions.postgres
+    return join(cachePath("postgres", version), `pg-${version}`, "bin")
+  })()
+
+  return {
+    pgBinDir: pgCacheDir,
+    dataDir,
+    port: 5432,
+    logPath: join(logsDir, "postgres.log"),
+  }
+}

package/src/commands/pull.ts

@@ -1,96 +1,17 @@
 import type { Command } from "commander"
-import { mkdirSync, writeFileSync } from "node:fs"
-import { resolve } from "node:path"
-import { loadConfig } from "../config.js"
-import { ensureEngine, invokeEngine } from "../engine.js"
-import { pgTypeToField, toCamelCase, type ColumnInfo } from "../pull-utils.js"
-
-interface IntrospectResult {
-  models: Array<{
-    name: string
-    tableName: string
-    columns: ColumnInfo[]
-  }>
-}
+import { ensureEngine } from "../engine-client.js"
 
 export function registerPull(program: Command): void {
   program
     .command("pull")
     .description(
-      "Introspect an existing Postgres database and generate TypeScript schema files",
+      "Introspect an existing Postgres database (deprecated in type-first mode)",
     )
-    .option("--connection <url>", "Database connection URL (overrides config)")
-    .option("--output <path>", "Output directory for schema files", "./schema")
-    .action(async (opts: { connection?: string; output: string }) => {
-      const cwd = process.cwd()
-      const connection = opts.connection ?? loadConfig(cwd).connection
-
+    .action(async () => {
       await ensureEngine()
-      console.log("Introspecting database...")
-      const result = invokeEngine([
-        "introspect",
-        "--connection",
-        connection,
-        "--format",
-        "json",
-      ])
-      if (result.exitCode !== 0) {
-        console.error(result.stderr || result.stdout)
-        process.exit(1)
-      }
-
-      const introspected = JSON.parse(result.stdout) as IntrospectResult
-      const models = introspected.models ?? []
-
-      if (models.length === 0) {
-        console.log("No tables found in the database.")
-        return
-      }
-
-      const outputDir = resolve(cwd, opts.output)
-      mkdirSync(outputDir, { recursive: true })
-
-      for (const model of models) {
-        const content = generateModelFile(model)
-        writeFileSync(resolve(outputDir, `${model.name}.ts`), content, "utf8")
-        console.log(`  wrote  ${opts.output}/${model.name}.ts`)
-      }
-
-      const indexContent = generateIndexFile(models.map((m) => m.name))
-      writeFileSync(resolve(outputDir, "index.ts"), indexContent, "utf8")
-      console.log(`  wrote  ${opts.output}/index.ts`)
-
-      console.log(
-        `\nPulled ${models.length} model(s). Review TODO comments before running supatype push.\n`,
+      throw new Error(
+        "The legacy `supatype pull` schema generator has been removed.\n" +
+          "Use type-based models with @supatype/types and run `supatype generate`.",
       )
     })
 }
-
-function generateModelFile(model: IntrospectResult["models"][number]): string {
-  const fieldLines = model.columns
-    .map((col) => `    ${col.name}: ${pgTypeToField(col)},`)
-    .join("\n")
-
-  return `import { model, field, access } from "@supatype/schema"
-
-// TODO: review access rules — all operations default to authenticated
-export const ${toCamelCase(model.name)} = model(${JSON.stringify(model.name)}, {
-  tableName: ${JSON.stringify(model.tableName)},
-  fields: {
-${fieldLines}
-  },
-  access: {
-    read: access.role("authenticated"),
-    create: access.role("authenticated"),
-    update: access.role("authenticated"),
-    delete: access.role("authenticated"),
-  },
-})
-`
-}
-
-function generateIndexFile(names: string[]): string {
-  return names
-    .map((n) => `export { ${toCamelCase(n)} } from "./${n}.js"`)
-    .join("\n") + "\n"
-}