@supatype/cli 0.1.13 → 0.2.1

package/tests/port-in-use.test.ts

@@ -0,0 +1,58 @@
+import { createServer, type Server } from "node:net"
+import { afterEach, describe, expect, it } from "vitest"
+import { isPortInUse } from "../src/postgres-ctl.js"
+
+/**
+ * `supatype dev` asks this before handing a port to Docker Compose, so a wrong answer costs a
+ * failed `compose up`, not a warning:
+ *
+ *     Bind for 0.0.0.0:5432 failed: port is already allocated
+ *
+ * The Docker case cannot be reproduced here, because it needs Docker Desktop's port proxy, which
+ * publishes without holding a bind that a socket can see. It is why this function connects as well
+ * as binds; the loopback case below is what a unit test can hold onto.
+ */
+
+// Ports in the high range this repository does not otherwise use.
+const PORT = 19871
+
+let server: Server | null = null
+
+function listen(port: number, host: string): Promise<Server> {
+  return new Promise((resolve, reject) => {
+    const created = createServer()
+    created.once("error", reject)
+    created.listen(port, host, () => resolve(created))
+  })
+}
+
+afterEach(async () => {
+  if (server !== null) {
+    await new Promise<void>((resolve) => server!.close(() => resolve()))
+    server = null
+  }
+})
+
+describe("isPortInUse", () => {
+  it("reports a free port as free", async () => {
+    await expect(isPortInUse(PORT)).resolves.toBe(false)
+  })
+
+  it("reports a port with a loopback listener as in use", async () => {
+    server = await listen(PORT, "127.0.0.1")
+    await expect(isPortInUse(PORT)).resolves.toBe(true)
+  })
+
+  it("reports a port with a wildcard listener as in use", async () => {
+    server = await listen(PORT, "0.0.0.0")
+    await expect(isPortInUse(PORT)).resolves.toBe(true)
+  })
+
+  it("reports the port free again once the listener closes", async () => {
+    server = await listen(PORT, "127.0.0.1")
+    await expect(isPortInUse(PORT)).resolves.toBe(true)
+    await new Promise<void>((resolve) => server!.close(() => resolve()))
+    server = null
+    await expect(isPortInUse(PORT)).resolves.toBe(false)
+  })
+})

package/tests/readiness-poll.test.ts

