@devrev/meerkat-core 0.0.97 → 0.0.99

package/src/utils/key-from-measures-dimension.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMemberInfoFromTableSchema = void 0;
+const split_into_data_source_and_fields_1 = require("../member-formatters/split-into-data-source-and-fields");
+const getMemberInfoFromTableSchema = (memberKey, tableSchema) => {
+    let memberInfo;
+    const [_, memberKeyName] = (0, split_into_data_source_and_fields_1.splitIntoDataSourceAndFields)(memberKey);
+    /**
+     * Finding the table key from the measures.
+     */
+    for (let i = 0; i < tableSchema.measures.length; i++) {
+        const measure = tableSchema.measures[i];
+        const key = measure.name;
+        if (!key || key !== memberKeyName) {
+            continue;
+        }
+        memberInfo = measure;
+        return memberInfo;
+    }
+    for (let i = 0; i < tableSchema.dimensions.length; i++) {
+        const dimension = tableSchema.dimensions[i];
+        const key = dimension.name;
+        if (!key || key !== memberKeyName) {
+            continue;
+        }
+        memberInfo = dimension;
+        return memberInfo;
+    }
+    return;
+};
+exports.getMemberInfoFromTableSchema = getMemberInfoFromTableSchema;
+//# sourceMappingURL=key-from-measures-dimension.js.map

package/src/utils/key-from-measures-dimension.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-from-measures-dimension.js","sourceRoot":"","sources":["../../../../meerkat-core/src/utils/key-from-measures-dimension.ts"],"names":[],"mappings":";;;AAAA,8GAAsG;AAG/F,MAAM,4BAA4B,GAAG,CAC1C,SAAiB,EACjB,WAAwB,EACxB,EAAE;IACF,IAAI,UAA2C,CAAC;IAEhD,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,GAAG,IAAA,gEAA4B,EAAC,SAAS,CAAC,CAAC;IAEnE;;OAEG;IACH,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACpD,MAAM,OAAO,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;QACxC,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK,aAAa,EAAE;YACjC,SAAS;SACV;QAED,UAAU,GAAG,OAAO,CAAC;QACrB,OAAO,UAAU,CAAC;KACnB;IAED,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;QACtD,MAAM,SAAS,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAC5C,MAAM,GAAG,GAAG,SAAS,CAAC,IAAI,CAAC;QAE3B,IAAI,CAAC,GAAG,IAAI,GAAG,KAAK,aAAa,EAAE;YACjC,SAAS;SACV;QAED,UAAU,GAAG,SAAS,CAAC;QACvB,OAAO,UAAU,CAAC;KACnB;IACD,OAAO;AACT,CAAC,CAAC;AAlCW,QAAA,4BAA4B,gCAkCvC"}

package/src/utils/meerkat-placeholder-replacer.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meerkatPlaceholderReplacer = void 0;
+const constants_1 = require("../member-formatters/constants");
+const meerkatPlaceholderReplacer = (sql, tableName) => {
+    const tableNameEncapsulationRegEx = /\{MEERKAT\}\./g;
+    return sql.replace(tableNameEncapsulationRegEx, tableName + constants_1.MEERKAT_OUTPUT_DELIMITER);
+};
+exports.meerkatPlaceholderReplacer = meerkatPlaceholderReplacer;
+//# sourceMappingURL=meerkat-placeholder-replacer.js.map

package/src/utils/meerkat-placeholder-replacer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meerkat-placeholder-replacer.js","sourceRoot":"","sources":["../../../../meerkat-core/src/utils/meerkat-placeholder-replacer.ts"],"names":[],"mappings":";;;AAAA,8DAA0E;AAEnE,MAAM,0BAA0B,GAAG,CAAC,GAAW,EAAE,SAAiB,EAAE,EAAE;IAC3E,MAAM,2BAA2B,GAAG,gBAAgB,CAAC;IACrD,OAAO,GAAG,CAAC,OAAO,CAChB,2BAA2B,EAC3B,SAAS,GAAG,oCAAwB,CACrC,CAAC;AACJ,CAAC,CAAC;AANW,QAAA,0BAA0B,8BAMrC"}

package/src/utils/modify-meerkat-filter.d.ts

@@ -1,3 +1,2 @@
-import { QueryFiltersWithInfo } from "../cube-to-duckdb/cube-filter-to-duckdb";
-import { QueryFilter } from "../types/cube-types";
-export declare const modifyLeafMeerkatFilter: <T>(filters: QueryFiltersWithInfo, callback: (arg: QueryFilter) => T) => T[] | undefined;
+import { QueryFiltersWithInfo, QueryOperatorsWithInfo } from '../cube-to-duckdb/cube-filter-to-duckdb';
+export declare const modifyLeafMeerkatFilter: <T>(filters: QueryFiltersWithInfo, callback: (arg: QueryOperatorsWithInfo) => T) => T[] | undefined;

package/src/utils/modify-meerkat-filter.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modifyLeafMeerkatFilter = void 0;
+const modifyLeafMeerkatFilter = (filters, callback) => {
+    /*
+     ** This function traverse the QueryFiltersWithInfo JSON, and calls the callback for each leaf type.
+     ** This way we need no rewrite the traversal logic again and again.
+     ** The return value of the callback will show up the same path in the resulting object as in the original object
+     */
+    if (!filters)
+        return undefined;
+    return filters.map((item) => {
+        if ('member' in item) {
+            return callback(item);
+        }
+        else {
+            const andPayload = 'and' in item ? (0, exports.modifyLeafMeerkatFilter)(item.and, callback) : undefined;
+            const orPayload = 'or' in item ? (0, exports.modifyLeafMeerkatFilter)(item.or, callback) : undefined;
+            return Object.assign(Object.assign({}, (andPayload ? { and: andPayload } : {})), (orPayload ? { or: orPayload } : {}));
+        }
+    });
+};
+exports.modifyLeafMeerkatFilter = modifyLeafMeerkatFilter;
+//# sourceMappingURL=modify-meerkat-filter.js.map

