@supatype/cli 0.1.0-alpha.10

package/tests/cached-artifact-format.test.ts

@@ -0,0 +1,84 @@
+import { afterEach, describe, expect, it } from "vitest"
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import {
+  validateArtifactFormat,
+  type Component,
+  type PlatformId,
+} from "../src/binary-cache.js"
+
+function writeMagic(name: string, bytes: number[]): string {
+  const dir = mkdtempSync(join(tmpdir(), "supatype-artifact-"))
+  const path = join(dir, name)
+  writeFileSync(path, Buffer.from(bytes))
+  return path
+}
+
+function expectValid(component: Component, path: string, platform: PlatformId): void {
+  expect(() => validateArtifactFormat(component, path, platform)).not.toThrow()
+}
+
+function expectInvalid(component: Component, path: string, platform: PlatformId): void {
+  expect(() => validateArtifactFormat(component, path, platform)).toThrow()
+}
+
+describe("validateArtifactFormat", () => {
+  const paths: string[] = []
+
+  afterEach(() => {
+    for (const p of paths) {
+      try {
+        rmSync(join(p, ".."), { recursive: true, force: true })
+      } catch {
+        /* ignore */
+      }
+    }
+    paths.length = 0
+  })
+
+  it("accepts ELF for engine/server/deno on linux", () => {
+    const linux: PlatformId = { os: "linux", arch: "amd64" }
+    for (const component of ["engine", "server", "deno"] as const) {
+      const p = writeMagic(component, [0x7f, 0x45, 0x4c, 0x46, 0, 0, 0, 0])
+      paths.push(p)
+      expectValid(component, p, linux)
+    }
+  })
+
+  it("accepts Mach-O for engine on darwin", () => {
+    const p = writeMagic("engine", [0xcf, 0xfa, 0xed, 0xfe, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("engine", p, { os: "darwin", arch: "arm64" })
+  })
+
+  it("accepts PE for deno on windows", () => {
+    const p = writeMagic("deno.exe", [0x4d, 0x5a, 0x90, 0x00, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("deno", p, { os: "windows", arch: "amd64" })
+  })
+
+  it("rejects Go c-archive for server on linux", () => {
+    const p = writeMagic("server", [0x21, 0x3c, 0x61, 0x72, 0, 0, 0, 0])
+    paths.push(p)
+    expectInvalid("server", p, { os: "linux", arch: "amd64" })
+  })
+
+  it("accepts gzip for postgres on linux", () => {
+    const p = writeMagic("pg.tar.gz", [0x1f, 0x8b, 0x08, 0x00, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("postgres", p, { os: "linux", arch: "amd64" })
+  })
+
+  it("accepts zip for postgres on windows", () => {
+    const p = writeMagic("pg.zip", [0x50, 0x4b, 0x03, 0x04, 0, 0, 0, 0])
+    paths.push(p)
+    expectValid("postgres", p, { os: "windows", arch: "amd64" })
+  })
+
+  it("rejects gzip postgres artifact on windows", () => {
+    const p = writeMagic("pg.tar.gz", [0x1f, 0x8b, 0x08, 0x00, 0, 0, 0, 0])
+    paths.push(p)
+    expectInvalid("postgres", p, { os: "windows", arch: "amd64" })
+  })
+})

package/tests/cli-help.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Subprocess tests — spawn the compiled CLI binary and verify commands are
+ * registered. Requires `pnpm build` to have run first (turbo handles this).
+ */
+import { describe, it, expect } from "vitest"
+import { spawnSync } from "node:child_process"
+import { resolve, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const CLI_BIN = resolve(__dirname, "../bin/supatype.js")
+const DIST_CLI = resolve(__dirname, "../dist/cli.js")
+
+function runCli(args: string[]): { stdout: string; stderr: string; exitCode: number } {
+  const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
+    encoding: "utf8",
+    timeout: 10_000,
+  })
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: result.status ?? 1,
+  }
+}
+
+describe("CLI binary (requires built dist/)", () => {
+  it("--help lists all top-level commands", () => {
+    const { stdout, exitCode } = runCli(["--help"])
+    expect(exitCode).toBe(0)
+    const commands = [
+      "init",
+      "dev",
+      "push",
+      "diff",
+      "pull",
+      "generate",
+      "migrate",
+      "rollback",
+      "reset",
+      "seed",
+      "keys",
+      "app",
+      "self-host",
+      "self-update",
+    ]
+    for (const cmd of commands) {
+      expect(stdout, `Expected '${cmd}' in --help output`).toContain(cmd)
+    }
+  })
+
+  it("--version prints a semver string", () => {
+    const { stdout, exitCode } = runCli(["--version"])
+    expect(exitCode).toBe(0)
+    expect(stdout.trim()).toMatch(/^\d+\.\d+\.\d+/)
+  })
+
+  it("self-update --help describes the command", () => {
+    const { stdout, exitCode } = runCli(["self-update", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout.toLowerCase()).toMatch(/npm|update/)
+  })
+
+  it("init --help describes the init command", () => {
+    const { stdout, exitCode } = runCli(["init", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("Scaffold")
+  })
+
+  it("push --help describes the push command and --yes flag", () => {
+    const { stdout, exitCode } = runCli(["push", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("--yes")
+    expect(stdout).toContain("--connection")
+  })
+
+  it("diff --help describes the diff command", () => {
+    const { stdout, exitCode } = runCli(["diff", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("dry run")
+  })
+
+  it("pull --help describes deprecated pull command", () => {
+    const { stdout, exitCode } = runCli(["pull", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("deprecated")
+  })
+
+  it("reset --help shows --yes flag", () => {
+    const { stdout, exitCode } = runCli(["reset", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("--yes")
+  })
+
+  it("app --help describes the app command with add/remove subcommands", () => {
+    const { stdout, exitCode } = runCli(["app", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("add")
+    expect(stdout).toContain("remove")
+  })
+
+  it("app add --help shows --static and --port options", () => {
+    const { stdout, exitCode } = runCli(["app", "add", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("--static")
+    expect(stdout).toContain("--port")
+  })
+
+  it("self-host --help shows compose only (legacy commands hidden)", () => {
+    const { stdout, exitCode } = runCli(["self-host", "--help"])
+    expect(exitCode).toBe(0)
+    const commandsSection = stdout.split("Commands:")[1] ?? ""
+    expect(commandsSection).toContain("compose")
+    expect(commandsSection).not.toContain("install-service")
+    expect(commandsSection).not.toContain("native")
+    expect(commandsSection).not.toContain("backup")
+    expect(stdout).not.toContain("--output-dir")
+  })
+
+  it("self-host compose --help shows compose subcommands", () => {
+    const { stdout, exitCode } = runCli(["self-host", "compose", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("render")
+    expect(stdout).toContain("up")
+    expect(stdout).toContain("down")
+    expect(stdout).toContain("status")
+    expect(stdout).toContain("logs")
+  })
+
+  it("unknown command exits non-zero", () => {
+    const { exitCode } = runCli(["doesnotexist"])
+    expect(exitCode).not.toBe(0)
+  })
+})

package/tests/config.test.ts

@@ -0,0 +1,252 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { defineConfig, loadConfig } from "../src/config.js"
+import { mergeProjectConfig, resolveRuntimeProvider, type SupatypeProjectConfig } from "../src/project-config.js"
+import { DENO_RELEASE_PIN } from "../src/release-pins.js"
+
+let counter = 0
+let tmpDir: string
+
+const minimalProject = (name: string): SupatypeProjectConfig => ({
+  project: { name },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  versions: {
+    engine: "0.4.2",
+    server: "0.1.0",
+    postgres: "17.2",
+    deno: DENO_RELEASE_PIN,
+  },
+})
+
+beforeEach(() => {
+  tmpDir = join(tmpdir(), `dt-config-test-${Date.now()}-${++counter}`)
+  mkdirSync(tmpDir, { recursive: true })
+})
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true })
+})
+
+describe("defineConfig()", () => {
+  it("returns its argument unchanged (identity helper for type inference)", () => {
+    const cfg = defineConfig({
+      ...minimalProject("test"),
+      connection: "postgresql://localhost/test",
+      schema: { path: "./schema/index.ts" },
+    })
+    expect(defineConfig(cfg)).toBe(cfg)
+  })
+
+  it("preserves optional output field", () => {
+    const cfg = defineConfig({
+      ...minimalProject("test"),
+      schema: { path: "./schema/index.ts" },
+      output: { types: "./src/types.d.ts", client: "./src/client.ts" },
+    })
+    expect(cfg.output?.types).toBe("./src/types.d.ts")
+    expect(cfg.output?.client).toBe("./src/client.ts")
+  })
+})
+
+describe("loadConfig()", () => {
+  it("throws when no config file exists in the directory", () => {
+    expect(() => loadConfig(tmpDir)).toThrow(/No supatype.config.ts/)
+  })
+
+  it("loads a valid supatype.config.ts (plain export default, no package imports)", () => {
+    const body = {
+      ...minimalProject("mydb"),
+      connection: "postgresql://localhost/mydb",
+      schema: { path: "./schema/index.ts" },
+    }
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify(body)}
+`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.connection).toBe("postgresql://localhost/mydb")
+    expect(cfg.schema?.path).toBe("./schema/index.ts")
+  })
+
+  it("normalizes shorthand schema string to { path, pg_schema }", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        ...minimalProject("x"),
+        schema: "./schema/index.ts",
+      })}
+`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.schema?.path).toBe("./schema/index.ts")
+    expect(cfg.schema?.pg_schema).toBe("public")
+  })
+
+  it("loads a supatype.config.js (plain ESM)", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.js"),
+      `export default ${JSON.stringify({
+        ...minimalProject("jsdb"),
+        connection: "postgresql://localhost/jsdb",
+        schema: { path: "./schema/index.ts" },
+      })}
+`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.connection).toBe("postgresql://localhost/jsdb")
+  })
+
+  it("loads config without a versions section (latest by default)", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default {
+  project: { name: "t" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  schema: { path: "./schema/index.ts" },
+}`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.versions).toBeUndefined()
+  })
+
+  it("prefers supatype.config.ts over supatype.config.js when both exist", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        ...minimalProject("from-ts"),
+        connection: "postgresql://localhost/from-ts",
+        schema: { path: "./schema/index.ts" },
+      })}`,
+    )
+    writeFileSync(
+      join(tmpDir, "supatype.config.js"),
+      `export default ${JSON.stringify({
+        ...minimalProject("from-js"),
+        connection: "postgresql://localhost/from-js",
+        schema: { path: "./schema/index.ts" },
+      })}`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.connection).toContain("from-ts")
+  })
+
+  it("supports optional output field in config", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        ...minimalProject("t"),
+        schema: { path: "./schema/index.ts" },
+        output: { types: "./src/types.d.ts" },
+      })}`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.output?.types).toBe("./src/types.d.ts")
+  })
+
+  it("merges supatype.local.config.ts over base", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        ...minimalProject("base"),
+        schema: { path: "./a.ts" },
+        versions: {
+          engine: "0.4.0",
+          server: "0.1.0",
+          postgres: "17",
+          deno: "2.2.0",
+        },
+      })}`,
+    )
+    writeFileSync(
+      join(tmpDir, "supatype.local.config.ts"),
+      `export default ${JSON.stringify({
+        versions: {
+          engine: "0.4.2",
+          server: "0.1.0",
+          postgres: "17",
+          deno: "2.2.0",
+        },
+      })}`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.versions.engine).toBe("0.4.2")
+    expect(cfg.schema?.path).toBe("./a.ts")
+  })
+})
+
+describe("resolveRuntimeProvider()", () => {
+  it("prefers top-level provider over database.provider", () => {
+    const cfg = defineConfig({
+      ...minimalProject("p"),
+      provider: "docker",
+      database: { provider: "native" },
+    })
+    expect(resolveRuntimeProvider(cfg)).toBe("docker")
+  })
+
+  it("falls back to database.provider then native", () => {
+    expect(resolveRuntimeProvider(defineConfig({ ...minimalProject("p"), database: { provider: "docker" } }))).toBe(
+      "docker",
+    )
+    expect(resolveRuntimeProvider(defineConfig({ ...minimalProject("p"), database: { provider: "native" } }))).toBe(
+      "native",
+    )
+  })
+})
+
+describe("mergeProjectConfig()", () => {
+  it("deep-merges email.smtp between base and local", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      email: { provider: "smtp", smtp: { host: "h1", port: 587, user: "u0" } },
+    })
+    const merged = mergeProjectConfig(base, { email: { smtp: { host: "h2", pass: "x" } } })
+    expect(merged.email?.provider).toBe("smtp")
+    expect(merged.email?.smtp?.host).toBe("h2")
+    expect(merged.email?.smtp?.port).toBe(587)
+    expect(merged.email?.smtp?.user).toBe("u0")
+    expect(merged.email?.smtp?.pass).toBe("x")
+  })
+
+  it("merges send_email_hook fields from local", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      email: { provider: "console", send_email_hook: true, send_email_hook_uri: "http://old/hook" },
+    })
+    const merged = mergeProjectConfig(base, {
+      email: { send_email_hook_secrets: "v1,whsec_customsecret0000000000000000" },
+    })
+    expect(merged.email?.send_email_hook).toBe(true)
+    expect(merged.email?.send_email_hook_uri).toBe("http://old/hook")
+    expect(merged.email?.send_email_hook_secrets).toBe("v1,whsec_customsecret0000000000000000")
+  })
+
+  it("overrides app.vite_dev_url from local", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      app: { mode: "static", static_dir: "./dist", vite_dev_url: "http://127.0.0.1:1111" },
+    })
+    const merged = mergeProjectConfig(base, { app: { vite_dev_url: "http://127.0.0.1:5173" } })
+    expect(merged.app?.vite_dev_url).toBe("http://127.0.0.1:5173")
+  })
+
+  it("merges app.start for proxy dev script override", () => {
+    const base = defineConfig({
+      ...minimalProject("p"),
+      app: { mode: "static", static_dir: "./dist" },
+    })
+    const merged = mergeProjectConfig(base, {
+      app: { mode: "proxy", upstream: "http://127.0.0.1:4321", start: "dev:site" },
+    })
+    expect(merged.app.mode).toBe("proxy")
+    expect(merged.app.start).toBe("dev:site")
+    expect(merged.app.static_dir).toBe("./dist")
+  })
+})

