@pgsql/transform 18.3.0 → 18.4.1

package/categorize.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TIER_PROFILE = void 0;
-exports.categorizeChange = categorizeChange;
-exports.buildCategoryOf = buildCategoryOf;
-const facts_1 = require("./facts");
-/**
- * Default tier profile: isolates the security surface and procedural code out
- * of the schema base. Precedence, highest first — a change is placed in the
- * most specialized tier any of its statements reaches:
- *
- *   security       any securityRelevant statement (policy/grant/RLS/role/owner)
- *   functionality  functions and triggers
- *   fixtures       seed DML (INSERT/UPDATE/DELETE)
- *   schema         schemas, tables, views, indexes, types, constraints (base)
- *
- * Ordering/dependencies across the resulting chunks are still resolved by
- * core's rebundle graph, so this only decides *naming/grouping*, never deploy
- * order.
- */
-exports.TIER_PROFILE = {
-    name: 'tier',
-    categorize(facts) {
-        if (facts.length === 0)
-            return 'schema';
-        if (facts.some(f => f.securityRelevant))
-            return 'security';
-        if (facts.some(f => f.kind === 'function' || f.kind === 'trigger'))
-            return 'functionality';
-        if (facts.some(f => f.kind === 'seed_dml'))
-            return 'fixtures';
-        return 'schema';
-    },
-};
-/**
- * Classify a single change's deploy SQL into its category under `profile`
- * (defaults to {@link TIER_PROFILE}).
- */
-function categorizeChange(sql, changeName, profile = exports.TIER_PROFILE) {
-    return profile.categorize((0, facts_1.classifyStatements)(sql), changeName);
-}
-/**
- * Build a `categoryOf(changeName)` seam function from a map of change name to
- * its deploy SQL — ready to pass straight to `@pgpmjs/core`'s rebundle
- * `boundary: 'category'` / `categoryOf` options.
- *
- * Changes absent from `changeSql` return `undefined`, letting core fall back to
- * its folder key for anything the classifier did not see.
- */
-function buildCategoryOf(changeSql, profile = exports.TIER_PROFILE) {
-    const categories = new Map();
-    for (const [name, sql] of Object.entries(changeSql)) {
-        categories.set(name, categorizeChange(sql, name, profile));
-    }
-    return (changeName) => categories.get(changeName);
-}

package/esm/categorize.js

@@ -1,51 +0,0 @@
-import { classifyStatements } from './facts';
-/**
- * Default tier profile: isolates the security surface and procedural code out
- * of the schema base. Precedence, highest first — a change is placed in the
- * most specialized tier any of its statements reaches:
- *
- *   security       any securityRelevant statement (policy/grant/RLS/role/owner)
- *   functionality  functions and triggers
- *   fixtures       seed DML (INSERT/UPDATE/DELETE)
- *   schema         schemas, tables, views, indexes, types, constraints (base)
- *
- * Ordering/dependencies across the resulting chunks are still resolved by
- * core's rebundle graph, so this only decides *naming/grouping*, never deploy
- * order.
- */
-export const TIER_PROFILE = {
-    name: 'tier',
-    categorize(facts) {
-        if (facts.length === 0)
-            return 'schema';
-        if (facts.some(f => f.securityRelevant))
-            return 'security';
-        if (facts.some(f => f.kind === 'function' || f.kind === 'trigger'))
-            return 'functionality';
-        if (facts.some(f => f.kind === 'seed_dml'))
-            return 'fixtures';
-        return 'schema';
-    },
-};
-/**
- * Classify a single change's deploy SQL into its category under `profile`
- * (defaults to {@link TIER_PROFILE}).
- */
-export function categorizeChange(sql, changeName, profile = TIER_PROFILE) {
-    return profile.categorize(classifyStatements(sql), changeName);
-}
-/**
- * Build a `categoryOf(changeName)` seam function from a map of change name to
- * its deploy SQL — ready to pass straight to `@pgpmjs/core`'s rebundle
- * `boundary: 'category'` / `categoryOf` options.
- *
- * Changes absent from `changeSql` return `undefined`, letting core fall back to
- * its folder key for anything the classifier did not see.
- */
-export function buildCategoryOf(changeSql, profile = TIER_PROFILE) {
-    const categories = new Map();
-    for (const [name, sql] of Object.entries(changeSql)) {
-        categories.set(name, categorizeChange(sql, name, profile));
-    }
-    return (changeName) => categories.get(changeName);
-}

package/esm/fixture-closure.js

