refactor(schema-compiler): Extract ToString type

Author: mcheshkov

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

@@ -1,7 +1,7 @@
 /* eslint-disable no-restricted-syntax */
 import R from 'ramda';
 
-import { CubeSymbols } from './CubeSymbols';
+import { CubeSymbols, type ToString } from './CubeSymbols';
 import { UserError } from './UserError';
 import { BaseQuery } from '../adapter';
 import type { CubeValidator } from './CubeValidator';
@@ -28,7 +28,7 @@ export type DimensionDefinition = {
 };
 
 export type TimeShiftDefinition = {
-  timeDimension: (...args: Array<unknown>) => { toString(): string },
+  timeDimension: (...args: Array<unknown>) => ToString,
   interval: string,
   type: 'next' | 'prior',
 };
@@ -48,9 +48,9 @@ export type MeasureDefinition = {
   primaryKey?: true,
   drillFilters?: any,
   multiStage?: boolean,
-  groupBy?: (...args: Array<unknown>) => Array<{ toString(): string }>,
-  reduceBy?: (...args: Array<unknown>) => Array<{ toString(): string }>,
-  addGroupBy?: (...args: Array<unknown>) => Array<{ toString(): string }>,
+  groupBy?: (...args: Array<unknown>) => Array<ToString>,
+  reduceBy?: (...args: Array<unknown>) => Array<ToString>,
+  addGroupBy?: (...args: Array<unknown>) => Array<ToString>,
   timeShift?: TimeShiftDefinition[],
   groupByReferences?: string[],
   reduceByReferences?: string[],
@@ -67,13 +67,13 @@ export type PreAggregationFilters = {
 
 type PreAggregationDefinition = {
   allowNonStrictDateRangeMatch?: boolean,
-  timeDimensionReference?: () => { toString(): string },
+  timeDimensionReference?: () => ToString,
   granularity: string,
-  timeDimensionReferences: Array<{ dimension: () => { toString(): string }, granularity: string }>,
-  dimensionReferences: () => Array<{ toString(): string }>,
-  segmentReferences: () => Array<{ toString(): string }>,
-  measureReferences: () => Array<{ toString(): string }>,
-  rollupReferences: () => Array<{ toString(): string }>,
+  timeDimensionReferences: Array<{ dimension: () => ToString, granularity: string }>,
+  dimensionReferences: () => Array<ToString>,
+  segmentReferences: () => Array<ToString>,
+  measureReferences: () => Array<ToString>,
+  rollupReferences: () => Array<ToString>,
 };
 
 type PreAggregationTimeDimensionReference = {

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

@@ -9,6 +9,8 @@ import { BaseQuery } from '../adapter';
 
 import type { ErrorReporter } from './ErrorReporter';
 
+export type ToString = { toString(): string };
+
 interface CubeDefinition {
   name: string;
   extends?: (...args: Array<unknown>) => { __cubeName: string };
@@ -293,7 +295,7 @@ export class CubeSymbols {
         // Extend `includes` with members from hierarchies that should be auto-included
         const cubes = type === 'dimensions' ? cube.cubes.map((it) => {
           // TODO recheck `it.joinPath` typing
-          const fullPath = this.evaluateReferences(null, it.joinPath as () => { toString(): string }, { collectJoinHints: true });
+          const fullPath = this.evaluateReferences(null, it.joinPath as () => ToString, { collectJoinHints: true });
           const split = fullPath.split('.');
           const cubeRef = split[split.length - 1];
 
@@ -334,7 +336,7 @@ export class CubeSymbols {
 
           if (hierarchy) {
             // TODO recheck `this.getResolvedMember(...).levels` typing
-            const levels = this.evaluateReferences(cubeName, this.getResolvedMember('hierarchies', cubeName, hierarchyName).levels as () => Array<{ toString(): string }>, { originalSorting: true });
+            const levels = this.evaluateReferences(cubeName, this.getResolvedMember('hierarchies', cubeName, hierarchyName).levels as () => Array<ToString>, { originalSorting: true });
 
             levels.forEach((level) => autoIncludeMembers.add(level));
           }
@@ -373,7 +375,7 @@ export class CubeSymbols {
   protected membersFromCubes(parentCube: CubeDefinition, cubes: any[], type: string, errorReporter: ErrorReporter, splitViews: SplitViews, memberSets: any) {
     return R.unnest(cubes.map(cubeInclude => {
       // TODO recheck `cubeInclude.joinPath` typing
-      const fullPath = this.evaluateReferences(null, cubeInclude.joinPath as () => { toString(): string }, { collectJoinHints: true });
+      const fullPath = this.evaluateReferences(null, cubeInclude.joinPath as () => ToString, { collectJoinHints: true });
       const split = fullPath.split('.');
       const cubeReference = split[split.length - 1];
       const cubeName = cubeInclude.alias || cubeReference;
@@ -456,7 +458,7 @@ export class CubeSymbols {
     return includes.filter(include => !excludesMap.has(include.member));
   }
 
-  protected membersFromIncludeExclude(referencesFn: (...args: Array<unknown>) => Array<{ toString(): string }>, cubeName: string, type: string) {
+  protected membersFromIncludeExclude(referencesFn: (...args: Array<unknown>) => Array<ToString>, cubeName: string, type: string) {
     const references = this.evaluateReferences(cubeName, referencesFn);
     return R.unnest(references.map((ref: string) => {
       const path = ref.split('.');
@@ -553,11 +555,12 @@ export class CubeSymbols {
     return res;
   }
 
-  protected evaluateReferences<T extends { toString(): string } | Array<{ toString(): string }>>(
+  protected evaluateReferences<T extends ToString | Array<ToString>>(
     cube: string | null,
     referencesFn: (...args: Array<unknown>) => T,
-    options: { collectJoinHints?: boolean, originalSorting?: boolean } = {}):
-  T extends Array<{ toString(): string }> ? Array<string> : T extends { toString(): string } ? string : string | Array<string> {
+    options: { collectJoinHints?: boolean, originalSorting?: boolean } = {}
+  ):
+  T extends Array<ToString> ? Array<string> : T extends ToString ? string : string | Array<string> {
     const cubeEvaluator = this;
 
     const fullPath = (joinHints, path) => {