@supatype/cli 0.1.0-alpha.6

package/src/commands/dev.ts

@@ -0,0 +1,477 @@
+import type { Command } from "commander"
+import { spawnSync, spawn, type ChildProcess } from "node:child_process"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { resolve } from "node:path"
+import { loadConfig } from "../config.js"
+import { ensureEngine, invokeEngine } from "../engine.js"
+
+const POSTGREST_URL = "http://localhost:3000"
+const HEALTH_TIMEOUT_MS = 60_000
+const HEALTH_POLL_MS = 2_000
+
+export function registerDev(program: Command): void {
+  program
+    .command("dev")
+    .description(
+      "Start local Postgres, PostgREST, and Kong via Docker Compose, then watch for schema changes",
+    )
+    .option("--no-watch", "Start services but do not watch for schema changes")
+    .option("--local", "Run storage, realtime, and studio from source (monorepo dev)")
+    .action(async (opts: { watch: boolean; local: boolean }) => {
+      const cwd = process.cwd()
+
+      // Generate .env with local defaults if missing
+      ensureDevEnv(cwd)
+
+      if (opts.local) {
+        // Monorepo dev — generate an infra-only compose if needed, then start
+        const composePath = resolve(cwd, "docker-compose.yml")
+        if (!existsSync(composePath)) {
+          ensureInfraCompose(cwd)
+        }
+        console.log("Starting infra services...")
+        const up = spawnSync(
+          "docker",
+          ["compose", "up", "-d", "--wait", "db", "pgbouncer", "gotrue", "postgrest", "minio", "kong"],
+          { cwd, stdio: "inherit" },
+        )
+        if (up.status !== 0) {
+          console.error("docker compose up failed.")
+          process.exit(1)
+        }
+      } else {
+        if (!existsSync(resolve(cwd, "docker-compose.yml"))) {
+          console.error(
+            "docker-compose.yml not found. Run: supatype init",
+          )
+          process.exit(1)
+        }
+        console.log("Starting services...")
+        const up = spawnSync(
+          "docker",
+          ["compose", "up", "-d", "--wait"],
+          { cwd, stdio: "inherit" },
+        )
+        if (up.status !== 0) {
+          console.error("docker compose up failed.")
+          process.exit(1)
+        }
+      }
+
+      console.log("Waiting for PostgREST to be ready...")
+      await waitForPostgREST()
+
+      const children: ChildProcess[] = []
+
+      if (opts.local) {
+        console.log("\nStarting local services from source...")
+        children.push(
+          ...startLocalServices(cwd),
+        )
+      }
+
+      console.log("\nServices running:")
+      console.log("  Postgres    postgresql://localhost:5432")
+      console.log("  PostgREST   http://localhost:3000")
+      console.log("  Kong        http://localhost:8000")
+      console.log("    REST API  http://localhost:8000/rest/v1/")
+      console.log("    GraphQL   http://localhost:8000/graphql/v1")
+      if (opts.local) {
+        console.log("  Storage     http://localhost:5000  (from source)")
+        console.log("  Realtime    http://localhost:4000  (from source)")
+        console.log("  Studio      http://localhost:3002  (from source)")
+      }
+      console.log()
+
+      // Clean shutdown on Ctrl+C
+      const cleanup = () => {
+        for (const child of children) {
+          child.kill()
+        }
+        process.exit(0)
+      }
+      process.on("SIGINT", cleanup)
+      process.on("SIGTERM", cleanup)
+
+      if (opts.watch) {
+        await watchAndPush(cwd)
+      }
+    })
+}
+
+function ensureInfraCompose(cwd: string): void {
+  const projectName = resolve(cwd).split(/[\\/]/).pop() ?? "supatype"
+  const content = `# Generated by supatype dev --local — infra services only
+services:
+  db:
+    image: supatype/postgres:17-latest
+    environment:
+      POSTGRES_PASSWORD: \${POSTGRES_PASSWORD:-postgres}
+      POSTGRES_DB: \${POSTGRES_DB:-${projectName}}
+    ports:
+      - "5432:5432"
+    volumes:
+      - db-data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 20
+
+  pgbouncer:
+    image: pgbouncer/pgbouncer:latest
+    volumes:
+      - ./.supatype/pgbouncer.ini:/etc/pgbouncer/pgbouncer.ini:ro
+      - ./.supatype/userlist.txt:/etc/pgbouncer/userlist.txt:ro
+    depends_on:
+      db:
+        condition: service_healthy
+    healthcheck:
+      test: ["CMD", "pg_isready", "-h", "localhost", "-p", "6432", "-U", "postgres"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  gotrue:
+    image: supatype/auth:v1.0.0
+    environment:
+      GOTRUE_API_HOST: 0.0.0.0
+      GOTRUE_API_PORT: 9999
+      GOTRUE_DB_DRIVER: postgres
+      GOTRUE_DB_DATABASE_URL: "postgres://postgres:\${POSTGRES_PASSWORD:-postgres}@pgbouncer:6432/\${POSTGRES_DB:-${projectName}}?search_path=auth"
+      GOTRUE_SITE_URL: \${SITE_URL:-http://localhost:3000}
+      GOTRUE_JWT_SECRET: \${JWT_SECRET:-super-secret-jwt-token-change-in-production}
+      GOTRUE_JWT_EXP: 3600
+      GOTRUE_JWT_AUD: authenticated
+      GOTRUE_JWT_DEFAULT_GROUP_NAME: authenticated
+      GOTRUE_JWT_ADMIN_ROLES: service_role
+      GOTRUE_MAILER_AUTOCONFIRM: \${GOTRUE_MAILER_AUTOCONFIRM:-true}
+      GOTRUE_DISABLE_SIGNUP: \${DISABLE_SIGNUP:-false}
+    ports:
+      - "9999:9999"
+    depends_on:
+      pgbouncer:
+        condition: service_healthy
+
+  postgrest:
+    image: postgrest/postgrest:v12.2.8
+    environment:
+      PGRST_DB_URI: postgresql://authenticator:\${POSTGRES_PASSWORD:-postgres}@pgbouncer:6432/\${POSTGRES_DB:-${projectName}}
+      PGRST_DB_SCHEMA: public
+      PGRST_DB_ANON_ROLE: anon
+      PGRST_JWT_SECRET: \${JWT_SECRET:-super-secret-jwt-token-change-in-production}
+      PGRST_DB_EXTRA_SEARCH_PATH: public,extensions
+      PGRST_DB_POOL: 3
+    ports:
+      - "3000:3000"
+    depends_on:
+      pgbouncer:
+        condition: service_healthy
+
+  minio:
+    image: minio/minio:RELEASE.2024-11-07T00-52-20Z
+    command: server /data --console-address ":9001"
+    environment:
+      MINIO_ROOT_USER: supatype
+      MINIO_ROOT_PASSWORD: supatype-secret
+    ports:
+      - "9000:9000"
+      - "9001:9001"
+    volumes:
+      - minio-data:/data
+    healthcheck:
+      test: ["CMD", "mc", "ready", "local"]
+      interval: 5s
+      timeout: 5s
+      retries: 10
+
+  kong:
+    image: kong:3.6
+    environment:
+      KONG_DATABASE: "off"
+      KONG_DECLARATIVE_CONFIG: /etc/kong/kong.yml
+      KONG_PROXY_ACCESS_LOG: /dev/stdout
+      KONG_ADMIN_ACCESS_LOG: /dev/stdout
+      KONG_PROXY_ERROR_LOG: /dev/stderr
+      KONG_ADMIN_ERROR_LOG: /dev/stderr
+    volumes:
+      - ./.supatype/kong.yml:/etc/kong/kong.yml:ro
+    ports:
+      - "8000:8000"
+    depends_on:
+      - postgrest
+      - gotrue
+
+volumes:
+  db-data:
+  minio-data:
+`
+  writeFileSync(resolve(cwd, "docker-compose.yml"), content, "utf8")
+  console.log("  created  docker-compose.yml (infra only)\n")
+
+  // Also ensure pgbouncer config exists
+  const supatypeDir = resolve(cwd, ".supatype")
+  mkdirSync(supatypeDir, { recursive: true })
+
+  if (!existsSync(resolve(supatypeDir, "pgbouncer.ini"))) {
+    writeFileSync(resolve(supatypeDir, "pgbouncer.ini"), `[databases]
+* = host=db port=5432
+
+[pgbouncer]
+listen_addr = 0.0.0.0
+listen_port = 6432
+auth_type = trust
+auth_file = /etc/pgbouncer/userlist.txt
+pool_mode = transaction
+default_pool_size = 20
+max_db_connections = 60
+max_client_conn = 100
+server_reset_query = DEALLOCATE ALL
+ignore_startup_parameters = extra_float_digits
+`, "utf8")
+  }
+
+  if (!existsSync(resolve(supatypeDir, "userlist.txt"))) {
+    writeFileSync(resolve(supatypeDir, "userlist.txt"), "", "utf8")
+  }
+
+  if (!existsSync(resolve(supatypeDir, "kong.yml"))) {
+    writeFileSync(resolve(supatypeDir, "kong.yml"), `_format_version: "3.0"
+
+services:
+  - name: rest-v1
+    url: http://postgrest:3000
+    routes:
+      - name: rest-v1-all
+        strip_path: true
+        paths:
+          - /rest/v1/
+  - name: auth-v1
+    url: http://gotrue:9999
+    routes:
+      - name: auth-v1-all
+        strip_path: true
+        paths:
+          - /auth/v1/
+  - name: storage-v1
+    url: http://host.docker.internal:5000
+    routes:
+      - name: storage-v1-all
+        strip_path: true
+        paths:
+          - /storage/v1/
+  - name: realtime-v1
+    url: http://host.docker.internal:4000
+    routes:
+      - name: realtime-v1-all
+        strip_path: true
+        paths:
+          - /realtime/v1/
+        protocols:
+          - http
+          - https
+          - ws
+          - wss
+  - name: functions-v1
+    url: http://host.docker.internal:54321
+    routes:
+      - name: functions-v1-all
+        strip_path: false
+        paths:
+          - /functions/v1/
+  - name: studio
+    url: http://host.docker.internal:3002
+    routes:
+      - name: studio-all
+        strip_path: true
+        paths:
+          - /studio/
+`, "utf8")
+  }
+}
+
+function ensureDevEnv(cwd: string): void {
+  const envPath = resolve(cwd, ".env")
+  if (existsSync(envPath)) return
+
+  const projectName = resolve(cwd).split(/[\\/]/).pop() ?? "supatype"
+  const content = `# Generated by supatype dev — all defaults for local development
+DATABASE_URL=postgresql://postgres:postgres@localhost:5432/${projectName}
+POSTGRES_PASSWORD=postgres
+POSTGRES_DB=${projectName}
+
+JWT_SECRET=super-secret-jwt-token-change-in-production
+ANON_KEY=
+SERVICE_ROLE_KEY=
+
+SITE_URL=http://localhost:3000
+
+# Storage (MinIO)
+S3_ENDPOINT=http://localhost:9000
+S3_REGION=us-east-1
+S3_ACCESS_KEY=supatype
+S3_SECRET_KEY=supatype-secret
+S3_FORCE_PATH_STYLE=true
+
+# SMTP — leave empty for email autoconfirm in dev
+SMTP_HOST=
+SMTP_PORT=
+SMTP_USER=
+SMTP_PASS=
+`
+  writeFileSync(envPath, content, "utf8")
+  console.log("  created  .env (local dev defaults)\n")
+}
+
+function loadDotEnv(cwd: string): Record<string, string> {
+  const envPath = resolve(cwd, ".env")
+  if (!existsSync(envPath)) return {}
+  const vars: Record<string, string> = {}
+  for (const line of readFileSync(envPath, "utf8").split("\n")) {
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith("#")) continue
+    const eq = trimmed.indexOf("=")
+    if (eq === -1) continue
+    const key = trimmed.slice(0, eq)
+    const value = trimmed.slice(eq + 1)
+    vars[key] = value
+  }
+  return vars
+}
+
+function localDevDefaults(cwd: string): Record<string, string> {
+  const projectName = resolve(cwd).split(/[\\/]/).pop() ?? "supatype"
+  // Known defaults that match docker-compose local dev setup
+  const defaults: Record<string, string> = {
+    DATABASE_URL: `postgresql://postgres:postgres@localhost:5432/${projectName}`,
+    POSTGRES_PASSWORD: "postgres",
+    POSTGRES_DB: projectName,
+    JWT_SECRET: "super-secret-jwt-token-change-in-production",
+    SITE_URL: "http://localhost:3000",
+    S3_ENDPOINT: "http://localhost:9000",
+    S3_REGION: "us-east-1",
+    S3_ACCESS_KEY: "supatype",
+    S3_SECRET_KEY: "supatype-secret",
+    S3_FORCE_PATH_STYLE: "true",
+    SLOT_NAME: "realtime_slot",
+    REPLICATION_POLL_INTERVAL: "100",
+    SECURE_CHANNELS: "true",
+  }
+  // .env file values override defaults
+  const dotEnv = loadDotEnv(cwd)
+  return { ...defaults, ...dotEnv }
+}
+
+function startLocalServices(cwd: string): ChildProcess[] {
+  const children: ChildProcess[] = []
+  const devEnv = localDevDefaults(cwd)
+
+  const services = [
+    { name: "storage", filter: "@supatype/storage", color: "\x1b[34m" },
+    { name: "realtime", filter: "@supatype/realtime", color: "\x1b[35m" },
+    { name: "studio", filter: "@supatype/studio", color: "\x1b[36m" },
+  ]
+
+  for (const svc of services) {
+    const pkgDir = resolve(cwd, "..", "packages", svc.name)
+
+    if (!existsSync(resolve(pkgDir, "package.json"))) {
+      console.warn(`  Skipping ${svc.name} — not found at ${pkgDir}`)
+      continue
+    }
+
+    const reset = "\x1b[0m"
+    const prefix = `${svc.color}[${svc.name}]${reset}`
+
+    const child = spawn("pnpm", ["dev"], {
+      cwd: pkgDir,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true,
+      env: {
+        ...process.env,
+        ...devEnv,
+        PORT: svc.name === "storage" ? "5000" : svc.name === "realtime" ? "4000" : "3002",
+      },
+    })
+
+    child.stdout?.on("data", (data: Buffer) => {
+      for (const line of data.toString().trimEnd().split("\n")) {
+        console.log(`${prefix} ${line}`)
+      }
+    })
+    child.stderr?.on("data", (data: Buffer) => {
+      for (const line of data.toString().trimEnd().split("\n")) {
+        console.error(`${prefix} ${line}`)
+      }
+    })
+    child.on("exit", (code) => {
+      if (code !== 0 && code !== null) {
+        console.error(`${prefix} exited with code ${code}`)
+      }
+    })
+
+    children.push(child)
+    console.log(`  ${prefix} started (pnpm dev)`)
+  }
+
+  return children
+}
+
+async function waitForPostgREST(): Promise<void> {
+  const deadline = Date.now() + HEALTH_TIMEOUT_MS
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(POSTGREST_URL, { signal: AbortSignal.timeout(2000) })
+      if (res.ok || res.status === 401) return // 401 = JWT required = server up
+    } catch {
+      // not ready yet
+    }
+    await sleep(HEALTH_POLL_MS)
+  }
+  throw new Error(
+    `PostgREST did not become healthy within ${HEALTH_TIMEOUT_MS / 1000}s.\n` +
+      "Check: docker compose logs postgrest",
+  )
+}
+
+async function watchAndPush(cwd: string): Promise<void> {
+  const config = loadConfig(cwd)
+  const schemaDir = resolve(cwd, config.schema, "..")
+
+  console.log(`Watching ${schemaDir} for changes... (Ctrl+C to stop)\n`)
+
+  // Initial push on start
+  await runPush(cwd)
+
+  const { watch } = await import("node:fs")
+  watch(schemaDir, { recursive: true }, (eventType, filename) => {
+    if (!filename?.endsWith(".ts")) return
+    console.log(`\nChange detected in ${filename}, pushing...`)
+    runPush(cwd).catch((e: unknown) =>
+      console.error("Push failed:", (e as Error).message),
+    )
+  })
+
+  // Block forever
+  await new Promise<never>(() => undefined)
+}
+
+async function runPush(cwd: string): Promise<void> {
+  const { loadConfig, loadSchemaAst } = await import("../config.js")
+  const config = loadConfig(cwd)
+  const ast = loadSchemaAst(config.schema, cwd)
+  await ensureEngine()
+  const result = invokeEngine(
+    ["migrate", "--connection", config.connection],
+    JSON.stringify(ast),
+  )
+  if (result.exitCode !== 0) {
+    console.error(result.stderr || result.stdout)
+    return
+  }
+  console.log(result.stdout || "Schema up to date.")
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((r) => setTimeout(r, ms))
+}

