drizzle-cube 0.4.2 → 0.4.4

package/dist/server/index.d.ts

@@ -2138,6 +2138,8 @@ declare interface InternalJoinPathStep {
     toCube: string;
     /** The join definition from the source cube */
     joinDef: CubeJoin;
+    /** True when this step was discovered via a reversed edge (target cube defines the join back to source) */
+    reversed?: boolean;
 }
 
 /**
@@ -2259,15 +2261,30 @@ export declare interface JoinPathAnalysis {
 }
 
 /**
- * Resolves join paths between cubes and manages connectivity caching
+ * Resolves join paths between cubes and manages connectivity caching.
+ * Supports bidirectional path finding: both forward (outgoing) joins and
+ * reverse (incoming) joins are traversable. Reversed steps are marked with
+ * `reversed: true` so downstream code can adjust join type and analysis.
  */
 export declare class JoinPathResolver {
     private cubes;
     private connectivityCache;
+    /** Maps cubeName → joins that TARGET that cube (incoming edges) */
+    private reverseIndex;
     /**
      * @param cubes Map of cube name to cube definition
      */
     constructor(cubes: Map<string, Cube>);
+    /**
+     * Build reverse adjacency index: for each cube's outgoing join A→B,
+     * store an entry under B pointing back to A.
+     *
+     * Excludes belongsToMany joins because reversing them requires swapping
+     * sourceKey/targetKey in the junction table configuration, which is
+     * error-prone. The 2-hop forward path through the junction table handles
+     * these relationships correctly.
+     */
+    private buildReverseIndex;
     /**
      * Find the shortest join path from source cube to target cube
      * Uses BFS algorithm for optimal path discovery
@@ -2324,6 +2341,11 @@ export declare class JoinPathResolver {
      * @returns true if all cubes are reachable
      */
     canReachAll(fromCube: string, allCubes: string[]): boolean;
+    /**
+     * Forward-only path finding (no reverse edges).
+     * Used by canReachAll for primary cube selection to preserve join semantics.
+     */
+    private findForwardOnlyPath;
     /**
      * Build SQL join condition from join definition
      *
@@ -2354,7 +2376,7 @@ export declare interface JoinPathStep {
     fromCube: string;
     /** Target cube name */
     toCube: string;
-    /** Relationship type used */
+    /** Relationship type used (effective, after reversal if applicable) */
     relationship: 'belongsTo' | 'hasOne' | 'hasMany' | 'belongsToMany';
     /** SQL join type that will be used */
     joinType: 'inner' | 'left' | 'right' | 'full';
@@ -2369,6 +2391,8 @@ export declare interface JoinPathStep {
         sourceColumns: string[];
         targetColumns: string[];
     };
+    /** True when this step was discovered via a reversed edge */
+    reversed?: boolean;
 }
 
 declare interface JoinRef {