@supatype/cli 0.1.1 → 0.1.2

package/tests/docker-runtime.test.ts

@@ -1,9 +1,8 @@
-import { describe, expect, it, vi, beforeEach, afterEach, afterAll } from "vitest"
+import { describe, expect, it, vi, beforeEach, afterEach, afterAll, type MockInstance } from "vitest"
 import type { SpawnSyncReturns } from "node:child_process"
 
 const spawnSyncMock = vi.hoisted(() => vi.fn())
 const isInteractiveMock = vi.hoisted(() => vi.fn(() => false))
-const clackLogErrorMock = vi.hoisted(() => vi.fn())
 const clackNoteMock = vi.hoisted(() => vi.fn())
 const clackIntroMock = vi.hoisted(() => vi.fn())
 const printLogoMock = vi.hoisted(() => vi.fn())
@@ -16,18 +15,12 @@ vi.mock("../src/ui/interactive.js", () => ({
   isInteractive: isInteractiveMock,
 }))
 
-vi.mock("@clack/prompts", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@clack/prompts")>()
-  return {
-    ...original,
+vi.mock("../src/ui/clack.js", () => ({
+  p: {
     intro: clackIntroMock,
     note: clackNoteMock,
-    log: {
-      ...original.log,
-      error: clackLogErrorMock,
-    },
-  }
-})
+  },
+}))
 
 vi.mock("../src/ui/prompts.js", async (importOriginal) => {
   const original = await importOriginal<typeof import("../src/ui/prompts.js")>()
@@ -124,7 +117,6 @@ describe("reportDockerUnavailable", () => {
     isInteractiveMock.mockReturnValue(false)
     errorMock.mockClear()
     logMock.mockClear()
-    clackLogErrorMock.mockClear()
     clackNoteMock.mockClear()
     clackIntroMock.mockClear()
     printLogoMock.mockClear()
@@ -171,7 +163,7 @@ describe("reportDockerUnavailable", () => {
     expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker-desktop"))).toBe(true)
   })
 
-  it("uses Clack log + note in interactive mode", () => {
+  it("uses Ink intro + note and themed error in interactive mode", () => {
     isInteractiveMock.mockReturnValue(true)
 
     reportDockerUnavailable(
@@ -185,20 +177,17 @@ describe("reportDockerUnavailable", () => {
 
     expect(printLogoMock).toHaveBeenCalled()
     expect(clackIntroMock).toHaveBeenCalledWith("Local development")
-    expect(clackLogErrorMock).toHaveBeenCalledWith(
-      "Docker is installed but the daemon is not running.",
-    )
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("daemon is not running"))).toBe(true)
     expect(clackNoteMock).toHaveBeenCalledWith(
       expect.stringContaining("Unpause Docker Desktop"),
     )
     expect(errorMock).not.toHaveBeenCalled()
-    expect(logMock).not.toHaveBeenCalled()
   })
 })
 
 describe("requireDockerDaemon", () => {
-  let exitMock: ReturnType<typeof vi.spyOn<typeof process, "exit">>
-  let errorMock: ReturnType<typeof vi.spyOn<typeof console, "error">>
+  let exitMock: MockInstance<(code?: string | number | null | undefined) => never>
+  let errorMock: MockInstance<typeof console.error>
 
   beforeEach(() => {
     spawnSyncMock.mockReset()

package/tests/ensure-dev-api-config.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest"
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { ensureDevApiConfig } from "../src/ensure-dev-api-config.js"
+
+describe("ensureDevApiConfig()", () => {
+  it("copies config/api-config.json when target is missing", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-api-config-"))
+    const configDir = join(dir, "config")
+    const template = join(configDir, "api-config.json")
+    const target = join(dir, ".supatype", "api-config.json")
+
+    mkdirSync(configDir, { recursive: true })
+    writeFileSync(template, '{"rest":{"schema":"public"}}\n', "utf8")
+
+    expect(ensureDevApiConfig(dir)).toBe(true)
+    expect(existsSync(target)).toBe(true)
+    expect(readFileSync(target, "utf8")).toContain('"rest"')
+    expect(ensureDevApiConfig(dir)).toBe(false)
+  })
+})

package/tests/init-dependency-versions.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+import {
+  initDependencyVersionsFallback,
+  resolveInitDependencyVersions,
+} from "../src/init-dependency-versions.js"
+
+function mockRegistry(packages: Record<string, { latest: string; versions: string[] }>) {
+  vi.stubGlobal(
+    "fetch",
+    vi.fn(async (url: string) => {
+      const name = decodeURIComponent(url.replace("https://registry.npmjs.org/", ""))
+      const pkg = packages[name]
+      if (!pkg) return new Response(null, { status: 404 })
+      const versions = Object.fromEntries(pkg.versions.map((v) => [v, {}]))
+      return Response.json({ versions, "dist-tags": { latest: pkg.latest } })
+    }),
+  )
+}
+
+describe("resolveInitDependencyVersions", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it("uses the running CLI version when both packages publish it", async () => {
+    mockRegistry({
+      "@supatype/cli": { latest: "0.1.3", versions: ["0.1.1", "0.1.3"] },
+      "@supatype/types": { latest: "0.1.3", versions: ["0.1.1", "0.1.3"] },
+    })
+
+    const deps = await resolveInitDependencyVersions()
+    expect(deps.cli).toBe("0.1.3")
+    expect(deps.types).toBe("0.1.3")
+  })
+
+  it("falls back to npm latest when the running CLI version is unpublished", async () => {
+    mockRegistry({
+      "@supatype/cli": { latest: "0.1.1", versions: ["0.1.1"] },
+      "@supatype/types": { latest: "0.1.1", versions: ["0.1.1"] },
+    })
+
+    const deps = await resolveInitDependencyVersions()
+    expect(deps.cli).toBe("0.1.1")
+    expect(deps.types).toBe("0.1.1")
+  })
+
+  it("can pin cli and types to different published versions", async () => {
+    mockRegistry({
+      "@supatype/cli": { latest: "0.1.3", versions: ["0.1.1", "0.1.3"] },
+      "@supatype/types": { latest: "0.1.1", versions: ["0.1.1"] },
+    })
+
+    const deps = await resolveInitDependencyVersions()
+    expect(deps.cli).toBe("0.1.3")
+    expect(deps.types).toBe("0.1.1")
+  })
+
+  it("falls back to the running CLI version when the registry is unreachable", async () => {
+    vi.stubGlobal("fetch", vi.fn(async () => new Response(null, { status: 500 })))
+    expect(await resolveInitDependencyVersions()).toEqual(initDependencyVersionsFallback())
+  })
+})

package/tests/init-package-json.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest"
+import { mergeSupatypePackageJson } from "../src/init-package-json.js"
+
+describe("mergeSupatypePackageJson", () => {
+  it("adds Supatype deps and scripts without overwriting existing dev script", () => {
+    const merged = mergeSupatypePackageJson(
+      { name: "existing", scripts: { dev: "next dev" } },
+      { projectName: "existing", app: { mode: "none" }, helloFunction: false },
+      { cli: "0.1.1", types: "0.1.1" },
+    )
+
+    expect(merged.dependencies?.["@supatype/cli"]).toBe("^0.1.1")
+    expect(merged.dependencies?.["@supatype/types"]).toBe("^0.1.1")
+    expect(merged.scripts?.dev).toBe("next dev")
+    expect(merged.scripts?.["supatype:dev"]).toBe("supatype dev")
+    expect(merged.scripts?.push).toBe("supatype push")
+  })
+})

package/tests/init.test.ts

@@ -53,11 +53,15 @@ describe("scaffold()", () => {
     expect(content).toContain("pkg-app")
   })
 
-  it("skips package.json when it already exists", () => {
+  it("merges Supatype deps into package.json when it already exists", () => {
     const pkgPath = join(tmpRoot, "package.json")
-    writeFileSync(pkgPath, '{"name":"existing"}', "utf8")
+    writeFileSync(pkgPath, '{"name":"existing","scripts":{"dev":"next dev"}}', "utf8")
     scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
-    expect(readFileSync(pkgPath, "utf8")).toBe('{"name":"existing"}')
+    const content = readFileSync(pkgPath, "utf8")
+    expect(content).toContain("@supatype/cli")
+    expect(content).toContain("@supatype/types")
+    expect(content).toContain("next dev")
+    expect(content).toContain("supatype:dev")
   })
 
   it("supatype.config.ts documents self-host workflow", () => {
@@ -185,6 +189,29 @@ describe("scaffold()", () => {
     expect(html).toContain("github.com/supatype")
   })
 
+  it("static app mode with Vite on self-host splits production static and local proxy override", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app", "self-host"),
+      domain: "api.example.com",
+      app: {
+        mode: "static",
+        staticDir: "./public",
+        viteDevUrl: "http://127.0.0.1:5173",
+      },
+    })
+    const committed = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(committed).toContain('mode: "static"')
+    expect(committed).toContain('static_dir: "./dist"')
+    expect(committed).not.toContain("vite_dev_url")
+
+    const local = readFileSync(join(tmpRoot, "supatype.local.config.ts"), "utf8")
+    expect(local).toContain('mode: "proxy"')
+    expect(local).toContain('start: "vite"')
+    expect(local).toContain('vite_dev_url: "http://127.0.0.1:5173"')
+    expect(existsSync(join(tmpRoot, "dist/index.html"))).toBe(true)
+    expect(existsSync(join(tmpRoot, "vite.config.ts"))).toBe(true)
+  })
+
   it("static app mode with Vite scaffolds root index.html and vite.config.ts", () => {
     scaffold(tmpRoot, {
       ...defaultScaffoldOptions("my-app"),

package/tests/required-host-components.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest"
+import { mkdirSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { requiredHostComponents } from "../src/required-host-components.js"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+
+function baseConfig(provider: "docker" | "native"): SupatypeProjectConfig {
+  return {
+    project: { name: "test" },
+    provider,
+    database: { provider },
+    server: { mode: "dev" },
+    app: { mode: "none" },
+  }
+}
+
+describe("requiredHostComponents", () => {
+  it("returns engine for docker (types + admin config on the host)", () => {
+    expect(requiredHostComponents(baseConfig("docker"))).toEqual(["engine"])
+  })
+
+  it("returns engine for docker with overrides.engine", () => {
+    const config = baseConfig("docker")
+    config.overrides = { engine: "/path/to/engine" }
+    expect(requiredHostComponents(config)).toEqual(["engine"])
+  })
+
+  it("returns native core binaries without functions/", () => {
+    const dir = join(tmpdir(), `supatype-req-host-${Date.now()}`)
+    mkdirSync(dir, { recursive: true })
+    expect(requiredHostComponents(baseConfig("native"), dir)).toEqual([
+      "engine",
+      "server",
+      "postgres",
+    ])
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it("includes deno for native when functions/ exists", () => {
+    const dir = join(tmpdir(), `supatype-req-host-fn-${Date.now()}`)
+    mkdirSync(join(dir, "functions"), { recursive: true })
+    expect(requiredHostComponents(baseConfig("native"), dir)).toEqual([
+      "engine",
+      "server",
+      "postgres",
+      "deno",
+    ])
+    rmSync(dir, { recursive: true, force: true })
+  })
+})

package/tests/resolve-api-url.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest"
+import { mkdtempSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { resolveProjectApiUrl } from "../src/resolve-api-url.js"
+
+describe("resolveProjectApiUrl()", () => {
+  it("prefers PUBLIC_SUPATYPE_URL from .env (docker dev)", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-api-url-"))
+    writeFileSync(
+      join(cwd, ".env"),
+      "PUBLIC_SUPATYPE_URL=http://localhost:18473\nPORT=54321\n",
+      "utf8",
+    )
+    expect(resolveProjectApiUrl(cwd)).toBe("http://localhost:18473")
+  })
+
+  it("uses SUPATYPE_KONG_PORT when no URL env is set", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-api-url-"))
+    writeFileSync(join(cwd, ".env"), "SUPATYPE_KONG_PORT=19200\nPORT=54321\n", "utf8")
+    expect(resolveProjectApiUrl(cwd)).toBe("http://localhost:19200")
+  })
+})

package/tests/rest-cache-admin.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it, vi } from "vitest"
+
+vi.mock("../src/env-file.js", () => ({
+  readEnvValue: () => "test-service-role-key",
+}))
+
+vi.mock("../src/resolve-api-url.js", () => ({
+  resolveProjectApiUrl: () => "http://localhost:1234",
+}))
+
+describe("listRestCacheEntries", () => {
+  it("coerces null entries to an empty array", async () => {
+    const { listRestCacheEntries } = await import("../src/rest-cache-admin.js")
+
+    const originalFetch = globalThis.fetch
+    globalThis.fetch = vi.fn(async () =>
+      new Response(JSON.stringify({ entries: null, cursor: "0" }), { status: 200 }),
+    )
+
+    try {
+      const result = await listRestCacheEntries(process.cwd())
+      expect(result.entries).toEqual([])
+      expect(result.cursor).toBe("0")
+    } finally {
+      globalThis.fetch = originalFetch
+    }
+  })
+})

package/tests/runtime-contract.test.ts

@@ -115,7 +115,9 @@ describe("runtime contract", () => {
       SUPATYPE_SERVER_IMAGE: "supatype/server:v0.1.0",
       SUPATYPE_POSTGRES_IMAGE: "supatype/postgres:17-latest",
     })
-    expect(composeDockerImageEnv({ ...baseConfig, versions: undefined })).toEqual({})
+    const withoutVersions = { ...baseConfig }
+    delete withoutVersions.versions
+    expect(composeDockerImageEnv(withoutVersions)).toEqual({})
     expect(
       composeDockerImageEnv({
         ...baseConfig,
@@ -483,9 +485,16 @@ export default defineConfig({
     expect(compose).not.toContain("HTTPS is off")
   })
 
+  it("self-host compose always includes Valkey and SUPATYPE_VALKEY_ADDR on server", () => {
+    const compose = renderSelfHostCompose(baseConfig)
+    expect(compose).toContain("\n  valkey:\n")
+    expect(compose).toContain("valkey/valkey:8-alpine")
+    expect(compose).toContain("SUPATYPE_VALKEY_ADDR: valkey:6379")
+    expect(compose).toMatch(/^\s{2}valkey-data:/m)
+  })
+
   it("self-host compose stays plain HTTP with a discoverable hint when TLS is off", () => {
     const compose = renderSelfHostCompose(baseConfig)
-    expect(compose).not.toContain("\n  valkey:\n")
     expect(compose).not.toContain('- "443:8443"')
     expect(compose).toContain("${SUPATYPE_KONG_PORT:-18473}:8000")
     expect(compose).toContain("HTTPS is off")
@@ -496,7 +505,7 @@ export default defineConfig({
       ...baseConfig,
       server: { mode: "standalone", domain: "api.example.com" },
     })
-    expect(compose).not.toContain("\n  valkey:\n")
+    expect(compose).toContain("\n  valkey:\n")
     expect(compose).not.toContain('- "443:8443"')
   })
 

package/tests/tsconfig.json

@@ -3,7 +3,13 @@
   "compilerOptions": {
     "noEmit": true,
     "composite": false,
-    "rootDir": ".."
+    "rootDir": "../.."
   },
-  "include": ["./**/*.ts"]
+  "include": [
+    "./**/*.ts",
+    "../src/**/*.ts",
+    "../../studio/src/lib/normalize-admin-config.ts",
+    "../../studio/src/config.ts"
+  ],
+  "exclude": ["engine-distribution.test.ts"]
 }

package/tests/ui-confirm.test.ts

@@ -1,35 +1,39 @@
 import { describe, expect, it, vi, beforeEach } from "vitest"
 
-vi.mock("@clack/prompts", () => ({
-  confirm: vi.fn(),
+const confirmMock = vi.hoisted(() => vi.fn())
+
+vi.mock("../src/ui/clack.js", () => ({
+  p: {
+    confirm: confirmMock,
+    cancel: vi.fn(() => process.exit(0)),
+  },
   isCancel: vi.fn((v: unknown) => v === Symbol.for("cancel")),
-  cancel: vi.fn(),
+  CLACK_CANCEL: Symbol.for("cancel"),
 }))
 
 vi.mock("../src/ui/interactive.js", () => ({
   isInteractive: vi.fn(() => true),
 }))
 
-import * as clack from "@clack/prompts"
 import { confirm, logSkippedConfirm } from "../src/ui/confirm.js"
 import { isInteractive } from "../src/ui/interactive.js"
 
 describe("ui confirm", () => {
   beforeEach(() => {
-    vi.mocked(clack.confirm).mockReset()
+    confirmMock.mockReset()
     vi.mocked(isInteractive).mockReturnValue(true)
   })
 
-  it("returns clack confirm result in TTY mode", async () => {
-    vi.mocked(clack.confirm).mockResolvedValue(true)
+  it("returns ink confirm result in TTY mode", async () => {
+    confirmMock.mockResolvedValue(true)
     await expect(confirm("Proceed?")).resolves.toBe(true)
-    expect(clack.confirm).toHaveBeenCalledWith({ message: "Proceed?", initialValue: false })
+    expect(confirmMock).toHaveBeenCalledWith({ message: "Proceed?", initialValue: false })
   })
 
   it("uses nonInteractive fallback when not a TTY", async () => {
     vi.mocked(isInteractive).mockReturnValue(false)
     await expect(confirm("Proceed?", { nonInteractive: false })).resolves.toBe(false)
-    expect(clack.confirm).not.toHaveBeenCalled()
+    expect(confirmMock).not.toHaveBeenCalled()
   })
 
   it("logSkippedConfirm mentions --yes", () => {

package/tests/ui-messages.test.ts

@@ -1,45 +1,31 @@
-import { describe, expect, it, vi, beforeEach, afterAll } from "vitest"
+import { describe, expect, it, vi, beforeEach } from "vitest"
 
 const isInteractiveMock = vi.hoisted(() => vi.fn(() => false))
-const clackInfoMock = vi.hoisted(() => vi.fn())
 
 vi.mock("../src/ui/interactive.js", () => ({
   isInteractive: isInteractiveMock,
 }))
 
-vi.mock("@clack/prompts", async (importOriginal) => {
-  const original = await importOriginal<typeof import("@clack/prompts")>()
-  return {
-    ...original,
-    log: {
-      ...original.log,
-      info: clackInfoMock,
-    },
-  }
-})
-
 import { file, info, plain, step, SUPATYPE_PREFIX } from "../src/ui/messages.js"
 
 describe("ui messages", () => {
   beforeEach(() => {
     isInteractiveMock.mockReturnValue(false)
-    clackInfoMock.mockClear()
   })
 
   it("info prefixes with [supatype] when non-interactive", () => {
     const log = vi.spyOn(console, "log").mockImplementation(() => {})
     info("hello")
     expect(log.mock.calls[0]?.[0]).toBe(`${SUPATYPE_PREFIX} hello`)
-    expect(clackInfoMock).not.toHaveBeenCalled()
     log.mockRestore()
   })
 
-  it("info uses Clack log in interactive mode", () => {
+  it("info uses themed plain output in interactive mode", () => {
     isInteractiveMock.mockReturnValue(true)
     const log = vi.spyOn(console, "log").mockImplementation(() => {})
     info("hello")
-    expect(clackInfoMock).toHaveBeenCalledWith("hello")
-    expect(log).not.toHaveBeenCalled()
+    expect(String(log.mock.calls[0]?.[0])).toContain("hello")
+    expect(String(log.mock.calls[0]?.[0])).toContain("ℹ")
     log.mockRestore()
   })
 

package/tsconfig.json

@@ -4,6 +4,7 @@
     "outDir": "dist",
     "rootDir": "src",
     "composite": true,
+    "jsx": "react-jsx",
     "types": ["node"]
   },
   "include": ["src"]