@supatype/cli 0.1.0-alpha.10

package/src/process-manager.ts

@@ -0,0 +1,220 @@
+/**
+ * ProcessManager — spawn a child process, write its PID, stream logs with a
+ * colored prefix, and restart on crash with exponential backoff.
+ */
+
+import { type ChildProcess, spawn, spawnSync } from "node:child_process"
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs"
+import { unlink } from "node:fs/promises"
+import { join } from "node:path"
+import { enhanceProcessOptions } from "./dev-session.js"
+
+export interface ProcessOptions {
+  /** Human-readable label (used in log prefix and PID filename). */
+  label: string
+  /** Directory to write {label}.pid to. */
+  pidDir: string
+  /** ANSI colour prefix string (e.g. "\x1b[36m"). Pass "" for no colour. */
+  colour?: string
+  /** Working directory for the spawned process. Defaults to process.cwd(). */
+  cwd?: string
+  /** Environment variables to merge with process.env. */
+  env?: Record<string, string>
+  /** Initial restart backoff in ms. Doubles each crash up to maxBackoffMs. */
+  initialBackoffMs?: number
+  /** Maximum restart backoff cap in ms. */
+  maxBackoffMs?: number
+  /** Called when the process exits cleanly (code 0). */
+  onExit?: () => void
+  /** Use shell to spawn (required for pnpm/npm/yarn .cmd shims on Windows). */
+  shell?: boolean
+  /** When set (TUI mode), receive log lines instead of writing to stdout/stderr. */
+  onLine?: (line: string, stream: "stdout" | "stderr") => void
+  /** Return false to drop a line before logging. */
+  shouldLogLine?: (line: string) => boolean
+}
+
+const RESET = "\x1b[0m"
+
+export class ProcessManager {
+  private child: ChildProcess | null = null
+  private stopped = false
+  private backoffMs: number
+  private opts: ProcessOptions & {
+    colour: string
+    cwd: string
+    env: Record<string, string>
+    initialBackoffMs: number
+    maxBackoffMs: number
+    onExit: () => void
+    shell: boolean
+  }
+  /** Skip immediate duplicate lines (npm prints script banners to both streams). */
+  private lastLoggedLine = ""
+
+  constructor(
+    private readonly bin: string,
+    private readonly args: string[],
+    opts: ProcessOptions,
+  ) {
+    const merged = enhanceProcessOptions(opts.label, opts)
+    this.opts = {
+      colour: "\x1b[36m",
+      cwd: process.cwd(),
+      env: {},
+      initialBackoffMs: 1_000,
+      maxBackoffMs: 30_000,
+      onExit: () => {},
+      shell: false,
+      ...merged,
+    }
+    this.backoffMs = this.opts.initialBackoffMs
+  }
+
+  /** Start the process. Returns immediately — the process runs in the background. */
+  start(): void {
+    this.stopped = false
+    this.spawn()
+  }
+
+  /** Stop the process and clear the PID file. */
+  async stop(): Promise<void> {
+    this.stopped = true
+    if (!this.child || this.child.killed) {
+      await this.clearPid()
+      return
+    }
+
+    const pid = this.child.pid
+    if (process.platform === "win32" && this.opts.shell && pid) {
+      spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { stdio: "ignore" })
+      this.child = null
+      await this.clearPid()
+      return
+    }
+
+    if (!this.child.killed) {
+      this.child.kill("SIGTERM")
+      // Give it 5s to exit gracefully, then SIGKILL.
+      await new Promise<void>((resolve) => {
+        const timeout = setTimeout(() => {
+          this.child?.kill("SIGKILL")
+          resolve()
+        }, 5_000)
+        this.child!.once("exit", () => {
+          clearTimeout(timeout)
+          resolve()
+        })
+      })
+    }
+    await this.clearPid()
+  }
+
+  private spawn(): void {
+    if (this.stopped) return
+
+    const env = { ...process.env, ...this.opts.env } as NodeJS.ProcessEnv
+    this.child = spawn(this.bin, this.args, {
+      env,
+      cwd: this.opts.cwd,
+      stdio: "pipe",
+      ...(this.opts.shell ? { shell: true } : {}),
+    })
+
+    const pid = this.child.pid
+    if (pid) this.writePid(pid)
+
+    const prefix = this.opts.colour
+      ? `${this.opts.colour}[${this.opts.label}]${RESET} `
+      : `[${this.opts.label}] `
+
+    const logLine = (line: string, stream: NodeJS.WriteStream): void => {
+      if (!line) return
+      if (this.opts.shouldLogLine && !this.opts.shouldLogLine(line)) return
+      if (this.opts.onLine) {
+        if (line !== this.lastLoggedLine) {
+          this.lastLoggedLine = line
+          this.opts.onLine(line, stream === process.stderr ? "stderr" : "stdout")
+        }
+        return
+      }
+      if (line === this.lastLoggedLine) return
+      this.lastLoggedLine = line
+      stream.write(prefix + line + "\n")
+    }
+
+    this.child.stdout?.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString().split("\n")) {
+        logLine(line, process.stdout)
+      }
+    })
+
+    this.child.stderr?.on("data", (chunk: Buffer) => {
+      for (const line of chunk.toString().split("\n")) {
+        logLine(line, process.stderr)
+      }
+    })
+
+    this.child.once("error", (err) => {
+      if (this.stopped) return
+      const message = `${prefix}failed to start: ${err.message}\n`
+      if (this.opts.onLine) {
+        this.opts.onLine(`failed to start: ${err.message}`, "stderr")
+      } else {
+        process.stderr.write(message)
+      }
+      setTimeout(() => {
+        this.backoffMs = Math.min(this.backoffMs * 2, this.opts.maxBackoffMs)
+        this.spawn()
+      }, this.backoffMs)
+    })
+
+    this.child.once("exit", (code, signal) => {
+      if (this.stopped) return
+
+      if (code === 0) {
+        this.opts.onExit()
+        return
+      }
+
+      const reason = signal ? `signal ${signal}` : `code ${code}`
+      const restartMsg = `${prefix}process exited (${reason}), restarting in ${this.backoffMs}ms\n`
+      if (this.opts.onLine) {
+        this.opts.onLine(`process exited (${reason}), restarting in ${this.backoffMs}ms`, "stderr")
+      } else {
+        process.stderr.write(restartMsg)
+      }
+
+      setTimeout(() => {
+        this.backoffMs = Math.min(this.backoffMs * 2, this.opts.maxBackoffMs)
+        this.spawn()
+      }, this.backoffMs)
+    })
+  }
+
+  private writePid(pid: number): void {
+    try {
+      mkdirSync(this.opts.pidDir, { recursive: true })
+      writeFileSync(join(this.opts.pidDir, `${this.opts.label}.pid`), String(pid))
+    } catch {
+      // Non-fatal — PID tracking is best-effort.
+    }
+  }
+
+  private async clearPid(): Promise<void> {
+    try {
+      await unlink(join(this.opts.pidDir, `${this.opts.label}.pid`))
+    } catch {
+      // Ignore — file may already be gone.
+    }
+  }
+}
+
+/** Read a PID from a file (returns null if not found or stale). */
+export function readPid(pidDir: string, label: string): number | null {
+  const pidFile = join(pidDir, `${label}.pid`)
+  if (!existsSync(pidFile)) return null
+  const raw = readFileSync(pidFile, "utf8").trim()
+  const pid = Number(raw)
+  return Number.isFinite(pid) && pid > 0 ? pid : null
+}

