@supatype/cli 0.1.0-alpha.10 → 0.1.0-alpha.11

package/tests/cli-help.test.ts

@@ -33,6 +33,9 @@ describe("CLI binary (requires built dist/)", () => {
       "push",
       "diff",
       "pull",
+      "doctor",
+      "introspect",
+      "adopt",
       "generate",
       "migrate",
       "rollback",
@@ -79,10 +82,32 @@ describe("CLI binary (requires built dist/)", () => {
     expect(stdout).toContain("dry run")
   })
 
-  it("pull --help describes deprecated pull command", () => {
+  it("pull --help describes scaffold pull command", () => {
     const { stdout, exitCode } = runCli(["pull", "--help"])
     expect(exitCode).toBe(0)
-    expect(stdout).toContain("deprecated")
+    expect(stdout).toContain("Scaffold")
+    expect(stdout).toContain("--dry-run")
+  })
+
+  it("doctor --help describes drift report command", () => {
+    const { stdout, exitCode } = runCli(["doctor", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("drift")
+    expect(stdout).toContain("--strict")
+  })
+
+  it("introspect --help describes database introspection command", () => {
+    const { stdout, exitCode } = runCli(["introspect", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("Introspect")
+    expect(stdout).toContain("--json")
+  })
+
+  it("adopt --help describes adoption ceremony command", () => {
+    const { stdout, exitCode } = runCli(["adopt", "--help"])
+    expect(exitCode).toBe(0)
+    expect(stdout).toContain("adopt")
+    expect(stdout).toContain("--yes")
   })
 
   it("reset --help shows --yes flag", () => {

package/tests/init.test.ts

@@ -97,7 +97,7 @@ describe("scaffold()", () => {
     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")
   })
 

package/tests/link.test.ts

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest"
+import { mkdtempSync, writeFileSync, rmSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { resolveTarget, targetSchemaRollback } from "../src/resolve-target.js"
+import { loadProjectLink, migrateLegacyLinkFiles } from "../src/link.js"
+import { scaffold } from "../src/commands/init.js"
+
+function writePlainConfig(dir: string): void {
+  writeFileSync(
+    join(dir, "supatype.config.ts"),
+    `export default ${JSON.stringify({
+      project: { name: "demo" },
+      database: { provider: "docker" },
+      server: { mode: "dev" },
+      app: { mode: "none" },
+      schema: { path: "schema/index.ts", pg_schema: "public" },
+    })}
+`,
+  )
+}
+
+describe("link model", () => {
+  let tmp: string
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "supatype-link-"))
+  })
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true })
+  })
+
+  it("migrates cloud.json into link.json", () => {
+    scaffold(tmp, "demo")
+    mkdirSync(join(tmp, ".supatype"), { recursive: true })
+    writeFileSync(join(tmp, ".supatype", "cloud.json"), JSON.stringify({
+      apiUrl: "https://api.example.com",
+      token: "pat",
+      projectSlug: "myproj",
+      orgId: "org1",
+    }), { encoding: "utf8" })
+
+    migrateLegacyLinkFiles(tmp)
+    const link = loadProjectLink(tmp)
+    expect(link?.kind).toBe("cloud")
+    expect(link?.projectRef).toBe("myproj")
+    expect(link?.environments.production?.apiUrl).toBe("https://api.example.com")
+  })
+
+  it("resolveTarget returns cloud mode with /api/v1 prefix", () => {
+    writePlainConfig(tmp)
+    mkdirSync(join(tmp, ".supatype"), { recursive: true })
+    writeFileSync(join(tmp, ".supatype", "link.json"), JSON.stringify({
+      version: 1,
+      kind: "cloud",
+      projectRef: "myproj",
+      defaultEnvironment: "production",
+      token: "pat",
+      orgId: "org1",
+      cloudApiUrl: "https://api.example.com",
+      linkedAt: new Date().toISOString(),
+      environments: {
+        production: {
+          name: "production",
+          apiUrl: "https://myproj.supatype.dev",
+          linkedAt: new Date().toISOString(),
+        },
+      },
+    }))
+
+    const target = resolveTarget(tmp)
+    expect(target.mode).toBe("cloud")
+    expect(target.apiPrefix).toBe("/api/v1")
+    expect(target.apiBaseUrl).toBe("https://api.example.com")
+  })
+
+  it("resolveTarget returns self-host mode with /platform/v1 prefix", () => {
+    writePlainConfig(tmp)
+    mkdirSync(join(tmp, ".supatype"), { recursive: true })
+    writeFileSync(join(tmp, ".supatype", "link.json"), JSON.stringify({
+      version: 1,
+      kind: "self-host",
+      projectRef: "demo",
+      defaultEnvironment: "production",
+      linkedAt: new Date().toISOString(),
+      environments: {
+        production: {
+          name: "production",
+          apiUrl: "https://app.example.com",
+          token: "srk",
+          linkedAt: new Date().toISOString(),
+        },
+      },
+    }))
+
+    const target = resolveTarget(tmp)
+    expect(target.mode).toBe("self-host")
+    expect(target.apiPrefix).toBe("/platform/v1")
+    expect(target.token).toBe("srk")
+  })
+
+  it("targetSchemaRollback posts to /platform/v1 when linked", async () => {
+    writePlainConfig(tmp)
+    mkdirSync(join(tmp, ".supatype"), { recursive: true })
+    writeFileSync(join(tmp, ".supatype", "link.json"), JSON.stringify({
+      version: 1,
+      kind: "self-host",
+      projectRef: "demo",
+      defaultEnvironment: "production",
+      linkedAt: new Date().toISOString(),
+      environments: {
+        production: {
+          name: "production",
+          apiUrl: "https://app.example.com",
+          token: "srk",
+          linkedAt: new Date().toISOString(),
+        },
+      },
+    }))
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        data: {
+          status: "rolled_back",
+          name: "push_test",
+          message: "Rolled back migration push_test.",
+        },
+      }),
+    })
+    vi.stubGlobal("fetch", fetchMock)
+
+    const target = resolveTarget(tmp)
+    await targetSchemaRollback(target, { schema: "public" })
+
+    expect(fetchMock).toHaveBeenCalledOnce()
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit]
+    expect(url).toBe("https://app.example.com/platform/v1/projects/demo/schema/rollback")
+    expect(init.method).toBe("POST")
+    expect(init.headers).toMatchObject({
+      Authorization: "Bearer srk",
+      "Content-Type": "application/json",
+    })
+
+    vi.unstubAllGlobals()
+  })
+})

