@supatype/cli 0.1.0-alpha.10

package/src/commands/self-update.ts

@@ -0,0 +1,45 @@
+/**
+ * supatype self-update — Phase 10.6C8.
+ *
+ * npm-installed CLI: instruct to use `npm update -g`.
+ * Standalone / future curl|sh installs: CDN-published CLI binary replacement is not wired yet.
+ */
+
+import type { Command } from "commander"
+import { sep } from "node:path"
+
+function looksLikeNpmOrWorkspaceCLI(): boolean {
+  const main = process.argv[1] ?? ""
+  return (
+    main.includes("node_modules") ||
+    main.includes(`${sep}dist${sep}cli`) ||
+    main.includes(`${sep}bin${sep}supatype.js`) ||
+    Boolean(process.env["npm_execpath"]) ||
+    Boolean(process.env["npm_lifecycle_event"])
+  )
+}
+
+export function registerSelfUpdate(program: Command): void {
+  program
+    .command("self-update")
+    .description(
+      "Update the supatype CLI (npm: use npm update; standalone binary swap from CDN is not available yet)",
+    )
+    .action(() => {
+      if (looksLikeNpmOrWorkspaceCLI()) {
+        console.log(
+          "This CLI was installed via npm (or runs from the package workspace).\n" +
+            "Update with:\n\n  npm update -g @supatype/cli\n\n" +
+            "To bump engine/server/postgres/deno pinned in supatype.config.ts, use:\n\n  supatype update\n",
+        )
+        return
+      }
+
+      console.error(
+        "Standalone CLI self-update (replace binary from CDN) is not published yet.\n\n" +
+          "Install or upgrade via npm:\n  npm install -g @supatype/cli\n\n" +
+          "Component binaries (engine, server, postgres, deno):\n  supatype update\n",
+      )
+      process.exit(1)
+    })
+}

package/src/commands/status.ts

@@ -0,0 +1,84 @@
+/**
+ * supatype status — show current state of local dev services.
+ */
+import type { Command } from "commander"
+import { spawnSync } from "node:child_process"
+import { LOCAL_KONG_HOST_PORT, localKongBaseUrl } from "../local-gateway.js"
+
+interface ServiceStatus {
+  name: string
+  container: string
+  status: "running" | "stopped" | "error"
+  port?: number
+  uptime?: string
+}
+
+export function registerStatus(program: Command): void {
+  program
+    .command("status")
+    .description("Show current state of local dev services")
+    .action(() => {
+      const services: ServiceStatus[] = [
+        { name: "Postgres", container: "supatype-postgres", port: 5432 },
+        { name: "PostgREST", container: "supatype-postgrest", port: 3000 },
+        { name: "GoTrue", container: "supatype-gotrue", port: 9999 },
+        { name: "Kong", container: "supatype-kong", port: LOCAL_KONG_HOST_PORT },
+        { name: "MinIO", container: "supatype-minio", port: 9000 },
+        { name: "Realtime", container: "supatype-realtime", port: 4000 },
+        { name: "Studio", container: "supatype-studio", port: 3100 },
+      ].map((svc) => {
+        const status = getContainerStatus(svc.container)
+        const uptime = getContainerUptime(svc.container)
+        return { ...svc, status, ...(uptime !== undefined && { uptime }) }
+      })
+
+      console.log("Supatype Local Development Stack\n")
+
+      const maxName = Math.max(...services.map((s) => s.name.length))
+      for (const svc of services) {
+        const icon = svc.status === "running" ? "●" : svc.status === "stopped" ? "○" : "✕"
+        const status = svc.status.padEnd(8)
+        const port = svc.port ? `:${svc.port}` : ""
+        const uptime = svc.uptime ? ` (${svc.uptime})` : ""
+        console.log(`  ${icon} ${svc.name.padEnd(maxName)}  ${status}  ${port}${uptime}`)
+      }
+
+      const running = services.filter((s) => s.status === "running")
+      console.log(`\n${running.length}/${services.length} services running`)
+
+      if (running.length > 0) {
+        console.log(`\nAPI URL:    ${localKongBaseUrl()}`)
+        console.log(`Studio:     http://localhost:3100`)
+        console.log(`Database:   postgresql://supatype_admin:postgres@localhost:5432/postgres`)
+      }
+    })
+}
+
+function getContainerStatus(name: string): "running" | "stopped" | "error" {
+  const result = spawnSync("docker", ["inspect", "--format", "{{.State.Status}}", name], {
+    timeout: 5000,
+  })
+  const status = result.stdout?.toString().trim()
+  if (status === "running") return "running"
+  if (result.status !== 0) return "stopped"
+  return "error"
+}
+
+function getContainerUptime(name: string): string | undefined {
+  const result = spawnSync("docker", ["inspect", "--format", "{{.State.StartedAt}}", name], {
+    timeout: 5000,
+  })
+  if (result.status !== 0) return undefined
+  const startedAt = result.stdout?.toString().trim()
+  if (!startedAt) return undefined
+
+  const started = new Date(startedAt)
+  const now = new Date()
+  const diffMs = now.getTime() - started.getTime()
+  if (diffMs < 0) return undefined
+
+  const hours = Math.floor(diffMs / (1000 * 60 * 60))
+  const minutes = Math.floor((diffMs % (1000 * 60 * 60)) / (1000 * 60))
+  if (hours > 0) return `${hours}h ${minutes}m`
+  return `${minutes}m`
+}

