feat(schema-compiler): Introduce public field (alias for shown) (#6361)

Author: ovr

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

@@ -15,17 +15,26 @@ export class CubeToMetaTransformer {
   }
 
   compile(cubes, errorReporter) {
-    // eslint-disable-next-line no-multi-assign
-    this.cubes = this.queries = this.cubeSymbols.cubeList
+    this.cubes = this.cubeSymbols.cubeList
       .filter(this.cubeValidator.isCubeValid.bind(this.cubeValidator))
       .map((v) => this.transform(v, errorReporter.inContext(`${v.name} cube`)))
       .filter(Boolean);
+
+    /**
+     * @deprecated
+     * @protected
+     */
+    this.queries = this.cubes;
   }
 
+  /**
+   * @protected
+   */
   transform(cube) {
     const cubeTitle = cube.title || this.titleize(cube.name);
-    
+
     return {
+      isVisible: this.isVisible(cube, true),
       config: {
         name: cube.name,
         title: cubeTitle,
@@ -87,13 +96,24 @@ export class CubeToMetaTransformer {
     )(this.queries);
   }
 
+  /**
+   * @protected
+   */
   isVisible(symbol, defaultValue) {
+    if (symbol.public != null) {
+      return symbol.public;
+    }
+
+    // TODO: Deprecated, should be removed in the future
     if (symbol.visible != null) {
       return symbol.visible;
     }
+
+    // TODO: Deprecated, should be removed in the futur
     if (symbol.shown != null) {
       return symbol.shown;
     }
+
     return defaultValue;
   }
 

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

@@ -15,6 +15,7 @@ export const nonStringFields = new Set([
   'unionWithSourceData',
   'rewriteQueries',
   'shown',
+  'public',
   'subQuery',
   'propagateFiltersToSubQuery',
   'incremental',
@@ -74,6 +75,7 @@ const BaseDimensionWithoutSubQuery = {
   valuesAsSegments: Joi.boolean().strict(),
   primaryKey: Joi.boolean().strict(),
   shown: Joi.boolean().strict(),
+  public: Joi.boolean().strict(),
   title: Joi.string(),
   description: Joi.string(),
   suggestFilterValues: Joi.boolean().strict(),
@@ -96,8 +98,11 @@ const BaseDimension = Object.assign({
 const BaseMeasure = {
   aliases: Joi.array().items(Joi.string()),
   format: Joi.any().valid('percent', 'currency', 'number'),
-  shown: Joi.boolean().strict(),
+  public: Joi.boolean().strict(),
+  // TODO: Deprecate and remove, please use public
   visible: Joi.boolean().strict(),
+  // TODO: Deprecate and remove, please use public
+  shown: Joi.boolean().strict(),
   cumulative: Joi.boolean().strict(),
   filters: Joi.array().items(
     Joi.object().keys({
@@ -462,6 +467,7 @@ const baseSchema = {
   description: Joi.string(),
   rewriteQueries: Joi.boolean().strict(),
   shown: Joi.boolean().strict(),
+  public: Joi.boolean().strict(),
   joins: Joi.object().pattern(identifierRegex, Joi.object().keys({
     sql: Joi.func().required(),
     relationship: Joi.any().valid('hasMany', 'belongsTo', 'hasOne').required()
@@ -509,8 +515,6 @@ const baseSchema = {
     meta: Joi.any()
   })),
   preAggregations: PreAggregationsAlternatives,
-  includes: Joi.func(),
-  excludes: Joi.func(),
 };
 
 const cubeSchema = inherit(baseSchema, {
@@ -522,6 +526,8 @@ const cubeSchema = inherit(baseSchema, {
 
 const viewSchema = inherit(baseSchema, {
   isView: Joi.boolean().strict(),
+  includes: Joi.func(),
+  excludes: Joi.func(),
 });
 
 function formatErrorMessageFromDetails(explain, d) {

packages/cubejs-schema-compiler/test/unit/PrepareCompiler.js

@@ -3,7 +3,7 @@ import { prepareCompiler as originalPrepareCompiler } from '../../src/compiler/P
 export const prepareCompiler = (content, options) => originalPrepareCompiler({
   localPath: () => __dirname,
   dataSchemaFiles: () => Promise.resolve([
-    { fileName: 'main.js', content }
+    { fileName: 'main.js', content: Array.isArray(content) ? content.join('\r\n') : content }
   ])
 }, { adapter: 'postgres', ...options });
 

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

@@ -15,6 +15,51 @@ describe('Cube Validation', () => {
     console.log('CubePropContextTranspiler.transpiledFieldsPatterns =', transpiledFieldsPatterns);
   });
 
+  it('cube all ways - correct', async () => {
+    const cubeValidator = new CubeValidator(new CubeSymbols());
+    const cube = {
+      name: 'name',
+      sql: () => 'SELECT * FROM public.Users',
+      public: true,
+      measures: {
+        min: {
+          public: true,
+          sql: () => 'amount',
+          type: 'min'
+        },
+        max: {
+          // old way
+          shown: true,
+          sql: () => 'amount',
+          type: 'max'
+        },
+      },
+      dimensions: {
+        createdAt: {
+          public: true,
+          sql: () => 'created_at',
+          type: 'time'
+        },
+        pkey: {
+          // old way
+          shown: true,
+          sql: () => 'id',
+          type: 'number',
+          primaryKey: true
+        },
+      },
+      fileName: 'fileName',
+    };
+
+    const validationResult = cubeValidator.validate(cube, {
+      error: (message, e) => {
+        console.log(message);
+      }
+    });
+
+    expect(validationResult.error).toBeFalsy();
+  });
+
   it('cube defined with sql - correct', async () => {
     const cubeValidator = new CubeValidator(new CubeSymbols());
     const cube = {

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

@@ -1,49 +1,11 @@
 import { prepareCompiler } from './PrepareCompiler';
-
-export function makeCubeSchema({ preAggregations }) {
-  return ` 
-      cube('CubeA', {
-        sql: \`select * from test\`,
-   
-        measures: {
-          count: {
-            type: 'count'
-          }
-        },
-  
-        dimensions: {
-          id: {
-            type: 'number',
-            sql: 'id',
-            primaryKey: true
-          },
-          type: {
-            type: 'string',
-            sql: 'type',
-          },
-          createdAt: {
-            type: 'time',
-            sql: 'created_at'
-          },
-        },
-        
-        segments: {
-          sfUsers: {
-            sql: \`\${CUBE}.location = 'San Francisco'\`
-          }
-        },
-
-        preAggregations: {
-          ${preAggregations}
-        },
-      }) 
-    `;
-}
+import { createCubeSchema } from './utils';
 
 describe('Schema Testing', () => {
   const schemaCompile = async () => {
     const { compiler, cubeEvaluator } = prepareCompiler(
-      makeCubeSchema({
+      createCubeSchema({
+        name: 'CubeA',
         preAggregations: `
           main: {
                 type: 'originalSql',
@@ -208,7 +170,8 @@ describe('Schema Testing', () => {
     const logger = jest.fn();
 
     const { compiler } = prepareCompiler(
-      makeCubeSchema({
+      createCubeSchema({
+        name: 'CubeA',
         preAggregations: `
             main: {
                 type: 'originalSql',
@@ -248,4 +211,41 @@ describe('Schema Testing', () => {
       'You specified both buildRangeEnd and refreshRangeEnd, buildRangeEnd will be used.'
     ]);
   });
+
+  it('visibility modifier', async () => {
+    const { compiler, metaTransformer } = prepareCompiler([
+      createCubeSchema({
+        name: 'CubeA',
+        publicly: false
+      }),
+      createCubeSchema({
+        name: 'CubeB',
+        publicly: true
+      }),
+      createCubeSchema({
+        name: 'CubeC',
+        shown: false
+      })
+    ]);
+    await compiler.compile();
+
+    expect(metaTransformer.cubes[0]).toMatchObject({
+      isVisible: false,
+      config: {
+        name: 'CubeA',
+      }
+    });
+    expect(metaTransformer.cubes[1]).toMatchObject({
+      isVisible: true,
+      config: {
+        name: 'CubeB',
+      }
+    });
+    expect(metaTransformer.cubes[2]).toMatchObject({
+      isVisible: false,
+      config: {
+        name: 'CubeC',
+      }
+    });
+  });
 });

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

@@ -1,17 +1,21 @@
 interface CreateCubeSchemaOptions {
   name: string,
+  publicly?: boolean,
+  shown?: boolean,
   sqlTable?: string,
   refreshKey?: string,
   preAggregations?: string,
 }
 
-export function createCubeSchema({ name, refreshKey = '', preAggregations = '', sqlTable }: CreateCubeSchemaOptions): string {
+export function createCubeSchema({ name, refreshKey = '', preAggregations = '', sqlTable, publicly, shown }: CreateCubeSchemaOptions): string {
   return ` 
     cube('${name}', {
         ${sqlTable ? `sqlTable: \`${sqlTable}\`` : 'sql: `select * from cards`'},
 
+        ${publicly !== undefined ? `public: ${publicly},` : ''}
+        ${shown !== undefined ? `shown: ${shown},` : ''}
         ${refreshKey}
-   
+
         measures: {
           count: {
             type: 'count'
@@ -29,19 +33,33 @@ export function createCubeSchema({ name, refreshKey = '', preAggregations = '',
             type: \`min\`
           }
         },
-  
+
         dimensions: {
           id: {
             type: 'number',
             sql: 'id',
             primaryKey: true
           },
+          type: {
+            type: 'string',
+            sql: 'type'
+          },
           createdAt: {
             type: 'time',
             sql: 'created_at'
           },
+          location: {
+            type: 'string',
+            sql: 'location'
+          }
         },
-        
+
+        segments: {
+          sfUsers: {
+            sql: \`\${CUBE}.location = 'San Francisco'\`
+          }
+        },
+
         preAggregations: {
             ${preAggregations}
         }