package/src/project-config.ts

@@ -0,0 +1,388 @@
+import { existsSync } from "node:fs"
+import { resolve } from "node:path"
+import type { ComponentVersions } from "./components.js"
+
+// ---------------------------------------------------------------------------
+// Config schema (single canonical shape; loaded from supatype.config.ts)
+// ---------------------------------------------------------------------------
+
+export interface SupatypeProjectConfig {
+  /**
+   * Runtime stack for local dev and `supatype update`.
+   * "native" = host binaries (default). "docker" = self-host Compose stack.
+   * Falls back to `database.provider` when omitted (deprecated).
+   */
+  provider?: "native" | "docker"
+  supatype?: {
+    /**
+     * Base directory for Supatype project assets (schema, functions, etc).
+     * "." means the current working directory (default).
+     */
+    root?: string
+  }
+  project: {
+    /** Project name — used for per-project state dirs and logging. */
+    name: string
+    /** Cloud project reference (set by `supatype link`). */
+    ref?: string
+  }
+  database: {
+    /**
+     * Database backend.
+     * "native" = supatype manages a native Postgres binary (downloaded from CDN).
+     * "docker" = supatype runs supatype/postgres via Docker (includes all extensions).
+     */
+    provider: "native" | "docker"
+    /**
+     * Directory where Postgres stores its data files (provider=native).
+     * Defaults to ~/.supatype/projects/{name}/data when omitted.
+     */
+    data_dir?: string
+    /**
+     * Docker image to use (provider=docker).
+     * Defaults to supatype/postgres:latest.
+     * Override in supatype.local.config.ts for local builds.
+     */
+    image?: string
+  }
+  server: {
+    /**
+     * Server mode.
+     * "dev"        = no TLS, permissive CORS, Vite HMR proxy
+     * "standalone" = ACME TLS (Let's Encrypt)
+     * "managed"    = cloud-managed, HMAC tenant verification
+     */
+    mode: "dev" | "standalone" | "managed"
+    /** Port supatype-server listens on (default: 54321). */
+    port?: number
+    /** Port PostgREST listens on in local dev (default: 3001). */
+    postgrestPort?: number
+    /** Domain for ACME TLS certificate (mode=standalone). */
+    domain?: string
+  }
+  app: {
+    /**
+     * How the root path "/" is handled by supatype-server.
+     * "none"   = 404
+     * "static" = serve files from static_dir
+     * "proxy"  = reverse-proxy to upstream
+     */
+    mode: "none" | "static" | "proxy"
+    /** Directory to serve static files from (mode=static). */
+    static_dir?: string
+    /** Upstream URL to proxy to (mode=proxy). */
+    upstream?: string
+    /**
+     * Vite dev server base URL for HMR (`/_vite/*`) when `server.mode` is dev.
+     * Example: `http://127.0.0.1:5173`. Sets `SUPATYPE_VITE_DEV_URL` for supatype-server.
+     * When omitted, dev still falls back to `SUPATYPE_APP_UPSTREAM` for non-proxy app modes.
+     */
+    vite_dev_url?: string
+    /**
+     * package.json script name for `supatype dev` to run when mode is proxy.
+     * Default: `"start"`. Ignored for static/none modes.
+     */
+    start?: string
+  }
+  /**
+   * Optional pins for engine, server, postgres, and deno.
+   * Omitted = resolve latest from CDN at runtime (native) or use Docker :latest.
+   * When set, native binaries cache under ~/.supatype/cache/{component}/{version}/
+   * and Docker image tags are synced to `.env` on `supatype dev` / `supatype push`.
+   * Use **`"local"`** with the matching **`overrides.*`** entry for contributor builds.
+   */
+  versions?: Partial<ComponentVersions>
+  /**
+   * Override component binaries with local build paths.
+   * Intended for supatype contributors testing local changes.
+   * Cannot be combined with a linked cloud project (`project.ref`, `.supatype/cloud.json`, or `.supatype/linked.json`; hard error in `resolveBinary`).
+   */
+  overrides?: {
+    /** Path to local engine binary. */
+    engine?: string
+    /** Path to local supatype-server binary. */
+    server?: string
+    /** Path to a directory containing a local Postgres installation. */
+    postgres_dir?: string
+    /** Path to a local deno binary. */
+    deno?: string
+    /** Path to the @supatype/studio package directory (starts Vite dev server). */
+    studio?: string
+    /** Path to a local PostgREST binary. */
+    postgrest?: string
+  }
+  email?: {
+    /**
+     * Email delivery provider.
+     * "console" = log to stdout (default for dev)
+     * "smtp"    = SMTP (set `smtp` below and/or GOTRUE_SMTP_* in `.env`)
+     * "resend"  = Resend API (requires RESEND_API_KEY, RESEND_FROM)
+     * "ses"     = AWS SES v2 (ambient credentials, requires SES_FROM)
+     */
+    provider: "console" | "smtp" | "resend" | "ses"
+    /**
+     * SMTP settings for provider=smtp (merged into process env as GOTRUE_SMTP_*).
+     * Omitted keys can still be set via `.env` / shell.
+     */
+    smtp?: {
+      host?: string
+      port?: number
+      user?: string
+      pass?: string
+      admin_email?: string
+      sender_name?: string
+    }
+    /** Resend API key (provider=resend, or set RESEND_API_KEY env var). */
+    resend_api_key?: string
+    /** From address for Resend (provider=resend, or set RESEND_FROM env var). */
+    resend_from?: string
+    /** From address for SES (provider=ses, or set SES_FROM env var). */
+    ses_from?: string
+    /**
+     * When true, `supatype dev` enables the GoTrue send-email HTTP hook pointing at this
+     * server's POST `/internal/v0hooks/send-email` (signed delivery, dev-only secret).
+     * Override `GOTRUE_HOOK_SEND_EMAIL_*` in `.env` if needed.
+     */
+    send_email_hook?: boolean
+    /**
+     * Override hook target URL when `send_email_hook` is true (e.g. HTTPS tunnel or Edge URL).
+     * Default: `http://127.0.0.1:<serverPort>/internal/v0hooks/send-email`.
+     */
+    send_email_hook_uri?: string
+    /**
+     * Standard Webhooks v1 secrets for the send-email hook (`v1,whsec_...`, pipe-separated for rotation).
+     * Default in dev: a fixed local secret; override for team-shared dev or CI.
+     */
+    send_email_hook_secrets?: string
+  }
+  storage?: {
+    /**
+     * Storage backend.
+     * "local" = files on disk (LocalStoragePath required)
+     * "s3"    = AWS S3 or compatible (ambient credentials)
+     */
+    provider: "local" | "s3"
+    /** Local directory to store objects in (provider=local). */
+    local_path?: string
+  }
+  schema?: {
+    /** Path (or glob) to the schema entry point. Defaults to "schema/index.ts". */
+    path?: string
+    /** Postgres schema name. Defaults to "public". */
+    pg_schema?: string
+  }
+  functions?: {
+    /** Path to edge functions directory, relative to `supatype.root` when not absolute. */
+    path?: string
+  }
+  output?: {
+    /** Path for generated TypeScript types. */
+    types?: string
+    /** Path for generated client helpers. */
+    client?: string
+  }
+  /**
+   * App build configuration for `supatype deploy`.
+   * Separate from `app` which controls how supatype-server serves at runtime.
+   */
+  build?: {
+    /** Framework name. Auto-detected from package.json when omitted. */
+    framework?: "nextjs" | "astro" | "vite" | "remix-spa" | "sveltekit" | "nuxt" | "static"
+    /** Path to the app directory. Defaults to cwd. */
+    directory?: string
+    /** Build command. Inferred from framework when omitted. */
+    buildCommand?: string
+    /** Build output directory. Inferred from framework when omitted. */
+    outputDirectory?: string
+    /** Enable SPA fallback routing. */
+    spa?: boolean
+    /** Environment variables injected at build time. */
+    env?: Record<string, string>
+    /** Custom response headers for the deployed static site. */
+    headers?: Record<string, string>
+  }
+  /**
+   * Optional Postgres URL for CLI commands that talk to the DB (`push`, `migrate`, …).
+   * When omitted, `DATABASE_URL` from the environment is used, then a local default DSN.
+   */
+  connection?: string
+  /** Studio admin panel access (Gap Appendices task 47). */
+  admin?: {
+    /** JWT `app_metadata.role` values allowed to use Studio. Default: admin, supatype_admin */
+    roles?: string[]
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Merge + validate
+// ---------------------------------------------------------------------------
+
+/**
+ * Merge each top-level section from `override` on top of `base`.
+ * Within each section, override values win. New optional sections in override are added.
+ */
+export function mergeProjectConfig(
+  base: SupatypeProjectConfig,
+  override: Partial<SupatypeProjectConfig>,
+): SupatypeProjectConfig {
+  return {
+    ...(base.provider !== undefined || override.provider !== undefined
+      ? { provider: override.provider ?? base.provider }
+      : {}),
+    ...(base.supatype !== undefined || override.supatype !== undefined
+      ? { supatype: { ...base.supatype, ...override.supatype } as NonNullable<SupatypeProjectConfig["supatype"]> }
+      : {}),
+    project: { ...base.project, ...override.project },
+    database: { ...base.database, ...override.database },
+    server: { ...base.server, ...override.server },
+    app: { ...base.app, ...override.app },
+    ...(base.versions !== undefined || override.versions !== undefined
+      ? { versions: { ...base.versions, ...override.versions } }
+      : {}),
+    ...(base.overrides !== undefined || override.overrides !== undefined
+      ? {
+          overrides: {
+            ...base.overrides,
+            ...override.overrides,
+          } as NonNullable<SupatypeProjectConfig["overrides"]>,
+        }
+      : {}),
+    ...(base.email !== undefined || override.email !== undefined
+      ? (() => {
+          const b = base.email
+          const o = override.email
+          const mergedSmtp =
+            b?.smtp !== undefined || o?.smtp !== undefined
+              ? { ...(b?.smtp ?? {}), ...(o?.smtp ?? {}) }
+              : undefined
+          return {
+            email: {
+              ...b,
+              ...o,
+              ...(mergedSmtp !== undefined ? { smtp: mergedSmtp } : {}),
+            } as NonNullable<SupatypeProjectConfig["email"]>,
+          }
+        })()
+      : {}),
+    ...(base.storage !== undefined || override.storage !== undefined
+      ? {
+          storage: {
+            ...base.storage,
+            ...override.storage,
+          } as NonNullable<SupatypeProjectConfig["storage"]>,
+        }
+      : {}),
+    ...(base.schema !== undefined || override.schema !== undefined
+      ? { schema: { ...base.schema, ...override.schema } as NonNullable<SupatypeProjectConfig["schema"]> }
+      : {}),
+    ...(base.functions !== undefined || override.functions !== undefined
+      ? { functions: { ...base.functions, ...override.functions } as NonNullable<SupatypeProjectConfig["functions"]> }
+      : {}),
+    ...(base.output !== undefined || override.output !== undefined
+      ? { output: { ...base.output, ...override.output } as NonNullable<SupatypeProjectConfig["output"]> }
+      : {}),
+    ...(base.build !== undefined || override.build !== undefined
+      ? { build: { ...base.build, ...override.build } as NonNullable<SupatypeProjectConfig["build"]> }
+      : {}),
+    ...(base.connection !== undefined || override.connection !== undefined
+      ? { connection: override.connection ?? base.connection }
+      : {}),
+    ...(base.admin !== undefined || override.admin !== undefined
+      ? { admin: { ...base.admin, ...override.admin } as NonNullable<SupatypeProjectConfig["admin"]> }
+      : {}),
+  }
+}
+
+export function validateProjectConfig(raw: unknown, filename: string): SupatypeProjectConfig {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`${filename}: expected a config object at the root`)
+  }
+
+  const cfg = raw as Record<string, unknown>
+
+  if (!cfg["project"] || typeof (cfg["project"] as Record<string, unknown>)["name"] !== "string") {
+    throw new Error(`${filename}: project.name is required`)
+  }
+  if (!cfg["database"]) {
+    throw new Error(`${filename}: database section is required`)
+  }
+  if (!cfg["server"]) {
+    throw new Error(`${filename}: server section is required`)
+  }
+  if (!cfg["app"]) {
+    throw new Error(`${filename}: app section is required`)
+  }
+
+  return raw as SupatypeProjectConfig
+}
+
+/** Schema entry path (with fallback). */
+export function schemaPathFromProject(cfg: SupatypeProjectConfig, cwd: string): string {
+  return resolve(projectRootFromConfig(cfg, cwd), cfg.schema?.path ?? "schema/index.ts")
+}
+
+/** Resolve project root for schema/functions defaults. */
+export function projectRootFromConfig(cfg: SupatypeProjectConfig, cwd: string): string {
+  return resolve(cwd, cfg.supatype?.root ?? ".")
+}
+
+/** Candidate functions directories in lookup order. */
+export function functionsPathCandidatesFromProject(cfg: SupatypeProjectConfig, cwd: string): string[] {
+  const root = projectRootFromConfig(cfg, cwd)
+  if (cfg.functions?.path) {
+    return [resolve(root, cfg.functions.path)]
+  }
+  // Prefer modern default, but keep legacy fallback for compatibility.
+  return [resolve(root, "functions"), resolve(root, "supatype/functions")]
+}
+
+/** Preferred default functions path (used when creating new functions). */
+export function preferredFunctionsPathFromProject(cfg: SupatypeProjectConfig, cwd: string): string {
+  const candidates = functionsPathCandidatesFromProject(cfg, cwd)
+  for (const dir of candidates) {
+    if (existsSync(dir)) return dir
+  }
+  return candidates[0] ?? resolve(projectRootFromConfig(cfg, cwd), "functions")
+}
+
+/**
+ * Derive the supatype-server base URL from the project config.
+ * Returns undefined if the mode is "managed" (cloud controls the URL).
+ */
+export function serverBaseUrl(cfg: SupatypeProjectConfig): string | undefined {
+  const port = cfg.server.port ?? 54321
+  switch (cfg.server.mode) {
+    case "dev":
+    case "standalone":
+      if (cfg.server.mode === "dev" && resolveRuntimeProvider(cfg) === "docker") {
+        return `http://localhost:${COMPOSE_DEV_KONG_PORT}`
+      }
+      return cfg.server.domain
+        ? `https://${cfg.server.domain}`
+        : `http://localhost:${port}`
+    case "managed":
+      return undefined
+  }
+}
+
+/** Resolved runtime provider (`config.provider` ?? `database.provider` ?? native). */
+export function resolveRuntimeProvider(cfg: SupatypeProjectConfig): "native" | "docker" {
+  return cfg.provider ?? cfg.database.provider ?? "native"
+}
+
+/** Kong gateway port when `provider: docker` (self-host compose dev). */
+export const COMPOSE_DEV_KONG_PORT = 18473
+
+/** The local Postgres DSN derived from project name (dev default). */
+export function localDSN(cfg: SupatypeProjectConfig): string {
+  const port = 5432 // standard; per-project state dir isolates data dirs
+  return `postgres://postgres:postgres@127.0.0.1:${port}/${cfg.project.name}?sslmode=disable`
+}
+
+/**
+ * Resolve the database connection string.
+ * Prefers optional `connection` in config, then `DATABASE_URL` env, then a local default DSN.
+ */
+export function connectionString(cfg: SupatypeProjectConfig): string {
+  return cfg.connection ?? process.env["DATABASE_URL"] ?? localDSN(cfg)
+}

