ddlforge 0.1.1 → 0.2.0

package/dist/src/runner/backoff.js

@@ -0,0 +1,65 @@
+/**
+ * ddlforge - Exponential backoff with full jitter for lock-timeout retry loops.
+ *
+ * Algorithm: sleep = Math.random() * Math.min(maxDelay, baseDelay * 2 ** attempt)
+ * This prevents lock-convoy / stampede effects by randomising each retry interval.
+ */
+/**
+ * Computes a full-jitter exponential backoff interval for the given attempt index.
+ *
+ * @param attempt   0-based attempt index (first retry = 0)
+ * @param options   Backoff configuration
+ * @returns         Randomised sleep duration in milliseconds
+ */
+export function computeBackoff(attempt, options = {}) {
+    const baseDelayMs = options.baseDelayMs ?? 250;
+    const maxDelayMs = options.maxDelayMs ?? 10_000;
+    const maxRetries = options.maxRetries ?? 5;
+    const ceiling = Math.min(maxDelayMs, baseDelayMs * Math.pow(2, attempt));
+    const sleepMs = Math.random() * ceiling;
+    const exceeded = attempt >= maxRetries;
+    return { sleepMs, attempt, exceeded };
+}
+/**
+ * Returns a promise that resolves after `ms` milliseconds.
+ * Optionally accepts an AbortSignal: if the signal is aborted before the
+ * timer fires, the promise rejects with the signal's reason.
+ *
+ * @param ms      Sleep duration in milliseconds
+ * @param signal  Optional AbortSignal for cancellation
+ */
+export function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason ?? new Error('AbortError'));
+            return;
+        }
+        const timer = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        function onAbort() {
+            clearTimeout(timer);
+            reject(this.reason ?? new Error('AbortError'));
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}
+/**
+ * Iterates over retry attempts, yielding the computed backoff for each attempt.
+ * Callers should `sleep(backoff.sleepMs)` after receiving each non-first result.
+ *
+ * Example:
+ * ```ts
+ * for (const backoff of retryIterator(3, opts)) {
+ *   if (backoff.attempt > 0) await sleep(backoff.sleepMs, signal);
+ *   // ... attempt work ...
+ * }
+ * ```
+ */
+export function* retryIterator(maxRetries, options = {}) {
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        yield computeBackoff(attempt, { ...options, maxRetries });
+    }
+}
+//# sourceMappingURL=backoff.js.map

package/dist/src/runner/backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.js","sourceRoot":"","sources":["../../../src/runner/backoff.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAoBH;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe,EAAE,UAA0B,EAAE;IAC1E,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,IAAI,GAAG,CAAC;IAC/C,MAAM,UAAU,GAAI,OAAO,CAAC,UAAU,IAAK,MAAM,CAAC;IAClD,MAAM,UAAU,GAAI,OAAO,CAAC,UAAU,IAAK,CAAC,CAAC;IAE7C,MAAM,OAAO,GAAI,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1E,MAAM,OAAO,GAAI,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC;IACzC,MAAM,QAAQ,GAAG,OAAO,IAAI,UAAU,CAAC;IAEvC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC;AACxC,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,KAAK,CAAC,EAAU,EAAE,MAAoB;IACpD,OAAO,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC3C,IAAI,MAAM,EAAE,OAAO,EAAE,CAAC;YACpB,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;YACjD,OAAO;QACT,CAAC;QAED,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,MAAM,EAAE,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YAC9C,OAAO,EAAE,CAAC;QACZ,CAAC,EAAE,EAAE,CAAC,CAAC;QAEP,SAAS,OAAO;YACd,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,CAAE,IAAoB,CAAC,MAAM,IAAI,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;QAClE,CAAC;QAED,MAAM,EAAE,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IAC7D,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,SAAS,CAAC,CAAC,aAAa,CAC5B,UAAkB,EAClB,UAA8C,EAAE;IAEhD,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;QACvD,MAAM,cAAc,CAAC,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,UAAU,EAAE,CAAC,CAAC;IAC5D,CAAC;AACH,CAAC"}

package/dist/src/runner/executor.d.ts

