fix(schema-compiler): hierarchies on extended cubes (#9100)

Author: vasilev-alex

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

@@ -213,10 +213,10 @@ export class CubeEvaluator extends CubeSymbols {
     return [];
   }
 
-  private prepareHierarchies(cube: any, errorReporter: ErrorReporter) {
+  private prepareHierarchies(cube: any, errorReporter: ErrorReporter): void {
     const uniqueHierarchyNames = new Set();
     if (Array.isArray(cube.hierarchies)) {
-      cube.hierarchies = cube.hierarchies.map(hierarchy => {
+      cube.evaluatedHierarchies = cube.hierarchies.map(hierarchy => {
         if (uniqueHierarchyNames.has(hierarchy.name)) {
           errorReporter.error(`Duplicate hierarchy name '${hierarchy.name}' in cube '${cube.name}'`);
         }
@@ -239,7 +239,8 @@ export class CubeEvaluator extends CubeSymbols {
       const includedHierarchyNames = cube.includedMembers.filter(it => it.type === 'hierarchies').map(it => it.memberPath.split('.')[1]);
 
       for (const cubeName of includedCubeNames) {
-        const { hierarchies } = this.evaluatedCubes[cubeName] || {};
+        // As views come after cubes in the list, we can safely assume that cube is already evaluated
+        const { evaluatedHierarchies: hierarchies } = this.evaluatedCubes[cubeName] || {};
 
         if (Array.isArray(hierarchies) && hierarchies.length) {
           const filteredHierarchies = hierarchies
@@ -264,11 +265,11 @@ export class CubeEvaluator extends CubeSymbols {
             })
             .filter(it => it.levels.length);
 
-          cube.hierarchies = [...(cube.hierarchies || []), ...filteredHierarchies];
+          cube.evaluatedHierarchies = [...(cube.evaluatedHierarchies || []), ...filteredHierarchies];
         }
       }
 
-      cube.hierarchies = (cube.hierarchies || []).map((hierarchy) => ({
+      cube.evaluatedHierarchies = (cube.evaluatedHierarchies || []).map((hierarchy) => ({
         ...hierarchy,
         levels: hierarchy.levels.map((level) => {
           const member = cube.includedMembers.find(m => m.memberPath === level);
@@ -281,8 +282,6 @@ export class CubeEvaluator extends CubeSymbols {
         }).filter(Boolean)
       }));
     }
-
-    return [];
   }
 
   private evaluateMultiStageReferences(cubeName: string, obj: { [key: string]: MeasureDefinition }) {

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

@@ -65,16 +65,26 @@ export class CubeSymbols {
     let measures;
     let dimensions;
     let segments;
+    let hierarchies;
 
     const cubeObject = Object.assign({
-      allDefinitions(type) {
+      allDefinitions(type, asArray = false) {
         if (cubeDefinition.extends) {
+          if (asArray) {
+            return [
+              ...super.allDefinitions(type, asArray),
+              ...(cubeDefinition[type] || [])
+            ];
+          }
+
           return {
-            ...super.allDefinitions(type),
+            ...super.allDefinitions(type, asArray),
             ...cubeDefinition[type]
           };
-        } else {
+        } else if (asArray) {
+          return [...(cubeDefinition[type] || [])];
           // TODO We probably do not need this shallow copy
+        } else {
           return { ...cubeDefinition[type] };
         }
       },
@@ -107,7 +117,18 @@ export class CubeSymbols {
       set segments(v) {
         // Dont allow to modify
       },
-    }, cubeDefinition);
+
+      get hierarchies() {
+        if (!hierarchies) {
+          hierarchies = this.allDefinitions('hierarchies', true);
+        }
+        return hierarchies;
+      },
+      set hierarchies(v) {
+        //
+      }
+    },
+    cubeDefinition);
 
     if (cubeDefinition.extends) {
       const superCube = this.resolveSymbolsCall(cubeDefinition.extends, (name) => this.cubeReferenceProxy(name));

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

@@ -106,7 +106,7 @@ export class CubeToMetaTransformer {
           })),
           R.toPairs
         )(cube.segments || {}),
-        hierarchies: (cube.hierarchies || []).map((it) => ({
+        hierarchies: (cube.evaluatedHierarchies || []).map((it) => ({
           ...it,
           public: it.public ?? true,
           name: `${cube.name}.${it.name}`,

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

@@ -794,6 +794,7 @@ const viewSchema = inherit(baseSchema, {
     })
   ),
   accessPolicy: Joi.array().items(RolePolicySchema.required()),
+  hierarchies: Joi.any()
 });
 
 function formatErrorMessageFromDetails(explain, d) {

packages/cubejs-schema-compiler/test/unit/fixtures/hierarchies-extended-cubes.yml

@@ -0,0 +1,54 @@
+cubes:
+  - name: base_orders
+    sql_table: orders
+    measures:
+      - name: count
+        sql: id
+        type: count
+    dimensions:
+      - name: id
+        sql: id
+        type: number
+        primary_key: true
+
+      - name: number
+        sql: number
+        type: number
+
+      - name: status
+        sql: status
+        type: string
+
+      - name: city
+        sql: city
+        type: string
+    hierarchies:
+      - name: base_orders_hierarchy
+        title: Hello Hierarchy
+        levels:
+          - "{CUBE}.status"
+          - number
+  #
+  - name: orders
+    extends: base_orders
+    hierarchies:
+      - name: orders_hierarchy
+        levels:
+          - state
+          - city
+    dimensions:
+      - name: state
+        sql: state
+        type: string
+      - name: city
+        sql: city
+        type: string
+
+views:
+  - name: test_view
+    cubes:
+      - join_path: orders
+        includes: "*"
+
+
+

packages/cubejs-schema-compiler/test/unit/hierarchies.test.ts

@@ -102,4 +102,32 @@ describe('Cube hierarchies', () => {
 
     await expect(compiler.compile()).rejects.toThrow('Duplicate hierarchy name \'test_hierarchy\' in cube \'orders\'');
   });
+
+  it(('hierarchies on extended cubes'), async () => {
+    const modelContent = fs.readFileSync(
+      path.join(process.cwd(), '/test/unit/fixtures/hierarchies-extended-cubes.yml'),
+      'utf8'
+    );
+    const { compiler, metaTransformer } = prepareYamlCompiler(modelContent);
+
+    await compiler.compile();
+
+    const testView = metaTransformer.cubes.find(
+      (it) => it.config.name === 'test_view'
+    );
+
+    expect(testView?.config.hierarchies).toEqual([
+      {
+        name: 'test_view.base_orders_hierarchy',
+        title: 'Hello Hierarchy',
+        levels: ['test_view.status', 'test_view.number'],
+        public: true
+      },
+      {
+        name: 'test_view.orders_hierarchy',
+        levels: ['test_view.state', 'test_view.city'],
+        public: true
+      }
+    ]);
+  });
 });