@@ -1,197 +0,0 @@
-import { TIER_PROFILE } from './categorize';
-import { classifyStatements } from './facts';
-function objectKey(schema, name) {
-    return `${schema ?? ''}\u0000${name}`;
-}
-function analyze(change, profile) {
-    const facts = classifyStatements(change.sql);
-    const category = profile.categorize(facts, change.name);
-    const creates = [];
-    const createsSchemas = [];
-    const createsRoles = [];
-    const needsObjects = [];
-    const needsSchemas = new Set();
-    const needsRoles = new Set();
-    for (const f of facts) {
-        for (const c of f.creates) {
-            if (f.kind === 'schema')
-                createsSchemas.push(c.name);
-            else {
-                creates.push(c);
-                if (c.schema)
-                    needsSchemas.add(c.schema);
-            }
-        }
-        if (f.nodeTag === 'CreateRoleStmt')
-            createsRoles.push(...f.roles);
-        for (const r of [...f.references, ...f.fkTargets]) {
-            if (r.schema)
-                needsObjects.push(r);
-        }
-        for (const s of f.referencedSchemas)
-            needsSchemas.add(s);
-    }
-    const created = new Set(createsRoles);
-    for (const f of facts) {
-        if (f.nodeTag === 'CreateRoleStmt')
-            continue;
-        for (const role of f.roles)
-            if (!created.has(role))
-                needsRoles.add(role);
-    }
-    for (const s of createsSchemas)
-        needsSchemas.delete(s);
-    return {
-        name: change.name,
-        category,
-        facts,
-        dependencies: change.dependencies ?? [],
-        creates,
-        createsSchemas,
-        createsRoles,
-        needsObjects,
-        needsSchemas: [...needsSchemas],
-        needsRoles: [...needsRoles],
-        isFixture: category === 'security' || category === 'fixtures'
-    };
-}
-/**
- * Resolve the fixture closure of a schema slice.
- *
- * Pure and deterministic — no I/O — and runs to a fixpoint in both directions:
- *   - forward: a selected change pulls in the producers of the objects/schemas/
- *     roles it references, plus its declared plan dependencies (prerequisites);
- *   - reverse: any fixture (security/fixtures-tier change) that attaches to an
- *     object already in the closure is pulled in (attached fixtures), and then
- *     resolved for its own prerequisites.
- *
- * Output order follows the input (plan) order, so it stays deploy-safe.
- */
-export function resolveFixtureClosure(allChanges, selection, options = {}) {
-    const profile = options.profile ?? TIER_PROFILE;
-    const includePrerequisites = options.includePrerequisites ?? true;
-    const analyses = allChanges.map(c => analyze(c, profile));
-    const byName = new Map(analyses.map(a => [a.name, a]));
-    const producerByObject = new Map();
-    const producerBySchema = new Map();
-    const producerByRole = new Map();
-    for (const a of analyses) {
-        for (const c of a.creates) {
-            const key = objectKey(c.schema, c.name);
-            if (!producerByObject.has(key))
-                producerByObject.set(key, a.name);
-        }
-        for (const s of a.createsSchemas) {
-            if (!producerBySchema.has(s))
-                producerBySchema.set(s, a.name);
-        }
-        for (const r of a.createsRoles) {
-            if (!producerByRole.has(r))
-                producerByRole.set(r, a.name);
-        }
-    }
-    const reason = new Map();
-    for (const name of selection) {
-        if (byName.has(name))
-            reason.set(name, 'selected');
-    }
-    const producedObjectKeys = new Set();
-    const producedSchemas = new Set();
-    const refreshProduced = () => {
-        producedObjectKeys.clear();
-        producedSchemas.clear();
-        for (const name of reason.keys()) {
-            const a = byName.get(name);
-            for (const c of a.creates)
-                producedObjectKeys.add(objectKey(c.schema, c.name));
-            for (const s of a.createsSchemas)
-                producedSchemas.add(s);
-        }
-    };
-    let changed = true;
-    while (changed) {
-        changed = false;
-        // forward: pull producers of what current members need
-        for (const name of [...reason.keys()]) {
-            const a = byName.get(name);
-            const pull = (producer, r) => {
-                if (!producer || reason.has(producer))
-                    return;
-                const pa = byName.get(producer);
-                reason.set(producer, pa.isFixture ? 'fixture' : r);
-                changed = true;
-            };
-            for (const dep of a.dependencies) {
-                pull(byName.has(dep) ? dep : undefined, 'prerequisite');
-            }
-            if (!includePrerequisites)
-                continue;
-            for (const o of a.needsObjects)
-                pull(producerByObject.get(objectKey(o.schema, o.name)), 'prerequisite');
-            for (const s of a.needsSchemas)
-                pull(producerBySchema.get(s), 'prerequisite');
-            for (const role of a.needsRoles)
-                pull(producerByRole.get(role), 'prerequisite');
-        }
-        // reverse: pull attached fixtures that target current members
-        refreshProduced();
-        for (const a of analyses) {
-            if (reason.has(a.name) || !a.isFixture)
-                continue;
-            const objectAttaches = a.needsObjects.some(o => producedObjectKeys.has(objectKey(o.schema, o.name))) ||
-                a.creates.some(c => producedObjectKeys.has(objectKey(c.schema, c.name)));
-            // Schema-scoped fixtures (e.g. ALTER DEFAULT PRIVILEGES IN SCHEMA x) name no
-            // specific object; attach them by schema. Object-scoped fixtures attach only
-            // via their object refs, so a shared schema does not drag in every fixture.
-            const schemaScoped = a.needsObjects.length === 0 && a.creates.length === 0;
-            const schemaAttaches = schemaScoped &&
-                (a.needsSchemas.some(s => producedSchemas.has(s)) ||
-                    a.createsSchemas.some(s => producedSchemas.has(s)));
-            if (objectAttaches || schemaAttaches) {
-                reason.set(a.name, 'fixture');
-                changed = true;
-            }
-        }
-    }
-    const order = analyses.filter(a => reason.has(a.name)).map(a => a.name);
-    const changes = order.map(name => {
-        const a = byName.get(name);
-        return { name, category: a.category, reason: reason.get(name) };
-    });
-    const roles = new Set();
-    const unresolvedObjects = [];
-    const unresolvedObjectKeys = new Set();
-    const unresolvedSchemas = new Set();
-    const unresolvedRoles = new Set();
-    for (const name of order) {
-        const a = byName.get(name);
-        for (const role of a.needsRoles) {
-            roles.add(role);
-            if (!producerByRole.has(role))
-                unresolvedRoles.add(role);
-        }
-        for (const o of a.needsObjects) {
-            const key = objectKey(o.schema, o.name);
-            if (!producerByObject.has(key) && !unresolvedObjectKeys.has(key)) {
-                unresolvedObjectKeys.add(key);
-                unresolvedObjects.push(o);
-            }
-        }
-        for (const s of a.needsSchemas) {
-            if (!producerBySchema.has(s))
-                unresolvedSchemas.add(s);
-        }
-    }
-    return {
-        order,
-        changes,
-        fixtures: changes.filter(c => c.reason === 'fixture').map(c => c.name),
-        prerequisites: changes.filter(c => c.reason === 'prerequisite').map(c => c.name),
-        roles: [...roles],
-        unresolved: {
-            objects: unresolvedObjects,
-            schemas: [...unresolvedSchemas],
-            roles: [...unresolvedRoles]
-        }
-    };
-}

