@pgpmjs/transform 0.18.0 → 0.20.0

package/module-source.d.ts

@@ -0,0 +1,33 @@
+/** One change of a loaded module: headerless, unwrapped deploy SQL. */
+export interface ModuleSourceChange {
+    /** Change name (plan token). */
+    name: string;
+    /** Change names this change requires, as recorded in the plan. */
+    dependencies: string[];
+    /** Deploy SQL with the pgpm header and BEGIN/COMMIT wrapper stripped. */
+    deploy: string;
+}
+/** A pgpm module loaded from disk, flattened in plan order. */
+export interface ModuleSource {
+    /** Module (project) name from pgpm.plan. */
+    name: string;
+    /** Absolute module directory. */
+    modulePath: string;
+    /** Changes in plan order. */
+    changes: ModuleSourceChange[];
+    /** Non-fatal notes (missing deploy scripts, etc.). */
+    warnings: string[];
+}
+/**
+ * Strip the transaction wrapper some modules carry inside their scripts
+ * (standalone `BEGIN;` / `COMMIT;` / `ROLLBACK;` lines). The caller owns
+ * transaction control.
+ */
+export declare const stripTransactionWrapper: (sql: string) => string;
+/**
+ * Load a pgpm module from disk: parse pgpm.plan and read each change's
+ * deploy script, stripping pgpm headers and transaction wrappers so the
+ * result can be flattened straight into the dials pipeline
+ * (`restructureChanges` / `partitionUnits`).
+ */
+export declare const loadModuleSource: (moduleDir: string) => ModuleSource;

package/module-source.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModuleSource = exports.stripTransactionWrapper = void 0;
+/**
+ * Module ingestion for the dials pipeline: load an on-disk pgpm module into
+ * the flattened, classified change list the transform/partition drivers
+ * consume. `pgpm transform` uses this today; a future `pgpm import` (dumps)
+ * and `pgpm diff` are expected to reuse the same seam.
+ */
+const ast_1 = require("@pgpmjs/ast");
+const path = __importStar(require("path"));
+const TX_LINE = /^\s*(BEGIN|COMMIT|ROLLBACK)\s*;\s*$/i;
+/**
+ * Strip the transaction wrapper some modules carry inside their scripts
+ * (standalone `BEGIN;` / `COMMIT;` / `ROLLBACK;` lines). The caller owns
+ * transaction control.
+ */
+const stripTransactionWrapper = (sql) => sql
+    .split('\n')
+    .filter(line => !TX_LINE.test(line))
+    .join('\n')
+    .trim();
+exports.stripTransactionWrapper = stripTransactionWrapper;
+/**
+ * Load a pgpm module from disk: parse pgpm.plan and read each change's
+ * deploy script, stripping pgpm headers and transaction wrappers so the
+ * result can be flattened straight into the dials pipeline
+ * (`restructureChanges` / `partitionUnits`).
+ */
+const loadModuleSource = (moduleDir) => {
+    const modulePath = path.resolve(moduleDir);
+    const planResult = (0, ast_1.parsePlanFile)(path.join(modulePath, 'pgpm.plan'));
+    if (!planResult.data) {
+        const reasons = planResult.errors.map(e => e.message).join(', ');
+        throw new Error(`Failed to parse pgpm.plan in ${modulePath}: ${reasons}`);
+    }
+    const warnings = [];
+    const changes = [];
+    for (const change of planResult.data.changes) {
+        const raw = (0, ast_1.readScript)(modulePath, 'deploy', change.name);
+        if (!raw) {
+            warnings.push(`${change.name}: no deploy script found, skipping`);
+            continue;
+        }
+        const { body } = (0, ast_1.parsePgpmHeader)(raw);
+        changes.push({
+            name: change.name,
+            dependencies: change.dependencies ?? [],
+            deploy: (0, exports.stripTransactionWrapper)(body)
+        });
+    }
+    return {
+        name: planResult.data.package,
+        modulePath,
+        changes,
+        warnings
+    };
+};
+exports.loadModuleSource = loadModuleSource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/transform",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Change-aware SQL transformation for PGPM — superset of @pgsql/transform plus change categorization, fixture closure, and bundle transpile/apply drivers",
   "main": "index.js",
@@ -39,14 +39,15 @@
     "plpgsql"
   ],
   "devDependencies": {
-    "@pgpmjs/bundle": "^0.13.2",
+    "@pgpmjs/bundle": "^0.13.3",
     "makage": "^0.3.0"
   },
   "dependencies": {
-    "@pgpmjs/naming-spec": "^0.1.2",
-    "@pgsql/scripts": "^18.1.0",
-    "@pgsql/transform": "^18.11.0",
-    "plpgsql-parser": "^18.2.3"
+    "@pgpmjs/ast": "^0.10.3",
+    "@pgpmjs/naming-spec": "^0.2.0",
+    "@pgsql/scripts": "^18.3.1",
+    "@pgsql/transform": "^18.14.1",
+    "plpgsql-parser": "^18.5.1"
   },
