@supatype/cli 0.1.0-alpha.10

package/tests/keys.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Tests for `supatype keys` — JWT generation command.
+ * Uses subprocess tests (requires built dist/) for the CLI integration,
+ * plus direct module tests for the signing logic.
+ */
+import { describe, it, expect } from "vitest"
+import { spawnSync } from "node:child_process"
+import { resolve, dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const CLI_BIN = resolve(__dirname, "../bin/supatype.js")
+
+function runCli(
+  args: string[],
+  opts: { cwd?: string; env?: NodeJS.ProcessEnv } = {},
+): { stdout: string; stderr: string; exitCode: number } {
+  const result = spawnSync(process.execPath, [CLI_BIN, ...args], {
+    encoding: "utf8",
+    timeout: 10_000,
+    cwd: opts.cwd,
+    env: { ...process.env, ...opts.env },
+  })
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: result.status ?? 1,
+  }
+}
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function decodeJwtPart(part: string): Record<string, unknown> {
+  return JSON.parse(Buffer.from(part, "base64url").toString("utf8")) as Record<string, unknown>
+}
+
+function parseJwt(token: string): { header: Record<string, unknown>; payload: Record<string, unknown> } {
+  const parts = token.split(".")
+  expect(parts).toHaveLength(3)
+  return {
+    header: decodeJwtPart(parts[0]!),
+    payload: decodeJwtPart(parts[1]!),
+  }
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe("supatype keys (CLI subprocess)", () => {
+  const SECRET = "my-test-jwt-secret-that-is-32-chars!"
+
+  it("exits 0 with --secret", () => {
+    const { exitCode } = runCli(["keys", "--secret", SECRET])
+    expect(exitCode).toBe(0)
+  })
+
+  it("outputs ANON_KEY= line", () => {
+    const { stdout } = runCli(["keys", "--secret", SECRET])
+    expect(stdout).toContain("ANON_KEY=")
+  })
+
+  it("outputs SERVICE_ROLE_KEY= line", () => {
+    const { stdout } = runCli(["keys", "--secret", SECRET])
+    expect(stdout).toContain("SERVICE_ROLE_KEY=")
+  })
+
+  it("ANON_KEY is a valid three-part JWT", () => {
+    const { stdout } = runCli(["keys", "--secret", SECRET])
+    const line = stdout.split("\n").find((l) => l.startsWith("ANON_KEY="))!
+    const token = line.replace("ANON_KEY=", "").trim()
+    const { header, payload } = parseJwt(token)
+    expect(header["alg"]).toBe("HS256")
+    expect(header["typ"]).toBe("JWT")
+    expect(payload["role"]).toBe("anon")
+    expect(payload["iss"]).toBe("supatype")
+  })
+
+  it("SERVICE_ROLE_KEY payload has role: service_role", () => {
+    const { stdout } = runCli(["keys", "--secret", SECRET])
+    const line = stdout.split("\n").find((l) => l.startsWith("SERVICE_ROLE_KEY="))!
+    const token = line.replace("SERVICE_ROLE_KEY=", "").trim()
+    const { payload } = parseJwt(token)
+    expect(payload["role"]).toBe("service_role")
+    expect(payload["iss"]).toBe("supatype")
+  })
+
+  it("JWT has exp in the future", () => {
+    const { stdout } = runCli(["keys", "--secret", SECRET])
+    const line = stdout.split("\n").find((l) => l.startsWith("ANON_KEY="))!
+    const token = line.replace("ANON_KEY=", "").trim()
+    const { payload } = parseJwt(token)
+    const exp = payload["exp"] as number
+    expect(exp).toBeGreaterThan(Math.floor(Date.now() / 1000))
+  })
+
+  it("--exp-years changes the expiry window", () => {
+    const short = runCli(["keys", "--secret", SECRET, "--exp-years", "1"])
+    const long = runCli(["keys", "--secret", SECRET, "--exp-years", "50"])
+
+    const getExp = (stdout: string): number => {
+      const line = stdout.split("\n").find((l) => l.startsWith("ANON_KEY="))!
+      const token = line.replace("ANON_KEY=", "").trim()
+      return (parseJwt(token).payload["exp"]) as number
+    }
+
+    expect(getExp(long.stdout)).toBeGreaterThan(getExp(short.stdout))
+  })
+
+  it("reads JWT_SECRET from environment variable", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "st-keys-env-"))
+    try {
+      const { exitCode, stdout } = runCli(["keys"], {
+        cwd: tmpDir,
+        env: { JWT_SECRET: SECRET },
+      })
+      expect(exitCode).toBe(0)
+      expect(stdout).toContain("ANON_KEY=")
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it("reads JWT_SECRET from .env file", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "st-keys-env-"))
+    try {
+      writeFileSync(join(tmpDir, ".env"), `JWT_SECRET=${SECRET}\n`, "utf8")
+      const { exitCode, stdout } = runCli(["keys"], {
+        cwd: tmpDir,
+        env: { JWT_SECRET: undefined as unknown as string },
+      })
+      expect(exitCode).toBe(0)
+      expect(stdout).toContain("ANON_KEY=")
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it("exits non-zero when no secret is available", () => {
+    const tmpDir = mkdtempSync(join(tmpdir(), "st-keys-nosecret-"))
+    try {
+      const { exitCode, stderr } = runCli(["keys"], {
+        cwd: tmpDir,
+        env: { JWT_SECRET: undefined as unknown as string },
+      })
+      expect(exitCode).not.toBe(0)
+      expect(stderr).toContain("JWT_SECRET")
+    } finally {
+      rmSync(tmpDir, { recursive: true, force: true })
+    }
+  })
+
+  it("keys --help shows --secret and --exp-years options", () => {
+    const { stdout, exitCode } = runCli(["keys", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("--secret")
+    expect(stdout).toContain("--exp-years")
+  })
+})

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

@@ -0,0 +1,150 @@
+import { describe, it, expect } from "vitest"
+import {
+  introspectColumnToColumnInfo,
+  pgTypeToField,
+  toCamelCase,
+  type ColumnInfo,
+} from "../src/pull-utils.js"
+
+function col(overrides: Partial<ColumnInfo> & { pgType: string }): ColumnInfo {
+  return {
+    name: "col",
+    nullable: true,
+    isPrimary: false,
+    isUnique: false,
+    hasDefault: false,
+    ...overrides,
+  }
+}
+
+describe("pgTypeToField()", () => {
+  it.each([
+    ["uuid", "field.uuid("],
+    ["text", "field.text("],
+    ["varchar(255)", "field.text("],
+    ["character varying", "field.text("],
+    ["int4", "field.integer("],
+    ["integer", "field.integer("],
+    ["int8", "field.bigInt("],
+    ["bigint", "field.bigInt("],
+    ["int2", "field.smallInt("],
+    ["smallint", "field.smallInt("],
+    ["float8", "field.float("],
+    ["double precision", "field.float("],
+    ["real", "field.float("],
+    ["numeric", "field.decimal("],
+    ["decimal", "field.decimal("],
+    ["bool", "field.boolean("],
+    ["boolean", "field.boolean("],
+    ["date", "field.date("],
+    ["timestamp", "field.timestamp("],
+    ["timestamptz", "field.datetime("],
+    ["timestamp with time zone", "field.datetime("],
+    ["json", "field.json("],
+    ["jsonb", "field.json("],
+    ["inet", "field.ip("],
+    ["cidr", "field.cidr("],
+    ["macaddr", "field.macaddr("],
+    ["bytea", "field.bytea("],
+    ["money", "field.money("],
+    ["xml", "field.xml("],
+    ["interval", "field.interval("],
+    ["tsvector", "field.tsvector("],
+    ["tsquery", "field.tsquery("],
+  ])("maps %s → %s call", (pgType, expectedPrefix) => {
+    const result = pgTypeToField(col({ pgType }))
+    expect(result).toContain(expectedPrefix)
+  })
+
+  it("unknown types fall back to field.text with a TODO comment", () => {
+    const result = pgTypeToField(col({ pgType: "some_custom_type" }))
+    expect(result).toContain("field.text(")
+    expect(result).toContain("TODO")
+    expect(result).toContain("some_custom_type")
+  })
+
+  it("nullable column sets required: false", () => {
+    const result = pgTypeToField(col({ pgType: "text", nullable: true }))
+    expect(result).toContain('"required":false')
+  })
+
+  it("non-nullable column sets required: true", () => {
+    const result = pgTypeToField(col({ pgType: "text", nullable: false }))
+    expect(result).toContain('"required":true')
+  })
+
+  it("primary key column sets primaryKey: true", () => {
+    const result = pgTypeToField(
+      col({ pgType: "uuid", isPrimary: true, nullable: false }),
+    )
+    expect(result).toContain('"primaryKey":true')
+  })
+
+  it("unique (non-PK) column sets unique: true", () => {
+    const result = pgTypeToField(
+      col({ pgType: "text", isUnique: true, isPrimary: false }),
+    )
+    expect(result).toContain('"unique":true')
+  })
+
+  it("primary key column does not also set unique (redundant)", () => {
+    const result = pgTypeToField(
+      col({ pgType: "uuid", isPrimary: true, isUnique: true }),
+    )
+    expect(result).not.toContain('"unique"')
+  })
+
+  it("jsonb column includes jsonb: true spread", () => {
+    const result = pgTypeToField(col({ pgType: "jsonb" }))
+    expect(result).toContain("jsonb: true")
+  })
+
+  it("plain json column does not include jsonb spread", () => {
+    const result = pgTypeToField(col({ pgType: "json" }))
+    expect(result).not.toContain("jsonb")
+  })
+})
+
+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"],
+    ["blog_post", "BlogPost"],
+    ["order_line_item", "OrderLineItem"],
+    ["saas_tenant", "SaasTenant"],
+    ["alreadyCamel", "AlreadyCamel"],
+    ["a", "A"],
+    ["api_key", "ApiKey"],
+  ])("converts %s → %s", (input, expected) => {
+    expect(toCamelCase(input)).toBe(expected)
+  })
+})

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