package/src/pull-utils.ts

@@ -0,0 +1,81 @@
+/**
+ * Utilities for the `pull` command — extracted for unit testability.
+ */
+
+export interface ColumnInfo {
+  name: string
+  pgType: string
+  nullable: boolean
+  isPrimary: boolean
+  isUnique: boolean
+  hasDefault: boolean
+}
+
+/** Engine `/introspect` column shape (see {@link IntrospectResult} in engine-client). */
+export interface IntrospectColumn {
+  name: string
+  type: string
+  nullable: boolean
+  default?: string
+  primaryKey?: boolean
+  unique?: boolean
+  references?: { table: string; column: string }
+}
+
+/** Map engine introspection JSON to {@link ColumnInfo} for {@link pgTypeToField}. */
+export function introspectColumnToColumnInfo(col: IntrospectColumn): ColumnInfo {
+  const def = col.default
+  return {
+    name: col.name,
+    pgType: col.type,
+    nullable: col.nullable,
+    isPrimary: col.primaryKey ?? false,
+    isUnique: col.unique ?? false,
+    hasDefault: def !== undefined && def !== "",
+  }
+}
+
+/** Map a Postgres column type to the corresponding field.X() call string. */
+export function pgTypeToField(col: ColumnInfo): string {
+  const opts: Record<string, unknown> = { required: !col.nullable }
+  if (col.isPrimary) opts["primaryKey"] = true
+  if (col.isUnique && !col.isPrimary) opts["unique"] = true
+  const optsStr = JSON.stringify(opts)
+
+  const type = col.pgType.toLowerCase()
+
+  if (type.includes("uuid")) return `field.uuid(${optsStr})`
+  if (type.includes("text") || type.includes("varchar") || type.includes("char"))
+    return `field.text(${optsStr})`
+  if (type.includes("int8") || type.includes("bigint")) return `field.bigInt(${optsStr})`
+  if (type.includes("int2") || type.includes("smallint")) return `field.smallInt(${optsStr})`
+  if (type.includes("interval")) return `field.interval(${optsStr})`
+  if (type.includes("int") || type.includes("serial")) return `field.integer(${optsStr})`
+  if (type.includes("float") || type.includes("double") || type.includes("real"))
+    return `field.float(${optsStr})`
+  if (type.includes("numeric") || type.includes("decimal")) return `field.decimal(${optsStr})`
+  if (type.includes("bool")) return `field.boolean(${optsStr})`
+  if (type.includes("timestamptz") || type.includes("timestamp with time zone"))
+    return `field.datetime(${optsStr})`
+  if (type.includes("timestamp")) return `field.timestamp(${optsStr})`
+  if (type.includes("date")) return `field.date(${optsStr})`
+  if (type.includes("jsonb")) return `field.json({ ...${optsStr}, jsonb: true })`
+  if (type.includes("json")) return `field.json(${optsStr})`
+  if (type.includes("inet")) return `field.ip(${optsStr})`
+  if (type.includes("cidr")) return `field.cidr(${optsStr})`
+  if (type.includes("macaddr")) return `field.macaddr(${optsStr})`
+  if (type.includes("bytea")) return `field.bytea(${optsStr})`
+  if (type.includes("money")) return `field.money(${optsStr})`
+  if (type.includes("xml")) return `field.xml(${optsStr})`
+  if (type.includes("tsvector")) return `field.tsvector(${optsStr})`
+  if (type.includes("tsquery")) return `field.tsquery(${optsStr})`
+
+  return `field.text({ ...${optsStr} }) /* TODO: ${col.pgType} */`
+}
+
+/** Convert snake_case table name to PascalCase model export name. */
+export function toCamelCase(s: string): string {
+  return s
+    .replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
+    .replace(/^([a-z])/, (c: string) => c.toUpperCase())
+}