package/src/utils/modify-meerkat-filter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modify-meerkat-filter.js","sourceRoot":"","sources":["../../../../meerkat-core/src/utils/modify-meerkat-filter.ts"],"names":[],"mappings":";;;AAKO,MAAM,uBAAuB,GAAG,CACrC,OAA6B,EAC7B,QAA4C,EAC3B,EAAE;IACnB;;;;OAIG;IACH,IAAI,CAAC,OAAO;QAAE,OAAO,SAAS,CAAC;IAC/B,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;QAC1B,IAAI,QAAQ,IAAI,IAAI,EAAE;YACpB,OAAO,QAAQ,CAAC,IAAI,CAAC,CAAC;SACvB;aAAM;YACL,MAAM,UAAU,GACd,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,IAAA,+BAAuB,EAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAC1E,MAAM,SAAS,GACb,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,IAAA,+BAAuB,EAAC,IAAI,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;YAExE,OAAO,gCACF,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,GAAG,EAAE,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GACvC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CACnC,CAAC;SACR;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC;AAzBW,QAAA,uBAAuB,2BAyBlC"}

package/{utils → src/utils}/type-guards.js

@@ -1,39 +1,17 @@
 "use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    hasChildren: function() {
-        return hasChildren;
-    },
-    isFilterArray: function() {
-        return isFilterArray;
-    },
-    isLogicalAnd: function() {
-        return isLogicalAnd;
-    },
-    isLogicalAndOR: function() {
-        return isLogicalAndOR;
-    },
-    isLogicalOr: function() {
-        return isLogicalOr;
-    },
-    isQueryFilter: function() {
-        return isQueryFilter;
-    }
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasChildren = exports.isFilterArray = exports.isQueryFilter = exports.isLogicalOr = exports.isLogicalAnd = exports.isLogicalAndOR = void 0;
 function isLogicalAndOR(expression) {
     if (!expression) {
         return false;
     }
-    if (Object.prototype.hasOwnProperty.call(expression, 'and') || Object.prototype.hasOwnProperty.call(expression, 'or')) {
+    if (Object.prototype.hasOwnProperty.call(expression, 'and') ||
+        Object.prototype.hasOwnProperty.call(expression, 'or')) {
         return true;
     }
     return false;
 }
+exports.isLogicalAndOR = isLogicalAndOR;
 function isLogicalAnd(expression) {
     if (!expression) {
         return false;
@@ -43,6 +21,7 @@ function isLogicalAnd(expression) {
     }
     return false;
 }
+exports.isLogicalAnd = isLogicalAnd;
 function isLogicalOr(expression) {
     if (!expression) {
         return false;
@@ -52,6 +31,7 @@ function isLogicalOr(expression) {
     }
     return false;
 }
+exports.isLogicalOr = isLogicalOr;
 function isQueryFilter(expression) {
     if (!expression) {
         return false;
@@ -61,6 +41,7 @@ function isQueryFilter(expression) {
     }
     return false;
 }
+exports.isQueryFilter = isQueryFilter;
 function isFilterArray(expression) {
     if (!expression) {
         return false;
@@ -70,6 +51,7 @@ function isFilterArray(expression) {
     }
     return false;
 }
+exports.isFilterArray = isFilterArray;
 function hasChildren(whereObj) {
     if (!whereObj) {
         return false;
@@ -79,5 +61,5 @@ function hasChildren(whereObj) {
     }
     return false;
 }
-
+exports.hasChildren = hasChildren;
 //# sourceMappingURL=type-guards.js.map

package/src/utils/type-guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-guards.js","sourceRoot":"","sources":["../../../../meerkat-core/src/utils/type-guards.ts"],"names":[],"mappings":";;;AAGA,SAAgB,cAAc,CAC5B,UAA4D;IAE5D,IAAI,CAAC,UAAU,EAAE;QACf,OAAO,KAAK,CAAC;KACd;IACD,IACE,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC;QACvD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,EACtD;QACA,OAAO,IAAI,CAAC;KACb;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAbD,wCAaC;AAED,SAAgB,YAAY,CAC1B,UAA4D;IAE5D,IAAI,CAAC,UAAU,EAAE;QACf,OAAO,KAAK,CAAC;KACd;IACD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,KAAK,CAAC,EAAE;QAC3D,OAAO,IAAI,CAAC;KACb;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAVD,oCAUC;AAED,SAAgB,WAAW,CACzB,UAA4D;IAE5D,IAAI,CAAC,UAAU,EAAE;QACf,OAAO,KAAK,CAAC;KACd;IACD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE;QAC1D,OAAO,IAAI,CAAC;KACb;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAVD,kCAUC;AAED,SAAgB,aAAa,CAC3B,UAA4D;IAE5D,IAAI,CAAC,UAAU,EAAE;QACf,OAAO,KAAK,CAAC;KACd;IACD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE;QAC9D,OAAO,IAAI,CAAC;KACb;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAVD,sCAUC;AAED,SAAgB,aAAa,CAC3B,UAEwD;IAExD,IAAI,CAAC,UAAU,EAAE;QACf,OAAO,KAAK,CAAC;KACd;IACD,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC7B,OAAO,IAAI,CAAC;KACb;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAZD,sCAYC;AAED,SAAgB,WAAW,CACzB,QAAiC;IAEjC,IAAI,CAAC,QAAQ,EAAE;QACb,OAAO,KAAK,CAAC;KACd;IACD,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,EAAE;QAC9D,OAAO,IAAI,CAAC;KACb;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAVD,kCAUC"}

package/ast-builder/ast-builder.js

@@ -1,90 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "cubeToDuckdbAST", {
-    enumerable: true,
-    get: function() {
-        return cubeToDuckdbAST;
-    }
-});
-const _extends = require("@swc/helpers/_/_extends");
-const _factory = require("../cube-filter-transformer/factory");
-const _cubegroupbytransformer = require("../cube-group-by-transformer/cube-group-by-transformer");
-const _cubelimitoffsettransformer = require("../cube-limit-offset-transformer/cube-limit-offset-transformer");
-const _cubeorderbytransformer = require("../cube-order-by-transformer/cube-order-by-transformer");
-const _filterparamsast = require("../filter-params/filter-params-ast");
-const _memberkeytosafekey = require("../member-formatters/member-key-to-safe-key");
-const _baseast = require("../utils/base-ast");
-const _cubefilterenrichment = require("../utils/cube-filter-enrichment");
-const _modifymeerkatfilter = require("../utils/modify-meerkat-filter");
-const formatFilters = (queryFiltersWithInfo, filterType)=>{
-    /*
-   * If the type of filter is set to base filter where
-   */ return filterType === 'BASE_FILTER' ? queryFiltersWithInfo : (0, _modifymeerkatfilter.modifyLeafMeerkatFilter)(queryFiltersWithInfo, (item)=>{
-        return _extends._({}, item, {
-            member: (0, _memberkeytosafekey.memberKeyToSafeKey)(item.member)
-        });
-    });
-};
-const getFormattedFilters = ({ queryFiltersWithInfo, filterType, mapperFn, baseAST })=>{
-    const filters = queryFiltersWithInfo.map((item)=>mapperFn(item)).filter(Boolean);
-    const formattedFilters = formatFilters(filters, filterType);
-    return (0, _factory.cubeFilterToDuckdbAST)(formattedFilters, baseAST);
-};
-const cubeToDuckdbAST = (query, tableSchema, options)=>{
-    var _query_dimensions;
-    /**
-   * Obviously, if no table schema was found, return null.
-   */ if (!tableSchema) {
-        return null;
-    }
-    const baseAST = (0, _baseast.getBaseAST)();
-    const node = baseAST.node;
-    if (query.filters && query.filters.length > 0) {
-        /**
-     * Make a copy of the query filters and enrich them with the table schema.
-     */ const queryFiltersWithInfo = (0, _cubefilterenrichment.cubeFiltersEnrichment)(JSON.parse(JSON.stringify(query.filters)), tableSchema);
-        if (!queryFiltersWithInfo) {
-            return null;
-        }
-        const whereClause = getFormattedFilters({
-            baseAST,
-            mapperFn: (item)=>(0, _filterparamsast.traverseAndFilter)(item, (value)=>!query.measures.includes(value.member)),
-            queryFiltersWithInfo,
-            filterType: options == null ? void 0 : options.filterType
-        });
-        const havingClause = getFormattedFilters({
-            baseAST,
-            mapperFn: (item)=>(0, _filterparamsast.traverseAndFilter)(item, (value)=>query.measures.includes(value.member)),
-            queryFiltersWithInfo,
-            filterType: options == null ? void 0 : options.filterType
-        });
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        //@ts-ignore
-        node.where_clause = whereClause;
-        node.having = havingClause;
-    }
-    if (query.measures.length && query.dimensions && ((_query_dimensions = query.dimensions) == null ? void 0 : _query_dimensions.length) > 0) {
-        node.group_expressions = (0, _cubegroupbytransformer.cubeDimensionToGroupByAST)(query.dimensions);
-        const groupSets = [];
-        /**
-     * We only support one group set for now.
-     */ for(let i = 0; i < node.group_expressions.length; i++){
-            groupSets.push(i);
-        }
-        node.group_sets = [
-            groupSets
-        ];
-    }
-    node.modifiers = [];
-    if (query.order && Object.keys(query.order).length > 0) {
-        node.modifiers.push((0, _cubeorderbytransformer.cubeOrderByToAST)(query.order));
-    }
-    if (query.limit || query.offset) {
-        // Type assertion is needed here because the AST is not typed correctly.
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        //@ts-ignore
-        node.modifiers.push((0, _cubelimitoffsettransformer.cubeLimitOffsetToAST)(query.limit, query.offset));
-    }
-    return baseAST;
-};
-
-//# sourceMappingURL=ast-builder.js.map

package/ast-builder/ast-builder.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/ast-builder/ast-builder.ts"],"sourcesContent":["import { cubeFilterToDuckdbAST } from '../cube-filter-transformer/factory';\nimport { cubeDimensionToGroupByAST } from '../cube-group-by-transformer/cube-group-by-transformer';\nimport { cubeLimitOffsetToAST } from '../cube-limit-offset-transformer/cube-limit-offset-transformer';\nimport { cubeOrderByToAST } from '../cube-order-by-transformer/cube-order-by-transformer';\nimport {\n  QueryFiltersWithInfo,\n  QueryFiltersWithInfoSingular,\n} from '../cube-to-duckdb/cube-filter-to-duckdb';\nimport { traverseAndFilter } from '../filter-params/filter-params-ast';\nimport { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';\nimport {\n  FilterType,\n  MeerkatQueryFilter,\n  Query,\n} from '../types/cube-types/query';\nimport { TableSchema } from '../types/cube-types/table';\nimport { SelectStatement } from '../types/duckdb-serialization-types';\nimport { SelectNode } from '../types/duckdb-serialization-types/serialization/QueryNode';\nimport { getBaseAST } from '../utils/base-ast';\nimport { cubeFiltersEnrichment } from '../utils/cube-filter-enrichment';\nimport { modifyLeafMeerkatFilter } from '../utils/modify-meerkat-filter';\n\nconst formatFilters = (\n  queryFiltersWithInfo: QueryFiltersWithInfo,\n  filterType?: FilterType\n) => {\n  /*\n   * If the type of filter is set to base filter where\n   */\n  return filterType === 'BASE_FILTER'\n    ? queryFiltersWithInfo\n    : (modifyLeafMeerkatFilter(queryFiltersWithInfo, (item) => {\n        return {\n          ...item,\n          member: memberKeyToSafeKey(item.member),\n        };\n      }) as QueryFiltersWithInfo);\n};\n\nconst getFormattedFilters = ({\n  queryFiltersWithInfo,\n  filterType,\n  mapperFn,\n  baseAST,\n}: {\n  queryFiltersWithInfo: QueryFiltersWithInfo;\n  filterType?: FilterType;\n  baseAST: SelectStatement;\n  mapperFn: (val: QueryFiltersWithInfoSingular) => MeerkatQueryFilter | null;\n}) => {\n  const filters = queryFiltersWithInfo\n    .map((item) => mapperFn(item))\n    .filter(Boolean) as QueryFiltersWithInfoSingular[];\n  const formattedFilters = formatFilters(filters, filterType);\n  return cubeFilterToDuckdbAST(formattedFilters, baseAST);\n};\n\nexport const cubeToDuckdbAST = (\n  query: Query,\n  tableSchema: TableSchema,\n  options?: { filterType: FilterType }\n) => {\n  /**\n   * Obviously, if no table schema was found, return null.\n   */\n  if (!tableSchema) {\n    return null;\n  }\n\n  const baseAST = getBaseAST();\n  const node = baseAST.node as SelectNode;\n  if (query.filters && query.filters.length > 0) {\n    /**\n     * Make a copy of the query filters and enrich them with the table schema.\n     */\n    const queryFiltersWithInfo = cubeFiltersEnrichment(\n      JSON.parse(JSON.stringify(query.filters)),\n      tableSchema\n    );\n\n    if (!queryFiltersWithInfo) {\n      return null;\n    }\n\n    const whereClause = getFormattedFilters({\n      baseAST,\n      mapperFn: (item) =>\n        traverseAndFilter(\n          item,\n          (value) => !query.measures.includes(value.member)\n        ),\n      queryFiltersWithInfo,\n      filterType: options?.filterType,\n    });\n\n    const havingClause = getFormattedFilters({\n      baseAST,\n      mapperFn: (item) =>\n        traverseAndFilter(item, (value) =>\n          query.measures.includes(value.member)\n        ),\n      queryFiltersWithInfo,\n      filterType: options?.filterType,\n    });\n\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    //@ts-ignore\n    node.where_clause = whereClause;\n    node.having = havingClause;\n  }\n  if (\n    query.measures.length &&\n    query.dimensions &&\n    query.dimensions?.length > 0\n  ) {\n    node.group_expressions = cubeDimensionToGroupByAST(query.dimensions);\n    const groupSets = [];\n    /**\n     * We only support one group set for now.\n     */\n    for (let i = 0; i < node.group_expressions.length; i++) {\n      groupSets.push(i);\n    }\n    node.group_sets = [groupSets];\n  }\n  node.modifiers = [];\n  if (query.order && Object.keys(query.order).length > 0) {\n    node.modifiers.push(cubeOrderByToAST(query.order));\n  }\n  if (query.limit || query.offset) {\n    // Type assertion is needed here because the AST is not typed correctly.\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    //@ts-ignore\n    node.modifiers.push(cubeLimitOffsetToAST(query.limit, query.offset));\n  }\n\n  return baseAST;\n};\n"],"names":["cubeToDuckdbAST","formatFilters","queryFiltersWithInfo","filterType","modifyLeafMeerkatFilter","item","member","memberKeyToSafeKey","getFormattedFilters","mapperFn","baseAST","filters","map","filter","Boolean","formattedFilters","cubeFilterToDuckdbAST","query","tableSchema","options","getBaseAST","node","length","cubeFiltersEnrichment","JSON","parse","stringify","whereClause","traverseAndFilter","value","measures","includes","havingClause","where_clause","having","dimensions","group_expressions","cubeDimensionToGroupByAST","groupSets","i","push","group_sets","modifiers","order","Object","keys","cubeOrderByToAST","limit","offset","cubeLimitOffsetToAST"],"mappings":"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"}

package/ast-deserializer/ast-deserializer.js

@@ -1,30 +0,0 @@
-"use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    astDeserializerQuery: function() {
-        return astDeserializerQuery;
-    },
-    deserializeQuery: function() {
-        return deserializeQuery;
-    }
-});
-const astDeserializerQuery = (ast)=>{
-    return `SELECT json_deserialize_sql('${JSON.stringify({
-        statements: [
-            ast
-        ]
-    })}');`;
-};
-const deserializeQuery = (queryOutput)=>{
-    const deserializeObj = queryOutput[0];
-    const deserializeKey = Object.keys(deserializeObj)[0];
-    const deserializeQuery = deserializeObj[deserializeKey];
-    return deserializeQuery;
-};
-
-//# sourceMappingURL=ast-deserializer.js.map

package/ast-deserializer/ast-deserializer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/ast-deserializer/ast-deserializer.ts"],"sourcesContent":["import { SelectStatement } from '../types/duckdb-serialization-types';\n\nexport const astDeserializerQuery = (ast: SelectStatement) => {\n  return `SELECT json_deserialize_sql('${JSON.stringify({\n    statements: [ast],\n  })}');`;\n};\n\nexport const deserializeQuery = (\n  queryOutput: {\n    [key: string]: string;\n  }[]\n) => {\n  const deserializeObj = queryOutput[0];\n  const deserializeKey = Object.keys(deserializeObj)[0];\n  const deserializeQuery = deserializeObj[deserializeKey];\n  return deserializeQuery;\n};\n"],"names":["astDeserializerQuery","deserializeQuery","ast","JSON","stringify","statements","queryOutput","deserializeObj","deserializeKey","Object","keys"],"mappings":";;;;;;;;IAEaA,oBAAoB;eAApBA;;IAMAC,gBAAgB;eAAhBA;;;AANN,MAAMD,uBAAuB,CAACE;IACnC,OAAO,CAAC,6BAA6B,EAAEC,KAAKC,SAAS,CAAC;QACpDC,YAAY;YAACH;SAAI;IACnB,GAAG,GAAG,CAAC;AACT;AAEO,MAAMD,mBAAmB,CAC9BK;IAIA,MAAMC,iBAAiBD,WAAW,CAAC,EAAE;IACrC,MAAME,iBAAiBC,OAAOC,IAAI,CAACH,eAAe,CAAC,EAAE;IACrD,MAAMN,mBAAmBM,cAAc,CAACC,eAAe;IACvD,OAAOP;AACT"}

package/ast-serializer/ast-serializer.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "astSerializerQuery", {
-    enumerable: true,
-    get: function() {
-        return astSerializerQuery;
-    }
-});
-const astSerializerQuery = (query)=>{
-    return `SELECT json_serialize_sql('${query}')`;
-};
-
-//# sourceMappingURL=ast-serializer.js.map

package/ast-serializer/ast-serializer.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/ast-serializer/ast-serializer.ts"],"sourcesContent":["export const astSerializerQuery = (query: string) => {\n  return `SELECT json_serialize_sql('${query}')`;\n};\n"],"names":["astSerializerQuery","query"],"mappings":";+BAAaA;;;eAAAA;;;AAAN,MAAMA,qBAAqB,CAACC;IACjC,OAAO,CAAC,2BAA2B,EAAEA,MAAM,EAAE,CAAC;AAChD"}

package/ast-validator/dimension-validator.js

@@ -1,54 +0,0 @@
-"use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    validateDimension: function() {
-        return validateDimension;
-    },
-    validateExpressionNode: function() {
-        return validateExpressionNode;
-    }
-});
-const _utils = require("../types/utils");
-const _utils1 = require("./utils");
-const validateExpressionNode = (node, validFunctions)=>{
-    // Column references and value constants
-    if ((0, _utils.isColumnRefExpression)(node) || (0, _utils.isConstantExpression)(node)) {
-        return true;
-    }
-    // Cast expression
-    if ((0, _utils.isCastExpression)(node)) {
-        return validateExpressionNode(node.child, validFunctions);
-    }
-    // Operator expression
-    if ((0, _utils.isOperatorExpression)(node)) {
-        return node.children.every((child)=>validateExpressionNode(child, validFunctions));
-    }
-    // Function expression
-    if ((0, _utils.isFunctionExpression)(node)) {
-        if (!validFunctions.has(node.function_name)) {
-            throw new Error(`Invalid function: ${node.function_name}`);
-        }
-        return node.children.every((child)=>validateExpressionNode(child, validFunctions));
-    }
-    // Case expression
-    if ((0, _utils.isCaseExpression)(node)) {
-        return node.case_checks.every((check)=>validateExpressionNode(check.then_expr, validFunctions)) && validateExpressionNode(node.else_expr, validFunctions);
-    }
-    throw new Error(`Invalid expression type: ${node.type}`);
-};
-const validateDimension = (parsedSerialization, validFunctions)=>{
-    const node = (0, _utils1.getSelectNode)(parsedSerialization);
-    const validFunctionSet = new Set(validFunctions);
-    // Validate the expression
-    if (validateExpressionNode(node, validFunctionSet)) {
-        return true;
-    }
-    throw new Error('Expression contains invalid functions or operators');
-};
-
-//# sourceMappingURL=dimension-validator.js.map

