@intentius/chant-lexicon-sql 0.124.46 → 0.124.48

package/src/migrate/from-postgres/types.ts

@@ -0,0 +1,236 @@
+/**
+ * The Postgres to ClickHouse type map (#4399).
+ *
+ * A type either maps with no judgment (`note` absent) or carries a `note`
+ * naming what the map could not keep. Only the first kind is mechanical: the
+ * translator writes no diagnostic for it. A type this file does not know (an
+ * enum, a domain, an extension type) maps to `String` with a note, because a
+ * mirror still has to hold the value.
+ *
+ * Source types and defaults are from the Postgres data types chapter
+ * (https://www.postgresql.org/docs/current/datatype.html): `timestamp` and
+ * `time` take a precision of 0 to 6 and default to microseconds, `numeric`
+ * with no precision holds any value, `money` is a fixed-point type with a
+ * locale-set scale, `float(n)` is `real` for n up to 24 and `double
+ * precision` above.
+ *
+ * Target types are ClickHouse types of the pinned server (`../../spec/pin.ts`);
+ * `types.test.ts` checks every family this file writes against the generated
+ * catalog.
+ */
+
+export interface MappedType {
+  ok: true;
+  /** The ClickHouse type, before `Nullable`. */
+  type: string;
+  /** The declared maximum length of a character type, when it has one. */
+  maxLength?: number;
+  /** The column is `serial`, `bigserial` or `smallserial`: an integer with a sequence behind it. */
+  serial?: boolean;
+  /** The column is an array. ClickHouse cannot make an `Array` `Nullable`. */
+  array?: boolean;
+  /** Present when the map is a judgment: what was lost or chosen. */
+  note?: { message: string; evidence: string[] };
+}
+
+export type TypeMapping = MappedType;
+
+interface ParsedType {
+  /** Lower case words of the type, schema prefix and quotes removed: `timestamp with time zone`. */
+  base: string;
+  args: number[];
+  /** Array dimensions. */
+  dims: number;
+  raw: string;
+}
+
+/** Split a column type as written into its words, its parenthesised arguments and its array dimensions. */
+export function parseType(text: string): ParsedType {
+  let rest = text.trim();
+  let dims = 0;
+  for (;;) {
+    const m = /\s*\[\s*\d*\s*\]\s*$/.exec(rest);
+    if (!m) break;
+    rest = rest.slice(0, m.index);
+    dims++;
+  }
+  const arrayWord = /\s+array(\s*\[\s*\d*\s*\])?$/i.exec(rest);
+  if (arrayWord) {
+    rest = rest.slice(0, arrayWord.index);
+    dims++;
+  }
+  const args: number[] = [];
+  rest = rest.replace(/\(([^)]*)\)/g, (_all, inner: string) => {
+    for (const part of inner.split(",")) {
+      const n = Number(part.trim());
+      if (Number.isFinite(n)) args.push(n);
+    }
+    return " ";
+  });
+  const base = rest
+    .replace(/"/g, "")
+    .replace(/^pg_catalog\./i, "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .toLowerCase();
+  return { base, args, dims, raw: text.trim() };
+}
+
+const STRING_NOTE = (what: string, evidence: string[]) => ({ message: `${what} is read as String.`, evidence });
+
+function mapScalar(t: ParsedType): MappedType {
+  const { base, args } = t;
+  switch (base) {
+    case "smallint":
+    case "int2":
+      return { ok: true, type: "Int16" };
+    case "integer":
+    case "int":
+    case "int4":
+      return { ok: true, type: "Int32" };
+    case "bigint":
+    case "int8":
+      return { ok: true, type: "Int64" };
+    case "smallserial":
+    case "serial2":
+      return { ok: true, type: "Int16", serial: true };
+    case "serial":
+    case "serial4":
+      return { ok: true, type: "Int32", serial: true };
+    case "bigserial":
+    case "serial8":
+      return { ok: true, type: "Int64", serial: true };
+    case "real":
+    case "float4":
+      return { ok: true, type: "Float32" };
+    case "double precision":
+    case "float8":
+      return { ok: true, type: "Float64" };
+    case "float":
+      return { ok: true, type: (args[0] ?? 53) <= 24 ? "Float32" : "Float64" };
+    case "numeric":
+    case "decimal": {
+      if (args.length === 0) {
+        return {
+          ok: true,
+          type: "Decimal(38, 18)",
+          note: {
+            message: "numeric with no precision is read as Decimal(38, 18).",
+            evidence: ["Postgres stores up to 131072 digits before the point and 16383 after; a ClickHouse Decimal has a fixed precision and scale", "a value that does not fit fails the insert"],
+          },
+        };
+      }
+      const p = args[0]!;
+      const s = args[1] ?? 0;
+      if (p > 76 || s < 0 || s > p) {
+        return {
+          ok: true,
+          type: "Decimal(76, 38)",
+          note: { message: `numeric(${String(p)}, ${String(s)}) is read as Decimal(76, 38).`, evidence: ["ClickHouse Decimal holds at most 76 digits"] },
+        };
+      }
+      return { ok: true, type: `Decimal(${String(p)}, ${String(s)})` };
+    }
+    case "money":
+      return {
+        ok: true,
+        type: "Decimal(19, 2)",
+        note: { message: "money is read as Decimal(19, 2).", evidence: ["money takes its scale from the lc_monetary setting of the source server, and two decimals is the common one"] },
+      };
+    case "boolean":
+    case "bool":
+      return { ok: true, type: "Bool" };
+    case "text":
+    case "varchar":
+    case "character varying":
+    case "name":
+    case "citext":
+      return { ok: true, type: "String", ...(args[0] !== undefined ? { maxLength: args[0] } : {}) };
+    case "char":
+    case "character":
+    case "bpchar":
+      return {
+        ok: true,
+        type: "String",
+        ...(args[0] !== undefined ? { maxLength: args[0] } : {}),
+        ...(args[0] !== undefined && args[0] > 1 ? { note: STRING_NOTE("char(n)", ["Postgres pads a char(n) value with spaces to n characters; a String keeps the value as it is loaded"]) } : {}),
+      };
+    case "bytea":
+      return { ok: true, type: "String" };
+    case "uuid":
+      return { ok: true, type: "UUID" };
+    case "date":
+      return { ok: true, type: "Date32" };
+    case "time":
+    case "time without time zone":
+      return { ok: true, type: `Time64(${String(args[0] ?? 6)})` };
+    case "timetz":
+    case "time with time zone":
+      return { ok: true, type: "String", note: STRING_NOTE("timetz", ["a time of day with an offset has no ClickHouse type; the offset is kept in the text"]) };
+    case "timestamp":
+    case "timestamp without time zone":
+      return { ok: true, type: `DateTime64(${String(args[0] ?? 6)})` };
+    case "timestamptz":
+    case "timestamp with time zone":
+      return { ok: true, type: `DateTime64(${String(args[0] ?? 6)}, 'UTC')` };
+    case "interval":
+      return { ok: true, type: "String", note: STRING_NOTE("interval", ["a ClickHouse Interval type cannot be stored in a column", "the value is kept as Postgres prints it"]) };
+    case "json":
+    case "jsonb":
+      return { ok: true, type: "JSON" };
+    case "oid":
+      return { ok: true, type: "UInt32" };
+    case "inet":
+    case "cidr":
+      return {
+        ok: true,
+        type: "IPv6",
+        note: { message: `${base} is read as IPv6.`, evidence: ["an IPv6 column holds an IPv4 address in its mapped form", "the prefix length of a network is not kept"] },
+      };
+    case "xml":
+    case "macaddr":
+    case "macaddr8":
+    case "tsvector":
+    case "tsquery":
+    case "bit":
+    case "bit varying":
+    case "varbit":
+    case "point":
+    case "line":
+    case "lseg":
+    case "box":
+    case "path":
+    case "polygon":
+    case "circle":
+      return { ok: true, type: "String", note: STRING_NOTE(base, [`ClickHouse has no ${base} type`, "the value is kept as Postgres prints it"]) };
+    default:
+      return {
+        ok: true,
+        type: "String",
+        note: STRING_NOTE(t.raw, [`${t.raw} is not a built-in type chant maps (an enum, a domain, a composite or an extension type)`, "the value is kept as Postgres prints it; an enum could be an Enum8 or Enum16 once its labels are settled"]),
+      };
+  }
+}
+
+/** Map a column type as the declaration wrote it. */
+export function mapPostgresType(text: string): TypeMapping {
+  const t = parseType(text);
+  const inner = mapScalar(t);
+  if (t.dims === 0) return inner;
+  let type = inner.type;
+  for (let i = 0; i < t.dims; i++) type = `Array(${type})`;
+  return {
+    ok: true,
+    type,
+    array: true,
+    ...(inner.serial ? { serial: true } : {}),
+    note: {
+      message: `${t.raw} is read as ${type}.`,
+      evidence: [
+        ...(inner.note ? [inner.note.message] : []),
+        "ClickHouse cannot make an Array Nullable, so a NULL array is stored as an empty one",
+        "Postgres does not enforce the declared dimensions or lengths of an array",
+      ],
+    },
+  };
+}

package/src/migrate/from-postgres/validate.e2e.test.ts

@@ -0,0 +1,44 @@
+/**
+ * Fourth Done-when box of #4399: `--validate` creates the translated example
+ * on the pinned ClickHouse server, as a bare table and as a `CdcMirror` call
+ * with its view, and reports a statement the server refuses by name.
+ *
+ * Needs Docker; skips cleanly without it. One throwaway container per call,
+ * removed afterwards even on failure. Written, not run, in the session that
+ * added it (no e2e and no Docker, by the brief).
+ */
+
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import { dockerAvailable } from "../../clickhouse/container";
+import type { Declarable } from "@intentius/chant/declarable";
+import { transform } from "./index";
+import * as source from "../../../examples/postgres-cdc-source/src/shop";
+import { translatePostgres } from "./translate";
+
+const enabled = await dockerAvailable();
+const sourceFile = join(import.meta.dirname, "../../../examples/postgres-cdc-source");
+
+describe.skipIf(!enabled)("the emulator accepts the translated example", () => {
+  test.each([
+    ["bare tables", false],
+    ["CdcMirror calls and their views", true],
+  ])("every statement of %s is created", async (_name, useComposites) => {
+    const r = await transform("", { emit: "ts", useComposites, sourceFile });
+    const found = await r.validate!();
+    expect(found, found.map((d) => String(d.message)).join("\n")).toEqual([]);
+  }, 300_000);
+
+  test("a statement the server refuses is an error naming the table", async () => {
+    // A key column the table does not have is caught by the server, not by the translator.
+    const entities = new Map(Object.entries(source) as Array<[string, Declarable]>);
+    const t = translatePostgres(entities, { composite: false });
+    t.mirrors[0]!.primaryKey = ["no_such_column"];
+    const { validateOnEmulator } = await import("../../sqlserver/validate");
+    const { objectsToIR } = await import("../../clickhouse/import/ir");
+    const { mirrorObjects } = await import("./emit");
+    const found = await validateOnEmulator(objectsToIR(mirrorObjects(t.mirrors, false)));
+    expect(found).toHaveLength(1);
+    expect(found[0]).toMatchObject({ ruleId: "SQLRV012", severity: "error", entity: "customers" });
+  }, 300_000);
+});

package/src/migrate/from-postgres/workspace.e2e.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Third Done-when box of #4399, through `chant workspace check`: a workspace
+ * with the Postgres member `db` (the DDL of `examples/postgres-cdc-source`)
+ * and the ClickHouse member `mirror`. `chant migrate` writes the mirror and its
+ * links; dropping a mirrored column from the Postgres side then fails the
+ * check, naming the mirror, until the mirror follows.
+ *
+ * The unit version of the same facts, on the example's own declarations, is
+ * `example.test.ts`. This one reads a real declaration file and folds the
+ * member's `.sql` file the way `chant workspace check` does, so it is e2e
+ * under the 5 s unit budget (#2817). Written, not run, in the session that
+ * added it.
+ */
+
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { afterAll, afterEach, describe, expect, test, vi } from "vitest";
+import { runDeclarationChecks } from "@intentius/chant/workspace/checks";
+import { parseArgs } from "@intentius/chant/cli/parse-args";
+import { runMigrate } from "@intentius/chant/cli/handlers/migrate";
+
+const scratch: string[] = [];
+afterAll(() => {
+  for (const d of scratch) rmSync(d, { recursive: true, force: true });
+});
+afterEach(() => vi.restoreAllMocks());
+
+function repo(files: Record<string, string>): string {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "chant-4399-")));
+  scratch.push(root);
+  execFileSync("git", ["init", "-q"], { cwd: root });
+  for (const [path, text] of Object.entries(files)) {
+    mkdirSync(dirname(join(root, path)), { recursive: true });
+    writeFileSync(join(root, path), text);
+  }
+  return root;
+}
+
+const schema = (email: string) => `CREATE SCHEMA shop;
+
+CREATE TABLE shop.customers (
+  id         bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+${email}  country    text NOT NULL,
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+
+CREATE TABLE shop.orders (
+  id          bigint GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
+  customer_id bigint NOT NULL REFERENCES shop.customers (id),
+  total       numeric(12, 2) NOT NULL,
+  status      text NOT NULL,
+  placed_at   timestamptz NOT NULL DEFAULT now()
+);
+`;
+
+const EMAIL = "  email      text NOT NULL,\n";
+const config = (dialect: string) => `import type { ChantConfig } from "@intentius/chant";\nexport default { lexicons: ["sql"], sql: { dialect: "${dialect}" } } satisfies ChantConfig;\n`;
+
+function shop(): string {
+  return repo({
+    "chant.workspace.json": `${JSON.stringify({ name: "shop", schema: 1, members: [{ name: "db", dir: "db", kind: "chant" }, { name: "mirror", dir: "mirror", kind: "chant" }] }, null, 2)}\n`,
+    "db/chant.config.ts": config("postgres"),
+    "db/schema.sql": schema(EMAIL),
+    "mirror/chant.config.ts": config("clickhouse"),
+  });
+}
+
+async function migrate(root: string): Promise<number> {
+  vi.spyOn(console, "error").mockImplementation(() => {});
+  return runMigrate({
+    args: parseArgs(["migrate", join(root, "db/schema.sql"), "--from", "sql/postgres", "--to", "sql/clickhouse", "--use-composites", "--output", join(root, "mirror/src/mirrors.ts")]),
+    plugins: [],
+    serializers: [],
+  } as never);
+}
+
+describe("chant migrate links the mirror to the Postgres member, and chant workspace check holds them", () => {
+  test("the links resolve; dropping a mirrored column fails the check naming the mirror; unlinking it and migrating again passes", async () => {
+    const root = shop();
+    expect(await migrate(root)).toBe(0);
+    const declared = JSON.parse(readFileSync(join(root, "chant.workspace.json"), "utf8")) as { members: Array<{ name: string; links?: Array<{ member: string; output: string }> }> };
+    const links = declared.members.find((m) => m.name === "mirror")!.links!;
+    expect(links).toHaveLength(9);
+    expect(links).toContainEqual({ member: "db", output: "shop.customers.email" });
+
+    const ok = await runDeclarationChecks(root);
+    expect(ok.diagnostics.filter((d) => d.ruleId.startsWith("WSP09"))).toEqual([]);
+    expect(ok.links.filter((r) => r.origin === "declared" && r.status === "resolved")).toHaveLength(9);
+
+    // The Postgres side drops email.
+    writeFileSync(join(root, "db/schema.sql"), schema(""));
+    const failed = await runDeclarationChecks(root);
+    expect(failed.ok).toBe(false);
+    expect(failed.diagnostics.map((d) => `${d.ruleId}:${d.entity}`)).toEqual(["WSP093:mirror"]);
+    expect(failed.diagnostics[0]!.message).toContain("db has no output shop.customers.email");
+
+    // The mirror follows: the link goes with the column, and migrating again adds nothing it should not.
+    const edited = { ...declared, members: declared.members.map((m) => (m.name === "mirror" ? { ...m, links: m.links!.filter((l) => l.output !== "shop.customers.email") } : m)) };
+    writeFileSync(join(root, "chant.workspace.json"), `${JSON.stringify(edited, null, 2)}\n`);
+    expect(await migrate(root)).toBe(0);
+    const after = await runDeclarationChecks(root);
+    expect(after.diagnostics.filter((d) => d.ruleId.startsWith("WSP09"))).toEqual([]);
+  });
+
+  test("a renamed column with a previously hint tells the mirror where it went", async () => {
+    const root = shop();
+    await migrate(root);
+    writeFileSync(join(root, "db/schema.sql"), schema("  email_hash text NOT NULL, -- previously: email\n"));
+    const report = await runDeclarationChecks(root);
+    expect(report.diagnostics[0]!.message).toContain("it was renamed to shop.customers.email_hash, so link to that instead");
+  });
+});

