@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.7

package/tests/engine-distribution.test.ts

@@ -59,12 +59,12 @@ describe("CDN URL construction", () => {
     const { getCdnUrl } = await import("../src/engine/platform.js")
 
     const url = getCdnUrl(
-      "https://releases.supatype.io/engine",
+      "https://releases.supatype.com/engine",
       "0.1.0-alpha.1",
       "supatype-engine-0.1.0-alpha.1-linux-x64",
     )
     expect(url).toBe(
-      "https://releases.supatype.io/engine/v0.1.0-alpha.1/supatype-engine-0.1.0-alpha.1-linux-x64",
+      "https://releases.supatype.com/engine/v0.1.0-alpha.1/supatype-engine-0.1.0-alpha.1-linux-x64",
     )
   })
 })
@@ -329,7 +329,7 @@ describe("Engine version constants", () => {
     } = await import("../src/engine-version.js")
 
     expect(ENGINE_VERSION).toMatch(/^\d+\.\d+\.\d+/)
-    expect(CDN_BASE_URL).toBe("https://releases.supatype.io/engine")
+    expect(CDN_BASE_URL).toBe("https://releases.supatype.com/engine")
     expect(ENGINE_RELEASES_REPO).toBe("supatype/engine-releases")
     expect(GITHUB_RELEASES_FALLBACK_URL).toContain("github.com")
   })

package/tests/ensure-binary.test.ts