-  "gitHead": "6d3e25dc5c9f93421dba49ddedf93239f87213a8"
+  "gitHead": "e6a7a57f88c9deb2a4acecaba2451320d1be8203"
 }

package/partition.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Partition dial wiring shared by `pgpm transform --partition` and
+ * `pgpm export --partition`: parse a partition config file, run
+ * `partitionUnits` (`@pgpmjs/transform`), and lift the emitted packages back
+ * onto the PgpmRow seam with generated revert/verify per change.
+ */
+import { PgpmRow } from '@pgpmjs/ast';
+import { PartitionConfig } from './partition-driver';
+export type { PartitionConfig } from './partition-driver';
+/**
+ * Parse and validate a partition config file (JSON matching
+ * `PartitionConfig`: rules, defaultPackage, optional style/splitRiders).
+ * Throws with a message naming the offending field.
+ */
+export declare const parsePartitionConfig: (filePath: string) => PartitionConfig;
+/** One partitioned package on the PgpmRow seam, ready to write to disk. */
+export interface PartitionedPackageRows {
+    name: string;
+    /** Package names this package requires (cross-package edges). */
+    requires: string[];
+    rows: PgpmRow[];
+}
+export interface PartitionExportRowsResult {
+    packages: PartitionedPackageRows[];
+    warnings: string[];
+}
+/**
+ * Partition changes into packages and generate revert/verify for every
+ * emitted change. Cross-package dependencies keep the `<pkg>:<path>`
+ * convention in `deps`. May throw `PartitionCycleError`.
+ */
+export declare const partitionExportRows: (rows: PgpmRow[], config: PartitionConfig) => Promise<PartitionExportRowsResult>;

package/partition.js

