@supatype/cli 0.1.0-alpha.9 → 0.1.0

package/tests/docker-runtime.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, it, vi, beforeEach, afterEach, afterAll } 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())
+
+vi.mock("node:child_process", () => ({
+  spawnSync: spawnSyncMock,
+}))
+
+vi.mock("../src/ui/interactive.js", () => ({
+  isInteractive: isInteractiveMock,
+}))
+
+vi.mock("@clack/prompts", async (importOriginal) => {
+  const original = await importOriginal<typeof import("@clack/prompts")>()
+  return {
+    ...original,
+    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")>()
+  return {
+    ...original,
+    printLogo: printLogoMock,
+  }
+})
+
+import {
+  probeDockerDaemon,
+  reportDockerUnavailable,
+  requireDockerDaemon,
+} from "../src/docker-runtime.js"
+
+function spawnResult(
+  overrides: Partial<SpawnSyncReturns<string>> & Pick<SpawnSyncReturns<string>, "status">,
+): SpawnSyncReturns<string> {
+  return {
+    stdout: "",
+    stderr: "",
+    pid: 0,
+    output: ["", ""],
+    signal: null,
+    ...overrides,
+  }
+}
+
+describe("probeDockerDaemon", () => {
+  beforeEach(() => {
+    spawnSyncMock.mockReset()
+  })
+
+  it("returns ok when docker version and info succeed", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "Server Version: 24.0.0" }))
+
+    expect(probeDockerDaemon()).toEqual({ ok: true })
+    expect(spawnSyncMock).toHaveBeenCalledTimes(2)
+    expect(spawnSyncMock.mock.calls[0]?.[1]).toEqual(["version", "--format", "{{.Client.Version}}"])
+    expect(spawnSyncMock.mock.calls[1]?.[1]).toEqual(["info"])
+  })
+
+  it("returns cli_missing when docker is not on PATH", () => {
+    spawnSyncMock.mockReturnValueOnce(
+      spawnResult({ status: 1, error: Object.assign(new Error("spawn docker ENOENT"), { code: "ENOENT" }) }),
+    )
+
+    expect(probeDockerDaemon()).toEqual({ ok: false, reason: "cli_missing" })
+    expect(spawnSyncMock).toHaveBeenCalledTimes(1)
+  })
+
+  it("returns daemon_unavailable when info fails", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(
+        spawnResult({
+          status: 1,
+          stderr: "Cannot connect to the Docker daemon at unix:///var/run/docker.sock",
+        }),
+      )
+
+    expect(probeDockerDaemon()).toEqual({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Cannot connect to the Docker daemon at unix:///var/run/docker.sock",
+    })
+  })
+
+  it("returns daemon_unavailable when version exits non-zero but client version is present (e.g. Docker paused)", () => {
+    spawnSyncMock.mockReturnValueOnce(
+      spawnResult({
+        status: 1,
+        stdout: "29.4.0\n",
+        stderr: "Error response from daemon: Docker Desktop is manually paused.",
+      }),
+    )
+
+    expect(probeDockerDaemon()).toEqual({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Error response from daemon: Docker Desktop is manually paused.",
+    })
+    expect(spawnSyncMock).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe("reportDockerUnavailable", () => {
+  const errorMock = vi.spyOn(console, "error").mockImplementation(() => {})
+  const logMock = vi.spyOn(console, "log").mockImplementation(() => {})
+
+  beforeEach(() => {
+    isInteractiveMock.mockReturnValue(false)
+    errorMock.mockClear()
+    logMock.mockClear()
+    clackLogErrorMock.mockClear()
+    clackNoteMock.mockClear()
+    clackIntroMock.mockClear()
+    printLogoMock.mockClear()
+  })
+
+  afterAll(() => {
+    errorMock.mockRestore()
+    logMock.mockRestore()
+  })
+
+  it("uses [supatype] prefix on the headline via error()", () => {
+    reportDockerUnavailable({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Cannot connect to the Docker daemon",
+    })
+
+    expect(errorMock).toHaveBeenCalledWith(
+      "[supatype] Docker is installed but the daemon is not running.",
+    )
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes('provider: "native"'))).toBe(true)
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker: Cannot connect"))).toBe(
+      false,
+    )
+  })
+
+  it("mentions unpause when daemon detail says paused", () => {
+    reportDockerUnavailable({
+      ok: false,
+      reason: "daemon_unavailable",
+      detail: "Error response from daemon: Docker Desktop is manually paused.",
+    })
+
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("Unpause Docker Desktop"))).toBe(
+      true,
+    )
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker:"))).toBe(false)
+  })
+
+  it("mentions install for cli_missing", () => {
+    reportDockerUnavailable({ ok: false, reason: "cli_missing" })
+
+    expect(errorMock).toHaveBeenCalledWith("[supatype] Docker is not installed or not on your PATH.")
+    expect(logMock.mock.calls.some((call) => String(call[0]).includes("docker-desktop"))).toBe(true)
+  })
+
+  it("uses Clack log + note in interactive mode", () => {
+    isInteractiveMock.mockReturnValue(true)
+
+    reportDockerUnavailable(
+      {
+        ok: false,
+        reason: "daemon_unavailable",
+        detail: "Error response from daemon: Docker Desktop is manually paused.",
+      },
+      { brand: { intro: "Local development" } },
+    )
+
+    expect(printLogoMock).toHaveBeenCalled()
+    expect(clackIntroMock).toHaveBeenCalledWith("Local development")
+    expect(clackLogErrorMock).toHaveBeenCalledWith(
+      "Docker is installed but the daemon is not running.",
+    )
+    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">>
+
+  beforeEach(() => {
+    spawnSyncMock.mockReset()
+    isInteractiveMock.mockReturnValue(false)
+    exitMock = vi.spyOn(process, "exit").mockImplementation((() => {}) as typeof process.exit)
+    errorMock = vi.spyOn(console, "error").mockImplementation(() => {})
+  })
+
+  afterEach(() => {
+    exitMock.mockRestore()
+    errorMock.mockRestore()
+  })
+
+  it("exits when the daemon is unavailable", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(spawnResult({ status: 1, stderr: "daemon down" }))
+
+    requireDockerDaemon()
+
+    expect(errorMock).toHaveBeenCalled()
+    expect(exitMock).toHaveBeenCalledWith(1)
+  })
+
+  it("does not exit when docker is available", () => {
+    spawnSyncMock
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "24.0.0" }))
+      .mockReturnValueOnce(spawnResult({ status: 0, stdout: "ok" }))
+
+    requireDockerDaemon()
+
+    expect(exitMock).not.toHaveBeenCalled()
+    expect(errorMock).not.toHaveBeenCalled()
+  })
+})

