@pgpmjs/transform 0.19.0 → 0.20.0

package/semantic-diff-driver.js

@@ -34,6 +34,7 @@ const naming_spec_1 = require("@pgpmjs/naming-spec");
 const scripts_1 = require("@pgsql/scripts");
 const transform_1 = require("@pgsql/transform");
 const plpgsql_parser_1 = require("plpgsql-parser");
+const constraint_names_1 = require("./constraint-names");
 const granularity_driver_1 = require("./granularity-driver");
 const identityKey = (id) => `${id.kind}\u0000${id.schema ?? ''}\u0000${id.table ?? ''}\u0000${id.name}`;
 /**
@@ -103,7 +104,7 @@ function groupingIdentity(f) {
     const identity = (0, transform_1.identityOf)(f);
     if (!identity)
         return null;
-    if ((f.kind === 'table' || f.kind === 'constraint' || f.kind === 'rls_enable') &&
+    if ((f.kind === 'table' || f.kind === 'constraint' || f.kind === 'fk_constraint' || f.kind === 'rls_enable') &&
         identity.kind !== 'table') {
         return { kind: 'table', schema: identity.schema, name: identity.table ?? identity.name };
     }
@@ -116,21 +117,61 @@ function fingerprint(text) {
 }
 /** Multiset fingerprint of a whole unit. */
 const unitFingerprint = (unit) => unit.texts.map(fingerprint).sort().join('\n');
