@intentius/chant-lexicon-sql 0.124.45 → 0.124.48

package/src/drizzle.test.ts

@@ -0,0 +1,358 @@
+/**
+ * The Drizzle export (#4401): `renderDrizzle`, `chant sql drizzle`, and the
+ * workspace `generated` entry that keeps the file current.
+ *
+ * Two golden files under `test-fixtures/drizzle/` hold the output for
+ * `examples/postgres-getting-started` and for a schema that uses every
+ * mapping. `drizzle-types.e2e.test.ts` type-checks them against drizzle-orm.
+ * Set `CHANT_UPDATE_GOLDEN=1` to rewrite them after a deliberate change.
+ */
+
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { build } from "@intentius/chant/build";
+import { resolveProjectBuildOptions } from "@intentius/chant/cli/build-options";
+import type { Declarable } from "@intentius/chant/declarable";
+import { readDeclaration } from "@intentius/chant/workspace/declaration";
+import { checkGenerated, gatherGeneratedFacts, WSP_GENERATED_DRIFT, type RenderSkills } from "@intentius/chant/workspace/checks/generated";
+import { workingTree } from "@intentius/chant/workspace/tree";
+import * as ch from "./clickhouse/entities";
+import * as pg from "./postgres/entities";
+import { checkName, chooseName, makeObjectName, referencedColumns } from "./postgres/constraint-names";
+import { DRIZZLE_ORM_CHECKED, DrizzleDialectError, renderDrizzle } from "./drizzle";
+import { runDrizzle } from "./drizzle-command";
+import { sqlPlugin } from "./plugin";
+import { sqlSerializer } from "./serializer";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const lexiconDir = join(here, "..");
+const repoNodeModules = resolve(here, "../../../node_modules");
+const fixtures = join(lexiconDir, "test-fixtures", "drizzle");
+const POSTGRES = { sql: { dialect: "postgres" } };
+
+const entityMap = (o: Record<string, unknown>) => new Map(Object.entries(o)) as Map<string, Declarable>;
+
+/** Compare with a golden file, or rewrite it under CHANT_UPDATE_GOLDEN=1. */
+function golden(file: string, text: string): void {
+  if (process.env.CHANT_UPDATE_GOLDEN === "1") {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, text);
+  }
+  expect(text).toBe(readFileSync(file, "utf8"));
+}
+
+async function exampleEntities(example: string): Promise<Map<string, Declarable>> {
+  const dir = join(lexiconDir, "examples", example);
+  const options = resolveProjectBuildOptions({ config: {}, configDir: dir, plugins: [sqlPlugin], modes: { fold: true, sandbox: false } });
+  const result = await build(join(dir, "src"), [sqlSerializer], undefined, options);
+  expect(result.errors.map(String)).toEqual([]);
+  return result.entities;
+}
+
+describe("the names Postgres gives", () => {
+  test("a name is the table, the columns and a label, cut to 63 bytes by shortening the longer part", () => {
+    expect(makeObjectName("orders", "user_id", "fkey")).toBe("orders_user_id_fkey");
+    expect(makeObjectName("orders", undefined, "pkey")).toBe("orders_pkey");
+    const long = makeObjectName("a_very_long_table_name_for_a_test_of_the_limit", "a_very_long_column_name_that_goes_on", "fkey");
+    expect(long).toHaveLength(63);
+    expect(long.endsWith("_fkey")).toBe(true);
+  });
+
+  test("a taken name gets a number after its label", () => {
+    expect(chooseName("t", "a", "key", new Set(["t_a_key"]))).toBe("t_a_key1");
+    expect(chooseName("t", "a", "key", new Set(["t_a_key", "t_a_key1"]))).toBe("t_a_key2");
+  });
+
+  test("a check is named for the one column it reads, else for the table", () => {
+    const cols = ["n", "ratio", "label"];
+    expect(referencedColumns("n > 0 AND n < 100", cols)).toEqual(["n"]);
+    expect(referencedColumns("length(label) > 2 AND label <> 'n'", cols)).toEqual(["label"]);
+    expect(checkName("t", "n > 0", cols, new Set())).toBe("t_n_check");
+    expect(checkName("t", "n > ratio", cols, new Set())).toBe("t_check");
+    expect(checkName("t", "n > ratio", cols, new Set(["t_check"]))).toBe("t_check1");
+  });
+});
+
+describe("renderDrizzle", () => {
+  test("examples/postgres-getting-started matches its golden file", async () => {
+    const text = renderDrizzle(await exampleEntities("postgres-getting-started"), { config: POSTGRES }).text;
+    expect(text.split("\n")[0]).toContain("Generated by chant");
+    golden(join(fixtures, "postgres-getting-started", "schema.ts"), text);
+  });
+
+  test("the getting-started tables, with the names Postgres gives their constraints", async () => {
+    const r = renderDrizzle(await exampleEntities("postgres-getting-started"), { config: POSTGRES });
+    expect(r.counts).toEqual({ tables: 2, views: 1, enums: 1, sequences: 1 });
+    expect(r.text).toContain('export const app = pgSchema("app");');
+    expect(r.text).toContain('export const orderStatus = app.enum("order_status", ["placed", "paid", "shipped", "cancelled"]);');
+    expect(r.text).toContain('export const invoiceSeq = app.sequence("invoice_seq", { startWith: 1000 });');
+    expect(r.text).toContain('id: bigint({ mode: "number" }).generatedAlwaysAsIdentity().primaryKey(),');
+    expect(r.text).toContain('status: orderStatus().notNull().default("placed"),');
+    expect(r.text).toContain('amount: numeric({ precision: 12, scale: 2 }).notNull(),');
+    expect(r.text).toContain("invoice_no: bigint({ mode: \"number\" }).notNull().default(sql`nextval('app.invoice_seq'::regclass)`),");
+    expect(r.text).toContain('foreignKey({ name: "orders_user_id_fkey", columns: [t.user_id], foreignColumns: [users.id] }).onDelete("cascade"),');
+    expect(r.text).toContain('check("orders_amount_check", sql`amount >= 0`),');
+    expect(r.text).toContain('index("orders_user_id_idx").on(t.user_id, t.placed_at.desc().nullsFirst()),');
+    expect(r.text).toContain('unique("users_email_key").on(t.email),');
+    expect(r.text).toContain('}).existing();');
+    expect(r.skipped).toEqual([]);
+    expect(r.approximated).toEqual(["app.order_totals: order_count, total are expressions, so their types are unknown"]);
+  });
+
+  test("--bigint bigint reads a bigint column as bigint", async () => {
+    const text = renderDrizzle(await exampleEntities("postgres-getting-started"), { config: POSTGRES, bigintMode: "bigint" }).text;
+    expect(text).toContain('id: bigint({ mode: "bigint" }).generatedAlwaysAsIdentity().primaryKey(),');
+  });
+
+  test("every mapping: types, defaults, keys, indexes, and what is left out", () => {
+    const shop = pg.schema`CREATE SCHEMA shop`;
+    const mood = pg.type`CREATE TYPE ${shop}.mood AS ENUM ('sad', 'ok', 'happy')`;
+    const kind = pg.type`CREATE TYPE public.kind AS ENUM ('a', 'b')`;
+    const email = pg.domain`CREATE DOMAIN ${shop}.email AS text CHECK (VALUE LIKE '%@%')`;
+    const tick = pg.sequence`CREATE SEQUENCE ${shop}.tick AS bigint INCREMENT BY 5 MINVALUE 10 MAXVALUE 1000000 START WITH 10 CACHE 2 CYCLE`;
+    const small = pg.sequence`CREATE SEQUENCE ${shop}.small AS integer`;
+    const accounts = pg.table`
+      CREATE TABLE ${shop}.accounts (
+        id bigserial PRIMARY KEY,
+        owner_id bigint,
+        mail ${email} NOT NULL,
+        mood ${mood} DEFAULT 'ok',
+        moods ${mood}[],
+        tags text[] NOT NULL DEFAULT '{}',
+        meta jsonb,
+        raw bytea,
+        search tsvector,
+        token uuid NOT NULL,
+        code varchar(12) NOT NULL DEFAULT 'x',
+        flag char(2),
+        ok boolean NOT NULL DEFAULT false,
+        n integer NOT NULL DEFAULT 0,
+        price numeric NOT NULL DEFAULT 0,
+        ratio real,
+        big double precision,
+        day date,
+        at timestamp(3) without time zone,
+        atz timestamptz DEFAULT now(),
+        t time(2) with time zone,
+        span interval day to second(3),
+        spot point,
+        ip inet,
+        low smallint GENERATED BY DEFAULT AS IDENTITY (START WITH 100 INCREMENT BY 2),
+        area integer GENERATED ALWAYS AS (n * 2) STORED,
+        CONSTRAINT accounts_owner_fk FOREIGN KEY (owner_id) REFERENCES ${shop}.accounts (id) ON UPDATE SET NULL,
+        CHECK (n > 0 AND n < 100),
+        CHECK (n > ratio),
+        UNIQUE (token, code)
+      )`;
+    const links = pg.table`
+      CREATE TABLE ${shop}.links (
+        a bigint NOT NULL REFERENCES ${accounts} (${accounts.columns.id}) ON DELETE RESTRICT,
+        b bigint NOT NULL REFERENCES ${accounts},
+        note text,
+        PRIMARY KEY (a, b)
+      )`;
+    const ca = pg.table`CREATE TABLE ${shop}.ca (id bigint PRIMARY KEY, b_id bigint REFERENCES shop.cb (id))`;
+    const cb = pg.table`CREATE TABLE ${shop}.cb (id bigint PRIMARY KEY, a_id bigint REFERENCES ${ca} (${ca.columns.id}))`;
+    const plain = pg.table`CREATE TABLE public.plain (id integer PRIMARY KEY, kind ${kind} NOT NULL, label text UNIQUE)`;
+    const lowerMail = pg.index`CREATE UNIQUE INDEX accounts_lower_mail ON ${accounts} (lower(mail)) WHERE ok`;
+    const search = pg.index`CREATE INDEX accounts_search ON ${accounts} USING gin (search)`;
+    const atIdx = pg.index`CREATE INDEX accounts_at ON ${accounts} (at DESC NULLS LAST, atz)`;
+    const incl = pg.index`CREATE INDEX accounts_incl ON ${accounts} (mail) INCLUDE (code)`;
+    const opclass = pg.index`CREATE INDEX plain_label ON public.plain (label text_pattern_ops)`;
+    const v = pg.view`CREATE VIEW ${shop}.v AS SELECT a.${accounts.columns.mail}, a.${accounts.columns.mood}, a.${accounts.columns.n} + 1 AS n1 FROM ${accounts} a`;
+    const mv = pg.view`CREATE MATERIALIZED VIEW ${shop}.mv AS SELECT l.${links.columns.a} FROM ${links} l`;
+    const fn = pg.func`CREATE FUNCTION ${shop}.f() RETURNS integer LANGUAGE sql AS 'select 1'`;
+    const r = renderDrizzle(entityMap({ shop, mood, kind, email, tick, small, accounts, links, ca, cb, plain, lowerMail, search, atIdx, incl, opclass, v, mv, fn }), { config: POSTGRES });
+
+    const t = r.text;
+    // Types.
+    expect(t).toContain('id: bigserial({ mode: "number" }).primaryKey(),');
+    expect(t).toContain("mail: shop_emailType().notNull(),");
+    expect(t).toContain('const shop_emailType = customType<{ data: string }>({ dataType: () => "shop.email" });');
+    expect(t).toContain('const byteaType = customType<{ data: Uint8Array }>({ dataType: () => "bytea" });');
+    expect(t).toContain('const tsvectorType = customType<{ data: string }>({ dataType: () => "tsvector" });');
+    expect(t).toContain('mood: mood().default("ok"),');
+    expect(t).toContain("moods: mood().array(),");
+    expect(t).toContain('kind: kind().notNull(),');
+    expect(t).toContain("tags: text().array().notNull().default(sql`'{}'`),");
+    expect(t).toContain('code: varchar({ length: 12 }).notNull().default("x"),');
+    expect(t).toContain("flag: char({ length: 2 }),");
+    expect(t).toContain("ok: boolean().notNull().default(false),");
+    expect(t).toContain("n: integer().notNull().default(0),");
+    expect(t).toContain("price: numeric().notNull().default(sql`0`),");
+    expect(t).toContain("at: timestamp({ precision: 3 }),");
+    expect(t).toContain("atz: timestamp({ withTimezone: true }).default(sql`now()`),");
+    expect(t).toContain("t: time({ precision: 2, withTimezone: true }),");
+    expect(t).toContain('span: interval({ fields: "day to second", precision: 3 }),');
+    expect(t).toContain('spot: point({ mode: "xy" }),');
+    expect(t).toContain("low: smallint().generatedByDefaultAsIdentity({ startWith: 100, increment: 2 }).notNull(),");
+    expect(t).toContain("area: integer().generatedAlwaysAs(sql`n * 2`),");
+    // Keys, in the order Drizzle's extra config takes them.
+    expect(t).toContain('unique("accounts_token_code_key").on(t.token, t.code),');
+    expect(t).toContain('check("accounts_n_check", sql`n > 0 AND n < 100`),');
+    expect(t).toContain('check("accounts_check", sql`n > ratio`),');
+    expect(t).toContain('foreignKey({ name: "accounts_owner_fk", columns: [t.owner_id], foreignColumns: [t.id] }).onUpdate("set null"),');
+    expect(t).toContain('primaryKey({ name: "links_pkey", columns: [t.a, t.b] }),');
+    expect(t).toContain('foreignKey({ name: "links_a_fkey", columns: [t.a], foreignColumns: [accounts.id] }).onDelete("restrict"),');
+    expect(t).toContain('foreignKey({ name: "links_b_fkey", columns: [t.b], foreignColumns: [accounts.id] }),');
+    expect(t).toContain('unique("plain_label_key").on(t.label),');
+    // Two tables that reference each other need the callback's return type, so tsc can infer both.
+    expect(t).toContain('export const ca = shop.table("ca", {');
+    expect(t).toContain("}, (t): PgTableExtraConfigValue[] => [");
+    expect(t).toContain('import type { PgTableExtraConfigValue } from "drizzle-orm/pg-core";');
+    // Indexes.
+    expect(t).toContain('index("accounts_at").on(t.at.desc().nullsLast(), t.atz),');
+    expect(t).toContain("uniqueIndex(\"accounts_lower_mail\").on(sql`lower(mail)`).where(sql`ok`),");
+    expect(t).toContain('index("accounts_search").using("gin", t.search),');
+    // Schemas, sequences, views.
+    expect(t).toContain('export const kind = pgEnum("kind", ["a", "b"]);');
+    expect(t).toContain('export const plain = pgTable("plain", {');
+    expect(t).toContain('export const tick = shop.sequence("tick", { increment: 5, minValue: 10, maxValue: 1000000, startWith: 10, cache: 2, cycle: true });');
+    expect(t).toContain('export const mv = shop.materializedView("mv", {');
+    expect(t).toContain("  n1: unknownColumn(),");
+    expect(t).not.toContain("pgSchema(\"public\")");
+
+    // What it leaves out, by kind, with the reason; and the header says so.
+    const skipped = Object.fromEntries(r.skipped.map((s) => [`${s.kind}: ${s.names.join(", ")}`, s.reason]));
+    expect(Object.keys(skipped).sort()).toEqual([
+      "Postgres::Domain: shop.email",
+      "Postgres::Function: shop.f",
+      "Postgres::Index: public.plain_label",
+      "Postgres::Index: shop.accounts_incl",
+      "Postgres::Sequence: shop.small",
+    ]);
+    expect(t).toContain("//   Postgres::Function: shop.f (Drizzle has no routines)");
+    golden(join(fixtures, "mappings", "schema.ts"), t);
+  });
+
+  test("a ClickHouse build is refused, since Drizzle has no ClickHouse dialect", () => {
+    const db = ch.database`CREATE DATABASE shop`;
+    const e = ch.table`CREATE TABLE ${db}.e (k String) ENGINE = MergeTree ORDER BY k`;
+    expect(() => renderDrizzle(entityMap({ db, e }))).toThrow(DrizzleDialectError);
+    expect(() => renderDrizzle(entityMap({ db, e }))).toThrow(/Drizzle has no clickhouse dialect/);
+  });
+
+  test("with nothing declared, a module that exports nothing", () => {
+    expect(renderDrizzle(new Map(), { config: POSTGRES }).text).toMatch(/\nexport \{\};\n$/);
+  });
+
+  test("it names the drizzle-orm version it was checked against", () => {
+    expect(DRIZZLE_ORM_CHECKED).toMatch(/^\d+\.\d+\.\d+$/);
+    expect(renderDrizzle(new Map(), { config: POSTGRES }).text).toContain(`drizzle-orm ${DRIZZLE_ORM_CHECKED}`);
+  });
+});
+
+describe("chant sql drizzle, and the workspace check that keeps its file current", () => {
+  let root: string;
+  let cwd: string;
+  let errors: string[];
+  let logs: string[];
+
+  const schema = (amount: string) =>
+    'import { schema, table } from "@intentius/chant-lexicon-sql/postgres";\n' +
+    "export const shop = schema`CREATE SCHEMA shop`;\n" +
+    "export const orders = table`CREATE TABLE ${shop}.orders (id bigint PRIMARY KEY, " +
+    `amount ${amount})\`;\n`;
+  const write = (amount: string) => writeFileSync(join(root, "member", "src", "schema.ts"), schema(amount));
+  const drizzle = async (...args: string[]) => {
+    process.chdir(join(root, "member"));
+    return runDrizzle({ verb: "drizzle", rawArgs: args });
+  };
+
+  beforeEach(() => {
+    cwd = process.cwd();
+    root = realpathSync(mkdtempSync(join(tmpdir(), "chant-4401-")));
+    mkdirSync(join(root, "member", "src"), { recursive: true });
+    symlinkSync(repoNodeModules, join(root, "member", "node_modules"), "dir");
+    writeFileSync(join(root, "member", "chant.config.json"), JSON.stringify({ lexicons: ["sql"], sourceDir: "src", sql: { dialect: "postgres" } }));
+    write("numeric(12,2)");
+    errors = [];
+    logs = [];
+    vi.spyOn(console, "error").mockImplementation((m: unknown) => void errors.push(String(m)));
+    vi.spyOn(console, "log").mockImplementation((m: unknown) => void logs.push(String(m)));
+    process.env.NO_COLOR = "1";
+  });
+
+  afterEach(() => {
+    process.chdir(cwd);
+    vi.restoreAllMocks();
+    delete process.env.NO_COLOR;
+  });
+
+  test("writes drizzle-schema.ts in the project, outside the source directory, and --check follows the declaration", async () => {
+    expect(await drizzle()).toBe(0);
+    const file = join(root, "member", "drizzle-schema.ts");
+    const written = readFileSync(file, "utf8");
+    expect(written).toContain('export const orders = shop.table("orders", {');
+    expect(written).toContain("amount: numeric({ precision: 12, scale: 2 }),");
+    expect(logs.join("\n")).toContain("wrote drizzle-schema.ts: 1 table, 0 views, 0 enums, 0 sequences");
+    expect(existsSync(join(root, "member", "src", "drizzle-schema.ts"))).toBe(false);
+
+    expect(await drizzle("--check")).toBe(0);
+    write("bigint");
+    expect(await drizzle("--check")).toBe(1);
+    expect(errors.join("\n")).toContain("drizzle-schema.ts differs");
+    expect(readFileSync(file, "utf8")).toBe(written);
+  }, 30_000);
+
+  test("--check on a missing file exits 1 and writes nothing; -o and --output write elsewhere", async () => {
+    expect(await drizzle("--check")).toBe(1);
+    expect(errors.join("\n")).toContain("drizzle-schema.ts does not exist");
+    expect(existsSync(join(root, "member", "drizzle-schema.ts"))).toBe(false);
+    expect(await drizzle("-o", "db/schema.ts")).toBe(0);
+    expect(await drizzle("--check", "--output=db/schema.ts")).toBe(0);
+    expect(existsSync(join(root, "member", "db", "schema.ts"))).toBe(true);
+  }, 30_000);
+
+  test("a bad argument and a ClickHouse project exit 1", async () => {
+    expect(await drizzle("--bogus")).toBe(1);
+    expect(await drizzle("--bigint", "string")).toBe(1);
+    writeFileSync(join(root, "member", "chant.config.json"), JSON.stringify({ lexicons: ["sql"], sourceDir: "src", sql: { dialect: "clickhouse" } }));
+    writeFileSync(join(root, "member", "src", "schema.ts"), 'import { database, table } from "@intentius/chant-lexicon-sql/clickhouse";\nexport const shop = database`CREATE DATABASE shop`;\nexport const e = table`CREATE TABLE ${shop}.e (k String) ENGINE = MergeTree ORDER BY k`;\n');
+    expect(await drizzle()).toBe(1);
+    expect(errors.join("\n")).toContain("Drizzle has no clickhouse dialect");
+  }, 30_000);
+
+  test("changing a column without regenerating fails the workspace's generated-file check", async () => {
+    writeFileSync(
+      join(root, "chant.workspace.json"),
+      JSON.stringify({
+        name: "shop",
+        schema: 1,
+        members: [{ name: "member", dir: "member", kind: "chant", generated: [{ path: "drizzle-schema.ts", generator: "chant sql drizzle --output drizzle-schema.ts", sources: ["member/src"] }] }],
+      }),
+    );
+    expect(await drizzle()).toBe(0);
+
+    // The generator the check runs is `chant sql drizzle --output <temp>`; it is a process, so the
+    // text it would write for the declaration as it now stands is rendered first and handed to a stand-in.
+    const standIn = async (): Promise<GeneratorRun> => {
+      expect(await drizzle("--output", "next.ts")).toBe(0);
+      const text = readFileSync(join(root, "member", "next.ts"), "utf8");
+      return ({ argv }) => {
+        expect(argv.slice(0, 4)).toEqual(["chant", "sql", "drizzle", "--output"]);
+        writeFileSync(argv[4]!, text);
+        return { ok: true };
+      };
+    };
+    type GeneratorRun = NonNullable<Parameters<typeof gatherGeneratedFacts>[2]>["runGenerator"];
+    const noSkills: RenderSkills = async () => ({ status: "rendered", files: new Map() });
+    const findings = async (runGenerator: GeneratorRun) => {
+      const facts = await gatherGeneratedFacts(root, readDeclaration(workingTree(root)), { runGenerators: true, renderSkills: noSkills, runGenerator });
+      return checkGenerated(facts);
+    };
+
+    expect(await findings(await standIn())).toEqual([]);
+
+    write("bigint");
+    const stale = await findings(await standIn());
+    expect(stale.map((f) => [f.id, f.severity, f.path])).toEqual([[WSP_GENERATED_DRIFT, "error", "member/drizzle-schema.ts"]]);
+    expect(stale[0]!.message).toContain("differs from what `chant sql drizzle --output drizzle-schema.ts` writes");
+
+    expect(await drizzle()).toBe(0);
+    expect(await findings(await standIn())).toEqual([]);
+  }, 60_000);
+});