package/tests/dev-ui.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
+import { DevLogBus } from "../src/dev-log-bus.js"
+import { filterDevSubprocessLine, formatConsoleArgs, stripAnsi } from "../src/dev-log-filter.js"
+import { appendDevTaskLog, beginDevSession, endDevSession, resolveDevUiMode } from "../src/dev-session.js"
+import {
+  layoutLogoBlock,
+  logoRowCount,
+  pickLogoLines,
+  SUPATYPE_ASCII_LOGO_WORDMARK,
+} from "../src/dev-logo.js"
+import { normalizeStackLogLine, taskColor } from "../src/dev-task-colors.js"
+
+describe("filterDevSubprocessLine()", () => {
+  it("filters npm script banners and vite network URLs for app", () => {
+    expect(filterDevSubprocessLine("app", "> vite")).toBe(false)
+    expect(filterDevSubprocessLine("app", "  ➜  Network: http://10.0.0.1:5173/")).toBe(false)
+    expect(filterDevSubprocessLine("app", "  ➜  Local:   http://localhost:5173/")).toBe(true)
+  })
+
+  it("does not filter stack logs", () => {
+    expect(filterDevSubprocessLine("stack", "> vite")).toBe(true)
+  })
+})
+
+describe("stripAnsi()", () => {
+  it("removes colour codes", () => {
+    expect(stripAnsi("\x1b[33mhello\x1b[0m")).toBe("hello")
+  })
+})
+
+describe("formatConsoleArgs()", () => {
+  it("joins mixed arguments", () => {
+    expect(formatConsoleArgs(["a", 1])).toBe("a 1")
+  })
+})
+
+describe("DevLogBus", () => {
+  it("marks non-focused tasks unread", () => {
+    const bus = new DevLogBus()
+    bus.registerTask("app", "app")
+    bus.setFocusedTaskId("stack")
+    bus.append("app", "ready")
+    expect(bus.getTask("app")?.unread).toBe(true)
+    bus.setFocusedTaskId("app")
+    expect(bus.getTask("app")?.unread).toBe(false)
+  })
+
+  it("splits multiline append into separate rows", () => {
+    const bus = new DevLogBus()
+    bus.append("stack", "line one\nline two")
+    expect(bus.getTask("stack")?.lines).toEqual(["line one", "line two"])
+  })
+
+  it("strips [supatype] prefix on stack task", () => {
+    const bus = new DevLogBus()
+    bus.append("stack", "[supatype] hello")
+    expect(bus.getTask("stack")?.lines).toEqual(["hello"])
+  })
+})
+
+describe("resolveDevUiMode()", () => {
+  it("honours --stream", () => {
+    expect(resolveDevUiMode(true)).toBe("stream")
+  })
+})
+
+describe("appendDevTaskLog()", () => {
+  afterEach(() => {
+    endDevSession()
+  })
+
+  it("routes proxy bootstrap lines to the app task in TUI mode", () => {
+    const session = beginDevSession("tui")
+    appendDevTaskLog("app", "app", "Proxy mode: running npm run vite (/tmp/app)")
+    expect(session.bus.getTask("app")?.lines).toEqual(["Proxy mode: running npm run vite (/tmp/app)"])
+    expect(session.bus.getTask("stack")?.lines ?? []).toEqual([])
+  })
+})
+
+describe("dev-logo", () => {
+  it("preserves authored line spacing including trailing spaces", () => {
+    const out = layoutLogoBlock(["  aa", "    bbbb ", ""])
+    expect(out[0]).toBe("  aa")
+    expect(out[1]).toBe("    bbbb ")
+  })
+
+  it("loads the figlet slant wordmark", () => {
+    expect(pickLogoLines()).toEqual([...SUPATYPE_ASCII_LOGO_WORDMARK])
+    expect(logoRowCount()).toBe(6)
+    expect(SUPATYPE_ASCII_LOGO_WORDMARK[1]).toContain("_______")
+  })
+})
+
+describe("dev-task-colors", () => {
+  it("assigns purple to stack and green to app", () => {
+    expect(taskColor("stack")).toBe("\x1b[35m")
+    expect(taskColor("app")).toBe("\x1b[32m")
+  })
+
+  it("strips stack log prefix", () => {
+    expect(normalizeStackLogLine("[supatype] Waiting for Postgres")).toBe("Waiting for Postgres")
+  })
+})
+
+describe("dev-shutdown", () => {
+  const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => undefined) as typeof process.exit)
+
+  beforeEach(() => {
+    exitSpy.mockClear()
+  })
+
+  afterEach(() => {
+    vi.resetModules()
+  })
+
+  it("exits 0 after registered work completes", async () => {
+    vi.resetModules()
+    const { registerDevShutdown, requestDevShutdown } = await import("../src/dev-shutdown.js")
+    let ran = false
+    registerDevShutdown(async () => {
+      ran = true
+    })
+    requestDevShutdown()
+    await vi.waitFor(() => expect(exitSpy).toHaveBeenCalledWith(0))
+    expect(ran).toBe(true)
+  })
+
+  it("force-exits 130 on second interrupt", async () => {
+    vi.resetModules()
+    const { registerDevShutdown, requestDevShutdown } = await import("../src/dev-shutdown.js")
+    registerDevShutdown(async () => {
+      await new Promise(() => undefined)
+    })
+    requestDevShutdown()
+    await vi.waitFor(() => expect(exitSpy).toHaveBeenCalledTimes(0))
+    requestDevShutdown()
+    expect(exitSpy).toHaveBeenCalledWith(130)
+  })
+})

