@supatype/cli 0.3.0 → 0.3.2

package/tests/client-generator.test.ts

@@ -0,0 +1,103 @@
+/**
+ * The client a project imports, generated into its own source tree.
+ *
+ * An app writes one import and nothing else:
+ *
+ *     import { createClient } from "./supatype/client"
+ *
+ * That single file carries three things that previously arrived by three different routes, two of
+ * which could silently fail:
+ *
+ *   the module augmentation  was a `.d.ts` found only through tsconfig `include`, so a stale or
+ *                            missing entry left every table name accepted and every column
+ *                            `unknown`, with the build passing
+ *   the field kinds          were read off disk and, failing that, reconstructed from PostgREST's
+ *                            OpenAPI document, which always succeeds and so could never report a
+ *                            project that had not generated
+ *   `createClient`           came from the package, which knows nothing about the project
+ *
+ * Arriving by import means the bundler carries them, tsconfig cannot lose them, nothing is
+ * fetched, and a project that has not generated has no file to import, so the build fails.
+ */
+import { describe, expect, it } from "vitest"
+import { generateProjectClient } from "../src/client-generator.js"
+
+const ast = {
+  models: [
+    {
+      name: "JobPost",
+      annotations: { db: { tableName: "job_post" } },
+      fields: {
+        id: { kind: "uuid", required: true },
+        title: { kind: "text", required: true },
+        views: { kind: "bigInt", required: true },
+        equityPct: { kind: "decimal", required: false },
+      },
+    },
+  ],
+}
+
+const plainAst = {
+  models: [
+    {
+      name: "LandingPage",
+      annotations: { db: { tableName: "landing_page" } },
+      fields: { id: { kind: "uuid", required: true } },
+    },
+  ],
+}
+
+describe("generateProjectClient", () => {
+  it("re-exports the client package, so one import is enough", () => {
+    expect(generateProjectClient(ast)).toContain('export * from "@supatype/client"')
+  })
+
+  it("carries the module augmentation, rather than relying on tsconfig to find it", () => {
+    const out = generateProjectClient(ast)
+    expect(out).toContain('declare module "@supatype/client"')
+    expect(out).toContain("interface SupatypeModels")
+    expect(out).toContain("job_post")
+  })
+
+  it("registers the columns a JSON parser would destroy", () => {
+    const out = generateProjectClient(ast)
+    expect(out).toContain("registerFieldKinds(")
+    expect(out).toContain('"views": "bigint"')
+    expect(out).toContain('"equityPct": "numeric"')
+  })
+
+  it("leaves ordinary columns out of the registration", () => {
+    // Listing a column that survives a parse would invite the client to convert one that was
+    // already correct.
+    const out = generateProjectClient(ast)
+    expect(out).not.toContain('"title"')
+    expect(out).not.toContain('"id": "')
+  })
+
+  it("still registers for a schema with nothing exact", () => {
+    // Registered-and-empty is how the client tells "this project generated and has no exact
+    // columns" from "this project never generated". Both must not look the same.
+    const out = generateProjectClient(plainAst)
+    expect(out).toContain("registerFieldKinds(")
+    expect(out).toContain('"tables": {}')
+  })
+
+  it("imports the registration function from the package", () => {
+    expect(generateProjectClient(ast)).toContain(
+      'import { registerFieldKinds } from "@supatype/client"',
+    )
+  })
+
+  it("says it is generated, on the first line", () => {
+    expect(generateProjectClient(ast).split("\n")[0]).toContain("Generated by supatype")
+  })
+
+  it("is stable across runs, so it does not churn the diff", () => {
+    expect(generateProjectClient(ast)).toBe(generateProjectClient(ast))
+  })
+
+  it("survives an ast it does not recognise", () => {
+    expect(() => generateProjectClient({})).not.toThrow()
+    expect(() => generateProjectClient(null)).not.toThrow()
+  })
+})

package/tests/db-port.test.ts