package/fixture-closure.d.ts

@@ -1,71 +0,0 @@
-import { CategoryProfile, ChangeCategory } from './categorize';
-import { QualifiedName } from './facts';
-/**
- * A change plus its deploy SQL. Optional plan `dependencies` (from `pgpm.plan`)
- * are followed as authoritative prerequisites in addition to AST-derived edges.
- */
-export interface ClosureInputChange {
-    name: string;
-    sql: string;
-    dependencies?: string[];
-}
-/** Why a change ended up in the closure. */
-export type ClosureReason = 'selected' | 'prerequisite' | 'fixture';
-/**
- * A change included in the closure, with its category and the reason it was pulled.
- */
-export interface ClosureChange {
-    name: string;
-    category: ChangeCategory;
-    reason: ClosureReason;
-}
-/**
- * The fixture closure of a schema slice.
- *
- * Everything the selected changes need to actually *work*: schema/functionality
- * prerequisites they depend on, plus the fixtures that attach to them (policies,
- * grants, RLS enables, role bindings, seed rows / SPRT-style support changes).
- * References that nothing in the input produces are surfaced in `unresolved`
- * rather than silently dropped.
- */
-export interface FixtureClosure {
-    /** Full closure (selection + prerequisites + fixtures) in input/plan order. */
-    order: string[];
-    /** Per-change detail in the same order as {@link order}. */
-    changes: ClosureChange[];
-    /** Closure members categorized as security/fixtures (attached fixtures). */
-    fixtures: string[];
-    /** Non-selected schema/functionality members pulled in as prerequisites. */
-    prerequisites: string[];
-    /** Roles required across the closure. */
-    roles: string[];
-    /** Requirements no input change produces — explicit, never dropped. */
-    unresolved: {
-        objects: QualifiedName[];
-        schemas: string[];
-        roles: string[];
-    };
-}
-export interface ResolveFixtureClosureOptions {
-    /** Category profile used to label changes (default {@link TIER_PROFILE}). */
-    profile?: CategoryProfile;
-    /**
-     * When false, do not follow AST references from selected changes to their
-     * schema/functionality producers (only pull attached fixtures + plan deps).
-     * Default true.
-     */
-    includePrerequisites?: boolean;
-}
-/**
- * Resolve the fixture closure of a schema slice.
- *
- * Pure and deterministic — no I/O — and runs to a fixpoint in both directions:
- *   - forward: a selected change pulls in the producers of the objects/schemas/
- *     roles it references, plus its declared plan dependencies (prerequisites);
- *   - reverse: any fixture (security/fixtures-tier change) that attaches to an
- *     object already in the closure is pulled in (attached fixtures), and then
- *     resolved for its own prerequisites.
- *
- * Output order follows the input (plan) order, so it stays deploy-safe.
- */
-export declare function resolveFixtureClosure(allChanges: ClosureInputChange[], selection: string[], options?: ResolveFixtureClosureOptions): FixtureClosure;

