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

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

@@ -3,6 +3,7 @@
  */
 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
@@ -21,7 +22,7 @@ export function registerStatus(program: Command): void {
         { 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: 8000 },
+        { 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 },
@@ -46,9 +47,9 @@ export function registerStatus(program: Command): void {
       console.log(`\n${running.length}/${services.length} services running`)
 
       if (running.length > 0) {
-        console.log(`\nAPI URL:    http://localhost:8000`)
+        console.log(`\nAPI URL:    ${localKongBaseUrl()}`)
         console.log(`Studio:     http://localhost:3100`)
-        console.log(`Database:   postgresql://postgres:postgres@localhost:5432/postgres`)
+        console.log(`Database:   postgresql://supatype_admin:postgres@localhost:5432/postgres`)
       }
     })
 }

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,109 @@
+/**
+ * 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 { download, currentPlatform, fetchAllLatestVersions, 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 })
+        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 current = config.versions[component]
+        if (current === "local") continue
+        const latest = latestVersions[component]
+        if (current !== latest) {
+          updates.push({ component, from: current, to: latest })
+        }
+      }
+
+      if (updates.length === 0) {
+        console.log("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
+        // engine: "0.4.1"  or  engine: '0.4.1'
+        text = text.replace(
+          new RegExp(`(${key}\\s*:\\s*['"])[^'"]*(['"])`),
+          `$1${to}$2`,
+        )
+      }
+
+      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

@@ -1,6 +1,19 @@
-import { existsSync } from "node:fs"
+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. */
@@ -27,12 +40,6 @@ export interface SelfHostConfig {
    * 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.
-   *
-   * @example
-   * services: {
-   *   db: { version: "17-latest" },
-   *   postgrest: { version: "v12.2.8" },
-   * }
    */
   services?: {
     db?: ServiceVersionPin
@@ -63,97 +70,136 @@ export interface AppConfig {
   headers?: Record<string, string>
 }
 
-export interface SupatypeConfig {
-  /** Database connection string. */
-  connection: string
-  /**
-   * Path (or glob) to the schema entry point.
-   * Must export model definitions as named exports.
-   * @example "./schema/index.ts"
-   */
-  schema: string
-  output?: {
-    /** Path for generated TypeScript types. */
-    types?: string
-    /** Path for generated client helpers. */
-    client?: string
-  }
-  /** Self-hosted production deployment configuration. */
-  selfHost?: SelfHostConfig
-  /** Cloud project reference (set by `supatype link --project <ref>`). */
-  projectRef?: string
-  /** Cloud API URL override. */
-  apiUrl?: string
-  /** Cloud access token (prefer SUPATYPE_ACCESS_TOKEN env var). */
-  accessToken?: string
-  /** CORS configuration. */
-  cors?: {
-    /** Allowed origins. Defaults to ['*'] in development. */
-    allowedOrigins?: string[]
-  }
-  /** Static site hosting configuration. */
-  app?: AppConfig
-  /** Registered plugins (provider, field, composite, widget). */
-  plugins?: Array<unknown> | undefined
-  /** Admin panel configuration (see Gap Appendices tasks 47–50). */
-  admin?: {
-    /**
-     * Roles from {ref}_auth.users that grant admin panel access.
-     * Checked against `app_metadata.role` in the project JWT.
-     * @default ["admin"]
-     */
-    roles?: string[]
-  }
-}
-
 /** Identity helper — provides type inference for config files. */
-export function defineConfig(config: SupatypeConfig): SupatypeConfig {
+export function defineConfig(config: SupatypeProjectConfig): SupatypeProjectConfig {
   return config
 }
 
-const CONFIG_CANDIDATES = [
+const LEGACY_TOML = "supatype.config.toml"
+
+const MAIN_CONFIG_CANDIDATES = [
   "supatype.config.ts",
   "supatype.config.js",
   "supatype.config.mjs",
 ]
 
-/** Load and evaluate supatype.config.ts from the given directory. */
-export function loadConfig(cwd: string = process.cwd()): SupatypeConfig {
-  for (const candidate of CONFIG_CANDIDATES) {
+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, "/")
-
-    // Use dynamic import so we can always access .default —
-    // files without a parent package.json are treated as CJS by tsx,
-    // meaning export default becomes module.exports.default rather than
-    // the namespace default. Dynamic import + fallback handles both.
     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) {
-      throw new Error(
-        `Failed to load ${candidate}:\n${result.stderr || result.stdout}`,
-      )
+    if (result.exitCode === 0) {
+      return JSON.parse(result.stdout) as Record<string, unknown>
     }
 
-    const parsed = JSON.parse(result.stdout) as SupatypeConfig
-    if (!parsed.connection || !parsed.schema) {
-      throw new Error(
-        `${candidate} must export { connection, schema } via defineConfig()`,
-      )
+    const failure = result.stderr || result.stdout
+    if (!failure.includes("ERR_PACKAGE_PATH_NOT_EXPORTED")) {
+      throw new Error(`Failed to load ${candidate}:\n${failure}`)
     }
-    return parsed
+
+    const fallback = loadTsConfigWithoutCliImport(configPath, cwd)
+    if (fallback !== null) return fallback
+    throw new Error(`Failed to load ${candidate}:\n${failure}`)
   }
+  return null
+}
 
-  throw new Error(
-    "No supatype.config.ts found in the current directory.\n" +
-      "Run: supatype init",
-  )
+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. */
@@ -161,30 +207,17 @@ 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}`)
   }
 
-  const urlPath = "file:///" + absPath.replace(/\\/g, "/")
-
-  const snippet = `
-import { serialiseSchema } from "@supatype/schema"
-const mod = await import(${JSON.stringify(urlPath)})
-const { default: _default, ...named } = mod
-const models = Object.fromEntries(
-  Object.entries(named).filter(([, v]) =>
-    v != null && typeof v === "object" && "__modelMeta" in (v as object)
+  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`).",
   )
-)
-process.stdout.write(JSON.stringify(serialiseSchema(models)))
-`
-  const result = evalTsSnippet(snippet, { cwd })
-  if (result.exitCode !== 0) {
-    throw new Error(
-      `Failed to load schema from ${absPath}:\n${result.stderr || result.stdout}`,
-    )
-  }
-
-  return JSON.parse(result.stdout)
 }