@@ -0,0 +1,83 @@
+/**
+ * ddlforge - PostgreSQL DDL execution supervisor.
+ *
+ * Responsibilities
+ * ────────────────
+ * 1. Dynamically imports `pg` at runtime (graceful error if not installed).
+ * 2. Parses SQL migration files into individual statements (reuses the existing
+ *    zero-dependency lexer — no duplicate parser code).
+ * 3. For each statement:
+ *    a. Opens a transaction on a fresh client.
+ *    b. Injects `SET LOCAL lock_timeout` and `SET LOCAL statement_timeout`.
+ *    c. Executes the statement.
+ *    d. On error 55P03 (lock_not_available) or 57014 (query_canceled):
+ *       – Rolls back, waits for a full-jitter backoff interval, retries.
+ *    e. On avalanche detected by the lock monitor: rolls back and aborts.
+ *    f. On success: commits and proceeds to the next statement.
+ * 4. Reports live progress via an optional EventEmitter-compatible callback.
+ *
+ * Zero-dependency invariant
+ * ─────────────────────────
+ * `pg` is imported with `await import('pg')` inside an async function so it
+ * never appears in the static import graph.  Static linting (`ddlforge check`)
+ * works without `pg` installed.
+ */
+export interface ExecutorOptions {
+    /** Full PostgreSQL connection string or URL */
+    databaseUrl: string;
+    /** lock_timeout value (e.g. "2500ms" or "2500"). Default: "3000ms" */
+    lockTimeout?: string;
+    /** statement_timeout value (e.g. "30000ms"). Default: "30000ms" */
+    statementTimeout?: string;
+    /** Maximum number of retry attempts per statement on lock errors. Default: 5 */
+    maxRetries?: number;
+    /** If true, parse and validate statements but never execute them. Default: false */
+    dryRun?: boolean;
+    /**
+     * Number of blocked backends that triggers an avalanche abort.
+     * Default: 1 (abort as soon as even one query queues behind ours).
+     */
+    lockQueueThreshold?: number;
+    /** Milliseconds between lock-monitor polls. Default: 500 */
+    monitorPollMs?: number;
+    /** Progress callback invoked after each statement attempt */
+    onProgress?: (event: ExecutionEvent) => void;
+    /** AbortSignal for external cancellation */
+    signal?: AbortSignal;
+}
+export type ExecutionEventKind = 'statement-start' | 'statement-success' | 'statement-retry' | 'statement-failed' | 'avalanche-abort' | 'dry-run-statement' | 'migration-complete' | 'migration-failed';
+export interface ExecutionEvent {
+    kind: ExecutionEventKind;
+    statementIndex: number;
+    totalStatements: number;
+    statementSql: string;
+    attempt: number;
+    elapsedMs: number;
+    error?: string;
+    lockTimeoutMs?: number;
+    retryBackoffMs?: number;
+}
+export interface ExecutionResult {
+    success: boolean;
+    statementsExecuted: number;
+    statementsTotal: number;
+    durationMs: number;
+    error?: string;
+    avalanche?: boolean;
+}
+/**
+ * Executes a SQL migration file against a PostgreSQL database with:
+ *  - per-statement lock-timeout injection
+ *  - exponential full-jitter retry on lock acquisition failures
+ *  - background lock-queue monitoring with automatic cancellation
+ *
+ * @param sql     Full text of the migration file
+ * @param options Execution configuration
+ */
+export declare function executeMigration(sql: string, options: ExecutorOptions): Promise<ExecutionResult>;
+/**
+ * Parses a SQL migration string and returns the list of individual statements
+ * that would be executed. Useful for tooling and dry-run previews.
+ */
+export declare function parseMigrationStatements(sql: string): string[];
+//# sourceMappingURL=executor.d.ts.map

package/dist/src/runner/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../../src/runner/executor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAUH,MAAM,WAAW,eAAe;IAC9B,+CAA+C;IAC/C,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mEAAmE;IACnE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,gFAAgF;IAChF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oFAAoF;IACpF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,4DAA4D;IAC5D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,CAAC;IAC7C,4CAA4C;IAC5C,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,MAAM,kBAAkB,GAC1B,iBAAiB,GACjB,mBAAmB,GACnB,iBAAiB,GACjB,kBAAkB,GAClB,iBAAiB,GACjB,mBAAmB,GACnB,oBAAoB,GACpB,kBAAkB,CAAC;AAEvB,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,kBAAkB,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAuGD;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,eAAe,CAAC,CAmQ1B;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAE9D"}

package/dist/src/runner/executor.js