package/ast-validator/dimension-validator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/ast-validator/dimension-validator.ts"],"sourcesContent":["import { ParsedExpression } from '../types/duckdb-serialization-types';\nimport {\n  isCaseExpression,\n  isCastExpression,\n  isColumnRefExpression,\n  isConstantExpression,\n  isFunctionExpression,\n  isOperatorExpression,\n} from '../types/utils';\nimport { ParsedSerialization } from './types';\nimport { getSelectNode } from './utils';\n\n/**\n * Validates an individual expression node\n */\nexport const validateExpressionNode = (\n  node: ParsedExpression,\n  validFunctions: Set<string>\n): boolean => {\n  // Column references and value constants\n  if (isColumnRefExpression(node) || isConstantExpression(node)) {\n    return true;\n  }\n\n  // Cast expression\n  if (isCastExpression(node)) {\n    return validateExpressionNode(node.child, validFunctions);\n  }\n\n  // Operator expression\n  if (isOperatorExpression(node)) {\n    return node.children.every((child) =>\n      validateExpressionNode(child, validFunctions)\n    );\n  }\n\n  // Function expression\n  if (isFunctionExpression(node)) {\n    if (!validFunctions.has(node.function_name)) {\n      throw new Error(`Invalid function: ${node.function_name}`);\n    }\n    return node.children.every((child) =>\n      validateExpressionNode(child, validFunctions)\n    );\n  }\n\n  // Case expression\n  if (isCaseExpression(node)) {\n    return (\n      node.case_checks.every((check) =>\n        validateExpressionNode(check.then_expr, validFunctions)\n      ) && validateExpressionNode(node.else_expr, validFunctions)\n    );\n  }\n\n  throw new Error(`Invalid expression type: ${node.type}`);\n};\n\n/**\n * Validates if the parsed serialization represents a valid dimension\n */\nexport const validateDimension = (\n  parsedSerialization: ParsedSerialization,\n  validFunctions: string[]\n): boolean => {\n  const node = getSelectNode(parsedSerialization);\n\n  const validFunctionSet = new Set(validFunctions);\n\n  // Validate the expression\n  if (validateExpressionNode(node, validFunctionSet)) {\n    return true;\n  }\n\n  throw new Error('Expression contains invalid functions or operators');\n};\n"],"names":["validateDimension","validateExpressionNode","node","validFunctions","isColumnRefExpression","isConstantExpression","isCastExpression","child","isOperatorExpression","children","every","isFunctionExpression","has","function_name","Error","isCaseExpression","case_checks","check","then_expr","else_expr","type","parsedSerialization","getSelectNode","validFunctionSet","Set"],"mappings":";;;;;;;;IA6DaA,iBAAiB;eAAjBA;;IA9CAC,sBAAsB;eAAtBA;;;uBAPN;wBAEuB;AAKvB,MAAMA,yBAAyB,CACpCC,MACAC;IAEA,wCAAwC;IACxC,IAAIC,IAAAA,4BAAqB,EAACF,SAASG,IAAAA,2BAAoB,EAACH,OAAO;QAC7D,OAAO;IACT;IAEA,kBAAkB;IAClB,IAAII,IAAAA,uBAAgB,EAACJ,OAAO;QAC1B,OAAOD,uBAAuBC,KAAKK,KAAK,EAAEJ;IAC5C;IAEA,sBAAsB;IACtB,IAAIK,IAAAA,2BAAoB,EAACN,OAAO;QAC9B,OAAOA,KAAKO,QAAQ,CAACC,KAAK,CAAC,CAACH,QAC1BN,uBAAuBM,OAAOJ;IAElC;IAEA,sBAAsB;IACtB,IAAIQ,IAAAA,2BAAoB,EAACT,OAAO;QAC9B,IAAI,CAACC,eAAeS,GAAG,CAACV,KAAKW,aAAa,GAAG;YAC3C,MAAM,IAAIC,MAAM,CAAC,kBAAkB,EAAEZ,KAAKW,aAAa,CAAC,CAAC;QAC3D;QACA,OAAOX,KAAKO,QAAQ,CAACC,KAAK,CAAC,CAACH,QAC1BN,uBAAuBM,OAAOJ;IAElC;IAEA,kBAAkB;IAClB,IAAIY,IAAAA,uBAAgB,EAACb,OAAO;QAC1B,OACEA,KAAKc,WAAW,CAACN,KAAK,CAAC,CAACO,QACtBhB,uBAAuBgB,MAAMC,SAAS,EAAEf,oBACrCF,uBAAuBC,KAAKiB,SAAS,EAAEhB;IAEhD;IAEA,MAAM,IAAIW,MAAM,CAAC,yBAAyB,EAAEZ,KAAKkB,IAAI,CAAC,CAAC;AACzD;AAKO,MAAMpB,oBAAoB,CAC/BqB,qBACAlB;IAEA,MAAMD,OAAOoB,IAAAA,qBAAa,EAACD;IAE3B,MAAME,mBAAmB,IAAIC,IAAIrB;IAEjC,0BAA0B;IAC1B,IAAIF,uBAAuBC,MAAMqB,mBAAmB;QAClD,OAAO;IACT;IAEA,MAAM,IAAIT,MAAM;AAClB"}

package/ast-validator/index.js

@@ -1,25 +0,0 @@
-"use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getSelectNode: function() {
-        return _utils.getSelectNode;
-    },
-    validateDimension: function() {
-        return _dimensionvalidator.validateDimension;
-    },
-    validateMeasure: function() {
-        return _measurevalidator.validateMeasure;
-    }
-});
-const _export_star = require("@swc/helpers/_/_export_star");
-const _dimensionvalidator = require("./dimension-validator");
-const _measurevalidator = require("./measure-validator");
-_export_star._(require("./types"), exports);
-const _utils = require("./utils");
-
-//# sourceMappingURL=index.js.map

