@supatype/cli 0.1.0-alpha.9 → 0.1.1

package/tests/runtime-contract.test.ts

@@ -4,8 +4,8 @@ import { join } from "node:path"
 import { tmpdir } from "node:os"
 import { runtimeRouteSpec } from "../src/runtime-routes.js"
 import { buildKongDeclarative } from "../src/kong-config.js"
-import { renderSelfHostCompose, writeSelfHostCompose } from "../src/self-host-compose.js"
-import { updateAppConfigInProject } from "../src/app-config.js"
+import { composeDockerImageEnv, composePullNeedsIgnoreFailures, hasLocalVersionPins, isRegistryPullableImageRef, renderSelfHostCompose, writeSelfHostCompose } from "../src/self-host-compose.js"
+import { updateAppConfigInProject, updateServerConfigInProject } from "../src/app-config.js"
 import type { SupatypeProjectConfig } from "../src/project-config.js"
 import { DENO_RELEASE_PIN } from "../src/release-pins.js"
 
@@ -109,6 +109,68 @@ describe("runtime contract", () => {
     expect(compose).toContain("supatype/schema-engine:latest")
   })
 
+  it("composeDockerImageEnv maps pinned versions to SUPATYPE_*_IMAGE", () => {
+    expect(composeDockerImageEnv(baseConfig)).toEqual({
+      SUPATYPE_ENGINE_IMAGE: "supatype/schema-engine:v0.4.2",
+      SUPATYPE_SERVER_IMAGE: "supatype/server:v0.1.0",
+      SUPATYPE_POSTGRES_IMAGE: "supatype/postgres:17-latest",
+    })
+    expect(composeDockerImageEnv({ ...baseConfig, versions: undefined })).toEqual({})
+    expect(
+      composeDockerImageEnv({
+        ...baseConfig,
+        database: { provider: "docker", image: "supatype/postgres:custom" },
+      }),
+    ).toEqual({
+      SUPATYPE_ENGINE_IMAGE: "supatype/schema-engine:v0.4.2",
+      SUPATYPE_SERVER_IMAGE: "supatype/server:v0.1.0",
+      SUPATYPE_POSTGRES_IMAGE: "supatype/postgres:custom",
+    })
+  })
+
+  it("isRegistryPullableImageRef accepts semver and latest tags", () => {
+    expect(isRegistryPullableImageRef("supatype/server:latest")).toBe(true)
+    expect(isRegistryPullableImageRef("supatype/schema-engine:v0.4.2")).toBe(true)
+    expect(isRegistryPullableImageRef("supatype/postgres:17-latest")).toBe(true)
+    expect(isRegistryPullableImageRef("supatype/control-plane:local")).toBe(false)
+    expect(isRegistryPullableImageRef("supatype/server:keepsake-local")).toBe(false)
+  })
+
+  it("composePullNeedsIgnoreFailures is false for semver pins only", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-pull-"))
+    try {
+      writeFileSync(
+        join(cwd, ".env"),
+        "SUPATYPE_ENGINE_IMAGE=supatype/schema-engine:v0.4.2\n",
+        "utf8",
+      )
+      expect(hasLocalVersionPins(baseConfig)).toBe(false)
+      expect(composePullNeedsIgnoreFailures(baseConfig, cwd)).toBe(false)
+    } finally {
+      rmSync(cwd, { recursive: true, force: true })
+    }
+  })
+
+  it("composePullNeedsIgnoreFailures is true for versions.local or custom tags", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-pull-local-"))
+    try {
+      writeFileSync(
+        join(cwd, ".env"),
+        "SUPATYPE_CONTROL_PLANE_IMAGE=supatype/control-plane:local\n",
+        "utf8",
+      )
+      expect(
+        composePullNeedsIgnoreFailures(
+          { ...baseConfig, versions: { engine: "local" } },
+          cwd,
+        ),
+      ).toBe(true)
+      expect(composePullNeedsIgnoreFailures(baseConfig, cwd)).toBe(true)
+    } finally {
+      rmSync(cwd, { recursive: true, force: true })
+    }
+  })
+
   it("self-host compose mounts project root at /project (project-directory relative)", () => {
     const compose = renderSelfHostCompose(baseConfig)
     expect(compose).toContain("- .:/project")
@@ -148,6 +210,18 @@ describe("runtime contract", () => {
     expect(compose).toContain("SUPATYPE_APP_UPSTREAM: http://host.docker.internal:4321")
   })
 
+  it("devLocal compose injects SUPATYPE_VITE_DEV_URL when app.vite_dev_url is set", () => {
+    const compose = renderSelfHostCompose(
+      {
+        ...baseConfig,
+        app: { mode: "static", static_dir: "./dist", vite_dev_url: "http://127.0.0.1:5173" },
+      },
+      process.cwd(),
+      { devLocal: true },
+    )
+    expect(compose).toContain("SUPATYPE_VITE_DEV_URL: http://host.docker.internal:5173")
+  })
+
   it("devLocal compose omits studio container when overrides.studio is set", () => {
     const compose = renderSelfHostCompose(
       { ...baseConfig, overrides: { studio: "../supatype/packages/studio" } },
@@ -314,6 +388,60 @@ export default defineConfig({
     }
   })
 
+  it("server config updater sets standalone mode, domain, and tls (preserving other keys)", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-server-config-"))
+    try {
+      const configPath = join(dir, "supatype.config.ts")
+      writeFileSync(
+        configPath,
+        `import { defineConfig } from "@supatype/cli"
+
+export default defineConfig({
+  project: { name: "x" },
+  database: { provider: "docker" },
+  server: { mode: "dev", port: 54321 },
+  app: { mode: "none" },
+})
+`,
+        "utf8",
+      )
+      updateServerConfigInProject(dir, { domain: "demo.supatype.com", tlsEmail: "hello@supatype.com" })
+      const next = readFileSync(configPath, "utf8")
+      expect(next).toContain(`mode: "standalone"`)
+      expect(next).toContain(`domain: "demo.supatype.com"`)
+      expect(next).toContain(`tls: { email: "hello@supatype.com", provider: "kong" }`)
+      expect(next).toContain(`port: 54321`)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("server config updater is idempotent and overwrites a prior domain/email", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-server-config-"))
+    try {
+      const configPath = join(dir, "supatype.config.ts")
+      writeFileSync(
+        configPath,
+        `export default {
+  project: { name: "x" },
+  database: { provider: "docker" },
+  server: { mode: "standalone", domain: "old.example.com", tls: { email: "old@example.com", provider: "kong" } },
+  app: { mode: "none" },
+}
+`,
+        "utf8",
+      )
+      updateServerConfigInProject(dir, { domain: "new.supatype.com", tlsEmail: "new@supatype.com" })
+      const next = readFileSync(configPath, "utf8")
+      expect(next).toContain(`domain: "new.supatype.com"`)
+      expect(next).toContain(`email: "new@supatype.com"`)
+      expect(next).not.toContain("old.example.com")
+      expect(next).not.toContain("old@example.com")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
   it("writes self-host compose artifacts under .supatype/self-host", () => {
     const dir = mkdtempSync(join(tmpdir(), "supatype-compose-"))
     try {
@@ -337,6 +465,62 @@ export default defineConfig({
     }
   })
 
+  const tlsConfig: SupatypeProjectConfig = {
+    ...baseConfig,
+    server: { mode: "standalone", domain: "api.example.com", tls: { email: "ops@example.com" } },
+  }
+
+  it("self-host compose renders Kong TLS + Valkey when standalone domain + email are set", () => {
+    const compose = renderSelfHostCompose(tlsConfig)
+    expect(compose).toContain("\n  valkey:\n")
+    expect(compose).toContain("valkey/valkey:8-alpine")
+    expect(compose).toContain('- "80:8000"')
+    expect(compose).toContain('- "443:8443"')
+    expect(compose).toContain("KONG_PROXY_LISTEN")
+    expect(compose).toContain("- valkey")
+    expect(compose).toContain("https://api.example.com")
+    expect(compose).toMatch(/^\s{2}valkey-data:/m)
+    expect(compose).not.toContain("HTTPS is off")
+  })
+
+  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")
+  })
+
+  it("self-host compose does not enable TLS for a domain without an ACME email", () => {
+    const compose = renderSelfHostCompose({
+      ...baseConfig,
+      server: { mode: "standalone", domain: "api.example.com" },
+    })
+    expect(compose).not.toContain("\n  valkey:\n")
+    expect(compose).not.toContain('- "443:8443"')
+  })
+
+  it("writeSelfHostCompose emits a Kong acme plugin backed by Valkey when TLS is on", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-tls-"))
+    try {
+      const out = writeSelfHostCompose(dir, tlsConfig)
+      const kong = readFileSync(out.kongPath, "utf8")
+      expect(kong).toContain("name: acme")
+      expect(kong).toContain('account_email: "ops@example.com"')
+      expect(kong).toContain("tos_accepted: true")
+      expect(kong).toContain('- "api.example.com"')
+      expect(kong).toContain("storage: redis")
+      expect(kong).toContain('host: "valkey"')
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("kong declarative omits the acme plugin when no acme options are provided", () => {
+    const kong = buildKongDeclarative({ unifiedGateway: true })
+    expect(kong).not.toContain("name: acme")
+  })
+
   it("writes default manifest when missing for compose", () => {
     const dir = mkdtempSync(join(tmpdir(), "supatype-manifest-"))
     try {

package/tests/schema-sources.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { collectSchemaSourcePaths } from "../src/type-extractor.js"
+import {
+  packSchemaSources,
+  unpackSchemaSources,
+  buildSchemaSourcesPayload,
+  restoreSchemaSourcesFromGz,
+  findOrphanSchemaFiles,
+} from "../src/schema-sources.js"
+
+function writeMultiFileSchema(root: string): void {
+  mkdirSync(join(root, "schema", "models"), { recursive: true })
+  mkdirSync(join(root, "schema", "shared"), { recursive: true })
+  writeFileSync(
+    join(root, "schema", "index.ts"),
+    `export type { Album } from "./models/album"\nexport type { localeConfig } from "./shared/locale"\n`,
+  )
+  writeFileSync(
+    join(root, "schema", "models", "album.ts"),
+    `import type { Nullable } from "../shared/field-types"\nexport type Album = { id: string; title: Nullable<string> }\n`,
+  )
+  writeFileSync(
+    join(root, "schema", "shared", "field-types.ts"),
+    `export type Nullable<T> = T | null\n`,
+  )
+  writeFileSync(
+    join(root, "schema", "shared", "locale.ts"),
+    `export type localeConfig = { default: string }\n`,
+  )
+}
+
+describe("schema-sources", () => {
+  let tmp: string
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "schema-sources-"))
+  })
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true })
+  })
+
+  it("discovers multi-file graph from entry point", () => {
+    writeMultiFileSchema(tmp)
+    const entry = join(tmp, "schema", "index.ts")
+    const graph = collectSchemaSourcePaths(entry, tmp)
+    const paths = graph.files.map((f) => f.relativePath).sort()
+    expect(paths).toEqual([
+      "schema/index.ts",
+      "schema/models/album.ts",
+      "schema/shared/field-types.ts",
+      "schema/shared/locale.ts",
+    ])
+    expect(graph.entryPoint).toBe("schema/index.ts")
+  })
+
+  it("roundtrips tar+gzip bytes", () => {
+    writeMultiFileSchema(tmp)
+    const graph = collectSchemaSourcePaths(join(tmp, "schema", "index.ts"), tmp)
+    const tar = packSchemaSources(graph)
+    const files = unpackSchemaSources(tar, tmp)
+    for (const file of graph.files) {
+      const original = readFileSync(file.absolutePath)
+      const restored = files.get(file.relativePath.replace(/\\/g, "/"))
+      expect(restored?.equals(original)).toBe(true)
+    }
+  })
+
+  it("buildSchemaSourcesPayload includes manifest metadata", () => {
+    writeMultiFileSchema(tmp)
+    writeFileSync(
+      join(tmp, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        project: { name: "demo" },
+        database: { provider: "docker" },
+        server: { mode: "dev" },
+        app: { mode: "none" },
+        schema: { path: "schema/index.ts", pg_schema: "public" },
+      })}\n`,
+    )
+    const payload = buildSchemaSourcesPayload(tmp, "test@example.com")
+    expect(payload).not.toBeNull()
+    expect(payload!.manifest.fileCount).toBe(4)
+    expect(payload!.manifest.pushedBy).toBe("test@example.com")
+    expect(payload!.manifest.compressedBytes).toBeGreaterThan(0)
+  })
+
+  it("restore overwrites modified local files", () => {
+    writeMultiFileSchema(tmp)
+    writeFileSync(
+      join(tmp, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        project: { name: "demo" },
+        database: { provider: "docker" },
+        server: { mode: "dev" },
+        app: { mode: "none" },
+        schema: { path: "schema/index.ts", pg_schema: "public" },
+      })}\n`,
+    )
+    const payload = buildSchemaSourcesPayload(tmp)!
+    const albumPath = join(tmp, "schema", "models", "album.ts")
+    writeFileSync(albumPath, "// modified\n")
+
+    restoreSchemaSourcesFromGz(payload.gz, payload.manifest, tmp)
+    expect(readFileSync(albumPath, "utf8")).toContain("Nullable")
+  })
+
+  it("warns about orphan files not in snapshot", () => {
+    writeMultiFileSchema(tmp)
+    writeFileSync(join(tmp, "schema", "models", "experimental.ts"), "export type X = {}\n")
+    const graph = collectSchemaSourcePaths(join(tmp, "schema", "index.ts"), tmp)
+    const manifestPaths = new Set(graph.files.map((f) => f.relativePath))
+    const orphans = findOrphanSchemaFiles(tmp, graph.entryPoint, manifestPaths)
+    expect(orphans).toContain("schema/models/experimental.ts")
+  })
+})

package/tests/storage-provision.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+import {
+  bucketSpecsFromAst,
+  provisionBuckets,
+  provisionBucketsFromAst,
+  type SchemaStorageBucketAst,
+} from "../src/storage-provision.js"
+
+describe("bucketSpecsFromAst", () => {
+  it("maps storage bucket AST fields to API bucket specs", () => {
+    const buckets: SchemaStorageBucketAst[] = [
+      {
+        id: "photos",
+        public: false,
+        accessMode: "private",
+        allowedMimeTypes: ["image/jpeg"],
+        fileSizeLimit: 5_000_000,
+      },
+      { id: "avatars", public: true },
+    ]
+
+    expect(bucketSpecsFromAst({ storageBuckets: buckets })).toEqual([
+      {
+        id: "photos",
+        public: false,
+        access_mode: "private",
+        allowed_mime_types: ["image/jpeg"],
+        file_size_limit: 5_000_000,
+      },
+      { id: "avatars", public: true },
+    ])
+  })
+
+  it("returns an empty list when no buckets are declared", () => {
+    expect(bucketSpecsFromAst({})).toEqual([])
+  })
+})
+
+describe("provisionBuckets", () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it("POSTs each bucket to the storage API", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ status: 200, ok: true })
+    vi.stubGlobal("fetch", fetchMock)
+
+    await provisionBuckets("http://localhost:54321/storage/v1/", "service-key", [
+      { id: "photos", public: false },
+      { id: "avatars", public: true },
+    ])
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      "http://localhost:54321/storage/v1/bucket",
+      expect.objectContaining({
+        method: "POST",
+        headers: {
+          Authorization: "Bearer service-key",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ id: "photos", name: "photos", public: false }),
+      }),
+    )
+  })
+
+  it("treats 409 Conflict as success (bucket already exists)", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ status: 409, ok: false })
+    vi.stubGlobal("fetch", fetchMock)
+
+    await expect(
+      provisionBuckets("http://localhost:54321/storage/v1", "key", [{ id: "photos", public: false }]),
+    ).resolves.toBeUndefined()
+  })
+
+  it("warns and continues when the storage API is unreachable", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined)
+    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("ECONNREFUSED")))
+
+    await provisionBuckets("http://localhost:54321/storage/v1", "key", [{ id: "photos", public: false }])
+
+    expect(warn).toHaveBeenCalledWith('[storage] Storage API unreachable — skipped bucket "photos"')
+  })
+})
+
+describe("provisionBucketsFromAst", () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it("skips provisioning when the AST declares no buckets", async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal("fetch", fetchMock)
+
+    await provisionBucketsFromAst({}, "http://localhost:54321/storage/v1", "key")
+
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+})

