@intentius/chant-lexicon-sql 0.124.46 → 0.124.49

package/dist/postgres/plan/statements.js

@@ -0,0 +1,364 @@
+/**
+ * The Postgres statement classifier (#4407): a migration file's statements,
+ * each given the class and rule the schema-diff classifier (`./rules.ts`)
+ * gives the same change, with the lock the rule's restriction names. It reads
+ * text and contacts no server.
+ *
+ * `CREATE`, `GRANT`, `REVOKE`, `COMMENT ON` and `ALTER TABLE ... ROW LEVEL
+ * SECURITY` go through the declaration parser (`../parser.ts`). The parser
+ * has no `ALTER` grammar, so the other `ALTER` and `DROP` statements are read
+ * word by word from the same tokens.
+ *
+ * A statement alone cannot decide some changes. `ALTER COLUMN ... TYPE` is a
+ * catalog change or a table rewrite by the column's old type, which the file
+ * does not state: it is `undecided`, naming SQLPG206 and SQLPG207 (and
+ * SQLPG208 with a `USING` expression). `CREATE OR REPLACE VIEW` is SQLPG250
+ * or SQLPG251 by whether the columns stay. A statement no rule covers is
+ * `unclassified` with a note.
+ */
+import { isTrivia, tokenizeText } from "../tokens.js";
+import { parseStatements } from "../parser.js";
+import { classifiedOf, lockOf, splitTopLevel, sqlHead } from "../../core/statement-class.js";
+import { PG_CHANGE_CLASSES, PG_CLASSIFIER_RULES } from "./rules.js";
+const classified = (id, extra = {}) => {
+    const lock = lockOf(PG_CLASSIFIER_RULES[id].restriction);
+    return classifiedOf(PG_CLASSIFIER_RULES, PG_CHANGE_CLASSES.label, id, { ...(lock ? { lock } : {}), ...extra });
+};
+const rule = (id, extra) => ({ rules: [{ id, ...(extra ? { extra } : {}) }] });
+const VOLATILE = /\b(?:clock_timestamp|random|gen_random_uuid|uuid_generate_v\d\w*|nextval|timeofday|txid_current|setseed)\s*\(/i;
+/** The words from `i` that are one possibly qualified name, and the index after it. */
+function nameAt(words, i) {
+    let name = words[i] ?? "";
+    let j = i + 1;
+    while (words[j] === "." && words[j + 1] !== undefined) {
+        name += `.${words[j + 1]}`;
+        j += 2;
+    }
+    return { name, next: j };
+}
+const bare = (name) => (name.split(".").pop() ?? name).replace(/^"|"$/g, "").toLowerCase();
+const has = (u, ...seq) => u.some((_, i) => seq.every((w, k) => u[i + k] === w));
+/** One `ALTER TABLE` action (the words between top-level commas). */
+function tableAction(a) {
+    const u = a.map((w) => w.toUpperCase());
+    const first = u[0];
+    if (first === "ADD") {
+        let i = 1;
+        if (u[i] === "COLUMN")
+            i++;
+        if (u[i] === "CONSTRAINT" || ["PRIMARY", "UNIQUE", "CHECK", "FOREIGN", "EXCLUDE"].includes(u[i] ?? "")) {
+            let k = i;
+            if (u[k] === "CONSTRAINT")
+                k += 2;
+            const kind = u[k];
+            const notValid = has(u, "NOT", "VALID");
+            if (kind === "NOT" && u[k + 1] === "NULL")
+                return rule("SQLPG210");
+            if (notValid)
+                return rule("SQLPG217", { note: `${kind ?? "constraint"} added NOT VALID; VALIDATE CONSTRAINT is SQLPG220` });
+            if (kind === "PRIMARY" || kind === "UNIQUE")
+                return rule("SQLPG221", has(u, "USING", "INDEX") ? { note: "from an existing unique index, so no build under this lock" } : {});
+            if (kind === "CHECK")
+                return rule("SQLPG218");
+            if (kind === "FOREIGN")
+                return rule("SQLPG219");
+            if (kind === "EXCLUDE")
+                return rule("SQLPG222");
+            return { none: "an ADD CONSTRAINT of a kind no rule names" };
+        }
+        if (u[i] === "IF" && u[i + 1] === "NOT" && u[i + 2] === "EXISTS")
+            i += 3;
+        const hasDefault = u.includes("DEFAULT");
+        const defaultText = hasDefault ? a.slice(u.indexOf("DEFAULT") + 1).join(" ") : "";
+        const generated = has(u, "GENERATED");
+        const stored = u.includes("STORED") && generated;
+        const identity = u.includes("IDENTITY");
+        const notNull = has(u, "NOT", "NULL");
+        if (stored || identity)
+            return rule("SQLPG202", { note: stored ? "a STORED generated column" : "an identity column" });
+        if (VOLATILE.test(defaultText))
+            return rule("SQLPG202", { note: "a volatile default" });
+        if (notNull && !hasDefault && !generated)
+            return rule("SQLPG203");
+        return rule("SQLPG201");
+    }
+    if (first === "DROP") {
+        if (u[1] === "CONSTRAINT")
+            return rule("SQLPG223");
+        return rule("SQLPG204", { destructive: true });
+    }
+    if (first === "RENAME") {
+        if (u[1] === "COLUMN" || (u[1] !== "CONSTRAINT" && u[1] !== "TO"))
+            return rule("SQLPG205");
+        return rule("SQLPG228");
+    }
+    if (first === "ALTER") {
+        let i = 1;
+        if (u[i] === "COLUMN")
+            i++;
+        if (u[i] === "CONSTRAINT")
+            return { none: "ALTER CONSTRAINT (deferrability)" };
+        const rest = u.slice(i + 1);
+        const col = a[i] ?? "column";
+        if (rest[0] === "TYPE" || (rest[0] === "SET" && rest[1] === "DATA" && rest[2] === "TYPE")) {
+            const using = rest.includes("USING");
+            return {
+                undecided: using ? ["SQLPG206", "SQLPG207", "SQLPG208"] : ["SQLPG206", "SQLPG207"],
+                note: `the new type of ${col} is a catalog change or a table rewrite by its old type${using ? ", or a change across kinds with this USING expression," : ""}, which the file does not state`,
+            };
+        }
+        if (rest[0] === "SET" && rest[1] === "DEFAULT")
+            return rule("SQLPG209");
+        if (rest[0] === "DROP" && rest[1] === "DEFAULT")
+            return rule("SQLPG209");
+        if (rest[0] === "SET" && rest[1] === "NOT" && rest[2] === "NULL")
+            return rule("SQLPG210");
+        if (rest[0] === "DROP" && rest[1] === "NOT" && rest[2] === "NULL")
+            return rule("SQLPG211");
+        if (rest[0] === "SET" && rest[1] === "EXPRESSION")
+            return rule("SQLPG212");
+        if ((rest[0] === "ADD" && rest[1] === "GENERATED") || (rest[0] === "SET" && (rest[1] === "GENERATED" || rest[1] === "INCREMENT" || rest[1] === "START" || rest[1] === "RESTART")) || rest[0] === "RESTART" || (rest[0] === "DROP" && rest[1] === "IDENTITY")) {
+            return rule("SQLPG213");
+        }
+        if (rest[0] === "SET" && (rest[1] === "STORAGE" || rest[1] === "COMPRESSION"))
+            return rule("SQLPG215");
+        return { none: `ALTER COLUMN ${rest.slice(0, 2).join(" ")}` };
+    }
+    if (first === "VALIDATE" && u[1] === "CONSTRAINT")
+        return rule("SQLPG220");
+    if (first === "SET" || first === "RESET") {
+        if (u[1] === "LOGGED" || u[1] === "UNLOGGED")
+            return rule("SQLPG225");
+        if (u[1] === "ACCESS" || u[1] === "TABLESPACE")
+            return rule("SQLPG226");
+        if (u[1] === "SCHEMA")
+            return rule("SQLPG228");
+        if (u[1] === "(" || first === "RESET")
+            return rule("SQLPG224");
+        return { none: `ALTER TABLE ${u.slice(0, 2).join(" ")}` };
+    }
+    if (first === "ATTACH" || first === "DETACH" || first === "INHERIT" || (first === "NO" && u[1] === "INHERIT") || first === "OF" || (first === "NOT" && u[1] === "OF"))
+        return rule("SQLPG227");
+    if ((first === "ENABLE" || first === "DISABLE" || first === "FORCE" || (first === "NO" && u[1] === "FORCE")) && has(u, "ROW", "LEVEL", "SECURITY"))
+        return rule("SQLPG293");
+    if ((first === "ENABLE" || first === "DISABLE") && (u[1] === "TRIGGER" || u[1] === "REPLICA" || u[1] === "ALWAYS"))
+        return rule("SQLPG284");
+    return { none: `ALTER TABLE ${u.slice(0, 2).join(" ")}` };
+}
+/** `ALTER <object> ...` other than `TABLE`, by its second word. */
+function alterOther(u, a) {
+    const obj = u[1];
+    const rename = u.includes("RENAME");
+    if (obj === "INDEX")
+        return rename ? rule("SQLPG229") : rule("SQLPG243");
+    if (obj === "TYPE") {
+        if (has(u, "ADD", "VALUE"))
+            return rule("SQLPG260");
+        if (has(u, "RENAME", "TO"))
+            return rule("SQLPG228");
+        return { none: "ALTER TYPE other than ADD VALUE and RENAME TO" };
+    }
+    if (obj === "SEQUENCE")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : has(u, "OWNER", "TO") ? { none: "ALTER SEQUENCE OWNER TO" } : rule("SQLPG265");
+    if (obj === "VIEW")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : has(u, "OWNER", "TO") ? { none: "ALTER VIEW OWNER TO" } : rule("SQLPG253");
+    if (obj === "MATERIALIZED")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : { none: "ALTER MATERIALIZED VIEW other than RENAME" };
+    if (obj === "SCHEMA")
+        return rename ? rule("SQLPG228") : has(u, "OWNER", "TO") ? rule("SQLPG267") : { none: "ALTER SCHEMA" };
+    if (obj === "EXTENSION")
+        return has(u, "UPDATE") || has(u, "SET", "SCHEMA") ? rule("SQLPG266") : { none: "ALTER EXTENSION ADD or DROP member" };
+    if (obj === "FUNCTION" || obj === "PROCEDURE" || obj === "ROUTINE")
+        return rename || has(u, "SET", "SCHEMA") ? rule("SQLPG228") : { none: `ALTER ${obj} other than RENAME` };
+    if (obj === "TRIGGER")
+        return rule("SQLPG284");
+    if (obj === "POLICY")
+        return rename ? rule("SQLPG228") : rule("SQLPG291");
+    if (obj === "ROLE" || obj === "USER" || obj === "GROUP")
+        return rule("SQLPG294");
+    if (obj === "DOMAIN") {
+        if (rename || has(u, "SET", "SCHEMA"))
+            return rule("SQLPG228");
+        if (has(u, "ADD", "CONSTRAINT") || (u[3] === "ADD" && ["CHECK", "NOT"].includes(u[4] ?? "")))
+            return rule("SQLPG262");
+        if (has(u, "OWNER", "TO"))
+            return { none: "ALTER DOMAIN OWNER TO" };
+        return rule("SQLPG263");
+    }
+    if (obj === "SERVER" || obj === "PUBLICATION" || (obj === "FOREIGN" && u[2] === "DATA"))
+        return rename ? rule("SQLPG228") : rule("SQLPG303");
+    void a;
+    return { none: `ALTER ${obj ?? ""}`.trim() };
+}
+function dropStatement(u) {
+    const obj = u[1] === "MATERIALIZED" || u[1] === "FOREIGN" || u[1] === "EVENT" ? `${u[1]} ${u[2]}` : u[1];
+    if (obj === "INDEX")
+        return rule("SQLPG242", u[2] === "CONCURRENTLY" ? { note: "DROP INDEX CONCURRENTLY waits for running queries instead of blocking them" } : {});
+    if (obj === "TRIGGER")
+        return rule("SQLPG285", { destructive: false });
+    if (obj === "POLICY")
+        return rule("SQLPG292", { destructive: false });
+    return rule("SQLPG270", { destructive: true });
+}
+/** How a `CREATE` that the parser could not read starts: its kind by key words. */
+function createByWords(u) {
+    let i = 1;
+    const orReplace = u[i] === "OR" && u[i + 1] === "REPLACE";
+    if (orReplace)
+        i += 2;
+    while (["GLOBAL", "LOCAL", "TEMPORARY", "TEMP", "UNLOGGED", "RECURSIVE", "UNIQUE", "CONSTRAINT"].includes(u[i] ?? "") && u[i + 1] !== "INDEX" && u[i] !== "UNIQUE")
+        i++;
+    if (u[i] === "UNIQUE")
+        i++;
+    if (u[i] === "INDEX") {
+        const concurrently = u[i + 1] === "CONCURRENTLY";
+        return concurrently ? rule("SQLPG240") : rule("SQLPG241");
+    }
+    if (orReplace && (u[i] === "FUNCTION" || u[i] === "PROCEDURE"))
+        return rule("SQLPG280");
+    if (orReplace && u[i] === "VIEW")
+        return { undecided: ["SQLPG250", "SQLPG251"], note: "whether the view keeps its columns depends on the view it replaces" };
+    if (orReplace && u[i] === "AGGREGATE")
+        return rule("SQLPG302");
+    if (u[i] === "TRIGGER")
+        return rule("SQLPG283");
+    if (u[i] === "POLICY")
+        return rule("SQLPG290");
+    return rule("SQLPG200");
+}
+/** A statement the parser read: its rule, given the tables this file created earlier. */
+function fromNode(n, created) {
+    switch (n.statement) {
+        case "table":
+            created.add(bare(n.name.pieces.join(".")));
+            return rule("SQLPG200");
+        case "index":
+            if (n.concurrently)
+                return rule("SQLPG240");
+            if (created.has(bare(n.table.pieces.join("."))))
+                return rule("SQLPG200", { note: "an index on a table this file creates, which has no rows to block" });
+            return rule("SQLPG241");
+        case "view":
+            if (n.orReplace && !n.materialized)
+                return { undecided: ["SQLPG250", "SQLPG251"], note: "whether the view keeps its columns depends on the view it replaces" };
+            return rule("SQLPG200");
+        case "function":
+        case "procedure":
+            return n.orReplace ? rule("SQLPG280") : rule("SQLPG200");
+        case "aggregate":
+            return n.orReplace ? rule("SQLPG302") : rule("SQLPG200");
+        case "trigger":
+            return created.has(bare(n.table.pieces.join("."))) ? rule("SQLPG200", { note: "a trigger on a table this file creates" }) : rule("SQLPG283");
+        case "policy":
+            return created.has(bare(n.table.pieces.join("."))) ? rule("SQLPG200", { note: "a policy on a table this file creates" }) : rule("SQLPG290");
+        case "grant":
+            return n.defaults ? rule("SQLPG298") : n.revoke ? rule("SQLPG297") : rule("SQLPG296");
+        case "rowSecurity":
+            return rule("SQLPG293");
+        case "comment":
+            return rule("SQLPG216");
+        case "role":
+            return rule("SQLPG200");
+        default:
+            return rule("SQLPG200");
+    }
+}
+const DATA_WORDS = new Set(["INSERT", "UPDATE", "DELETE", "SELECT", "WITH", "COPY", "CALL", "DO", "SET", "BEGIN", "START", "COMMIT", "END", "ROLLBACK", "SAVEPOINT", "RELEASE", "ANALYZE", "ANALYSE", "VACUUM", "REINDEX", "LOCK", "NOTIFY", "LISTEN", "RESET", "SHOW", "EXPLAIN", "VALUES", "MERGE", "REFRESH", "CLUSTER", "CHECKPOINT", "DISCARD", "PREPARE", "EXECUTE", "DEALLOCATE"]);
+/** Classify one statement. `created` is the tables the file's earlier statements created. */
+function read(sql, created) {
+    let tokens;
+    try {
+        tokens = tokenizeText(sql, 0);
+    }
+    catch {
+        return [{ none: "text the tokenizer could not read" }];
+    }
+    const words = tokens.filter((t) => !isTrivia(t) && t.text !== ";").map((t) => t.text);
+    const u = words.map((w) => w.toUpperCase());
+    const head = u[0];
+    if (head === undefined)
+        return [{ data: "an empty statement" }];
+    if (head === "CREATE" || head === "GRANT" || head === "REVOKE" || head === "COMMENT" || (head === "ALTER" && (u[1] === "DEFAULT" || (u[1] === "TABLE" && has(u, "ROW", "LEVEL", "SECURITY"))))) {
+        try {
+            const nodes = parseStatements(tokens);
+            return nodes.map((n) => fromNode(n, created));
+        }
+        catch {
+            if (head === "CREATE")
+                return [createByWords(u)];
+            if (head === "GRANT")
+                return [rule("SQLPG296")];
+            if (head === "REVOKE")
+                return [rule("SQLPG297")];
+            if (head === "COMMENT")
+                return [rule("SQLPG216")];
+            if (head === "ALTER" && u[1] === "DEFAULT")
+                return [rule("SQLPG298")];
+            return [rule("SQLPG293")];
+        }
+    }
+    if (head === "ALTER" && u[1] === "TABLE") {
+        let i = 2;
+        if (u[i] === "IF" && u[i + 1] === "EXISTS")
+            i += 2;
+        if (u[i] === "ONLY")
+            i++;
+        const { name, next } = nameAt(words, i);
+        if (u[next] === "*")
+            i = next + 1;
+        else
+            i = next;
+        const actions = splitTopLevel(words.slice(i));
+        if (actions.length === 0)
+            return [{ none: `ALTER TABLE ${name} with no action` }];
+        void name;
+        return actions.map(tableAction);
+    }
+    if (head === "ALTER")
+        return [alterOther(u, words)];
+    if (head === "DROP")
+        return [dropStatement(u)];
+    if (head === "TRUNCATE")
+        return [{ data: "TRUNCATE removes every row of the table" }];
+    if (DATA_WORDS.has(head))
+        return [{ data: `${head} reads or writes rows or the session, not the schema` }];
+    return [{ none: `${head} is not a statement the classifier reads` }];
+}
+/**
+ * Classify a migration's up statements, in order. The statements are the
+ * file's own text, one per entry (a Flyway file after placeholder
+ * substitution).
+ */
+export function classifyPgStatements(statements) {
+    const created = new Set();
+    return statements.map((sql, k) => {
+        const readings = read(sql, created);
+        const out = { index: k + 1, sql: sqlHead(sql), outcome: "classified", changes: [] };
+        const none = [];
+        for (const r of readings) {
+            if ("rules" in r)
+                out.changes.push(...r.rules.map((x) => classified(x.id, x.extra)));
+            else if ("undecided" in r) {
+                out.candidates = r.undecided.map((id) => classified(id));
+                out.note = r.note;
+            }
+            else if ("none" in r)
+                none.push(r.none);
+            else
+                out.note = r.data;
+        }
+        if (out.candidates && out.changes.length === 0)
+            out.outcome = "undecided";
+        else if (out.candidates) {
+            // A statement with some decided clauses and one undecided: report undecided, and keep the decided ones.
+            out.outcome = "undecided";
+        }
+        else if (out.changes.length === 0 && none.length === 0)
+            out.outcome = "data";
+        else if (none.length > 0) {
+            out.outcome = out.changes.length > 0 ? "classified" : "unclassified";
+            out.note = [out.note, `no rule covers ${none.join("; ")}`].filter(Boolean).join("; ");
+        }
+        return out;
+    });
+}

package/dist/postgres/secret-options.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Options that hold a credential. A foreign data wrapper's or server's
+ * `OPTIONS (...)` can carry any name, and a password in one would be written
+ * into a schema file by import and sent to every reader of the plan. The
+ * environment supplies credentials, in a user mapping (which is not declared)
+ * or its own secret store, as for a role's password (`./entities.ts`).
+ */
+/** Whether an option name reads as a credential: `password`, `sslpassword`, `secret_key`, `api_token`. */
+export declare const isSecretOption: (name: string) => boolean;
+//# sourceMappingURL=secret-options.d.ts.map

package/dist/postgres/secret-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secret-options.d.ts","sourceRoot":"","sources":["../../src/postgres/secret-options.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,0GAA0G;AAC1G,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,OAA2E,CAAC"}

package/dist/postgres/secret-options.js

@@ -0,0 +1,9 @@
+/**
+ * Options that hold a credential. A foreign data wrapper's or server's
+ * `OPTIONS (...)` can carry any name, and a password in one would be written
+ * into a schema file by import and sent to every reader of the plan. The
+ * environment supplies credentials, in a user mapping (which is not declared)
+ * or its own secret store, as for a role's password (`./entities.ts`).
+ */
+/** Whether an option name reads as a credential: `password`, `sslpassword`, `secret_key`, `api_token`. */
+export const isSecretOption = (name) => /pass(word|wd)?|secret|token|api[_-]?key|credential/i.test(name);

package/dist/postgres/testing/roundtrip-schema.d.ts

@@ -5,9 +5,11 @@
  * sequence options, storage parameters, comments), an extension and the
  * domain over its type, a collation, composite and range types (and a
  * multirange column), plain and ordered-set aggregates, a cast and an event
