@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/src/type-extractor.ts

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from "node:fs"
-import { dirname, isAbsolute, resolve } from "node:path"
+import { existsSync, readFileSync, realpathSync } from "node:fs"
+import { createHash } from "node:crypto"
+import { dirname, isAbsolute, relative, resolve } from "node:path"
 import ts from "typescript"
 import {
   applyImportRename,
@@ -103,7 +104,7 @@ export function extractSchemaAstFromTypes(
         )
       }
 
-      const { tableName, access, options } = parseModelMeta(
+      const { tableName, access, options, indexes } = parseModelMeta(
         metaArg,
         sourceFile,
         stmt.name.text,
@@ -112,7 +113,7 @@ export function extractSchemaAstFromTypes(
       )
 
       models.push(
-        emitModel(stmt.name.text, fields, options, tableName, access),
+        emitModel(stmt.name.text, fields, options, tableName, access, indexes),
       )
     }
   }
@@ -143,9 +144,51 @@ export function extractSchemaAstFromTypes(
   })
 }
 
-function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
+export interface SchemaSourceFile {
+  relativePath: string
+  absolutePath: string
+  sha256: string
+  bytes: number
+}
+
+export interface SchemaSourceGraph {
+  entryPoint: string
+  files: SchemaSourceFile[]
+}
+
+export function collectSchemaSourcePaths(entryAbsPath: string, projectRoot: string): SchemaSourceGraph {
+  const root = resolve(projectRoot)
+  const entryReal = realpathSync(entryAbsPath)
+  const entryPoint = relative(root, entryReal).replace(/\\/g, "/")
+  if (entryPoint.startsWith("..")) {
+    throw new Error(`Schema entry must be under project root: ${entryAbsPath}`)
+  }
+
+  const absolutePaths = walkSchemaSourceAbsPaths(entryReal)
+  const files: SchemaSourceFile[] = []
+
+  for (const abs of absolutePaths) {
+    const real = realpathSync(abs)
+    const rel = relative(root, real).replace(/\\/g, "/")
+    if (rel.startsWith("..")) {
+      throw new Error(`Schema source escapes project root: ${abs}`)
+    }
+    const content = readFileSync(real)
+    files.push({
+      relativePath: rel,
+      absolutePath: real,
+      sha256: createHash("sha256").update(content).digest("hex"),
+      bytes: content.length,
+    })
+  }
+
+  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
+  return { entryPoint, files }
+}
+
+function walkSchemaSourceAbsPaths(entryPath: string): string[] {
   const visited = new Set<string>()
-  const sourceFiles: ts.SourceFile[] = []
+  const paths: string[] = []
   const queue: string[] = [entryPath]
 
   while (queue.length > 0) {
@@ -153,12 +196,11 @@ function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
     if (!currentPath) continue
     if (visited.has(currentPath)) continue
     visited.add(currentPath)
-
     if (!existsSync(currentPath)) continue
+    paths.push(currentPath)
+
     const sourceText = readFileSync(currentPath, "utf8")
     const sourceFile = ts.createSourceFile(currentPath, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
-    sourceFiles.push(sourceFile)
-
     const baseDir = dirname(currentPath)
     for (const stmt of sourceFile.statements) {
       let specifier: string | undefined
@@ -178,7 +220,14 @@ function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
     }
   }
 
-  return sourceFiles
+  return paths
+}
+
+function loadSchemaSourceFiles(entryPath: string): ts.SourceFile[] {
+  return walkSchemaSourceAbsPaths(entryPath).map((abs) => {
+    const sourceText = readFileSync(abs, "utf8")
+    return ts.createSourceFile(abs, sourceText, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS)
+  })
 }
 
 function resolveTypeModulePath(fromDir: string, specifier: string): string | null {
@@ -1372,7 +1421,12 @@ function parseModelMeta(
   modelName: string,
   fieldsArg: ts.TypeNode,
   fields: Record<string, FieldAstV2>,
-): { tableName: string; access: Record<string, unknown>; options: Record<string, unknown> } {
+): {
+  tableName: string
+  access: Record<string, unknown>
+  options: Record<string, unknown>
+  indexes: unknown[]
+} {
   const literal = parseMetaLiteral(metaArg, sourceFile)
   const singleton = literal.singleton === true
   const tableName =
@@ -1397,7 +1451,66 @@ function parseModelMeta(
     tableName,
     access: parseModelAccess(metaArg, sourceFile),
     options,
+    indexes: parseModelIndexes(metaArg, sourceFile, fields),
+  }
+}
+
+function parseModelIndexes(
+  metaArg: ts.TypeNode | undefined,
+  sourceFile: ts.SourceFile,
+  fields: Record<string, FieldAstV2>,
+): unknown[] {
+  if (!metaArg || !ts.isTypeLiteralNode(metaArg)) return []
+
+  const indexesProp = metaArg.members.find(
+    (member) => ts.isPropertySignature(member) && getPropertyName(member.name) === "indexes",
+  )
+  if (
+    !indexesProp ||
+    !ts.isPropertySignature(indexesProp) ||
+    !indexesProp.type ||
+    !ts.isTupleTypeNode(indexesProp.type)
+  ) {
+    return []
+  }
+
+  const indexes: unknown[] = []
+  for (const element of indexesProp.type.elements) {
+    if (!ts.isTypeLiteralNode(element)) continue
+    const indexDef: Record<string, unknown> = { using: "btree" }
+    for (const member of element.members) {
+      if (!ts.isPropertySignature(member) || !member.type) continue
+      const key = getPropertyName(member.name)
+      if (!key) continue
+      if (key === "name" && ts.isLiteralTypeNode(member.type) && ts.isStringLiteral(member.type.literal)) {
+        indexDef.name = member.type.literal.text
+      } else if (key === "unique" && isBooleanLiteralType(member.type, true)) {
+        indexDef.unique = true
+      } else if (key === "fields" && ts.isTupleTypeNode(member.type)) {
+        indexDef.fields = member.type.elements
+          .map((fieldNode) => {
+            if (!ts.isLiteralTypeNode(fieldNode) || !ts.isStringLiteral(fieldNode.literal)) return null
+            return resolveIndexFieldName(fieldNode.literal.text, fields)
+          })
+          .filter((field): field is string => field !== null)
+      }
+    }
+    if (Array.isArray(indexDef.fields) && indexDef.fields.length > 0) {
+      indexes.push(indexDef)
+    }
+  }
+  return indexes
+}
+
+function resolveIndexFieldName(fieldName: string, fields: Record<string, FieldAstV2>): string | null {
+  if (fields[fieldName] !== undefined) {
+    const field = fields[fieldName]
+    if (field.kind === "relation" && field.annotations?.db?.foreignKey) {
+      return field.annotations.db.foreignKey as string
+    }
+    return fieldName
   }
+  return fieldName
 }
 
 function parseModelAccess(metaArg: ts.TypeNode | undefined, sourceFile: ts.SourceFile): Record<string, unknown> {

package/src/ui/README.md

@@ -0,0 +1,17 @@
+# CLI terminal UI (`packages/cli/src/ui/`)
+
+Shared output layer for `supatype` commands (not `supatype dev` TUI).
+
+| Module | Use for |
+|--------|---------|
+| `messages.ts` | `info` / `warn` / `error` (Clack log in TTY; `[supatype]` in CI), `file`, `step`, `plain` |
+| `fatal.ts` | `fatalError`, `reportCliFatal` — branded fatals + global catch helper |
+| `confirm.ts` | Yes/no prompts (Clack in TTY; respects `--yes` / non-TTY) |
+| `progress.ts` | `withSpinner` for long async work |
+| `prompts.ts` | Logo, Clack wizard helpers, `promptText` |
+| `next-steps.ts` | Bulleted follow-up commands |
+| `brand.ts` | ANSI colours + logo styling (shared with dev TUI) |
+
+**`supatype dev`** keeps its own alt-screen TUI (`dev-tui.ts`). Do not route dev logs through Clack.
+
+**Convention:** interactive multi-step flows use Clack (`init`, `add`, `link`); one-shot commands use `info` + optional `withSpinner`.

package/src/ui/brand.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared ANSI styling for Supatype CLI output and the dev TUI.
+ */
+
+export const RESET = "\x1b[0m"
+export const DIM = "\x1b[2m"
+export const BOLD = "\x1b[1m"
+export const BRAND_COLOR = "\x1b[35m"
+
+export function brandStyle(text: string): string {
+  return `${BRAND_COLOR}${BOLD}${text}${RESET}`
+}

package/src/ui/confirm.ts

@@ -0,0 +1,38 @@
+import * as p from "@clack/prompts"
+import { isInteractive } from "./interactive.js"
+import { plain } from "./messages.js"
+
+export interface ConfirmOptions {
+  default?: boolean
+  /** When non-interactive, return this instead of `default` (e.g. require --yes). */
+  nonInteractive?: boolean
+}
+
+/**
+ * Yes/no confirmation — Clack in TTY, plain prompt or default otherwise.
+ */
+export async function confirm(message: string, opts: ConfirmOptions = {}): Promise<boolean> {
+  const fallback = opts.nonInteractive ?? opts.default ?? false
+
+  if (!isInteractive()) {
+    if (opts.nonInteractive !== undefined) return opts.nonInteractive
+    return fallback
+  }
+
+  const value = await p.confirm({
+    message,
+    initialValue: opts.default ?? false,
+  })
+
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.")
+    process.exit(0)
+  }
+
+  return value
+}
+
+/** Legacy-style y/N prompt text for non-TTY logs when skipping confirm. */
+export function logSkippedConfirm(reason: string): void {
+  plain(`${reason} (use --yes to skip confirmation)`)
+}

package/src/ui/fatal.ts

@@ -0,0 +1,43 @@
+import * as p from "@clack/prompts"
+import type { DockerBrandOptions } from "../docker-runtime.js"
+import { isInteractive } from "./interactive.js"
+import { error, plain } from "./messages.js"
+import { clack, printLogo } from "./prompts.js"
+
+export type FatalOptions = {
+  brand?: DockerBrandOptions
+  exitCode?: number
+}
+
+/** Print a fatal headline + optional hint block, then exit. */
+export function fatalError(message: string, hints: string[] = [], opts?: FatalOptions): never {
+  if (opts?.brand && isInteractive()) {
+    printLogo()
+    clack.intro(opts.brand.intro)
+  }
+
+  error(message)
+
+  if (hints.length > 0) {
+    if (isInteractive()) {
+      p.note(hints.join("\n\n"))
+    } else {
+      for (const hint of hints) {
+        plain()
+        plain(`  ${hint}`)
+      }
+    }
+  }
+
+  process.exit(opts?.exitCode ?? 1)
+}
+
+/** Top-level CLI catch — user-facing message without branding. */
+export function reportCliFatal(err: unknown): void {
+  const message = err instanceof Error ? err.message : String(err)
+  error(message)
+  if (process.env["SUPATYPE_DEBUG"] === "1" && err instanceof Error && err.stack) {
+    plain()
+    plain(err.stack)
+  }
+}

package/src/ui/index.ts

@@ -0,0 +1,8 @@
+export * from "./brand.js"
+export * from "./interactive.js"
+export * from "./messages.js"
+export * from "./fatal.js"
+export * from "./confirm.js"
+export * from "./progress.js"
+export * from "./next-steps.js"
+export * from "./prompts.js"

package/src/ui/interactive.ts

@@ -0,0 +1,4 @@
+/** True when stdin/stdout are TTYs — interactive prompts and spinners are allowed. */
+export function isInteractive(): boolean {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY)
+}

package/src/ui/messages.ts

@@ -0,0 +1,43 @@
+import * as p from "@clack/prompts"
+import { isInteractive } from "./interactive.js"
+
+export const SUPATYPE_PREFIX = "[supatype]"
+
+export function info(message: string): void {
+  if (isInteractive()) {
+    p.log.info(message)
+    return
+  }
+  console.log(`${SUPATYPE_PREFIX} ${message}`)
+}
+
+export function warn(message: string): void {
+  if (isInteractive()) {
+    p.log.warn(message)
+    return
+  }
+  console.warn(`${SUPATYPE_PREFIX} ${message}`)
+}
+
+export function error(message: string): void {
+  if (isInteractive()) {
+    p.log.error(message)
+    return
+  }
+  console.error(`${SUPATYPE_PREFIX} ${message}`)
+}
+
+/** Unprefixed line (tables, diff output, blank lines). */
+export function plain(message = ""): void {
+  console.log(message)
+}
+
+export function step(title: string): void {
+  console.log(`\n${title}`)
+}
+
+export type FileAction = "created" | "updated" | "skipped" | "removed" | "wrote"
+
+export function file(action: FileAction, rel: string): void {
+  console.log(`  ${action}  ${rel}`)
+}

package/src/ui/next-steps.ts

@@ -0,0 +1,10 @@
+import { plain } from "./messages.js"
+
+/** Print a numbered or bulleted “next steps” block. */
+export function nextSteps(title: string, steps: string[]): void {
+  plain(`\n${title}`)
+  for (const step of steps) {
+    plain(`  ${step}`)
+  }
+  plain()
+}

package/src/ui/progress.ts

@@ -0,0 +1,28 @@
+import * as p from "@clack/prompts"
+import { isInteractive } from "./interactive.js"
+import { info } from "./messages.js"
+
+/**
+ * Run an async task with a Clack spinner (TTY) or a plain status line (CI/pipes).
+ */
+export async function withSpinner<T>(
+  message: string,
+  task: () => Promise<T>,
+  doneMessage?: string,
+): Promise<T> {
+  if (!isInteractive()) {
+    info(`${message}...`)
+    return task()
+  }
+
+  const spinner = p.spinner()
+  spinner.start(message)
+  try {
+    const result = await task()
+    spinner.stop(doneMessage ?? message)
+    return result
+  } catch (err) {
+    spinner.stop("Failed")
+    throw err
+  }
+}

package/src/ui/prompts.ts

@@ -0,0 +1,40 @@
+import * as p from "@clack/prompts"
+import { SUPATYPE_ASCII_LOGO_WORDMARK, colorLogoLines } from "../dev-logo.js"
+import { plain } from "./messages.js"
+import { isInteractive } from "./interactive.js"
+
+/** Print the coloured Supatype ASCII wordmark at the top of an interactive command. */
+export function printLogo(): void {
+  plain()
+  plain(colorLogoLines([...SUPATYPE_ASCII_LOGO_WORDMARK]).join("\n"))
+  plain()
+}
+
+/**
+ * Unwrap a clack prompt result, exiting cleanly when the user cancels (Ctrl-C).
+ */
+export function ensureNotCancelled<T>(value: T | symbol, cancelMessage = "Cancelled."): T {
+  if (p.isCancel(value)) {
+    p.cancel(cancelMessage)
+    process.exit(0)
+  }
+  return value as T
+}
+
+/** Single-line text input via Clack (TTY only). */
+export async function promptText(
+  message: string,
+  opts?: { defaultValue?: string; placeholder?: string },
+): Promise<string> {
+  if (!isInteractive()) {
+    throw new Error(`Cannot prompt for "${message}" in non-interactive mode.`)
+  }
+  const value = await p.text({
+    message,
+    ...(opts?.defaultValue !== undefined ? { defaultValue: opts.defaultValue } : {}),
+    ...(opts?.placeholder !== undefined ? { placeholder: opts.placeholder } : {}),
+  })
+  return ensureNotCancelled(value).trim()
+}
+
+export { p as clack }

package/tests/admin-ensure.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it } from "vitest"
+import {
+  ADMIN_EMAIL_ENV,
+  ADMIN_PASSWORD_ENV,
+  clearAdminSeedPassword,
+  hashPasswordForAuth,
+} from "../src/commands/admin.js"
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { scaffold, defaultScaffoldOptions } from "../src/commands/init.js"
+
+describe("hashPasswordForAuth", () => {
+  it("produces a bcrypt hash", async () => {
+    const hash = await hashPasswordForAuth("test-password-123")
+    expect(hash.startsWith("$2")).toBe(true)
+  })
+})
+
+describe("clearAdminSeedPassword", () => {
+  it("removes SUPATYPE_ADMIN_PASSWORD from .env", () => {
+    const dir = join(tmpdir(), `supatype-admin-seed-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    writeFileSync(
+      join(dir, ".env"),
+      `${ADMIN_EMAIL_ENV}=admin@example.com\n${ADMIN_PASSWORD_ENV}=secret123\nJWT_SECRET=x\n`,
+      "utf8",
+    )
+    try {
+      clearAdminSeedPassword(dir)
+      const content = readFileSync(join(dir, ".env"), "utf8")
+      expect(content).toContain(`${ADMIN_EMAIL_ENV}=admin@example.com`)
+      expect(content).not.toContain(ADMIN_PASSWORD_ENV)
+      expect(content).toContain("JWT_SECRET=x")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})
+
+describe("init admin seed in .env", () => {
+  it("writes SUPATYPE_ADMIN_* when scaffold options include credentials", () => {
+    const dir = join(tmpdir(), `supatype-init-admin-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    try {
+      scaffold(dir, {
+        ...defaultScaffoldOptions("seeded-app"),
+        adminEmail: "admin@example.com",
+        adminPassword: "password123",
+      })
+      const env = readFileSync(join(dir, ".env"), "utf8")
+      expect(env).toContain("SUPATYPE_ADMIN_EMAIL=admin@example.com")
+      expect(env).toContain("SUPATYPE_ADMIN_PASSWORD=password123")
+      expect(existsSync(join(dir, ".env"))).toBe(true)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})

package/tests/cli-help.test.ts

@@ -33,6 +33,9 @@ describe("CLI binary (requires built dist/)", () => {
       "push",
       "diff",
       "pull",
+      "doctor",
+      "introspect",
+      "adopt",
       "generate",
       "migrate",
       "rollback",
@@ -79,10 +82,32 @@ describe("CLI binary (requires built dist/)", () => {
     expect(stdout).toContain("dry run")
   })
 
-  it("pull --help describes deprecated pull command", () => {
+  it("pull --help describes scaffold pull command", () => {
     const { stdout, exitCode } = runCli(["pull", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("deprecated")
+    expect(stdout).toContain("Scaffold")
+    expect(stdout).toContain("--dry-run")
+  })
+
+  it("doctor --help describes drift report command", () => {
+    const { stdout, exitCode } = runCli(["doctor", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("drift")
+    expect(stdout).toContain("--strict")
+  })
+
+  it("introspect --help describes database introspection command", () => {
+    const { stdout, exitCode } = runCli(["introspect", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("Introspect")
+    expect(stdout).toContain("--json")
+  })
+
+  it("adopt --help describes adoption ceremony command", () => {
+    const { stdout, exitCode } = runCli(["adopt", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("adopt")
+    expect(stdout).toContain("--yes")
   })
 
   it("reset --help shows --yes flag", () => {

package/tests/config.test.ts

@@ -101,7 +101,7 @@ describe("loadConfig()", () => {
     expect(cfg.connection).toBe("postgresql://localhost/jsdb")
   })
 
-  it("throws if config is missing the versions section", () => {
+  it("loads config without a versions section (latest by default)", () => {
     writeFileSync(
       join(tmpDir, "supatype.config.ts"),
       `export default {
@@ -112,7 +112,8 @@ describe("loadConfig()", () => {
   schema: { path: "./schema/index.ts" },
 }`,
     )
-    expect(() => loadConfig(tmpDir)).toThrow(/versions/)
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.versions).toBeUndefined()
   })
 
   it("prefers supatype.config.ts over supatype.config.js when both exist", () => {
@@ -248,4 +249,30 @@ describe("mergeProjectConfig()", () => {
     expect(merged.app.start).toBe("dev:site")
     expect(merged.app.static_dir).toBe("./dist")
   })
+
+  it("preserves base environments when a local override sets only server.mode", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      server: { mode: "standalone", domain: "api.example.com" },
+      environments: { default: "production" },
+    })
+    const merged = mergeProjectConfig(base, { server: { mode: "dev" } })
+    expect(merged.server.mode).toBe("dev")
+    expect(merged.environments?.default).toBe("production")
+  })
+
+  it("deep-merges environments.branchDefaults across base and override", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      environments: { default: "production", branchDefaults: { main: "production" } },
+    })
+    const merged = mergeProjectConfig(base, {
+      environments: { branchDefaults: { staging: "preview" } },
+    })
+    expect(merged.environments?.default).toBe("production")
+    expect(merged.environments?.branchDefaults).toEqual({
+      main: "production",
+      staging: "preview",
+    })
+  })
 })

package/tests/dev-ports.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import {
+  findNextFreePort,
+  isValidHostPort,
+  parseHostPortInput,
+  readPersistedKongPort,
+} from "../src/dev-ports.js"
+import { isPortInUse } from "../src/postgres-ctl.js"
+
+vi.mock("../src/postgres-ctl.js", () => ({
+  isPortInUse: vi.fn(),
+}))
+
+const isPortInUseMock = vi.mocked(isPortInUse)
+
+describe("dev-ports", () => {
+  beforeEach(() => {
+    isPortInUseMock.mockReset()
+  })
+
+  it("validates host ports", () => {
+    expect(isValidHostPort(18473)).toBe(true)
+    expect(isValidHostPort(80)).toBe(false)
+    expect(parseHostPortInput("18473")).toBe(18473)
+    expect(parseHostPortInput("nope")).toBeNull()
+  })
+
+  it("reads persisted Kong port from .env", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-ports-"))
+    writeFileSync(join(dir, ".env"), "SUPATYPE_KONG_PORT=18474\n", "utf8")
+    expect(readPersistedKongPort(dir)).toBe(18474)
+  })
+
+  it("findNextFreePort skips taken ports", async () => {
+    isPortInUseMock.mockImplementation(async (port) => port === 18473 || port === 18474)
+    await expect(findNextFreePort(18473)).resolves.toBe(18475)
+  })
+})