package/tests/proxy-dev-app.test.ts

@@ -1,5 +1,12 @@
+import { mkdirSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
 import { describe, expect, it } from "vitest"
-import { resolveProxyDevScript } from "../src/app/proxy-dev-app.js"
+import {
+  portFromUpstream,
+  resolveProxyDevScript,
+  resolveViteDirectSpawn,
+} from "../src/app/proxy-dev-app.js"
 import type { SupatypeProjectConfig } from "../src/project-config.js"
 
 const base = {
@@ -31,3 +38,40 @@ describe("resolveProxyDevScript()", () => {
     expect(resolveProxyDevScript(config)).toBe("dev:site")
   })
 })
+
+describe("portFromUpstream()", () => {
+  it("parses port from upstream URL", () => {
+    const config = {
+      ...base,
+      app: { mode: "proxy" as const, upstream: "http://localhost:5285" },
+    } satisfies SupatypeProjectConfig
+    expect(portFromUpstream(config)).toBe(5285)
+  })
+
+  it("returns null when upstream has no port", () => {
+    const config = {
+      ...base,
+      app: { mode: "proxy" as const, upstream: "http://localhost" },
+    } satisfies SupatypeProjectConfig
+    expect(portFromUpstream(config)).toBeNull()
+  })
+})
+
+describe("resolveViteDirectSpawn()", () => {
+  it("returns node + vite.js for a plain vite script", () => {
+    const appDir = join(tmpdir(), `supatype-vite-spawn-${Date.now()}`)
+    const viteJs = join(appDir, "node_modules", "vite", "bin", "vite.js")
+    mkdirSync(join(appDir, "node_modules", "vite", "bin"), { recursive: true })
+    writeFileSync(viteJs, "")
+    const result = resolveViteDirectSpawn(appDir, "dev:vite", { "dev:vite": "vite" })
+    expect(result).not.toBeNull()
+    expect(result?.bin).toBe(process.execPath)
+    expect(result?.args[0]).toBe(viteJs)
+    expect(result?.shell).toBe(false)
+  })
+
+  it("returns null for non-vite scripts", () => {
+    const result = resolveViteDirectSpawn(process.cwd(), "dev", { dev: "next dev" })
+    expect(result).toBeNull()
+  })
+})