package/src/commands/diff.ts

@@ -0,0 +1,61 @@
+import type { Command } from "commander"
+import { loadConfig, loadSchemaAst } from "../config.js"
+import { ensureEngine, invokeEngine } from "../engine.js"
+
+interface DiffResult {
+  operations: Array<{
+    kind: string
+    risk: "safe" | "cautious" | "destructive"
+    description: string
+  }>
+}
+
+export function registerDiff(program: Command): void {
+  program
+    .command("diff")
+    .description("Show planned schema changes without applying them (dry run)")
+    .option("--connection <url>", "Database connection URL (overrides config)")
+    .action(async (opts: { connection?: string }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const connection = opts.connection ?? config.connection
+
+      await ensureEngine()
+
+      console.log("Loading schema...")
+      const ast = loadSchemaAst(config.schema, cwd)
+
+      const result = invokeEngine(
+        ["diff", "--connection", connection, "--format", "json"],
+        JSON.stringify(ast),
+      )
+      if (result.exitCode !== 0) {
+        console.error(result.stderr || result.stdout)
+        process.exit(1)
+      }
+
+      const diff = JSON.parse(result.stdout) as DiffResult
+      const ops = diff.operations ?? []
+
+      if (ops.length === 0) {
+        console.log("No changes.")
+        return
+      }
+
+      const symbol = { safe: "+", cautious: "~", destructive: "!" }
+      const legend = { safe: "safe", cautious: "cautious", destructive: "DESTRUCTIVE" }
+
+      console.log(`\n${ops.length} change(s):\n`)
+      for (const op of ops) {
+        console.log(
+          `  [${symbol[op.risk]}] ${op.description}  (${legend[op.risk]})`,
+        )
+      }
+
+      const destructive = ops.filter((o) => o.risk === "destructive").length
+      if (destructive > 0) {
+        console.log(`\n  ${destructive} destructive operation(s). Run with --yes to skip confirmation.`)
+      }
+      console.log()
+    })
+}

