@supatype/cli 0.3.0 → 0.3.2

package/tests/runtime-contract.test.ts

@@ -9,6 +9,22 @@ import { updateAppConfigInProject, updateServerConfigInProject } from "../src/ap
 import type { SupatypeProjectConfig } from "../src/project-config.js"
 import { DENO_RELEASE_PIN } from "../src/release-pins.js"
 
+/**
+ * One service's block from a rendered compose file.
+ *
+ * Compose is asserted as text here rather than parsed, because the CLI ships no YAML parser and a
+ * test is not worth a dependency. Slicing to a single service is what keeps that honest: service
+ * names and `condition: service_healthy` both recur, so a whole-document substring match would
+ * pass on another service's dependency.
+ */
+function serviceBlock(compose: string, name: string): string {
+  const lines = compose.split("\n")
+  const start = lines.indexOf(`  ${name}:`)
+  if (start === -1) return ""
+  const after = lines.slice(start + 1).findIndex((l) => /^ {2}[a-z][a-z0-9-]*:$/.test(l))
+  return lines.slice(start, after === -1 ? lines.length : start + 1 + after).join("\n")
+}
+
 const baseConfig: SupatypeProjectConfig = {
   project: { name: "acme" },
   database: { provider: "docker" },
@@ -375,9 +391,52 @@ describe("runtime contract", () => {
     }
   })
 
