perf(schema-compiler): Optimize CubeToMetaTransformer compilation flow (#10150)

* get rid of ramda in CubeToMetaTransformer

* optimize transform() in CubeToMetaTransformer

* move CubeDictionary to ts

* some types specified (CompilerInterface)

* move ContextEvaluator to ts

* fix unit tests (because of types)

* more precise types in CubeSymbols

* fix integration tests (because of types)

* move CubeToMetaTransformer to ts

* rewrite byId in CubeDictionary to Map<string, Cube>

* move contextDefinitions in ContextEvaluator to Map<string, CompiledContext>

Author: KSDaemon

packages/cubejs-schema-compiler/src/compiler/ContextEvaluator.js

@@ -0,0 +1,50 @@
+import type { CubeEvaluator } from './CubeEvaluator';
+import type { ErrorReporter } from './ErrorReporter';
+import { CompilerInterface } from './PrepareCompiler';
+
+export interface ContextInput {
+  name: string;
+  contextMembers: any;
+}
+
+export interface CompiledContext {
+  name: string;
+  contextMembers: any;
+}
+
+export class ContextEvaluator implements CompilerInterface {
+  private readonly cubeEvaluator: CubeEvaluator;
+
+  private contextDefinitions: Map<string, CompiledContext>;
+
+  public constructor(cubeEvaluator: CubeEvaluator) {
+    this.cubeEvaluator = cubeEvaluator;
+    this.contextDefinitions = new Map<string, CompiledContext>();
+  }
+
+  public compile(contexts: ContextInput[], errorReporter?: ErrorReporter): void {
+    if (contexts.length === 0) {
+      return;
+    }
+
+    this.contextDefinitions = new Map<string, CompiledContext>();
+    for (const context of contexts) {
+      if (errorReporter && this.contextDefinitions.has(context.name)) {
+        errorReporter.error(`Context "${context.name}" already exists!`);
+      } else {
+        this.contextDefinitions.set(context.name, this.compileContext(context));
+      }
+    }
+  }
+
+  private compileContext(context: ContextInput): CompiledContext {
+    return {
+      name: context.name,
+      contextMembers: this.cubeEvaluator.evaluateReferences(null, context.contextMembers)
+    };
+  }
+
+  public get contextList(): string[] {
+    return Array.from(this.contextDefinitions.keys());
+  }
+}

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

@@ -0,0 +1,35 @@
+import type { ErrorReporter } from './ErrorReporter';
+import { TranspilerCubeResolver } from './transpilers';
+import { CompilerInterface } from './PrepareCompiler';
+
+export interface Cube {
+  name: string;
+  [key: string]: any;
+}
+
+export class CubeDictionary implements TranspilerCubeResolver, CompilerInterface {
+  private byId: Map<string, Cube>;
+
+  public constructor() {
+    this.byId = new Map<string, Cube>();
+  }
+
+  public compile(cubes: Cube[], _errorReporter?: ErrorReporter): void {
+    this.byId = new Map<string, Cube>();
+    for (const cube of cubes) {
+      this.byId.set(cube.name, cube);
+    }
+  }
+
+  public resolveCube(name: string): Cube | undefined {
+    return this.byId.get(name);
+  }
+
+  public free(): void {
+    this.byId = new Map<string, Cube>();
+  }
+
+  public cubeNames(): string[] {
+    return Array.from(this.byId.keys());
+  }
+}

packages/cubejs-schema-compiler/src/compiler/CubeDictionary.js

@@ -8,11 +8,13 @@ import { camelizeCube } from './utils';
 
 import type { ErrorReporter } from './ErrorReporter';
 import { TranspilerSymbolResolver } from './transpilers';
+import { CompilerInterface } from './PrepareCompiler';
 
 export type ToString = { toString(): string };
 
 export type GranularityDefinition = {
   sql?: (...args: any[]) => string;
+  name?: string;
   title?: string;
   interval?: string;
   offset?: string;
@@ -139,6 +141,17 @@ export type ViewIncludedMember = {
   name: string;
 };
 
+export type FolderMember = {
+  type?: 'folder';
+  name: string;
+  includes?: FolderMember[];
+};
+
+export type Folder = {
+  name: string;
+  includes: FolderMember[];
+};
+
 export interface CubeDefinition {
   name: string;
   extends?: (...args: Array<unknown>) => { __cubeName: string };
@@ -158,7 +171,7 @@ export interface CubeDefinition {
   accessPolicy?: AccessPolicyDefinition[];
   // eslint-disable-next-line camelcase
   access_policy?: any[];
-  folders?: any[];
+  folders?: Folder[];
   includes?: any;
   excludes?: any;
   cubes?: any;
@@ -215,7 +228,7 @@ export const CONTEXT_SYMBOLS = {
 
 export const CURRENT_CUBE_CONSTANTS = ['CUBE', 'TABLE'];
 
-export class CubeSymbols implements TranspilerSymbolResolver {
+export class CubeSymbols implements TranspilerSymbolResolver, CompilerInterface {
   public symbols: Record<string | symbol, CubeSymbolsDefinition>;
 
   private builtCubes: Record<string, CubeDefinitionExtended>;
@@ -913,9 +926,7 @@ export class CubeSymbols implements TranspilerSymbolResolver {
    * refactoring.
    */
   protected evaluateContextFunction(cube: any, contextFn: any, context: any = {}) {
-    const cubeEvaluator = this;
-
-    return cubeEvaluator.resolveSymbolsCall(contextFn, (name: string) => {
+    return this.resolveSymbolsCall(contextFn, (name: string) => {
       const resolvedSymbol = this.resolveSymbol(cube, name);
       if (resolvedSymbol) {
         return resolvedSymbol;
@@ -930,7 +941,7 @@ export class CubeSymbols implements TranspilerSymbolResolver {
     });
   }
 
-  protected evaluateReferences<T extends ToString | Array<ToString>>(
+  public evaluateReferences<T extends ToString | Array<ToString>>(
     cube: string | null,
     referencesFn: (...args: Array<unknown>) => T,
     options: { collectJoinHints?: boolean, originalSorting?: boolean } = {}