@rebasepro/server-postgres 0.10.1-canary.8d27c46 → 0.10.1-canary.af2af91

package/src/services/realtimeService.ts

@@ -11,6 +11,7 @@ import { RealtimeProvider, CollectionSubscriptionConfig, SingleSubscriptionConfi
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import { buildPropertyCallbacks, getTableName } from "@rebasepro/common";
 import { applyAuthContext } from "../security/rls-enforcement";
+import { buildJunctionLinkMap, type JunctionLink } from "./cdc/junction-tables";
 import { logger } from "@rebasepro/server";
 import { sanitizeErrorForClient } from "../utils/pg-error-utils";
 import { CdcListener, type CdcChangeEvent } from "./cdc/CdcListener";
@@ -159,6 +160,9 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
     private cdcListener?: CdcListener;
     /** Whether database-level CDC is the active cross-instance change source. */
     private cdcActive = false;
+    /** Junction table → the child lists its rows belong to, built when CDC starts. */
+    private junctionLinkMap?: Map<string, JunctionLink[]>;
+
     /** Reverse lookup: `schema.table` (and bare `table`) → collection, built when CDC starts. */
     private cdcTableMap?: Map<string, CollectionConfig>;
     /**
@@ -1795,6 +1799,7 @@ lastSeen: Date.now() });
             return;
         }
         this.cdcTableMap = this.buildCdcTableMap();
+        this.junctionLinkMap = buildJunctionLinkMap(this.registry);
         this.cdcListener = new CdcListener(connectionString, (event) => this.handleCdcEvent(event));
         try {
             // start() validates the initial connection; if it can't be established
@@ -1805,6 +1810,7 @@ lastSeen: Date.now() });
             await this.cdcListener.stop().catch(() => { /* best effort */ });
             this.cdcListener = undefined;
             this.cdcTableMap = undefined;
+            this.junctionLinkMap = undefined;
             throw err;
         }
         this.cdcActive = true;
@@ -1822,6 +1828,7 @@ lastSeen: Date.now() });
             this.cdcListener = undefined;
         }
         this.cdcTableMap = undefined;
+        this.junctionLinkMap = undefined;
         this.recentAppEmits.clear();
     }
 
@@ -1862,6 +1869,10 @@ lastSeen: Date.now() });
     private async handleCdcEvent(event: CdcChangeEvent): Promise<void> {
         const collection = this.resolveCollectionForTable(event.schema, event.table);
         if (!collection) {
+            // A junction table backs no collection, but its rows *are* a child
+            // list. Route the change to the lists it changes before giving up.
+            if (await this.handleJunctionCdcEvent(event)) return;
+
             // Unmapped table (not backed by a collection) — nothing to deliver.
             this.debugLog(`📡 [CDC] Ignoring change on unmapped table ${event.schema}.${event.table}`);
             return;
@@ -1878,6 +1889,55 @@ lastSeen: Date.now() });
         await this.notifyUpdate(path, id, row, databaseId, /* broadcast */ false, /* origin */ "cdc");
     }
 