package/src/commands/types.ts

@@ -0,0 +1,76 @@
+import type { Command } from "commander"
+import { existsSync, readFileSync } from "node:fs"
+import { resolve, relative } from "node:path"
+import ts from "typescript"
+import { loadConfig } from "../config.js"
+
+export function registerTypes(program: Command): void {
+  const types = program.command("types").description("Type generation and validation utilities")
+
+  types
+    .command("check")
+    .description("Validate generated client augmentation wiring")
+    .action(() => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const augmentationPath = resolve(cwd, config.output?.client ?? "supatype/generated/index.d.ts")
+
+      const errors: string[] = []
+
+      if (!existsSync(augmentationPath)) {
+        errors.push(
+          `Missing generated augmentation file: ${relative(cwd, augmentationPath)}.\nRun: supatype generate`,
+        )
+      }
+
+      const tsconfigPath = resolve(cwd, "tsconfig.json")
+      if (!existsSync(tsconfigPath)) {
+        errors.push("Missing tsconfig.json in project root.")
+      } else {
+        const tsconfigRaw = readFileSync(tsconfigPath, "utf8")
+        const parsed = ts.parseConfigFileTextToJson(tsconfigPath, tsconfigRaw)
+        const cfg = (parsed.config ?? {}) as { include?: unknown; files?: unknown }
+        const include = Array.isArray(cfg.include) ? cfg.include.map(String) : []
+        const files = Array.isArray(cfg.files) ? cfg.files.map(String) : []
+        const relAug = toPosix(relative(cwd, augmentationPath))
+        const coveredByFiles = files.includes(relAug)
+        const coveredByInclude = include.some((entry) => {
+          if (entry.includes("**")) return relAug.startsWith(entry.split("**")[0] ?? "")
+          if (entry.endsWith("*.ts") || entry.endsWith("*.d.ts")) {
+            return relAug.startsWith(entry.replace(/\*\.d?ts$/, ""))
+          }
+          return relAug === entry || relAug.startsWith(entry.replace(/\/$/, "") + "/")
+        })
+        if (!coveredByFiles && !coveredByInclude) {
+          errors.push(
+            `tsconfig.json does not include ${relAug}. Add it to "include" or "files" so module augmentation is visible to TypeScript.`,
+          )
+        }
+      }
+
+      const packageJsonPath = resolve(cwd, "package.json")
+      if (existsSync(packageJsonPath)) {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8")) as {
+          dependencies?: Record<string, string>
+          devDependencies?: Record<string, string>
+        }
+        const hasClient =
+          (pkg.dependencies && "@supatype/client" in pkg.dependencies) ||
+          (pkg.devDependencies && "@supatype/client" in pkg.devDependencies)
+        if (!hasClient) {
+          errors.push('package.json is missing "@supatype/client" dependency.')
+        }
+      }
+
+      if (errors.length > 0) {
+        for (const err of errors) console.error(`- ${err}`)
+        process.exit(1)
+      }
+
+      console.log("types check passed")
+    })
+}
+
+function toPosix(path: string): string {
+  return path.replace(/\\/g, "/")
+}

package/src/commands/update.ts