@@ -0,0 +1,84 @@
+import { createServer, type Server } from "node:http"
+import { readFileSync } from "node:fs"
+import { fileURLToPath } from "node:url"
+import type { AddressInfo } from "node:net"
+import { afterEach, describe, expect, it } from "vitest"
+
+/**
+ * A readiness poll has to be able to give up, and has to poll an address that is bound.
+ *
+ * `supatype push` reported the schema applied and then appeared to hang, on a wait whose own error
+ * message advertised 120 seconds. Two things were wrong. The loop was bounded by iterations rather
+ * than by time, and each `fetch` carried no deadline of its own, so against a socket that accepts
+ * and never answers undici's ~30s default applied instead of the intended 1s: "120 attempts, one
+ * second apart" is really closer to an hour. And it polled `localhost`, which resolves to `::1`
+ * first, where Docker Desktop's IPv6 relay accepts and then goes silent when unhealthy. Docker
+ * publishes on `0.0.0.0`, so IPv4 is the address certainly bound.
+ */
+
+const servers: Server[] = []
+
+afterEach(async () => {
+  await Promise.all(
+    servers.splice(0).map((s) => new Promise<void>((resolve) => s.close(() => resolve()))),
+  )
+})
+
+/** A server that accepts connections and never responds, like the unhealthy relay. */
+async function blackHole(): Promise<number> {
+  const server = createServer(() => {
+    /* deliberately no response, and no socket close */
+  })
+  servers.push(server)
+  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve))
+  return (server.address() as AddressInfo).port
+}
+
+const devCompose = (): string =>
+  readFileSync(fileURLToPath(new URL("../src/dev-compose.ts", import.meta.url)), "utf8")
+
+describe("a readiness attempt against a port that accepts and never answers", () => {
+  it("ends promptly when it carries a deadline", async () => {
+    const port = await blackHole()
+    const started = Date.now()
+
+    await expect(
+      fetch(`http://127.0.0.1:${port}/`, { signal: AbortSignal.timeout(300) }),
+    ).rejects.toThrow()
+
+    // Generous, because the point is that it returns at all rather than how fast.
+    expect(Date.now() - started).toBeLessThan(3000)
+  })
+})
+
+describe("the polls the CLI actually runs", () => {
+  it("give every attempt a deadline", () => {
+    const source = devCompose()
+    // `fetchWithin` is the only way to reach the gateway from a poll loop. A bare `fetch` inside
+    // one is the bug: the loop's iteration count stops being its real bound.
+    const helper = source.match(/async function fetchWithin\(/g) ?? []
+    expect(helper.length, "the timeout helper should exist").toBe(1)
+
+    const kongPoll = source.slice(
+      source.indexOf("async function waitKongReady("),
+      source.indexOf("async function provisionDockerStorageBuckets("),
+    )
+    // Strip the wrapper's own name before looking for a bare call, or `fetchWithin(` matches
+    // `fetch(` and the check passes on exactly the code it exists to reject.
+    const bare = kongPoll.replaceAll("fetchWithin(", "<<ok>>")
+    expect(bare, "a poll loop must not call fetch without a deadline").not.toMatch(/\bfetch\(/)
+    expect(kongPoll).toMatch(/fetchWithin\(/)
+  })
+
+  it("target IPv4, not a name that may resolve to an unbound address", () => {
+    const source = devCompose()
+    const kongPoll = source.slice(
+      source.indexOf("async function waitKongReady("),
+      source.indexOf("async function provisionDockerStorageBuckets("),
+    )
+    // The URLs written to `.env` and printed for the operator stay on `localhost`, deliberately:
+    // those are for a browser. This is about what the CLI dials itself.
+    expect(kongPoll).not.toContain("http://localhost:")
+    expect(kongPoll).toMatch(/loopbackBase\(/)
+  })
+})

package/tests/runtime-contract.test.ts

@@ -163,7 +163,7 @@ describe("runtime contract", () => {
   })
 
   // The whole point of requiring them: a service must never fall back to a secret published in
-  // this repository. That default used to reach PostgREST, storage and GoTrue.
+  // this repository. That default used to reach PostgREST, storage and auth.
   it("never defaults a secret to a published constant", () => {
     const compose = renderSelfHostCompose(baseConfig)
     expect(compose).not.toContain("super-secret-jwt-token")

package/tests/self-host-keys.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest"
+import { mkdtempSync, rmSync, readFileSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { fillMissingKeys } from "../src/commands/keys.js"
+
+/**
+ * A self-host `.env` copied from the template arrives with ANON_KEY and
+ * SERVICE_ROLE_KEY blank, and the server refuses to serve without a service
+ * role key outside dev mode. The documented quick start could not start.
+ *
+ * Filling them has to be conservative: an operator's existing key must never be
+ * reissued, because every client holding the old one would stop working.
+ */
+const SECRET = "a-local-development-secret-at-least-32-chars"
+
+let dir: string
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "selfhost-keys-"))
+})
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+const envPath = () => join(dir, ".env")
+const read = () => readFileSync(envPath(), "utf8")
+const valueOf = (name: string): string => {
+  const line = read().split(/\r?\n/).find((l) => l.startsWith(`${name}=`))
+  return line === undefined ? "" : line.slice(name.length + 1)
+}
+
+describe("filling the self-host keys", () => {
+  it("mints both when the template leaves them blank", () => {
+    writeFileSync(envPath(), `JWT_SECRET=${SECRET}\nANON_KEY=\nSERVICE_ROLE_KEY=\n`)
+
+    const filled = fillMissingKeys(dir)
+
+    expect(filled.sort()).toEqual(["ANON_KEY", "SERVICE_ROLE_KEY"])
+    expect(valueOf("ANON_KEY").length).toBeGreaterThan(20)
+    expect(valueOf("SERVICE_ROLE_KEY").length).toBeGreaterThan(20)
+  })
+
+  it("signs them with the secret in the file, so they verify against it", () => {
+    writeFileSync(envPath(), `JWT_SECRET=${SECRET}\nANON_KEY=\nSERVICE_ROLE_KEY=\n`)
+    fillMissingKeys(dir)
+
+    const claims = (jwt: string): Record<string, unknown> =>
+      JSON.parse(Buffer.from(jwt.split(".")[1] as string, "base64url").toString("utf8"))
+
+    expect(claims(valueOf("ANON_KEY")).role).toBe("anon")
+    expect(claims(valueOf("SERVICE_ROLE_KEY")).role).toBe("service_role")
+  })
+
+  it("leaves a key the operator already set alone", () => {
+    writeFileSync(
+      envPath(),
+      `JWT_SECRET=${SECRET}\nANON_KEY=an-existing-key-in-use\nSERVICE_ROLE_KEY=\n`,
+    )
+
+    const filled = fillMissingKeys(dir)
+
+    expect(filled).toEqual(["SERVICE_ROLE_KEY"])
+    expect(valueOf("ANON_KEY")).toBe("an-existing-key-in-use")
+    expect(valueOf("SERVICE_ROLE_KEY").length).toBeGreaterThan(20)
+  })
+
+  it("does nothing when both are already set", () => {
+    const before = `JWT_SECRET=${SECRET}\nANON_KEY=key-one\nSERVICE_ROLE_KEY=key-two\n`
+    writeFileSync(envPath(), before)
+
+    expect(fillMissingKeys(dir)).toEqual([])
+    expect(read()).toBe(before)
+  })
+
+  it("treats whitespace as blank, since a stray space is not a key", () => {
+    writeFileSync(envPath(), `JWT_SECRET=${SECRET}\nANON_KEY=   \nSERVICE_ROLE_KEY=key-two\n`)
+
+    expect(fillMissingKeys(dir)).toEqual(["ANON_KEY"])
+    expect(valueOf("ANON_KEY").length).toBeGreaterThan(20)
+  })
+
+  it("does nothing without a secret, rather than minting keys nothing can verify", () => {
+    writeFileSync(envPath(), "ANON_KEY=\nSERVICE_ROLE_KEY=\n")
+
+    expect(fillMissingKeys(dir)).toEqual([])
+    expect(valueOf("ANON_KEY")).toBe("")
+  })
+
+  it("does nothing when there is no .env to write to", () => {
+    expect(fillMissingKeys(dir)).toEqual([])
+  })
+})