@@ -0,0 +1,59 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest"
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+import * as binaryCache from "../src/binary-cache.js"
+import { ensureBinary } from "../src/ensure-binary.js"
+
+const TEST_VERSION = "9.9.9"
+
+const config = (): SupatypeProjectConfig => ({
+  project: { name: "test" },
+  database: { provider: "native" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  versions: {
+    engine: "0.4.2",
+    server: "0.1.0",
+    postgres: "17.2",
+    deno: TEST_VERSION,
+  },
+})
+
+beforeEach(() => {
+  const dir = binaryCache.cachePath("deno", TEST_VERSION)
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+  mkdirSync(dir, { recursive: true })
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  const dir = binaryCache.cachePath("deno", TEST_VERSION)
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+describe("ensureBinary", () => {
+  it("returns cached path without calling download", async () => {
+    const platform = binaryCache.currentPlatform()
+    const path = binaryCache.cachedBinaryPath("deno", TEST_VERSION, platform)
+    writeFileSync(path, "stub", { mode: 0o755 })
+
+    const downloadSpy = vi.spyOn(binaryCache, "download")
+    const resolved = await ensureBinary("deno", config())
+    expect(resolved).toBe(path)
+    expect(downloadSpy).not.toHaveBeenCalled()
+  })
+
+  it("downloads on cache miss", async () => {
+    const platform = binaryCache.currentPlatform()
+    const expected = binaryCache.cachedBinaryPath("deno", TEST_VERSION, platform)
+    const downloadSpy = vi.spyOn(binaryCache, "download").mockResolvedValue(expected)
+
+    const path = await ensureBinary("deno", config())
+    expect(path).toBe(expected)
+    expect(downloadSpy).toHaveBeenCalledWith("deno", TEST_VERSION, platform)
+  })
+})

package/tests/init.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from "vitest"
-import { mkdirSync, rmSync, existsSync, readFileSync } from "node:fs"
+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"
@@ -20,14 +20,13 @@ describe("scaffold()", () => {
     scaffold(tmpRoot, "my-app")
 
     const expected = [
+      "package.json",
       "supatype.config.ts",
       "schema/index.ts",
       ".env",
-      "docker-compose.yml",
-      ".supatype/kong.yml",
-      ".supatype/pgbouncer.ini",
-      ".supatype/userlist.txt",
       "seed.ts",
+      "seeds/.gitkeep",
+      "public/.gitkeep",
       ".gitignore",
     ]
     for (const rel of expected) {
@@ -40,77 +39,38 @@ describe("scaffold()", () => {
     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("schema:")
-    expect(content).toContain("output:")
+    expect(content).toContain("versions:")
   })
 
-  it("supatype.config.ts contains commented selfHost section", () => {
-    scaffold(tmpRoot, "my-app")
-    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
-    expect(content).toContain("selfHost")
-    expect(content).toContain("domain")
-  })
-
-  it("docker-compose.yml references project name, correct images, and health check", () => {
-    scaffold(tmpRoot, "shop")
-    const content = readFileSync(join(tmpRoot, "docker-compose.yml"), "utf8")
-    expect(content).toContain("shop")
-    expect(content).toContain("supatype/postgres")
-    expect(content).toContain("postgrest/postgrest")
-    expect(content).toContain("kong:")
-    expect(content).toContain("service_healthy")
-  })
-
-  it("docker-compose.yml includes GoTrue auth service", () => {
-    scaffold(tmpRoot, "shop")
-    const content = readFileSync(join(tmpRoot, "docker-compose.yml"), "utf8")
-    expect(content).toContain("gotrue:")
-    expect(content).toContain("supatype/auth")
-    expect(content).toContain("GOTRUE_JWT_SECRET")
-    expect(content).toContain("9999")
-  })
-
-  it("docker-compose.yml includes PgBouncer service connecting services via port 6432", () => {
-    scaffold(tmpRoot, "shop")
-    const content = readFileSync(join(tmpRoot, "docker-compose.yml"), "utf8")
-    expect(content).toContain("pgbouncer:")
-    expect(content).toContain("pgbouncer/pgbouncer")
-    expect(content).toContain("pgbouncer:6432")
-    expect(content).toContain("PGRST_DB_POOL")
-  })
-
-  it("docker-compose.yml includes studio service (merged admin + studio)", () => {
-    scaffold(tmpRoot, "shop")
-    const content = readFileSync(join(tmpRoot, "docker-compose.yml"), "utf8")
-    expect(content).toContain("studio:")
-    expect(content).toContain("ghcr.io/supatype/studio")
-    expect(content).toContain("3002:3002")
-    // Admin was merged into studio — no separate admin service
-    expect(content).not.toContain("ghcr.io/supatype/admin")
+  it("package.json includes @supatype/cli and @supatype/types", () => {
+    scaffold(tmpRoot, "pkg-app")
+    const content = readFileSync(join(tmpRoot, "package.json"), "utf8")
+    expect(content).toContain("@supatype/cli")
+    expect(content).toContain("@supatype/types")
+    expect(content).toContain("pkg-app")
   })
 
-  it("docker-compose.yml includes commented app service slot", () => {
-    scaffold(tmpRoot, "shop")
-    const content = readFileSync(join(tmpRoot, "docker-compose.yml"), "utf8")
-    expect(content).toContain("supatype app add")
-    expect(content).toContain("SUPATYPE_URL")
-    expect(content).toContain("SUPATYPE_ANON_KEY")
+  it("skips package.json when it already exists", () => {
+    const pkgPath = join(tmpRoot, "package.json")
+    writeFileSync(pkgPath, '{"name":"existing"}', "utf8")
+    scaffold(tmpRoot, "my-app")
+    expect(readFileSync(pkgPath, "utf8")).toBe('{"name":"existing"}')
   })
 
-  it(".supatype/pgbouncer.ini has correct pool settings", () => {
+  it("supatype.config.ts documents self-host workflow", () => {
     scaffold(tmpRoot, "my-app")
-    const content = readFileSync(join(tmpRoot, ".supatype/pgbouncer.ini"), "utf8")
-    expect(content).toContain("pool_mode = transaction")
-    expect(content).toContain("default_pool_size = 20")
-    expect(content).toContain("max_db_connections = 60")
-    expect(content).toContain("listen_port = 6432")
+    const content = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
+    expect(content).toContain("self-host")
   })
 
-  it(".env contains DATABASE_URL, JWT_SECRET, POSTGRES_PASSWORD, POSTGRES_DB", () => {
+  it(".env contains DATABASE_URL, JWT_SECRET, POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB", () => {
     scaffold(tmpRoot, "my-app")
     const content = readFileSync(join(tmpRoot, ".env"), "utf8")
     expect(content).toContain("DATABASE_URL=")
     expect(content).toContain("JWT_SECRET=")
+    expect(content).toContain("POSTGRES_USER=")
     expect(content).toContain("POSTGRES_PASSWORD=")
     expect(content).toContain("POSTGRES_DB=")
   })
@@ -123,31 +83,12 @@ describe("scaffold()", () => {
     expect(content).toContain("SITE_URL=")
   })
 
-  it("schema/index.ts exports a User model with field builders and access rules", () => {
+  it("schema/index.ts exports a User model using RFC v2 Model<>", () => {
     scaffold(tmpRoot, "my-app")
     const content = readFileSync(join(tmpRoot, "schema/index.ts"), "utf8")
-    expect(content).toContain("export const User")
-    expect(content).toContain("model(")
-    expect(content).toContain("field.")
-    expect(content).toContain("access.")
-    expect(content).toContain("options: { timestamps: true }")
-  })
-
-  it(".supatype/kong.yml declares REST, GraphQL, and auth routes", () => {
-    scaffold(tmpRoot, "my-app")
-    const content = readFileSync(join(tmpRoot, ".supatype/kong.yml"), "utf8")
-    expect(content).toContain("/rest/v1/")
-    expect(content).toContain("/graphql/v1")
-    expect(content).toContain("/auth/v1/")
-    expect(content).toContain("postgrest")
-    expect(content).toContain("gotrue")
-  })
-
-  it(".supatype/kong.yml contains commented app fallback route", () => {
-    scaffold(tmpRoot, "my-app")
-    const content = readFileSync(join(tmpRoot, ".supatype/kong.yml"), "utf8")
-    expect(content).toContain("supatype app add")
-    expect(content).toContain("app-root")
+    expect(content).toContain("export type User")
+    expect(content).toContain("Model<")
+    expect(content).toContain("access:")
   })
 
   it(".gitignore excludes .env, node_modules, and engine binary", () => {
@@ -156,6 +97,7 @@ describe("scaffold()", () => {
     expect(content).toContain(".env")
     expect(content).toContain("node_modules/")
     expect(content).toContain(".supatype/engine/")
+    expect(content).toContain("supatype.local.config.ts")
   })
 
   it("seed.ts references the project name", () => {
@@ -164,7 +106,7 @@ describe("scaffold()", () => {
     expect(content).toContain("acme")
   })
 
-  it("different project names produce different connection strings", () => {
+  it("different project names produce different config bodies", () => {
     scaffold(tmpRoot, "alpha")
     const alpha = readFileSync(join(tmpRoot, "supatype.config.ts"), "utf8")
 

package/tests/migrate-from-v1.test.ts

@@ -0,0 +1,29 @@
+import ts from "typescript"
+import { describe, expect, it } from "vitest"
+import { codemodSource } from "../src/commands/migrate-from-v1.js"
+
+describe("migrate-from-v1 codemod", () => {
+  it("converts exported model() declarations into Model<> aliases", () => {
+    const source = ts.createSourceFile(
+      "schema.ts",
+      `
+import { model, field } from "@supatype/schema"
+export const User = model("user", {
+  fields: {
+    id: field.uuid({ required: true }),
+    email: field.email({ required: true, unique: true }),
+    name: field.text({ required: true }),
+  },
+})
+`,
+      ts.ScriptTarget.Latest,
+      true,
+      ts.ScriptKind.TS,
+    )
+
+    const out = codemodSource(source)
+    expect(out).toContain("export type User = Model<")
+    expect(out).toContain("id: UUID")
+    expect(out).toContain("email: string")
+  })
+})

package/tests/pg-spawn-env.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest"
+import { join } from "node:path"
+import { pgSpawnEnv } from "../src/postgres-ctl.js"
+
+const PG_BIN = "/cache/postgres/17.2/pg-17.2/bin"
+const PG_LIB = join("/cache/postgres/17.2/pg-17.2", "lib")
+
+describe("pgSpawnEnv", () => {
+  it("prepends lib dir to DYLD_LIBRARY_PATH on darwin", () => {
+    const env = pgSpawnEnv(PG_BIN, "darwin")
+    expect(env.DYLD_LIBRARY_PATH).toContain(PG_LIB)
+  })
+
+  it("prepends lib dir to LD_LIBRARY_PATH on linux", () => {
+    const env = pgSpawnEnv(PG_BIN, "linux")
+    expect(env.LD_LIBRARY_PATH).toContain(PG_LIB)
+  })
+})

package/tests/postgres-archive-tag.test.ts

@@ -0,0 +1,9 @@
+import { describe, expect, it } from "vitest"
+import { postgresArchiveTag } from "../src/binary-cache.js"
+
+describe("postgresArchiveTag", () => {
+  it("uses PG major only for CDN archive basenames", () => {
+    expect(postgresArchiveTag("17.2")).toBe("17")
+    expect(postgresArchiveTag("17")).toBe("17")
+  })
+})

package/tests/pull-utils.test.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect } from "vitest"
-import { pgTypeToField, toCamelCase, type ColumnInfo } from "../src/pull-utils.js"
+import {
+  introspectColumnToColumnInfo,
+  pgTypeToField,
+  toCamelCase,
+  type ColumnInfo,
+} from "../src/pull-utils.js"
 
 function col(overrides: Partial<ColumnInfo> & { pgType: string }): ColumnInfo {
   return {
@@ -100,6 +105,36 @@ describe("pgTypeToField()", () => {
   })
 })
 
+describe("introspectColumnToColumnInfo()", () => {
+  it("maps engine type → pgType and flags", () => {
+    const out = introspectColumnToColumnInfo({
+      name: "id",
+      type: "uuid",
+      nullable: false,
+      primaryKey: true,
+      default: "gen_random_uuid()",
+    })
+    expect(out).toEqual({
+      name: "id",
+      pgType: "uuid",
+      nullable: false,
+      isPrimary: true,
+      isUnique: false,
+      hasDefault: true,
+    })
+  })
+
+  it("treats empty default as no default", () => {
+    const out = introspectColumnToColumnInfo({
+      name: "x",
+      type: "text",
+      nullable: true,
+      default: "",
+    })
+    expect(out.hasDefault).toBe(false)
+  })
+})
+
 describe("toCamelCase()", () => {
   it.each([
     ["user", "User"],

package/tests/release-pins.test.ts

@@ -0,0 +1,28 @@
+import { readFileSync } from "node:fs"
+import { join, resolve } from "node:path"
+import { describe, expect, it } from "vitest"
+import { DENO_RELEASE_PIN } from "../src/release-pins.js"
+
+const CLI_ROOT = resolve(import.meta.dirname, "..")
+const REPO_ROOT = resolve(CLI_ROOT, "../..")
+
+const EXAMPLE_CONFIGS = [
+  "examples/blog/supatype.config.ts",
+  "examples/self-host/supatype.config.ts",
+  "tests/integration/supatype.config.ts",
+]
+
+describe("release-pins", () => {
+  it("DENO_RELEASE_PIN matches releases/deno/VERSION", () => {
+    const file = join(CLI_ROOT, "releases", "deno", "VERSION")
+    expect(DENO_RELEASE_PIN).toBe(readFileSync(file, "utf8").trim())
+  })
+
+  it("example configs use the same deno pin", () => {
+    const needle = `deno: "${DENO_RELEASE_PIN}"`
+    for (const rel of EXAMPLE_CONFIGS) {
+      const content = readFileSync(join(REPO_ROOT, rel), "utf8")
+      expect(content, rel).toContain(needle)
+    }
+  })
+})

package/tests/runtime-contract.test.ts

@@ -0,0 +1,236 @@
+import { describe, expect, it } from "vitest"
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+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 type { SupatypeProjectConfig } from "../src/project-config.js"
+import { DENO_RELEASE_PIN } from "../src/release-pins.js"
+
+const baseConfig: SupatypeProjectConfig = {
+  project: { name: "acme" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: { mode: "none" },
+  versions: {
+    engine: "0.4.2",
+    server: "0.1.0",
+    postgres: "17.2",
+    deno: DENO_RELEASE_PIN,
+  },
+}
+
+describe("runtime contract", () => {
+  it("includes core route families", () => {
+    const paths = runtimeRouteSpec().flatMap((r) => r.paths)
+    for (const path of ["/rest/v1/", "/auth/v1/", "/storage/v1/", "/realtime/v1/", "/functions/v1/"]) {
+      expect(paths).toContain(path)
+    }
+  })
+
+  it("renders app root route when upstream is provided", () => {
+    const paths = runtimeRouteSpec({ appUpstream: "http://app:3000" }).flatMap((r) => r.paths)
+    expect(paths).toContain("/")
+  })
+
+  it("renders app root route for static service URL", () => {
+    const paths = runtimeRouteSpec({ staticAppServiceUrl: "http://static-app:8080" }).flatMap((r) => r.paths)
+    expect(paths).toContain("/")
+  })
+
+  it("self-host kong uses unified supatype-server gateway", () => {
+    const kong = buildKongDeclarative({ unifiedGateway: true })
+    expect(kong).toContain("http://server:9999")
+    expect(kong).toContain("/rest/v1/")
+    expect(kong).toContain("/auth/v1/")
+    expect(kong).toContain("/storage/v1/")
+    expect(kong).toContain("/realtime/v1/")
+    expect(kong).toContain("/functions/v1/")
+    expect(kong).not.toContain("http://postgrest:3000")
+    expect(kong).not.toContain("http://storage:5000")
+  })
+
+  it("kong declarative output contains route contract paths", () => {
+    const kong = buildKongDeclarative({ appUpstream: "http://app:3000" })
+    expect(kong).toContain("/rest/v1/")
+    expect(kong).toContain("/auth/v1/")
+    expect(kong).toContain("/storage/v1/")
+    expect(kong).toContain("/realtime/v1/")
+    expect(kong).toContain("/functions/v1/")
+    expect(kong).toContain("- /")
+  })
+
+  it("self-host compose render is deterministic for same config", () => {
+    const first = renderSelfHostCompose({ ...baseConfig, app: { mode: "proxy", upstream: "http://app:3000" } })
+    const second = renderSelfHostCompose({ ...baseConfig, app: { mode: "proxy", upstream: "http://app:3000" } })
+    expect(first).toBe(second)
+  })
+
+  it("self-host compose does not inject a synthetic app-proxy service", () => {
+    const compose = renderSelfHostCompose({ ...baseConfig, app: { mode: "proxy", upstream: "http://app:3000" } })
+    expect(compose).not.toContain("ghcr.io/supatype/app-proxy")
+    expect(compose).not.toContain("\n  app:\n")
+  })
+
+  it("self-host compose configures static app on supatype-server", () => {
+    const compose = renderSelfHostCompose({ ...baseConfig, app: { mode: "static", static_dir: "./public" } })
+    expect(compose).toContain('SUPATYPE_APP_MODE: static')
+    expect(compose).toContain("SUPATYPE_APP_STATIC_DIR: /project/public")
+    expect(compose).not.toContain("static-app:")
+  })
+
+  it("self-host compose runs per-project functions-worker and proxies via server", () => {
+    const compose = renderSelfHostCompose(baseConfig)
+    expect(compose).toContain("\n  functions-worker:\n")
+    expect(compose).toContain("SUPATYPE_FUNCTIONS_WORKER_URL: http://functions-worker:8001")
+    expect(compose).toContain("SUPATYPE_FUNCTIONS_ROOT: /project/functions")
+    expect(compose).not.toContain("deploy/functions")
+    expect(compose).not.toContain("supatype-functions")
+  })
+
+  it("app config updater writes proxy mode intent", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-app-config-"))
+    try {
+      const configPath = join(dir, "supatype.config.ts")
+      writeFileSync(
+        configPath,
+        `export default {
+  project: { name: "x" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: {
+    mode: "none",
+    // mode: "static", static_dir: "./dist",
+    // mode: "proxy", upstream: "http://localhost:3000",
+  },
+  versions: { engine: "0", server: "0", postgres: "0", deno: "0" },
+}
+`,
+        "utf8",
+      )
+      updateAppConfigInProject(dir, { mode: "proxy", upstream: "http://localhost:7777" })
+      const next = readFileSync(configPath, "utf8")
+      expect(next).toContain(`mode: "proxy"`)
+      expect(next).toContain(`upstream: "http://localhost:7777"`)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("app config updater handles defineConfig wrappers", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-app-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" },
+  app: { mode: "none" },
+  versions: { engine: "0", server: "0", postgres: "0", deno: "0" },
+})
+`,
+        "utf8",
+      )
+      updateAppConfigInProject(dir, { mode: "static", staticDir: "./site" })
+      const next = readFileSync(configPath, "utf8")
+      expect(next).toContain(`mode: "static"`)
+      expect(next).toContain(`static_dir: "./site"`)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("app config updater inserts app block when missing", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-app-config-"))
+    try {
+      const configPath = join(dir, "supatype.config.ts")
+      writeFileSync(
+        configPath,
+        `export default {
+  project: { name: "x" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  versions: { engine: "0", server: "0", postgres: "0", deno: "0" },
+}
+`,
+        "utf8",
+      )
+      updateAppConfigInProject(dir, { mode: "none" })
+      const next = readFileSync(configPath, "utf8")
+      expect(next).toContain("app:")
+      expect(next).toContain(`mode: "none"`)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("app config updater preserves unrelated app keys", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-app-config-"))
+    try {
+      const configPath = join(dir, "supatype.config.ts")
+      writeFileSync(
+        configPath,
+        `export default {
+  project: { name: "x" },
+  database: { provider: "docker" },
+  server: { mode: "dev" },
+  app: {
+    mode: "proxy",
+    upstream: "http://localhost:3000",
+    headers: { "x-feature": "on" },
+  },
+  versions: { engine: "0", server: "0", postgres: "0", deno: "0" },
+}
+`,
+        "utf8",
+      )
+      updateAppConfigInProject(dir, { mode: "proxy", upstream: "http://localhost:8080" })
+      const next = readFileSync(configPath, "utf8")
+      expect(next).toContain(`upstream: "http://localhost:8080"`)
+      expect(next).toContain(`headers`)
+      expect(next).toContain(`"x-feature"`)
+    } 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 {
+      const out = writeSelfHostCompose(dir, { ...baseConfig, app: { mode: "none" } })
+      expect(out.composePath).toContain(".supatype")
+      expect(readFileSync(out.composePath, "utf8")).toContain("services:")
+      expect(readFileSync(out.kongPath, "utf8")).toContain("/rest/v1/")
+      const compose = readFileSync(out.composePath, "utf8")
+      expect(compose).toContain("${SUPATYPE_POSTGRES_IMAGE:-supatype/postgres:17-latest}")
+      expect(compose).toContain("${SUPATYPE_SERVER_IMAGE:-${SUPATYPE_AUTH_IMAGE:-supatype/server:latest}}")
+      expect(compose).toContain("${SUPATYPE_STORAGE_IMAGE:-supatype/storage:latest}")
+      expect(compose).toContain("${SUPATYPE_STUDIO_IMAGE:-supatype/studio:latest}")
+      expect(compose).toContain("SUPATYPE_POSTGREST_URL: http://postgrest:3000")
+      expect(compose).toContain("unified gateway")
+      const kong = readFileSync(out.kongPath, "utf8")
+      expect(kong).toContain("http://server:9999")
+      expect(kong).not.toContain("http://postgrest:3000")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("writes default manifest when missing for compose", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-manifest-"))
+    try {
+      writeSelfHostCompose(dir, { ...baseConfig, app: { mode: "none" } })
+      const manifest = readFileSync(join(dir, ".supatype", "manifest.json"), "utf8")
+      expect(manifest).toContain("postgrest_url")
+      expect(manifest).toContain("http://postgrest:3000")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+})

package/tests/seed-discover.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdirSync, writeFileSync, rmSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { discoverSeedsDir } from "../src/commands/seed.js"
+
+let tmp: string
+beforeEach(() => {
+  tmp = join(tmpdir(), `supatype-seed-${Date.now()}`)
+  mkdirSync(join(tmp, "seeds"), { recursive: true })
+})
+afterEach(() => {
+  rmSync(tmp, { recursive: true, force: true })
+})
+
+describe("discoverSeedsDir", () => {
+  it("returns sorted paths for seeds/*.ts", () => {
+    writeFileSync(join(tmp, "seeds", "z_first.ts"), "//")
+    writeFileSync(join(tmp, "seeds", "a_second.ts"), "//")
+    const paths = discoverSeedsDir(tmp, join(tmp, "seeds"))
+    expect(paths.map((p) => p.replace(/\\/g, "/"))).toEqual([
+      join(tmp, "seeds", "a_second.ts").replace(/\\/g, "/"),
+      join(tmp, "seeds", "z_first.ts").replace(/\\/g, "/"),
+    ])
+  })
+
+  it("returns empty when seeds dir missing", () => {
+    const empty = join(tmp, "no-seeds")
+    expect(discoverSeedsDir(tmp, empty)).toEqual([])
+  })
+})

package/tests/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "composite": false,
+    "rootDir": ".."
+  },
+  "include": ["./**/*.ts"]
+}