@@ -0,0 +1,136 @@
+/**
+ * supatype update — bump component versions in supatype.config.ts
+ * and download the new binaries.
+ */
+
+import type { Command } from "commander"
+import { existsSync, readFileSync, writeFileSync } from "node:fs"
+import { basename, resolve } from "node:path"
+import { loadConfig } from "../config.js"
+import { resolveRuntimeProvider } from "../project-config.js"
+import { runDockerCompose, writeSelfHostCompose } from "../self-host-compose.js"
+import { syncComposeImagePins } from "../dev-compose.js"
+import { download, currentPlatform, fetchAllLatestVersions, pinnedVersion, type Component } from "../binary-cache.js"
+
+const CONFIG_CANDIDATES = ["supatype.config.ts", "supatype.config.js", "supatype.config.mjs"]
+
+function resolveConfigFile(cwd: string): string | null {
+  for (const name of CONFIG_CANDIDATES) {
+    const p = resolve(cwd, name)
+    if (existsSync(p)) return p
+  }
+  return null
+}
+
+export function registerUpdate(program: Command): void {
+  program
+    .command("update")
+    .description(
+      "Download the latest component binaries and update versions in supatype.config.ts",
+    )
+    .option("--check", "Print available updates without downloading", false)
+    .action(async (opts: { check: boolean }) => {
+      const cwd = process.cwd()
+      const config = loadConfig(cwd)
+      const provider = resolveRuntimeProvider(config)
+
+      if (provider === "docker") {
+        if (opts.check) {
+          console.log("Docker provider: run without --check to pull compose images (supatype self-host compose pull).")
+          return
+        }
+        const paths = writeSelfHostCompose(cwd, config, { devLocal: true })
+        syncComposeImagePins(cwd, config)
+        console.log("Pulling self-host compose images...")
+        const status = runDockerCompose(paths.composePath, ["pull"], cwd)
+        if (status !== 0) process.exit(status)
+        console.log("Compose images updated.")
+        return
+      }
+
+      const platform = currentPlatform()
+
+      const components: Component[] = ["engine", "server", "postgres", "deno"]
+      const updates: Array<{ component: Component; from: string; to: string }> = []
+
+      console.log("Fetching latest component versions from CDN...")
+      const latestVersions = await fetchAllLatestVersions()
+
+      for (const component of components) {
+        const latest = latestVersions[component]
+        const current = pinnedVersion(component, config)
+        if (!current) {
+          if (opts.check) {
+            console.log(`  ${component}  (latest) → ${latest} on CDN`)
+          } else {
+            console.log(`\nDownloading latest ${component} v${latest}...`)
+            try {
+              await download(component, latest, platform)
+              console.log(`  ${component} v${latest} downloaded.`)
+            } catch (err) {
+              console.error(`  Failed: ${(err as Error).message}`)
+            }
+          }
+          continue
+        }
+        if (current === "local") continue
+        if (current !== latest) {
+          updates.push({ component, from: current, to: latest })
+        }
+      }
+
+      if (updates.length === 0) {
+        console.log(opts.check ? "All pinned components match CDN latest." : "All components are up to date.")
+        return
+      }
+
+      console.log("Available updates:")
+      for (const { component, from, to } of updates) {
+        console.log(`  ${component}  ${from} → ${to}`)
+      }
+
+      if (opts.check) return
+
+      // Download updated binaries.
+      for (const { component, to } of updates) {
+        console.log(`\nDownloading ${component} v${to}...`)
+        try {
+          await download(component, to, platform)
+        } catch (err) {
+          console.error(`  Failed: ${(err as Error).message}`)
+          continue
+        }
+        console.log(`  ${component} v${to} downloaded.`)
+      }
+
+      const configPath = resolveConfigFile(cwd)
+      if (configPath === null) {
+        console.error("No supatype.config.ts (or .js/.mjs) found to patch versions.")
+        process.exit(1)
+      }
+
+      let text = readFileSync(configPath, "utf8")
+      for (const { component, to } of updates) {
+        const key = component
+        if (text.includes(`${key}:`)) {
+          text = text.replace(
+            new RegExp(`(${key}\\s*:\\s*['"])[^'"]*(['"])`),
+            `$1${to}$2`,
+          )
+        } else if (text.includes("versions:")) {
+          text = text.replace(
+            /(versions:\s*\{[^}]*)(\})/,
+            `$1,\n    ${key}: "${to}"$2`,
+          )
+        } else {
+          text = text.replace(
+            /(\n)(\s*)(email:|schema:|storage:)/,
+            `$1$2versions: {\n$2  ${key}: "${to}",\n$2},\n$2$3`,
+          )
+        }
+      }
+
+      writeFileSync(configPath, text, "utf8")
+      console.log(`\n${basename(configPath)} updated.`)
+    })
+}

package/src/components.ts