package/src/migration-replay.e2e.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Goose and golang-migrate directories replayed into a Postgres emulator
+ * (#4400): the replay records the tables and columns, a dbt member links to
+ * one of them, `chant workspace check` passes, and a migration that drops the
+ * linked column fails it after the next replay. Also the `--check` of the
+ * recorded file.
+ *
+ * Needs Docker; skips cleanly without it. One throwaway `postgres` container,
+ * a fresh database for each replay. Not part of the unit suite.
+ */
+
+import { spawnSync } from "node:child_process";
+import { readFileSync, symlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { cleanScratch, declaration, REPO, repo } from "../../../packages/core/src/workspace/__fixtures__/contract-repo";
+import { workingTree } from "@intentius/chant/workspace/tree";
+import { REPLAY_FILE } from "@intentius/chant/workspace/migration-dirs";
+import { dockerAvailable, startTestPostgres, type TestPostgres } from "./postgres/testing/server";
+import { renderSnapshot, replayDirectory, type ReplayDb, type ReplayKind } from "./migration-replay";
+
+const enabled = await dockerAvailable();
+const TIMEOUT = 600_000;
+const LEXICON = "@intentius/chant-lexicon-sql";
+const VERSION = (JSON.parse(readFileSync(join(REPO, "lexicons", "sql", "package.json"), "utf-8")) as { version: string }).version;
+let server: TestPostgres | undefined;
+let databases = 0;
+
+beforeAll(async () => {
+  if (enabled) server = await startTestPostgres();
+}, TIMEOUT);
+
+afterAll(async () => {
+  await server?.stop();
+  cleanScratch();
+});
+
+function chant(cwd: string, ...argv: string[]) {
+  return spawnSync(process.execPath, ["--import", pathToFileURL(join(REPO, "node_modules/tsx/dist/loader.mjs")).href, join(REPO, "packages/core/src/cli/main.ts"), ...argv], {
+    cwd,
+    encoding: "utf-8",
+    timeout: TIMEOUT,
+    env: { ...process.env, NO_COLOR: "1", TSX_DISABLE_CACHE: "1" },
+  });
+}
+
+/** An empty database on the emulator, as a {@link ReplayDb}. */
+async function emptyDb(): Promise<ReplayDb> {
+  const admin = await server!.connect();
+  const name = `replay_${String((databases += 1))}`;
+  await admin.query(`CREATE DATABASE ${name}`);
+  await admin.end();
+  const client = await server!.connect(name);
+  return { dialect: "postgres", run: async (sql) => void (await client.query(sql)), rows: (sql) => client.query(sql), close: () => client.end() };
+}
+
+const SOURCES = "version: 2\n\nsources:\n  - name: shop\n    schema: public\n    tables:\n      - name: orders\n        columns:\n          - name: id\n          - name: customer_id\n";
+
+const FIXTURES: Record<"goose" | "golang-migrate", { first: Record<string, string>; drop: Record<string, string> }> = {
+  goose: {
+    first: {
+      "db/00001_orders.sql": "-- +goose Up\nCREATE TABLE orders (id bigint PRIMARY KEY, customer_id bigint NOT NULL);\n-- +goose Down\nDROP TABLE orders;\n",
+    },
+    drop: { "db/00002_drop_customer.sql": "-- +goose Up\nALTER TABLE orders DROP COLUMN customer_id;\n-- +goose Down\nALTER TABLE orders ADD COLUMN customer_id bigint;\n" },
+  },
+  "golang-migrate": {
+    first: {
+      "db/1_orders.up.sql": "CREATE TABLE orders (id bigint PRIMARY KEY, customer_id bigint NOT NULL);\n",
+      "db/1_orders.down.sql": "DROP TABLE orders;\n",
+    },
+    drop: { "db/2_drop_customer.up.sql": "ALTER TABLE orders DROP COLUMN customer_id;\n", "db/2_drop_customer.down.sql": "ALTER TABLE orders ADD COLUMN customer_id bigint;\n" },
+  },
+};
+
+async function workspace(kind: "goose" | "golang-migrate", extra: Record<string, string>): Promise<string> {
+  const root = repo({
+    "chant.workspace.json": declaration(
+      [
+        { name: "db", dir: "db", kind },
+        { name: "analytics", dir: "analytics", kind: "dbt", fields: { sqlMember: "db" } },
+      ],
+      { pins: [{ package: LEXICON, version: VERSION }] },
+    ),
+    "analytics/dbt_project.yml": "name: analytics\nversion: '1.0'\nprofile: analytics\n",
+    "analytics/models/staging/sources.yml": SOURCES,
+    ".gitignore": "node_modules\n",
+    ...FIXTURES[kind].first,
+    ...extra,
+  });
+  symlinkSync(join(REPO, "node_modules"), join(root, "node_modules"), "dir");
+  return root;
+}
+
+/** Replay `root/db` into a fresh database and write the snapshot beside the migrations. */
+async function record(root: string, kind: ReplayKind): Promise<void> {
+  const db = await emptyDb();
+  try {
+    const snapshot = await replayDirectory(db, kind, workingTree(join(root, "db")), "");
+    writeFileSync(join(root, "db", REPLAY_FILE), renderSnapshot(snapshot));
+  } finally {
+    await db.close();
+  }
+}
+
+describe.skipIf(!enabled)("migration directories replayed into the emulator (#4400)", () => {
+  for (const kind of ["goose", "golang-migrate"] as const) {
+    test(
+      `${kind}: the replayed columns are outputs a dbt member links to, and a migration that drops a linked column fails workspace check`,
+      async () => {
+        const ok = await workspace(kind, {});
+        await record(ok, kind);
+        expect(JSON.parse(readFileSync(join(ok, "db", REPLAY_FILE), "utf-8")).outputs).toEqual(["public.orders", "public.orders.id", "public.orders.customer_id"]);
+        const passed = chant(ok, "workspace", "check");
+        expect(passed.status, passed.stdout + passed.stderr).toBe(0);
+
+        const dropped = await workspace(kind, FIXTURES[kind].drop);
+        await record(dropped, kind);
+        const failed = chant(dropped, "workspace", "check");
+        expect(failed.status).toBe(1);
+        const text = failed.stdout + failed.stderr;
+        expect(text).toContain("analytics/models/staging/sources.yml:10");
+        expect(text).toContain("WSP093");
+        expect(text).toMatch(/link to db output public\.orders\.customer_id .*does not resolve/);
+      },
+      TIMEOUT,
+    );
+
+    test(
+      `${kind}: a migration added after the replay leaves the outputs unresolved until the replay runs again`,
+      async () => {
+        const root = await workspace(kind, {});
+        await record(root, kind);
+        for (const [path, text] of Object.entries(FIXTURES[kind].drop)) writeFileSync(join(root, path), text);
+        const stale = chant(root, "workspace", "check");
+        expect(stale.stdout + stale.stderr).toContain("changed since chant.replay.json was recorded");
+      },
+      TIMEOUT,
+    );
+  }
+
+  test(
+    "a migration that fails stops the replay and names its file",
+    async () => {
+      const root = await workspace("golang-migrate", { "db/2_bad.up.sql": "ALTER TABLE nowhere ADD COLUMN x int;\n" });
+      const db = await emptyDb();
+      try {
+        await expect(replayDirectory(db, "golang-migrate", workingTree(join(root, "db")), "")).rejects.toThrow(/2_bad\.up\.sql: statement 1 failed/);
+      } finally {
+        await db.close();
+      }
+    },
+    TIMEOUT,
+  );
+});