@supatype/cli 0.1.12 → 0.2.0

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/type-extractor.test.ts

@@ -1322,4 +1322,53 @@ export type Media = Bucket<"media", {
       /Bucket "media": could not resolve its `access` rules/,
     )
   })
+
+  it("emits structured validation bounds alongside the compiled check constraint", () => {
+    const dir = mkdtempSync(join(tmpdir(), "supatype-validation-"))
+    dirs.push(dir)
+    const schemaPath = join(dir, "schema.ts")
+    writeFileSync(
+      schemaPath,
+      `
+import type {
+  Model, Public, UUID, Int, Optional, MaxLength, MinLength, Between,
+} from "@supatype/types"
+
+export type Review = Model<{
+  id: UUID
+  headline: MaxLength<string, 120>
+  body: MinLength<MaxLength<string, 4000>, 20>
+  rating: Between<Int, 1, 5>
+  note: Optional<string>
+}, {
+  access: { read: Public }
+}>
+`,
+      "utf8",
+    )
+
+    const ast = extractSchemaAstFromTypes(schemaPath, dir)
+    const review = ast?.models.find((m) => m.name === "Review")
+    expect(review).toBeDefined()
+
+    expect(review?.fields["headline"]).toMatchObject({
+      check: 'char_length("{name}") <= 120',
+      validation: { maxLength: 120 },
+    })
+
+    // Stacked modifiers merge into one check and one validation object.
+    expect(review?.fields["body"]).toMatchObject({
+      validation: { maxLength: 4000, minLength: 20 },
+    })
+    expect(review?.fields["body"]?.["check"]).toContain('char_length("{name}") <= 4000')
+    expect(review?.fields["body"]?.["check"]).toContain('char_length("{name}") >= 20')
+
+    expect(review?.fields["rating"]).toMatchObject({
+      kind: "integer",
+      validation: { min: 1, max: 5 },
+    })
+
+    // A field with no constraint modifier carries no validation key at all.
+    expect(review?.fields["note"]?.["validation"]).toBeUndefined()
+  })
 })