@@ -0,0 +1,6 @@
+/** CDN-cached binaries resolved by the CLI (`engine`, `server`, `postgres`, `deno`). */
+export const BINARY_COMPONENTS = ["engine", "server", "postgres", "deno"] as const
+
+export type Component = (typeof BINARY_COMPONENTS)[number]
+
+export type ComponentVersions = Record<Component, string>

package/src/config.ts

@@ -0,0 +1,223 @@
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from "node:fs"
+import { resolve } from "node:path"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { evalTsSnippet } from "./tsx-runner.js"
+import {
+  mergeProjectConfig,
+  validateProjectConfig,
+  type SupatypeProjectConfig,
+} from "./project-config.js"
+import { extractSchemaAstFromTypes } from "./type-extractor.js"
+
+export type { SupatypeProjectConfig } from "./project-config.js"
+
+/** Canonical project configuration shape (alias for clarity at call sites). */
+export type SupatypeConfig = SupatypeProjectConfig
+
+export interface ServiceVersionPin {
+  /** Docker image tag to pin this service to (e.g. "v1.2.3"). When set, `self-host upgrade` skips this service. */
+  version: string
+}
+
+export interface SelfHostConfig {
+  /** Production domain (e.g. "api.example.com"). Used by Caddy for HTTPS. */
+  domain: string
+  /** App service to include in the production stack. */
+  app?: {
+    /** Path to the app's Dockerfile, relative to the project root. */
+    dockerfile: string
+    /** Port the app listens on. */
+    port: number
+  }
+  ssl?: {
+    /** SSL provider. "caddy" = automatic Let's Encrypt. "none" = bring your own. */
+    provider: "caddy" | "none"
+    /** Email for Let's Encrypt registration (required when provider = "caddy"). */
+    email?: string
+  }
+  /**
+   * Pin specific services to fixed Docker image versions.
+   * When a service is pinned, `self-host upgrade` will skip it.
+   * Omit a service or set to `undefined` to allow automatic upgrades.
+   */
+  services?: {
+    db?: ServiceVersionPin
+    gotrue?: ServiceVersionPin
+    postgrest?: ServiceVersionPin
+    kong?: ServiceVersionPin
+    caddy?: ServiceVersionPin
+    pgbouncer?: ServiceVersionPin
+  }
+}
+
+export type AppFramework = "nextjs" | "astro" | "vite" | "remix-spa" | "sveltekit" | "nuxt" | "static"
+
+export interface AppConfig {
+  /** Framework name. Auto-detected from package.json if not specified. */
+  framework?: AppFramework
+  /** Path to the app directory (default: "./" or "./apps/web" for monorepos). */
+  directory?: string
+  /** Build command (inferred from framework if not specified). */
+  buildCommand?: string
+  /** Output directory (inferred from framework if not specified). */
+  outputDirectory?: string
+  /** Enable SPA fallback routing (default: true for Vite/CRA, false for SSG frameworks). */
+  spa?: boolean
+  /** Environment variables to inject during build. */
+  env?: Record<string, string>
+  /** Custom response headers for the static site. */
+  headers?: Record<string, string>
+}
+
+/** Identity helper — provides type inference for config files. */
+export function defineConfig(config: SupatypeProjectConfig): SupatypeProjectConfig {
+  return config
+}
+
+const LEGACY_TOML = "supatype.config.toml"
+
+const MAIN_CONFIG_CANDIDATES = [
+  "supatype.config.ts",
+  "supatype.config.js",
+  "supatype.config.mjs",
+]
+
+const LOCAL_CONFIG_CANDIDATES = [
+  "supatype.local.config.ts",
+  "supatype.local.config.js",
+  "supatype.local.config.mjs",
+]
+
+/**
+ * Normalize a config object parsed from JSON (e.g. shorthand `schema: "./x"`).
+ */
+function normalizeProjectJson(raw: unknown): unknown {
+  if (typeof raw !== "object" || raw === null) return raw
+  const o = { ...(raw as Record<string, unknown>) }
+  const sch = o["schema"]
+  if (typeof sch === "string") {
+    o["schema"] = {
+      path: sch,
+      pg_schema: typeof o["pg_schema"] === "string" ? o["pg_schema"] : "public",
+    }
+    delete o["pg_schema"]
+  }
+  return o
+}
+
+/**
+ * Load project config from `supatype.config.ts` (or .js/.mjs), merged with
+ * optional `supatype.local.config.*` (gitignored overrides).
+ */
+export function loadConfig(cwd: string = process.cwd()): SupatypeProjectConfig {
+  if (existsSync(resolve(cwd, LEGACY_TOML))) {
+    throw new Error(
+      `Found ${LEGACY_TOML}, which is no longer supported.\n` +
+        "Move settings into supatype.config.ts (export default { project, database, server, app, versions, … }).\n" +
+        "Run `supatype init` in a new folder for a fresh template.",
+    )
+  }
+
+  const baseRaw = loadFirstTsConfig(cwd, MAIN_CONFIG_CANDIDATES)
+  if (baseRaw === null) {
+    throw new Error(
+      "No supatype.config.ts (or .js/.mjs) found in the current directory.\n" +
+        "Run: supatype init",
+    )
+  }
+
+  const baseNorm = normalizeProjectJson(baseRaw)
+  const base = validateProjectConfig(baseNorm, "supatype.config.ts")
+
+  const localRaw = loadFirstTsConfig(cwd, LOCAL_CONFIG_CANDIDATES)
+  if (localRaw === null) return base
+
+  const localNorm = normalizeProjectJson(localRaw) as Partial<SupatypeProjectConfig>
+  return mergeProjectConfig(base, localNorm)
+}
+
+function loadFirstTsConfig(
+  cwd: string,
+  candidates: string[],
+): Record<string, unknown> | null {
+  for (const candidate of candidates) {
+    const configPath = resolve(cwd, candidate)
+    if (!existsSync(configPath)) continue
+
+    const urlPath = "file:///" + configPath.replace(/\\/g, "/")
+    const snippet = `
+const mod = await import(${JSON.stringify(urlPath)})
+const config = mod.default ?? mod
+process.stdout.write(JSON.stringify(config))
+`
+    const result = evalTsSnippet(snippet, { cwd })
+    if (result.exitCode === 0) {
+      return JSON.parse(result.stdout) as Record<string, unknown>
+    }
+
+    const failure = result.stderr || result.stdout
+    if (!failure.includes("ERR_PACKAGE_PATH_NOT_EXPORTED")) {
+      throw new Error(`Failed to load ${candidate}:\n${failure}`)
+    }
+
+    const fallback = loadTsConfigWithoutCliImport(configPath, cwd)
+    if (fallback !== null) return fallback
+    throw new Error(`Failed to load ${candidate}:\n${failure}`)
+  }
+  return null
+}
+
+function loadTsConfigWithoutCliImport(
+  configPath: string,
+  cwd: string,
+): Record<string, unknown> | null {
+  const original = readFileSync(configPath, "utf8")
+  const patched = original
+    .replace(/^import\s+type\s+\{[^}]*\}\s+from\s+["']@supatype\/cli["'];?\s*$/gm, "")
+    .replace(/^import\s+\{[^}]*defineConfig[^}]*\}\s+from\s+["']@supatype\/cli["'];?\s*$/gm, "")
+
+  // If the file didn't import from @supatype/cli, this fallback won't help.
+  if (patched === original) return null
+
+  const tmpPath = join(tmpdir(), `supatype-config-fallback-${Date.now()}.mts`)
+  const wrapper = `const defineConfig = (config) => config\n${patched}`
+  writeFileSync(tmpPath, wrapper, "utf8")
+  try {
+    const urlPath = "file:///" + tmpPath.replace(/\\/g, "/")
+    const snippet = `
+const mod = await import(${JSON.stringify(urlPath)})
+const config = mod.default ?? mod
+process.stdout.write(JSON.stringify(config))
+`
+    const result = evalTsSnippet(snippet, { cwd })
+    if (result.exitCode !== 0) return null
+    return JSON.parse(result.stdout) as Record<string, unknown>
+  } finally {
+    try {
+      unlinkSync(tmpPath)
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+}
+
+/** Load schema AST by evaluating the user's schema entry point via tsx. */
+export function loadSchemaAst(
+  schemaPath: string,
+  cwd: string = process.cwd(),
+): unknown {
+  const extracted = extractSchemaAstFromTypes(schemaPath, cwd)
+  if (extracted !== null) return extracted
+
+  const absPath = resolve(cwd, schemaPath)
+  if (!existsSync(absPath)) {
+    throw new Error(`Schema file not found: ${absPath}`)
+  }
+
+  throw new Error(
+    "Runtime model() schemas are no longer supported.\n" +
+      `Could not extract type-based models from: ${absPath}\n` +
+      "Migrate this file to @supatype/types Model<> definitions (or run `supatype migrate-from-v1`).",
+  )
+}