package/fixture-closure.js

@@ -1,200 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveFixtureClosure = resolveFixtureClosure;
-const categorize_1 = require("./categorize");
-const facts_1 = require("./facts");
-function objectKey(schema, name) {
-    return `${schema ?? ''}\u0000${name}`;
-}
-function analyze(change, profile) {
-    const facts = (0, facts_1.classifyStatements)(change.sql);
-    const category = profile.categorize(facts, change.name);
-    const creates = [];
-    const createsSchemas = [];
-    const createsRoles = [];
-    const needsObjects = [];
-    const needsSchemas = new Set();
-    const needsRoles = new Set();
-    for (const f of facts) {
-        for (const c of f.creates) {
-            if (f.kind === 'schema')
-                createsSchemas.push(c.name);
-            else {
-                creates.push(c);
-                if (c.schema)
-                    needsSchemas.add(c.schema);
-            }
-        }
-        if (f.nodeTag === 'CreateRoleStmt')
-            createsRoles.push(...f.roles);
-        for (const r of [...f.references, ...f.fkTargets]) {
-            if (r.schema)
-                needsObjects.push(r);
-        }
-        for (const s of f.referencedSchemas)
-            needsSchemas.add(s);
-    }
-    const created = new Set(createsRoles);
-    for (const f of facts) {
-        if (f.nodeTag === 'CreateRoleStmt')
-            continue;
-        for (const role of f.roles)
-            if (!created.has(role))
-                needsRoles.add(role);
-    }
-    for (const s of createsSchemas)
-        needsSchemas.delete(s);
-    return {
-        name: change.name,
-        category,
-        facts,
-        dependencies: change.dependencies ?? [],
-        creates,
-        createsSchemas,
-        createsRoles,
-        needsObjects,
-        needsSchemas: [...needsSchemas],
-        needsRoles: [...needsRoles],
-        isFixture: category === 'security' || category === 'fixtures'
-    };
-}
-/**
- * Resolve the fixture closure of a schema slice.
- *
- * Pure and deterministic — no I/O — and runs to a fixpoint in both directions:
- *   - forward: a selected change pulls in the producers of the objects/schemas/
- *     roles it references, plus its declared plan dependencies (prerequisites);
- *   - reverse: any fixture (security/fixtures-tier change) that attaches to an
- *     object already in the closure is pulled in (attached fixtures), and then
- *     resolved for its own prerequisites.
- *
- * Output order follows the input (plan) order, so it stays deploy-safe.
- */
-function resolveFixtureClosure(allChanges, selection, options = {}) {
-    const profile = options.profile ?? categorize_1.TIER_PROFILE;
-    const includePrerequisites = options.includePrerequisites ?? true;
-    const analyses = allChanges.map(c => analyze(c, profile));
-    const byName = new Map(analyses.map(a => [a.name, a]));
-    const producerByObject = new Map();
-    const producerBySchema = new Map();
-    const producerByRole = new Map();
-    for (const a of analyses) {
-        for (const c of a.creates) {
-            const key = objectKey(c.schema, c.name);
-            if (!producerByObject.has(key))
-                producerByObject.set(key, a.name);
-        }
-        for (const s of a.createsSchemas) {
-            if (!producerBySchema.has(s))
-                producerBySchema.set(s, a.name);
-        }
-        for (const r of a.createsRoles) {
-            if (!producerByRole.has(r))
-                producerByRole.set(r, a.name);
-        }
-    }
-    const reason = new Map();
-    for (const name of selection) {
-        if (byName.has(name))
-            reason.set(name, 'selected');
-    }
-    const producedObjectKeys = new Set();
-    const producedSchemas = new Set();
-    const refreshProduced = () => {
-        producedObjectKeys.clear();
-        producedSchemas.clear();
-        for (const name of reason.keys()) {
-            const a = byName.get(name);
-            for (const c of a.creates)
-                producedObjectKeys.add(objectKey(c.schema, c.name));
-            for (const s of a.createsSchemas)
-                producedSchemas.add(s);
-        }
-    };
-    let changed = true;
-    while (changed) {
-        changed = false;
-        // forward: pull producers of what current members need
-        for (const name of [...reason.keys()]) {
-            const a = byName.get(name);
-            const pull = (producer, r) => {
-                if (!producer || reason.has(producer))
-                    return;
-                const pa = byName.get(producer);
-                reason.set(producer, pa.isFixture ? 'fixture' : r);
-                changed = true;
-            };
-            for (const dep of a.dependencies) {
-                pull(byName.has(dep) ? dep : undefined, 'prerequisite');
-            }
-            if (!includePrerequisites)
-                continue;
-            for (const o of a.needsObjects)
-                pull(producerByObject.get(objectKey(o.schema, o.name)), 'prerequisite');
-            for (const s of a.needsSchemas)
-                pull(producerBySchema.get(s), 'prerequisite');
-            for (const role of a.needsRoles)
-                pull(producerByRole.get(role), 'prerequisite');
-        }
-        // reverse: pull attached fixtures that target current members
-        refreshProduced();
-        for (const a of analyses) {
-            if (reason.has(a.name) || !a.isFixture)
-                continue;
-            const objectAttaches = a.needsObjects.some(o => producedObjectKeys.has(objectKey(o.schema, o.name))) ||
-                a.creates.some(c => producedObjectKeys.has(objectKey(c.schema, c.name)));
-            // Schema-scoped fixtures (e.g. ALTER DEFAULT PRIVILEGES IN SCHEMA x) name no
-            // specific object; attach them by schema. Object-scoped fixtures attach only
-            // via their object refs, so a shared schema does not drag in every fixture.
-            const schemaScoped = a.needsObjects.length === 0 && a.creates.length === 0;
-            const schemaAttaches = schemaScoped &&
-                (a.needsSchemas.some(s => producedSchemas.has(s)) ||
-                    a.createsSchemas.some(s => producedSchemas.has(s)));
-            if (objectAttaches || schemaAttaches) {
-                reason.set(a.name, 'fixture');
-                changed = true;
-            }
-        }
-    }
-    const order = analyses.filter(a => reason.has(a.name)).map(a => a.name);
-    const changes = order.map(name => {
-        const a = byName.get(name);
-        return { name, category: a.category, reason: reason.get(name) };
-    });
-    const roles = new Set();
-    const unresolvedObjects = [];
-    const unresolvedObjectKeys = new Set();
-    const unresolvedSchemas = new Set();
-    const unresolvedRoles = new Set();
-    for (const name of order) {
-        const a = byName.get(name);
-        for (const role of a.needsRoles) {
-            roles.add(role);
-            if (!producerByRole.has(role))
-                unresolvedRoles.add(role);
-        }
-        for (const o of a.needsObjects) {
-            const key = objectKey(o.schema, o.name);
-            if (!producerByObject.has(key) && !unresolvedObjectKeys.has(key)) {
-                unresolvedObjectKeys.add(key);
-                unresolvedObjects.push(o);
-            }
-        }
-        for (const s of a.needsSchemas) {
-            if (!producerBySchema.has(s))
-                unresolvedSchemas.add(s);
-        }
-    }
-    return {
-        order,
-        changes,
-        fixtures: changes.filter(c => c.reason === 'fixture').map(c => c.name),
-        prerequisites: changes.filter(c => c.reason === 'prerequisite').map(c => c.name),
-        roles: [...roles],
-        unresolved: {
-            objects: unresolvedObjects,
-            schemas: [...unresolvedSchemas],
-            roles: [...unresolvedRoles]
-        }
-    };
-}