@supatype/cli 0.1.0-alpha.6

package/src/scripts/postinstall.ts

@@ -0,0 +1,40 @@
+/**
+ * Postinstall script — downloads the correct engine binary for the current
+ * platform and caches it at ~/.supatype/engine/{version}/supatype-engine[.exe].
+ *
+ * Pattern: same as Prisma, esbuild, SWC, Turbo.
+ *
+ * The binary is verified via:
+ * 1. Minisign signature on checksums.sha256 (proves checksum file is authentic)
+ * 2. SHA256 checksum of binary (proves binary matches signed checksum)
+ */
+
+import { ENGINE_VERSION } from "../engine-version.js"
+import { detectPlatform } from "../engine/platform.js"
+import { hasCachedBinary } from "../engine/cache.js"
+import { resolveEngine } from "../engine/resolve.js"
+
+async function main(): Promise<void> {
+  const platform = detectPlatform()
+
+  // Skip if already cached at the right version
+  if (hasCachedBinary(ENGINE_VERSION, platform)) {
+    console.log(`[supatype] Engine v${ENGINE_VERSION} already cached.`)
+    return
+  }
+
+  console.log(
+    `[supatype] Downloading engine v${ENGINE_VERSION} for ${platform.os}-${platform.arch}...`,
+  )
+
+  const result = await resolveEngine(ENGINE_VERSION)
+  console.log(`[supatype] Engine installed at ${result.binaryPath}`)
+}
+
+main().catch((err) => {
+  console.error("[supatype] Engine download failed:", err.message)
+  console.error(
+    "[supatype] You can still use the CLI — the engine will be downloaded on first use.",
+  )
+  // Don't exit(1) — let npm install succeed even if binary download fails.
+})

package/src/tsx-runner.ts

@@ -0,0 +1,79 @@
+/**
+ * Locates the tsx binary shipped with this package and provides a helper
+ * to run TypeScript files at runtime.
+ */
+
+import { spawnSync, type SpawnSyncOptions } from "node:child_process"
+import { existsSync, readFileSync } from "node:fs"
+import { resolve, dirname } from "node:path"
+import { createRequire } from "node:module"
+import { writeFileSync, unlinkSync } from "node:fs"
+import { tmpdir } from "node:os"
+
+const _require = createRequire(import.meta.url)
+
+/**
+ * Resolve the absolute path to the tsx CLI entry point.
+ * tsx is a direct dependency so this will always succeed after `npm install`.
+ */
+function findTsxBin(): string {
+  try {
+    const pkgPath = _require.resolve("tsx/package.json")
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as {
+      bin?: string | Record<string, string>
+    }
+    const binRelative =
+      typeof pkg.bin === "string"
+        ? pkg.bin
+        : (pkg.bin?.["tsx"] ?? "./dist/cli.mjs")
+    return resolve(dirname(pkgPath), binRelative)
+  } catch {
+    return "tsx" // last-resort: hope it's on PATH
+  }
+}
+
+const TSX_BIN = findTsxBin()
+
+export interface RunResult {
+  stdout: string
+  stderr: string
+  exitCode: number
+}
+
+/** Run a TypeScript file with tsx and capture output. */
+export function runTsFile(
+  filePath: string,
+  opts: SpawnSyncOptions = {},
+): RunResult {
+  const result = spawnSync(process.execPath, [TSX_BIN, filePath], {
+    encoding: "utf8",
+    maxBuffer: 50 * 1024 * 1024,
+    ...opts,
+  })
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: result.status ?? 1,
+  }
+}
+
+/**
+ * Evaluate an ESM TypeScript snippet via tsx and return its stdout.
+ * The snippet should write JSON to process.stdout.
+ */
+export function evalTsSnippet(
+  snippet: string,
+  opts: SpawnSyncOptions = {},
+): RunResult {
+  const tmpFile = resolve(tmpdir(), `supatype-eval-${Date.now()}.mts`)
+  writeFileSync(tmpFile, snippet, "utf8")
+  try {
+    return runTsFile(tmpFile, opts)
+  } finally {
+    try {
+      unlinkSync(tmpFile)
+    } catch {
+      // ignore cleanup errors
+    }
+  }
+}

package/tests/cli-help.test.ts

@@ -0,0 +1,107 @@
+/**
+ * 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"]
+    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("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 shows --output option", () => {
+    const { stdout, exitCode } = runCli(["pull", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("--output")
+  })
+
+  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 --dockerfile and --port options", () => {
+    const { stdout, exitCode } = runCli(["app", "add", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("--dockerfile")
+    expect(stdout).toContain("--port")
+  })
+
+  it("self-host --help describes the self-host command", () => {
+    const { stdout, exitCode } = runCli(["self-host", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("setup")
+    expect(stdout).toContain("status")
+    expect(stdout).toContain("logs")
+    expect(stdout).toContain("backup")
+    expect(stdout).toContain("update")
+  })
+
+  it("self-host setup --help shows --domain option", () => {
+    const { stdout, exitCode } = runCli(["self-host", "setup", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("--domain")
+  })
+
+  it("unknown command exits non-zero", () => {
+    const { exitCode } = runCli(["doesnotexist"])
+    expect(exitCode).not.toBe(0)
+  })
+})

package/tests/config.test.ts

@@ -0,0 +1,117 @@
+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 type { DefinatypeConfig } from "../src/config.js"
+
+let counter = 0
+let tmpDir: string
+
+beforeEach(() => {
+  // Counter prevents timestamp collisions when tests run in rapid succession
+  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: DefinatypeConfig = {
+      connection: "postgresql://localhost/test",
+      schema: "./schema/index.ts",
+    }
+    expect(defineConfig(cfg)).toBe(cfg)
+  })
+
+  it("preserves optional output field", () => {
+    const cfg = defineConfig({
+      connection: "postgresql://localhost/test",
+      schema: "./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 found/)
+  })
+
+  it("loads a valid supatype.config.ts (plain export default, no package imports)", () => {
+    // Note: avoid importing @supatype/cli inside the temp config —
+    // the temp dir is outside the monorepo and can't resolve workspace packages.
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default {
+  connection: "postgresql://localhost/mydb",
+  schema: "./schema/index.ts",
+}
+`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.connection).toBe("postgresql://localhost/mydb")
+    expect(cfg.schema).toBe("./schema/index.ts")
+  })
+
+  it("loads a supatype.config.js (plain ESM)", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.js"),
+      `export default {
+  connection: "postgresql://localhost/jsdb",
+  schema: "./schema/index.ts",
+}
+`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.connection).toBe("postgresql://localhost/jsdb")
+  })
+
+  it("throws if config is missing the schema field", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default { connection: "postgresql://localhost/test" }`,
+    )
+    expect(() => loadConfig(tmpDir)).toThrow(/must export/)
+  })
+
+  it("throws if config is missing the connection field", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default { schema: "./schema/index.ts" }`,
+    )
+    expect(() => loadConfig(tmpDir)).toThrow(/must export/)
+  })
+
+  it("prefers supatype.config.ts over supatype.config.js when both exist", () => {
+    writeFileSync(
+      join(tmpDir, "supatype.config.ts"),
+      `export default { connection: "postgresql://localhost/from-ts", schema: "./schema/index.ts" }`,
+    )
+    writeFileSync(
+      join(tmpDir, "supatype.config.js"),
+      `export default { connection: "postgresql://localhost/from-js", schema: "./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 {
+  connection: "postgresql://localhost/test",
+  schema: "./schema/index.ts",
+  output: { types: "./src/types.d.ts" },
+}
+`,
+    )
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.output?.types).toBe("./src/types.d.ts")
+  })
+})