@pgpmjs/transform 0.18.0 → 0.20.0

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');
+}