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

package/src/commands/push.ts

@@ -1,17 +1,19 @@
 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 { ensureEngine, invokeEngine } from "../engine.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 { signJwt } from "../jwt.js"
+import { provisionBuckets } from "../storage-provision.js"
 import { promptFirstAdminUser } from "./admin.js"
-interface DiffResult {
-  operations: Operation[]
-}
+import { withAdminRoles } from "../studio-admin-roles.js"
+import type { SupatypeProjectConfig } from "../project-config.js"
 
-interface Operation {
-  kind: string
-  risk: "safe" | "cautious" | "destructive"
-  description: string
-}
+const DEV_JWT_SECRET = "super-secret-jwt-token-with-at-least-32-characters-long"
 
 export function registerPush(program: Command): void {
   program
@@ -23,89 +25,183 @@ export function registerPush(program: Command): void {
     .option("--connection <url>", "Database connection URL (overrides config)")
     .action(async (opts: { yes?: boolean; connection?: string }) => {
       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)
-      const connection = opts.connection ?? config.connection
+
+      // 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 ast = loadSchemaAst(config.schema, cwd)
+      const ast = loadSchemaAst(schemaPathFromProject(config, cwd), cwd)
 
-      // Validate configured providers before diffing
       console.log("Diffing against database...")
-      const diffResult = invokeEngine(
-        ["diff", "--connection", connection, "--format", "json"],
-        JSON.stringify(ast),
-      )
-      if (diffResult.exitCode !== 0) {
-        console.error(diffResult.stderr || diffResult.stdout)
-        process.exit(1)
-      }
+      const diff = await engineRequest<DiffResult>("/diff", {
+        ast,
+        database_url: connection,
+        schema: "public",
+      })
 
-      const diff = JSON.parse(diffResult.stdout) as DiffResult
       const ops = diff.operations ?? []
+      printDiffWarnings(diff)
 
       if (ops.length === 0) {
-        console.log("Schema is up to date. Nothing to push.")
-        return
-      }
-
-      printDiff(ops)
+        console.log(
+          "Schema matches the database (no DDL). Syncing Studio metadata...",
+        )
+      } else {
+        printDiff(ops)
 
-      const destructive = ops.filter((o) => o.risk === "destructive")
-      if (destructive.length > 0 && !opts.yes) {
-        const confirmed = await confirm(
-          `\n${destructive.length} destructive operation(s) above. Proceed? [y/N] `,
+        const risky = ops.filter(
+          (o) => o.risk === "cautious" || o.risk === "destructive" || o.risk === "warn" || o.risk === "danger",
         )
-        if (!confirmed) {
-          console.log("Aborted.")
-          return
+        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("\nApplying migration...")
-      const migrateResult = invokeEngine(
-        ["migrate", "--connection", connection],
-        JSON.stringify(ast),
-      )
-      if (migrateResult.exitCode !== 0) {
-        console.error(migrateResult.stderr || migrateResult.stdout)
-        process.exit(1)
+      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.")
       }
-      console.log(migrateResult.stdout || "Migration applied.")
 
-      // After migration, check if this is the first push and offer to create an
+      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).
-      await promptFirstAdminUser(connection)
+      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 genArgs = ["generate", "--connection", connection]
-        if (config.output?.types) genArgs.push("--types", config.output.types)
-        if (config.output?.client) genArgs.push("--client", config.output.client)
+        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 = invokeEngine(genArgs, JSON.stringify(ast))
-        if (genResult.exitCode !== 0) {
-          console.error(genResult.stderr || genResult.stdout)
-          process.exit(1)
-        }
-        console.log(genResult.stdout || "Types generated.")
+        const genResult = await engineRequest<{ code?: string; message?: string }>("/generate", genBody)
+        console.log(genResult.message ?? "Types generated.")
       }
 
-      console.log("\nDone.")
+      const studioBase = baseUrl?.replace(/\/$/, "") ?? ""
+      if (studioBase) {
+        console.log(`\nStudio: ${studioBase}/studio/ — sign in with the admin user you created.`)
+      } else {
+        console.log("\nDone.")
+      }
     })
 }
 
 function printDiff(ops: Operation[]): void {
-  const symbol: Record<Operation["risk"], string> = {
+  const symbol: Record<string, string> = {
     safe: "+",
+    warn: "~",
     cautious: "~",
+    danger: "!",
     destructive: "!",
   }
   console.log(`\n${ops.length} change(s) planned:\n`)
   for (const op of ops) {
-    console.log(`  [${symbol[op.risk]}] ${op.description}`)
+    const riskKey = op.risk ?? "safe"
+    const s = symbol[riskKey] ?? "?"
+    const label = op.warning ?? op.description ?? formatOperation(op)
+    console.log(`  [${s}] ${label}`)
+  }
+}
+
+function formatOperation(op: Operation): string {
+  if (typeof op.description === "string" && op.description.trim().length > 0) {
+    return op.description
+  }
+
+  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 (typeof table === "string") {
+    return `${kind} ${table}`
+  }
+
+  // Last resort: show operation kind with compact payload.
+  return `${kind} ${JSON.stringify(op)}`
 }
 
 async function confirm(prompt: string): Promise<boolean> {
@@ -117,3 +213,12 @@ async function confirm(prompt: string): Promise<boolean> {
     })
   })
 }