@@ -0,0 +1,127 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.partitionExportRows = exports.parsePartitionConfig = void 0;
+const fs = __importStar(require("fs"));
+const plpgsql_parser_1 = require("plpgsql-parser");
+const partition_driver_1 = require("./partition-driver");
+const regen_1 = require("./regen");
+const PATH_STYLES = ['directory', 'flat'];
+/**
+ * Parse and validate a partition config file (JSON matching
+ * `PartitionConfig`: rules, defaultPackage, optional style/splitRiders).
+ * Throws with a message naming the offending field.
+ */
+const parsePartitionConfig = (filePath) => {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Partition config not found: ${filePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Partition config is not valid JSON (${filePath}): ${err?.message ?? err}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Partition config must be a JSON object (${filePath})`);
+    }
+    if (typeof parsed.defaultPackage !== 'string' || !parsed.defaultPackage) {
+        throw new Error('Partition config: "defaultPackage" must be a non-empty string');
+    }
+    if (!Array.isArray(parsed.rules)) {
+        throw new Error('Partition config: "rules" must be an array');
+    }
+    parsed.rules.forEach((rule, i) => {
+        if (typeof rule !== 'object' || rule === null) {
+            throw new Error(`Partition config: rules[${i}] must be an object`);
+        }
+        if (typeof rule.package !== 'string' || !rule.package) {
+            throw new Error(`Partition config: rules[${i}].package must be a non-empty string`);
+        }
+        if (!Array.isArray(rule.select) || rule.select.length === 0) {
+            throw new Error(`Partition config: rules[${i}].select must be a non-empty array of selectors`);
+        }
+    });
+    if (parsed.style !== undefined && !PATH_STYLES.includes(parsed.style)) {
+        throw new Error(`Partition config: "style" must be one of: ${PATH_STYLES.join(', ')}`);
+    }
+    if (parsed.splitRiders !== undefined && !Array.isArray(parsed.splitRiders)) {
+        throw new Error('Partition config: "splitRiders" must be an array of statement kinds');
+    }
+    return parsed;
+};
+exports.parsePartitionConfig = parsePartitionConfig;
+/**
+ * Partition changes into packages and generate revert/verify for every
+ * emitted change. Cross-package dependencies keep the `<pkg>:<path>`
+ * convention in `deps`. May throw `PartitionCycleError`.
+ */
+const partitionExportRows = async (rows, config) => {
+    await (0, plpgsql_parser_1.loadModule)();
+    const input = rows.map(row => ({
+        name: row.deploy,
+        dependencies: row.deps ?? [],
+        deploy: row.content
+    }));
+    const { packages, warnings } = (0, partition_driver_1.partitionUnits)(input, config);
+    const result = packages.map(pkg => ({
+        name: pkg.name,
+        requires: pkg.requires,
+        rows: pkg.changes.map(change => {
+            const scripts = (0, regen_1.regenerateScripts)(change.deploy);
+            for (const warning of scripts.revert.warnings) {
+                warnings.push(`${pkg.name}:${change.name}: ${warning}`);
+            }
+            for (const warning of scripts.verify.warnings) {
+                warnings.push(`${pkg.name}:${change.name}: ${warning}`);
+            }
+            return {
+                name: change.name,
+                deploy: change.name,
+                deps: change.dependencies,
+                content: change.deploy,
+                revert: scripts.revert.sql,
+                verify: scripts.verify.sql
+            };
+        })
+    }));
+    return { packages: result, warnings };
+};
+exports.partitionExportRows = partitionExportRows;

package/restructure.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Granularity dial for `pgpm export`: route exported sql_actions rows through
+ * the dials pipeline (`restructureChanges` in `@pgpmjs/transform`) so change
+ * paths are derived from the naming spec (`identityOf` + `pathFor`) and
+ * `requires` come from the statement dependency graph instead of the
+ * hand-chained deps recorded at action time.
+ */
+import { PgpmRow } from '@pgpmjs/ast';
+import { PathStyle } from '@pgpmjs/naming-spec';
+import { Granularity } from '@pgsql/transform';
+import { ChangeGranularity } from './granularity-driver';
+export type ExportGranularity = Granularity;
+export declare const EXPORT_GRANULARITIES: readonly ExportGranularity[];
+export declare const isExportGranularity: (value: unknown) => value is ExportGranularity;
+export interface RestructureExportRowsResult {
+    rows: PgpmRow[];
+    warnings: string[];
+}
+export interface RestructureExportRowsOptions {
+    /** Naming-spec rendering style for derived paths (default `directory`). */
+    naming?: PathStyle;
+    /**
+     * Change-level distribution (default `object`): with `alteration`, each
+     * `ADD COLUMN` / `ADD CONSTRAINT` becomes its own change. See
+     * {@link ChangeGranularity}.
+     */
+    changeGranularity?: ChangeGranularity;
+}
+/**
+ * Restructure exported migration rows to the target granularity.
+ *
+ * The rows' deploy SQL is flattened in export order, restructured, and
+ * re-sliced into per-object changes whose paths come from the naming spec and
+ * whose deps come from the statement graph. When two changes derive the same
+ * path (the same object altered again), later occurrences get the spec's
+ * alteration convention via `alterationPathFor` (monotonic per-parent
+ * counter), with the parent added to their deps.
+ *
+ * Revert/verify scripts are not carried through from the original rows (the
+ * restructured grouping no longer matches them one-to-one); instead each
+ * change gets scripts generated from its own statements via
+ * `revertFor`/`verifyFor` (drops in reverse topological order, one existence
+ * check per created object).
+ */
+export declare const restructureExportRows: (rows: PgpmRow[], granularity: ExportGranularity, options?: RestructureExportRowsOptions) => Promise<RestructureExportRowsResult>;

package/restructure.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restructureExportRows = exports.isExportGranularity = exports.EXPORT_GRANULARITIES = void 0;
+const naming_spec_1 = require("@pgpmjs/naming-spec");
+const transform_1 = require("@pgsql/transform");
+const plpgsql_parser_1 = require("plpgsql-parser");
+const granularity_driver_1 = require("./granularity-driver");
+exports.EXPORT_GRANULARITIES = ['atomic', 'object', 'consolidated'];
+const isExportGranularity = (value) => typeof value === 'string' && exports.EXPORT_GRANULARITIES.includes(value);
+exports.isExportGranularity = isExportGranularity;
+/**
+ * Restructure exported migration rows to the target granularity.
+ *
+ * The rows' deploy SQL is flattened in export order, restructured, and
+ * re-sliced into per-object changes whose paths come from the naming spec and
+ * whose deps come from the statement graph. When two changes derive the same
+ * path (the same object altered again), later occurrences get the spec's
+ * alteration convention via `alterationPathFor` (monotonic per-parent
+ * counter), with the parent added to their deps.
+ *
+ * Revert/verify scripts are not carried through from the original rows (the
+ * restructured grouping no longer matches them one-to-one); instead each
+ * change gets scripts generated from its own statements via
+ * `revertFor`/`verifyFor` (drops in reverse topological order, one existence
+ * check per created object).
+ */
+const restructureExportRows = async (rows, granularity, options = {}) => {
+    await (0, plpgsql_parser_1.loadModule)();
+    const style = options.naming ?? 'directory';
+    const changeName = (facts) => {
+        const identity = (0, transform_1.identityOf)(facts);
+        if (identity)
+            return (0, naming_spec_1.pathFor)(identity, { style });
+        return 'misc/statements';
+    };
+    const { changes, warnings } = (0, granularity_driver_1.restructureChanges)(rows.map(row => ({
+        name: row.deploy,
+        dependencies: row.deps ?? [],
+        deploy: row.content
+    })), {
+        granularity,
+        changeGranularity: options.changeGranularity,
+        changeName,
+        subObjectName: identity => (0, naming_spec_1.pathFor)(identity, { style })
+    });
+    const counters = new Map();
+    const taken = new Set();
+    const restructured = changes.map(change => {
+        let deploy = change.name;
+        const deps = [...change.dependencies];
+        if (taken.has(deploy)) {
+            let n = (counters.get(change.name) ?? 0) + 1;
+            while (taken.has((0, naming_spec_1.alterationPathFor)(change.name, n)))
+                n++;
+            counters.set(change.name, n);
+            deploy = (0, naming_spec_1.alterationPathFor)(change.name, n);
+            if (!deps.includes(change.name))
+                deps.push(change.name);
+        }
+        taken.add(deploy);
+        return {
+            name: deploy,
+            deploy,
+            deps,
+            content: change.deploy,
+            revert: change.revert,
+            verify: change.verify
+        };
+    });
+    return { rows: restructured, warnings };
+};
+exports.restructureExportRows = restructureExportRows;

package/semantic-diff-driver.d.ts

@@ -29,7 +29,7 @@
 import { PathStyle } from '@pgpmjs/naming-spec';
 import type { ObjectIdentity } from '@pgsql/transform';
 import { Granularity } from '@pgsql/transform';
-import { GranularityChange } from './granularity-driver';
+import { ChangeGranularity, GranularityChange } from './granularity-driver';
 /** How one object differs between the two sides. */
 export type ObjectDelta = 'added' | 'removed' | 'modified';
 export interface SemanticObjectDiff {
@@ -45,6 +45,8 @@ export interface SemanticObjectDiff {
 export interface SemanticDiffOptions {
     /** Granularity for the emitted CREATE/ALTER changes (default `object`). */
     granularity?: Granularity;
+    /** Change-level distribution for emitted changes (default `object`). */
+    changeGranularity?: ChangeGranularity;
     /** Naming-spec rendering style (default `directory`). */
     style?: PathStyle;
 }

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 })};`;
@@ -214,32 +301,46 @@ function diffTable(from, to, diff, warnings) {
             stmts.push(alter({ subtype: 'AT_DropColumn', name }));
         }
     }
-    for (const [print, extra] of to.extras) {
-        if (!from.extras.has(print)) {
-            const at = extra.AlterTableCmd;
-            if (at)
-                stmts.push(alter(at));
-            else if (extra.Constraint) {
-                stmts.push(alter({ subtype: 'AT_AddConstraint', def: extra }));
-            }
-            else {
-                warnings.push(`${diff.path}: unrecognized added table element; emit a manual ALTER`);
-            }
-        }
-    }
+    // Self-inverse ALTER TABLE subtypes: a removed extra with one of these
+    // undoes with the paired subtype rather than a DROP CONSTRAINT.
+    const INVERSE_SUBTYPE = {
+        AT_EnableRowSecurity: 'AT_DisableRowSecurity',
+        AT_DisableRowSecurity: 'AT_EnableRowSecurity',
+        AT_ForceRowSecurity: 'AT_NoForceRowSecurity',
+        AT_NoForceRowSecurity: 'AT_ForceRowSecurity'
+    };
+    // Removed extras drop before added ones: a changed constraint that keeps
+    // its name must DROP CONSTRAINT before the replacement ADD CONSTRAINT.
     for (const [print, extra] of from.extras) {
         if (to.extras.has(print))
             continue;
         const conname = extra.Constraint?.conname
             ?? extra
                 .AlterTableCmd?.def?.Constraint?.conname;
+        const subtype = extra.AlterTableCmd?.subtype;
         if (conname) {
             stmts.push(alter({ subtype: 'AT_DropConstraint', name: conname }));
         }
+        else if (subtype && INVERSE_SUBTYPE[subtype]) {
+            stmts.push(alter({ subtype: INVERSE_SUBTYPE[subtype] }));
+        }
         else {
             warnings.push(`${diff.path}: removed table element has no name to drop; emit a manual ALTER`);
         }
     }
+    for (const [print, extra] of to.extras) {
+        if (!from.extras.has(print)) {
+            const at = extra.AlterTableCmd;
+            if (at)
+                stmts.push(alter(at));
+            else if (extra.Constraint) {
+                stmts.push(alter({ subtype: 'AT_AddConstraint', def: extra }));
+            }
+            else {
+                warnings.push(`${diff.path}: unrecognized added table element; emit a manual ALTER`);
+            }
+        }
+    }
     return stmts;
 }
 /**
@@ -375,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),