feat: Rename refreshRangeStart/End to buildRangeStart/End

Author: ovr

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

@@ -17,7 +17,7 @@ export class CubeEvaluator extends CubeSymbols {
     super.compile(cubes, errorReporter);
     const validCubes = this.cubeList.filter(cube => this.cubeValidator.isCubeValid(cube));
 
-    Object.values(validCubes).map(this.prepareCube);
+    Object.values(validCubes).map((cube) => this.prepareCube(cube, errorReporter));
 
     this.evaluatedCubes = R.fromPairs(validCubes.map(v => [v.name, v]));
     this.byFileName = R.groupBy(v => v.fileName, validCubes);
@@ -30,7 +30,7 @@ export class CubeEvaluator extends CubeSymbols {
     }));
   }
 
-  prepareCube(cube) {
+  prepareCube(cube, errorReporter) {
     if (cube.preAggregations) {
       // eslint-disable-next-line no-restricted-syntax
       for (const preAggregation of Object.values(cube.preAggregations)) {
@@ -58,6 +58,28 @@ export class CubeEvaluator extends CubeSymbols {
           preAggregation.rollupReferences = preAggregation.rollups;
           delete preAggregation.rollups;
         }
+
+        if (preAggregation.buildRangeStart) {
+          if (preAggregation.refreshRangeStart) {
+            errorReporter.warning({
+              message: 'You specified both buildRangeStart and refreshRangeStart, buildRangeStart will be used.'
+            });
+          }
+
+          preAggregation.refreshRangeStart = preAggregation.buildRangeStart;
+          delete preAggregation.buildRangeStart;
+        }
+
+        if (preAggregation.buildRangeEnd) {
+          if (preAggregation.refreshRangeEnd) {
+            errorReporter.warning({
+              message: 'You specified both buildRangeEnd and refreshRangeEnd, buildRangeEnd will be used.'
+            });
+          }
+
+          preAggregation.refreshRangeEnd = preAggregation.buildRangeEnd;
+          delete preAggregation.buildRangeEnd;
+        }
       }
     }
   }

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

@@ -82,12 +82,6 @@ const BasePreAggregationWithoutPartitionGranularity = {
   useOriginalSqlPreAggregations: Joi.boolean(),
   external: Joi.boolean(),
   scheduledRefresh: Joi.boolean(),
-  refreshRangeStart: {
-    sql: Joi.func().required()
-  },
-  refreshRangeEnd: {
-    sql: Joi.func().required()
-  },
   indexes: Joi.object().pattern(identifierRegex, Joi.alternatives().try(
     Joi.object().keys({
       sql: Joi.func().required()
@@ -96,6 +90,20 @@ const BasePreAggregationWithoutPartitionGranularity = {
       columns: Joi.func().required()
     })
   )),
+  // refreshRange was deprecated
+  refreshRangeStart: {
+    sql: Joi.func().required()
+  },
+  refreshRangeEnd: {
+    sql: Joi.func().required()
+  },
+  // new api
+  buildRangeStart: {
+    sql: Joi.func().required()
+  },
+  buildRangeEnd: {
+    sql: Joi.func().required()
+  },
 };
 
 const BasePreAggregation = {

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

@@ -1,8 +1,7 @@
 import { prepareCompiler } from './PrepareCompiler';
 
-describe('Schema Testing', () => {
-  const schemaCompile = async () => {
-    const { compiler, cubeEvaluator } = prepareCompiler(` 
+export function makeCubeSchema({ preAggregations }) {
+  return ` 
       cube('CubeA', {
         sql: \`select * from test\`,
    
@@ -35,29 +34,58 @@ describe('Schema Testing', () => {
         },
 
         preAggregations: {
-            main: {
+          ${preAggregations}
+        },
+      }) 
+    `;
+}
+
+describe('Schema Testing', () => {
+  const schemaCompile = async () => {
+    const { compiler, cubeEvaluator } = prepareCompiler(
+      makeCubeSchema({
+        preAggregations: `
+          main: {
                 type: 'originalSql',
                 timeDimension: createdAt,
                 partitionGranularity: \`month\`,
+                refreshRangeStart: {
+                  sql: 'SELECT NOW()',
+                },
+                refreshRangeEnd: {
+                  sql: 'SELECT NOW()',
+                }
             },
             // Pre-aggregation without type, rollup is used by default
             countCreatedAt: {
                 measureReferences: [count],
                 timeDimensionReference: createdAt,
                 granularity: \`day\`,
-                partitionGranularity: \`month\`
+                partitionGranularity: \`month\`,
+                buildRangeStart: {
+                  sql: 'SELECT NOW()',
+                },
+                buildRangeEnd: {
+                  sql: 'SELECT NOW()',
+                }
             },
             countCreatedAtWithoutReferences: {
                 dimensions: [type],
                 measures: [count],
                 timeDimension: [createdAt],
                 segments: [sfUsers],
                 granularity: \`day\`,
-                partitionGranularity: \`month\`
+                partitionGranularity: \`month\`,
+                buildRangeStart: {
+                  sql: 'SELECT NOW()',
+                },
+                buildRangeEnd: {
+                  sql: 'SELECT NOW()',
+                }
             }
-        },
-      }) 
-    `);
+        `
+      })
+    );
     await compiler.compile();
 
     return { compiler, cubeEvaluator };
@@ -73,6 +101,12 @@ describe('Schema Testing', () => {
         timeDimensionReference: expect.any(Function),
         partitionGranularity: 'month',
         type: 'originalSql',
+        refreshRangeStart: {
+          sql: expect.any(Function),
+        },
+        refreshRangeEnd: {
+          sql: expect.any(Function),
+        },
       },
       countCreatedAt: {
         external: false,
@@ -82,6 +116,12 @@ describe('Schema Testing', () => {
         timeDimensionReference: expect.any(Function),
         partitionGranularity: 'month',
         type: 'rollup',
+        refreshRangeStart: {
+          sql: expect.any(Function),
+        },
+        refreshRangeEnd: {
+          sql: expect.any(Function),
+        },
       },
       countCreatedAtWithoutReferences: {
         // because preview
@@ -94,6 +134,12 @@ describe('Schema Testing', () => {
         dimensionReferences: expect.any(Function),
         partitionGranularity: 'month',
         type: 'rollup',
+        refreshRangeStart: {
+          sql: expect.any(Function),
+        },
+        refreshRangeEnd: {
+          sql: expect.any(Function),
+        },
       }
     });
   });
@@ -114,6 +160,12 @@ describe('Schema Testing', () => {
         timeDimensionReference: expect.any(Function),
         partitionGranularity: 'month',
         type: 'originalSql',
+        refreshRangeStart: {
+          sql: expect.any(Function),
+        },
+        refreshRangeEnd: {
+          sql: expect.any(Function),
+        },
       },
       countCreatedAt: {
         // because preview
@@ -124,6 +176,12 @@ describe('Schema Testing', () => {
         timeDimensionReference: expect.any(Function),
         partitionGranularity: 'month',
         type: 'rollup',
+        refreshRangeStart: {
+          sql: expect.any(Function),
+        },
+        refreshRangeEnd: {
+          sql: expect.any(Function),
+        },
       },
       countCreatedAtWithoutReferences: {
         // because preview
@@ -136,7 +194,58 @@ describe('Schema Testing', () => {
         timeDimensionReference: expect.any(Function),
         partitionGranularity: 'month',
         type: 'rollup',
+        refreshRangeStart: {
+          sql: expect.any(Function),
+        },
+        refreshRangeEnd: {
+          sql: expect.any(Function),
+        },
       }
     });
   });
+
+  it('invalid schema', async () => {
+    const logger = jest.fn();
+
+    const { compiler } = prepareCompiler(
+      makeCubeSchema({
+        preAggregations: `
+            main: {
+                type: 'originalSql',
+                timeDimension: createdAt,
+                partitionGranularity: \`month\`,
+                refreshRangeStart: {
+                  sql: 'SELECT NOW()',
+                },
+                buildRangeStart: {
+                  sql: 'SELECT NOW()',
+                },
+                refreshRangeEnd: {
+                  sql: 'SELECT NOW()',
+                },
+                buildRangeEnd: {
+                  sql: 'SELECT NOW()',
+                }
+            },
+          `
+      }),
+      {
+        omitErrors: true,
+        errorReport: {
+          logger,
+        }
+      }
+    );
+
+    await compiler.compile();
+    compiler.throwIfAnyErrors();
+
+    expect(logger.mock.calls.length).toEqual(2);
+    expect(logger.mock.calls[0]).toEqual([
+      'You specified both buildRangeStart and refreshRangeStart, buildRangeStart will be used.'
+    ]);
+    expect(logger.mock.calls[1]).toEqual([
+      'You specified both buildRangeEnd and refreshRangeEnd, buildRangeEnd will be used.'
+    ]);
+  });
 });