+
+/** 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 })
+  const admin = withAdminRoles(await engineRequest<unknown>("/admin", { ast }), config)
+  writeFileSync(join(dir, "admin-config.json"), `${JSON.stringify(admin, null, 2)}\n`)
+}

package/src/commands/seed.ts

@@ -1,26 +1,68 @@
 import type { Command } from "commander"
-import { existsSync } from "node:fs"
-import { resolve } from "node:path"
+import { existsSync, readdirSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { isLinkedToCloudProject } from "../binary-cache.js"
+import { loadConfig } from "../config.js"
+import { projectRootFromConfig } from "../project-config.js"
 import { runTsFile } from "../tsx-runner.js"
 
+const SEED_EXT = /\.(ts|mts|tsx)$/
+
+/** Seed entries under `seeds/`, sorted by filename (Phase 10.6 C19). */
+export function discoverSeedsDir(cwd: string, seedsDir: string): string[] {
+  if (!existsSync(seedsDir)) return []
+  const names = readdirSync(seedsDir).filter((n) => SEED_EXT.test(n))
+  names.sort((a, b) => a.localeCompare(b))
+  return names.map((n) => join(seedsDir, n))
+}
+
 export function registerSeed(program: Command): void {
   program
     .command("seed [file]")
-    .description("Run seed.ts (or a custom seed file) against the database")
-    .action((file?: string) => {
+    .description(
+      "Run database seeds: optional single file; else all seeds/*.ts (alphabetical); else seed.ts",
+    )
+    .option(
+      "--force",
+      "Allow running when the project is linked to Supatype Cloud (dangerous)",
+      false,
+    )
+    .action(async (file: string | undefined, opts: { force: boolean }) => {
       const cwd = process.cwd()
-      const seedFile = resolve(cwd, file ?? "seed.ts")
-
-      if (!existsSync(seedFile)) {
-        console.error(`Seed file not found: ${seedFile}`)
+      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" +
+            "  Pass --force only if you intend to target this linked project (advanced).",
+        )
         process.exit(1)
       }
 
-      console.log(`Running ${seedFile}...`)
-      const result = runTsFile(seedFile, { cwd, stdio: "inherit" })
+      const root = projectRootFromConfig(config, cwd)
+      const seedsDir = join(root, "seeds")
+
+      let paths: string[]
+      if (file !== undefined && file.trim() !== "") {
+        paths = [resolve(cwd, file)]
+      } else {
+        paths = discoverSeedsDir(cwd, seedsDir)
+        if (paths.length === 0) {
+          paths = [resolve(root, "seed.ts")]
+        }
+      }
+
+      const missing = paths.filter((p) => !existsSync(p))
+      if (missing.length > 0) {
+        console.error(`Seed file(s) not found:\n  ${missing.join("\n  ")}`)
+        process.exit(1)
+      }
 
-      if (result.exitCode !== 0) {
-        process.exit(result.exitCode)
+      for (const seedFile of paths) {
+        console.log(`[supatype] Running ${seedFile}...`)
+        const result = runTsFile(seedFile, { cwd, stdio: "inherit" })
+        if (result.exitCode !== 0) {
+          process.exit(result.exitCode)
+        }
       }
     })
 }