package/tests/engine-push-output.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest"
+import {
+  filterComposeNoise,
+  formatEnginePushMessage,
+  parseEnginePushOutput,
+} from "../src/engine-push-output.js"
+
+describe("parseEnginePushOutput()", () => {
+  it("parses JSON on its own line amid docker progress", () => {
+    const output = [
+      " Container supatype-to-do-db-1 Running",
+      " Container supatype-to-do-db-1 Waiting",
+      " Container supatype-to-do-db-1 Healthy",
+      '{"status":"up_to_date","operations":0,"admin_refreshed":true}',
+      " Container supatype-to-do-schema-engine-run-abc Created",
+    ].join("\n")
+
+    expect(parseEnginePushOutput(output)).toEqual({
+      status: "up_to_date",
+      operations: 0,
+      admin_refreshed: true,
+    })
+  })
+
+  it("parses bare JSON output", () => {
+    expect(parseEnginePushOutput('{"status":"applied","operations":2}')).toEqual({
+      status: "applied",
+      operations: 2,
+    })
+  })
+
+  it("returns null when no JSON present", () => {
+    expect(parseEnginePushOutput("engine failed: connection refused")).toBeNull()
+  })
+})
+
+describe("formatEnginePushMessage()", () => {
+  it("formats up_to_date with admin refresh", () => {
+    expect(
+      formatEnginePushMessage({ status: "up_to_date", operations: 0, admin_refreshed: true }),
+    ).toBe("Schema up to date — Studio metadata synced.")
+  })
+
+  it("formats up_to_date without admin refresh", () => {
+    expect(formatEnginePushMessage({ status: "up_to_date" })).toBe("Schema up to date.")
+  })
+
+  it("formats applied operations", () => {
+    expect(formatEnginePushMessage({ status: "applied", operations: 3 })).toBe(
+      "Applied 3 operation(s).",
+    )
+  })
+})
+
+describe("filterComposeNoise()", () => {
+  it("removes container progress lines but keeps errors", () => {
+    const output = [
+      " Container supatype-to-do-db-1 Running",
+      "engine error: permission denied",
+      '{"status":"up_to_date","operations":0}',
+    ].join("\n")
+
+    expect(filterComposeNoise(output)).toBe(
+      'engine error: permission denied\n{"status":"up_to_date","operations":0}',
+    )
+  })
+})

