@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/process-manager.ts

@@ -3,10 +3,11 @@
  * colored prefix, and restart on crash with exponential backoff.
  */
 
-import { type ChildProcess, spawn } from "node:child_process"
+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). */
@@ -27,6 +28,12 @@ export interface ProcessOptions {
   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
+  /** Called before auto-restart after a non-zero exit (e.g. free a stale port). */
+  beforeRestart?: () => void
 }
 
 const RESET = "\x1b[0m"
@@ -35,13 +42,24 @@ export class ProcessManager {
   private child: ChildProcess | null = null
   private stopped = false
   private backoffMs: number
-  private opts: Required<ProcessOptions>
+  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(),
@@ -50,7 +68,7 @@ export class ProcessManager {
       maxBackoffMs: 30_000,
       onExit: () => {},
       shell: false,
-      ...opts,
+      ...merged,
     }
     this.backoffMs = this.opts.initialBackoffMs
   }
@@ -64,7 +82,20 @@ export class ProcessManager {
   /** Stop the process and clear the PID file. */
   async stop(): Promise<void> {
     this.stopped = true
-    if (this.child && !this.child.killed) {
+    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) => {
@@ -99,22 +130,43 @@ export class ProcessManager {
       ? `${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")) {
-        if (line) process.stdout.write(prefix + line + "\n")
+        logLine(line, process.stdout)
       }
     })
 
     this.child.stderr?.on("data", (chunk: Buffer) => {
       for (const line of chunk.toString().split("\n")) {
-        if (line) process.stderr.write(prefix + line + "\n")
+        logLine(line, process.stderr)
       }
     })
 
     this.child.once("error", (err) => {
       if (this.stopped) return
-      process.stderr.write(`${prefix}failed to start: ${err.message}\n`)
+      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.opts.beforeRestart?.()
         this.backoffMs = Math.min(this.backoffMs * 2, this.opts.maxBackoffMs)
         this.spawn()
       }, this.backoffMs)
@@ -129,11 +181,15 @@ export class ProcessManager {
       }
 
       const reason = signal ? `signal ${signal}` : `code ${code}`
-      process.stderr.write(
-        `${prefix}process exited (${reason}), restarting in ${this.backoffMs}ms\n`,
-      )
+      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.opts.beforeRestart?.()
         this.backoffMs = Math.min(this.backoffMs * 2, this.opts.maxBackoffMs)
         this.spawn()
       }, this.backoffMs)

package/src/project-config.ts

@@ -59,6 +59,16 @@ export interface SupatypeProjectConfig {
     postgrestPort?: number
     /** Domain for ACME TLS certificate (mode=standalone). */
     domain?: string
+    /**
+     * TLS for self-host HTTPS (Kong ACME / Let's Encrypt).
+     * Requires `mode: "standalone"` and a non-empty `domain`.
+     */
+    tls?: {
+      /** ACME contact email for Let's Encrypt (required to enable HTTPS). */
+      email?: string
+      /** "kong" (default) = Kong acme plugin; "none" = stay HTTP even with a domain. */
+      provider?: "kong" | "none"
+    }
   }
   app: {
     /**
@@ -85,10 +95,13 @@ export interface SupatypeProjectConfig {
     start?: string
   }
   /**
-   * Pinned binary versions per component. Use **`"local"`** with the matching **`overrides.*`**
-   * entry when testing a local build (Phase 10.7).
+   * 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: ComponentVersions
+  versions?: Partial<ComponentVersions>
   /**
    * Override component binaries with local build paths.
    * Intended for supatype contributors testing local changes.
@@ -198,6 +211,14 @@ export interface SupatypeProjectConfig {
     /** Custom response headers for the deployed static site. */
     headers?: Record<string, string>
   }
+  /**
+   * Persistent environment defaults for `resolveTarget()` when `--env` is omitted.
+   * Ephemeral schema branches (Phase 22) use `.supatype/branch.json`, not this block.
+   */
+  environments?: {
+    default?: string
+    branchDefaults?: 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.
@@ -233,7 +254,9 @@ export function mergeProjectConfig(
     database: { ...base.database, ...override.database },
     server: { ...base.server, ...override.server },
     app: { ...base.app, ...override.app },
-    versions: { ...base.versions, ...override.versions },
+    ...(base.versions !== undefined || override.versions !== undefined
+      ? { versions: { ...base.versions, ...override.versions } }
+      : {}),
     ...(base.overrides !== undefined || override.overrides !== undefined
       ? {
           overrides: {
@@ -285,6 +308,23 @@ export function mergeProjectConfig(
     ...(base.admin !== undefined || override.admin !== undefined
       ? { admin: { ...base.admin, ...override.admin } as NonNullable<SupatypeProjectConfig["admin"]> }
       : {}),
+    ...(base.environments !== undefined || override.environments !== undefined
+      ? (() => {
+          const b = base.environments
+          const o = override.environments
+          const mergedBranchDefaults =
+            b?.branchDefaults !== undefined || o?.branchDefaults !== undefined
+              ? { ...(b?.branchDefaults ?? {}), ...(o?.branchDefaults ?? {}) }
+              : undefined
+          return {
+            environments: {
+              ...b,
+              ...o,
+              ...(mergedBranchDefaults !== undefined ? { branchDefaults: mergedBranchDefaults } : {}),
+            } as NonNullable<SupatypeProjectConfig["environments"]>,
+          }
+        })()
+      : {}),
   }
 }
 
@@ -307,9 +347,6 @@ export function validateProjectConfig(raw: unknown, filename: string): SupatypeP
   if (!cfg["app"]) {
     throw new Error(`${filename}: app section is required`)
   }
-  if (!cfg["versions"]) {
-    throw new Error(`${filename}: versions section is required`)
-  }
 
   return raw as SupatypeProjectConfig
 }
@@ -363,6 +400,24 @@ export function serverBaseUrl(cfg: SupatypeProjectConfig): string | undefined {
   }
 }
 
+/**
+ * True when `supatype self-host compose` should render Kong ACME TLS (Let's Encrypt).
+ * Gated on a real self-host render (not `supatype dev`), standalone mode, a non-empty
+ * domain, an ACME contact email, and `tls.provider !== "none"`.
+ */
+export function selfHostTlsEnabled(
+  cfg: SupatypeProjectConfig,
+  devLocal = false,
+): boolean {
+  if (devLocal) return false
+  if (cfg.server.mode !== "standalone") return false
+  const domain = cfg.server.domain?.trim()
+  if (!domain) return false
+  const tls = cfg.server.tls
+  if (!tls || tls.provider === "none") return false
+  return Boolean(tls.email?.trim())
+}
+
 /** Resolved runtime provider (`config.provider` ?? `database.provider` ?? native). */
 export function resolveRuntimeProvider(cfg: SupatypeProjectConfig): "native" | "docker" {
   return cfg.provider ?? cfg.database.provider ?? "native"

package/src/prompts.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from `./ui/prompts.js` or `./ui/index.js`. */
+export { printLogo, ensureNotCancelled, clack } from "./ui/prompts.js"

package/src/pull-utils.ts

@@ -1,41 +1,237 @@
 /**
- * Utilities for the `pull` command — extracted for unit testability.
+ * Utilities for `pull` and `introspect` — map engine DatabaseState to Model<> scaffold.
  */
 
-export interface ColumnInfo {
+export interface DbColumnState {
   name: string
-  pgType: string
+  dataType: string
+  udtName: string
   nullable: boolean
+  default?: string | null
+  ordinalPosition?: number
+}
+
+export interface DbTableState {
+  schema?: string
+  name: string
+  columns: DbColumnState[]
+}
+
+export interface DbConstraintState {
+  table: string
+  name: string
+  constraintType: string
+  columns: string[]
+  foreignTable?: string | null
+  foreignColumns?: string[] | null
+  comment?: string | null
+}
+
+export interface DbIndexState {
+  table: string
+  name: string
+  columns: string[]
+  unique: boolean
+  method: string
   isPrimary: boolean
-  isUnique: boolean
-  hasDefault: boolean
+  comment?: string | null
 }
 
-/** Engine `/introspect` column shape (see {@link IntrospectResult} in engine-client). */
-export interface IntrospectColumn {
+export interface DatabaseStateJson {
+  schema?: string
+  tables: DbTableState[]
+  constraints?: DbConstraintState[]
+  indexes?: DbIndexState[]
+}
+
+export interface ColumnInfo {
   name: string
-  type: string
+  pgType: string
   nullable: boolean
-  default?: string
-  primaryKey?: boolean
-  unique?: boolean
+  isPrimary: boolean
+  isUnique: boolean
+  hasDefault: 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
+/** Map engine introspection column to {@link ColumnInfo}. */
+export function introspectColumnToColumnInfo(col: DbColumnState): ColumnInfo {
   return {
     name: col.name,
-    pgType: col.type,
+    pgType: col.udtName || col.dataType,
     nullable: col.nullable,
-    isPrimary: col.primaryKey ?? false,
-    isUnique: col.unique ?? false,
-    hasDefault: def !== undefined && def !== "",
+    isPrimary: col.name === "id" && (col.udtName === "uuid" || col.dataType.includes("uuid")),
+    isUnique: false,
+    hasDefault: col.default != null && col.default !== "",
+  }
+}
+
+function singleColumnUniques(
+  table: string,
+  constraints: DbConstraintState[] | undefined,
+): Map<string, boolean> {
+  const out = new Map<string, boolean>()
+  for (const c of constraints ?? []) {
+    if (c.table !== table || c.constraintType !== "unique" || c.columns.length !== 1) continue
+    out.set(c.columns[0]!, true)
   }
+  return out
 }
 
-/** Map a Postgres column type to the corresponding field.X() call string. */
+function compositeIndexes(
+  table: string,
+  indexes: DbIndexState[] | undefined,
+): Array<{ fields: string[]; unique: boolean }> {
+  const out: Array<{ fields: string[]; unique: boolean }> = []
+  for (const idx of indexes ?? []) {
+    if (idx.table !== table || idx.isPrimary || idx.columns.length < 2) continue
+    out.push({ fields: idx.columns, unique: idx.unique })
+  }
+  return out
+}
+
+/** Map a Postgres column to a Model<> field type string (draft). */
+export function pgTypeToModelField(col: ColumnInfo): string {
+  const name = col.name
+  const type = col.pgType.toLowerCase()
+  const optional = col.nullable ? "Optional<" : ""
+  const optionalClose = col.nullable ? ">" : ""
+
+  if (name === "id" && type.includes("uuid")) {
+    return `id: SupatypeAuthUserId`
+  }
+  if (name.endsWith("_id") && type.includes("uuid")) {
+    const base = name.replace(/_id$/, "")
+    const rel = base.replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
+    const relName = rel.charAt(0).toUpperCase() + rel.slice(1)
+    return `${name}: UUID\n  // TODO: relation — RelatedTo<"${relName}">`
+  }
+  if (name === "created_at" || name === "updated_at") {
+    return `${name}: Timestamp`
+  }
+  if (name === "deleted_at") {
+    return `${name}: Optional<Timestamp>`
+  }
+  if (type.includes("timestamptz") || type.includes("timestamp with time zone")) {
+    return `${name}: ${optional}Timestamp${optionalClose}`
+  }
+  if (type.includes("uuid")) {
+    const inner = col.isUnique ? "Unique<UUID>" : "UUID"
+    return `${name}: ${optional}${inner}${optionalClose}`
+  }
+  if (name.includes("email") && (type.includes("text") || type.includes("varchar"))) {
+    const inner = col.isUnique ? "Unique<Email>" : "Email"
+    return `${name}: ${optional}${inner}${optionalClose}`
+  }
+  if (name === "slug" || name.endsWith("_slug")) {
+    return `${name}: Slug<"title">`
+  }
+  if (type.includes("jsonb")) {
+    return `${name}: ${optional}JSON${optionalClose}`
+  }
+  if (type.includes("bool")) {
+    return `${name}: ${optional}boolean${optionalClose}`
+  }
+  if (type.includes("int8") || type.includes("bigint")) {
+    return `${name}: ${optional}BigInt${optionalClose}`
+  }
+  if (type.includes("int")) {
+    return `${name}: ${optional}Int${optionalClose}`
+  }
+  if (type.includes("text") || type.includes("varchar")) {
+    const inner = col.isUnique ? "Unique<string>" : "string"
+    return `${name}: ${optional}${inner}${optionalClose}`
+  }
+
+  return `${name}: string /* TODO: ${col.pgType} */`
+}
+
+/** Convert snake_case table name to PascalCase model export name. */
+export function toModelName(s: string): string {
+  return s
+    .replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
+    .replace(/^([a-z])/, (c: string) => c.toUpperCase())
+}
+
+/** Generate draft schema/index.ts content from introspected DatabaseState. */
+export function databaseStateToSchemaScaffold(state: DatabaseStateJson): string {
+  const constraints = state.constraints ?? []
+  const indexes = state.indexes ?? []
+  const skipTables = new Set(["spatial_ref_sys", "schema_migrations"])
+
+  const lines: string[] = [
+    "// DRAFT — generated by `supatype pull`. Review access rules, relations, and indexes before push.",
+    'import type { Model, Public, UUID, Timestamp, Optional, Unique, Email, Slug, SupatypeAuthUserId, JSON, Int, BigInt } from "@supatype/types"',
+    "",
+  ]
+
+  for (const table of state.tables) {
+    if (skipTables.has(table.name) || table.name.startsWith("_")) continue
+
+    const modelName = toModelName(table.name)
+    const uniques = singleColumnUniques(table.name, constraints)
+    const modelIndexes = compositeIndexes(table.name, indexes)
+
+    const fieldLines: string[] = []
+    for (const col of table.columns) {
+      if (col.name === "created_at" || col.name === "updated_at") continue
+      const info = introspectColumnToColumnInfo(col)
+      info.isPrimary = col.name === "id"
+      info.isUnique = uniques.get(col.name) ?? false
+      fieldLines.push(`  ${pgTypeToModelField(info)}`)
+    }
+
+    const hasTimestamps = table.columns.some((c) => c.name === "created_at")
+    if (hasTimestamps) {
+      fieldLines.push("  created_at: Timestamp")
+      fieldLines.push("  updated_at: Timestamp")
+    }
+
+    const indexBlock =
+      modelIndexes.length > 0
+        ? `\n  indexes: [\n${modelIndexes
+            .map(
+              (idx) =>
+                `    { fields: [${idx.fields.map((f) => `"${f}"`).join(", ")}]${idx.unique ? ", unique: true" : ""} },`,
+            )
+            .join("\n")}\n  ],`
+        : ""
+
+    lines.push(`export type ${modelName} = Model<{`)
+    lines.push(fieldLines.join("\n"))
+    lines.push(`}, {`)
+    lines.push(`  access: {`)
+    lines.push(`    read: Public`)
+    lines.push(`    create: Public`)
+    lines.push(`    update: Public`)
+    lines.push(`    delete: Public`)
+    lines.push(`  },${indexBlock}`)
+    lines.push(`}>`)
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}
+
+/** Human-readable introspection summary for `supatype introspect`. */
+export function printIntrospectSummary(state: DatabaseStateJson): void {
+  console.log(`Schema: ${state.schema ?? "public"}`)
+  console.log(`Tables: ${state.tables.length}`)
+  for (const table of state.tables) {
+    console.log(`\n  ${table.name} (${table.columns.length} columns)`)
+    for (const col of table.columns) {
+      const nullMark = col.nullable ? "?" : ""
+      console.log(`    ${col.name}${nullMark}: ${col.udtName || col.dataType}`)
+    }
+  }
+  const constraintCount = state.constraints?.length ?? 0
+  const indexCount = state.indexes?.length ?? 0
+  if (constraintCount + indexCount > 0) {
+    console.log(`\nConstraints: ${constraintCount}, Indexes: ${indexCount}`)
+  }
+}
+
+/** @deprecated Legacy pull helper — use {@link pgTypeToModelField}. */
 export function pgTypeToField(col: ColumnInfo): string {
   const opts: Record<string, unknown> = { required: !col.nullable }
   if (col.isPrimary) opts["primaryKey"] = true
@@ -73,9 +269,7 @@ export function pgTypeToField(col: ColumnInfo): string {
   return `field.text({ ...${optsStr} }) /* TODO: ${col.pgType} */`
 }
 
-/** Convert snake_case table name to PascalCase model export name. */
+/** @deprecated Use {@link toModelName}. */
 export function toCamelCase(s: string): string {
-  return s
-    .replace(/_([a-z])/g, (_, c: string) => c.toUpperCase())
-    .replace(/^([a-z])/, (c: string) => c.toUpperCase())
+  return toModelName(s)
 }