package/src/commands/engine.ts

@@ -0,0 +1,133 @@
+/**
+ * Engine management commands:
+ *   supatype engine version      — show pinned, cached, and latest versions
+ *   supatype engine update-check — check for newer engine versions
+ *   supatype engine prune        — remove old cached engine versions
+ */
+
+import type { Command } from "commander"
+import { ENGINE_VERSION } from "../engine-version.js"
+import { detectPlatform } from "../engine/platform.js"
+import {
+  hasCachedBinary,
+  listCachedVersions,
+  pruneCacheExcept,
+  saveUpdateCheck,
+} from "../engine/cache.js"
+import { checkLatestVersion } from "../engine/resolve.js"
+
+export function registerEngine(program: Command): void {
+  const engine = program
+    .command("engine")
+    .description("Manage the Supatype engine binary")
+
+  // supatype engine version
+  engine
+    .command("version")
+    .description("Show engine version information")
+    .action(async () => {
+      const platform = detectPlatform()
+      const cached = hasCachedBinary(ENGINE_VERSION, platform)
+      const cachedVersions = listCachedVersions()
+
+      console.log(`Engine: v${ENGINE_VERSION} (pinned)`)
+      console.log(
+        `Cache:  ${cached ? `v${ENGINE_VERSION} ✓` : "not downloaded"}`,
+      )
+
+      if (cachedVersions.length > 1) {
+        const others = cachedVersions.filter((v) => v !== ENGINE_VERSION)
+        console.log(`Other cached versions: ${others.join(", ")}`)
+      }
+
+      // Check latest
+      try {
+        const latest = await checkLatestVersion()
+        if (latest) {
+          await saveUpdateCheck(latest.version)
+          if (latest.version !== ENGINE_VERSION) {
+            console.log(
+              `Latest: v${latest.version} — update available, run: npm update @supatype/cli`,
+            )
+          } else {
+            console.log(`Latest: v${latest.version} (up to date)`)
+          }
+        }
+      } catch {
+        console.log("Latest: unable to check (offline?)")
+      }
+    })
+
+  // supatype engine update-check
+  engine
+    .command("update-check")
+    .description("Check if a newer engine version is available")
+    .action(async () => {
+      const latest = await checkLatestVersion()
+
+      if (!latest) {
+        console.error(
+          "Could not check for updates. Check your internet connection.",
+        )
+        process.exitCode = 1
+        return
+      }
+
+      await saveUpdateCheck(latest.version)
+
+      if (latest.version !== ENGINE_VERSION) {
+        console.log(
+          `Supatype engine v${latest.version} is available (current: v${ENGINE_VERSION}).`,
+        )
+        console.log(`Run: npm update @supatype/cli`)
+      } else {
+        console.log(`Engine v${ENGINE_VERSION} is up to date.`)
+      }
+    })
+
+  // supatype engine prune
+  engine
+    .command("prune")
+    .description("Remove all cached engine versions except the current one")
+    .action(() => {
+      const { removed, bytesFreed } = pruneCacheExcept(ENGINE_VERSION)
+
+      if (removed.length === 0) {
+        console.log("Nothing to prune — only the current version is cached.")
+        return
+      }
+
+      const mb = (bytesFreed / (1024 * 1024)).toFixed(1)
+      console.log(`Removed ${removed.length} cached version(s): ${removed.join(", ")}`)
+      console.log(`Space reclaimed: ${mb}MB`)
+    })
+
+  // supatype engine versions (list all released versions)
+  engine
+    .command("versions")
+    .description("List all released engine versions")
+    .action(async () => {
+      const { fetchJson } = await import("../engine/download.js")
+      const { CDN_BASE_URL } = await import("../engine-version.js")
+
+      interface VersionEntry {
+        version: string
+        date: string
+      }
+
+      const versions = await fetchJson<VersionEntry[]>(
+        `${CDN_BASE_URL}/versions.json`,
+      )
+
+      if (!versions || versions.length === 0) {
+        console.log("No released versions found.")
+        return
+      }
+
+      console.log("Released engine versions:")
+      for (const v of versions) {
+        const current = v.version === ENGINE_VERSION ? " (current)" : ""
+        console.log(`  v${v.version}  ${v.date}${current}`)
+      }
+    })
+}