package/tests/init.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from "vitest"
 import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync } from "node:fs"
 import { join } from "node:path"
 import { tmpdir } from "node:os"
-import { scaffold } from "../src/commands/init.js"
+import { scaffold, defaultScaffoldOptions } from "../src/commands/init.js"
 
 let tmpRoot: string
 
@@ -17,7 +17,7 @@ afterEach(() => {
 
 describe("scaffold()", () => {
   it("creates all expected files", () => {
-    scaffold(tmpRoot, "my-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
 
     const expected = [
       "package.json",
@@ -35,17 +35,18 @@ describe("scaffold()", () => {
   })
 
   it("supatype.config.ts embeds the project name and exports defineConfig", () => {
-    scaffold(tmpRoot, "blog-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("blog-app"))
     const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
     expect(content).toContain("blog-app")
     expect(content).toContain("defineConfig")
-    expect(content).toContain('provider: "native"')
+    expect(content).toContain('provider: "docker"')
     expect(content).toContain("schema:")
-    expect(content).toContain("versions:")
+    expect(content).toContain("Optional: pin component versions")
+    expect(content).not.toMatch(/^\s*versions:\s*\{/m)
   })
 
   it("package.json includes @supatype/cli and @supatype/types", () => {
-    scaffold(tmpRoot, "pkg-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("pkg-app"))
     const content = readFileSync(join(tmpRoot, "package.json"), "utf8")
     expect(content).toContain("@supatype/cli")
     expect(content).toContain("@supatype/types")
@@ -55,18 +56,18 @@ describe("scaffold()", () => {
   it("skips package.json when it already exists", () => {
     const pkgPath = join(tmpRoot, "package.json")
     writeFileSync(pkgPath, '{"name":"existing"}', "utf8")
-    scaffold(tmpRoot, "my-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
     expect(readFileSync(pkgPath, "utf8")).toBe('{"name":"existing"}')
   })
 
   it("supatype.config.ts documents self-host workflow", () => {
-    scaffold(tmpRoot, "my-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
     const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
     expect(content).toContain("self-host")
   })
 
   it(".env contains DATABASE_URL, JWT_SECRET, POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB", () => {
-    scaffold(tmpRoot, "my-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
     const content = readFileSync(join(tmpRoot, ".env"), "utf8")
     expect(content).toContain("DATABASE_URL=")
     expect(content).toContain("JWT_SECRET=")
@@ -76,44 +77,45 @@ describe("scaffold()", () => {
   })
 
   it(".env contains ANON_KEY, SERVICE_ROLE_KEY, and SITE_URL placeholders", () => {
-    scaffold(tmpRoot, "my-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
     const content = readFileSync(join(tmpRoot, ".env"), "utf8")
     expect(content).toContain("ANON_KEY=")
     expect(content).toContain("SERVICE_ROLE_KEY=")
     expect(content).toContain("SITE_URL=")
   })
 
-  it("schema/index.ts exports a User model using RFC v2 Model<>", () => {
-    scaffold(tmpRoot, "my-app")
+  it("schema/index.ts exports a Profile model using RFC v2 Model<>", () => {
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
     const content = readFileSync(join(tmpRoot, "schema/index.ts"), "utf8")
-    expect(content).toContain("export type User")
+    expect(content).toContain("export type Profile")
+    expect(content).toContain("display_name")
     expect(content).toContain("Model<")
     expect(content).toContain("access:")
   })
 
   it(".gitignore excludes .env, node_modules, and engine binary", () => {
-    scaffold(tmpRoot, "my-app")
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app"))
     const content = readFileSync(join(tmpRoot, ".gitignore"), "utf8")
     expect(content).toContain(".env")
     expect(content).toContain("node_modules/")
-    expect(content).toContain(".supatype/engine/")
+    expect(content).toContain(".supatype/")
     expect(content).toContain("supatype.local.config.ts")
   })
 
   it("seed.ts references the project name", () => {
-    scaffold(tmpRoot, "acme")
+    scaffold(tmpRoot, defaultScaffoldOptions("acme"))
     const content = readFileSync(join(tmpRoot, "seed.ts"), "utf8")
     expect(content).toContain("acme")
   })
 
   it("different project names produce different config bodies", () => {
-    scaffold(tmpRoot, "alpha")
+    scaffold(tmpRoot, defaultScaffoldOptions("alpha"))
     const alpha = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
 
     const tmp2 = join(tmpdir(), `dt-init-test2-${Date.now()}`)
     mkdirSync(tmp2, { recursive: true })
     try {
-      scaffold(tmp2, "beta")
+      scaffold(tmp2, defaultScaffoldOptions("beta"))
       const beta = readFileSync(join(tmp2, "supatype.config.ts"), "utf8")
       expect(alpha).toContain("alpha")
       expect(beta).toContain("beta")
@@ -123,4 +125,181 @@ describe("scaffold()", () => {
       rmSync(tmp2, { recursive: true, force: true })
     }
   })
+
+  it("self-host target emits standalone mode + domain and a local override", () => {
+    scaffold(tmpRoot, { ...defaultScaffoldOptions("my-app", "self-host"), domain: "api.example.com" })
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('mode: "standalone"')
+    expect(content).toContain('domain: "api.example.com"')
+    expect(content).toContain('environments: { default: "production" }')
+    expect(existsSync(join(tmpRoot, "supatype.local.config.ts"))).toBe(true)
+    const local = readFileSync(join(tmpRoot, "supatype.local.config.ts"), "utf8")
+    expect(local).toContain('mode: "dev"')
+    expect(local).toContain("Partial<SupatypeConfig>")
+  })
+
+  it("self-host with a TLS email emits an active tls block", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app", "self-host"),
+      domain: "api.example.com",
+      tlsEmail: "ops@example.com",
+    })
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('tls: { email: "ops@example.com" }')
+  })
+
+  it("self-host without a TLS email emits a commented tls hint", () => {
+    scaffold(tmpRoot, { ...defaultScaffoldOptions("my-app", "self-host"), domain: "api.example.com" })
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('// tls: { email: "you@example.com" }')
+  })
+
+  it("cloud target emits managed mode + environments and a local override", () => {
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app", "cloud"))
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('mode: "managed"')
+    expect(content).toContain('environments: { default: "production" }')
+    expect(existsSync(join(tmpRoot, "supatype.local.config.ts"))).toBe(true)
+  })
+
+  it("later target stays in dev mode with no local override", () => {
+    scaffold(tmpRoot, defaultScaffoldOptions("my-app", "later"))
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('mode: "dev"')
+    expect(content).not.toContain("environments:")
+    expect(existsSync(join(tmpRoot, "supatype.local.config.ts"))).toBe(false)
+  })
+
+  it("static app mode writes the static dir and config block", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app"),
+      app: { mode: "static", staticDir: "./dist" },
+    })
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('mode: "static"')
+    expect(content).toContain('static_dir: "./dist"')
+    expect(existsSync(join(tmpRoot, "dist/index.html"))).toBe(true)
+    const html = readFileSync(join(tmpRoot, "dist/index.html"), "utf8")
+    expect(html).toContain("Supatype")
+    expect(html).toContain("supatype.github.io/supatype/")
+    expect(html).toContain("github.com/supatype")
+  })
+
+  it("static app mode with Vite scaffolds root index.html and vite.config.ts", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app"),
+      app: {
+        mode: "static",
+        staticDir: "./public",
+        viteDevUrl: "http://127.0.0.1:5173",
+      },
+    })
+    expect(existsSync(join(tmpRoot, "public/index.html"))).toBe(true)
+    expect(existsSync(join(tmpRoot, "index.html"))).toBe(true)
+    expect(existsSync(join(tmpRoot, "vite.config.ts"))).toBe(true)
+    const pkg = readFileSync(join(tmpRoot, "package.json"), "utf8")
+    expect(pkg).toContain('"vite": "vite"')
+    expect(pkg).toContain('"vite": "^6"')
+    const viteConfig = readFileSync(join(tmpRoot, "vite.config.ts"), "utf8")
+    expect(viteConfig).toContain("port: 5173")
+  })
+
+  it("proxy app mode writes upstream and start in the config when target is later", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app"),
+      app: { mode: "proxy", upstream: "http://localhost:4000", start: "dev" },
+    })
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('mode: "proxy"')
+    expect(content).toContain('upstream: "http://localhost:4000"')
+    expect(content).toContain('start: "dev"')
+    expect(existsSync(join(tmpRoot, "supatype.local.config.ts"))).toBe(false)
+  })
+
+  it("proxy app mode with self-host splits static production config and local proxy override", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app", "self-host"),
+      domain: "api.example.com",
+      app: {
+        mode: "proxy",
+        upstream: "http://127.0.0.1:5173",
+        start: "vite",
+        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('mode: "proxy"')
+
+    const local = readFileSync(join(tmpRoot, "supatype.local.config.ts"), "utf8")
+    expect(local).toContain('mode: "dev"')
+    expect(local).toContain('mode: "proxy"')
+    expect(local).toContain('upstream: "http://127.0.0.1:5173"')
+    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, "index.html"))).toBe(true)
+    expect(existsSync(join(tmpRoot, "vite.config.ts"))).toBe(true)
+  })
+
+  it("proxy app mode with cloud target splits static production config and local proxy override", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app", "cloud"),
+      app: { mode: "proxy", upstream: "http://localhost:3000", start: "dev" },
+    })
+    const committed = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(committed).toContain('mode: "static"')
+    expect(committed).not.toContain('mode: "proxy"')
+
+    const local = readFileSync(join(tmpRoot, "supatype.local.config.ts"), "utf8")
+    expect(local).toContain('mode: "proxy"')
+    expect(local).toContain('upstream: "http://localhost:3000"')
+  })
+
+  it("hello-world function scaffolds function files and a functions script", () => {
+    scaffold(tmpRoot, { ...defaultScaffoldOptions("my-app"), helloFunction: true })
+    expect(existsSync(join(tmpRoot, "functions/hello/index.ts"))).toBe(true)
+    expect(existsSync(join(tmpRoot, "functions/_shared/README.md"))).toBe(true)
+    expect(existsSync(join(tmpRoot, "functions/.env.local"))).toBe(true)
+    const pkg = readFileSync(join(tmpRoot, "package.json"), "utf8")
+    expect(pkg).toContain("supatype functions serve")
+  })
+
+  it("custom schema path is honored", () => {
+    scaffold(tmpRoot, { ...defaultScaffoldOptions("my-app"), schemaPath: "db/schema.ts" })
+    expect(existsSync(join(tmpRoot, "db/schema.ts"))).toBe(true)
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain('path: "db/schema.ts"')
+  })
+
+  it("s3 storage and resend email reflect in config and .env", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app"),
+      email: "resend",
+      storageLocal: "s3",
+      storageProduction: "s3",
+    })
+    const config = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(config).toContain('email: { provider: "resend" }')
+    expect(config).toContain('storage: { provider: "s3" }')
+    const env = readFileSync(join(tmpRoot, ".env"), "utf8")
+    expect(env).toContain("RESEND_API_KEY=")
+    expect(env).toContain("S3_BUCKET=")
+    expect(env).toContain("local development and production")
+  })
+
+  it("mixed local dev and s3 production writes both storage sections", () => {
+    scaffold(tmpRoot, {
+      ...defaultScaffoldOptions("my-app"),
+      storageLocal: "local",
+      storageProduction: "s3",
+    })
+    const config = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(config).toContain('provider: "local"')
+    expect(config).toContain("Production storage: external S3")
+    const env = readFileSync(join(tmpRoot, ".env"), "utf8")
+    expect(env).toContain("local development — MinIO")
+    expect(env).toContain("production — external bucket")
+  })
 })