package/tests/docker-postgres.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest"
+import {
+  containerName,
+  dockerPgLoopbackDbUrl,
+  dockerPgPostInitServing,
+} from "../src/docker-postgres.js"
+
+describe("docker-postgres", () => {
+  it("derives container name from project name", () => {
+    expect(containerName("supatype-integration")).toBe("supatype-supatype-integration")
+  })
+
+  it("detects post-init serving after first-boot init", () => {
+    const logs = [
+      "PostgreSQL init process complete; ready for start up.",
+      "database system is ready to accept connections",
+    ].join("\n")
+    expect(dockerPgPostInitServing(logs)).toBe(true)
+  })
+
+  it("detects post-init serving on reused volume (no init banner this run)", () => {
+    const logs = "database system is ready to accept connections\n"
+    expect(dockerPgPostInitServing(logs)).toBe(true)
+  })
+
+  it("builds loopback DB URL for in-container migrate", () => {
+    expect(dockerPgLoopbackDbUrl("my-project")).toBe(
+      "postgres://supatype_admin:postgres@127.0.0.1:5432/my-project?sslmode=disable",
+    )
+  })
+
+  it("rejects ready line before init complete on first boot", () => {
+    const logs = [
+      "database system is ready to accept connections",
+      "PostgreSQL init process complete; ready for start up.",
+    ].join("\n")
+    expect(dockerPgPostInitServing(logs)).toBe(false)
+  })
+})