+    /**
+     * Deliver a change on a many-to-many junction table as a change to the child
+     * lists it belongs to.
+     *
+     * Linking a tag to a post writes only `posts_tags`. That table backs no
+     * collection, so change capture dropped the event as unmapped and the
+     * subscribers of `posts/1/tags` never heard about it — every other write in
+     * the system was realtime, and this one silently was not. The junction row
+     * carries both ids, so it names its own paths exactly.
+     *
+     * Notifies the nested path rather than either endpoint collection, because
+     * invalidation walks *parent* paths and never child ones: telling `tags` it
+     * changed would not reach a subscription on `posts/1/tags`.
+     *
+     * Returns whether the table was recognised as a junction.
+     */
+    private async handleJunctionCdcEvent(event: CdcChangeEvent): Promise<boolean> {
+        const links = this.junctionLinkMap?.get(`${event.schema}.${event.table}`)
+            ?? this.junctionLinkMap?.get(event.table);
+        if (!links?.length) return false;
+
+        for (const link of links) {
+            const sourceId = event.row?.[link.sourceColumn];
+            const targetId = event.row?.[link.targetColumn];
+            if (sourceId === undefined || sourceId === null || targetId === undefined || targetId === null) {
+                this.debugLog(
+                    `📡 [CDC] Junction row on ${event.table} is missing '${link.sourceColumn}'/'${link.targetColumn}' — skipping.`
+                );
+                continue;
+            }
+
+            const path = `${link.parentCollection.slug}/${String(sourceId)}/${link.relationKey}`;
+            // An unlink removes the target from this list; a link invalidates it
+            // so each subscriber refetches under its own RLS context.
+            const row = event.op === "DELETE" ? null : { _rebase_invalidated: true };
+
+            await this.notifyUpdate(
+                path,
+                String(targetId),
+                row,
+                (link.parentCollection as { databaseId?: string }).databaseId,
+                /* broadcast */ false,
+                /* origin */ "cdc"
+            );
+        }
+
+        return true;
+    }
+
     /** Compute the canonical (possibly composite) id string from a captured row. */
     private extractIdFromCdcRow(collection: CollectionConfig, row: Record<string, unknown>): string {
         // Unaddressable falls back to a collection-level invalidation: single-row

package/src/utils/drizzle-conditions.ts

@@ -38,6 +38,160 @@ export interface DrizzleDynamicQuery {
  */
 export class DrizzleConditionBuilder {
 
+    /**
+     * Express "reachable from this parent through this relation" as a plain
+     * `WHERE` condition on the target table.
+     *
+     * This is the primitive that lets a relation be a *filter* rather than an
+     * addressing scheme. A nested listing used to be served by its own query
+     * builder — `fetchEntitiesUsingJoins`, which grew joins the root pipeline
+     * did not have and lost the options the root pipeline did have (offset,
+     * filter, orderBy, include). Reduced to a condition, the same listing runs
+     * through the ordinary collection query, so it inherits all of them and
+     * there is one read path instead of two.
+     *
+     * The shapes:
+     *   - inverse FK  → `target.<fk> = :parentId`, a column comparison.
+     *   - `through`   → `EXISTS (SELECT 1 FROM junction …)`, correlated on the
+     *                   target's key, so the junction never multiplies rows the
+     *                   way an `INNER JOIN` would.
+     *   - `joinPath`  → the same `EXISTS`, with the path's steps joined inside
+     *                   it and the final step correlating to the outer row.
+     */
+    static buildRelationScopeCondition(
+        relation: Relation,
+        /**
+         * Lazy: only `joinPath` and `localKey` relations need the parent's own
+         * table. An inverse foreign key and a junction are both expressible
+         * from the parent's *id* alone, and requiring the table for them would
+         * make a child listing fail on a parent whose table isn't registered.
+         */
+        parent: () => { table: PgTable<any>; idColumn: AnyPgColumn },
+        parentId: string | number,
+        targetTable: PgTable<any>,
+        targetIdColumn: AnyPgColumn,
+        registry: PostgresCollectionRegistry
+    ): SQL {
+        if (relation.joinPath && relation.joinPath.length > 0) {
+            const { table, idColumn } = parent();
+            return this.buildJoinPathScopeCondition(
+                relation.joinPath, table, idColumn, parentId, targetTable, registry
+            );
+        }
+
+        if (relation.through) {
+            const junctionTable = registry.getTable(relation.through.table);
+            if (!junctionTable) {
+                throw new Error(`Junction table not found: ${relation.through.table}`);
+            }
+            const sourceCol = junctionTable[relation.through.sourceColumn as keyof typeof junctionTable] as AnyPgColumn;
+            const targetCol = junctionTable[relation.through.targetColumn as keyof typeof junctionTable] as AnyPgColumn;
+            if (!sourceCol || !targetCol) {
+                throw new Error(
+                    `Junction columns '${relation.through.sourceColumn}'/'${relation.through.targetColumn}' not found in '${relation.through.table}'`
+                );
+            }
+            return sql`EXISTS (SELECT 1 FROM ${junctionTable} WHERE ${targetCol} = ${targetIdColumn} AND ${sourceCol} = ${parentId})`;
+        }
+
+        if (relation.foreignKeyOnTarget) {
+            const fkColumn = targetTable[relation.foreignKeyOnTarget as keyof typeof targetTable] as AnyPgColumn;
+            if (!fkColumn) {
+                throw new Error(
+                    `Foreign key column '${relation.foreignKeyOnTarget}' not found in the target table of relation ` +
+                    `'${relation.relationName}'. A many-to-many relation needs \`through\` instead.`
+                );
+            }
+            return eq(fkColumn, parentId);
+        }
+
+        if (relation.localKey) {
+            // A to-one owning relation read as a scope: the single target row is
+            // the one the parent's foreign key points at.
+            const { table, idColumn } = parent();
+            return sql`${targetIdColumn} = (SELECT ${sql.identifier(relation.localKey)} FROM ${table} WHERE ${idColumn} = ${parentId})`;
+        }
+
+        throw new Error(
+            `Relation '${relation.relationName}' declares no \`foreignKeyOnTarget\`, \`through\`, \`joinPath\` or ` +
+            "`localKey`, so there is no way to tell which target rows belong to a parent."
+        );
+    }
+
+    /**
+     * `EXISTS` for an explicit `joinPath`.
+     *
+     * The path is declared source → target. The subquery replays every step but
+     * the last from inside, and turns the last one into the correlation with the
+     * outer target row — so the target table is never named twice and needs no
+     * alias. Each intermediate table is aliased positionally, which keeps a path
+     * that revisits a table (a self-referencing many-to-many) unambiguous.
+     */
+    private static buildJoinPathScopeCondition(
+        joinPath: JoinStep[],
+        parentTable: PgTable<any>,
+        parentIdColumn: AnyPgColumn,
+        parentId: string | number,
+        targetTable: PgTable<any>,
+        registry: PostgresCollectionRegistry
+    ): SQL {
+        const sourceAlias = "__rel_src";
+        const aliasFor = (index: number) => `__rel_j${index}`;
+
+        // Column reference against the previous hop: the aliased source for the
+        // first step, the previous aliased join table after that.
+        const fromRef = (stepIndex: number, column: string) =>
+            sql`${sql.identifier(stepIndex === 0 ? sourceAlias : aliasFor(stepIndex - 1))}.${sql.identifier(getColumnName(column))}`;
+
+        const pairs = (step: JoinStep): { from: string; to: string }[] => {
+            const from = Array.isArray(step.on.from) ? step.on.from : [step.on.from];
+            const to = Array.isArray(step.on.to) ? step.on.to : [step.on.to];
+            if (from.length !== to.length) {
+                throw new Error(`Join step on '${step.table}' has ${from.length} \`from\` columns and ${to.length} \`to\` columns`);
+            }
+            return from.map((f, i) => ({ from: f, to: to[i] }));
+        };
+
+        const inner = joinPath.slice(0, -1);
+        const last = joinPath[joinPath.length - 1];
+
+        const joins: SQL[] = inner.map((step, index) => {
+            const table = registry.getTable(step.table);
+            if (!table) throw new Error(`Join table not found: ${step.table}`);
+            const on = pairs(step).map(({ from, to }) =>
+                sql`${fromRef(index, from)} = ${sql.identifier(aliasFor(index))}.${sql.identifier(getColumnName(to))}`
+            );
+            return sql`JOIN ${table} AS ${sql.identifier(aliasFor(index))} ON ${sql.join(on, sql` AND `)}`;
+        });
+
+        // The last step correlates to the outer row instead of joining the
+        // target table into the subquery.
+        //
+        // On the step's own `to` column, which is not always the target's
+        // primary key: a one-step path like `{ table: "posts", on: { from:
+        // "id", to: "author_id" } }` correlates through a foreign key, and
+        // matching `authors.id = posts.id` there compares two unrelated
+        // identifiers — which returns nothing, quietly. Referencing the Drizzle
+        // column rather than a bare name also keeps it qualified, so it binds
+        // to the outer target and not to a table joined inside the EXISTS.
+        const targetColumn = (name: string): AnyPgColumn => {
+            const column = targetTable[getColumnName(name) as keyof typeof targetTable] as AnyPgColumn;
+            if (!column) {
+                throw new Error(`Join step column '${name}' not found in the target table of this joinPath`);
+            }
+            return column;
+        };
+
+        const correlation = sql.join(
+            pairs(last).map(({ from, to }) => sql`${fromRef(inner.length, from)} = ${targetColumn(to)}`),
+            sql` AND `
+        );
+
+        const joinsSql = joins.length > 0 ? sql` ${sql.join(joins, sql` `)}` : sql``;
+
+        return sql`EXISTS (SELECT 1 FROM ${parentTable} AS ${sql.identifier(sourceAlias)}${joinsSql} WHERE ${sql.identifier(sourceAlias)}.${sql.identifier(parentIdColumn.name)} = ${parentId} AND ${correlation})`;
+    }
+
     /**
      * Build filter conditions from FilterValues
      */