@@ -0,0 +1,340 @@
+/**
+ * ddlforge - PostgreSQL DDL execution supervisor.
+ *
+ * Responsibilities
+ * ────────────────
+ * 1. Dynamically imports `pg` at runtime (graceful error if not installed).
+ * 2. Parses SQL migration files into individual statements (reuses the existing
+ *    zero-dependency lexer — no duplicate parser code).
+ * 3. For each statement:
+ *    a. Opens a transaction on a fresh client.
+ *    b. Injects `SET LOCAL lock_timeout` and `SET LOCAL statement_timeout`.
+ *    c. Executes the statement.
+ *    d. On error 55P03 (lock_not_available) or 57014 (query_canceled):
+ *       – Rolls back, waits for a full-jitter backoff interval, retries.
+ *    e. On avalanche detected by the lock monitor: rolls back and aborts.
+ *    f. On success: commits and proceeds to the next statement.
+ * 4. Reports live progress via an optional EventEmitter-compatible callback.
+ *
+ * Zero-dependency invariant
+ * ─────────────────────────
+ * `pg` is imported with `await import('pg')` inside an async function so it
+ * never appears in the static import graph.  Static linting (`ddlforge check`)
+ * works without `pg` installed.
+ */
+import { splitStatements } from '../lexer/sqlTokenizer.js';
+import { sleep, computeBackoff } from './backoff.js';
+import { startLockMonitor, isLockError } from './locksMonitor.js';
+/**
+ * Dynamically imports pg and returns the Pool and Client constructors.
+ * If pg is not installed, prints clear installation instructions and throws.
+ */
+async function loadPg() {
+    try {
+        // Dynamic import: NOT in static import graph — ddlforge check still works
+        const mod = await import('pg');
+        return mod.default;
+    }
+    catch {
+        const msg = [
+            '',
+            '  ╔══════════════════════════════════════════════════════════╗',
+            '  ║  ddlforge apply requires the "pg" package to be         ║',
+            '  ║  installed in your project.                             ║',
+            '  ║                                                          ║',
+            '  ║  Run one of:                                             ║',
+            '  ║    npm install pg                                        ║',
+            '  ║    yarn add pg                                           ║',
+            '  ║    pnpm add pg                                           ║',
+            '  ╚══════════════════════════════════════════════════════════╝',
+            '',
+        ].join('\n');
+        process.stderr.write(msg + '\n');
+        throw new Error('pg package is not installed. Run: npm install pg');
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Helpers                                                              */
+/* ------------------------------------------------------------------ */
+/**
+ * Normalises a timeout value into a bare integer millisecond string
+ * suitable for `SET LOCAL lock_timeout = '<value>'`.
+ *
+ * Accepts:
+ *  - "3000ms"  → "3000"
+ *  - "3s"      → "3000"  (NOT handled — pass pre-converted ms values)
+ *  - "3000"    → "3000"
+ *  - 3000      → "3000"
+ */
+function normaliseTimeoutMs(value) {
+    const s = String(value).trim();
+    if (s.endsWith('ms')) {
+        return s.slice(0, -2);
+    }
+    return s;
+}
+/**
+ * Returns the `code` from a Postgres-driver error object.
+ * pg errors expose `.code` as a top-level property.
+ */
+function pgErrorCode(err) {
+    if (err !== null && typeof err === 'object' && 'code' in err) {
+        return String(err['code'] ?? '');
+    }
+    return '';
+}
+/* ------------------------------------------------------------------ */
+/* Statement text reconstruction                                        */
+/* ------------------------------------------------------------------ */
+/**
+ * Extracts the original SQL text for a statement from the migration file.
+ * We reconstruct it from the token raw values so that whitespace is
+ * preserved reasonably well for display purposes.
+ */
+function statementText(raw) {
+    // The lexer joins tokens with single spaces; we just use the raw field.
+    return raw.trimEnd() + ';';
+}
+/* ------------------------------------------------------------------ */
+/* Main executor                                                        */
+/* ------------------------------------------------------------------ */
+/**
+ * Executes a SQL migration file against a PostgreSQL database with:
+ *  - per-statement lock-timeout injection
+ *  - exponential full-jitter retry on lock acquisition failures
+ *  - background lock-queue monitoring with automatic cancellation
+ *
+ * @param sql     Full text of the migration file
+ * @param options Execution configuration
+ */
+export async function executeMigration(sql, options) {
+    const { databaseUrl, lockTimeout = '3000ms', statementTimeout = '30000ms', maxRetries = 5, dryRun = false, lockQueueThreshold = 1, monitorPollMs = 500, onProgress, signal, } = options;
+    const lockTimeoutMs = normaliseTimeoutMs(lockTimeout);
+    const statementTimeoutMs = normaliseTimeoutMs(statementTimeout);
+    const migrationStart = Date.now();
+    // ── Parse statements (zero-dependency lexer) ────────────────────────
+    const statements = splitStatements(sql);
+    const total = statements.length;
+    if (total === 0) {
+        return { success: true, statementsExecuted: 0, statementsTotal: 0, durationMs: 0 };
+    }
+    // ── Dry run mode ─────────────────────────────────────────────────────
+    if (dryRun) {
+        for (let i = 0; i < statements.length; i++) {
+            const stmt = statements[i];
+            onProgress?.({
+                kind: 'dry-run-statement',
+                statementIndex: i,
+                totalStatements: total,
+                statementSql: statementText(stmt.raw),
+                attempt: 0,
+                elapsedMs: Date.now() - migrationStart,
+            });
+        }
+        return {
+            success: true,
+            statementsExecuted: 0,
+            statementsTotal: total,
+            durationMs: Date.now() - migrationStart,
+        };
+    }
+    // ── Load pg ──────────────────────────────────────────────────────────
+    const { Pool, Client } = await loadPg();
+    // One pool for the migration; monitor gets its own direct clients
+    const pool = new Pool({ connectionString: databaseUrl, max: 1 });
+    let statementsExecuted = 0;
+    let globalError;
+    let avalanche = false;
+    try {
+        for (let i = 0; i < statements.length; i++) {
+            if (signal?.aborted) {
+                globalError = 'Execution aborted by caller signal.';
+                break;
+            }
+            const stmt = statements[i];
+            const stmtSql = statementText(stmt.raw);
+            const stmtStart = Date.now();
+            let succeeded = false;
+            let stmtError;
+            onProgress?.({
+                kind: 'statement-start',
+                statementIndex: i,
+                totalStatements: total,
+                statementSql: stmtSql,
+                attempt: 0,
+                elapsedMs: stmtStart - migrationStart,
+                lockTimeoutMs: Number(lockTimeoutMs),
+            });
+            // ── Retry loop per statement ──────────────────────────────────────
+            for (let attempt = 0; attempt <= maxRetries; attempt++) {
+                if (signal?.aborted)
+                    break;
+                // Jitter-sleep before all retries (not before first attempt)
+                if (attempt > 0) {
+                    const backoff = computeBackoff(attempt - 1, {
+                        baseDelayMs: 250,
+                        maxDelayMs: 10_000,
+                        maxRetries,
+                    });
+                    onProgress?.({
+                        kind: 'statement-retry',
+                        statementIndex: i,
+                        totalStatements: total,
+                        statementSql: stmtSql,
+                        attempt,
+                        elapsedMs: Date.now() - migrationStart,
+                        retryBackoffMs: backoff.sleepMs,
+                    });
+                    await sleep(backoff.sleepMs, signal);
+                    if (signal?.aborted)
+                        break;
+                }
+                // Grab a client from the pool for this attempt
+                const client = await pool.connect();
+                // Snapshot our backend PID for the lock monitor
+                let migrationPid = -1;
+                try {
+                    const pidResult = await client.query('SELECT pg_backend_pid() AS pid');
+                    migrationPid = Number(pidResult.rows[0]?.['pid'] ?? -1);
+                }
+                catch {
+                    // Fallback: proceed without monitoring
+                }
+                // Start the lock monitor on its own independent connection
+                const monitorClientFactory = async () => {
+                    const monClient = new Client({ connectionString: databaseUrl });
+                    await monClient.connect?.();
+                    return monClient;
+                };
+                const monitor = migrationPid > 0
+                    ? startLockMonitor({
+                        migrationPid,
+                        clientFactory: monitorClientFactory,
+                        pollIntervalMs: monitorPollMs,
+                        queueThreshold: lockQueueThreshold,
+                        signal,
+                    })
+                    : null;
+                try {
+                    // Open transaction
+                    await client.query('BEGIN');
+                    // Inject session-local timeouts (scoped to this transaction)
+                    await client.query(`SET LOCAL lock_timeout = '${lockTimeoutMs}'`);
+                    await client.query(`SET LOCAL statement_timeout = '${statementTimeoutMs}'`);
+                    // Execute the DDL statement
+                    await client.query(stmtSql);
+                    // Commit
+                    await client.query('COMMIT');
+                    // Stop monitor — execution succeeded, no avalanche
+                    monitor?.stop();
+                    const monResult = await monitor?.result;
+                    if (monResult?.avalanche) {
+                        // Race condition: monitor fired just as we committed.
+                        // The COMMIT succeeded so we treat this as a success.
+                        // (pg_cancel_backend after COMMIT is a no-op.)
+                    }
+                    succeeded = true;
+                    stmtError = undefined;
+                    break; // exit retry loop
+                }
+                catch (err) {
+                    const code = pgErrorCode(err);
+                    // Stop monitor before doing anything else
+                    monitor?.stop();
+                    const monResult = await monitor?.result;
+                    // Rollback the failed transaction
+                    try {
+                        await client.query('ROLLBACK');
+                    }
+                    catch { /* ignore */ }
+                    if (monResult?.avalanche) {
+                        // Lock-queue avalanche: abort the entire migration
+                        onProgress?.({
+                            kind: 'avalanche-abort',
+                            statementIndex: i,
+                            totalStatements: total,
+                            statementSql: stmtSql,
+                            attempt,
+                            elapsedMs: Date.now() - migrationStart,
+                            error: `Lock-queue avalanche: ${monResult.blockedCount} backend(s) queued. Cancelled at ${monResult.cancelledAt}.`,
+                        });
+                        globalError = `Lock-queue avalanche detected. ${monResult.blockedCount} backend(s) were waiting behind migration PID ${migrationPid}. Migration aborted to protect connection pool.`;
+                        avalanche = true;
+                        break;
+                    }
+                    if (isLockError(code) && attempt < maxRetries) {
+                        // Retryable lock error — continue retry loop
+                        stmtError = `[${code}] ${err.message ?? String(err)}`;
+                        continue;
+                    }
+                    // Non-retryable error or max retries exhausted
+                    stmtError = `[${code || 'ERR'}] ${err.message ?? String(err)}`;
+                    break;
+                }
+                finally {
+                    client.release?.();
+                }
+            } // end retry loop
+            if (avalanche)
+                break;
+            if (signal?.aborted && !succeeded) {
+                globalError = 'Execution aborted by caller signal.';
+                break;
+            }
+            if (succeeded) {
+                statementsExecuted++;
+                onProgress?.({
+                    kind: 'statement-success',
+                    statementIndex: i,
+                    totalStatements: total,
+                    statementSql: stmtSql,
+                    attempt: 0,
+                    elapsedMs: Date.now() - stmtStart,
+                });
+            }
+            else {
+                globalError = stmtError ?? 'Unknown execution error.';
+                onProgress?.({
+                    kind: 'statement-failed',
+                    statementIndex: i,
+                    totalStatements: total,
+                    statementSql: stmtSql,
+                    attempt: maxRetries,
+                    elapsedMs: Date.now() - stmtStart,
+                    error: globalError,
+                });
+                break;
+            }
+        }
+    }
+    finally {
+        await pool.end().catch(() => { });
+    }
+    const durationMs = Date.now() - migrationStart;
+    const success = !globalError;
+    onProgress?.({
+        kind: success ? 'migration-complete' : 'migration-failed',
+        statementIndex: statementsExecuted,
+        totalStatements: total,
+        statementSql: '',
+        attempt: 0,
+        elapsedMs: durationMs,
+        error: globalError,
+    });
+    return {
+        success,
+        statementsExecuted,
+        statementsTotal: total,
+        durationMs,
+        error: globalError,
+        avalanche: avalanche || undefined,
+    };
+}
+/**
+ * Parses a SQL migration string and returns the list of individual statements
+ * that would be executed. Useful for tooling and dry-run previews.
+ */
+export function parseMigrationStatements(sql) {
+    return splitStatements(sql).map(s => statementText(s.raw));
+}
+//# sourceMappingURL=executor.js.map

package/dist/src/runner/executor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.js","sourceRoot":"","sources":["../../../src/runner/executor.ts"],"names":[],"mappings":"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"}

package/dist/src/runner/locksMonitor.d.ts

@@ -0,0 +1,85 @@
+/**
+ * ddlforge - Background lock-queue monitor for PostgreSQL execution supervisor.
+ *
+ * During DDL execution the monitor periodically queries pg_locks and
+ * pg_stat_activity to detect when other backends are queuing behind the
+ * migration's exclusive lock.  If the queue depth exceeds a configurable
+ * threshold the monitor cancels the migration backend via pg_cancel_backend()
+ * and sets the `avalanche` flag so the executor can surface a clear error.
+ *
+ * Design notes
+ * ────────────
+ * • Uses a separate Client connection so it never shares the migration
+ *   transaction (avoids deadlock on the monitor itself).
+ * • All monitor queries use SHORT local timeouts so a hung Postgres cannot
+ *   also jam the monitor.
+ * • The monitor resolves its returned promise with a MonitorResult when it
+ *   self-terminates; callers must await that to detect the avalanche flag.
+ */
+export interface MonitorOptions {
+    /** PID of the migration backend being guarded */
+    migrationPid: number;
+    /**
+     * Factory that returns a fresh client already connected to the database.
+     * The monitor will call end() on it when done.
+     */
+    clientFactory: () => Promise<MonitorClient>;
+    /** Milliseconds between each poll (default: 500 ms) */
+    pollIntervalMs?: number;
+    /**
+     * Number of waiting backends that triggers a cancellation
+     * (default: 1 – i.e. cancel as soon as even one query is blocked).
+     */
+    queueThreshold?: number;
+    /** AbortSignal: when aborted the monitor stops without cancelling */
+    signal?: AbortSignal;
+}
+/**
+ * Minimal pg Client interface required by the monitor.
+ * Using a structural type allows tests to inject simple mocks.
+ */
+export interface MonitorClient {
+    query(sql: string, params?: unknown[]): Promise<{
+        rows: Record<string, unknown>[];
+    }>;
+    end(): Promise<void>;
+}
+export interface MonitorResult {
+    /** True when the monitor detected a queue avalanche and cancelled the backend */
+    avalanche: boolean;
+    /** Number of waiting backends detected at cancellation time */
+    blockedCount: number;
+    /** ISO timestamp at which cancellation was issued (empty if no cancellation) */
+    cancelledAt: string;
+    /** Reason the monitor stopped */
+    stopReason: 'aborted' | 'avalanche' | 'error' | 'external-stop';
+}
+export interface BlockedBackend {
+    waiterPid: number;
+    waiterQuery: string;
+    waiterState: string;
+    waitEventType: string;
+    waitEvent: string;
+    blockerMode: string;
+}
+/**
+ * Starts a non-blocking background lock-queue monitor.
+ *
+ * Returns a Promise<MonitorResult> that settles when the monitor self-stops
+ * (either via the AbortSignal, an avalanche cancellation, or an internal error).
+ *
+ * Also returns a `stop()` function that callers use to gracefully terminate
+ * the monitor after successful execution.
+ */
+export declare function startLockMonitor(options: MonitorOptions): {
+    result: Promise<MonitorResult>;
+    stop: () => void;
+};
+/**
+ * Determines whether a Postgres error code represents a lock-related failure.
+ *
+ * 55P03 — lock_not_available  (SET LOCAL lock_timeout exceeded)
+ * 57014 — query_canceled      (SET LOCAL statement_timeout exceeded, or pg_cancel_backend)
+ */
+export declare function isLockError(code: string): boolean;
+//# sourceMappingURL=locksMonitor.d.ts.map

package/dist/src/runner/locksMonitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locksMonitor.d.ts","sourceRoot":"","sources":["../../../src/runner/locksMonitor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH,MAAM,WAAW,cAAc;IAC7B,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,aAAa,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,CAAC;IAC5C,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qEAAqE;IACrE,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;KAAE,CAAC,CAAC;IACrF,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,iFAAiF;IACjF,SAAS,EAAE,OAAO,CAAC;IACnB,+DAA+D;IAC/D,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,WAAW,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,UAAU,EAAE,SAAS,GAAG,WAAW,GAAG,OAAO,GAAG,eAAe,CAAC;CACjE;AAqCD,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,cAAc,GAAG;IACzD,MAAM,EAAE,OAAO,CAAC,aAAa,CAAC,CAAC;IAC/B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CA0HA;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjD"}