@intentius/chant-lexicon-sql 0.124.19 → 0.124.22

package/src/postgres/live/describe-resources.ts

@@ -41,9 +41,17 @@ interface Bound {
  */
 export function declaredAddress(entity: { type: string; props: Record<string, unknown> }, defaultSchema: string): { schema?: string; name: string; signature?: string } {
   const name = String(entity.props.name ?? "");
-  if (entity.type === POSTGRES_ENTITY_TYPES.schema || entity.type === POSTGRES_ENTITY_TYPES.extension || entity.type === POSTGRES_ENTITY_TYPES.role) return { name };
+  if (entity.type === POSTGRES_ENTITY_TYPES.schema || entity.type === POSTGRES_ENTITY_TYPES.extension || entity.type === POSTGRES_ENTITY_TYPES.role || entity.type === POSTGRES_ENTITY_TYPES.eventTrigger) return { name };
+  // A cast is named by its two types, as the catalog prints them.
+  if (entity.type === POSTGRES_ENTITY_TYPES.cast) return { name: canonicalPgObject(entity.type, entity.props, defaultSchema).name };
   const schema = typeof entity.props.schema === "string" ? entity.props.schema : identValue(defaultSchema);
-  if (entity.type === POSTGRES_ENTITY_TYPES.function || entity.type === POSTGRES_ENTITY_TYPES.procedure || entity.type === POSTGRES_ENTITY_TYPES.trigger || entity.type === POSTGRES_ENTITY_TYPES.policy) {
+  if (
+    entity.type === POSTGRES_ENTITY_TYPES.function ||
+    entity.type === POSTGRES_ENTITY_TYPES.procedure ||
+    entity.type === POSTGRES_ENTITY_TYPES.aggregate ||
+    entity.type === POSTGRES_ENTITY_TYPES.trigger ||
+    entity.type === POSTGRES_ENTITY_TYPES.policy
+  ) {
     const signature = canonicalPgObject(entity.type, entity.props, defaultSchema).signature;
     return { schema, name, ...(signature !== undefined ? { signature } : {}) };
   }
@@ -70,10 +78,11 @@ export function scopeFor(target: PostgresTarget, entities: ReadonlyArray<{ type:
   if (target.schemas) return target.schemas;
   if (entities.length === 0) return undefined;
   const out = new Set<string>([target.defaultSchema]);
+  // The schema alone: the rest of an address (a routine's parameter types) needs props a caller may not have.
+  const unplaced = new Set<string>([POSTGRES_ENTITY_TYPES.extension, POSTGRES_ENTITY_TYPES.role, POSTGRES_ENTITY_TYPES.cast, POSTGRES_ENTITY_TYPES.eventTrigger]);
   for (const e of entities) {
-    const a = declaredAddress(e, target.defaultSchema);
-    if (e.type === POSTGRES_ENTITY_TYPES.schema) out.add(a.name);
-    else if (a.schema) out.add(a.schema);
+    if (e.type === POSTGRES_ENTITY_TYPES.schema) out.add(String(e.props.name ?? ""));
+    else if (!unplaced.has(e.type)) out.add(typeof e.props.schema === "string" ? e.props.schema : identValue(target.defaultSchema));
   }
   return [...out].sort();
 }

package/src/postgres/live/kinds.e2e.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Composite and range types, aggregates, collations, casts and event
+ * triggers against a live server (#3911): applied as declared, they plan
+ * with no change and read back with no drift; a definition changed in the
+ * declaration is replaced (CREATE OR REPLACE AGGREGATE), dropped and created,
+ * or refused while something depends on it; an import writes each back as
+ * the declaration it came from, which plans with no change.
+ *
+ * The server: a throwaway one at the pin, skipped cleanly when Docker is not
+ * available. An event trigger is the database's and fires for every DDL in
+ * it, so this test does not run against a shared server
+ * (`CHANT_SQL_E2E_POSTGRES_URL`).
+ */
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { dockerAvailable, startTestPostgres, type TestPostgres } from "../testing/server";
+import { connectPostgres, type PostgresClient, type PostgresEndpoint } from "./client";
+import { readLiveSchema } from "./catalog";
+import { planPgAgainstServer } from "../plan/commands";
+import { observeResourcesDeep, liveProps } from "../plan/deep";
+import { postgresApply } from "../../op/activities/postgres-apply";
+import { objectsToIR } from "../import/ir";
+import { PostgresGenerator, postgresTemplates } from "../import/generator";
+import { declaredObjects } from "../apply/apply";
+
+const SCHEMA = "chant_e2e_3911";
+const enabled = await dockerAvailable();
+const dir = mkdtempSync(join(tmpdir(), "chant-pg-kinds-"));
+let server: TestPostgres | undefined;
+let endpoint: PostgresEndpoint;
+let admin: PostgresClient;
+
+beforeAll(async () => {
+  if (!enabled) return;
+  server = await startTestPostgres();
+  endpoint = server.endpoint();
+  admin = await connectPostgres(endpoint);
+}, 600_000);
+
+afterAll(async () => {
+  await admin?.end();
+  await server?.stop();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+interface Obj {
+  export: string;
+  type: string;
+  ddl: string;
+  dependsOn?: string[];
+}
+
+const MARKER = { stack: "e2e3911", env: "test" };
+const profile = () => ({
+  config: { ownership: MARKER, sql: { profiles: { e2e: { url: endpoint.url, password: { env: "PG_E2E_PASSWORD" }, schemas: [SCHEMA] } } } },
+  env: { PG_E2E_PASSWORD: endpoint.password ?? "" },
+});
+
+function writeBuild(file: string, objects: Obj[]): string {
+  const path = join(dir, file);
+  writeFileSync(path, JSON.stringify({ dialect: "postgres", postgresMajor: 18, objects: objects.map((o) => ({ dependsOn: [], ...o })) }));
+  return path;
+}
+
+const apply = (path: string, prune = false) => postgresApply({ buildPath: path, environment: "e2e", ...(prune ? { prune: true } : {}) }, undefined, { ...profile(), log: () => undefined });
+const plan = (path: string) => planPgAgainstServer("e2e", path, profile());
+
+const S = SCHEMA;
+interface Version {
+  /** The composite type's attributes. */
+  pair: string;
+  /** The aggregate's INITCOND. */
+  initcond: string;
+  /** The range's SUBTYPE_DIFF clause. */
+  diff: string;
+  /** The collation's locale. */
+  locale: string;
+  /** The cast's context. */
+  context: string;
+  /** The event trigger's tags. */
+  tags: string;
+}
+
+const objects = (v: Version): Obj[] => [
+  { export: "app", type: "Postgres::Schema", ddl: `CREATE SCHEMA ${S}` },
+  { export: "ci", type: "Postgres::Collation", dependsOn: ["app"], ddl: `CREATE COLLATION ${S}.ci (provider = icu, locale = '${v.locale}', deterministic = false);\nCOMMENT ON COLLATION ${S}.ci IS 'Case-insensitive'` },
+  { export: "pair", type: "Postgres::CompositeType", dependsOn: ["app"], ddl: `CREATE TYPE ${S}.pair AS (${v.pair});\nCOMMENT ON TYPE ${S}.pair IS 'Two values'` },
+  { export: "floatrange", type: "Postgres::RangeType", dependsOn: ["app"], ddl: `CREATE TYPE ${S}.floatrange AS RANGE (SUBTYPE = float8${v.diff})` },
+  { export: "people", type: "Postgres::Table", dependsOn: ["ci", "floatrange"], ddl: `CREATE TABLE ${S}.people (id int PRIMARY KEY, nick text COLLATE ${S}.ci, span ${S}.floatrange)` },
+  { export: "add2", type: "Postgres::Function", dependsOn: ["app"], ddl: `CREATE FUNCTION ${S}.add2(a integer, b integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$` },
+  {
+    export: "total",
+    type: "Postgres::Aggregate",
+    dependsOn: ["add2"],
+    ddl: `CREATE AGGREGATE ${S}.total(integer) (SFUNC = ${S}.add2, STYPE = int4, INITCOND = ${v.initcond}, PARALLEL = SAFE);\nCOMMENT ON AGGREGATE ${S}.total(int) IS 'A sum'`,
+  },
+  { export: "pairText", type: "Postgres::Function", dependsOn: ["pair"], ddl: `CREATE FUNCTION ${S}.pair_text(p ${S}.pair) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT p.a || ':' || p.b $$` },
+  { export: "pairCast", type: "Postgres::Cast", dependsOn: ["pair", "pairText"], ddl: `CREATE CAST (${S}.pair AS text) WITH FUNCTION ${S}.pair_text(${S}.pair)${v.context}` },
+  { export: "audit", type: "Postgres::Function", dependsOn: ["app"], ddl: `CREATE FUNCTION ${S}.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$` },
+  { export: "ddlAudit", type: "Postgres::EventTrigger", dependsOn: ["audit"], ddl: `CREATE EVENT TRIGGER ddl_audit_3911 ON ddl_command_end WHEN TAG IN (${v.tags}) EXECUTE FUNCTION ${S}.audit();\nCOMMENT ON EVENT TRIGGER ddl_audit_3911 IS 'Audits DDL'` },
+];
+
+const V1: Version = { pair: "a integer, b text COLLATE \"C\"", initcond: "0", diff: ", SUBTYPE_DIFF = float8mi", locale: "und-u-ks-level2", context: " AS ASSIGNMENT", tags: "'CREATE TABLE'" };
+// Each kind changed: the aggregate's INITCOND (OR REPLACE), the range's SUBTYPE_DIFF (a column uses the type: refused), the cast's context and the event trigger's tags (drop and create).
+const V2: Version = { ...V1, initcond: "'10'", diff: "", context: " AS IMPLICIT", tags: "'CREATE TABLE', 'ALTER TABLE'" };
+
+describe.skipIf(!enabled)("types, aggregates, collations, casts and event triggers on a live server", () => {
+  test("apply, plan, drift, change and import", async () => {
+    const v1 = writeBuild("v1.json", objects(V1));
+    const first = await apply(v1);
+    expect(first.failed).toEqual([]);
+    expect(first.applied.map((a) => [a.name, a.action])).toEqual([
+      [S, "created"],
+      [`${S}.ci`, "created"],
+      [`${S}.pair`, "created"],
+      [`${S}.floatrange`, "created"],
+      [`${S}.people`, "created"],
+      [`${S}.add2(integer,integer)`, "created"],
+      [`${S}.total(integer)`, "created"],
+      [`${S}.pair_text(${S}.pair)`, "created"],
+      [`(${S}.pair AS text)`, "created"],
+      [`${S}.audit()`, "created"],
+      ["ddl_audit_3911", "created"],
+    ]);
+    // Each works: the aggregate sums, the cast casts, the collation compares without case, the range has its multirange.
+    expect((await admin.query<{ t: number }>(`SELECT ${S}.total(x) AS t FROM generate_series(1, 4) x`))[0]!.t).toBe(10);
+    expect((await admin.query<{ t: string }>(`SELECT ROW(1, 'x')::${S}.pair::text AS t`))[0]!.t).toBe("1:x");
+    expect((await admin.query<{ eq: boolean }>(`SELECT 'Ab' = 'aB' COLLATE ${S}.ci AS eq`))[0]!.eq).toBe(true);
+    expect((await admin.query<{ m: string }>(`SELECT '{[1,2)}'::${S}.floatmultirange::text AS m`))[0]!.m).toBe("{[1,2)}");
+
+    // As declared: no change, and no drift.
+    expect((await plan(v1)).changes).toEqual([]);
+    const declared = declaredObjects(JSON.stringify({ dialect: "postgres", objects: objects(V1).map((o) => ({ dependsOn: [], ...o })) }));
+    const entities = new Map(declared.map((o) => [o.exportName, { entityType: o.type, props: o.props }]));
+    const deep = await observeResourcesDeep({ environment: "e2e", entityNames: [...entities.keys()], entities, ...profile() });
+    expect(deep.unobserved ?? {}).toEqual({});
+    const strip = (p: Record<string, unknown>) => Object.fromEntries(Object.entries(p).filter(([k]) => !["ddl", "source", "reads", "orReplace"].includes(k)));
+    for (const [name, e] of entities) expect(strip(deep.resources[name]!.properties), name).toEqual(strip(e.props));
+
+    // Changed by hand: drift, in the plan.
+    await admin.query(`CREATE OR REPLACE AGGREGATE ${S}.total(integer) (SFUNC = ${S}.add2, STYPE = int4, INITCOND = '5', PARALLEL = SAFE)`);
+    expect((await plan(v1)).changes.map((c) => [c.object, c.field, c.rule])).toEqual([[`total (${S}.total(integer))`, "definition", "SQLPG302"]]);
+
+    // Changed in the declaration: each with its rule; the range is used by a column, so its change is refused.
+    const v2 = writeBuild("v2.json", objects(V2));
+    const planned = await plan(v2);
+    expect(planned.changes.map((c) => [c.object, c.rule])).toEqual([
+      [`floatrange (${S}.floatrange)`, "SQLPG301"],
+      [`total (${S}.total(integer))`, "SQLPG302"],
+      [`pairCast ((${S}.pair AS text))`, "SQLPG300"],
+      ["ddlAudit (ddl_audit_3911)", "SQLPG300"],
+    ]);
+    expect(planned.refused.map((c) => c.object)).toEqual([`floatrange (${S}.floatrange)`]);
+    const v2Applied = writeBuild("v2-applied.json", objects({ ...V2, diff: V1.diff }));
+    const second = await apply(v2Applied);
+    expect(second.failed).toEqual([]);
+    expect(second.applied.filter((a) => a.action === "updated").map((a) => a.name)).toEqual([`${S}.total(integer)`, `(${S}.pair AS text)`, "ddl_audit_3911"]);
+    expect((await plan(v2Applied)).changes).toEqual([]);
+    expect((await admin.query<{ t: number }>(`SELECT ${S}.total(x) AS t FROM generate_series(1, 4) x`))[0]!.t).toBe(20);
+
+    // Import: the server's own printing, written back as declarations that parse and plan with no change.
+    const live = await readLiveSchema(admin, { schemas: [S] });
+    for (const o of live) liveProps(o);
+    const ir = objectsToIR(live.map((o) => ({ type: o.type, ...(o.schema ? { schema: o.schema } : {}), name: o.name, ddl: o.statement })));
+    const [file] = new PostgresGenerator().generate(ir);
+    expect(file!.content).toContain("export const ci = collation`");
+    expect(file!.content).toContain("export const pair = type`");
+    expect(file!.content).toContain("export const floatrange = type`");
+    expect(file!.content).toContain("export const total = aggregate`");
+    expect(file!.content).toContain("SFUNC = ${add2}");
+    expect(file!.content).toContain("cast`\n  CREATE CAST (${pair} AS text) WITH FUNCTION ${pairText}(${pair}) AS IMPLICIT");
+    expect(file!.content).toContain("export const ddlAudit3911 = eventTrigger`");
+    // The imported statements, in the generator's order, as a build: no change against the server they came from.
+    const items = ir.resources.map((r) => ({ exportName: r.logicalId, type: r.type, ...(r.properties.schema ? { schema: String(r.properties.schema) } : {}), name: String(r.properties.name), ddl: String(r.properties.ddl) }));
+    const { order } = postgresTemplates(items);
+    const imported = writeBuild("imported.json", order.map((it) => ({ export: it.exportName, type: it.type, ddl: it.ddl })));
+    expect((await plan(imported)).changes).toEqual([]);
+  }, 600_000);
+});

package/src/postgres/live/roundtrip.e2e.test.ts

@@ -2,9 +2,9 @@
  * The live round trip (#3279): a schema on one Postgres database is imported
  * as chant declarations, built, and applied to a second, empty database;
  * both catalogs then print the same statements for every object, exporting
- * the second gives back the same declarations, every declared object is
- * present, and the deep read of the applied database reports no drift from
- * the declarations.
+ * the second gives back the same declarations, a plan of the build against
+ * either database has no change, every declared object is present, and the
+ * deep read of the applied database reports no drift from the declarations.
  *
  * Needs Docker; skips cleanly without it. One throwaway `postgres` container
  * at the pin (18.6, by tag and digest), removed afterwards even on failure.
@@ -22,6 +22,7 @@ import { PostgresGenerator } from "../import/generator";
 import { readLiveSchema } from "./catalog";
 import { describeResources } from "./describe-resources";
 import { observeResourcesDeep } from "../plan/deep";
+import { planPgAgainstServer } from "../plan/commands";
 import { sqlPlugin } from "../../plugin";
 import { POSTGRES_DDL_FILE, sqlSerializer } from "../../serializer";
 
@@ -90,6 +91,11 @@ describe.skipIf(!enabled)("import, build, apply, and the catalog is unchanged",
     // The catalog is unchanged.
     expect(await catalog("target")).toEqual(await catalog("source"));
 
+    // A plan of the build against either database: no change (#3911).
+    const buildFile = join(projectDir, "schema.json");
+    writeFileSync(buildFile, out.primary);
+    for (const db of ["target", "source"]) expect((await planPgAgainstServer("rt", buildFile, profile(db))).changes, db).toEqual([]);
+
     // Exporting the applied database gives back the same declarations.
     const again = await exportResources({ environment: "rt", ...profile("target") });
     expect(new PostgresGenerator().generate(again)[0]!.content).toBe(file!.content);

package/src/postgres/live/undeclarable.e2e.test.ts

@@ -1,10 +1,12 @@
 /**
  * Import against a real Postgres server never leaves an object out without a
- * word (#3911): a database holding a composite type, an aggregate, a
- * collation, a cast and an event trigger beside a table fails the import,
- * which names all five; with `skipUndeclarable` the table is imported and
- * the five are warnings. What an extension brings (hstore's casts and
- * operators) is the extension's, and is not refused.
+ * word (#3911): a database holding a rewrite rule, an encoding conversion, an
+ * access method and a shell type beside a table fails the import, which
+ * names all four; with `skipUndeclarable` the rest is imported and the four
+ * are warnings. A composite type, an aggregate, a collation, a cast and an
+ * event trigger are declared kinds, so they are imported, not refused. What
+ * an extension brings (hstore's casts and operators) is the extension's, and
+ * is not refused.
  *
  * Needs Docker; skips cleanly without it. One throwaway `postgres` container
  * at the pin, removed afterwards even on failure.
@@ -30,6 +32,10 @@ CREATE FUNCTION app.pair_text(app.pair) RETURNS text LANGUAGE sql AS $$ SELECT (
 CREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair);
 CREATE FUNCTION app.on_ddl() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;
 CREATE EVENT TRIGGER audit_ddl ON ddl_command_end EXECUTE FUNCTION app.on_ddl();
+CREATE RULE users_notify AS ON INSERT TO app.users DO ALSO NOTIFY users;
+CREATE CONVERSION app.latin1_utf8 FOR 'LATIN1' TO 'UTF8' FROM iso8859_1_to_utf8;
+CREATE ACCESS METHOD heap2 TYPE TABLE HANDLER heap_tableam_handler;
+CREATE TYPE app.later;
 `;
 
 beforeAll(async () => {
@@ -52,13 +58,7 @@ const profile = () => ({
   env: { PG_UD_PASSWORD: server!.endpoint("source").password },
 });
 
-const NAMED = [
-  "aggregate app.total(integer)",
-  "cast (app.pair AS text)",
-  "collation app.ci",
-  "event trigger audit_ddl",
-  "composite type app.pair",
-];
+const NAMED = ["rule app.users_notify ON users", "conversion app.latin1_utf8", "access method heap2", "base type app.later"];
 
 describe.skipIf(!enabled)("importing a database with objects chant cannot declare", () => {
   test("fails, naming every one of them", async () => {
@@ -74,7 +74,9 @@ describe.skipIf(!enabled)("importing a database with objects chant cannot declar
 
   test("with skipUndeclarable, imports the rest and lists them as warnings", async () => {
     const ir = await exportResources({ environment: "src", skipUndeclarable: true, ...profile() });
-    expect(ir.resources.map((r) => r.properties.name)).toEqual(expect.arrayContaining(["users", "hstore", "add2", "pair_text", "on_ddl"]));
+    expect(ir.resources.map((r) => r.properties.name)).toEqual(
+      expect.arrayContaining(["users", "hstore", "add2", "pair_text", "on_ddl", "pair", "total", "ci", "(app.pair AS text)", "audit_ddl"]),
+    );
     const left = (ir.warnings ?? []).filter((w) => w.includes("is left out (--skip-undeclarable)"));
     expect(left.map((w) => w.split(" is left out")[0]).sort()).toEqual([...NAMED].sort());
   }, 120_000);

package/src/postgres/parser.test.ts

@@ -164,7 +164,8 @@ describe("the other statements", () => {
     expect(s.options.map((o) => o.option)).toEqual(["AS", "INCREMENT", "NO MINVALUE", "MAXVALUE", "START", "CACHE", "NO CYCLE", "OWNED BY"]);
     expect(parse("CREATE DOMAIN d AS text CONSTRAINT c CHECK (VALUE <> '') NOT VALID")[0]!.statement).toBe("domain");
     expect(parse("CREATE TYPE mood AS ENUM ('sad', 'ok')")[0]!.statement).toBe("enum");
-    expect(at("CREATE TYPE mood AS (a int)")).toBe("(");
+    expect(parse("CREATE TYPE pair AS (a int)")[0]!.statement).toBe("composite");
+    expect(at("CREATE TYPE t (INPUT = t_in)")).toBe("(");
     expect(parse("CREATE SCHEMA IF NOT EXISTS app AUTHORIZATION owner")[0]!.statement).toBe("schema");
     expect(parse("CREATE EXTENSION IF NOT EXISTS citext WITH SCHEMA public VERSION '1.6' CASCADE")[0]!.statement).toBe("extension");
   });