+/** JSON with recursively sorted object keys — an insertion-order-proof fingerprint. */
+function stablePrint(node) {
+    if (Array.isArray(node))
+        return `[${node.map(stablePrint).join(',')}]`;
+    if (node && typeof node === 'object') {
+        const entries = Object.entries(node)
+            .filter(([, v]) => v !== undefined)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([k, v]) => `${JSON.stringify(k)}:${stablePrint(v)}`);
+        return `{${entries.join(',')}}`;
+    }
+    return JSON.stringify(node);
+}
+/** Constraint kinds that can move between column, table-elt, and ALTER form. */
+const RELOCATABLE = new Set(['CONSTR_PRIMARY', 'CONSTR_UNIQUE', 'CONSTR_FOREIGN', 'CONSTR_CHECK']);
 /**
  * Fold a table unit's statements (CREATE TABLE plus any ALTER TABLE
  * ADD COLUMN / ADD CONSTRAINT) into an effective shape, so atomic and
  * consolidated authorships of the same table compare equal.
+ *
+ * Constraint placement is representation, not semantics: `id bigint PRIMARY
+ * KEY`, a `PRIMARY KEY (id)` table elt, and `ALTER TABLE .. ADD CONSTRAINT
+ * t_pkey PRIMARY KEY (id)` all catalog identically. Relocatable constraints
+ * (PK/UNIQUE/FK/CHECK) are therefore lifted out of columns and ALTER
+ * commands into one canonical table-level set — keyed with the Postgres
+ * default name when unnamed, columns filled in from the owning column when
+ * column-attached — and PK columns gain the NOT NULL the catalog implies.
  */
 function tableShape(unit) {
     const shape = { relation: null, columns: new Map(), extras: new Map() };
+    const table = unit.identity.name;
+    const rawColumns = [];
+    const constraints = [];
+    const pkColumns = new Set();
     const addColumn = (node) => {
-        const def = node;
-        const clean = (0, transform_1.cleanTree)(node);
-        shape.columns.set(def.colname ?? '', { def: clean, print: JSON.stringify(clean) });
+        const colname = node.colname ?? '';
+        const attached = node.constraints ?? [];
+        const residual = [];
+        for (const item of attached) {
+            const c = item.Constraint;
+            if (c && RELOCATABLE.has(c.contype ?? '')) {
+                constraints.push({ node: c, column: colname });
+            }
+            else {
+                residual.push(item);
+            }
+        }
+        rawColumns.push({ colname, def: { ...node, constraints: residual } });
+    };
+    const addConstraint = (node, column) => {
+        constraints.push({ node: node, column });
     };
     const addExtra = (node) => {
         const clean = (0, transform_1.cleanTree)(node);
-        shape.extras.set(JSON.stringify(clean), clean);
+        shape.extras.set(stablePrint(clean), clean);
     };
     for (const text of unit.texts) {
         for (const raw of (0, plpgsql_parser_1.parseSync)(text).sql.stmts) {
@@ -141,6 +182,9 @@ function tableShape(unit) {
                 for (const elt of elts) {
                     if (elt.ColumnDef)
                         addColumn(elt.ColumnDef);
+                    else if (elt.Constraint && RELOCATABLE.has(elt.Constraint.contype ?? '')) {
+                        addConstraint(elt.Constraint);
+                    }
                     else
                         addExtra(elt);
                 }
@@ -156,6 +200,11 @@ function tableShape(unit) {
                     if (at.subtype === 'AT_AddColumn' && def?.ColumnDef) {
                         addColumn(def.ColumnDef);
                     }
+                    else if (at.subtype === 'AT_AddConstraint' &&
+                        def?.Constraint &&
+                        RELOCATABLE.has(def.Constraint.contype ?? '')) {
+                        addConstraint(def.Constraint);
+                    }
                     else {
                         addExtra({ AlterTableCmd: at });
                     }
@@ -166,6 +215,44 @@ function tableShape(unit) {
             }
         }
     }
+    for (const { node, column } of constraints) {
+        const canonical = { ...node };
+        canonical.conname = node.conname ?? (0, constraint_names_1.defaultConstraintName)(table, node, column) ?? undefined;
+        if (column && (node.keys ?? []).length === 0 && node.contype !== 'CONSTR_FOREIGN' && node.contype !== 'CONSTR_CHECK') {
+            canonical.keys = [{ String: { sval: column } }];
+        }
+        if (column && node.contype === 'CONSTR_FOREIGN' && (node.fk_attrs ?? []).length === 0) {
+            canonical.fk_attrs = [{ String: { sval: column } }];
+        }
+        if (node.contype === 'CONSTR_PRIMARY') {
+            const keyed = canonical.keys ?? [];
+            for (const k of keyed)
+                if (k.String?.sval)
+                    pkColumns.add(k.String.sval);
+        }
+        addExtra({ Constraint: canonical });
+    }
+    for (const { colname, def } of rawColumns) {
+        const residual = (def.constraints ?? []).map(c => {
+            const constraint = c.Constraint;
+            // NOT NULL parses with parser-version-dependent extras (is_enforced,
+            // initially_valid); reduce to its semantic core so an authored NOT NULL
+            // equals the one a primary key implies.
+            if (constraint?.contype === 'CONSTR_NOTNULL') {
+                return { Constraint: { contype: 'CONSTR_NOTNULL', conname: constraint.conname } };
+            }
+            return c;
+        });
+        const hasNotNull = residual.some(c => c.Constraint?.contype === 'CONSTR_NOTNULL');
+        if (pkColumns.has(colname) && !hasNotNull) {
+            residual.push({ Constraint: { contype: 'CONSTR_NOTNULL' } });
+        }
+        const sorted = residual
+            .map(c => (0, transform_1.cleanTree)(c))
+            .sort((x, y) => stablePrint(x).localeCompare(stablePrint(y)));
+        const clean = (0, transform_1.cleanTree)({ ...def, constraints: sorted });
+        shape.columns.set(colname, { def: clean, print: stablePrint(clean) });
+    }
     return shape;
 }
 const deparseStmt = (node) => `${plpgsql_parser_1.Deparser.deparse(node, { pretty: false })};`;
@@ -389,7 +476,11 @@ function diffSchemas(from, to, options = {}) {
     }
     let forwardChanges = [];
     if (forwardSql.length > 0) {
-        const { changes, warnings: w } = (0, granularity_driver_1.restructureChanges)([{ name: 'delta', dependencies: [], deploy: forwardSql.join('\n\n') }], { granularity: options.granularity ?? 'object' });
+        const { changes, warnings: w } = (0, granularity_driver_1.restructureChanges)([{ name: 'delta', dependencies: [], deploy: forwardSql.join('\n\n') }], {
+            granularity: options.granularity ?? 'object',
+            changeGranularity: options.changeGranularity,
+            subObjectName: identity => (0, naming_spec_1.pathFor)(identity, { style })
+        });
         forwardChanges = changes.map(c => ({
             ...c,
             revert: inverseOf(c.deploy, c.name),

package/sub-object.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Sub-object identities: the column or constraint a single `ALTER TABLE`
+ * statement adds.
+ *
+ * `identityOf` summarizes an ALTER TABLE by the table it targets — the right
+ * grouping key for object-level changes, but lossy one level down: the added
+ * column's `colname` and the added constraint's `conname` stay behind in the
+ * raw parse node (`facts.stmt`). This module recovers them, giving the
+ * change-granularity pipeline a stable identity (and naming-spec path) for
+ * every alteration.
+ */
+import type { ObjectIdentity } from '@pgpmjs/naming-spec';
+import type { StatementFacts } from '@pgsql/transform';
+/**
+ * The column or constraint a one-command `ALTER TABLE .. ADD COLUMN` /
+ * `ADD CONSTRAINT` statement adds, as a naming-spec identity
+ * (`kind: 'column' | 'constraint'`, `table` set). Unnamed constraints get
+ * their Postgres default name. Returns `null` for anything else — multi-
+ * command ALTERs, other subtypes, non-ALTER statements — so callers fall
+ * back to object-level grouping.
+ */
+export declare function subObjectIdentityOf(facts: StatementFacts): ObjectIdentity | null;
+/**
+ * Rewrite a script so every unnamed `ALTER TABLE .. ADD <constraint>` carries
+ * its Postgres default name (`ADD PRIMARY KEY (id)` becomes `ADD CONSTRAINT
+ * {table}_pkey PRIMARY KEY (id)`) — the exact name the catalog would assign
+ * anyway. Naming them makes each constraint change independently revertible
+ * (`DROP CONSTRAINT <name>`) and verifiable. Statements that need no rewrite
+ * keep their original text.
+ */
+export declare function nameUnnamedConstraints(sql: string): string;

package/sub-object.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subObjectIdentityOf = subObjectIdentityOf;
+exports.nameUnnamedConstraints = nameUnnamedConstraints;
+const plpgsql_parser_1 = require("plpgsql-parser");
+const constraint_names_1 = require("./constraint-names");
+/** The single AlterTableCmd of a one-command ALTER TABLE, or null. */
+function singleCmd(stmt) {
+    const cmds = stmt.cmds ?? [];
+    if (cmds.length !== 1)
+        return null;
+    return cmds[0].AlterTableCmd ?? null;
+}
+/**
+ * The column or constraint a one-command `ALTER TABLE .. ADD COLUMN` /
+ * `ADD CONSTRAINT` statement adds, as a naming-spec identity
+ * (`kind: 'column' | 'constraint'`, `table` set). Unnamed constraints get
+ * their Postgres default name. Returns `null` for anything else — multi-
+ * command ALTERs, other subtypes, non-ALTER statements — so callers fall
+ * back to object-level grouping.
+ */
+function subObjectIdentityOf(facts) {
+    const stmt = facts.stmt?.AlterTableStmt;
+    if (!stmt?.relation?.relname)
+        return null;
+    const cmd = singleCmd(stmt);
+    if (!cmd)
+        return null;
+    const schema = stmt.relation.schemaname ?? null;
+    const table = stmt.relation.relname;
+    if (cmd.subtype === 'AT_AddColumn' && cmd.def?.ColumnDef?.colname) {
+        return { kind: 'column', schema, name: cmd.def.ColumnDef.colname, table };
+    }
+    if (cmd.subtype === 'AT_AddConstraint' && cmd.def?.Constraint) {
+        const constraint = cmd.def.Constraint;
+        const name = constraint.conname ?? (0, constraint_names_1.defaultConstraintName)(table, constraint);
+        if (!name)
+            return null;
+        return { kind: 'constraint', schema, name, table };
+    }
+    return null;
+}
+/**
+ * Rewrite a script so every unnamed `ALTER TABLE .. ADD <constraint>` carries
+ * its Postgres default name (`ADD PRIMARY KEY (id)` becomes `ADD CONSTRAINT
+ * {table}_pkey PRIMARY KEY (id)`) — the exact name the catalog would assign
+ * anyway. Naming them makes each constraint change independently revertible
+ * (`DROP CONSTRAINT <name>`) and verifiable. Statements that need no rewrite
+ * keep their original text.
+ */
+function nameUnnamedConstraints(sql) {
+    const parsed = (0, plpgsql_parser_1.parseSync)(sql);
+    const pieces = [];
+    for (const raw of parsed.sql.stmts) {
+        const node = raw.stmt;
+        const stmt = node.AlterTableStmt;
+        const table = stmt?.relation?.relname;
+        let rewritten = false;
+        if (stmt && table) {
+            for (const cmd of stmt.cmds ?? []) {
+                const at = cmd.AlterTableCmd;
+                const constraint = at?.subtype === 'AT_AddConstraint' ? at.def?.Constraint : undefined;
+                if (constraint && !constraint.conname) {
+                    const name = (0, constraint_names_1.defaultConstraintName)(table, constraint);
+                    if (name) {
+                        constraint.conname = name;
+                        rewritten = true;
+                    }
+                }
+            }
+        }
+        if (rewritten) {
+            pieces.push(`${plpgsql_parser_1.Deparser.deparse(node, { pretty: true })};`);
+        }
+        else {
+            const start = raw.stmt_location ?? 0;
+            const len = raw.stmt_len;
+            const text = len === undefined ? sql.slice(start) : sql.slice(start, start + len);
+            const trimmed = text.trim();
+            pieces.push(trimmed.endsWith(';') ? trimmed : `${trimmed};`);
+        }
+    }
+    return pieces.join('\n\n');
+}