orez 0.4.29 → 0.4.31

package/dist/pg-proxy-do-backend.js

@@ -2,6 +2,7 @@
 import { deparseSync, loadModule, parseSync } from 'pgsql-parser';
 import { TX_MANIFEST_DDL, TX_MANIFEST_TABLE } from './cf-do/tx-journal.js';
 import { RETURNING_INTERNAL_PREFIX } from './do-sql-tracking.js';
+import { expandDelete, FkCascadeRegistry, recordAlterTableForeignKeys, recordCreateTableForeignKeys, } from './fk-cascade.js';
 import { Mutex } from './mutex.js';
 import { signalReplicationChange } from './replication/handler.js';
 import { markSQLiteKeywordIdentifiers, restoreSQLiteKeywordIdentifierMarkers, } from './sqlite-keyword-identifiers.js';
@@ -939,6 +940,14 @@ function flattenSchemaName(schema, name) {
         return `_zero_${name}`;
     return `${schema}_${name}`;
 }
+// canonical FK-registry key for a table: schema-qualified PG name (un-flattened),
+// quoted. used for BOTH capture (CREATE TABLE child + parent) and lookup (DELETE
+// target), so they always agree. expansion emits PG SQL under these names and
+// each child re-enters rewriteParsedStatement, which flattens + tracks it exactly
+// like a normal delete — so cascade tracking is identical to hand-written deletes.
+function fkTableKey(ref) {
+    return `${quoteIdentifier(ref.schemaname ?? 'public')}.${quoteIdentifier(ref.relname)}`;
+}
 function flattenRangeVar(rangeVar) {
     if (!rangeVar?.schemaname)
         return rangeVar?.relname;
@@ -3085,6 +3094,28 @@ function deparseExpressionSQL(version, expr) {
         return null;
     return sql.slice(selectIndex + 'SELECT'.length).trim();
 }
+// expand a DELETE on `target` into its cascade child statements (leaves-first).
+// expansion emits PG SQL under un-flattened names, then each child re-enters
+// rewriteParsedStatement (suppressFkCascade so it doesn't re-expand) — so each
+// returns a normal RewrittenStatement, flattened + change-tracked identically to
+// a hand-written delete. `whereClause` is the parent's already-normalized clause
+// (deparsed back to SQL, $N params intact); its $N bind to the parent's params
+// at execute time. unconditional deletes (no WHERE) cascade every child row.
+function buildCascadeStatements(version, target, whereClause, context) {
+    const whereSql = whereClause ? deparseExpressionSQL(version, whereClause) : null;
+    const childContext = { ...context, suppressFkCascade: true };
+    const out = [];
+    for (const childSql of expandDelete(target, whereSql, context.fkRegistry)) {
+        for (const raw of parseSync(childSql).stmts) {
+            const rewritten = rewriteParsedStatement(version, raw, childContext);
+            if (Array.isArray(rewritten))
+                out.push(...rewritten.filter((s) => !!s));
+            else if (rewritten)
+                out.push(rewritten);
+        }
+    }
+    return out;
+}
 function parseExpressionTarget(source) {
     try {
         const parsed = parseSync(`SELECT ${source}`);
@@ -3439,7 +3470,14 @@ function rewriteParsedStatement(version, rawStmt, context) {
     let changeTracking;
     let writeTable = null;
     let serialTriggers = [];
+    let cascadeStatements;
+    let fkEdgesAdded = false;
     if (nodeType === 'AlterTableStmt') {
+        // capture FK cascade/set-null edges before normalizeAlterTable drops the
+        // ADD CONSTRAINT — drizzle emits FKs as a separate ALTER, not inline.
+        if (context?.fkRegistry && !context.suppressFkCascade) {
+            fkEdgesAdded = recordAlterTableForeignKeys(node, context.fkRegistry, fkTableKey) > 0;
+        }
         alterMetadata = normalizeAlterTable(node);
         if (!node.cmds?.length) {
             const statements = [];
@@ -3456,6 +3494,12 @@ function rewriteParsedStatement(version, rawStmt, context) {
     }
     else if (nodeType === 'CreateStmt') {
         schemaColumns = schemaColumnsForCreateTable(node);
+        // capture FK cascade/set-null edges BEFORE normalizeCreateTable drops the
+        // CONSTR_FOREIGN nodes. flattened keys (fkTableKey) match the DELETE lookup.
+        if (context?.fkRegistry) {
+            fkEdgesAdded =
+                recordCreateTableForeignKeys(node, context.fkRegistry, fkTableKey) > 0;
+        }
         // capture serial columns before normalizeCreateTable rewrites the type to integer
         const serialCols = serialColumnNames(node);
         normalizeCreateTable(node);
@@ -3490,6 +3534,15 @@ function rewriteParsedStatement(version, rawStmt, context) {
     else if (nodeType === 'DeleteStmt') {
         const table = publicationTableRefForRangeVar(node.relation);
         writeTable = table;
+        // build the cascade from the ORIGINAL delete (before normalizeDelete mutates
+        // node), so each child re-enters the rewrite and is flattened + translated
+        // uniformly. suppressFkCascade guards against re-expanding the children.
+        if (context?.fkRegistry?.hasEdges && !context.suppressFkCascade && node.relation) {
+            const cascadeTarget = fkTableKey(node.relation);
+            if (context.fkRegistry.childrenOf(cascadeTarget).length) {
+                cascadeStatements = buildCascadeStatements(version, cascadeTarget, node.whereClause, context);
+            }
+        }
         skipIfTableEmpty = normalizeDelete(node, context);
         changeTracking = changeTrackingForDML(version, stmt, nodeType, table, 'DELETE');
     }
@@ -3590,6 +3643,8 @@ function rewriteParsedStatement(version, rawStmt, context) {
         ...(skipIfColumnExists ? { skipIfColumnExists } : null),
         ...(skipIfColumnMissing ? { skipIfColumnMissing } : null),
         ...(skipIfTableEmpty ? { skipIfTableEmpty } : null),
+        ...(cascadeStatements?.length ? { cascadeStatements } : null),
+        ...(fkEdgesAdded ? { fkEdges: true } : null),
     };
     return serialTriggers.length ? [mainStatement, ...serialTriggers] : mainStatement;
 }
@@ -4735,6 +4790,7 @@ export class DoBackend {
         this.schemaMetadata = new Map();
         this.publications = new Map();
         this.rewriteCache = new Map();
+        this.fkRegistry = new FkCascadeRegistry();
     }
     get waitReady() {
         return this.ensureReady();
@@ -4827,6 +4883,9 @@ export class DoBackend {
                     if (publication)
                         this.publications.set(key, publication);
                 }
+                else if (kind === 'fk_edge') {
+                    this.fkRegistry.add(key, JSON.parse(value));
+                }
             }
             if (await this.repairShardMetadataPublications()) {
                 await this.persistDurableMetadata();
@@ -4904,6 +4963,16 @@ export class DoBackend {
             for (const [name, publication] of this.publications) {
                 rows.push(['publication', name, '', this.publicationToJSON(publication)]);
             }
+            // FK cascade edges — durable so the registry survives DO eviction (the
+            // app tables persist and CREATE TABLE never re-runs to repopulate it).
+            for (const [parentKey, child] of this.fkRegistry.entries()) {
+                rows.push([
+                    'fk_edge',
+                    parentKey,
+                    `${child.table}|${child.columns.join(',')}`,
+                    JSON.stringify(child),
+                ]);
+            }
             if (rows.length === 0)
                 return;
             // single multi-row INSERT OR REPLACE per chunk. previously this was one
@@ -5251,6 +5320,13 @@ export class DoBackend {
                 this.applyPublicationChange(change);
                 changed = true;
             }
+            if (statement.fkEdges) {
+                // edges were already added to this.fkRegistry at rewrite time; persist
+                // them and drop cached rewrites so DELETEs issued before this CREATE
+                // TABLE now expand their cascade.
+                changed = true;
+                this.rewriteCache.clear();
+            }
         }
         if (changed) {
             this.publicationTableInfoCache = null;
@@ -5536,6 +5612,9 @@ export class DoBackend {
             const tracking = statement ? this.trackingForStatement(statement) : undefined;
             const bound = this.sqliteBoundSQL(tracking?.returningSQL ?? sql, portal.params, portal.arrayParamNumbers, portal.jsonParamNumbers, portal.timestampParamNumbers, portal.epochMillisParamNumbers, portal.booleanParamNumbers);
             const exec = await this.materializePublishedSchemaFunctions(bound.sql, statement, bound.params);
+            if (statement?.cascadeStatements?.length) {
+                await this.runCascadeStatements(statement.cascadeStatements, portal);
+            }
             const result = await this.doExecResult(exec.sql, exec.params, tracking ? this.trackingRequest(tracking) : undefined);
             if (portal.schemaColumns?.length) {
                 await this.applyStatementMetadata([{ sql, schemaColumns: portal.schemaColumns }]);
@@ -5628,6 +5707,9 @@ export class DoBackend {
         }
         if (statement)
             await this.snapshotTransactionWrite(statement);
+        if (statement?.cascadeStatements?.length) {
+            await this.runCascadeStatements(statement.cascadeStatements, {});
+        }
         const tracking = statement ? this.trackingForStatement(statement) : undefined;
         const result = await this.doExecResult(tracking?.returningSQL ?? rewritten, undefined, tracking ? this.trackingRequest(tracking) : undefined);
         await this.applyStatementMetadata(statements);
@@ -5705,6 +5787,16 @@ export class DoBackend {
             ? this.sqliteBoundSQL(tracking.returningSQL, params, arrayParamNumbers, jsonParamNumbers, timestampParamNumbers, epochMillisParamNumbers, booleanParamNumbers)
             : bound;
         const exec = await this.materializePublishedSchemaFunctions(execBound.sql, statement, execBound.params);
+        if (statement?.cascadeStatements?.length) {
+            await this.runCascadeStatements(statement.cascadeStatements, {
+                params,
+                arrayParamNumbers,
+                jsonParamNumbers,
+                timestampParamNumbers,
+                epochMillisParamNumbers,
+                booleanParamNumbers,
+            });
+        }
         const result = await this.doExecResult(exec.sql, exec.params, tracking ? this.trackingRequest(tracking) : undefined);
         await this.applyStatementMetadata(statements);
         // metadata for the returned columns must be derived from the ORIGINAL SQL,
@@ -5743,6 +5835,7 @@ export class DoBackend {
             arrayParamNumbers,
             jsonParamNumbers,
             epochMillisParamNumbers,
+            fkRegistry: this.fkRegistry,
         });
         if (this.canCacheRewrite(statements)) {
             this.rememberRewrite(key, statements);
@@ -5781,6 +5874,7 @@ export class DoBackend {
             arrayParamNumbers,
             jsonParamNumbers,
             epochMillisParamNumbers,
+            fkRegistry: this.fkRegistry,
         });
     }
     normalizedHighLevelResult(sql, result) {
@@ -5969,6 +6063,9 @@ export class DoBackend {
         if (statement.isDDL)
             this.publicationTableInfoCache = null;
         await this.snapshotTransactionWrite(statement);
+        if (statement.cascadeStatements?.length) {
+            await this.runCascadeStatements(statement.cascadeStatements, {});
+        }
         const tracking = this.trackingForStatement(statement);
         const exec = await this.materializePublishedSchemaFunctions(tracking?.returningSQL ?? statement.sql, statement);
         return this.doExecResult(exec.sql, exec.params, tracking ? this.trackingRequest(tracking) : undefined);
@@ -5980,6 +6077,23 @@ export class DoBackend {
         }
         return result;
     }
+    // run a parent DELETE's cascade children (leaves-first) as their own bound
+    // execs BEFORE the parent. each child's returningSQL embeds the full parent
+    // WHERE, so the SAME params bind unchanged (sqliteBoundSQL maps $N
+    // positionally); the tracking request captures every deletion so it
+    // replicates like any other write. publication gating matches the parent:
+    // unpublished (e.g. private) child tables cascade in the store but don't
+    // stream — correct, since clients don't see those rows anyway.
+    async runCascadeStatements(cascades, bind) {
+        for (const child of cascades) {
+            if (await this.shouldSkipStatement(child))
+                continue;
+            await this.snapshotTransactionWrite(child);
+            const gated = this.trackingForStatement(child);
+            const bound = this.sqliteBoundSQL(gated?.returningSQL ?? child.sql, bind.params, bind.arrayParamNumbers, bind.jsonParamNumbers, bind.timestampParamNumbers, bind.epochMillisParamNumbers, bind.booleanParamNumbers);
+            await this.doExecResult(bound.sql, bound.params, gated ? this.trackingRequest(gated) : undefined);
+        }
+    }
     async doBatchExec(statements) {
         let sqls = [];
         const flush = async () => {