@supatype/cli 0.1.1 → 0.1.3

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/stdin-after-ink.test.ts

@@ -0,0 +1,8 @@
+import { describe, it, expect } from "vitest"
+import { restoreStdinAfterInk } from "../src/ui/runtime/stdin-after-ink.js"
+
+describe("restoreStdinAfterInk()", () => {
+  it("does not throw when stdin is not a TTY", () => {
+    expect(() => restoreStdinAfterInk()).not.toThrow()
+  })
+})

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"]