package/ast-validator/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/ast-validator/index.ts"],"sourcesContent":["export { validateDimension } from './dimension-validator';\nexport { validateMeasure } from './measure-validator';\nexport * from './types';\nexport { getSelectNode } from './utils';\n"],"names":["getSelectNode","validateDimension","validateMeasure"],"mappings":";;;;;;;;IAGSA,aAAa;eAAbA,oBAAa;;IAHbC,iBAAiB;eAAjBA,qCAAiB;;IACjBC,eAAe;eAAfA,iCAAe;;;;oCADU;kCACF;uBAClB;uBACgB"}

package/ast-validator/measure-validator.js

@@ -1,163 +0,0 @@
-"use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    containsAggregation: function() {
-        return containsAggregation;
-    },
-    validateExpressionNode: function() {
-        return validateExpressionNode;
-    },
-    validateMeasure: function() {
-        return validateMeasure;
-    }
-});
-const _utils = require("../types/utils");
-const _utils1 = require("./utils");
-const validateExpressionNode = ({ node, validFunctions, parentNode, validScalarFunctions, hasAggregation = false })=>{
-    // Base cases for column references and constants
-    if ((0, _utils.isColumnRefExpression)(node) || (0, _utils.isConstantExpression)(node)) {
-        // Allow column references inside aggregation functions
-        return !!parentNode;
-    }
-    // Check for valid aggregation functions
-    if ((0, _utils.isFunctionExpression)(node) || (0, _utils.isWindowExpression)(node)) {
-        // count_star don't have children
-        if (node.function_name === 'count_star') return true;
-        // This is a valid aggregation function - verify its children don't contain nested aggregations
-        if (validFunctions.has(node.function_name)) {
-            return node.children.some((child)=>validateExpressionNode({
-                    node: child,
-                    validFunctions,
-                    parentNode: node,
-                    validScalarFunctions,
-                    hasAggregation: true
-                }));
-        }
-        // For non-aggregation functions
-        if (validScalarFunctions.has(node.function_name)) {
-            return node.children.some((child)=>{
-                return validateExpressionNode({
-                    node: child,
-                    validFunctions,
-                    parentNode: node,
-                    validScalarFunctions
-                }) && (containsAggregation(child, validFunctions) || hasAggregation);
-            });
-        }
-        throw new Error(`Invalid function type: ${node.function_name}`);
-    }
-    // Operator expression
-    if ((0, _utils.isOperatorExpression)(node)) {
-        return node.children.some((child)=>validateExpressionNode({
-                node: child,
-                validFunctions,
-                parentNode,
-                validScalarFunctions
-            }));
-    }
-    // Cast expression
-    if ((0, _utils.isCastExpression)(node)) {
-        return validateExpressionNode({
-            node: node.child,
-            validFunctions,
-            parentNode,
-            validScalarFunctions
-        });
-    }
-    // Case expression
-    if ((0, _utils.isCaseExpression)(node)) {
-        const checksValid = node.case_checks.every((caseCheck)=>{
-            // WHEN conditions cannot contain aggregations
-            const whenValid = !containsAggregation(caseCheck.when_expr, validFunctions);
-            // THEN expressions must be valid aggregations or contain no aggregations
-            const thenValid = validateExpressionNode({
-                node: caseCheck.then_expr,
-                validFunctions,
-                parentNode: node,
-                validScalarFunctions
-            }) || !containsAggregation(caseCheck.then_expr, validFunctions);
-            return whenValid && thenValid;
-        });
-        const elseValid = validateExpressionNode({
-            node: node.else_expr,
-            validFunctions,
-            parentNode: node,
-            validScalarFunctions
-        }) || !containsAggregation(node.else_expr, validFunctions);
-        return checksValid && elseValid;
-    }
-    // Subquery expression
-    if ((0, _utils.isSubqueryExpression)(node) && (0, _utils.isSelectNode)(node.subquery.node)) {
-        return node.subquery.node.select_list.every((node)=>{
-            return validateExpressionNode({
-                node,
-                validFunctions,
-                parentNode,
-                validScalarFunctions
-            });
-        });
-    }
-    // Window expression
-    if ((0, _utils.isWindowExpression)(node)) {
-        return node.children.every((node)=>{
-            return validateExpressionNode({
-                node,
-                validFunctions,
-                parentNode,
-                validScalarFunctions
-            });
-        });
-    }
-    throw new Error(`Invalid expression type: ${node.type}`);
-};
-const containsAggregation = (node, validFunctions)=>{
-    if (!node) return false;
-    // Function expression
-    if ((0, _utils.isFunctionExpression)(node) || (0, _utils.isWindowExpression)(node)) {
-        return validFunctions.has(node.function_name) || node.children.some((child)=>containsAggregation(child, validFunctions));
-    }
-    // Case expression
-    if ((0, _utils.isCaseExpression)(node)) {
-        return node.case_checks.some((check)=>containsAggregation(check.when_expr, validFunctions) || containsAggregation(check.then_expr, validFunctions)) || containsAggregation(node.else_expr, validFunctions);
-    }
-    // Operator expression
-    if ((0, _utils.isOperatorExpression)(node)) {
-        return node.children.some((child)=>containsAggregation(child, validFunctions));
-    }
-    if ((0, _utils.isCastExpression)(node)) {
-        return containsAggregation(node.child, validFunctions);
-    }
-    // Window expression
-    if ((0, _utils.isWindowExpression)(node)) {
-        return node.children.some((child)=>containsAggregation(child, validFunctions));
-    }
-    // Subquery expression
-    if ((0, _utils.isSubqueryExpression)(node) && (0, _utils.isSelectNode)(node.subquery.node)) {
-        return node.subquery.node.select_list.every((node)=>{
-            return containsAggregation(node, validFunctions);
-        });
-    }
-    return false;
-};
-const validateMeasure = (parsedSerialization, validFunctions, validScalarFunctions)=>{
-    const node = (0, _utils1.getSelectNode)(parsedSerialization);
-    const validFunctionSet = new Set(validFunctions);
-    const validScalarFunctionSet = new Set(validScalarFunctions);
-    // Validate the expression
-    if (validateExpressionNode({
-        node: node,
-        validFunctions: validFunctionSet,
-        parentNode: null,
-        validScalarFunctions: validScalarFunctionSet
-    })) {
-        return true;
-    }
-    throw new Error('Expression contains invalid functions or operators');
-};
-
-//# sourceMappingURL=measure-validator.js.map

