@cubejs-backend/schema-compiler 0.34.29 → 0.34.31

package/dist/src/compiler/CubeValidator.js

@@ -1,8 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CubeValidator = exports.functionFieldsPatterns = exports.nonStringFields = void 0;
-const Joi = require('joi');
-const cronParser = require('cron-parser');
+const joi_1 = __importDefault(require("joi"));
+const cron_parser_1 = __importDefault(require("cron-parser"));
 /* *****************************
  * ATTENTION:
  * In case of adding/removing/changing any Joi.func() field that needs to be transpiled,
@@ -26,99 +29,107 @@ exports.nonStringFields = new Set([
     'prefix'
 ]);
 const identifierRegex = /^[_a-zA-Z][_a-zA-Z0-9]*$/;
-const identifier = Joi.string().regex(identifierRegex, 'identifier');
-const regexTimeInterval = Joi.string().custom((value, helper) => {
+const identifier = joi_1.default.string().regex(identifierRegex, 'identifier');
+function formatStatePath(state) {
+    if (state.path) {
+        // TODO: Remove cast after upgrade of Joi. It show it as string, while it's array
+        const path = state.path;
+        return path.join('.');
+    }
+    return '<unknown path>';
+}
+const regexTimeInterval = joi_1.default.string().custom((value, helper) => {
     if (value.match(/^(-?\d+) (minute|hour|day|week|month|quarter|year)$/)) {
         return value;
     }
     else {
-        return helper.message({ custom: `(${helper.state.path.join('.')} = ${value}) does not match regexp: /^(-?\\d+) (minute|hour|day|week|month|quarter|year)$/` });
+        return helper.message({ custom: `(${formatStatePath(helper.state)} = ${value}) does not match regexp: /^(-?\\d+) (minute|hour|day|week|month|quarter|year)$/` });
     }
 });
-const timeInterval = Joi.alternatives([
+const timeInterval = joi_1.default.alternatives([
     regexTimeInterval,
-    Joi.any().valid('unbounded')
+    joi_1.default.any().valid('unbounded')
 ]);
-const everyInterval = Joi.string().custom((value, helper) => {
+const everyInterval = joi_1.default.string().custom((value, helper) => {
     if (value.match(/^(\d+) (second|minute|hour|day|week)s?$/)) {
         return value;
     }
     else {
-        return helper.message({ custom: `(${helper.state.path.join('.')} = ${value}) does not match regexp: /^(\\d+) (second|minute|hour|day|week)s?$/` });
+        return helper.message({ custom: `(${formatStatePath(helper.state)} = ${value}) does not match regexp: /^(\\d+) (second|minute|hour|day|week)s?$/` });
     }
 });
-const everyCronInterval = Joi.string().custom((value, helper) => {
+const everyCronInterval = joi_1.default.string().custom((value, helper) => {
     try {
-        cronParser.parseExpression(value);
+        cron_parser_1.default.parseExpression(value);
         return value;
     }
     catch (e) {
-        return helper.message({ custom: `(${helper.state.path.join('.')} = ${value}) CronParser: ${e.toString()}` });
+        return helper.message({ custom: `(${formatStatePath(helper.state)} = ${value}) CronParser: ${e.toString()}` });
     }
 });
-const everyCronTimeZone = Joi.string().custom((value, helper) => {
+const everyCronTimeZone = joi_1.default.string().custom((value, helper) => {
     try {
-        cronParser.parseExpression('0 * * * *', { currentDate: '2020-01-01 00:00:01', tz: value });
+        cron_parser_1.default.parseExpression('0 * * * *', { currentDate: '2020-01-01 00:00:01', tz: value });
         return value;
     }
     catch (e) {
-        return helper.message({ custom: `(${helper.state.path.join('.')} = ${value}) unknown timezone. Take a look here https://cube.dev/docs/schema/reference/cube#supported-timezones to get available time zones` });
+        return helper.message({ custom: `(${formatStatePath(helper.state)} = ${value}) unknown timezone. Take a look here https://cube.dev/docs/schema/reference/cube#supported-timezones to get available time zones` });
     }
 });
 const BaseDimensionWithoutSubQuery = {
-    aliases: Joi.array().items(Joi.string()),
-    type: Joi.any().valid('string', 'number', 'boolean', 'time', 'geo').required(),
-    fieldType: Joi.any().valid('string'),
-    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(),
-    enableSuggestions: Joi.boolean().strict(),
-    format: Joi.alternatives([
-        Joi.string().valid('imageUrl', 'link', 'currency', 'percent', 'number', 'id'),
-        Joi.object().keys({
-            type: Joi.string().valid('link'),
-            label: Joi.string().required()
+    aliases: joi_1.default.array().items(joi_1.default.string()),
+    type: joi_1.default.any().valid('string', 'number', 'boolean', 'time', 'geo').required(),
+    fieldType: joi_1.default.any().valid('string'),
+    valuesAsSegments: joi_1.default.boolean().strict(),
+    primaryKey: joi_1.default.boolean().strict(),
+    shown: joi_1.default.boolean().strict(),
+    public: joi_1.default.boolean().strict(),
+    title: joi_1.default.string(),
+    description: joi_1.default.string(),
+    suggestFilterValues: joi_1.default.boolean().strict(),
+    enableSuggestions: joi_1.default.boolean().strict(),
+    format: joi_1.default.alternatives([
+        joi_1.default.string().valid('imageUrl', 'link', 'currency', 'percent', 'number', 'id'),
+        joi_1.default.object().keys({
+            type: joi_1.default.string().valid('link'),
+            label: joi_1.default.string().required()
         })
     ]),
-    meta: Joi.any()
+    meta: joi_1.default.any()
 };
 const BaseDimension = Object.assign({
-    subQuery: Joi.boolean().strict(),
-    propagateFiltersToSubQuery: Joi.boolean().strict()
+    subQuery: joi_1.default.boolean().strict(),
+    propagateFiltersToSubQuery: joi_1.default.boolean().strict()
 }, BaseDimensionWithoutSubQuery);
 const BaseMeasure = {
-    aliases: Joi.array().items(Joi.string()),
-    format: Joi.any().valid('percent', 'currency', 'number'),
-    public: Joi.boolean().strict(),
+    aliases: joi_1.default.array().items(joi_1.default.string()),
+    format: joi_1.default.any().valid('percent', 'currency', 'number'),
+    public: joi_1.default.boolean().strict(),
     // TODO: Deprecate and remove, please use public
-    visible: Joi.boolean().strict(),
+    visible: joi_1.default.boolean().strict(),
     // TODO: Deprecate and remove, please use public
-    shown: Joi.boolean().strict(),
-    cumulative: Joi.boolean().strict(),
-    filters: Joi.array().items(Joi.object().keys({
-        sql: Joi.func().required()
+    shown: joi_1.default.boolean().strict(),
+    cumulative: joi_1.default.boolean().strict(),
+    filters: joi_1.default.array().items(joi_1.default.object().keys({
+        sql: joi_1.default.func().required()
     })),
-    title: Joi.string(),
-    description: Joi.string(),
-    rollingWindow: Joi.object().keys({
+    title: joi_1.default.string(),
+    description: joi_1.default.string(),
+    rollingWindow: joi_1.default.object().keys({
         trailing: timeInterval,
         leading: timeInterval,
-        offset: Joi.any().valid('start', 'end')
+        offset: joi_1.default.any().valid('start', 'end')
     }),
-    drillMemberReferences: Joi.func(),
-    drillMembers: Joi.func(),
-    drillFilters: Joi.array().items(Joi.object().keys({
-        sql: Joi.func().required()
+    drillMemberReferences: joi_1.default.func(),
+    drillMembers: joi_1.default.func(),
+    drillFilters: joi_1.default.array().items(joi_1.default.object().keys({
+        sql: joi_1.default.func().required()
     })),
-    meta: Joi.any()
+    meta: joi_1.default.any()
 };
 function condition(fun, then, otherwise) {
-    return Joi.alternatives().conditional(Joi.ref('.'), {
-        is: Joi.custom((value, helper) => (fun(value) ? value : helper.message({}))),
+    return joi_1.default.alternatives().conditional(joi_1.default.ref('.'), {
+        is: joi_1.default.custom((value, helper) => (fun(value) ? value : helper.message({}))),
         then,
         otherwise
     });
@@ -127,223 +138,223 @@ function defined(a) {
     return typeof a !== 'undefined';
 }
 function inherit(a, b) {
-    return Joi.object().keys(Object.assign({}, a, b));
+    return joi_1.default.object().keys(Object.assign({}, a, b));
 }
 function requireOneOf(...keys) {
-    return Joi.alternatives().try(...(keys.map((k) => Joi.object().keys({ [k]: Joi.exist().required() }))));
+    return joi_1.default.alternatives().try(...(keys.map((k) => joi_1.default.object().keys({ [k]: joi_1.default.exist().required() }))));
 }
-const PreAggregationRefreshKeySchema = condition((s) => defined(s.sql), Joi.object().keys({
-    sql: Joi.func().required(),
+const PreAggregationRefreshKeySchema = condition((s) => defined(s.sql), joi_1.default.object().keys({
+    sql: joi_1.default.func().required(),
     // We dont support timezone for this, because it's useless
     // We cannot support cron interval
     every: everyInterval,
-}), condition((s) => defined(s.every), Joi.object().keys({
-    every: Joi.alternatives().try(everyInterval, everyCronInterval),
+}), condition((s) => defined(s.every), joi_1.default.object().keys({
+    every: joi_1.default.alternatives().try(everyInterval, everyCronInterval),
     timezone: everyCronTimeZone,
-    incremental: Joi.boolean().strict(),
+    incremental: joi_1.default.boolean().strict(),
     updateWindow: everyInterval
 }), requireOneOf('sql', 'every')));
 const BasePreAggregationWithoutPartitionGranularity = {
     refreshKey: PreAggregationRefreshKeySchema,
-    sqlAlias: Joi.string().optional(),
-    useOriginalSqlPreAggregations: Joi.boolean().strict(),
-    external: Joi.boolean().strict(),
-    scheduledRefresh: Joi.boolean().strict(),
-    indexes: Joi.object().pattern(identifierRegex, Joi.alternatives().try(Joi.object().keys({
-        sql: Joi.func().required()
-    }), Joi.object().keys({
-        columns: Joi.func().required(),
-        type: Joi.any().valid('regular', 'aggregate'),
+    sqlAlias: joi_1.default.string().optional(),
+    useOriginalSqlPreAggregations: joi_1.default.boolean().strict(),
+    external: joi_1.default.boolean().strict(),
+    scheduledRefresh: joi_1.default.boolean().strict(),
+    indexes: joi_1.default.object().pattern(identifierRegex, joi_1.default.alternatives().try(joi_1.default.object().keys({
+        sql: joi_1.default.func().required()
+    }), joi_1.default.object().keys({
+        columns: joi_1.default.func().required(),
+        type: joi_1.default.any().valid('regular', 'aggregate'),
     }))),
     // refreshRange was deprecated
     refreshRangeStart: {
-        sql: Joi.func().required()
+        sql: joi_1.default.func().required()
     },
     refreshRangeEnd: {
-        sql: Joi.func().required()
+        sql: joi_1.default.func().required()
     },
     // new api
     buildRangeStart: {
-        sql: Joi.func().required()
+        sql: joi_1.default.func().required()
     },
     buildRangeEnd: {
-        sql: Joi.func().required()
+        sql: joi_1.default.func().required()
     },
-    readOnly: Joi.boolean().strict(),
-    streamOffset: Joi.any().valid('earliest', 'latest'),
+    readOnly: joi_1.default.boolean().strict(),
+    streamOffset: joi_1.default.any().valid('earliest', 'latest'),
 };
 const BasePreAggregation = {
     ...BasePreAggregationWithoutPartitionGranularity,
-    partitionGranularity: Joi.any().valid('hour', 'day', 'week', 'month', 'quarter', 'year'),
+    partitionGranularity: joi_1.default.any().valid('hour', 'day', 'week', 'month', 'quarter', 'year'),
 };
 const AutoRollupSchema = inherit(BasePreAggregation, {
-    type: Joi.any().valid('autoRollup').required(),
-    maxPreAggregations: Joi.number(),
+    type: joi_1.default.any().valid('autoRollup').required(),
+    maxPreAggregations: joi_1.default.number(),
 });
 const OriginalSqlSchema = condition((s) => defined(s.partitionGranularity) || defined(s.timeDimension) || defined(s.timeDimensionReference), condition((s) => defined(s.timeDimensionReference), inherit(BasePreAggregation, {
-    type: Joi.any().valid('originalSql').required(),
-    uniqueKeyColumns: Joi.array().items(Joi.string()),
+    type: joi_1.default.any().valid('originalSql').required(),
+    uniqueKeyColumns: joi_1.default.array().items(joi_1.default.string()),
     partitionGranularity: BasePreAggregation.partitionGranularity.required(),
-    timeDimensionReference: Joi.func().required(),
-    allowNonStrictDateRangeMatch: Joi.bool(),
+    timeDimensionReference: joi_1.default.func().required(),
+    allowNonStrictDateRangeMatch: joi_1.default.bool(),
 }), inherit(BasePreAggregation, {
-    type: Joi.any().valid('originalSql').required(),
-    uniqueKeyColumns: Joi.array().items(Joi.string()),
+    type: joi_1.default.any().valid('originalSql').required(),
+    uniqueKeyColumns: joi_1.default.array().items(joi_1.default.string()),
     partitionGranularity: BasePreAggregation.partitionGranularity.required(),
-    timeDimension: Joi.func().required(),
-    allowNonStrictDateRangeMatch: Joi.bool(),
+    timeDimension: joi_1.default.func().required(),
+    allowNonStrictDateRangeMatch: joi_1.default.bool(),
 })), inherit(BasePreAggregationWithoutPartitionGranularity, {
-    type: Joi.any().valid('originalSql').required(),
-    uniqueKeyColumns: Joi.array().items(Joi.string())
+    type: joi_1.default.any().valid('originalSql').required(),
+    uniqueKeyColumns: joi_1.default.array().items(joi_1.default.string())
 }));
-const GranularitySchema = Joi.string().valid('second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year').required();
+const GranularitySchema = joi_1.default.string().valid('second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year').required();
 const ReferencesFields = ['timeDimensionReference', 'rollupReferences', 'measureReferences', 'dimensionReferences', 'segmentReferences'];
 const NonReferencesFields = ['timeDimension', 'rollups', 'measures', 'dimensions', 'segments'];
 function hasAnyField(fields, s) {
     return !fields.every((f) => !defined(s[f]));
 }
 function errorOnMixing(schema) {
-    return condition((s) => hasAnyField(ReferencesFields, s) && hasAnyField(NonReferencesFields, s), Joi.any().forbidden().error(new Error(`[${ReferencesFields.join(', ')}] are deprecated, please, use [${NonReferencesFields.join(', ')}] instead`)), schema);
+    return condition((s) => hasAnyField(ReferencesFields, s) && hasAnyField(NonReferencesFields, s), joi_1.default.any().forbidden().error(new Error(`[${ReferencesFields.join(', ')}] are deprecated, please, use [${NonReferencesFields.join(', ')}] instead`)), schema);
 }
 const RollUpJoinSchema = condition((s) => defined(s.granularity) || defined(s.timeDimension) || defined(s.timeDimensionReference), condition((s) => defined(s.rollupReferences) || defined(s.timeDimensionReference), inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollupJoin').required(),
-    scheduledRefresh: Joi.boolean().valid(false),
+    type: joi_1.default.any().valid('rollupJoin').required(),
+    scheduledRefresh: joi_1.default.boolean().valid(false),
     granularity: GranularitySchema,
-    allowNonStrictDateRangeMatch: Joi.bool(),
-    timeDimensionReference: Joi.func().required(),
-    rollupReferences: Joi.func().required(),
-    measureReferences: Joi.func(),
-    dimensionReferences: Joi.func(),
-    segmentReferences: Joi.func(),
+    allowNonStrictDateRangeMatch: joi_1.default.bool(),
+    timeDimensionReference: joi_1.default.func().required(),
+    rollupReferences: joi_1.default.func().required(),
+    measureReferences: joi_1.default.func(),
+    dimensionReferences: joi_1.default.func(),
+    segmentReferences: joi_1.default.func(),
 }), 
 // RollupJoin without references
 inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollupJoin').required(),
-    scheduledRefresh: Joi.boolean().valid(false),
+    type: joi_1.default.any().valid('rollupJoin').required(),
+    scheduledRefresh: joi_1.default.boolean().valid(false),
     granularity: GranularitySchema,
-    timeDimension: Joi.func().required(),
-    allowNonStrictDateRangeMatch: Joi.bool(),
-    rollups: Joi.func().required(),
-    measures: Joi.func(),
-    dimensions: Joi.func(),
-    segments: Joi.func(),
+    timeDimension: joi_1.default.func().required(),
+    allowNonStrictDateRangeMatch: joi_1.default.bool(),
+    rollups: joi_1.default.func().required(),
+    measures: joi_1.default.func(),
+    dimensions: joi_1.default.func(),
+    segments: joi_1.default.func(),
 })), condition((s) => defined(s.rollupReferences), inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollupJoin').required(),
-    scheduledRefresh: Joi.boolean().valid(false),
-    rollupReferences: Joi.func().required(),
-    measureReferences: Joi.func(),
-    dimensionReferences: Joi.func(),
-    segmentReferences: Joi.func(),
+    type: joi_1.default.any().valid('rollupJoin').required(),
+    scheduledRefresh: joi_1.default.boolean().valid(false),
+    rollupReferences: joi_1.default.func().required(),
+    measureReferences: joi_1.default.func(),
+    dimensionReferences: joi_1.default.func(),
+    segmentReferences: joi_1.default.func(),
 }), 
 // RollupJoin without references
 condition((s) => defined(s.rollups), inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollupJoin').required(),
-    scheduledRefresh: Joi.boolean().valid(false),
-    rollups: Joi.func().required(),
-    measures: Joi.func(),
-    dimensions: Joi.func(),
-    segments: Joi.func(),
+    type: joi_1.default.any().valid('rollupJoin').required(),
+    scheduledRefresh: joi_1.default.boolean().valid(false),
+    rollups: joi_1.default.func().required(),
+    measures: joi_1.default.func(),
+    dimensions: joi_1.default.func(),
+    segments: joi_1.default.func(),
 }), requireOneOf('granularity', 'rollups', 'timeDimension'))));
 const RollupLambdaSchema = condition((s) => defined(s.granularity) || defined(s.timeDimension), {
-    type: Joi.any().valid('rollupLambda').required(),
+    type: joi_1.default.any().valid('rollupLambda').required(),
     granularity: GranularitySchema,
-    timeDimension: Joi.func().required(),
-    rollups: Joi.func().required(),
-    measures: Joi.func(),
-    dimensions: Joi.func(),
-    segments: Joi.func(),
-    unionWithSourceData: Joi.boolean().strict(),
+    timeDimension: joi_1.default.func().required(),
+    rollups: joi_1.default.func().required(),
+    measures: joi_1.default.func(),
+    dimensions: joi_1.default.func(),
+    segments: joi_1.default.func(),
+    unionWithSourceData: joi_1.default.boolean().strict(),
 }, {
-    type: Joi.any().valid('rollupLambda').required(),
-    rollups: Joi.func().required(),
-    measures: Joi.func(),
-    dimensions: Joi.func(),
-    segments: Joi.func(),
-    unionWithSourceData: Joi.boolean().strict(),
+    type: joi_1.default.any().valid('rollupLambda').required(),
+    rollups: joi_1.default.func().required(),
+    measures: joi_1.default.func(),
+    dimensions: joi_1.default.func(),
+    segments: joi_1.default.func(),
+    unionWithSourceData: joi_1.default.boolean().strict(),
 });
 const RollUpSchema = condition((s) => defined(s.granularity) || defined(s.timeDimension) || defined(s.timeDimensionReference), condition((s) => defined(s.timeDimensionReference), inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollup').required(),
-    timeDimensionReference: Joi.func().required(),
+    type: joi_1.default.any().valid('rollup').required(),
+    timeDimensionReference: joi_1.default.func().required(),
     granularity: GranularitySchema,
-    allowNonStrictDateRangeMatch: Joi.bool(),
-    measureReferences: Joi.func(),
-    dimensionReferences: Joi.func(),
-    segmentReferences: Joi.func(),
+    allowNonStrictDateRangeMatch: joi_1.default.bool(),
+    measureReferences: joi_1.default.func(),
+    dimensionReferences: joi_1.default.func(),
+    segmentReferences: joi_1.default.func(),
 }), 
 // Rollup without References postfix
 inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollup').required(),
-    timeDimension: Joi.func().required(),
-    allowNonStrictDateRangeMatch: Joi.bool(),
+    type: joi_1.default.any().valid('rollup').required(),
+    timeDimension: joi_1.default.func().required(),
+    allowNonStrictDateRangeMatch: joi_1.default.bool(),
     granularity: GranularitySchema,
-    measures: Joi.func(),
-    dimensions: Joi.func(),
-    segments: Joi.func(),
-})), Joi.alternatives().try(inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollup').required(),
-    measureReferences: Joi.func(),
-    dimensionReferences: Joi.func(),
-    segmentReferences: Joi.func()
+    measures: joi_1.default.func(),
+    dimensions: joi_1.default.func(),
+    segments: joi_1.default.func(),
+})), joi_1.default.alternatives().try(inherit(BasePreAggregation, {
+    type: joi_1.default.any().valid('rollup').required(),
+    measureReferences: joi_1.default.func(),
+    dimensionReferences: joi_1.default.func(),
+    segmentReferences: joi_1.default.func()
 }), 
 // Rollup without References postfix
 inherit(BasePreAggregation, {
-    type: Joi.any().valid('rollup').required(),
-    measures: Joi.func(),
-    dimensions: Joi.func(),
-    segments: Joi.func()
+    type: joi_1.default.any().valid('rollup').required(),
+    measures: joi_1.default.func(),
+    dimensions: joi_1.default.func(),
+    segments: joi_1.default.func()
 })));
-const PreAggregationsAlternatives = Joi.object().pattern(identifierRegex, errorOnMixing(Joi.alternatives().conditional(Joi.ref('.type'), [
+const PreAggregationsAlternatives = joi_1.default.object().pattern(identifierRegex, errorOnMixing(joi_1.default.alternatives().conditional(joi_1.default.ref('.type'), [
     { is: 'autoRollup', then: AutoRollupSchema },
     { is: 'originalSql', then: OriginalSqlSchema },
     { is: 'rollupJoin', then: RollUpJoinSchema },
     { is: 'rollupLambda', then: RollupLambdaSchema },
     { is: 'rollup',
         then: RollUpSchema,
-        otherwise: Joi.object().keys({
-            type: Joi.string().valid('autoRollup', 'originalSql', 'rollupJoin', 'rollup').required()
+        otherwise: joi_1.default.object().keys({
+            type: joi_1.default.string().valid('autoRollup', 'originalSql', 'rollupJoin', 'rollup').required()
         })
     }
 ])));
-const CubeRefreshKeySchema = condition((s) => defined(s.every), condition((s) => defined(s.sql), Joi.object().keys({
-    sql: Joi.func().required(),
+const CubeRefreshKeySchema = condition((s) => defined(s.every), condition((s) => defined(s.sql), joi_1.default.object().keys({
+    sql: joi_1.default.func().required(),
     // We dont support timezone for this, because it's useless
     // We cannot support cron interval
     every: everyInterval,
-}), Joi.object().keys({
-    every: Joi.alternatives().try(everyInterval, everyCronInterval).required(),
+}), joi_1.default.object().keys({
+    every: joi_1.default.alternatives().try(everyInterval, everyCronInterval).required(),
     timezone: everyCronTimeZone,
-})), condition((s) => defined(s.immutable), Joi.object().keys({
-    immutable: Joi.boolean().strict().required()
+})), condition((s) => defined(s.immutable), joi_1.default.object().keys({
+    immutable: joi_1.default.boolean().strict().required()
 }), requireOneOf('every', 'sql', 'immutable')));
-const measureType = Joi.string().valid('number', 'string', 'boolean', 'time', 'sum', 'avg', 'min', 'max', 'countDistinct', 'runningTotal', 'countDistinctApprox');
-const measureTypeWithCount = Joi.string().valid('count', 'number', 'string', 'boolean', 'time', 'sum', 'avg', 'min', 'max', 'countDistinct', 'runningTotal', 'countDistinctApprox');
-const MeasuresSchema = Joi.object().pattern(identifierRegex, Joi.alternatives().conditional(Joi.ref('.type'), [
+const measureType = joi_1.default.string().valid('number', 'string', 'boolean', 'time', 'sum', 'avg', 'min', 'max', 'countDistinct', 'runningTotal', 'countDistinctApprox');
+const measureTypeWithCount = joi_1.default.string().valid('count', 'number', 'string', 'boolean', 'time', 'sum', 'avg', 'min', 'max', 'countDistinct', 'runningTotal', 'countDistinctApprox');
+const MeasuresSchema = joi_1.default.object().pattern(identifierRegex, joi_1.default.alternatives().conditional(joi_1.default.ref('.type'), [
     {
         is: 'count',
         then: inherit(BaseMeasure, {
-            type: Joi.any().valid('count').required(),
-            sql: Joi.func(),
+            type: joi_1.default.any().valid('count').required(),
+            sql: joi_1.default.func(),
         })
     },
     {
         is: measureType,
         then: inherit(BaseMeasure, {
-            sql: Joi.func().required(),
+            sql: joi_1.default.func().required(),
             type: measureType.required()
         }),
-        otherwise: Joi.object().keys({
+        otherwise: joi_1.default.object().keys({
             type: measureTypeWithCount.required()
         })
     }
 ]));
-const SegmentsSchema = Joi.object().pattern(identifierRegex, Joi.object().keys({
-    aliases: Joi.array().items(Joi.string()),
-    sql: Joi.func().required(),
-    title: Joi.string(),
-    description: Joi.string(),
-    meta: Joi.any(),
-    shown: Joi.boolean().strict(),
-    public: Joi.boolean().strict(),
+const SegmentsSchema = joi_1.default.object().pattern(identifierRegex, joi_1.default.object().keys({
+    aliases: joi_1.default.array().items(joi_1.default.string()),
+    sql: joi_1.default.func().required(),
+    title: joi_1.default.string(),
+    description: joi_1.default.string(),
+    meta: joi_1.default.any(),
+    shown: joi_1.default.boolean().strict(),
+    public: joi_1.default.boolean().strict(),
 }));
 /* *****************************
  * ATTENTION:
@@ -354,80 +365,80 @@ const SegmentsSchema = Joi.object().pattern(identifierRegex, Joi.object().keys({
 const baseSchema = {
     name: identifier,
     refreshKey: CubeRefreshKeySchema,
-    fileName: Joi.string().required(),
-    extends: Joi.func(),
-    allDefinitions: Joi.func(),
-    title: Joi.string(),
-    sqlAlias: Joi.string(),
-    dataSource: Joi.string(),
-    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('belongsTo', 'belongs_to', 'many_to_one', 'manyToOne', 'hasMany', 'has_many', 'one_to_many', 'oneToMany', 'hasOne', 'has_one', 'one_to_one', 'oneToOne').required()
+    fileName: joi_1.default.string().required(),
+    extends: joi_1.default.func(),
+    allDefinitions: joi_1.default.func(),
+    title: joi_1.default.string(),
+    sqlAlias: joi_1.default.string(),
+    dataSource: joi_1.default.string(),
+    description: joi_1.default.string(),
+    rewriteQueries: joi_1.default.boolean().strict(),
+    shown: joi_1.default.boolean().strict(),
+    public: joi_1.default.boolean().strict(),
+    joins: joi_1.default.object().pattern(identifierRegex, joi_1.default.object().keys({
+        sql: joi_1.default.func().required(),
+        relationship: joi_1.default.any().valid('belongsTo', 'belongs_to', 'many_to_one', 'manyToOne', 'hasMany', 'has_many', 'one_to_many', 'oneToMany', 'hasOne', 'has_one', 'one_to_one', 'oneToOne').required()
     })),
     measures: MeasuresSchema,
-    dimensions: Joi.object().pattern(identifierRegex, Joi.alternatives().try(inherit(BaseDimensionWithoutSubQuery, {
-        case: Joi.object().keys({
-            when: Joi.array().items(Joi.object().keys({
-                sql: Joi.func().required(),
-                label: Joi.alternatives([
-                    Joi.string(),
-                    Joi.object().keys({
-                        sql: Joi.func().required()
+    dimensions: joi_1.default.object().pattern(identifierRegex, joi_1.default.alternatives().try(inherit(BaseDimensionWithoutSubQuery, {
+        case: joi_1.default.object().keys({
+            when: joi_1.default.array().items(joi_1.default.object().keys({
+                sql: joi_1.default.func().required(),
+                label: joi_1.default.alternatives([
+                    joi_1.default.string(),
+                    joi_1.default.object().keys({
+                        sql: joi_1.default.func().required()
                     })
                 ])
             })),
-            else: Joi.object().keys({
-                label: Joi.alternatives([
-                    Joi.string(),
-                    Joi.object().keys({
-                        sql: Joi.func().required()
+            else: joi_1.default.object().keys({
+                label: joi_1.default.alternatives([
+                    joi_1.default.string(),
+                    joi_1.default.object().keys({
+                        sql: joi_1.default.func().required()
                     })
                 ])
             })
         }).required()
     }), inherit(BaseDimensionWithoutSubQuery, {
-        latitude: Joi.object().keys({
-            sql: Joi.func().required()
+        latitude: joi_1.default.object().keys({
+            sql: joi_1.default.func().required()
         }).required(),
-        longitude: Joi.object().keys({
-            sql: Joi.func().required()
+        longitude: joi_1.default.object().keys({
+            sql: joi_1.default.func().required()
         }).required()
     }), inherit(BaseDimension, {
-        sql: Joi.func().required()
+        sql: joi_1.default.func().required()
     }))),
     segments: SegmentsSchema,
     preAggregations: PreAggregationsAlternatives,
 };
 const cubeSchema = inherit(baseSchema, {
-    sql: Joi.func(),
-    sqlTable: Joi.func(),
+    sql: joi_1.default.func(),
+    sqlTable: joi_1.default.func(),
 }).xor('sql', 'sqlTable').messages({
     'object.xor': 'You must use either sql or sqlTable within a model, but not both'
 });
 const viewSchema = inherit(baseSchema, {
-    isView: Joi.boolean().strict(),
-    includes: Joi.func(),
-    excludes: Joi.func(),
-    cubes: Joi.array().items(Joi.object().keys({
-        joinPath: Joi.func().required(),
-        prefix: Joi.boolean(),
-        split: Joi.boolean(),
-        alias: Joi.string(),
-        includes: Joi.alternatives([
-            Joi.string().valid('*'),
-            Joi.array().items(Joi.alternatives([
-                Joi.string().required(),
-                Joi.object().keys({
-                    name: Joi.string().required(),
-                    alias: Joi.string()
+    isView: joi_1.default.boolean().strict(),
+    includes: joi_1.default.func(),
+    excludes: joi_1.default.func(),
+    cubes: joi_1.default.array().items(joi_1.default.object().keys({
+        joinPath: joi_1.default.func().required(),
+        prefix: joi_1.default.boolean(),
+        split: joi_1.default.boolean(),
+        alias: joi_1.default.string(),
+        includes: joi_1.default.alternatives([
+            joi_1.default.string().valid('*'),
+            joi_1.default.array().items(joi_1.default.alternatives([
+                joi_1.default.string().required(),
+                joi_1.default.object().keys({
+                    name: joi_1.default.string().required(),
+                    alias: joi_1.default.string()
                 })
             ]))
         ]).required(),
-        excludes: Joi.array().items(Joi.string().required()),
+        excludes: joi_1.default.array().items(joi_1.default.string().required()),
     }).oxor('split', 'prefix').messages({
         'object.oxor': 'Using split together with prefix is not supported'
     })),
@@ -487,7 +498,7 @@ exports.functionFieldsPatterns = functionFieldsPatterns;
 class CubeValidator {
     constructor(cubeSymbols) {
         this.cubeSymbols = cubeSymbols;
-        this.validCubes = {};
+        this.validCubes = new Map();
     }
     compile(cubes, errorReporter) {
         return this.cubeSymbols.cubeList.map((v) => this.validate(this.cubeSymbols.getCubeDefinition(v.name), errorReporter.inContext(`${v.name} cube`)));