-  it("devLocal compose enables STUDIO_OPEN_DEV on supatype-server", () => {
+  it("maps host.docker.internal, so a host proxy works on Linux too", () => {
+    // Docker Desktop resolves this name; Linux does not unless it is mapped. A project proxying
+    // the site or Studio to something on the host therefore worked on macOS and Windows and
+    // failed on Linux, with the gateway reaching nothing and no error naming the cause.
     const compose = renderSelfHostCompose(baseConfig, process.cwd(), { devLocal: true })
-    expect(compose).toContain('STUDIO_OPEN_DEV: "1"')
+    for (const service of ["server", "kong"]) {
+      expect(serviceBlock(compose, service), service).toContain(
+        '- "host.docker.internal:host-gateway"',
+      )
+    }
+  })
+
+  it("publishes the database when a port is asked for", () => {
+    // In dev the port is published only when something on the host needs it, which is normally a
+    // host engine build. Naming a port is the same request: without this the number was honoured
+    // and the port never existed, so anything connecting over TCP got ECONNREFUSED.
+    const dir = mkdtempSync(join(tmpdir(), "supatype-dbport-"))
+    try {
+      writeFileSync(join(dir, ".env"), "SUPATYPE_DEV_DB_PORT=54329\n")
+      const compose = renderSelfHostCompose(baseConfig, dir, { devLocal: true })
+      // The number stays a compose variable so Docker resolves it; what changes is that the
+      // ports block exists at all.
+      expect(serviceBlock(compose, "db")).toContain("ports:")
+      expect(serviceBlock(compose, "db")).toContain("SUPATYPE_DEV_DB_PORT")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("leaves the database unpublished when nothing asked for it", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-dbport-"))
+    try {
+      writeFileSync(join(dir, ".env"), "ANON_KEY=x\n")
+      expect(serviceBlock(renderSelfHostCompose(baseConfig, dir, { devLocal: true }), "db"))
+        .not.toContain("5432:5432")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("devLocal compose enables STUDIO_OPEN_DEV on supatype-server, and lets it be turned off", () => {
+    const compose = renderSelfHostCompose(baseConfig, process.cwd(), { devLocal: true })
+    // Defaulted rather than hardcoded. `supatype dev` still opens Studio without a sign-in, and
+    // the browser suite can set STUDIO_OPEN_DEV=0 to drive the gate a deployment actually has.
+    // Held as a literal "1" there was no way to test Studio with its authorization on at all.
+    expect(compose).toContain('STUDIO_OPEN_DEV: "${STUDIO_OPEN_DEV:-1}"')
   })
 
   it("production self-host compose does not enable STUDIO_OPEN_DEV", () => {
@@ -597,6 +656,60 @@ export default defineConfig({
     }
   })
 
+  it("offers functions a database URL, off unless the operator sets one", () => {
+    // `ctx.dbUrl` is read from SUPATYPE_DB_URL by the worker, and the generated compose never set
+    // it, so the field was permanently undefined on self-host: a function reaching for it got no
+    // value and nothing to explain why.
+    const dir = mkdtempSync(join(tmpdir(), "supatype-compose-"))
+    try {
+      const compose = readFileSync(
+        writeSelfHostCompose(dir, { ...baseConfig, app: { mode: "none" } }).composePath,
+        "utf8",
+      )
+      const worker = serviceBlock(compose, "functions-worker")
+
+      // Passed through, so the capability is reachable at all.
+      expect(worker).toContain("SUPATYPE_DB_URL:")
+      // Empty by default. The worker treats an empty value as absent, so `ctx.dbUrl` stays
+      // undefined until somebody opts in.
+      expect(worker).toContain("SUPATYPE_DB_URL: ${SUPATYPE_FUNCTIONS_DB_URL:-}")
+      // And its own variable, not the project's owner DSN. Interpolating DATABASE_URL here would
+      // give every function a connection that bypasses access rules, masking and hooks.
+      expect(worker).not.toContain("SUPATYPE_DB_URL: ${DATABASE_URL")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it("starts storage only once the object store is answering", () => {
+    // seaweedfs had no healthcheck and nothing depended on it, so compose started it alongside
+    // storage. Storage then accepted a bucket creation before seaweedfs was listening, every
+    // bucket in the schema failed with `connect ECONNREFUSED <ip>:8333`, and the metadata row was
+    // written anyway so a later push looked fine. Measured on a live stack: seaweedfs started
+    // twelve minutes after storage with RestartCount 0.
+    //
+    // It lands on the first push after a stack comes up, which is the first push anyone runs.
+    const dir = mkdtempSync(join(tmpdir(), "supatype-compose-"))
+    try {
+      const out = writeSelfHostCompose(dir, { ...baseConfig, app: { mode: "none" } })
+      const compose = readFileSync(out.composePath, "utf8")
+
+      // Sliced to one service, because `seaweedfs` and `service_healthy` both appear elsewhere in
+      // this file and a whole-document substring match would pass on either.
+      const storage = serviceBlock(compose, "storage")
+      expect(storage).toContain("depends_on:")
+      expect(storage).toMatch(/seaweedfs:\s*\n\s*condition: service_healthy/)
+      // Still waits for the database. The fix must not swap one dependency for another.
+      expect(storage).toMatch(/db:\s*\n\s*condition: service_healthy/)
+
+      // `service_healthy` is only meaningful if the service defines health. Without it compose
+      // refuses to start the stack at all, which is a worse failure than the race.
+      expect(serviceBlock(compose, "seaweedfs")).toContain("healthcheck:")
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
   it("renders SeaweedFS with its identities and its own volume", () => {
     const dir = mkdtempSync(join(tmpdir(), "supatype-seaweed-"))
     try {

package/tests/strict.test.ts

@@ -0,0 +1,78 @@
+/**
+ * Strict mode, which decides whether a degraded path is survivable.
+ *
+ * The behaviour under test is the *difference* between the two modes, so each case asserts both
+ * halves. A test that only checked the throw would pass against an implementation that threw
+ * always, which would break every interactive fallback the CLI has on purpose.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
+import { degraded, strict } from "../src/strict.js"
+
+const KEY = "SUPATYPE_STRICT"
+let original: string | undefined
+
+beforeEach(() => {
+  original = process.env[KEY]
+  delete process.env[KEY]
+})
+
+afterEach(() => {
+  if (original === undefined) delete process.env[KEY]
+  else process.env[KEY] = original
+  vi.restoreAllMocks()
+})
+
+describe("strict()", () => {
+  it("is off when the variable is unset", () => {
+    expect(strict()).toBe(false)
+  })
+
+  it("is on only for exactly \"1\"", () => {
+    process.env[KEY] = "1"
+    expect(strict()).toBe(true)
+  })
+
+  it("is off for other truthy-looking values", () => {
+    // Deliberately narrow. A flag that accepts "true", "yes" and "on" is a flag whose meaning has
+    // to be looked up, and this one turns warnings into build failures.
+    for (const value of ["true", "yes", "on", "0", ""]) {
+      process.env[KEY] = value
+      expect(strict(), `value ${JSON.stringify(value)}`).toBe(false)
+    }
+  })
+})
+
+describe("degraded()", () => {
+  it("warns and returns when strict is off, so an interactive run continues", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+    expect(() => degraded("Host engine unavailable", "CDN refused")).not.toThrow()
+    expect(warn).toHaveBeenCalledTimes(1)
+    expect(warn.mock.calls[0]?.[0]).toContain("Host engine unavailable")
+  })
+
+  it("throws when strict is on, so CI cannot pass over it", () => {
+    process.env[KEY] = "1"
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {})
+    expect(() => degraded("Host engine unavailable", "CDN refused")).toThrow(
+      /Host engine unavailable/,
+    )
+    // Not warned as well: a run that fails should not also print the line that says it recovered.
+    expect(warn).not.toHaveBeenCalled()
+  })
+
+  it("names the capability and the cause, because the assertion that fails names neither", () => {
+    process.env[KEY] = "1"
+    // The failure this exists to prevent read "expected validator refusal, got 200". The cause was
+    // an engine download refused twenty lines earlier, and nothing in the failure said so.
+    expect(() => degraded("Host engine unavailable", "no minisign public key configured")).toThrow(
+      /no minisign public key configured/,
+    )
+  })
+
+  it("says which flag made it fatal", () => {
+    process.env[KEY] = "1"
+    // Otherwise the reader's first move is to work out why a warning became an error.
+    expect(() => degraded("Bucket unreachable", "ECONNREFUSED")).toThrow(/SUPATYPE_STRICT=1/)
+  })
+})

package/tests/type-extractor.test.ts

@@ -1485,3 +1485,37 @@ export type Event = Model<{
     expect(event?.annotations.platform.searchFields).toBeUndefined()
   })
 })
+
+describe("the pg type an asset column claims", () => {
+  it("says JSONB, like the engine and the live column", () => {
+    // The extractor annotated image and file as TEXT, while this package's own DEFAULT_DB_BY_KIND,
+    // the engine's default, and the actual column in every pushed project all say JSONB. The
+    // engine honours an explicit annotation, so this was one code path away from creating a text
+    // column and then writing a JSON object into it.
+    const dir = mkdtempSync(join(tmpdir(), "supatype-asset-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type { Model, UUID, ImageAsset, FileAsset, Optional, Public } from "@supatype/types"
+
+export type Speaker = Model<{
+  id: UUID
+  headshot: Optional<ImageAsset>
+  handout: Optional<FileAsset>
+}, {
+  access: { read: Public }
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const speaker = ast?.models.find((m) => m.name === "Speaker")
+    const fields = speaker?.fields as Record<string, { annotations?: { db?: { pgType?: string } } }>
+
+    expect(fields["headshot"]?.annotations?.db?.pgType).toBe("JSONB")
+    expect(fields["handout"]?.annotations?.db?.pgType).toBe("JSONB")
+  })
+})