- * trigger (#3911), a partitioned table and a partition, an ORM's
+ * trigger, an operator, extended statistics, a foreign data wrapper and server, and a
+ * publication (#3911), a foreign table, an operator class and family, a text
+ * search dictionary and configuration (#4406), a partitioned table and a partition, an ORM's
  * revision table that import leaves out, and an object carrying chant's
  * ownership trailer.
  */
-export declare const ROUNDTRIP_SCHEMA = "\nCREATE SCHEMA app;\nCOMMENT ON SCHEMA app IS 'The shop';\nCREATE EXTENSION citext WITH SCHEMA app;\nCREATE TYPE app.order_status AS ENUM ('placed', 'paid', 'shipped');\nCREATE DOMAIN app.email AS app.citext CONSTRAINT email_shape CHECK (VALUE LIKE '%@%');\nCOMMENT ON CONSTRAINT email_shape ON DOMAIN app.email IS 'needs an @';\nCREATE SEQUENCE app.invoice_seq AS integer START WITH 1000 CACHE 10;\nCREATE TABLE app.users (\n  id bigint GENERATED ALWAYS AS IDENTITY (START WITH 10) PRIMARY KEY,\n  email app.email NOT NULL UNIQUE,\n  plan text NOT NULL DEFAULT 'free' CHECK (plan IN ('free', 'pro')),\n  created_at timestamptz NOT NULL DEFAULT now()\n) WITH (fillfactor = 90);\nCOMMENT ON TABLE app.users IS 'Accounts [chant managed-by=chant stack=shop env=e2e]';\nCOMMENT ON COLUMN app.users.email IS 'Login name';\nCREATE TABLE app.orders (\n  id serial PRIMARY KEY,\n  user_id bigint NOT NULL REFERENCES app.users (id) ON DELETE CASCADE,\n  invoice_no integer NOT NULL DEFAULT nextval('app.invoice_seq'),\n  status app.order_status NOT NULL DEFAULT 'placed',\n  amount numeric(12, 2) NOT NULL CONSTRAINT amount_positive CHECK (amount >= 0),\n  discount int DEFAULT -1,\n  total numeric GENERATED ALWAYS AS (amount * 2) STORED,\n  placed_at timestamp(3) without time zone\n);\nCREATE INDEX orders_user_idx ON app.orders (user_id, placed_at DESC) WHERE status <> 'shipped';\nCREATE UNIQUE INDEX orders_invoice_idx ON app.orders USING btree (invoice_no) INCLUDE (amount);\nCREATE TABLE app.measures (ts date NOT NULL, v double precision) PARTITION BY RANGE (ts);\nCREATE TABLE app.measures_2026 PARTITION OF app.measures FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');\nCREATE VIEW app.order_totals AS\n  SELECT u.id AS user_id, u.email, count(o.id) AS n, coalesce(sum(o.amount), 0) AS total\n  FROM app.users u LEFT JOIN app.orders o ON o.user_id = u.id\n  GROUP BY u.id, u.email;\nCREATE MATERIALIZED VIEW app.daily AS SELECT placed_at::date AS day, count(*) AS n FROM app.orders GROUP BY 1 WITH NO DATA;\nCREATE COLLATION app.ci (provider = icu, locale = 'und-u-ks-level2', deterministic = false);\nCOMMENT ON COLLATION app.ci IS 'Case-insensitive';\nCREATE TYPE app.pair AS (a integer, b text COLLATE \"C\");\nCOMMENT ON TYPE app.pair IS 'Two values';\nCREATE TYPE app.floatrange AS RANGE (SUBTYPE = float8, SUBTYPE_DIFF = float8mi);\nCREATE TABLE app.people (id integer PRIMARY KEY, nick text COLLATE app.ci, span app.floatrange, tags app.floatmultirange);\nCREATE FUNCTION app.add2(a integer, b integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$;\nCREATE AGGREGATE app.total(integer) (SFUNC = app.add2, STYPE = integer, INITCOND = '0', PARALLEL = SAFE);\nCOMMENT ON AGGREGATE app.total(integer) IS 'A sum';\nCREATE FUNCTION app.middle(v double precision[]) RETURNS double precision LANGUAGE sql IMMUTABLE AS $$ SELECT v[(array_length(v, 1) + 1) / 2] $$;\nCREATE AGGREGATE app.median_of(ORDER BY double precision) (SFUNC = pg_catalog.array_append, STYPE = double precision[], FINALFUNC = app.middle);\nCREATE FUNCTION app.pair_text(p app.pair) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT p.a || ':' || p.b $$;\nCREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair) AS ASSIGNMENT;\nCOMMENT ON CAST (app.pair AS text) IS 'a:b';\nCREATE FUNCTION app.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;\nCREATE EVENT TRIGGER app_audit ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION app.audit();\nCREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);\n";
+export declare const ROUNDTRIP_SCHEMA = "\nCREATE SCHEMA app;\nCOMMENT ON SCHEMA app IS 'The shop';\nCREATE EXTENSION citext WITH SCHEMA app;\nCREATE TYPE app.order_status AS ENUM ('placed', 'paid', 'shipped');\nCREATE DOMAIN app.email AS app.citext CONSTRAINT email_shape CHECK (VALUE LIKE '%@%');\nCOMMENT ON CONSTRAINT email_shape ON DOMAIN app.email IS 'needs an @';\nCREATE SEQUENCE app.invoice_seq AS integer START WITH 1000 CACHE 10;\nCREATE TABLE app.users (\n  id bigint GENERATED ALWAYS AS IDENTITY (START WITH 10) PRIMARY KEY,\n  email app.email NOT NULL UNIQUE,\n  plan text NOT NULL DEFAULT 'free' CHECK (plan IN ('free', 'pro')),\n  created_at timestamptz NOT NULL DEFAULT now()\n) WITH (fillfactor = 90);\nCOMMENT ON TABLE app.users IS 'Accounts [chant managed-by=chant stack=shop env=e2e]';\nCOMMENT ON COLUMN app.users.email IS 'Login name';\nCREATE TABLE app.orders (\n  id serial PRIMARY KEY,\n  user_id bigint NOT NULL REFERENCES app.users (id) ON DELETE CASCADE,\n  invoice_no integer NOT NULL DEFAULT nextval('app.invoice_seq'),\n  status app.order_status NOT NULL DEFAULT 'placed',\n  amount numeric(12, 2) NOT NULL CONSTRAINT amount_positive CHECK (amount >= 0),\n  discount int DEFAULT -1,\n  total numeric GENERATED ALWAYS AS (amount * 2) STORED,\n  placed_at timestamp(3) without time zone\n);\nCREATE INDEX orders_user_idx ON app.orders (user_id, placed_at DESC) WHERE status <> 'shipped';\nCREATE UNIQUE INDEX orders_invoice_idx ON app.orders USING btree (invoice_no) INCLUDE (amount);\nCREATE TABLE app.measures (ts date NOT NULL, v double precision) PARTITION BY RANGE (ts);\nCREATE TABLE app.measures_2026 PARTITION OF app.measures FOR VALUES FROM ('2026-01-01') TO ('2027-01-01');\nCREATE VIEW app.order_totals AS\n  SELECT u.id AS user_id, u.email, count(o.id) AS n, coalesce(sum(o.amount), 0) AS total\n  FROM app.users u LEFT JOIN app.orders o ON o.user_id = u.id\n  GROUP BY u.id, u.email;\nCREATE MATERIALIZED VIEW app.daily AS SELECT placed_at::date AS day, count(*) AS n FROM app.orders GROUP BY 1 WITH NO DATA;\nCREATE COLLATION app.ci (provider = icu, locale = 'und-u-ks-level2', deterministic = false);\nCOMMENT ON COLLATION app.ci IS 'Case-insensitive';\nCREATE TYPE app.pair AS (a integer, b text COLLATE \"C\");\nCOMMENT ON TYPE app.pair IS 'Two values';\nCREATE TYPE app.floatrange AS RANGE (SUBTYPE = float8, SUBTYPE_DIFF = float8mi);\nCREATE TABLE app.people (id integer PRIMARY KEY, nick text COLLATE app.ci, span app.floatrange, tags app.floatmultirange);\nCREATE FUNCTION app.add2(a integer, b integer) RETURNS integer LANGUAGE sql IMMUTABLE AS $$ SELECT a + b $$;\nCREATE AGGREGATE app.total(integer) (SFUNC = app.add2, STYPE = integer, INITCOND = '0', PARALLEL = SAFE);\nCOMMENT ON AGGREGATE app.total(integer) IS 'A sum';\nCREATE FUNCTION app.middle(v double precision[]) RETURNS double precision LANGUAGE sql IMMUTABLE AS $$ SELECT v[(array_length(v, 1) + 1) / 2] $$;\nCREATE AGGREGATE app.median_of(ORDER BY double precision) (SFUNC = pg_catalog.array_append, STYPE = double precision[], FINALFUNC = app.middle);\nCREATE FUNCTION app.pair_text(p app.pair) RETURNS text LANGUAGE sql IMMUTABLE AS $$ SELECT p.a || ':' || p.b $$;\nCREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair) AS ASSIGNMENT;\nCOMMENT ON CAST (app.pair AS text) IS 'a:b';\nCREATE FUNCTION app.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;\nCREATE EVENT TRIGGER app_audit ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION app.audit();\nCREATE FUNCTION app.int_same(a integer, b integer) RETURNS boolean LANGUAGE sql IMMUTABLE AS $$ SELECT a = b $$;\nCREATE OPERATOR app.=== (FUNCTION = app.int_same, LEFTARG = integer, RIGHTARG = integer, COMMUTATOR = OPERATOR(app.===), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES, MERGES);\nCOMMENT ON OPERATOR app.===(integer, integer) IS 'Same value';\nCREATE STATISTICS app.orders_stats (dependencies) ON user_id, status FROM app.orders;\nCOMMENT ON STATISTICS app.orders_stats IS 'Users and their order states';\nCREATE FOREIGN DATA WRAPPER app_fdw OPTIONS (debug 'true');\nCOMMENT ON FOREIGN DATA WRAPPER app_fdw IS 'Remote tables';\nCREATE SERVER app_replica TYPE 'pg' VERSION '16' FOREIGN DATA WRAPPER app_fdw OPTIONS (host 'db.internal', port '5432');\nCOMMENT ON SERVER app_replica IS 'The read replica';\nCREATE PUBLICATION app_pub FOR TABLE app.orders, app.users WITH (publish = 'insert, update');\nCOMMENT ON PUBLICATION app_pub IS 'Order changes';\nCREATE FOREIGN TABLE app.remote_orders (id integer OPTIONS (column_name 'order_id') NOT NULL, status text DEFAULT 'placed', CONSTRAINT status_known CHECK (status IS NOT NULL)) SERVER app_replica OPTIONS (table_name 'orders');\nCOMMENT ON FOREIGN TABLE app.remote_orders IS 'Orders on the replica';\nCREATE OPERATOR CLASS app.int_hash_ops FOR TYPE integer USING hash AS OPERATOR 1 =, FUNCTION 1 hashint4(integer);\nCOMMENT ON OPERATOR CLASS app.int_hash_ops USING hash IS 'Hash by value';\nCREATE OPERATOR FAMILY app.spare_ops USING btree;\nCREATE TEXT SEARCH DICTIONARY app.shop_stop (TEMPLATE = simple, StopWords = english);\nCREATE TEXT SEARCH CONFIGURATION app.shop (PARSER = pg_catalog.\"default\");\nALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR asciiword, word WITH app.shop_stop, english_stem;\nALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR int, uint WITH simple;\nCOMMENT ON TEXT SEARCH CONFIGURATION app.shop IS 'Shop search';\nCREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);\n";
 //# sourceMappingURL=roundtrip-schema.d.ts.map

package/dist/postgres/testing/roundtrip-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roundtrip-schema.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/roundtrip-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,2/GAoD5B,CAAC"}
+{"version":3,"file":"roundtrip-schema.d.ts","sourceRoot":"","sources":["../../../src/postgres/testing/roundtrip-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,03KAyE5B,CAAC"}

package/dist/postgres/testing/roundtrip-schema.js

@@ -5,7 +5,9 @@
  * sequence options, storage parameters, comments), an extension and the
  * domain over its type, a collation, composite and range types (and a
  * multirange column), plain and ordered-set aggregates, a cast and an event
- * trigger (#3911), a partitioned table and a partition, an ORM's
+ * trigger, an operator, extended statistics, a foreign data wrapper and server, and a
+ * publication (#3911), a foreign table, an operator class and family, a text
+ * search dictionary and configuration (#4406), a partitioned table and a partition, an ORM's
  * revision table that import leaves out, and an object carrying chant's
  * ownership trailer.
  */
@@ -60,5 +62,26 @@ CREATE CAST (app.pair AS text) WITH FUNCTION app.pair_text(app.pair) AS ASSIGNME
 COMMENT ON CAST (app.pair AS text) IS 'a:b';
 CREATE FUNCTION app.audit() RETURNS event_trigger LANGUAGE plpgsql AS $$ BEGIN END $$;
 CREATE EVENT TRIGGER app_audit ON ddl_command_end WHEN TAG IN ('CREATE TABLE') EXECUTE FUNCTION app.audit();
+CREATE FUNCTION app.int_same(a integer, b integer) RETURNS boolean LANGUAGE sql IMMUTABLE AS $$ SELECT a = b $$;
+CREATE OPERATOR app.=== (FUNCTION = app.int_same, LEFTARG = integer, RIGHTARG = integer, COMMUTATOR = OPERATOR(app.===), RESTRICT = eqsel, JOIN = eqjoinsel, HASHES, MERGES);
+COMMENT ON OPERATOR app.===(integer, integer) IS 'Same value';
+CREATE STATISTICS app.orders_stats (dependencies) ON user_id, status FROM app.orders;
+COMMENT ON STATISTICS app.orders_stats IS 'Users and their order states';
+CREATE FOREIGN DATA WRAPPER app_fdw OPTIONS (debug 'true');
+COMMENT ON FOREIGN DATA WRAPPER app_fdw IS 'Remote tables';
+CREATE SERVER app_replica TYPE 'pg' VERSION '16' FOREIGN DATA WRAPPER app_fdw OPTIONS (host 'db.internal', port '5432');
+COMMENT ON SERVER app_replica IS 'The read replica';
+CREATE PUBLICATION app_pub FOR TABLE app.orders, app.users WITH (publish = 'insert, update');
+COMMENT ON PUBLICATION app_pub IS 'Order changes';
+CREATE FOREIGN TABLE app.remote_orders (id integer OPTIONS (column_name 'order_id') NOT NULL, status text DEFAULT 'placed', CONSTRAINT status_known CHECK (status IS NOT NULL)) SERVER app_replica OPTIONS (table_name 'orders');
+COMMENT ON FOREIGN TABLE app.remote_orders IS 'Orders on the replica';
+CREATE OPERATOR CLASS app.int_hash_ops FOR TYPE integer USING hash AS OPERATOR 1 =, FUNCTION 1 hashint4(integer);
+COMMENT ON OPERATOR CLASS app.int_hash_ops USING hash IS 'Hash by value';
+CREATE OPERATOR FAMILY app.spare_ops USING btree;
+CREATE TEXT SEARCH DICTIONARY app.shop_stop (TEMPLATE = simple, StopWords = english);
+CREATE TEXT SEARCH CONFIGURATION app.shop (PARSER = pg_catalog."default");
+ALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR asciiword, word WITH app.shop_stop, english_stem;
+ALTER TEXT SEARCH CONFIGURATION app.shop ADD MAPPING FOR int, uint WITH simple;
+COMMENT ON TEXT SEARCH CONFIGURATION app.shop IS 'Shop search';
 CREATE TABLE public._prisma_migrations (id varchar(36) PRIMARY KEY, checksum varchar(64) NOT NULL);
 `;

package/dist/postgres.d.ts

@@ -5,7 +5,7 @@
  * the statements are Postgres's own DDL, parsed at build time into entities,
  * and the names fold and quote as Postgres folds and quotes them.
  */
-export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, type PostgresEntityType, type PostgresSchema, type PostgresRelation, type PostgresTable, type PostgresView, type PostgresIndex, type PostgresSequence, type PostgresEnum, type PostgresCompositeType, type PostgresRangeType, type PostgresType, type PostgresDomain, type PostgresAggregate, type PostgresCollation, type PostgresCast, type PostgresEventTrigger, type PostgresExtension, type PostgresFunction, type PostgresProcedure, type PostgresTrigger, type PostgresPolicy, type PostgresRole, type PostgresGrant, type ColumnDef, type KeyDef, type CheckDef, type ForeignKeyDef, type ExclusionDef, type SchemaProps, type TableProps, type IndexProps, type ViewProps, type SequenceProps, type EnumProps, type CompositeTypeProps, type CompositeAttributeDef, type RangeTypeProps, type AggregateProps, type AggregateArgDef, type CollationProps, type CastProps, type EventTriggerProps, type DomainProps, type ExtensionProps, type RoutineProps, type RoutineArgDef, type FunctionProps, type ProcedureProps, type TriggerProps, type PolicyProps, type RoleProps, type GrantProps, type DefaultPrivilegesProps, type PrivilegeDef, type LineageEdge, type SqlSchema, type RowOf, type Column, type ColumnTraits, type AnyColumn, type UncheckedColumn, type KeyColumn, type NotNullColumn, type Named, type Unnamed, } from "./postgres/entities.js";
+export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, operator, operatorClass, operatorFamily, foreignTable, textSearchConfiguration, textSearchDictionary, statistics, foreignDataWrapper, foreignServer, publication, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, type PostgresEntityType, type PostgresSchema, type PostgresRelation, type PostgresTable, type PostgresView, type PostgresIndex, type PostgresSequence, type PostgresEnum, type PostgresCompositeType, type PostgresRangeType, type PostgresType, type PostgresDomain, type PostgresAggregate, type PostgresCollation, type PostgresCast, type PostgresEventTrigger, type PostgresOperator, type PostgresOperatorClass, type PostgresOperatorFamily, type PostgresForeignTable, type PostgresTextSearchConfiguration, type PostgresTextSearchDictionary, type PostgresStatistics, type PostgresForeignDataWrapper, type PostgresForeignServer, type PostgresPublication, type PostgresExtension, type PostgresFunction, type PostgresProcedure, type PostgresTrigger, type PostgresPolicy, type PostgresRole, type PostgresGrant, type ColumnDef, type KeyDef, type CheckDef, type ForeignKeyDef, type ExclusionDef, type SchemaProps, type TableProps, type IndexProps, type ViewProps, type SequenceProps, type EnumProps, type CompositeTypeProps, type CompositeAttributeDef, type RangeTypeProps, type AggregateProps, type AggregateArgDef, type CollationProps, type CastProps, type EventTriggerProps, type OperatorProps, type OperatorClassProps, type OperatorClassItemDef, type OperatorFamilyProps, type ForeignTableProps, type TextSearchConfigurationProps, type TextSearchDictionaryProps, type TextSearchMappingDef, type StatisticsProps, type ForeignDataWrapperProps, type ForeignServerProps, type PublicationProps, type PublicationTableDef, type DomainProps, type ExtensionProps, type RoutineProps, type RoutineArgDef, type FunctionProps, type ProcedureProps, type TriggerProps, type PolicyProps, type RoleProps, type GrantProps, type DefaultPrivilegesProps, type PrivilegeDef, type LineageEdge, type SqlSchema, type RowOf, type Column, type ColumnTraits, type AnyColumn, type UncheckedColumn, type KeyColumn, type NotNullColumn, type Named, type Unnamed, } from "./postgres/entities.js";
 export { POSTGRES_PROVIDERS, COMMON_REFUSED, providerData, isPostgresProvider, providerAllowsExtension, isProviderOwned, refusedStatement, normalizeStatement, type PostgresProvider, type ProviderData, type ProviderSource, type RefusedStatement, type LiveObjectRef, } from "./postgres/providers/index.js";
 export { PostgresMigrationOp, type PostgresMigrationOpConfig, type PostgresMigrationOpResources, type PostgresMigrationArgs, } from "./postgres/migrate/op.js";
 export { POSTGRES_RECEIPTS_TABLE } from "./postgres/migrate/receipts.js";

package/dist/postgres.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,MAAM,EACN,KAAK,EACL,KAAK,EACL,IAAI,EACJ,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,SAAS,EACT,IAAI,EACJ,SAAS,EACT,SAAS,EACT,OAAO,EACP,YAAY,EACZ,SAAS,EACT,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,KAAK,EACL,OAAO,EACP,UAAU,EACV,gBAAgB,EAChB,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,WAAW,EACX,UAAU,EACV,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAChB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,UAAU,EACf,KAAK,sBAAsB,EAC3B,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,SAAS,EACd,KAAK,KAAK,EACV,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,SAAS,EACd,KAAK,aAAa,EAClB,KAAK,KAAK,EACV,KAAK,OAAO,GACb,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EACL,kBAAkB,EAClB,cAAc,EACd,YAAY,EACZ,kBAAkB,EAClB,uBAAuB,EACvB,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,aAAa,GACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,mBAAmB,EACnB,KAAK,yBAAyB,EAC9B,KAAK,4BAA4B,EACjC,KAAK,qBAAqB,GAC3B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AACtE,cAAc,uBAAuB,CAAC;AAItC,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../src/postgres.ts"],"names":[],"mappings":"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"}

package/dist/postgres.js

@@ -5,7 +5,7 @@
  * the statements are Postgres's own DDL, parsed at build time into entities,
  * and the names fold and quote as Postgres folds and quotes them.
  */
-export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, } from "./postgres/entities.js";
+export { schema, table, index, view, sequence, type, domain, extension, func, procedure, aggregate, trigger, eventTrigger, operator, operatorClass, operatorFamily, foreignTable, textSearchConfiguration, textSearchDictionary, statistics, foreignDataWrapper, foreignServer, publication, collation, cast, policy, role, grant, literal, SqlLiteral, SqlTemplateError, PostgresObject, POSTGRES_ENTITY_TYPES, isPostgresObject, isColumnRef, quoteIdent, } from "./postgres/entities.js";
 export { POSTGRES_PROVIDERS, COMMON_REFUSED, providerData, isPostgresProvider, providerAllowsExtension, isProviderOwned, refusedStatement, normalizeStatement, } from "./postgres/providers/index.js";
 export { PostgresMigrationOp, } from "./postgres/migrate/op.js";
 export { POSTGRES_RECEIPTS_TABLE } from "./postgres/migrate/receipts.js";

package/dist/rules/audit-entries.ts

@@ -33,4 +33,5 @@ export const sqlPostSynthAuditEntries: Record<string, RuleMeta> = {
   SQLCH125: auditRule("SQLCH125", "merge-worthy", "guidance", "A codec parameter is outside what the codec takes", "Give the codec a parameter within its range or set, or drop the parameter for the default.", { category: "correctness" }),
   SQLCH126: auditRule("SQLCH126", "merge-worthy", "guidance", "A GRANT column list names a column the table does not declare", "Fix the column name, or declare the column on the table.", { category: "correctness" }),
   SQLCH127: auditRule("SQLCH127", "merge-worthy", "guidance", "An expression calls a function the pinned server does not have", "Fix the function name, use one from the pinned server's system.functions, or declare it with func.", { category: "correctness" }),
+  SQLCH128: auditRule("SQLCH128", "merge-worthy", "guidance", "An integration engine or table function argument holds a literal credential", "Create a named collection with the credentials on the server and name it in place of the arguments: ENGINE = S3(lake_creds, format = 'Parquet').", { category: "security" }),
 };

package/dist/rules/postgres-names.ts

@@ -474,6 +474,8 @@ export type OpClassResolution = { ok: true } | { ok: false; miss: Miss; otherMet
 /** An operator class for `method` at the target major. */
 export function resolveOpClass(p: PgProject, method: string, opclass: { schema?: string; name: string }): OpClassResolution {
   if (opclass.schema !== undefined && outsideProject(p, opclass.schema)) return { ok: true };
+  // A class the project declares (an `operatorClass` tag), for this method.
+  if (p.objects.some((o) => o.type === "Postgres::OperatorClass" && o.name === opclass.name && o.method === method && (opclass.schema === undefined || o.schema === opclass.schema))) return { ok: true };
   const classes = OPERATOR_CLASSES as Readonly<Record<string, Readonly<Record<string, Presence>>>>;
   if (presentAt(classes[method]?.[opclass.name], p.major)) return { ok: true };
   const ext = extensionFor(p, (e) => e.opclasses?.[method]?.includes(opclass.name) ?? false);

package/dist/rules/postgres-templates.ts

@@ -17,12 +17,12 @@ export const POSTGRES_TEMPLATE_SOURCES: readonly TemplateSource<PostgresTag>[] =
   {
     dialect: "postgres",
     modules: ["@intentius/chant-lexicon-sql/postgres"],
-    tags: ["schema", "table", "index", "view", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "collation", "cast", "policy", "role", "grant"],
+    tags: ["schema", "table", "index", "view", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "operator", "operatorClass", "operatorFamily", "foreignTable", "textSearchConfiguration", "textSearchDictionary", "statistics", "foreignDataWrapper", "foreignServer", "publication", "collation", "cast", "policy", "role", "grant"],
   },
   {
     dialect: "postgres",
     modules: ["@intentius/chant-lexicon-sql"],
-    tags: ["schema", "index", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "collation", "cast", "policy", "role", "grant"],
+    tags: ["schema", "index", "sequence", "type", "domain", "extension", "func", "procedure", "aggregate", "trigger", "eventTrigger", "operator", "operatorClass", "operatorFamily", "foreignTable", "textSearchConfiguration", "textSearchDictionary", "statistics", "foreignDataWrapper", "foreignServer", "publication", "collation", "cast", "policy", "role", "grant"],
   },
 ];