move JoinGraph to ts

Author: KSDaemon

packages/cubejs-schema-compiler/src/compiler/CubeSymbols.ts

@@ -857,7 +857,7 @@ export class CubeSymbols {
     }
   }
 
-  protected funcArguments(func: Function): string[] {
+  public funcArguments(func: Function): string[] {
     const funcDefinition = func.toString();
     if (!this.funcArgumentsValues[funcDefinition]) {
       const match = funcDefinition.match(FunctionRegex);

packages/cubejs-schema-compiler/src/compiler/JoinGraph.js renamed to packages/cubejs-schema-compiler/src/compiler/JoinGraph.ts

@@ -2,52 +2,123 @@ import R from 'ramda';
 import Graph from 'node-dijkstra';
 import { UserError } from './UserError';
 
+import type { CubeValidator } from './CubeValidator';
+import type { CubeEvaluator, MeasureDefinition } from './CubeEvaluator';
+import type { CubeDefinition, JoinDefinition } from './CubeSymbols';
+import type { ErrorReporter } from './ErrorReporter';
+
+type JoinEdge = {
+  join: JoinDefinition,
+  from: string,
+  to: string,
+  originalFrom: string,
+  originalTo: string,
+};
+
+type JoinTreeJoins = JoinEdge[];
+
+type JoinTree = {
+  root: string,
+  joins: JoinTreeJoins,
+};
+
+export type FinishedJoinTree = JoinTree & {
+  multiplicationFactor: Record<string, boolean>,
+};
+
+export type JoinHint = string | string[];
+
+export type JoinHints = JoinHint[];
+
 export class JoinGraph {
-  /**
-   * @param {import('./CubeValidator').CubeValidator} cubeValidator
-   * @param {import('./CubeEvaluator').CubeEvaluator} cubeEvaluator
-   */
-  constructor(cubeValidator, cubeEvaluator) {
+  private readonly cubeValidator: CubeValidator;
+
+  private readonly cubeEvaluator: CubeEvaluator;
+
+  // source node -> destination node -> weight
+  private nodes: Record<string, Record<string, 1>>;
+
+  // source node -> destination node -> weight
+  private undirectedNodes: Record<string, Record<string, 1>>;
+
+  private edges: Record<string, JoinEdge>;
+
+  private builtJoins: Record<string, FinishedJoinTree>;
+
+  private graph: Graph | null;
+
+  private cachedConnectedComponents: Record<string, number> | null;
+
+  public constructor(cubeValidator: CubeValidator, cubeEvaluator: CubeEvaluator) {
     this.cubeValidator = cubeValidator;
     this.cubeEvaluator = cubeEvaluator;
     this.nodes = {};
+    this.undirectedNodes = {};
     this.edges = {};
     this.builtJoins = {};
+    this.cachedConnectedComponents = null;
   }
 
-  compile(cubes, errorReporter) {
-    this.edges = R.compose(
+  public compile(cubes: unknown, errorReporter: ErrorReporter): void {
+    this.edges = R.compose<
+        Array<CubeDefinition>,
+        Array<CubeDefinition>,
+        Array<[string, JoinEdge][]>,
+        Array<[string, JoinEdge]>,
+        Record<string, JoinEdge>
+    >(
       R.fromPairs,
       R.unnest,
-      R.map(v => this.buildJoinEdges(v, errorReporter.inContext(`${v.name} cube`))),
+      R.map((v: CubeDefinition): [string, JoinEdge][] => this.buildJoinEdges(v, errorReporter.inContext(`${v.name} cube`))),
       R.filter(this.cubeValidator.isCubeValid.bind(this.cubeValidator))
     )(this.cubeEvaluator.cubeList);
-    this.nodes = R.compose(
+
+    // This requires @types/[email protected] or newer
+    // @ts-ignore
+    this.nodes = R.compose<
+        Record<string, JoinEdge>,
+        Array<[string, JoinEdge]>,
+        Array<JoinEdge>,
+        Record<string, Array<JoinEdge> | undefined>,
+        Record<string, Record<string, 1>>
+    >(
+      // This requires @types/[email protected] or newer
+      // @ts-ignore
       R.map(groupedByFrom => R.fromPairs(groupedByFrom.map(join => [join.to, 1]))),
-      R.groupBy(join => join.from),
+      R.groupBy((join: JoinEdge) => join.from),
       R.map(v => v[1]),
       R.toPairs
+    // @ts-ignore
     )(this.edges);
+
+    // @ts-ignore
     this.undirectedNodes = R.compose(
+      // @ts-ignore
       R.map(groupedByFrom => R.fromPairs(groupedByFrom.map(join => [join.from, 1]))),
+      // @ts-ignore
       R.groupBy(join => join.to),
       R.unnest,
+      // @ts-ignore
       R.map(v => [v[1], { from: v[1].to, to: v[1].from }]),
       R.toPairs
+    // @ts-ignore
     )(this.edges);
+
     this.graph = new Graph(this.nodes);
   }
 
-  buildJoinEdges(cube, errorReporter) {
+  protected buildJoinEdges(cube: CubeDefinition, errorReporter: ErrorReporter): Array<[string, JoinEdge]> {
+    // @ts-ignore
     return R.compose(
+      // @ts-ignore
       R.filter(R.identity),
-      R.map(join => {
-        const multipliedMeasures = R.compose(
-          R.filter(
-            m => m.sql && this.cubeEvaluator.funcArguments(m.sql).length === 0 && m.sql() === 'count(*)' ||
+      R.map((join: [string, JoinEdge]) => {
+        const multipliedMeasures: ((m: Record<string, MeasureDefinition>) => MeasureDefinition[]) = R.compose(
+          R.filter<MeasureDefinition>(
+            (m: MeasureDefinition): boolean => m.sql && this.cubeEvaluator.funcArguments(m.sql).length === 0 && m.sql() === 'count(*)' ||
             ['sum', 'avg', 'count', 'number'].indexOf(m.type) !== -1
           ),
-          R.values
+          R.values as (input: Record<string, MeasureDefinition>) => MeasureDefinition[]
         );
         const joinRequired =
           (v) => `primary key for '${v}' is required when join is defined in order to make aggregates work properly`;
@@ -66,7 +137,7 @@ export class JoinGraph {
         return join;
       }),
       R.unnest,
-      R.map(join => [
+      R.map((join: [string, JoinDefinition]): [[string, JoinEdge]] => [
         [`${cube.name}-${join[0]}`, {
           join: join[1],
           from: cube.name,
@@ -75,44 +146,65 @@ export class JoinGraph {
           originalTo: join[0]
         }]
       ]),
+      // @ts-ignore
       R.filter(R.identity),
-      R.map(join => {
+      R.map((join: [string, JoinDefinition]) => {
         if (!this.cubeEvaluator.cubeExists(join[0])) {
           errorReporter.error(`Cube ${join[0]} doesn't exist`);
           return undefined;
         }
         return join;
       }),
+      // @ts-ignore
       R.toPairs
+    // @ts-ignore
     )(cube.joins || {});
   }
 
-  buildJoinNode(cube) {
-    return R.compose(
+  protected buildJoinNode(cube: CubeDefinition): Record<string, 1> {
+    return R.compose<
+      Record<string, JoinDefinition>,
+      Array<[string, JoinDefinition]>,
+      Array<[string, 1]>,
+      Record<string, 1>
+    >(
       R.fromPairs,
       R.map(v => [v[0], 1]),
       R.toPairs
     )(cube.joins || {});
   }
 
-  buildJoin(cubesToJoin) {
+  public buildJoin(cubesToJoin: JoinHints): FinishedJoinTree | null {
     if (!cubesToJoin.length) {
       return null;
     }
     const key = JSON.stringify(cubesToJoin);
     if (!this.builtJoins[key]) {
-      const join = R.pipe(
+      const join = R.pipe<
+          JoinHints,
+          Array<JoinTree | null>,
+          Array<JoinTree>,
+          Array<JoinTree>
+      >(
         R.map(
-          cube => this.buildJoinTreeForRoot(cube, R.without([cube], cubesToJoin))
+          (cube: JoinHint): JoinTree | null => this.buildJoinTreeForRoot(cube, R.without([cube], cubesToJoin))
         ),
+        // @ts-ignore
         R.filter(R.identity),
-        R.sortBy(joinTree => joinTree.joins.length)
+        R.sortBy((joinTree: JoinTree) => joinTree.joins.length)
+      // @ts-ignore
       )(cubesToJoin)[0];
+
       if (!join) {
         throw new UserError(`Can't find join path to join ${cubesToJoin.map(v => `'${v}'`).join(', ')}`);
       }
+
       this.builtJoins[key] = Object.assign(join, {
-        multiplicationFactor: R.compose(
+        multiplicationFactor: R.compose<
+          JoinHints,
+          Array<[string, boolean]>,
+          Record<string, boolean>
+        >(
           R.fromPairs,
           R.map(v => [this.cubeFromPath(v), this.findMultiplicationFactorFor(this.cubeFromPath(v), join.joins)])
         )(cubesToJoin)
@@ -121,19 +213,19 @@ export class JoinGraph {
     return this.builtJoins[key];
   }
 
-  cubeFromPath(cubePath) {
+  protected cubeFromPath(cubePath) {
     if (Array.isArray(cubePath)) {
       return cubePath[cubePath.length - 1];
     }
     return cubePath;
   }
 
-  buildJoinTreeForRoot(root, cubesToJoin) {
+  protected buildJoinTreeForRoot(root: JoinHint, cubesToJoin: JoinHints): JoinTree | null {
     const self = this;
     if (Array.isArray(root)) {
       const [newRoot, ...additionalToJoin] = root;
       if (additionalToJoin.length > 0) {
-        cubesToJoin = [additionalToJoin].concat(cubesToJoin);
+        cubesToJoin = [additionalToJoin, ...cubesToJoin];
       }
       root = newRoot;
     }
@@ -157,39 +249,54 @@ export class JoinGraph {
         nodesJoined[toJoin] = true;
         return { cubes: path, joins: foundJoins };
       });
-    }).reduce((a, b) => a.concat(b), []).reduce((joined, res) => {
-      if (!res || !joined) {
-        return null;
-      }
-      const indexedPairs = R.compose(
-        R.addIndex(R.map)((j, i) => [i + joined.joins.length, j])
-      );
-      return {
-        joins: joined.joins.concat(indexedPairs(res.joins))
-      };
-    }, { joins: [] });
+    }).reduce((a, b) => a.concat(b), [])
+      // @ts-ignore
+      .reduce((joined, res) => {
+        if (!res || !joined) {
+          return null;
+        }
+        const indexedPairs = R.compose<
+          Array<JoinEdge>,
+          Array<[number, JoinEdge]>
+        >(
+          R.addIndex(R.map)((j, i) => [i + joined.joins.length, j])
+        );
+        return {
+          joins: [...joined.joins, ...indexedPairs(res.joins)],
+        };
+      }, { joins: [] });
 
     if (!result) {
       return null;
     }
 
-    const pairsSortedByIndex =
-      R.compose(R.uniq, R.map(indexToJoin => indexToJoin[1]), R.sortBy(indexToJoin => indexToJoin[0]));
+    const pairsSortedByIndex: (joins: [number, JoinEdge][]) => JoinEdge[] =
+      R.compose<
+        Array<[number, JoinEdge]>,
+        Array<[number, JoinEdge]>,
+        Array<JoinEdge>,
+        Array<JoinEdge>
+      >(
+        R.uniq,
+        R.map(([_, join]: [number, JoinEdge]) => join),
+        R.sortBy(([index]: [number, JoinEdge]) => index)
+      );
     return {
+      // @ts-ignore
       joins: pairsSortedByIndex(result.joins),
       root
     };
   }
 
-  findMultiplicationFactorFor(cube, joins) {
+  protected findMultiplicationFactorFor(cube: string, joins: JoinTreeJoins): boolean {
     const visited = {};
     const self = this;
-    function findIfMultipliedRecursive(currentCube) {
+    function findIfMultipliedRecursive(currentCube: string) {
       if (visited[currentCube]) {
         return false;
       }
       visited[currentCube] = true;
-      function nextNode(nextJoin) {
+      function nextNode(nextJoin: JoinEdge): string {
         return nextJoin.from === currentCube ? nextJoin.to : nextJoin.from;
       }
       const nextJoins = joins.filter(j => j.from === currentCube || j.to === currentCube);
@@ -205,16 +312,16 @@ export class JoinGraph {
     return findIfMultipliedRecursive(cube);
   }
 
-  checkIfCubeMultiplied(cube, join) {
+  protected checkIfCubeMultiplied(cube: string, join: JoinEdge): boolean {
     return join.from === cube && join.join.relationship === 'hasMany' ||
       join.to === cube && join.join.relationship === 'belongsTo';
   }
 
-  joinsByPath(path) {
+  protected joinsByPath(path: string[]): JoinEdge[] {
     return R.range(0, path.length - 1).map(i => this.edges[`${path[i]}-${path[i + 1]}`]);
   }
 
-  connectedComponents() {
+  public connectedComponents(): Record<string, number> {
     if (!this.cachedConnectedComponents) {
       let componentId = 1;
       const components = {};
@@ -227,7 +334,7 @@ export class JoinGraph {
     return this.cachedConnectedComponents;
   }
 
-  findConnectedComponent(componentId, node, components) {
+  protected findConnectedComponent(componentId: number, node: string, components: Record<string, number>): void {
     if (!components[node]) {
       components[node] = componentId;
       R.toPairs(this.undirectedNodes[node])