package/tests/pull-utils.test.ts

@@ -106,12 +106,12 @@ describe("pgTypeToField()", () => {
 })
 
 describe("introspectColumnToColumnInfo()", () => {
-  it("maps engine type → pgType and flags", () => {
+  it("maps engine column → pgType and flags", () => {
     const out = introspectColumnToColumnInfo({
       name: "id",
-      type: "uuid",
+      dataType: "uuid",
+      udtName: "uuid",
       nullable: false,
-      primaryKey: true,
       default: "gen_random_uuid()",
     })
     expect(out).toEqual({
@@ -127,7 +127,8 @@ describe("introspectColumnToColumnInfo()", () => {
   it("treats empty default as no default", () => {
     const out = introspectColumnToColumnInfo({
       name: "x",
-      type: "text",
+      dataType: "text",
+      udtName: "text",
       nullable: true,
       default: "",
     })

package/tests/runtime-contract.test.ts

@@ -4,7 +4,7 @@ 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 { composeDockerImageEnv, renderSelfHostCompose, writeSelfHostCompose } from "../src/self-host-compose.js"
+import { composeDockerImageEnv, composePullNeedsIgnoreFailures, hasLocalVersionPins, isRegistryPullableImageRef, 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"
@@ -128,6 +128,49 @@ describe("runtime contract", () => {
     })
   })
 
+  it("isRegistryPullableImageRef accepts semver and latest tags", () => {
+    expect(isRegistryPullableImageRef("supatype/server:latest")).toBe(true)
+    expect(isRegistryPullableImageRef("supatype/schema-engine:v0.4.2")).toBe(true)
+    expect(isRegistryPullableImageRef("supatype/postgres:17-latest")).toBe(true)
+    expect(isRegistryPullableImageRef("supatype/control-plane:local")).toBe(false)
+    expect(isRegistryPullableImageRef("supatype/server:keepsake-local")).toBe(false)
+  })
+
+  it("composePullNeedsIgnoreFailures is false for semver pins only", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-pull-"))
+    try {
+      writeFileSync(
+        join(cwd, ".env"),
+        "SUPATYPE_ENGINE_IMAGE=supatype/schema-engine:v0.4.2\n",
+        "utf8",
+      )
+      expect(hasLocalVersionPins(baseConfig)).toBe(false)
+      expect(composePullNeedsIgnoreFailures(baseConfig, cwd)).toBe(false)
+    } finally {
+      rmSync(cwd, { recursive: true, force: true })
+    }
+  })
+
+  it("composePullNeedsIgnoreFailures is true for versions.local or custom tags", () => {
+    const cwd = mkdtempSync(join(tmpdir(), "supatype-pull-local-"))
+    try {
+      writeFileSync(
+        join(cwd, ".env"),
+        "SUPATYPE_CONTROL_PLANE_IMAGE=supatype/control-plane:local\n",
+        "utf8",
+      )
+      expect(
+        composePullNeedsIgnoreFailures(
+          { ...baseConfig, versions: { engine: "local" } },
+          cwd,
+        ),
+      ).toBe(true)
+      expect(composePullNeedsIgnoreFailures(baseConfig, cwd)).toBe(true)
+    } finally {
+      rmSync(cwd, { recursive: true, force: true })
+    }
+  })
+
   it("self-host compose mounts project root at /project (project-directory relative)", () => {
     const compose = renderSelfHostCompose(baseConfig)
     expect(compose).toContain("- .:/project")

package/tests/schema-sources.test.ts

@@ -0,0 +1,119 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdtempSync, writeFileSync, readFileSync, rmSync, mkdirSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { collectSchemaSourcePaths } from "../src/type-extractor.js"
+import {
+  packSchemaSources,
+  unpackSchemaSources,
+  buildSchemaSourcesPayload,
+  restoreSchemaSourcesFromGz,
+  findOrphanSchemaFiles,
+} from "../src/schema-sources.js"
+
+function writeMultiFileSchema(root: string): void {
+  mkdirSync(join(root, "schema", "models"), { recursive: true })
+  mkdirSync(join(root, "schema", "shared"), { recursive: true })
+  writeFileSync(
+    join(root, "schema", "index.ts"),
+    `export type { Album } from "./models/album"\nexport type { localeConfig } from "./shared/locale"\n`,
+  )
+  writeFileSync(
+    join(root, "schema", "models", "album.ts"),
+    `import type { Nullable } from "../shared/field-types"\nexport type Album = { id: string; title: Nullable<string> }\n`,
+  )
+  writeFileSync(
+    join(root, "schema", "shared", "field-types.ts"),
+    `export type Nullable<T> = T | null\n`,
+  )
+  writeFileSync(
+    join(root, "schema", "shared", "locale.ts"),
+    `export type localeConfig = { default: string }\n`,
+  )
+}
+
+describe("schema-sources", () => {
+  let tmp: string
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), "schema-sources-"))
+  })
+
+  afterEach(() => {
+    rmSync(tmp, { recursive: true, force: true })
+  })
+
+  it("discovers multi-file graph from entry point", () => {
+    writeMultiFileSchema(tmp)
+    const entry = join(tmp, "schema", "index.ts")
+    const graph = collectSchemaSourcePaths(entry, tmp)
+    const paths = graph.files.map((f) => f.relativePath).sort()
+    expect(paths).toEqual([
+      "schema/index.ts",
+      "schema/models/album.ts",
+      "schema/shared/field-types.ts",
+      "schema/shared/locale.ts",
+    ])
+    expect(graph.entryPoint).toBe("schema/index.ts")
+  })
+
+  it("roundtrips tar+gzip bytes", () => {
+    writeMultiFileSchema(tmp)
+    const graph = collectSchemaSourcePaths(join(tmp, "schema", "index.ts"), tmp)
+    const tar = packSchemaSources(graph)
+    const files = unpackSchemaSources(tar, tmp)
+    for (const file of graph.files) {
+      const original = readFileSync(file.absolutePath)
+      const restored = files.get(file.relativePath.replace(/\\/g, "/"))
+      expect(restored?.equals(original)).toBe(true)
+    }
+  })
+
+  it("buildSchemaSourcesPayload includes manifest metadata", () => {
+    writeMultiFileSchema(tmp)
+    writeFileSync(
+      join(tmp, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        project: { name: "demo" },
+        database: { provider: "docker" },
+        server: { mode: "dev" },
+        app: { mode: "none" },
+        schema: { path: "schema/index.ts", pg_schema: "public" },
+      })}\n`,
+    )
+    const payload = buildSchemaSourcesPayload(tmp, "test@example.com")
+    expect(payload).not.toBeNull()
+    expect(payload!.manifest.fileCount).toBe(4)
+    expect(payload!.manifest.pushedBy).toBe("test@example.com")
+    expect(payload!.manifest.compressedBytes).toBeGreaterThan(0)
+  })
+
+  it("restore overwrites modified local files", () => {
+    writeMultiFileSchema(tmp)
+    writeFileSync(
+      join(tmp, "supatype.config.ts"),
+      `export default ${JSON.stringify({
+        project: { name: "demo" },
+        database: { provider: "docker" },
+        server: { mode: "dev" },
+        app: { mode: "none" },
+        schema: { path: "schema/index.ts", pg_schema: "public" },
+      })}\n`,
+    )
+    const payload = buildSchemaSourcesPayload(tmp)!
+    const albumPath = join(tmp, "schema", "models", "album.ts")
+    writeFileSync(albumPath, "// modified\n")
+
+    restoreSchemaSourcesFromGz(payload.gz, payload.manifest, tmp)
+    expect(readFileSync(albumPath, "utf8")).toContain("Nullable")
+  })
+
+  it("warns about orphan files not in snapshot", () => {
+    writeMultiFileSchema(tmp)
+    writeFileSync(join(tmp, "schema", "models", "experimental.ts"), "export type X = {}\n")
+    const graph = collectSchemaSourcePaths(join(tmp, "schema", "index.ts"), tmp)
+    const manifestPaths = new Set(graph.files.map((f) => f.relativePath))
+    const orphans = findOrphanSchemaFiles(tmp, graph.entryPoint, manifestPaths)
+    expect(orphans).toContain("schema/models/experimental.ts")
+  })
+})

package/tests/storage-provision.test.ts

@@ -0,0 +1,100 @@
+import { afterEach, describe, expect, it, vi } from "vitest"
+import {
+  bucketSpecsFromAst,
+  provisionBuckets,
+  provisionBucketsFromAst,
+  type SchemaStorageBucketAst,
+} from "../src/storage-provision.js"
+
+describe("bucketSpecsFromAst", () => {
+  it("maps storage bucket AST fields to API bucket specs", () => {
+    const buckets: SchemaStorageBucketAst[] = [
+      {
+        id: "photos",
+        public: false,
+        accessMode: "private",
+        allowedMimeTypes: ["image/jpeg"],
+        fileSizeLimit: 5_000_000,
+      },
+      { id: "avatars", public: true },
+    ]
+
+    expect(bucketSpecsFromAst({ storageBuckets: buckets })).toEqual([
+      {
+        id: "photos",
+        public: false,
+        access_mode: "private",
+        allowed_mime_types: ["image/jpeg"],
+        file_size_limit: 5_000_000,
+      },
+      { id: "avatars", public: true },
+    ])
+  })
+
+  it("returns an empty list when no buckets are declared", () => {
+    expect(bucketSpecsFromAst({})).toEqual([])
+  })
+})
+
+describe("provisionBuckets", () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it("POSTs each bucket to the storage API", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ status: 200, ok: true })
+    vi.stubGlobal("fetch", fetchMock)
+
+    await provisionBuckets("http://localhost:54321/storage/v1/", "service-key", [
+      { id: "photos", public: false },
+      { id: "avatars", public: true },
+    ])
+
+    expect(fetchMock).toHaveBeenCalledTimes(2)
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      "http://localhost:54321/storage/v1/bucket",
+      expect.objectContaining({
+        method: "POST",
+        headers: {
+          Authorization: "Bearer service-key",
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ id: "photos", name: "photos", public: false }),
+      }),
+    )
+  })
+
+  it("treats 409 Conflict as success (bucket already exists)", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ status: 409, ok: false })
+    vi.stubGlobal("fetch", fetchMock)
+
+    await expect(
+      provisionBuckets("http://localhost:54321/storage/v1", "key", [{ id: "photos", public: false }]),
+    ).resolves.toBeUndefined()
+  })
+
+  it("warns and continues when the storage API is unreachable", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => undefined)
+    vi.stubGlobal("fetch", vi.fn().mockRejectedValue(new Error("ECONNREFUSED")))
+
+    await provisionBuckets("http://localhost:54321/storage/v1", "key", [{ id: "photos", public: false }])
+
+    expect(warn).toHaveBeenCalledWith('[storage] Storage API unreachable — skipped bucket "photos"')
+  })
+})
+
+describe("provisionBucketsFromAst", () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it("skips provisioning when the AST declares no buckets", async () => {
+    const fetchMock = vi.fn()
+    vi.stubGlobal("fetch", fetchMock)
+
+    await provisionBucketsFromAst({}, "http://localhost:54321/storage/v1", "key")
+
+    expect(fetchMock).not.toHaveBeenCalled()
+  })
+})