@pgpmjs/transform 0.15.3 → 0.17.0

package/esm/semantic-diff-driver.js

@@ -0,0 +1,366 @@
+/**
+ * Semantic diff driver: identity-keyed schema delta between two deploy
+ * surfaces.
+ *
+ * Where `diffBundles` (in `@pgpmjs/bundle`) compares change names and content
+ * digests — which breaks the moment a dial regroups or renames changes — this
+ * driver re-keys the comparison on object identity (`identityOf`), so the
+ * same schema authored at different granularities or partitions diffs as
+ * equal. Objects are compared at the AST level (normalized parse trees, so
+ * formatting never matters); tables are compared column-by-column and
+ * constraint-by-constraint so an added column emits `ALTER TABLE ADD COLUMN`,
+ * not a table rebuild.
+ *
+ * The emitted delta is a set of pgpm changes: DROPs for removed objects
+ * (reverse topological order), then CREATE/ALTER changes for added and
+ * modified objects routed through the granularity pipeline
+ * (`restructureChanges`), so names come from the naming spec and `requires`
+ * from the statement graph — the same derivation every other projection uses.
+ * Every emitted change carries a full deploy/revert/verify triple: drops are
+ * `@pgsql/scripts`' `revertFor` inverses of the object's own deploy
+ * statements (never hand-templated), reverts recreate what was dropped, and
+ * verifies come from `verifyFor`.
+ *
+ * Requires `loadModule()` from `plpgsql-parser` before use.
+ */
+import { pathFor } from '@pgpmjs/naming-spec';
+import { revertFor, verifyFor } from '@pgsql/scripts';
+import { buildStatementGraph, classifyStatements, cleanTree, identityOf } from '@pgsql/transform';
+import { Deparser, parseSync } from 'plpgsql-parser';
+import { restructureChanges } from './granularity-driver';
+const identityKey = (id) => `${id.kind}\u0000${id.schema ?? ''}\u0000${id.table ?? ''}\u0000${id.name}`;
+/**
+ * Group one side's script into identity-keyed object units. Statements with
+ * no identity (grants, comments) attach to the unit of the first object they
+ * reference, falling back to the preceding statement's unit; truly homeless
+ * statements are reported via `warnings`.
+ */
+function readSide(sql, warnings, label) {
+    const facts = classifyStatements(sql);
+    const graph = buildStatementGraph(facts);
+    const units = new Map();
+    const order = [];
+    const unitOf = new Array(facts.length).fill(null);
+    const byObject = new Map();
+    facts.forEach((f, i) => {
+        const text = sql.slice(f.span.start, f.span.start + f.span.len).trim();
+        if (!text)
+            return;
+        let identity = groupingIdentity(f);
+        if (identity && identity.kind === 'other') {
+            const asTable = identityKey({ kind: 'table', schema: identity.schema, name: identity.name });
+            if (units.has(asTable))
+                identity = units.get(asTable).identity;
+        }
+        let key = null;
+        if (identity) {
+            key = identityKey(identity);
+            if (!units.has(key)) {
+                units.set(key, { identity, statements: [], texts: [] });
+                order.push(key);
+            }
+            if (!identity.table) {
+                byObject.set(`${identity.schema ?? ''}.${identity.name}`, key);
+            }
+        }
+        else {
+            for (const r of f.references) {
+                const host = byObject.get(`${r.schema ?? ''}.${r.name}`);
+                if (host) {
+                    key = host;
+                    break;
+                }
+            }
+            if (!key && i > 0)
+                key = unitOf[i - 1];
+        }
+        if (!key) {
+            warnings.push(`${label}: statement ${i} (${f.kind}) belongs to no object; ignored in the diff`);
+            return;
+        }
+        unitOf[i] = key;
+        const unit = units.get(key);
+        unit.statements.push(i);
+        unit.texts.push(text.endsWith(';') ? text : `${text};`);
+    });
+    return { facts, units, order, graph };
+}
+/**
+ * The identity a statement groups under. Table-shaping statements — ALTER
+ * TABLE column/constraint additions, RLS enablement — fold into their table's
+ * unit so that atomic and consolidated authorships of the same table land in
+ * the same unit and compare shape-to-shape. Generic ALTERs (`kind: 'other'`)
+ * fold in `readSide` when a table unit for the same object already exists.
+ */
+function groupingIdentity(f) {
+    const identity = identityOf(f);
+    if (!identity)
+        return null;
+    if ((f.kind === 'table' || f.kind === 'constraint' || f.kind === 'rls_enable') &&
+        identity.kind !== 'table') {
+        return { kind: 'table', schema: identity.schema, name: identity.table ?? identity.name };
+    }
+    return identity;
+}
+/** Normalized-AST fingerprint of one statement (formatting/position-proof). */
+function fingerprint(text) {
+    const parsed = parseSync(text);
+    return JSON.stringify(cleanTree(parsed.sql.stmts.map(s => s.stmt)));
+}
+/** Multiset fingerprint of a whole unit. */
+const unitFingerprint = (unit) => unit.texts.map(fingerprint).sort().join('\n');
+/**
+ * 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.
+ */
+function tableShape(unit) {
+    const shape = { relation: null, columns: new Map(), extras: new Map() };
+    const addColumn = (node) => {
+        const def = node;
+        const clean = cleanTree(node);
+        shape.columns.set(def.colname ?? '', { def: clean, print: JSON.stringify(clean) });
+    };
+    const addExtra = (node) => {
+        const clean = cleanTree(node);
+        shape.extras.set(JSON.stringify(clean), clean);
+    };
+    for (const text of unit.texts) {
+        for (const raw of parseSync(text).sql.stmts) {
+            const stmt = raw.stmt;
+            if (stmt.CreateStmt) {
+                shape.relation = stmt.CreateStmt.relation;
+                const elts = stmt.CreateStmt.tableElts ?? [];
+                for (const elt of elts) {
+                    if (elt.ColumnDef)
+                        addColumn(elt.ColumnDef);
+                    else
+                        addExtra(elt);
+                }
+            }
+            else if (stmt.AlterTableStmt) {
+                shape.relation ??= stmt.AlterTableStmt.relation;
+                const cmds = stmt.AlterTableStmt.cmds ?? [];
+                for (const cmd of cmds) {
+                    const at = cmd.AlterTableCmd;
+                    if (!at)
+                        continue;
+                    const def = at.def;
+                    if (at.subtype === 'AT_AddColumn' && def?.ColumnDef) {
+                        addColumn(def.ColumnDef);
+                    }
+                    else {
+                        addExtra({ AlterTableCmd: at });
+                    }
+                }
+            }
+            else {
+                addExtra(stmt);
+            }
+        }
+    }
+    return shape;
+}
+const deparseStmt = (node) => `${Deparser.deparse(node, { pretty: false })};`;
+/** Column-level ALTERs between two table shapes. */
+function diffTable(from, to, diff, warnings) {
+    const stmts = [];
+    const relation = to.relation ?? from.relation;
+    const alter = (cmd) => deparseStmt({
+        AlterTableStmt: {
+            relation,
+            cmds: [{ AlterTableCmd: { behavior: 'DROP_RESTRICT', ...cmd } }],
+            objtype: 'OBJECT_TABLE'
+        }
+    });
+    diff.columnsAdded = [];
+    diff.columnsRemoved = [];
+    diff.columnsModified = [];
+    for (const [name, col] of to.columns) {
+        const prior = from.columns.get(name);
+        if (!prior) {
+            diff.columnsAdded.push(name);
+            stmts.push(alter({ subtype: 'AT_AddColumn', def: { ColumnDef: col.def } }));
+        }
+        else if (prior.print !== col.print) {
+            diff.columnsModified.push(name);
+            const fromDef = prior.def;
+            const toDef = col.def;
+            const typeChanged = JSON.stringify(fromDef.typeName) !== JSON.stringify(toDef.typeName);
+            const restChanged = JSON.stringify({ ...fromDef, typeName: null }) !==
+                JSON.stringify({ ...toDef, typeName: null });
+            if (typeChanged) {
+                stmts.push(alter({
+                    subtype: 'AT_AlterColumnType',
+                    name,
+                    def: { ColumnDef: { typeName: toDef.typeName } }
+                }));
+            }
+            if (restChanged) {
+                warnings.push(`${diff.path}: column "${name}" changed beyond its type (constraints/defaults); emit a manual ALTER`);
+            }
+        }
+    }
+    for (const name of from.columns.keys()) {
+        if (!to.columns.has(name)) {
+            diff.columnsRemoved.push(name);
+            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`);
+            }
+        }
+    }
+    for (const [print, extra] of from.extras) {
+        if (to.extras.has(print))
+            continue;
+        const conname = extra.Constraint?.conname
+            ?? extra
+                .AlterTableCmd?.def?.Constraint?.conname;
+        if (conname) {
+            stmts.push(alter({ subtype: 'AT_DropConstraint', name: conname }));
+        }
+        else {
+            warnings.push(`${diff.path}: removed table element has no name to drop; emit a manual ALTER`);
+        }
+    }
+    return stmts;
+}
+/**
+ * Diff two deploy surfaces by object identity and emit the migration delta.
+ *
+ * `from`/`to` are whole deploy scripts (flatten changes in plan order to
+ * diff bundles/modules). The result's `changes` deploy `to`'s shape on top
+ * of `from`: reverse-topological DROPs, then CREATE/ALTERs named and
+ * ordered by `restructureChanges`.
+ */
+export function diffSchemas(from, to, options = {}) {
+    const style = options.style ?? 'directory';
+    const warnings = [];
+    const a = readSide(from, warnings, 'from');
+    const b = readSide(to, warnings, 'to');
+    const objects = [];
+    const forwardSql = [];
+    const modifiedChanges = [];
+    const dropUnits = [];
+    /** `@pgsql/scripts` inverse of a deploy script (drops in reverse topo order). */
+    const inverseOf = (deploy, context) => {
+        const { sql, warnings: w } = revertFor(classifyStatements(deploy));
+        warnings.push(...w.map(x => `${context}: ${x}`));
+        return sql;
+    };
+    /** `@pgsql/scripts` existence checks for a deploy script. */
+    const verifyOf = (deploy, context) => {
+        const { sql, warnings: w } = verifyFor(classifyStatements(deploy));
+        warnings.push(...w.map(x => `${context}: ${x}`));
+        return sql;
+    };
+    for (const key of b.order) {
+        const unit = b.units.get(key);
+        const prior = a.units.get(key);
+        const path = pathFor(unit.identity, { style });
+        if (!prior) {
+            objects.push({ identity: unit.identity, path, delta: 'added' });
+            forwardSql.push(...unit.texts);
+            continue;
+        }
+        if (unit.identity.kind === 'table') {
+            const shapeFrom = tableShape(prior);
+            const shapeTo = tableShape(unit);
+            const diff = { identity: unit.identity, path, delta: 'modified' };
+            const stmts = diffTable(shapeFrom, shapeTo, diff, warnings);
+            const columnsTouched = diff.columnsAdded.length + diff.columnsRemoved.length + diff.columnsModified.length > 0;
+            if (stmts.length > 0 || columnsTouched) {
+                objects.push(diff);
+                if (stmts.length > 0) {
+                    // The inverse alteration is the same diff with the sides swapped.
+                    const scratch = { identity: unit.identity, path, delta: 'modified' };
+                    const deploy = stmts.join('\n');
+                    modifiedChanges.push({
+                        name: `${path}/alter`,
+                        dependencies: [],
+                        deploy,
+                        revert: diffTable(shapeTo, shapeFrom, scratch, []).join('\n'),
+                        verify: verifyOf(deploy, path)
+                    });
+                }
+            }
+            continue;
+        }
+        if (unitFingerprint(prior) !== unitFingerprint(unit)) {
+            objects.push({ identity: unit.identity, path, delta: 'modified' });
+            const priorDeploy = prior.texts.join('\n');
+            const newDeploy = unit.texts.join('\n');
+            modifiedChanges.push({
+                name: path,
+                dependencies: [],
+                deploy: [inverseOf(priorDeploy, path), newDeploy].filter(Boolean).join('\n'),
+                revert: [inverseOf(newDeploy, path), priorDeploy].filter(Boolean).join('\n'),
+                verify: verifyOf(newDeploy, path)
+            });
+        }
+    }
+    for (const key of a.order) {
+        if (b.units.has(key))
+            continue;
+        const unit = a.units.get(key);
+        objects.push({ identity: unit.identity, path: pathFor(unit.identity, { style }), delta: 'removed' });
+        dropUnits.push(unit);
+    }
+    // Removed objects drop in reverse topological order of the `from` graph
+    // (dependents before dependencies), one change per object.
+    const position = new Map(dropUnits.map(u => [u, Math.min(...u.statements.map(s => a.graph.order.indexOf(s)))]));
+    dropUnits.sort((x, y) => position.get(y) - position.get(x));
+    const dropChanges = [];
+    for (const unit of dropUnits) {
+        const path = pathFor(unit.identity, { style });
+        const recreate = unit.texts.join('\n');
+        const drop = inverseOf(recreate, path);
+        if (!drop.trim() || drop.trim().startsWith('--')) {
+            warnings.push(`${path}: no DROP derivable for kind "${unit.identity.kind}"; drop manually`);
+            continue;
+        }
+        dropChanges.push({
+            name: `${path}/drop`,
+            dependencies: dropChanges.length > 0 ? [dropChanges[dropChanges.length - 1].name] : [],
+            deploy: drop,
+            revert: recreate,
+            verify: ''
+        });
+    }
+    let forwardChanges = [];
+    if (forwardSql.length > 0) {
+        const { changes, warnings: w } = restructureChanges([{ name: 'delta', dependencies: [], deploy: forwardSql.join('\n\n') }], { granularity: options.granularity ?? 'object' });
+        forwardChanges = changes.map(c => ({
+            ...c,
+            revert: inverseOf(c.deploy, c.name),
+            verify: verifyOf(c.deploy, c.name)
+        }));
+        warnings.push(...w);
+    }
+    return {
+        identical: objects.length === 0,
+        objects,
+        changes: [...dropChanges, ...forwardChanges, ...modifiedChanges],
+        warnings
+    };
+}
+/**
+ * Identity-keyed diff over pgpm changes: flattens each side's deploy scripts
+ * in plan order and delegates to {@link diffSchemas}. Change names never
+ * enter the comparison — regrouping, renaming, or repartitioning the same
+ * schema yields an identical diff.
+ */
+export function diffChangeSets(from, to, options = {}) {
+    const flatten = (changes) => changes.map(c => c.deploy.trim()).filter(Boolean).join('\n\n');
+    return diffSchemas(flatten(from), flatten(to), options);
+}

package/granularity-driver.d.ts

@@ -1,52 +1,49 @@
-/**
- * Granularity driver: restructure a pgpm module's deploy surface between the
- * atomic, object, and consolidated shapes.
- *
- * The upstream pass (`restructureSql` in `@pgsql/transform`) rewrites one SQL
- * script between equivalent shapes, guarded by the statement dependency
- * graph. This driver lifts that to the pgpm change model: it flattens a
- * module's deploy scripts in plan order into one program, restructures it to
- * the target granularity, then re-slices the result into changes — one change
- * per created object — with change dependencies recomputed from the statement
- * graph. Like the other drivers in this package it is structurally typed on
- * the bundle seams: no dependency on `@pgpmjs/bundle` or `@pgpmjs/core`.
- *
- * - `atomic`       — the machine-emitted shape: bare CREATE TABLE plus one
- *                    ALTER per column/constraint.
- * - `object`       — each table fully baked; cross-object statements
- *                    (FKs, indexes, triggers, policies) stay separate.
- * - `consolidated` — additionally inlines FKs proven safe by the graph.
- */
 import type { Granularity, StatementFacts } from '@pgsql/transform';
 export type { Granularity } from '@pgsql/transform';
 /** A change's deploy surface going into or out of the restructure. */
 export interface GranularityChange {
-    /** Change name (plan token, e.g. `schemas/app/tables/users`). */
+    /** Change name (plan token, e.g. `schemas/app/tables/users/table`). */
     name: string;
     /** Change names this change requires (within the same module). */
     dependencies: string[];
     /** Deploy SQL (headerless — the caller owns pgpm headers). */
     deploy: string;
 }
+/** A restructured change: deploy plus generated revert/verify scripts. */
+export interface RestructuredChange extends GranularityChange {
+    /**
+     * Generated revert SQL (headerless): mechanical inverses of the change's
+     * statements in reverse topological order within the group, via
+     * `revertFor`. Non-invertible statements leave a `-- revert not
+     * derivable` comment and a warning.
+     */
+    revert: string;
+    /**
+     * Generated verify SQL (headerless): one raise-on-failure existence check
+     * per created object, via `verifyFor`.
+     */
+    verify: string;
+}
 export interface RestructureModuleOptions {
     granularity: Granularity;
     /**
      * Derive a change name for a statement group from the facts of its primary
-     * (creating) statement. Defaults to {@link defaultChangeName}: pgpm-style
-     * `schemas/<schema>` / `schemas/<schema>/tables/<name>` paths.
+     * (creating) statement. Defaults to {@link defaultChangeName}: naming spec
+     * v1 paths (`identityOf` + `pathFor`).
      */
     changeName?: (facts: StatementFacts) => string;
 }
 export interface RestructureModuleResult {
     /** Restructured changes in deploy order, dependencies recomputed. */
-    changes: GranularityChange[];
+    changes: RestructuredChange[];
     /** Non-fatal notes (folds rejected to preserve ordering, etc.). */
     warnings: string[];
 }
 /**
- * Default pgpm-style change name for a statement group:
- * `schemas/<schema>` for schemas, `schemas/<schema>/<kind>/<name>` for
- * objects, `misc/<n>` when nothing better is known.
+ * Default change name for a statement group: the object's canonical naming
+ * spec v1 path — `identityOf(facts)` (Postgres-native identity, from
+ * `@pgsql/transform`) rendered through `pathFor` (`@pgpmjs/naming-spec`).
+ * Paths are pure projections of identity, never authored.
  */
 export declare function defaultChangeName(facts: StatementFacts): string;
 /**

package/granularity-driver.js

@@ -2,6 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultChangeName = defaultChangeName;
 exports.restructureChanges = restructureChanges;
+/**
+ * Granularity driver: restructure a pgpm module's deploy surface between the
+ * atomic, object, and consolidated shapes.
+ *
+ * The upstream pass (`restructureSql` in `@pgsql/transform`) rewrites one SQL
+ * script between equivalent shapes, guarded by the statement dependency
+ * graph. This driver lifts that to the pgpm change model: it flattens a
+ * module's deploy scripts in plan order into one program, restructures it to
+ * the target granularity, then re-slices the result into changes — one change
+ * per created object — with change dependencies recomputed from the statement
+ * graph. Like the other drivers in this package it is structurally typed on
+ * the bundle seams: no dependency on `@pgpmjs/bundle` or `@pgpmjs/core`.
+ *
+ * - `atomic`       — the machine-emitted shape: bare CREATE TABLE plus one
+ *                    ALTER per column/constraint.
+ * - `object`       — each table fully baked; cross-object statements
+ *                    (FKs, indexes, triggers, policies) stay separate.
+ * - `consolidated` — additionally inlines FKs proven safe by the graph.
+ */
+const naming_spec_1 = require("@pgpmjs/naming-spec");
+const scripts_1 = require("@pgsql/scripts");
 const transform_1 = require("@pgsql/transform");
 const KIND_DIRS = {
     table: 'tables',
@@ -14,21 +35,15 @@ const KIND_DIRS = {
     seed_dml: 'fixtures'
 };
 /**
- * Default pgpm-style change name for a statement group:
- * `schemas/<schema>` for schemas, `schemas/<schema>/<kind>/<name>` for
- * objects, `misc/<n>` when nothing better is known.
+ * Default change name for a statement group: the object's canonical naming
+ * spec v1 path — `identityOf(facts)` (Postgres-native identity, from
+ * `@pgsql/transform`) rendered through `pathFor` (`@pgpmjs/naming-spec`).
+ * Paths are pure projections of identity, never authored.
  */
 function defaultChangeName(facts) {
-    const created = facts.creates[0];
-    if (facts.kind === 'schema' && created)
-        return `schemas/${created.name}`;
-    if (created) {
-        const dir = KIND_DIRS[facts.kind] ?? 'objects';
-        const schema = created.schema ?? 'public';
-        // Trigger/policy names are table-qualified (`table.trigger`).
-        const name = created.name.replace(/\./g, '/');
-        return `schemas/${schema}/${dir}/${name}`;
-    }
+    const identity = (0, transform_1.identityOf)(facts);
+    if (identity)
+        return (0, naming_spec_1.pathFor)(identity);
     return 'misc/statements';
 }
 /**
@@ -89,13 +104,16 @@ function restructureChanges(changes, options) {
             schemaGroup.set(f.creates[0].name, groupOf[i]);
         }
     });
-    // Slice statement text per group, in the emitted (topological) order.
+    // Slice statement text per group, in the emitted (topological) order,
+    // and collect each group's facts for revert/verify generation.
     const groupSql = groupNames.map(() => []);
+    const groupStatements = groupNames.map(() => []);
     facts.forEach((f, i) => {
         const text = sql.slice(f.span.start, f.span.start + f.span.len).trim();
         const g = groupOf[i];
         if (g !== -1 && text) {
             groupSql[g].push(text.endsWith(';') ? text : `${text};`);
+            groupStatements[g].push(f);
         }
     });
     // Change dependencies = statement edges projected onto groups, plus
@@ -132,10 +150,22 @@ function restructureChanges(changes, options) {
     });
     const result = order
         .filter(g => groupSql[g].length > 0)
-        .map(g => ({
-        name: groupNames[g],
-        dependencies: [...groupDeps[g]].map(d => groupNames[d]).sort(),
-        deploy: groupSql[g].join('\n\n')
-    }));
+        .map(g => {
+        const revert = (0, scripts_1.revertFor)(groupStatements[g]);
+        const verify = (0, scripts_1.verifyFor)(groupStatements[g]);
+        for (const warning of revert.warnings) {
+            warnings.push(`${groupNames[g]}: ${warning}`);
+        }
+        for (const warning of verify.warnings) {
+            warnings.push(`${groupNames[g]}: ${warning}`);
+        }
+        return {
+            name: groupNames[g],
+            dependencies: [...groupDeps[g]].map(d => groupNames[d]).sort(),
+            deploy: groupSql[g].join('\n\n'),
+            revert: revert.sql,
+            verify: verify.sql
+        };
+    });
     return { changes: result, warnings };
 }

package/index.d.ts

@@ -2,11 +2,17 @@ export * from '@pgsql/transform';
 export { loadModule } from 'plpgsql-parser';
 export type { BundleScriptContext, ExtensionRoutingInput, NamespaceValidatorOptions, SchemaObjectRoute, SchemaTranspiler, SchemaTranspilerOptions, } from './bundle-driver';
 export { buildExtensionRouter, buildSchemaRouter, makeNamespaceValidator, makeSchemaTranspiler, } from './bundle-driver';
-export type { GranularityChange, RestructureModuleOptions, RestructureModuleResult, } from './granularity-driver';
+export type { GranularityChange, RestructuredChange, RestructureModuleOptions, RestructureModuleResult, } from './granularity-driver';
 export { defaultChangeName, restructureChanges, } from './granularity-driver';
+export type { DiffInputChange, ObjectDelta, SemanticDeltaChange, SemanticDiffOptions, SemanticDiffResult, SemanticObjectDiff, } from './semantic-diff-driver';
+export { diffChangeSets, diffSchemas, } from './semantic-diff-driver';
+export type { PartitionConfig, PartitionedChange, PartitionedPackage, PartitionInputChange, PartitionRule, PartitionUnit, PartitionUnitsResult, UnitSelector, } from './partition-driver';
+export { PartitionCycleError, partitionUnits, RESIDUAL_UNIT_PATH, } from './partition-driver';
 export type { CategoryProfile, ChangeCategory, } from './categorize';
 export { buildCategoryOf, categorizeChange, TIER_PROFILE, } from './categorize';
 export type { ClosureChange, ClosureInputChange, ClosureReason, FixtureClosure, ResolveFixtureClosureOptions, } from './fixture-closure';
 export { resolveFixtureClosure } from './fixture-closure';
+export type { GeneratedScript, RegeneratedScripts, } from './regen';
+export { classifyScript, isStubScript, regenerateScripts, } from './regen';
 export type { SqlProgram, SqlStatementAst, SqlStatementSpan, } from './program';
 export { emitSqlProgram, parseSqlProgram } from './program';

package/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSqlProgram = exports.emitSqlProgram = exports.resolveFixtureClosure = exports.TIER_PROFILE = exports.categorizeChange = exports.buildCategoryOf = exports.restructureChanges = exports.defaultChangeName = exports.makeSchemaTranspiler = exports.makeNamespaceValidator = exports.buildSchemaRouter = exports.buildExtensionRouter = exports.loadModule = void 0;
+exports.parseSqlProgram = exports.emitSqlProgram = exports.regenerateScripts = exports.isStubScript = exports.classifyScript = exports.resolveFixtureClosure = exports.TIER_PROFILE = exports.categorizeChange = exports.buildCategoryOf = exports.RESIDUAL_UNIT_PATH = exports.partitionUnits = exports.PartitionCycleError = exports.diffSchemas = exports.diffChangeSets = exports.restructureChanges = exports.defaultChangeName = exports.makeSchemaTranspiler = exports.makeNamespaceValidator = exports.buildSchemaRouter = exports.buildExtensionRouter = exports.loadModule = void 0;
 __exportStar(require("@pgsql/transform"), exports);
 var plpgsql_parser_1 = require("plpgsql-parser");
 Object.defineProperty(exports, "loadModule", { enumerable: true, get: function () { return plpgsql_parser_1.loadModule; } });
@@ -26,12 +26,23 @@ Object.defineProperty(exports, "makeSchemaTranspiler", { enumerable: true, get:
 var granularity_driver_1 = require("./granularity-driver");
 Object.defineProperty(exports, "defaultChangeName", { enumerable: true, get: function () { return granularity_driver_1.defaultChangeName; } });
 Object.defineProperty(exports, "restructureChanges", { enumerable: true, get: function () { return granularity_driver_1.restructureChanges; } });
+var semantic_diff_driver_1 = require("./semantic-diff-driver");
+Object.defineProperty(exports, "diffChangeSets", { enumerable: true, get: function () { return semantic_diff_driver_1.diffChangeSets; } });
+Object.defineProperty(exports, "diffSchemas", { enumerable: true, get: function () { return semantic_diff_driver_1.diffSchemas; } });
+var partition_driver_1 = require("./partition-driver");
+Object.defineProperty(exports, "PartitionCycleError", { enumerable: true, get: function () { return partition_driver_1.PartitionCycleError; } });
+Object.defineProperty(exports, "partitionUnits", { enumerable: true, get: function () { return partition_driver_1.partitionUnits; } });
+Object.defineProperty(exports, "RESIDUAL_UNIT_PATH", { enumerable: true, get: function () { return partition_driver_1.RESIDUAL_UNIT_PATH; } });
 var categorize_1 = require("./categorize");
 Object.defineProperty(exports, "buildCategoryOf", { enumerable: true, get: function () { return categorize_1.buildCategoryOf; } });
 Object.defineProperty(exports, "categorizeChange", { enumerable: true, get: function () { return categorize_1.categorizeChange; } });
 Object.defineProperty(exports, "TIER_PROFILE", { enumerable: true, get: function () { return categorize_1.TIER_PROFILE; } });
 var fixture_closure_1 = require("./fixture-closure");
 Object.defineProperty(exports, "resolveFixtureClosure", { enumerable: true, get: function () { return fixture_closure_1.resolveFixtureClosure; } });
+var regen_1 = require("./regen");
+Object.defineProperty(exports, "classifyScript", { enumerable: true, get: function () { return regen_1.classifyScript; } });
+Object.defineProperty(exports, "isStubScript", { enumerable: true, get: function () { return regen_1.isStubScript; } });
+Object.defineProperty(exports, "regenerateScripts", { enumerable: true, get: function () { return regen_1.regenerateScripts; } });
 var program_1 = require("./program");
 Object.defineProperty(exports, "emitSqlProgram", { enumerable: true, get: function () { return program_1.emitSqlProgram; } });
 Object.defineProperty(exports, "parseSqlProgram", { enumerable: true, get: function () { return program_1.parseSqlProgram; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/transform",
-  "version": "0.15.3",
+  "version": "0.17.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",
@@ -43,8 +43,10 @@
     "makage": "^0.3.0"
   },
   "dependencies": {
-    "@pgsql/transform": "^18.10.0",
-    "plpgsql-parser": "^18.2.2"
+    "@pgpmjs/naming-spec": "^0.1.2",
+    "@pgsql/scripts": "^18.1.0",
+    "@pgsql/transform": "^18.11.0",
+    "plpgsql-parser": "^18.2.3"
   },
-  "gitHead": "90f447482b056a4949134565db2665f21d11aca3"
+  "gitHead": "45cd961cf956d2d28e4d09b20db4204982c33593"
 }