@@ -0,0 +1,128 @@
+/**
+ * `DATABASE_URL` has to name the port Postgres is published on.
+ *
+ * `SUPATYPE_DB_PORT` moves the host side of the compose mapping so two projects can coexist on one
+ * machine. `DATABASE_URL` is what every host-side script uses. Nothing reconciled them, so a
+ * project moved to 5433 started cleanly, served every request, and failed on its own seed script
+ * with `ECONNREFUSED 127.0.0.1:5432`, naming a port the person never chose.
+ *
+ * The cases that matter most here are the ones where it must NOT act: a remote database is not
+ * ours to repoint, and a malformed URL is not ours to half-fix.
+ */
+
+import { describe, expect, it, beforeEach, afterEach } from "vitest"
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { DEFAULT_DB_PORT, publishedDbPort, syncDatabaseUrlPort } from "../src/db-port.js"
+
+let dir: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "supatype-dbport-"))
+})
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+function writeEnv(lines: string): void {
+  writeFileSync(join(dir, ".env"), lines, "utf8")
+}
+
+function envText(): string {
+  return readFileSync(join(dir, ".env"), "utf8")
+}
+
+describe("publishedDbPort", () => {
+  it("defaults to the port compose binds when unset", () => {
+    expect(publishedDbPort({})).toBe(DEFAULT_DB_PORT)
+  })
+
+  it("reads the configured port", () => {
+    expect(publishedDbPort({ SUPATYPE_DB_PORT: "5433" })).toBe(5433)
+  })
+
+  it("prefers the dev-local port, because its presence marks the deployment shape", () => {
+    // Found by running the validation e2e: that project publishes on SUPATYPE_DEV_DB_PORT=54330
+    // for its host-side engine, and an earlier version of this file rewrote a correct URL to 5432.
+    expect(publishedDbPort({ SUPATYPE_DEV_DB_PORT: "54330" })).toBe(54330)
+    expect(publishedDbPort({ SUPATYPE_DEV_DB_PORT: "54330", SUPATYPE_DB_PORT: "5433" })).toBe(54330)
+  })
+
+  it("uses the self-host port when there is no dev-local one", () => {
+    expect(publishedDbPort({ SUPATYPE_DB_PORT: "5433" })).toBe(5433)
+  })
+
+  it("falls through a nonsense dev-local port to the self-host one", () => {
+    expect(publishedDbPort({ SUPATYPE_DEV_DB_PORT: "abc", SUPATYPE_DB_PORT: "5433" })).toBe(5433)
+  })
+
+  it("falls back rather than inventing a port from nonsense", () => {
+    // Compose reports a bad value far better than we can, and a made-up port would send the seed
+    // somewhere nothing is listening with no clue why.
+    for (const bad of ["", "   ", "abc", "-1", "0", "70000", "5433.5"]) {
+      expect(publishedDbPort({ SUPATYPE_DB_PORT: bad }), `value ${JSON.stringify(bad)}`).toBe(
+        DEFAULT_DB_PORT,
+      )
+    }
+  })
+})
+
+describe("syncDatabaseUrlPort", () => {
+  it("rewrites the port when the two disagree", () => {
+    writeEnv("DATABASE_URL=postgresql://u:p@localhost:5432/acme\nSUPATYPE_DB_PORT=5433\n")
+    expect(syncDatabaseUrlPort(dir)).toEqual({ from: "5432", to: "5433" })
+    expect(envText()).toContain("localhost:5433/acme")
+  })
+
+  it("keeps the credentials, database and query string intact", () => {
+    // The whole point is one field. A rewrite that dropped the password would take the stack down
+    // in a way that looks nothing like a port problem.
+    writeEnv(
+      "DATABASE_URL=postgresql://supatype_admin:s3cr3t@127.0.0.1:5432/acme?sslmode=disable\nSUPATYPE_DB_PORT=5440\n",
+    )
+    syncDatabaseUrlPort(dir)
+    const url = new URL(readFileSync(join(dir, ".env"), "utf8").match(/^DATABASE_URL=(.+)$/m)![1]!)
+    expect(url.port).toBe("5440")
+    expect(url.username).toBe("supatype_admin")
+    expect(url.password).toBe("s3cr3t")
+    expect(url.pathname).toBe("/acme")
+    expect(url.searchParams.get("sslmode")).toBe("disable")
+  })
+
+  it("does nothing when they already agree", () => {
+    writeEnv("DATABASE_URL=postgresql://u:p@localhost:5433/acme\nSUPATYPE_DB_PORT=5433\n")
+    expect(syncDatabaseUrlPort(dir)).toBeNull()
+  })
+
+  it("treats an absent port as the default rather than rewriting it every run", () => {
+    writeEnv("DATABASE_URL=postgresql://u:p@localhost/acme\n")
+    expect(syncDatabaseUrlPort(dir)).toBeNull()
+  })
+
+  it("leaves a remote database alone", () => {
+    // Somebody else's Postgres. Its port has nothing to do with our compose mapping, and
+    // rewriting it would repoint the project at a database that does not exist.
+    const remote = "postgresql://u:p@db.example.com:5432/acme"
+    writeEnv(`DATABASE_URL=${remote}\nSUPATYPE_DB_PORT=5433\n`)
+    expect(syncDatabaseUrlPort(dir)).toBeNull()
+    expect(envText()).toContain(remote)
+  })
+
+  it("leaves a malformed URL alone rather than half-fixing it", () => {
+    const broken = "postgres//u:p@localhost:5432/acme"
+    writeEnv(`DATABASE_URL=${broken}\nSUPATYPE_DB_PORT=5433\n`)
+    expect(syncDatabaseUrlPort(dir)).toBeNull()
+    expect(envText()).toContain(broken)
+  })
+
+  it("does nothing when there is no DATABASE_URL at all", () => {
+    writeEnv("SUPATYPE_DB_PORT=5433\n")
+    expect(syncDatabaseUrlPort(dir)).toBeNull()
+  })
+
+  it("does nothing when there is no .env", () => {
+    expect(syncDatabaseUrlPort(dir)).toBeNull()
+  })
+})

