@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.8

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

@@ -27,7 +27,22 @@ 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"]
+    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)
     }
@@ -39,6 +54,12 @@ describe("CLI binary (requires built dist/)", () => {
     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)
@@ -58,10 +79,10 @@ describe("CLI binary (requires built dist/)", () => {
     expect(stdout).toContain("dry run")
   })
 
-  it("pull --help shows --output option", () => {
+  it("pull --help describes deprecated pull command", () => {
     const { stdout, exitCode } = runCli(["pull", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("--output")
+    expect(stdout).toContain("deprecated")
   })
 
   it("reset --help shows --yes flag", () => {
@@ -77,27 +98,32 @@ describe("CLI binary (requires built dist/)", () => {
     expect(stdout).toContain("remove")
   })
 
-  it("app add --help shows --dockerfile and --port options", () => {
+  it("app add --help shows --static and --port options", () => {
     const { stdout, exitCode } = runCli(["app", "add", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("--dockerfile")
+    expect(stdout).toContain("--static")
     expect(stdout).toContain("--port")
   })
 
-  it("self-host --help describes the self-host command", () => {
+  it("self-host --help shows compose only (legacy commands hidden)", () => {
     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")
+    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 setup --help shows --domain option", () => {
-    const { stdout, exitCode } = runCli(["self-host", "setup", "--help"])
+  it("self-host compose --help shows compose subcommands", () => {
+    const { stdout, exitCode } = runCli(["self-host", "compose", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("--domain")
+    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", () => {

package/tests/config.test.ts

@@ -3,13 +3,26 @@ 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"
+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(() => {
-  // Counter prevents timestamp collisions when tests run in rapid succession
   tmpDir = join(tmpdir(), `dt-config-test-${Date.now()}-${++counter}`)
   mkdirSync(tmpDir, { recursive: true })
 })
@@ -20,17 +33,18 @@ afterEach(() => {
 
 describe("defineConfig()", () => {
   it("returns its argument unchanged (identity helper for type inference)", () => {
-    const cfg: DefinatypeConfig = {
+    const cfg = defineConfig({
+      ...minimalProject("test"),
       connection: "postgresql://localhost/test",
-      schema: "./schema/index.ts",
-    }
+      schema: { path: "./schema/index.ts" },
+    })
     expect(defineConfig(cfg)).toBe(cfg)
   })
 
   it("preserves optional output field", () => {
     const cfg = defineConfig({
-      connection: "postgresql://localhost/test",
-      schema: "./schema/index.ts",
+      ...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")
@@ -40,62 +54,83 @@ describe("defineConfig()", () => {
 
 describe("loadConfig()", () => {
   it("throws when no config file exists in the directory", () => {
-    expect(() => loadConfig(tmpDir)).toThrow(/No supatype.config.ts found/)
+    expect(() => loadConfig(tmpDir)).toThrow(/No supatype.config.ts/)
   })
 
   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.
+    const body = {
+      ...minimalProject("mydb"),
+      connection: "postgresql://localhost/mydb",
+      schema: { path: "./schema/index.ts" },
+    }
     writeFileSync(
       join(tmpDir, "supatype.config.ts"),
-      `export default {
-  connection: "postgresql://localhost/mydb",
-  schema: "./schema/index.ts",
-}
+      `export default ${JSON.stringify(body)}
 `,
     )
     const cfg = loadConfig(tmpDir)
     expect(cfg.connection).toBe("postgresql://localhost/mydb")
-    expect(cfg.schema).toBe("./schema/index.ts")
+    expect(cfg.schema?.path).toBe("./schema/index.ts")
   })
 
-  it("loads a supatype.config.js (plain ESM)", () => {
+  it("normalizes shorthand schema string to { path, pg_schema }", () => {
     writeFileSync(
-      join(tmpDir, "supatype.config.js"),
-      `export default {
-  connection: "postgresql://localhost/jsdb",
-  schema: "./schema/index.ts",
-}
+      join(tmpDir, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        ...minimalProject("x"),
+        schema: "./schema/index.ts",
+      })}
 `,
     )
     const cfg = loadConfig(tmpDir)
-    expect(cfg.connection).toBe("postgresql://localhost/jsdb")
+    expect(cfg.schema?.path).toBe("./schema/index.ts")
+    expect(cfg.schema?.pg_schema).toBe("public")
   })
 
-  it("throws if config is missing the schema field", () => {
+  it("loads a supatype.config.js (plain ESM)", () => {
     writeFileSync(
-      join(tmpDir, "supatype.config.ts"),
-      `export default { connection: "postgresql://localhost/test" }`,
+      join(tmpDir, "supatype.config.js"),
+      `export default ${JSON.stringify({
+        ...minimalProject("jsdb"),
+        connection: "postgresql://localhost/jsdb",
+        schema: { path: "./schema/index.ts" },
+      })}
+`,
     )
-    expect(() => loadConfig(tmpDir)).toThrow(/must export/)
+    const cfg = loadConfig(tmpDir)
+    expect(cfg.connection).toBe("postgresql://localhost/jsdb")
   })
 
-  it("throws if config is missing the connection field", () => {
+  it("throws if config is missing the versions section", () => {
     writeFileSync(
       join(tmpDir, "supatype.config.ts"),
-      `export default { schema: "./schema/index.ts" }`,
+      `export default {
+  project: { name: "t" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  schema: { path: "./schema/index.ts" },
+}`,
     )
-    expect(() => loadConfig(tmpDir)).toThrow(/must export/)
+    expect(() => loadConfig(tmpDir)).toThrow(/versions/)
   })
 
   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" }`,
+      `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 { connection: "postgresql://localhost/from-js", schema: "./schema/index.ts" }`,
+      `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")
@@ -104,14 +139,113 @@ describe("loadConfig()", () => {
   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" },
-}
-`,
+      `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/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)
+  })
+})

package/tests/engine-distribution.test.ts

@@ -59,12 +59,12 @@ describe("CDN URL construction", () => {
     const { getCdnUrl } = await import("../src/engine/platform.js")
 
     const url = getCdnUrl(
-      "https://releases.supatype.io/engine",
+      "https://releases.supatype.com/engine",
       "0.1.0-alpha.1",
       "supatype-engine-0.1.0-alpha.1-linux-x64",
     )
     expect(url).toBe(
-      "https://releases.supatype.io/engine/v0.1.0-alpha.1/supatype-engine-0.1.0-alpha.1-linux-x64",
+      "https://releases.supatype.com/engine/v0.1.0-alpha.1/supatype-engine-0.1.0-alpha.1-linux-x64",
     )
   })
 })
@@ -329,7 +329,7 @@ describe("Engine version constants", () => {
     } = await import("../src/engine-version.js")
 
     expect(ENGINE_VERSION).toMatch(/^\d+\.\d+\.\d+/)
-    expect(CDN_BASE_URL).toBe("https://releases.supatype.io/engine")
+    expect(CDN_BASE_URL).toBe("https://releases.supatype.com/engine")
     expect(ENGINE_RELEASES_REPO).toBe("supatype/engine-releases")
     expect(GITHUB_RELEASES_FALLBACK_URL).toContain("github.com")
   })

package/tests/ensure-binary.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+import * as binaryCache from "../src/binary-cache.js"
+import { ensureBinary } from "../src/ensure-binary.js"
+
+const TEST_VERSION = "9.9.9"
+
+const config = (): SupatypeProjectConfig => ({
+  project: { name: "test" },
+  database: { provider: "native" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  versions: {
+    engine: "0.4.2",
+    server: "0.1.0",
+    postgres: "17.2",
+    deno: TEST_VERSION,
+  },
+})
+
+beforeEach(() => {
+  const dir = binaryCache.cachePath("deno", TEST_VERSION)
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+  mkdirSync(dir, { recursive: true })
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  const dir = binaryCache.cachePath("deno", TEST_VERSION)
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe("ensureBinary", () => {
+  it("returns cached path without calling download", async () => {
+    const platform = binaryCache.currentPlatform()
+    const path = binaryCache.cachedBinaryPath("deno", TEST_VERSION, platform)
+    writeFileSync(path, "stub", { mode: 0o755 })
+
+    const downloadSpy = vi.spyOn(binaryCache, "download")
+    const resolved = await ensureBinary("deno", config())
+    expect(resolved).toBe(path)
+    expect(downloadSpy).not.toHaveBeenCalled()
+  })
+
+  it("downloads on cache miss", async () => {
+    const platform = binaryCache.currentPlatform()
+    const expected = binaryCache.cachedBinaryPath("deno", TEST_VERSION, platform)
+    const downloadSpy = vi.spyOn(binaryCache, "download").mockResolvedValue(expected)
+
+    const path = await ensureBinary("deno", config())
+    expect(path).toBe(expected)
+    expect(downloadSpy).toHaveBeenCalledWith("deno", TEST_VERSION, platform)
+  })
+})