@rebasepro/server-postgres 0.10.1-canary.ed8caed → 0.10.1-canary.gdaf6ba4

package/dist/services/RelationService.d.ts

@@ -1,5 +1,6 @@
 import { DrizzleClient } from "../interfaces";
-import { CollectionConfig, FilterValues, Relation } from "@rebasepro/types";
+import { CollectionConfig, FilterValues, ResolvedRelation, ResolvedManyToMany } from "@rebasepro/types";
+import { type ResolvedVia } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 import type { NestedPathHop } from "./nested-path";
 /**
@@ -70,7 +71,7 @@ export declare class RelationService {
     /**
      * Fetch rows using join paths for complex relations
      */
-    fetchEntitiesUsingJoins<M extends Record<string, unknown>>(parentCollection: CollectionConfig, parentId: string | number, relation: Relation, options?: {
+    fetchEntitiesUsingJoins<M extends Record<string, unknown>>(parentCollection: CollectionConfig, parentId: string | number, relation: ResolvedRelation, options?: {
         filter?: FilterValues<Extract<keyof M, string>>;
         orderBy?: string;
         order?: "desc" | "asc";
@@ -118,13 +119,13 @@ export declare class RelationService {
     /**
      * Batch fetch related rows for multiple parent rows to avoid N+1 queries
      */
-    batchFetchRelatedEntities(parentCollectionPath: string, parentIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, RelatedRow<Record<string, unknown>>>>;
+    batchFetchRelatedEntities(parentCollectionPath: string, parentIds: (string | number)[], _relationKey: string, relation: ResolvedRelation): Promise<Map<string, RelatedRow<Record<string, unknown>>>>;
     /**
      * Batch fetch many-cardinality related rows for multiple parent rows.
      * Returns a Map<parentId, RelatedRow[]> instead of Map<parentId, RelatedRow>.
      * Uses a single SQL query with IN clause to avoid N+1.
      */
-    batchFetchRelatedEntitiesMany(parentCollectionPath: string, parentIds: (string | number)[], _relationKey: string, relation: Relation): Promise<Map<string, RelatedRow<Record<string, unknown>>[]>>;
+    batchFetchRelatedEntitiesMany(parentCollectionPath: string, parentIds: (string | number)[], _relationKey: string, relation: ResolvedRelation): Promise<Map<string, RelatedRow<Record<string, unknown>>[]>>;
     /**
      * Update many-to-many and junction relations
      */
@@ -134,7 +135,7 @@ export declare class RelationService {
      */
     updateInverseRelations(tx: DrizzleClient, sourceCollection: CollectionConfig, sourceEntityId: string | number, inverseRelationUpdates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedRelation;
         newValue: unknown;
     }>): Promise<void>;
     /**
@@ -150,13 +151,13 @@ export declare class RelationService {
      */
     updateJoinPathOneToOneRelations(tx: DrizzleClient, parentCollection: CollectionConfig, parentId: string | number, updates: Array<{
         relationKey: string;
-        relation: Relation;
+        relation: ResolvedVia;
         newTargetId: string | number | null;
     }>): Promise<void>;
     /**
      * Resolve joinPath write mapping for one-to-one relations
      */
-    resolveJoinPathWriteMapping(parentCollection: CollectionConfig, relation: Relation): {
+    resolveJoinPathWriteMapping(parentCollection: CollectionConfig, relation: ResolvedVia): {
         targetFKColName: string;
         parentSourceColName: string;
     };
@@ -166,7 +167,7 @@ export declare class RelationService {
     handleJunctionTableCreation(tx: DrizzleClient, newEntityId: string | number, junctionTableInfo: {
         parentCollection: CollectionConfig;
         parentId: string | number;
-        relation: Relation;
+        relation: ResolvedManyToMany;
         relationKey: string;
     }): Promise<void>;
 }

package/dist/services/cdc/junction-tables.d.ts

@@ -0,0 +1,38 @@
+import { CollectionConfig } from "@rebasepro/types";
+import { PostgresCollectionRegistry } from "../../collections/PostgresCollectionRegistry";
+/**
+ * One end of a many-to-many, as seen from the junction table.
+ *
+ * A junction table is not a collection, so nothing in the registry maps it to
+ * one — which is why a change to it was invisible to change capture. But its
+ * rows are exactly the contents of a parent's child list, so a write to it is a
+ * change to `<parentSlug>/<sourceId>/<relationKey>` and to nothing else.
+ */
+export interface JunctionLink {
+    schema: string;
+    /** The junction table itself, e.g. `posts_tags`. */
+    table: string;
+    /** The collection whose relation this is, e.g. `posts`. */
+    parentCollection: CollectionConfig;
+    /** The relation's key — the path segment a child list is addressed by. */
+    relationKey: string;
+    /** Junction column holding the parent's id. */
+    sourceColumn: string;
+    /** Junction column holding the target's id. */
+    targetColumn: string;
+}
+/**
+ * Every junction table reachable from a registered collection, once per
+ * relation that uses it.
+ *
+ * A junction is listed once per *direction* when both sides declare it, because
+ * each direction addresses a different child list: `posts/1/tags` and
+ * `tags/t/posts` both change when one link is written.
+ */
+export declare function collectJunctionLinks(registry: PostgresCollectionRegistry): JunctionLink[];
+/**
+ * Index {@link collectJunctionLinks} by table, under both the qualified and the
+ * bare name — a change event carries whatever the trigger reports, and a
+ * collection need not declare a schema.
+ */
+export declare function buildJunctionLinkMap(registry: PostgresCollectionRegistry): Map<string, JunctionLink[]>;

package/dist/services/nested-path.d.ts

@@ -1,4 +1,4 @@
-import { CollectionConfig, Relation } from "@rebasepro/types";
+import { CollectionConfig, ResolvedRelation } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 /**
  * The last hop of a nested collection path, e.g. `authors/1/posts`.
@@ -16,7 +16,7 @@ export interface NestedPathHop {
     parentId: string;
     /** The path segment that named the relation (e.g. `posts`). */
     relationKey: string;
-    relation: Relation;
+    relation: ResolvedRelation;
     /** `relation.target()`, resolved once. */
     targetCollection: CollectionConfig;
 }
@@ -45,7 +45,7 @@ export declare function resolveNestedPath(path: string, registry: PostgresCollec
  * `joinPath`. The target row is shared with other parents, so writing "through"
  * such a path addresses the *link*, not the row.
  */
-export declare function isJunctionBackedRelation(relation: Relation): boolean;
+export declare function isJunctionBackedRelation(relation: ResolvedRelation): boolean;
 /**
  * Reject a nested write whose final segment is a to-one relation.
  *

package/dist/services/realtimeService.d.ts

@@ -95,6 +95,8 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
     private cdcListener?;
     /** Whether database-level CDC is the active cross-instance change source. */
     private cdcActive;
+    /** Junction table → the child lists its rows belong to, built when CDC starts. */
+    private junctionLinkMap?;
     /** Reverse lookup: `schema.table` (and bare `table`) → collection, built when CDC starts. */
     private cdcTableMap?;
     /**
@@ -437,6 +439,23 @@ export declare class RealtimeService extends EventEmitter implements RealtimePro
      * subscriber, never per publisher.
      */
     private handleCdcEvent;
+    /**
+     * 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 handleJunctionCdcEvent;
     /** Compute the canonical (possibly composite) id string from a captured row. */
     private extractIdFromCdcRow;
     private dedupKey;

package/dist/services/row-pipeline.d.ts

@@ -1,4 +1,4 @@
-import { CollectionConfig, Relation } from "@rebasepro/types";
+import { CollectionConfig, ResolvedRelation } from "@rebasepro/types";
 import { PostgresCollectionRegistry } from "../collections/PostgresCollectionRegistry";
 /**
  * Turning a drizzle result into a row we serve.
@@ -26,7 +26,7 @@ export type RelationStyle = "ref" | "inline";
  * the query has to nest one level deeper for a junction, and the row walk has
  * to unwrap that same level back out.
  */
-export declare function isJunctionRelation(relation: Relation): boolean;
+export declare function isJunctionRelation(relation: ResolvedRelation): boolean;
 /**
  * The address a relation ref points at.
  *