package/tests/external-database-compose.test.ts

@@ -42,13 +42,20 @@ describe("external database: compose", () => {
     const compose = renderSelfHostCompose(managed())
     expect(compose).toMatch(/^ {2}db:$/m)
     expect(compose).toContain("pg_isready")
+    // The positive half of "leaves no reference to the db host anywhere" below. Without this, that
+    // test's negative assertion could pass against a pattern that matches nothing at all.
+    expect(compose).toMatch(/^\s+db:\s*\n\s+condition:/m)
   })
 
   it("leaves no reference to the db host anywhere", () => {
     const compose = renderSelfHostCompose(external())
     expect(compose).not.toContain("@db:5432")
     expect(compose).not.toContain("db-data")
-    expect(compose).not.toContain("condition: service_healthy")
+    // Nothing may wait on a `db` service that is not there. Asserted as a dependency on `db`
+    // rather than as the absence of any health condition, which is what this used to say: storage
+    // waits for the object store to be healthy in every deployment, because that race is about
+    // seaweedfs and has nothing to do with where Postgres lives.
+    expect(compose).not.toMatch(/^\s+db:\s*\n\s+condition:/m)
   })
 
   it("points every database consumer at the one URL", () => {

package/tests/functions-context-refresh.test.ts

@@ -0,0 +1,86 @@
+/**
+ * `functions/_shared/context.ts` reaches a project that already exists.
+ *
+ * The module was written by `init` and `supatype functions new`, and by nothing else. So it arrived
+ * with new projects and new functions, and never arrived at a project that already had functions
+ * when the two-argument handler contract landed: those keep `(req)` handlers with no
+ * `FunctionContext` to import, while the generated file itself asserts
+ *
+ *   Regenerated by the CLI. Edits are overwritten.
+ *
+ * which was true only if you scaffolded again. `tests/integration` in this repo had four functions
+ * and no context module at all, which is how it was found.
+ */
+import { describe, expect, it, beforeEach, afterEach } from "vitest"
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { refreshFunctionsContext } from "../src/functions-context-refresh.js"
+import type { SupatypeProjectConfig } from "../src/project-config.js"
+
+const config: SupatypeProjectConfig = {
+  project: { name: "ctx" },
+  database: { provider: "docker" },
+} as SupatypeProjectConfig
+
+let dir: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "supatype-ctx-"))
+})
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+/** A project with functions but no `_shared`, which is what a pre-migration project looks like. */
+function projectWithFunctions(): string {
+  const functions = join(dir, "functions")
+  mkdirSync(functions, { recursive: true })
+  writeFileSync(
+    join(functions, "ping.ts"),
+    "export default function ping(_req: Request) { return new Response('ok') }\n",
+    "utf8",
+  )
+  return functions
+}
+
+describe("a project that already has functions", () => {
+  it("gets the context module written", () => {
+    const functions = projectWithFunctions()
+    expect(existsSync(join(functions, "_shared", "context.ts"))).toBe(false)
+
+    expect(refreshFunctionsContext(dir, config)).toBe(true)
+    expect(existsSync(join(functions, "_shared", "context.ts"))).toBe(true)
+  })
+
+  it("writes a module that actually declares the contract", () => {
+    // Not merely that a file appeared. The point is the type handlers import.
+    projectWithFunctions()
+    refreshFunctionsContext(dir, config)
+    const source = readFileSync(join(dir, "functions", "_shared", "context.ts"), "utf8")
+    expect(source).toContain("FunctionContext")
+    expect(source).toContain("executionId")
+  })
+
+  it("rewrites a stale copy rather than leaving it", () => {
+    // The file says edits are overwritten, so they have to be.
+    const functions = projectWithFunctions()
+    mkdirSync(join(functions, "_shared"), { recursive: true })
+    writeFileSync(join(functions, "_shared", "context.ts"), "// stale\n", "utf8")
+
+    refreshFunctionsContext(dir, config)
+    const source = readFileSync(join(functions, "_shared", "context.ts"), "utf8")
+    expect(source).not.toBe("// stale\n")
+    expect(source).toContain("FunctionContext")
+  })
+})
+
+describe("a project with no functions", () => {
+  it("is left alone", () => {
+    // Writing `_shared/` into a project with no functions would create the thing it describes out
+    // of nothing, and leave a directory nobody asked for in the diff.
+    expect(refreshFunctionsContext(dir, config)).toBe(false)
+    expect(existsSync(join(dir, "functions"))).toBe(false)
+  })
+})

