@supatype/cli 0.3.2 → 0.3.3

package/tests/access-composition.test.ts

@@ -580,6 +580,129 @@ export type Post = Model<{
     })
   })
 
+
+  // `After` / `Before`: a point in time plus or minus a multi-unit duration. The
+  // composition `Ago` and `FromNow` could not express, because they carry one amount
+  // and one unit.
+  it("extracts a composed offset from a truncation base", () => {
+    const post = extract(
+      `
+import type { Model, UUID, All, Gte, Lte, After, Before, Now, StartOf } from "@supatype/types"
+
+export type Post = Model<{
+  id: UUID
+}, {
+  access: {
+    read: All<[
+      Gte<"starts_at", After<StartOf<"day">, { days: 30, hours: 9 }>>,
+      Lte<"created_at", Before<Now, { weeks: 2 }>>
+    ]>
+  }
+}>
+`,
+      "offsets",
+    )
+
+    expect(access(post)["read"]).toEqual({
+      type: "all",
+      rules: [
+        {
+          type: "compare",
+          op: "gte",
+          left: { kind: "column", name: "starts_at" },
+          right: {
+            kind: "after",
+            base: { kind: "startOf", unit: "day" },
+            interval: { days: 30, hours: 9 },
+          },
+        },
+        {
+          type: "compare",
+          op: "lte",
+          left: { kind: "column", name: "created_at" },
+          right: {
+            kind: "before",
+            base: { kind: "now" },
+            interval: { weeks: 2 },
+          },
+        },
+      ],
+    })
+  })
+
+  // The base is what makes an offset meaningful. A column depends on the row, so it is
+  // not a point in time an offset can be measured from, and the engine refuses one too.
+  it("rejects a base that is not a point in time", () => {
+    expect(() =>
+      extract(
+        `
+import type { Model, UUID, Gte, After, Ago } from "@supatype/types"
+export type Post = Model<{ id: UUID }, {
+  access: { read: Gte<"a", After<Ago<1, "days">, { days: 1 }>> }
+}>
+`,
+        "offset-base",
+      ),
+    ).toThrow(/must be `Now` or `StartOf/)
+  })
+
+  it("rejects an unknown unit inside the interval", () => {
+    expect(() =>
+      extract(
+        `
+import type { Model, UUID, Gte, After, Now } from "@supatype/types"
+export type Post = Model<{ id: UUID }, {
+  access: { read: Gte<"a", After<Now, { dayz: 30 }>> }
+}>
+`,
+        "offset-unit",
+      ),
+    ).toThrow(/is not a unit of time/)
+  })
+
+  // Same rule as Ago/FromNow: direction lives in the operand name, not in a sign, so a
+  // negative amount is refused with the opposite operand named.
+  it("rejects a negative or fractional amount and names the opposite operand", () => {
+    const bad = (n: string) => `
+import type { Model, UUID, Gte, After, Now } from "@supatype/types"
+export type Post = Model<{ id: UUID }, {
+  access: { read: Gte<"a", After<Now, { days: ${n} }>> }
+}>
+`
+    expect(() => extract(bad("-5"), "offset-neg")).toThrow(/does not take a negative amount/)
+    expect(() => extract(bad("-5"), "offset-neg2")).toThrow(/`Before<>`/)
+    expect(() => extract(bad("0.5"), "offset-frac")).toThrow(/whole number/)
+  })
+
+  // An all-zero interval means the base unchanged, which is never what an author wrote.
+  it("rejects an interval that sums to nothing", () => {
+    expect(() =>
+      extract(
+        `
+import type { Model, UUID, Gte, After, Now } from "@supatype/types"
+export type Post = Model<{ id: UUID }, {
+  access: { read: Gte<"a", After<Now, { days: 0 }>> }
+}>
+`,
+        "offset-zero",
+      ),
+    ).toThrow(/empty interval/)
+  })
+
+  it("rejects a unit given twice", () => {
+    expect(() =>
+      extract(
+        `
+import type { Model, UUID, Gte, After, Now } from "@supatype/types"
+export type Post = Model<{ id: UUID }, {
+  access: { read: Gte<"a", After<Now, { days: 1, days: 2 }>> }
+}>
+`,
+        "offset-dup",
+      ),
+    ).toThrow(/twice/)
+  })
+
   // A permissive `"30 days"` string would be raw SQL by another name, so the amount
   // and unit are validated separately and the interval is reassembled from them.
   it("rejects a fractional or negative amount", () => {

package/tests/augmentation-generator.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest"
 import { generateClientAugmentation, generateRowType } from "../src/augmentation-generator.js"
 
 describe("generateClientAugmentation", () => {
-  it("emits deterministic output independent of model order", () => {
+  it("emits models in the order the schema declares them", () => {
     const astA = {
       models: [
         {
@@ -32,9 +32,13 @@ describe("generateClientAugmentation", () => {
       ],
     }
 
-    expect(generateClientAugmentation(astA)).toEqual(generateClientAugmentation(astB))
-    expect(generateClientAugmentation(astA)).toContain("post:")
-    expect(generateClientAugmentation(astA)).toContain("comment:")
+    // The AST keeps the order `schema/index.ts` was written in, so the generated file does
+    // too: alphabetising threw away an order the author chose and the source of truth kept.
+    const a = generateClientAugmentation(astA)
+    const b = generateClientAugmentation(astB)
+    expect(a.indexOf("post:")).toBeLessThan(a.indexOf("comment:"))
+    expect(b.indexOf("comment:")).toBeLessThan(b.indexOf("post:"))
+    expect(a).not.toEqual(b)
   })
 
   it("resolves tableName from AST v2 annotations.db.tableName", () => {
@@ -80,7 +84,7 @@ describe("generateClientAugmentation", () => {
     expect(insertOnly).not.toContain("name?:")
   })
 
-  it("types richText fields as SerializedEditorState", () => {
+  it("types richText fields as the Lexical document they hold", () => {
     const ast = {
       models: [
         {
@@ -93,10 +97,40 @@ describe("generateClientAugmentation", () => {
       ],
     }
     const out = generateClientAugmentation(ast)
-    expect(out).toContain('import("@supatype/types/lexical").SerializedEditorState')
+    expect(out).toContain('import type { SerializedEditorState } from "@supatype/types/lexical"')
+    expect(out).toContain("export type RichText = SerializedEditorState")
+    expect(out).toContain("body: RichText")
     expect(out).not.toMatch(/body: Record<string, unknown>/)
   })
 
+  it("widens a localized richText column inside the locale map, not around it", () => {
+    // The column holds one document per locale and the trigger normalises each of them, so what
+    // accepts prose is the locale's value. `{ [locale: string]: RichText } | string` would say a
+    // bare string is a valid write, and the trigger would store it as a single document where a
+    // locale map belongs, which the Row type says cannot happen.
+    const ast = {
+      models: [
+        {
+          tableName: "page",
+          fields: {
+            id: { kind: "uuid", pgType: "UUID", required: true, primaryKey: true, default: { kind: "genRandomUuid" } },
+            title: { kind: "richText", pgType: "JSONB", required: false, localized: true },
+            body: { kind: "richText", pgType: "JSONB", required: false },
+          },
+        },
+      ],
+    }
+    const out = generateClientAugmentation(ast)
+
+    expect(out).toContain("title: { [locale: string]: RichText } | null")
+    expect(out).toContain("title?: { [locale: string]: RichText | string } | null")
+    expect(out).not.toContain("{ [locale: string]: RichText } | string")
+
+    // The plain column keeps the widening at the top, so one cannot be flattened into the other.
+    expect(out).toContain("body: RichText | null")
+    expect(out).toContain("body?: RichText | string | null")
+  })
+
   it("uses a field's declared tsType instead of collapsing JSONB to an opaque object", () => {
     // `Currency<"USD">` and `Code<"sql">` are stored as JSONB because each carries two values. If
     // the generated row typed them as `Record<string, unknown>`, a caller reading `price.amount`
@@ -234,16 +268,17 @@ describe("column shapes that disagreed with the database", () => {
   })
 
   it("types an image as what storage.upload actually produces", () => {
-    // Was `Record<string, unknown>`, which is why the examples cast on the good path.
+    // Was `Record<string, unknown>`, which is why the examples cast on the good path. Named
+    // rather than written out, so this file and `types/database.ts` say it the same way.
     const row = generateRowType({
       headshot: { kind: "image", required: false, bucket: "speaker-headshots" },
     })
-    expect(row).toContain("headshot: { bucket: string; path: string } | null")
+    expect(row).toContain("headshot: StorageReference | null")
   })
 
   it("types a file the same way", () => {
     const row = generateRowType({ attachment: { kind: "file", required: true } })
-    expect(row).toContain("attachment: { bucket: string; path: string }")
+    expect(row).toContain("attachment: StorageReference")
   })
 
   it("does not store a url, because a stored one goes stale", () => {
@@ -251,3 +286,108 @@ describe("column shapes that disagreed with the database", () => {
     expect(row).not.toContain("url")
   })
 })
+
+/**
+ * What this file has to agree with.
+ *
+ * `types/database.ts` and `supatype/generated/index.d.ts` describe the same columns of the
+ * same tables, and are written by two different generators: the engine's and this one. When
+ * they were compared column by column for a real schema, three of them disagreed, and in
+ * every case this side was the one that was wrong. Each is pinned below.
+ *
+ * The comparison itself is not automated here, because it needs an engine binary. What is
+ * automated is the property each disagreement came down to.
+ */
+describe("agreement with the engine's generator", () => {
+  const ast = {
+    models: [
+      {
+        name: "Event",
+        fields: {
+          id: { kind: "uuid", required: true, primaryKey: true },
+          title: { kind: "text", required: true },
+          slug: { kind: "slug", required: true },
+          description: { kind: "richText", required: false },
+          cover_image: { kind: "image", required: false },
+        },
+        annotations: { db: { tableName: "event", indexes: [] } },
+      },
+    ],
+  }
+
+  /**
+   * A slug is filled by a trigger the engine emits, so an insert need not supply one. This
+   * side demanded it, which asked for a value the database was about to overwrite.
+   */
+  it("does not demand a slug on insert", () => {
+    const out = generateClientAugmentation(ast)
+    const insert = out.split("Insert: {")[1]?.split("}")[0] ?? ""
+    expect(insert).toContain("slug?:")
+    expect(insert).not.toContain("slug: ")
+  })
+
+  /**
+   * A rich-text column holds a Lexical document. `| string` said it might hold a bare string
+   * too, so this file and `types/database.ts` disagreed about the same column.
+   */
+  it("types rich text as the document it holds, and nothing looser", () => {
+    const out = generateClientAugmentation(ast)
+    expect(out).toContain("description: RichText | null")
+    expect(out).not.toContain("SerializedEditorState | string")
+  })
+
+  /**
+   * The three shapes differ by more than optionality here, which they do nowhere else. The
+   * engine emits a trigger that turns a plain string into a document on the way in, so a read
+   * is always a document and a write may be prose.
+   */
+  it("types rich text as a document to read and prose to write", () => {
+    const out = generateClientAugmentation(ast)
+    const block = (name: string): string =>
+      out.split(`${name}: {`)[1]?.split("      }")[0] ?? ""
+    expect(block("Row")).toContain("description: RichText | null")
+    expect(block("Insert")).toContain("description?: RichText | string | null")
+    expect(block("Update")).toContain("description?: RichText | string | null")
+  })
+
+  /** Named aliases, the same ones, so a reader moving between the two files is not
+   * comparing spellings. */
+  it("names the shared types rather than writing them out", () => {
+    const out = generateClientAugmentation(ast)
+    expect(out).toContain("export type RichText = SerializedEditorState")
+    expect(out).toContain("export type StorageReference = {")
+    expect(out).toContain("cover_image: StorageReference | null")
+    expect(out).not.toContain("{ bucket: string; path: string }")
+  })
+
+  /** Emitted only when the schema uses them. */
+  it("declares no alias the schema does not use", () => {
+    const plain = generateClientAugmentation({
+      models: [
+        {
+          name: "Note",
+          fields: { body: { kind: "text", required: true } },
+          annotations: { db: { tableName: "note", indexes: [] } },
+        },
+      ],
+    })
+    expect(plain).not.toContain("RichText")
+    expect(plain).not.toContain("StorageReference")
+  })
+
+  /** The columns sit inside the block that holds them. */
+  it("indents each column into its own block", () => {
+    const out = generateClientAugmentation(ast)
+    expect(out).toContain("        title: string")
+    expect(out).not.toMatch(/^ {2}title: string$/m)
+  })
+
+  /** In the order the schema declares them, because the AST keeps that order. */
+  it("keeps the schema's column order", () => {
+    const out = generateClientAugmentation(ast)
+    const row = out.split("Row: {")[1]?.split("}")[0] ?? ""
+    const order = ["id", "title", "slug", "description", "cover_image"]
+    const positions = order.map((column) => row.indexOf(`${column}:`))
+    expect(positions).toEqual([...positions].sort((a, b) => a - b))
+  })
+})

package/tests/engine-floor.test.ts

@@ -4,8 +4,12 @@ import {
   boundsRequiringHelpers,
   compareVersions,
   ENGINE_MIN_FOR_BOUNDS,
+  ENGINE_MIN_FOR_RICHTEXT_TRIGGER,
+  ENGINE_MIN_FOR_SEED,
   ENGINE_MIN_FOR_VERSIONS,
+  fieldsNeedingRichTextTrigger,
   modelsRequiringVersions,
+  seedUnsupportedByPinnedEngine,
 } from "../src/engine-floor.js"
 import type { ExtractedSchemaAstV2, FieldAstV2, ModelAstV2 } from "../src/schema-ast-v2.js"
 
@@ -36,6 +40,12 @@ function schema(models: ModelAstV2[]): ExtractedSchemaAstV2 {
 const WITH_BOUND = schema([model("Post", { title: field({ validation: { maxLength: 80 } }) })])
 const WITHOUT_BOUND = schema([model("Post", { title: field() })])
 
+const RICH_TEXT = field({ kind: "richText", annotations: { db: { pgType: "JSONB" }, platform: {} } })
+const WITH_RICH_TEXT = schema([model("Post", { title: field(), body: RICH_TEXT })])
+
+/** The engine released before either floor, so it is what a project pinned today would carry. */
+const BEFORE_BOTH = "0.3.3"
+
 describe("compareVersions", () => {
   it("orders by each numeric part, not lexically", () => {
     expect(compareVersions("0.10.0", "0.9.0")).toBeGreaterThan(0)
@@ -143,3 +153,86 @@ describe("the versions floor", () => {
     expect(() => { assertEngineSupportsSchema(WITH_BOUND, "0.1.9") }).toThrow(/bounds/)
   })
 })
+
+describe("the rich text trigger floor", () => {
+  it("names the columns that need it", () => {
+    expect(fieldsNeedingRichTextTrigger(WITH_RICH_TEXT)).toEqual(["Post.body"])
+    expect(fieldsNeedingRichTextTrigger(WITHOUT_BOUND)).toEqual([])
+  })
+
+  it("refuses a rich text column on an engine that cannot normalise it", () => {
+    expect(() => { assertEngineSupportsSchema(WITH_RICH_TEXT, BEFORE_BOTH) }).toThrow(
+      new RegExp(`schema-engine ${ENGINE_MIN_FOR_RICHTEXT_TRIGGER.replace(/\./g, "\.")} or newer`),
+    )
+  })
+
+  it("points at the column, because the remedy is in the schema", () => {
+    try {
+      assertEngineSupportsSchema(WITH_RICH_TEXT, BEFORE_BOTH)
+      expect.unreachable("a rich text column on an older engine has to be refused")
+    } catch (err) {
+      const message = (err as Error).message
+      expect(message).toContain("Post.body")
+      expect(message).toContain("rich text columns")
+      // The whole point of the refusal: what goes wrong is a read, not the push.
+      expect(message).toContain("what the types say is impossible")
+      expect(message).toContain(`versions: { engine: "${ENGINE_MIN_FOR_RICHTEXT_TRIGGER}" }`)
+    }
+  })
+
+  it("allows the release itself and anything newer", () => {
+    expect(() => {
+      assertEngineSupportsSchema(WITH_RICH_TEXT, ENGINE_MIN_FOR_RICHTEXT_TRIGGER)
+    }).not.toThrow()
+    expect(() => { assertEngineSupportsSchema(WITH_RICH_TEXT, "1.0.0") }).not.toThrow()
+  })
+
+  it("says nothing about a schema with no rich text column", () => {
+    expect(() => { assertEngineSupportsSchema(WITHOUT_BOUND, BEFORE_BOTH) }).not.toThrow()
+  })
+
+  it("leaves an unpinned or local project alone", () => {
+    expect(() => { assertEngineSupportsSchema(WITH_RICH_TEXT, undefined) }).not.toThrow()
+    expect(() => { assertEngineSupportsSchema(WITH_RICH_TEXT, "local") }).not.toThrow()
+  })
+})
+
+describe("seedUnsupportedByPinnedEngine", () => {
+  it("refuses a pin with no seed subcommand, and says what to change", () => {
+    const message = seedUnsupportedByPinnedEngine(BEFORE_BOTH)
+    expect(message).toBeDefined()
+    expect(message).toContain(`schema-engine ${ENGINE_MIN_FOR_SEED} or newer`)
+    expect(message).toContain(BEFORE_BOTH)
+    expect(message).toContain(`versions: { engine: "${ENGINE_MIN_FOR_SEED}" }`)
+  })
+
+  it("allows the release itself and anything newer", () => {
+    expect(seedUnsupportedByPinnedEngine(ENGINE_MIN_FOR_SEED)).toBeUndefined()
+    expect(seedUnsupportedByPinnedEngine("1.0.0")).toBeUndefined()
+  })
+
+  it("leaves an unpinned or local project alone", () => {
+    // Unpinned resolves to latest, which is at or above the floor by definition.
+    expect(seedUnsupportedByPinnedEngine(undefined)).toBeUndefined()
+    expect(seedUnsupportedByPinnedEngine("local")).toBeUndefined()
+  })
+
+  it("is not conditional on the schema, because every seed needs the subcommand", () => {
+    // No argument but the pin: there is nothing a project could declare to opt out of this one,
+    // which is what makes it different from every other floor in this file.
+    expect(seedUnsupportedByPinnedEngine.length).toBe(1)
+  })
+})
+
+describe("the floors themselves", () => {
+  it("name the engine release that introduced them", () => {
+    // Hard-coded rather than read back from the constant. Every other assertion in this file
+    // builds its expectation from the value under test, so lowering a floor would move the tests
+    // with it and nothing would go red. A floor is a reviewed claim about a published engine, and
+    // this is the one place that says which one.
+    expect(ENGINE_MIN_FOR_BOUNDS).toBe("0.2.0")
+    expect(ENGINE_MIN_FOR_VERSIONS).toBe("0.3.0")
+    expect(ENGINE_MIN_FOR_RICHTEXT_TRIGGER).toBe("0.4.0")
+    expect(ENGINE_MIN_FOR_SEED).toBe("0.4.0")
+  })
+})

package/tests/fixtures/seed_golden_ir.json

@@ -0,0 +1,186 @@
+{
+  "irVersion": 1,
+  "schemaFingerprint": "sha256:0000000000000000000000000000000000000000000000000000000000000000",
+  "operations": [
+    {
+      "op": "upsert",
+      "model": "Profile",
+      "id": "alex",
+      "where": {
+        "id": "a0000000-0000-4000-8000-000000000001"
+      },
+      "data": {
+        "display_name": "Alex Rivera",
+        "full_name": "Alex Rivera"
+      }
+    },
+    {
+      "op": "upsert",
+      "model": "Organiser",
+      "id": "northern",
+      "where": {
+        "slug": "northern-lights-events"
+      },
+      "data": {
+        "name": "Northern Lights Events",
+        "contact_email": "hello@northernlights.test",
+        "owner": {
+          "connect": {
+            "id": {
+              "$ref": "alex.id"
+            }
+          }
+        },
+        "events": {
+          "create": [
+            {
+              "title": "Southwest Dev Conference",
+              "status": "published",
+              "starts_at": {
+                "kind": "after",
+                "base": {
+                  "kind": "startOf",
+                  "unit": "day"
+                },
+                "interval": {
+                  "days": 30,
+                  "hours": 9
+                }
+              },
+              "ends_at": {
+                "kind": "after",
+                "base": {
+                  "kind": "startOf",
+                  "unit": "day"
+                },
+                "interval": {
+                  "days": 30,
+                  "hours": 18
+                }
+              },
+              "created_at": {
+                "kind": "now"
+              },
+              "ticket_types": {
+                "createMany": [
+                  {
+                    "name": "Early Bird",
+                    "price": {
+                      "$numeric": "75.0000"
+                    },
+                    "quantity": 100
+                  },
+                  {
+                    "name": "Standard",
+                    "price": {
+                      "$numeric": "125.0000"
+                    },
+                    "quantity": 250
+                  }
+                ]
+              }
+            }
+          ]
+        }
+      }
+    },
+    {
+      "op": "createMany",
+      "model": "Venue",
+      "rows": [
+        {
+          "name": "The Exchange",
+          "city": "Bristol",
+          "capacity": 450,
+          "country": {
+            "$default": true
+          },
+          "organiser": {
+            "connect": {
+              "slug": "northern-lights-events"
+            }
+          }
+        },
+        {
+          "name": "Archway Studios",
+          "city": "London",
+          "capacity": 180,
+          "country": {
+            "$default": true
+          },
+          "organiser": {
+            "connect": {
+              "slug": "northern-lights-events"
+            }
+          }
+        }
+      ]
+    },
+    {
+      "op": "group",
+      "if": {
+        "kind": "notExists",
+        "model": "SiteSettings"
+      },
+      "operations": [
+        {
+          "op": "create",
+          "model": "SiteSettings",
+          "data": {
+            "site_name": "Launch Test Tickets",
+            "default_currency": "GBP"
+          }
+        }
+      ]
+    },
+    {
+      "op": "group",
+      "if": {
+        "kind": "exists",
+        "model": "Event",
+        "where": {
+          "type": "compare",
+          "op": "eq",
+          "left": {
+            "kind": "column",
+            "name": "status"
+          },
+          "right": {
+            "kind": "literal",
+            "value": "published"
+          }
+        }
+      },
+      "operations": [
+        {
+          "op": "create",
+          "model": "PromoCode",
+          "data": {
+            "code": "EARLY20",
+            "discount_kind": "percentage",
+            "discount_value": 20,
+            "valid_until": {
+              "kind": "after",
+              "base": {
+                "kind": "now"
+              },
+              "interval": {
+                "days": 25
+              }
+            },
+            "event": {
+              "connect": {
+                "slug": "southwest-dev-conference"
+              }
+            }
+          }
+        }
+      ]
+    },
+    {
+      "op": "sql",
+      "text": "ANALYZE event",
+      "params": []
+    }
+  ]
+}

package/tests/runtime-contract.test.ts

@@ -276,22 +276,47 @@ describe("runtime contract", () => {
     expect(compose).not.toContain("- ./kong.yml:/etc/kong/kong.yml:ro")
   })
 
-  it("devLocal compose omits host-published db and server ports", () => {
+  it("devLocal compose omits the production ports", () => {
     const compose = renderSelfHostCompose(baseConfig, process.cwd(), { devLocal: true })
     expect(compose).not.toContain('"5432:5432"')
     expect(compose).not.toContain('"9999:9999"')
     expect(compose).toContain("${SUPATYPE_KONG_PORT:-18473}:8000")
-    expect(compose).not.toContain("SUPATYPE_DEV_DB_PORT")
   })
 
-  it("devLocal compose publishes db to host when overrides.engine is set", () => {
-    const compose = renderSelfHostCompose(
+  /**
+   * The database is reachable from this machine, always.
+   *
+   * It used to be published in dev only when something was known to need it, which meant a
+   * fresh project had a database nothing on the host could reach: `supatype seed` resolves a
+   * connection string and the engine connects over TCP, so the first seed got ECONNREFUSED
+   * and the remedy was an environment variable nobody had reason to know about.
+   */
+  it("devLocal compose publishes the database on loopback", () => {
+    const compose = renderSelfHostCompose(baseConfig, process.cwd(), { devLocal: true })
+    expect(compose).toContain("127.0.0.1:${SUPATYPE_DEV_DB_PORT:-54329}:5432")
+  })
+
+  /** Loopback, so it is reachable from here and from nowhere else. */
+  it("devLocal never publishes the database beyond this machine", () => {
+    const compose = renderSelfHostCompose(baseConfig, process.cwd(), { devLocal: true })
+    const dbPorts = compose
+      .split("\n")
+      .filter((line) => line.includes(":5432"))
+      .filter((line) => line.trim().startsWith("-"))
+    expect(dbPorts.length).toBeGreaterThan(0)
+    for (const line of dbPorts) expect(line).toContain("127.0.0.1:")
+  })
+
+  it("an engine override no longer decides whether the database is published", () => {
+    const withOverride = renderSelfHostCompose(
       { ...baseConfig, overrides: { engine: "/tmp/supatype-engine" } },
       process.cwd(),
       { devLocal: true },
     )
-    expect(compose).toContain("127.0.0.1:${SUPATYPE_DEV_DB_PORT:-54329}:5432")
-    expect(compose).not.toContain('"5432:5432"')
+    const without = renderSelfHostCompose(baseConfig, process.cwd(), { devLocal: true })
+    expect(withOverride).toContain("127.0.0.1:${SUPATYPE_DEV_DB_PORT:-54329}:5432")
+    expect(without).toContain("127.0.0.1:${SUPATYPE_DEV_DB_PORT:-54329}:5432")
+    expect(withOverride).not.toContain('"5432:5432"')
   })
 
   it("devLocal proxy upstream rewrites localhost to host.docker.internal", () => {