package/ast-validator/measure-validator.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/ast-validator/measure-validator.ts"],"sourcesContent":["import { ParsedExpression } from '../types/duckdb-serialization-types';\nimport {\n  isCaseExpression,\n  isCastExpression,\n  isColumnRefExpression,\n  isConstantExpression,\n  isFunctionExpression,\n  isOperatorExpression,\n  isSelectNode,\n  isSubqueryExpression,\n  isWindowExpression,\n} from '../types/utils';\nimport { ParsedSerialization } from './types';\nimport { getSelectNode } from './utils';\n\nexport const validateExpressionNode = ({\n  node,\n  validFunctions,\n  parentNode,\n  validScalarFunctions,\n  hasAggregation = false,\n}: {\n  node: ParsedExpression;\n  validFunctions: Set<string>;\n  parentNode: ParsedExpression | null;\n  hasAggregation?: boolean;\n  validScalarFunctions: Set<string>;\n}): boolean => {\n  // Base cases for column references and constants\n  if (isColumnRefExpression(node) || isConstantExpression(node)) {\n    // Allow column references inside aggregation functions\n    return !!parentNode;\n  }\n\n  // Check for valid aggregation functions\n  if (isFunctionExpression(node) || isWindowExpression(node)) {\n    // count_star don't have children\n    if (node.function_name === 'count_star') return true;\n\n    // This is a valid aggregation function - verify its children don't contain nested aggregations\n    if (validFunctions.has(node.function_name)) {\n      return node.children.some((child) =>\n        validateExpressionNode({\n          node: child,\n          validFunctions,\n          parentNode: node,\n          validScalarFunctions,\n          hasAggregation: true,\n        })\n      );\n    }\n\n    // For non-aggregation functions\n    if (validScalarFunctions.has(node.function_name)) {\n      return node.children.some((child) => {\n        return (\n          validateExpressionNode({\n            node: child,\n            validFunctions,\n            parentNode: node,\n            validScalarFunctions,\n          }) &&\n          (containsAggregation(child, validFunctions) || hasAggregation)\n        );\n      });\n    }\n\n    throw new Error(`Invalid function type: ${node.function_name}`);\n  }\n\n  // Operator expression\n  if (isOperatorExpression(node)) {\n    return node.children.some((child) =>\n      validateExpressionNode({\n        node: child,\n        validFunctions,\n        parentNode,\n        validScalarFunctions,\n      })\n    );\n  }\n\n  // Cast expression\n  if (isCastExpression(node)) {\n    return validateExpressionNode({\n      node: node.child,\n      validFunctions,\n      parentNode,\n      validScalarFunctions,\n    });\n  }\n\n  // Case expression\n  if (isCaseExpression(node)) {\n    const checksValid = node.case_checks.every((caseCheck) => {\n      // WHEN conditions cannot contain aggregations\n      const whenValid = !containsAggregation(\n        caseCheck.when_expr,\n        validFunctions\n      );\n\n      // THEN expressions must be valid aggregations or contain no aggregations\n      const thenValid =\n        validateExpressionNode({\n          node: caseCheck.then_expr,\n          validFunctions,\n          parentNode: node,\n          validScalarFunctions,\n        }) || !containsAggregation(caseCheck.then_expr, validFunctions);\n      return whenValid && thenValid;\n    });\n\n    const elseValid =\n      validateExpressionNode({\n        node: node.else_expr,\n        validFunctions,\n        parentNode: node,\n        validScalarFunctions,\n      }) || !containsAggregation(node.else_expr, validFunctions);\n\n    return checksValid && elseValid;\n  }\n\n  // Subquery expression\n  if (isSubqueryExpression(node) && isSelectNode(node.subquery.node)) {\n    return node.subquery.node.select_list.every((node) => {\n      return validateExpressionNode({\n        node,\n        validFunctions,\n        parentNode,\n        validScalarFunctions,\n      });\n    });\n  }\n\n  // Window expression\n  if (isWindowExpression(node)) {\n    return node.children.every((node) => {\n      return validateExpressionNode({\n        node,\n        validFunctions,\n        parentNode,\n        validScalarFunctions,\n      });\n    });\n  }\n\n  throw new Error(`Invalid expression type: ${node.type}`);\n};\n\nexport const containsAggregation = (\n  node: ParsedExpression,\n  validFunctions: Set<string>\n): boolean => {\n  if (!node) return false;\n\n  // Function expression\n  if (isFunctionExpression(node) || isWindowExpression(node)) {\n    return (\n      validFunctions.has(node.function_name) ||\n      node.children.some((child) => containsAggregation(child, validFunctions))\n    );\n  }\n\n  // Case expression\n  if (isCaseExpression(node)) {\n    return (\n      node.case_checks.some(\n        (check) =>\n          containsAggregation(check.when_expr, validFunctions) ||\n          containsAggregation(check.then_expr, validFunctions)\n      ) || containsAggregation(node.else_expr, validFunctions)\n    );\n  }\n\n  // Operator expression\n  if (isOperatorExpression(node)) {\n    return node.children.some((child) =>\n      containsAggregation(child, validFunctions)\n    );\n  }\n\n  if (isCastExpression(node)) {\n    return containsAggregation(node.child, validFunctions);\n  }\n\n  // Window expression\n  if (isWindowExpression(node)) {\n    return node.children.some((child) =>\n      containsAggregation(child, validFunctions)\n    );\n  }\n\n  // Subquery expression\n  if (isSubqueryExpression(node) && isSelectNode(node.subquery.node)) {\n    return node.subquery.node.select_list.every((node) => {\n      return containsAggregation(node, validFunctions);\n    });\n  }\n\n  return false;\n};\n\nexport const validateMeasure = (\n  parsedSerialization: ParsedSerialization,\n  validFunctions: string[],\n  validScalarFunctions: string[]\n): boolean => {\n  const node = getSelectNode(parsedSerialization);\n\n  const validFunctionSet = new Set(validFunctions);\n  const validScalarFunctionSet = new Set(validScalarFunctions);\n\n  // Validate the expression\n  if (\n    validateExpressionNode({\n      node: node,\n      validFunctions: validFunctionSet,\n      parentNode: null,\n      validScalarFunctions: validScalarFunctionSet,\n    })\n  ) {\n    return true;\n  }\n\n  throw new Error('Expression contains invalid functions or operators');\n};\n"],"names":["containsAggregation","validateExpressionNode","validateMeasure","node","validFunctions","parentNode","validScalarFunctions","hasAggregation","isColumnRefExpression","isConstantExpression","isFunctionExpression","isWindowExpression","function_name","has","children","some","child","Error","isOperatorExpression","isCastExpression","isCaseExpression","checksValid","case_checks","every","caseCheck","whenValid","when_expr","thenValid","then_expr","elseValid","else_expr","isSubqueryExpression","isSelectNode","subquery","select_list","type","check","parsedSerialization","getSelectNode","validFunctionSet","Set","validScalarFunctionSet"],"mappings":"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"}