package/tests/ui-confirm.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it, vi, beforeEach } from "vitest"
+
+vi.mock("@clack/prompts", () => ({
+  confirm: vi.fn(),
+  isCancel: vi.fn((v: unknown) => v === Symbol.for("cancel")),
+  cancel: vi.fn(),
+}))
+
+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()
+    vi.mocked(isInteractive).mockReturnValue(true)
+  })
+
+  it("returns clack confirm result in TTY mode", async () => {
+    vi.mocked(clack.confirm).mockResolvedValue(true)
+    await expect(confirm("Proceed?")).resolves.toBe(true)
+    expect(clack.confirm).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()
+  })
+
+  it("logSkippedConfirm mentions --yes", () => {
+    const log = vi.spyOn(console, "log").mockImplementation(() => {})
+    logSkippedConfirm("3 risky operations")
+    expect(log.mock.calls[0]?.[0]).toContain("--yes")
+    log.mockRestore()
+  })
+})

package/tests/ui-messages.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi, beforeEach, afterAll } 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", () => {
+    isInteractiveMock.mockReturnValue(true)
+    const log = vi.spyOn(console, "log").mockImplementation(() => {})
+    info("hello")
+    expect(clackInfoMock).toHaveBeenCalledWith("hello")
+    expect(log).not.toHaveBeenCalled()
+    log.mockRestore()
+  })
+
+  it("file action uses scaffold-style columns", () => {
+    const log = vi.spyOn(console, "log").mockImplementation(() => {})
+    file("created", "schema/index.ts")
+    expect(log.mock.calls[0]?.[0]).toBe("  created  schema/index.ts")
+    log.mockRestore()
+  })
+
+  it("step prints a titled section", () => {
+    const log = vi.spyOn(console, "log").mockImplementation(() => {})
+    step("Schema Push")
+    expect(log.mock.calls[0]?.[0]).toBe("\nSchema Push")
+    log.mockRestore()
+  })
+
+  it("plain writes unprefixed lines", () => {
+    const log = vi.spyOn(console, "log").mockImplementation(() => {})
+    plain("no prefix")
+    expect(log.mock.calls[0]?.[0]).toBe("no prefix")
+    log.mockRestore()
+  })
+})