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

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/normalize-admin-config.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "vitest"
+import { normalizeAdminConfig } from "../../studio/src/lib/normalize-admin-config.js"
+
+describe("normalizeAdminConfig", () => {
+  it("maps global fields and Settings navigation items", () => {
+    const config = normalizeAdminConfig({
+      localization: { locales: ["en"], defaultLocale: "en" },
+      navigation: [
+        {
+          group: "Content",
+          items: [{ label: "Post", model: "posts" }],
+        },
+        {
+          group: "Settings",
+          items: [{ label: "Site Settings", global: "_global_site_settings" }],
+        },
+      ],
+      models: [
+        {
+          name: "Post",
+          tableName: "posts",
+          fields: [{ name: "title", widget: "text", required: true }],
+        },
+      ],
+      globals: [
+        {
+          name: "SiteSettings",
+          tableName: "_global_site_settings",
+          singleton: true,
+          fields: [{ name: "site_name", widget: "text", required: true }],
+        },
+      ],
+    })
+
+    expect(config.globals).toHaveLength(1)
+    expect(config.globals[0]?.tableName).toBe("_global_site_settings")
+    expect(config.globals[0]?.apiPath).toBe("/rest/v1/_global_site_settings")
+    expect(config.globals[0]?.fields).toHaveLength(1)
+    expect(config.globals[0]?.fields[0]?.name).toBe("site_name")
+
+    const settingsNav = config.navigation.find((g) => g.label === "Settings")
+    expect(settingsNav?.items[0]).toMatchObject({
+      type: "global",
+      href: "/models/globals/SiteSettings",
+      label: "Site Settings",
+    })
+  })
+})

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/proxy-dev-app.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest"
+import { resolveProxyDevScript } from "../src/app/proxy-dev-app.js"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+
+const base = {
+  project: { name: "test" },
+  database: { provider: "native" as const },
+  server: { mode: "dev" as const },
+  versions: { engine: "latest", server: "latest", postgres: "latest", deno: "latest" },
+}
+
+describe("resolveProxyDevScript()", () => {
+  it("returns null when app.mode is not proxy", () => {
+    const config = { ...base, app: { mode: "static" as const } } satisfies SupatypeProjectConfig
+    expect(resolveProxyDevScript(config)).toBeNull()
+  })
+
+  it("defaults to start when proxy mode and app.start omitted", () => {
+    const config = {
+      ...base,
+      app: { mode: "proxy" as const, upstream: "http://127.0.0.1:4321" },
+    } satisfies SupatypeProjectConfig
+    expect(resolveProxyDevScript(config)).toBe("start")
+  })
+
+  it("uses app.start when set", () => {
+    const config = {
+      ...base,
+      app: { mode: "proxy" as const, upstream: "http://127.0.0.1:4321", start: "dev:site" },
+    } satisfies SupatypeProjectConfig
+    expect(resolveProxyDevScript(config)).toBe("dev:site")
+  })
+})

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)
+    }
+  })
+})