@supatype/cli 0.1.0-alpha.13 → 0.1.0-alpha.15

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,7 +35,7 @@ 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")
@@ -46,7 +46,7 @@ describe("scaffold()", () => {
   })
 
   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")
@@ -56,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=")
@@ -77,23 +77,24 @@ 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/")
@@ -102,19 +103,19 @@ describe("scaffold()", () => {
   })
 
   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")
@@ -124,4 +125,116 @@ 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/.gitkeep"))).toBe(true)
+  })
+
+  it("proxy app mode writes upstream and start in the config", () => {
+    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"')
+  })
+
+  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")
+  })
 })

package/tests/runtime-contract.test.ts

@@ -5,7 +5,7 @@ import { tmpdir } from "node:os"
 import { runtimeRouteSpec } from "../src/runtime-routes.js"
 import { buildKongDeclarative } from "../src/kong-config.js"
 import { composeDockerImageEnv, composePullNeedsIgnoreFailures, hasLocalVersionPins, isRegistryPullableImageRef, renderSelfHostCompose, writeSelfHostCompose } from "../src/self-host-compose.js"
-import { updateAppConfigInProject } from "../src/app-config.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"
 
@@ -376,6 +376,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 {
@@ -399,6 +453,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 {