package/tests/gitignore-secrets.test.ts

@@ -0,0 +1,90 @@
+/**
+ * The `.gitignore` we write has to cover the secrets we write.
+ *
+ * `supatype functions new` writes `functions/.env.local` with "These are NOT committed to git" at
+ * the top of it, and nothing made that true: `.env` matches a file named exactly `.env`, and both
+ * `.env.local` and `.env.<function>.local` were tracked.
+ *
+ * Asserted through `git check-ignore` rather than by reading the patterns, because the question is
+ * what git does with them and a pattern that looks right is how this got shipped.
+ */
+
+import { describe, expect, it, beforeEach, afterEach } from "vitest"
+import { execFileSync } from "node:child_process"
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
+import { join } from "node:path"
+import { tmpdir } from "node:os"
+import { SUPATYPE_GITIGNORE_BLOCK, SUPATYPE_GITIGNORE_PATHS } from "../src/gitignore.js"
+
+let dir: string
+
+beforeEach(() => {
+  dir = mkdtempSync(join(tmpdir(), "supatype-ignore-"))
+  execFileSync("git", ["init", "-q", "."], { cwd: dir })
+})
+
+afterEach(() => {
+  rmSync(dir, { recursive: true, force: true })
+})
+
+/** What git itself says about a path, which is the only answer that counts. */
+function ignored(relPath: string): boolean {
+  try {
+    execFileSync("git", ["check-ignore", "-q", relPath], { cwd: dir })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function writeIgnore(contents: string): void {
+  writeFileSync(join(dir, ".gitignore"), contents, "utf8")
+  mkdirSync(join(dir, "functions"), { recursive: true })
+  mkdirSync(join(dir, "src"), { recursive: true })
+  for (const f of [
+    ".env",
+    ".env.local",
+    "functions/.env.local",
+    "functions/.env.checkout.local",
+    "src/index.ts",
+    "src/env.local.ts",
+  ]) {
+    writeFileSync(join(dir, f), "x", "utf8")
+  }
+}
+
+describe("the block written into an existing .gitignore", () => {
+  beforeEach(() => writeIgnore(SUPATYPE_GITIGNORE_BLOCK))
+
+  it("ignores the plain env file", () => {
+    expect(ignored(".env")).toBe(true)
+  })
+
+  it("ignores the function env files, at the root and nested", () => {
+    // The ones `supatype functions new` writes and the worker reads.
+    expect(ignored(".env.local")).toBe(true)
+    expect(ignored("functions/.env.local")).toBe(true)
+    expect(ignored("functions/.env.checkout.local")).toBe(true)
+  })
+
+  it("does not swallow source files", () => {
+    // `.env.*.local` is a glob, and a careless widening of it catches real code.
+    expect(ignored("src/index.ts")).toBe(false)
+    expect(ignored("src/env.local.ts")).toBe(false)
+  })
+})
+
+describe("the two emitters", () => {
+  it("agree, because they read one list", () => {
+    // They were separate copies and had already drifted. The copy that drifts is the one found
+    // when a key reaches a public repository.
+    for (const path of SUPATYPE_GITIGNORE_PATHS) {
+      expect(SUPATYPE_GITIGNORE_BLOCK).toContain(path)
+    }
+  })
+
+  it("carries the env patterns `.env` alone does not cover", () => {
+    expect(SUPATYPE_GITIGNORE_PATHS).toContain(".env.local")
+    expect(SUPATYPE_GITIGNORE_PATHS).toContain(".env.*.local")
+  })
+})

package/tests/keys-write.test.ts

@@ -0,0 +1,148 @@
+/**
+ * `supatype keys --write` writes the pair it mints.
+ *
+ * The command printed the keys and wrote nothing, while every README in this repository says it
+ * mints them into `.env`. Following the docs therefore produced a front end built with
+ * `anonKey: undefined` and a gateway refusing its every request, with nothing in the output saying
+ * so.
+ *
+ * Writing is opt-in rather than the default: a command that reads a secret and edits a file on
+ * sight is worse than one that has to be asked. What it writes is blanks only, because an anon key
+ * already in `.env` is held by clients this command cannot reach and reissuing it locks them out.
+ * `--force` is how someone says they meant to rotate.
+ */
+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 { anonKeyEnvUpdates, writeKeysToEnv } from "../src/commands/keys.js"
+
+const PAIR = { anonKey: "anon.jwt.value", serviceKey: "service.jwt.value" }
+
+function envValue(dir: string, key: string): string | undefined {
+  const line = readFileSync(join(dir, ".env"), "utf8")
+    .split("\n")
+    .find((l) => l.startsWith(`${key}=`))
+  return line?.slice(key.length + 1).trim()
+}
+
+describe("writeKeysToEnv", () => {
+  let dir: string
+
+  beforeEach(() => {
+    dir = mkdtempSync(join(tmpdir(), "supatype-keys-"))
+  })
+  afterEach(() => {
+    rmSync(dir, { recursive: true, force: true })
+  })
+
+  it("fills blank keys", () => {
+    writeFileSync(join(dir, ".env"), "JWT_SECRET=s\nANON_KEY=\nSERVICE_ROLE_KEY=\n")
+    const result = writeKeysToEnv(dir, PAIR, false)
+
+    expect(result.written).toContain("ANON_KEY")
+    expect(result.written).toContain("SERVICE_ROLE_KEY")
+    expect(envValue(dir, "ANON_KEY")).toBe(PAIR.anonKey)
+    expect(envValue(dir, "SERVICE_ROLE_KEY")).toBe(PAIR.serviceKey)
+  })
+
+  it("adds keys that are absent entirely", () => {
+    writeFileSync(join(dir, ".env"), "JWT_SECRET=s\n")
+    writeKeysToEnv(dir, PAIR, false)
+
+    expect(envValue(dir, "ANON_KEY")).toBe(PAIR.anonKey)
+    expect(envValue(dir, "VITE_SUPATYPE_ANON_KEY")).toBe(PAIR.anonKey)
+  })
+
+  it("treats a declared-but-blank line as a blank to fill", () => {
+    // The templates ship `ANON_KEY=` with nothing after it, which is exactly the line to write.
+    writeFileSync(join(dir, ".env"), "JWT_SECRET=s\nVITE_SUPATYPE_ANON_KEY=\n")
+    const result = writeKeysToEnv(dir, PAIR, false)
+
+    expect(result.written).toContain("VITE_SUPATYPE_ANON_KEY")
+    expect(envValue(dir, "VITE_SUPATYPE_ANON_KEY")).toBe(PAIR.anonKey)
+  })
+
+  it("leaves a key that already holds a value, and says which", () => {
+    writeFileSync(join(dir, ".env"), "JWT_SECRET=s\nANON_KEY=in-use-by-clients\nSERVICE_ROLE_KEY=\n")
+    const result = writeKeysToEnv(dir, PAIR, false)
+
+    expect(result.kept).toContain("ANON_KEY")
+    expect(result.written).not.toContain("ANON_KEY")
+    expect(envValue(dir, "ANON_KEY")).toBe("in-use-by-clients")
+    expect(envValue(dir, "SERVICE_ROLE_KEY")).toBe(PAIR.serviceKey)
+  })
+
+  it("replaces every key it owns under --force, not only the blank ones", () => {
+    writeFileSync(
+      join(dir, ".env"),
+      "JWT_SECRET=s\nANON_KEY=old-anon\nSERVICE_ROLE_KEY=old-service\nVITE_SUPATYPE_ANON_KEY=old-vite\n",
+    )
+    const result = writeKeysToEnv(dir, PAIR, true)
+
+    expect(result.kept).toEqual([])
+    expect(envValue(dir, "ANON_KEY")).toBe(PAIR.anonKey)
+    expect(envValue(dir, "SERVICE_ROLE_KEY")).toBe(PAIR.serviceKey)
+    expect(envValue(dir, "VITE_SUPATYPE_ANON_KEY")).toBe(PAIR.anonKey)
+  })
+
+  it("does not rewrite the file, even under --force", () => {
+    // `.env` holds JWT_SECRET, which these keys are derived from, plus the database password and
+    // whatever else the project keeps there. Replacing the file would leave a project whose keys
+    // cannot be regenerated and whose stack cannot start.
+    writeFileSync(
+      join(dir, ".env"),
+      "# a comment someone wrote\nJWT_SECRET=s\nPOSTGRES_PASSWORD=pw\nANON_KEY=old\nCUSTOM_THING=mine\n",
+    )
+    writeKeysToEnv(dir, PAIR, true)
+
+    const content = readFileSync(join(dir, ".env"), "utf8")
+    expect(content).toContain("# a comment someone wrote")
+    expect(envValue(dir, "JWT_SECRET")).toBe("s")
+    expect(envValue(dir, "POSTGRES_PASSWORD")).toBe("pw")
+    expect(envValue(dir, "CUSTOM_THING")).toBe("mine")
+  })
+
+  it("carries the API URL through when the project records one", () => {
+    writeFileSync(join(dir, ".env"), "JWT_SECRET=s\nPUBLIC_SUPATYPE_URL=http://localhost:18475\n")
+    writeKeysToEnv(dir, PAIR, true)
+
+    expect(envValue(dir, "VITE_SUPATYPE_URL")).toBe("http://localhost:18475")
+  })
+
+  it("writes no URL names when the project records no URL", () => {
+    // An empty `VITE_SUPATYPE_URL` is worse than an absent one: the client reads it, finds a blank
+    // string, and requests against the page origin without saying why.
+    writeFileSync(join(dir, ".env"), "JWT_SECRET=s\n")
+    writeKeysToEnv(dir, PAIR, false)
+
+    expect(readFileSync(join(dir, ".env"), "utf8")).not.toContain("VITE_SUPATYPE_URL")
+  })
+
+  it("reports no .env rather than creating one", () => {
+    const result = writeKeysToEnv(dir, PAIR, false)
+
+    expect(result.path).toBeNull()
+    expect(result.written).toEqual([])
+  })
+})
+
+describe("anonKeyEnvUpdates", () => {
+  it("is the one list both `keys` and `dev` write from", () => {
+    // They held separate lists, so a front end's prefix could be written by one and forgotten by
+    // the other, and which names a project's .env ended up with depended on which command ran last.
+    const names = Object.keys(anonKeyEnvUpdates("a", "s"))
+    expect(names).toEqual([
+      "ANON_KEY",
+      "SERVICE_ROLE_KEY",
+      "VITE_SUPATYPE_ANON_KEY",
+      "PUBLIC_SUPATYPE_ANON_KEY",
+      "EXPO_PUBLIC_SUPATYPE_ANON_KEY",
+    ])
+  })
+
+  it("adds the URL names only when given a URL", () => {
+    expect(Object.keys(anonKeyEnvUpdates("a", "s", "http://x"))).toContain("VITE_SUPATYPE_URL")
+    expect(Object.keys(anonKeyEnvUpdates("a", "s"))).not.toContain("VITE_SUPATYPE_URL")
+  })
+})