@devrev/meerkat-core 0.0.90 → 0.0.93

package/utils/cube-to-table-schema.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "convertCubeStringToTableSchema", {
+    enumerable: true,
+    get: function() {
+        return convertCubeStringToTableSchema;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+const cube = (name, object)=>({
+        name,
+        object
+    });
+function convertCubeStringToTableSchema(file) {
+    // replace ${...} with ...
+    let replacedFile = file.replace(/\${(.*?)}/g, (match, variable)=>variable);
+    // replace CUBE with MEERKAT
+    replacedFile = replacedFile.replace(/CUBE/g, '{MEERKAT}');
+    const { name, object } = eval(replacedFile);
+    return convertCubeToTableSchema({
+        name,
+        object
+    });
+}
+function convertCubeToTableSchema({ name, object }) {
+    const resObj = {
+        name,
+        sql: object.sql_table,
+        measures: [],
+        dimensions: []
+    };
+    const dimensions = object.dimensions;
+    const measures = object.measures;
+    // convert dimensions and measures
+    for(const key in dimensions){
+        resObj.dimensions.push({
+            name: key,
+            sql: dimensions[key].sql,
+            type: dimensions[key].type
+        });
+    }
+    for(const key in measures){
+        resObj.measures.push(_extends._({
+            name: key
+        }, convertMeasure(measures[key])));
+    }
+    // convert joins
+    if (object.joins && Object.keys(object.joins).length > 0) {
+        resObj.joins = [];
+        for(const joinName in object.joins){
+            const join = object.joins[joinName];
+            resObj.joins.push({
+                sql: join.sql
+            });
+        }
+    }
+    return resObj;
+}
+function convertMeasure(measure) {
+    switch(measure.type){
+        case 'count':
+            return {
+                sql: measure.sql ? `COUNT(${measure.sql})` : 'COUNT(*)',
+                type: 'number'
+            };
+        case 'count_distinct':
+            return {
+                sql: `COUNT(DISTINCT ${measure.sql})`,
+                type: 'number'
+            };
+        case 'count_distinct_approx':
+            return {
+                sql: `APPROX_COUNT_DISTINCT(${measure.sql})`,
+                type: 'number'
+            };
+        case 'sum':
+            return {
+                sql: `SUM(${measure.sql})`,
+                type: 'number'
+            };
+        case 'avg':
+            return {
+                sql: `AVG(${measure.sql})`,
+                type: 'number'
+            };
+        case 'min':
+            return {
+                sql: `MIN(${measure.sql})`,
+                type: 'number'
+            };
+        case 'max':
+            return {
+                sql: `MAX(${measure.sql})`,
+                type: 'number'
+            };
+        default:
+            var _measure_sql;
+            return {
+                sql: (_measure_sql = measure.sql) != null ? _measure_sql : '',
+                type: measure.type
+            };
+    }
+}
+
+//# sourceMappingURL=cube-to-table-schema.js.map

package/utils/cube-to-table-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/cube-to-table-schema.ts"],"sourcesContent":["import { DimensionType, Measure, TableSchema } from '../types/cube-types/table';\n\nexport type CubeMeasureType =\n  | 'string'\n  | 'string_array'\n  | 'time'\n  | 'number'\n  | 'number_array'\n  | 'boolean'\n  | 'count'\n  | 'count_distinct'\n  | 'count_distinct_approx'\n  | 'sum'\n  | 'avg'\n  | 'min'\n  | 'max';\n\ninterface CubeSchema {\n  name: string;\n  object: {\n    sql_table: string;\n    measures: {\n      [key: string]: CubeMeasure;\n    };\n    dimensions: {\n      [key: string]: {\n        sql: string;\n        type: DimensionType;\n      };\n    };\n    joins?: {\n      [key: string]: {\n        sql: string;\n      };\n    };\n  };\n}\nconst cube = (name: any, object: any) => ({ name, object });\nexport function convertCubeStringToTableSchema(\n  file: string\n): TableSchema | null {\n  // replace ${...} with ...\n  let replacedFile = file.replace(/\\${(.*?)}/g, (match, variable) => variable);\n\n  // replace CUBE with MEERKAT\n  replacedFile = replacedFile.replace(/CUBE/g, '{MEERKAT}');\n  const { name, object } = eval(replacedFile);\n  return convertCubeToTableSchema({ name, object });\n}\n\nfunction convertCubeToTableSchema({\n  name,\n  object,\n}: CubeSchema): TableSchema | null {\n  const resObj: TableSchema = {\n    name,\n    sql: object.sql_table,\n    measures: [],\n    dimensions: [],\n  };\n  const dimensions = object.dimensions;\n  const measures = object.measures;\n\n  // convert dimensions and measures\n  for (const key in dimensions) {\n    resObj.dimensions.push({\n      name: key,\n      sql: dimensions[key].sql,\n      type: dimensions[key].type,\n    });\n  }\n  for (const key in measures) {\n    resObj.measures.push({ name: key, ...convertMeasure(measures[key]) });\n  }\n\n  // convert joins\n  if (object.joins && Object.keys(object.joins).length > 0) {\n    resObj.joins = [];\n    for (const joinName in object.joins) {\n      const join = object.joins[joinName];\n      resObj.joins.push({\n        sql: join.sql,\n      });\n    }\n  }\n  return resObj;\n}\ninterface CubeMeasure {\n  sql?: string;\n  type: CubeMeasureType;\n}\n\nfunction convertMeasure(measure: CubeMeasure): Pick<Measure, 'sql' | 'type'> {\n  switch (measure.type) {\n    case 'count':\n      return {\n        sql: measure.sql ? `COUNT(${measure.sql})` : 'COUNT(*)',\n        type: 'number',\n      };\n    case 'count_distinct':\n      return {\n        sql: `COUNT(DISTINCT ${measure.sql})`,\n        type: 'number',\n      };\n    case 'count_distinct_approx':\n      return {\n        sql: `APPROX_COUNT_DISTINCT(${measure.sql})`,\n        type: 'number',\n      };\n    case 'sum':\n      return {\n        sql: `SUM(${measure.sql})`,\n        type: 'number',\n      };\n    case 'avg':\n      return {\n        sql: `AVG(${measure.sql})`,\n        type: 'number',\n      };\n    case 'min':\n      return {\n        sql: `MIN(${measure.sql})`,\n        type: 'number',\n      };\n    case 'max':\n      return {\n        sql: `MAX(${measure.sql})`,\n        type: 'number',\n      };\n    default:\n      return {\n        sql: measure.sql ?? '',\n        type: measure.type,\n      };\n  }\n}\n"],"names":["convertCubeStringToTableSchema","cube","name","object","file","replacedFile","replace","match","variable","eval","convertCubeToTableSchema","resObj","sql","sql_table","measures","dimensions","key","push","type","convertMeasure","joins","Object","keys","length","joinName","join","measure"],"mappings":";+BAsCgBA;;;eAAAA;;;;AADhB,MAAMC,OAAO,CAACC,MAAWC,SAAiB,CAAA;QAAED;QAAMC;IAAO,CAAA;AAClD,SAASH,+BACdI,IAAY;IAEZ,0BAA0B;IAC1B,IAAIC,eAAeD,KAAKE,OAAO,CAAC,cAAc,CAACC,OAAOC,WAAaA;IAEnE,4BAA4B;IAC5BH,eAAeA,aAAaC,OAAO,CAAC,SAAS;IAC7C,MAAM,EAAEJ,IAAI,EAAEC,MAAM,EAAE,GAAGM,KAAKJ;IAC9B,OAAOK,yBAAyB;QAAER;QAAMC;IAAO;AACjD;AAEA,SAASO,yBAAyB,EAChCR,IAAI,EACJC,MAAM,EACK;IACX,MAAMQ,SAAsB;QAC1BT;QACAU,KAAKT,OAAOU,SAAS;QACrBC,UAAU,EAAE;QACZC,YAAY,EAAE;IAChB;IACA,MAAMA,aAAaZ,OAAOY,UAAU;IACpC,MAAMD,WAAWX,OAAOW,QAAQ;IAEhC,kCAAkC;IAClC,IAAK,MAAME,OAAOD,WAAY;QAC5BJ,OAAOI,UAAU,CAACE,IAAI,CAAC;YACrBf,MAAMc;YACNJ,KAAKG,UAAU,CAACC,IAAI,CAACJ,GAAG;YACxBM,MAAMH,UAAU,CAACC,IAAI,CAACE,IAAI;QAC5B;IACF;IACA,IAAK,MAAMF,OAAOF,SAAU;QAC1BH,OAAOG,QAAQ,CAACG,IAAI,CAAC;YAAEf,MAAMc;WAAQG,eAAeL,QAAQ,CAACE,IAAI;IACnE;IAEA,gBAAgB;IAChB,IAAIb,OAAOiB,KAAK,IAAIC,OAAOC,IAAI,CAACnB,OAAOiB,KAAK,EAAEG,MAAM,GAAG,GAAG;QACxDZ,OAAOS,KAAK,GAAG,EAAE;QACjB,IAAK,MAAMI,YAAYrB,OAAOiB,KAAK,CAAE;YACnC,MAAMK,OAAOtB,OAAOiB,KAAK,CAACI,SAAS;YACnCb,OAAOS,KAAK,CAACH,IAAI,CAAC;gBAChBL,KAAKa,KAAKb,GAAG;YACf;QACF;IACF;IACA,OAAOD;AACT;AAMA,SAASQ,eAAeO,OAAoB;IAC1C,OAAQA,QAAQR,IAAI;QAClB,KAAK;YACH,OAAO;gBACLN,KAAKc,QAAQd,GAAG,GAAG,CAAC,MAAM,EAAEc,QAAQd,GAAG,CAAC,CAAC,CAAC,GAAG;gBAC7CM,MAAM;YACR;QACF,KAAK;YACH,OAAO;gBACLN,KAAK,CAAC,eAAe,EAAEc,QAAQd,GAAG,CAAC,CAAC,CAAC;gBACrCM,MAAM;YACR;QACF,KAAK;YACH,OAAO;gBACLN,KAAK,CAAC,sBAAsB,EAAEc,QAAQd,GAAG,CAAC,CAAC,CAAC;gBAC5CM,MAAM;YACR;QACF,KAAK;YACH,OAAO;gBACLN,KAAK,CAAC,IAAI,EAAEc,QAAQd,GAAG,CAAC,CAAC,CAAC;gBAC1BM,MAAM;YACR;QACF,KAAK;YACH,OAAO;gBACLN,KAAK,CAAC,IAAI,EAAEc,QAAQd,GAAG,CAAC,CAAC,CAAC;gBAC1BM,MAAM;YACR;QACF,KAAK;YACH,OAAO;gBACLN,KAAK,CAAC,IAAI,EAAEc,QAAQd,GAAG,CAAC,CAAC,CAAC;gBAC1BM,MAAM;YACR;QACF,KAAK;YACH,OAAO;gBACLN,KAAK,CAAC,IAAI,EAAEc,QAAQd,GAAG,CAAC,CAAC,CAAC;gBAC1BM,MAAM;YACR;QACF;gBAESQ;YADP,OAAO;gBACLd,KAAKc,CAAAA,eAAAA,QAAQd,GAAG,YAAXc,eAAe;gBACpBR,MAAMQ,QAAQR,IAAI;YACpB;IACJ;AACF"}

package/utils/cube-type-to-duckdb-type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/cube-type-to-duckdb-type.ts"],"sourcesContent":["import { DimensionType, MeasureType } from '../types/cube-types';\n\ntype CubeType = DimensionType | MeasureType;\n\nexport const CUBE_TYPE_TO_DUCKDB_TYPE: {\n  [key in CubeType]: string;\n} = {\n  string: 'VARCHAR',\n  number: 'DECIMAL',\n  time: 'VARCHAR',\n  boolean: 'BOOLEAN',\n  string_array: 'VARCHAR[]',\n  number_array: 'DECIMAL[]',\n};\n"],"names":["CUBE_TYPE_TO_DUCKDB_TYPE","string","number","time","boolean","string_array","number_array"],"mappings":";+BAIaA;;;eAAAA;;;AAAN,MAAMA,2BAET;IACFC,QAAQ;IACRC,QAAQ;IACRC,MAAM;IACNC,SAAS;IACTC,cAAc;IACdC,cAAc;AAChB"}

package/utils/find-in-table-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/find-in-table-schema.ts"],"sourcesContent":["import { TableSchema } from \"../types/cube-types\"\n\n\nexport const findInDimensionSchema = (measure: string, tableSchema: TableSchema) => {\n  return tableSchema.dimensions.find(\n    (m) => m.name === measure\n  )\n}\n\nexport const findInMeasureSchema = (measure: string, tableSchema: TableSchema) => {\n  return tableSchema.measures.find(\n    (m) => m.name === measure\n  )\n}\n\nexport const findInSchema = (measure: string, tableSchema: TableSchema) => {\n  /*\n  ** Using the key passed as measureWithoutTable this function searches the table schema.\n  ** It returns either the first dimension or measure found.\n  */\n  const foundDimension = findInDimensionSchema(measure, tableSchema)\n  if (foundDimension) {\n    return foundDimension\n  }\n  const foundMeasure = findInMeasureSchema(measure, tableSchema)\n  if (foundMeasure) {\n    return foundMeasure\n  }\n  return undefined\n}\n"],"names":["findInDimensionSchema","findInMeasureSchema","findInSchema","measure","tableSchema","dimensions","find","m","name","measures","foundDimension","foundMeasure","undefined"],"mappings":";;;;;;;;IAGaA,qBAAqB;eAArBA;;IAMAC,mBAAmB;eAAnBA;;IAMAC,YAAY;eAAZA;;;AAZN,MAAMF,wBAAwB,CAACG,SAAiBC;IACrD,OAAOA,YAAYC,UAAU,CAACC,IAAI,CAChC,CAACC,IAAMA,EAAEC,IAAI,KAAKL;AAEtB;AAEO,MAAMF,sBAAsB,CAACE,SAAiBC;IACnD,OAAOA,YAAYK,QAAQ,CAACH,IAAI,CAC9B,CAACC,IAAMA,EAAEC,IAAI,KAAKL;AAEtB;AAEO,MAAMD,eAAe,CAACC,SAAiBC;IAC5C;;;EAGA,GACA,MAAMM,iBAAiBV,sBAAsBG,SAASC;IACtD,IAAIM,gBAAgB;QAClB,OAAOA;IACT;IACA,MAAMC,eAAeV,oBAAoBE,SAASC;IAClD,IAAIO,cAAc;QAChB,OAAOA;IACT;IACA,OAAOC;AACT"}

package/{src/utils → utils}/get-column-names-from-ast.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "getColumnNamesFromAst", {
         return getColumnNamesFromAst;
     }
 });
-const _constant = require("../cube-filter-transformer/constant");
+const _memberformatters = require("../member-formatters");
 const _utils = require("../types/utils");
 const getColumnNamesFromAst = (node, columnSet = new Set())=>{
     if (!node) return Array.from(columnSet);
@@ -15,7 +15,7 @@ const getColumnNamesFromAst = (node, columnSet = new Set())=>{
         getColumnNamesFromAst(node.upper, columnSet);
     }
     if ((0, _utils.isColumnRefExpression)(node)) {
-        columnSet.add(node.column_names.join(_constant.COLUMN_NAME_DELIMITER));
+        columnSet.add(node.column_names.join(_memberformatters.COLUMN_NAME_DELIMITER));
     }
     if ((0, _utils.isCastExpression)(node) || (0, _utils.isCollateExpression)(node)) {
         getColumnNamesFromAst(node.child, columnSet);

package/utils/get-column-names-from-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/get-column-names-from-ast.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../member-formatters';\nimport { ParsedExpression } from '../types/duckdb-serialization-types';\nimport {\n  isBetweenExpression,\n  isCaseExpression,\n  isCastExpression,\n  isCollateExpression,\n  isColumnRefExpression,\n  isComparisonExpression,\n  isConjunctionExpression,\n  isFunctionExpression,\n  isOperatorExpression,\n  isSelectNode,\n  isSubqueryExpression,\n  isWindowExpression,\n} from '../types/utils';\n\nexport const getColumnNamesFromAst = (\n  node: ParsedExpression,\n  columnSet: Set<string> = new Set()\n): string[] => {\n  if (!node) return Array.from(columnSet);\n\n  if (isBetweenExpression(node)) {\n    getColumnNamesFromAst(node.input, columnSet);\n    getColumnNamesFromAst(node.lower, columnSet);\n    getColumnNamesFromAst(node.upper, columnSet);\n  }\n\n  if (isColumnRefExpression(node)) {\n    columnSet.add(node.column_names.join(COLUMN_NAME_DELIMITER));\n  }\n\n  if (isCastExpression(node) || isCollateExpression(node)) {\n    getColumnNamesFromAst(node.child, columnSet);\n  }\n\n  if (isComparisonExpression(node)) {\n    getColumnNamesFromAst(node.left, columnSet);\n    getColumnNamesFromAst(node.right, columnSet);\n  }\n\n  if (\n    isFunctionExpression(node) ||\n    isWindowExpression(node) ||\n    isOperatorExpression(node) ||\n    isConjunctionExpression(node)\n  ) {\n    node.children.forEach((child) => getColumnNamesFromAst(child, columnSet));\n  }\n\n  if (isCaseExpression(node)) {\n    node.case_checks.forEach((check) => {\n      getColumnNamesFromAst(check.then_expr, columnSet);\n      getColumnNamesFromAst(check.when_expr, columnSet);\n    });\n    getColumnNamesFromAst(node.else_expr, columnSet);\n  }\n\n  if (isSubqueryExpression(node) && isSelectNode(node.subquery.node)) {\n    node.subquery.node.select_list.forEach((node) => {\n      getColumnNamesFromAst(node, columnSet);\n    });\n  }\n\n  return Array.from(columnSet);\n};\n"],"names":["getColumnNamesFromAst","node","columnSet","Set","Array","from","isBetweenExpression","input","lower","upper","isColumnRefExpression","add","column_names","join","COLUMN_NAME_DELIMITER","isCastExpression","isCollateExpression","child","isComparisonExpression","left","right","isFunctionExpression","isWindowExpression","isOperatorExpression","isConjunctionExpression","children","forEach","isCaseExpression","case_checks","check","then_expr","when_expr","else_expr","isSubqueryExpression","isSelectNode","subquery","select_list"],"mappings":";+BAiBaA;;;eAAAA;;;kCAjByB;uBAe/B;AAEA,MAAMA,wBAAwB,CACnCC,MACAC,YAAyB,IAAIC,KAAK;IAElC,IAAI,CAACF,MAAM,OAAOG,MAAMC,IAAI,CAACH;IAE7B,IAAII,IAAAA,0BAAmB,EAACL,OAAO;QAC7BD,sBAAsBC,KAAKM,KAAK,EAAEL;QAClCF,sBAAsBC,KAAKO,KAAK,EAAEN;QAClCF,sBAAsBC,KAAKQ,KAAK,EAAEP;IACpC;IAEA,IAAIQ,IAAAA,4BAAqB,EAACT,OAAO;QAC/BC,UAAUS,GAAG,CAACV,KAAKW,YAAY,CAACC,IAAI,CAACC,uCAAqB;IAC5D;IAEA,IAAIC,IAAAA,uBAAgB,EAACd,SAASe,IAAAA,0BAAmB,EAACf,OAAO;QACvDD,sBAAsBC,KAAKgB,KAAK,EAAEf;IACpC;IAEA,IAAIgB,IAAAA,6BAAsB,EAACjB,OAAO;QAChCD,sBAAsBC,KAAKkB,IAAI,EAAEjB;QACjCF,sBAAsBC,KAAKmB,KAAK,EAAElB;IACpC;IAEA,IACEmB,IAAAA,2BAAoB,EAACpB,SACrBqB,IAAAA,yBAAkB,EAACrB,SACnBsB,IAAAA,2BAAoB,EAACtB,SACrBuB,IAAAA,8BAAuB,EAACvB,OACxB;QACAA,KAAKwB,QAAQ,CAACC,OAAO,CAAC,CAACT,QAAUjB,sBAAsBiB,OAAOf;IAChE;IAEA,IAAIyB,IAAAA,uBAAgB,EAAC1B,OAAO;QAC1BA,KAAK2B,WAAW,CAACF,OAAO,CAAC,CAACG;YACxB7B,sBAAsB6B,MAAMC,SAAS,EAAE5B;YACvCF,sBAAsB6B,MAAME,SAAS,EAAE7B;QACzC;QACAF,sBAAsBC,KAAK+B,SAAS,EAAE9B;IACxC;IAEA,IAAI+B,IAAAA,2BAAoB,EAAChC,SAASiC,IAAAA,mBAAY,EAACjC,KAAKkC,QAAQ,CAAClC,IAAI,GAAG;QAClEA,KAAKkC,QAAQ,CAAClC,IAAI,CAACmC,WAAW,CAACV,OAAO,CAAC,CAACzB;YACtCD,sBAAsBC,MAAMC;QAC9B;IACF;IAEA,OAAOE,MAAMC,IAAI,CAACH;AACpB"}

package/utils/get-possible-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/get-possible-nodes.ts"],"sourcesContent":["import { Graph, checkLoopInJoinPath, createDirectedGraph } from '../joins/joins';\nimport {\n  Dimension,\n  JoinPath,\n  Measure,\n  TableSchema,\n  isJoinNode,\n} from '../types/cube-types';\n\nexport interface NestedMeasure {\n  schema: Measure;\n  children: NestedTableSchema[];\n}\n\nexport interface NestedDimension {\n  schema: Dimension;\n  children: NestedTableSchema[];\n}\n\nexport interface NestedTableSchema {\n  name: string;\n  measures: NestedMeasure[];\n  dimensions: NestedDimension[];\n}\n\nexport const getNestedTableSchema = (\n  tableSchemas: TableSchema[],\n  joinPath: JoinPath[],\n  depth: number\n) => {\n  const tableSchemaSqlMap: { [key: string]: string } = {};\n  for (const schema of tableSchemas) {\n    if (!schema) {\n      throw new Error('Schema is undefined');\n    }\n    tableSchemaSqlMap[schema.name] = schema.sql;\n  }\n\n  const directedGraph = createDirectedGraph(tableSchemas, tableSchemaSqlMap);\n\n  const hasLoop = checkLoopInJoinPath(joinPath);\n  if (hasLoop) {\n    throw new Error('A loop was detected in the joins paths',);\n  }\n  const visitedNodes: { [key: string]: boolean } = {};\n\n  const startingNode = tableSchemas.find(\n    (schema) => schema.name === joinPath[0][0].left\n  ) as TableSchema;\n\n  visitedNodes[startingNode.name] = true;\n\n  const nestedTableSchema: NestedTableSchema = {\n    name: startingNode.name,\n    measures: startingNode.measures.map((measure) => ({\n      schema: measure,\n      children: [],\n    })),\n    dimensions: startingNode.dimensions.map((dimension) => ({\n      schema: dimension,\n      children: [],\n    })),\n  };\n\n  const checkedPaths: { [key: string]: boolean } = {};\n\n  const buildNestedSchema = (\n    edges: JoinPath,\n    index: number,\n    nestedTableSchema: NestedTableSchema,\n    tableSchemas: TableSchema[]\n  ): NestedTableSchema => {\n    const edge = edges[index];\n\n    /**\n     * If there is no right table, return the nested schema immediately\n     * This means there is a single node in the path.\n     */\n\n    if (!isJoinNode(edge)) {\n      return nestedTableSchema;\n    }\n\n    // If the path has been checked before, return the nested schema immediately\n    const pathKey = `${edge.left}-${edge.right}-${edge.on}`;\n    if (checkedPaths[pathKey]) {\n      nestedTableSchema.dimensions.map((dimension) => {\n        dimension.children?.forEach((child) => {\n          if (child.name === edge.right) {\n            return buildNestedSchema(edges, index + 1, child, tableSchemas);\n          }\n          return;\n        });\n      });\n      return nestedTableSchema;\n    }\n\n    const rightSchema = tableSchemas.find(\n      (schema) => schema.name === edge.right\n    ) as TableSchema;\n\n    if (!rightSchema) {\n      throw new Error(`The schema for ${edge.right} does not exist.`);\n    }\n\n    // Mark the path as checked\n    checkedPaths[pathKey] = true;\n\n    const nestedRightSchema: NestedTableSchema = {\n      name: rightSchema.name,\n      measures: (rightSchema.measures || []).map(\n        (measure) => ({ schema: measure, children: [] } as NestedMeasure)\n      ),\n      dimensions: (rightSchema.dimensions || []).map(\n        (dimension) => ({ schema: dimension, children: [] } as NestedDimension)\n      ),\n    };\n\n    const nestedDimension = nestedTableSchema.dimensions.find(\n      (dimension) => dimension.schema.name === edge.on\n    ) as NestedMeasure;\n\n    if (!nestedDimension) {\n      throw new Error(\n        `The dimension ${edge.on} does not exist in the table schema.`\n      );\n    }\n\n    nestedDimension.children?.push(nestedRightSchema);\n\n    // Mark the right schema as visited\n    visitedNodes[rightSchema.name] = true;\n\n    if (index < edges.length - 1) {\n      buildNestedSchema(\n        edges,\n        index + 1,\n        nestedRightSchema as NestedTableSchema,\n        tableSchemas\n      );\n    }\n    return nestedTableSchema;\n  };\n\n  for (let i = 0; i < joinPath.length; i++) {\n    buildNestedSchema(joinPath[i], 0, nestedTableSchema, tableSchemas);\n  }\n\n  getNextPossibleNodes(\n    directedGraph,\n    nestedTableSchema,\n    visitedNodes,\n    tableSchemas,\n    depth\n  );\n\n  return nestedTableSchema;\n};\n\nconst getNextPossibleNodes = (\n  directedGraph: Graph,\n  nestedTableSchema: NestedTableSchema,\n  visitedNodes: { [key: string]: boolean },\n  tableSchemas: TableSchema[],\n  depth: number,\n  currentDepth = 0\n) => {\n  const currentNode = nestedTableSchema.name;\n\n  /**\n   * We are already iterating the next nodes for each dimension. It means we are already at the next level of depth.\n   * So we should return if the current depth is greater than or equal to the depth we want to go to.\n   */\n  if (currentDepth >= depth) {\n    return;\n  }\n\n  /**\n   * Iterating through each dimension of the current node\n   */\n  for (let i = 0; i < nestedTableSchema.dimensions.length; i++) {\n    const dimension = nestedTableSchema.dimensions[i];\n    /**\n     * Gettting the next possible nodes for the current dimension\n     */\n    const nextPossibleNodes = directedGraph[currentNode];\n    if (!nextPossibleNodes) {\n      return;\n    }\n\n    for (const [node] of Object.entries(nextPossibleNodes)) {\n      /**\n       * If the next node is not possible with the current dimension, continue to the next node\n       */\n      if (!nextPossibleNodes[node][dimension.schema.name]) {\n        continue;\n      }\n      const nextSchema = tableSchemas.find(\n        (schema) => schema.name === node\n      ) as TableSchema;\n\n      if (!nextSchema) {\n        throw new Error(`The schema for ${node} does not exist.`);\n      }\n\n      if (!visitedNodes[nextSchema.name]) {\n        const nestedNextSchema: NestedTableSchema = {\n          name: nextSchema.name,\n          measures: nextSchema.measures.map((measure) => ({\n            schema: measure,\n            children: [],\n          })),\n          dimensions: nextSchema.dimensions.map((dimension) => ({\n            schema: dimension,\n            children: [],\n          })),\n        };\n        if (\n          !dimension.children?.some(\n            (child) => child.name === nestedNextSchema.name\n          )\n        ) {\n          dimension.children?.push(nestedNextSchema);\n        }\n      }\n      for (const children of dimension.children || []) {\n        if (visitedNodes[children.name] && currentDepth > 0) {\n          continue;\n        }\n\n        getNextPossibleNodes(\n          directedGraph,\n          children,\n          visitedNodes,\n          tableSchemas,\n          depth,\n          visitedNodes[children.name] ? 0 : currentDepth + 1\n        );\n      }\n    }\n  }\n};\n"],"names":["getNestedTableSchema","tableSchemas","joinPath","depth","tableSchemaSqlMap","schema","Error","name","sql","directedGraph","createDirectedGraph","hasLoop","checkLoopInJoinPath","visitedNodes","startingNode","find","left","nestedTableSchema","measures","map","measure","children","dimensions","dimension","checkedPaths","buildNestedSchema","edges","index","nestedDimension","edge","isJoinNode","pathKey","right","on","forEach","child","rightSchema","nestedRightSchema","push","length","i","getNextPossibleNodes","currentDepth","currentNode","nextPossibleNodes","node","Object","entries","nextSchema","nestedNextSchema","some"],"mappings":"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"}

package/{src/utils → utils}/get-type-info.js

@@ -6,11 +6,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    getTypeInfo: function() {
-        return getTypeInfo;
-    },
     convertFloatToInt: function() {
         return convertFloatToInt;
+    },
+    getTypeInfo: function() {
+        return getTypeInfo;
     }
 });
 function getTypeInfo(num) {

package/utils/get-type-info.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/get-type-info.ts"],"sourcesContent":["export function getTypeInfo(num: number) {\n  const numString = num.toString();\n\n  let width = numString.length;\n  if (numString.includes('.')) {\n    width -= 1; // subtract 1 to exclude the dot from the count of digits\n  }\n\n  /**\n   * If the number is a whole number, then the scale is 0\n   * If the number is a floating point number, then the scale is the number of digits after the decimal\n   */\n  const scale = numString.split('.')[1]?.length || 0;\n\n  const typeInfo = {\n    type: 'DECIMAL_TYPE_INFO',\n    alias: '',\n    width: width,\n    scale: scale,\n  };\n\n  return typeInfo;\n}\n\nexport const convertFloatToInt = (num: number) => {\n  const numString = num.toString();\n\n  //Remove dot from the number string\n  const numStringWithoutDot = numString.replace('.', '');\n\n  //Convert the number string to a number\n  const numWithoutDot = parseInt(numStringWithoutDot);\n\n  return numWithoutDot;\n};\n"],"names":["convertFloatToInt","getTypeInfo","num","numString","toString","width","length","includes","scale","split","typeInfo","type","alias","numStringWithoutDot","replace","numWithoutDot","parseInt"],"mappings":";;;;;;;;IAwBaA,iBAAiB;eAAjBA;;IAxBGC,WAAW;eAAXA;;;AAAT,SAASA,YAAYC,GAAW;QAYvBC;IAXd,MAAMA,YAAYD,IAAIE,QAAQ;IAE9B,IAAIC,QAAQF,UAAUG,MAAM;IAC5B,IAAIH,UAAUI,QAAQ,CAAC,MAAM;QAC3BF,SAAS,GAAG,yDAAyD;IACvE;IAEA;;;GAGC,GACD,MAAMG,QAAQL,EAAAA,oBAAAA,UAAUM,KAAK,CAAC,IAAI,CAAC,EAAE,qBAAvBN,kBAAyBG,MAAM,KAAI;IAEjD,MAAMI,WAAW;QACfC,MAAM;QACNC,OAAO;QACPP,OAAOA;QACPG,OAAOA;IACT;IAEA,OAAOE;AACT;AAEO,MAAMV,oBAAoB,CAACE;IAChC,MAAMC,YAAYD,IAAIE,QAAQ;IAE9B,mCAAmC;IACnC,MAAMS,sBAAsBV,UAAUW,OAAO,CAAC,KAAK;IAEnD,uCAAuC;IACvC,MAAMC,gBAAgBC,SAASH;IAE/B,OAAOE;AACT"}

package/utils/is-array-member-type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/is-array-member-type.ts"],"sourcesContent":["import { DimensionType, MeasureType } from '../types/cube-types';\n\ntype CubeType = DimensionType | MeasureType;\n\nexport const isArrayTypeMember = (type: CubeType) => {\n  return type.endsWith('_array');\n};\n"],"names":["isArrayTypeMember","type","endsWith"],"mappings":";+BAIaA;;;eAAAA;;;AAAN,MAAMA,oBAAoB,CAACC;IAChC,OAAOA,KAAKC,QAAQ,CAAC;AACvB"}

package/{src/utils → utils}/key-from-measures-dimension.js

@@ -5,9 +5,10 @@ Object.defineProperty(exports, "getMemberInfoFromTableSchema", {
         return getMemberInfoFromTableSchema;
     }
 });
+const _splitintodatasourceandfields = require("../member-formatters/split-into-data-source-and-fields");
 const getMemberInfoFromTableSchema = (memberKey, tableSchema)=>{
     let memberInfo;
-    const memberKeyName = memberKey.split('.')[1];
+    const [_, memberKeyName] = (0, _splitintodatasourceandfields.splitIntoDataSourceAndFields)(memberKey);
     /**
    * Finding the table key from the measures.
    */ for(let i = 0; i < tableSchema.measures.length; i++){

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/key-from-measures-dimension.ts"],"sourcesContent":["import { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';\nimport { Dimension, Measure, TableSchema } from '../types/cube-types/table';\n\nexport const getMemberInfoFromTableSchema = (\n  memberKey: string,\n  tableSchema: TableSchema\n) => {\n  let memberInfo: Measure | Dimension | undefined;\n\n  const [_, memberKeyName] = splitIntoDataSourceAndFields(memberKey);\n\n  /**\n   * Finding the table key from the measures.\n   */\n  for (let i = 0; i < tableSchema.measures.length; i++) {\n    const measure = tableSchema.measures[i];\n    const key = measure.name;\n    if (!key || key !== memberKeyName) {\n      continue;\n    }\n\n    memberInfo = measure;\n    return memberInfo;\n  }\n\n  for (let i = 0; i < tableSchema.dimensions.length; i++) {\n    const dimension = tableSchema.dimensions[i];\n    const key = dimension.name;\n\n    if (!key || key !== memberKeyName) {\n      continue;\n    }\n\n    memberInfo = dimension;\n    return memberInfo;\n  }\n  return;\n};\n"],"names":["getMemberInfoFromTableSchema","memberKey","tableSchema","memberInfo","_","memberKeyName","splitIntoDataSourceAndFields","i","measures","length","measure","key","name","dimensions","dimension"],"mappings":";+BAGaA;;;eAAAA;;;8CAHgC;AAGtC,MAAMA,+BAA+B,CAC1CC,WACAC;IAEA,IAAIC;IAEJ,MAAM,CAACC,GAAGC,cAAc,GAAGC,IAAAA,0DAA4B,EAACL;IAExD;;GAEC,GACD,IAAK,IAAIM,IAAI,GAAGA,IAAIL,YAAYM,QAAQ,CAACC,MAAM,EAAEF,IAAK;QACpD,MAAMG,UAAUR,YAAYM,QAAQ,CAACD,EAAE;QACvC,MAAMI,MAAMD,QAAQE,IAAI;QACxB,IAAI,CAACD,OAAOA,QAAQN,eAAe;YACjC;QACF;QAEAF,aAAaO;QACb,OAAOP;IACT;IAEA,IAAK,IAAII,IAAI,GAAGA,IAAIL,YAAYW,UAAU,CAACJ,MAAM,EAAEF,IAAK;QACtD,MAAMO,YAAYZ,YAAYW,UAAU,CAACN,EAAE;QAC3C,MAAMI,MAAMG,UAAUF,IAAI;QAE1B,IAAI,CAACD,OAAOA,QAAQN,eAAe;YACjC;QACF;QAEAF,aAAaW;QACb,OAAOX;IACT;IACA;AACF"}

package/{src/utils → utils}/meerkat-placeholder-replacer.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "meerkatPlaceholderReplacer", {
         return meerkatPlaceholderReplacer;
     }
 });
-const _constants = require("./constants");
+const _constants = require("../member-formatters/constants");
 const meerkatPlaceholderReplacer = (sql, tableName)=>{
     const tableNameEncapsulationRegEx = /\{MEERKAT\}\./g;
     return sql.replace(tableNameEncapsulationRegEx, tableName + _constants.MEERKAT_OUTPUT_DELIMITER);

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/meerkat-placeholder-replacer.ts"],"sourcesContent":["import { MEERKAT_OUTPUT_DELIMITER } from '../member-formatters/constants';\n\nexport const meerkatPlaceholderReplacer = (sql: string, tableName: string) => {\n  const tableNameEncapsulationRegEx = /\\{MEERKAT\\}\\./g;\n  return sql.replace(\n    tableNameEncapsulationRegEx,\n    tableName + MEERKAT_OUTPUT_DELIMITER\n  );\n};\n"],"names":["meerkatPlaceholderReplacer","sql","tableName","tableNameEncapsulationRegEx","replace","MEERKAT_OUTPUT_DELIMITER"],"mappings":";+BAEaA;;;eAAAA;;;2BAF4B;AAElC,MAAMA,6BAA6B,CAACC,KAAaC;IACtD,MAAMC,8BAA8B;IACpC,OAAOF,IAAIG,OAAO,CAChBD,6BACAD,YAAYG,mCAAwB;AAExC"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/modify-meerkat-filter.ts"],"sourcesContent":["import { QueryFiltersWithInfo } from \"../cube-to-duckdb/cube-filter-to-duckdb\";\nimport { QueryFilter } from \"../types/cube-types\";\n\nexport const modifyLeafMeerkatFilter = <T>(filters: QueryFiltersWithInfo, callback: (arg: QueryFilter) => T): T[] | undefined  => {\n  /*\n  ** This function traverse the QueryFiltersWithInfo JSON, and calls the callback for each leaf type.\n  ** This way we need no rewrite the traversal logic again and again.\n  ** The return value of the callback will show up the same path in the resulting object as in the original object\n  */\n  if (!filters) return undefined;\n  return filters.map((item) => {\n    if ('member' in item) {\n      return callback(item)\n    } else {\n      const andPayload: T[] | undefined = 'and' in item ? modifyLeafMeerkatFilter(item.and, callback) : undefined;\n      const orPayload: T[] | undefined = 'or' in item ?  modifyLeafMeerkatFilter(item.or, callback) : undefined;\n      \n      return {\n        ...(andPayload ? { and: andPayload } : {}),\n        ...(orPayload ? { or: orPayload } : {}),\n      } as T\n    }\n  })\n};\n"],"names":["modifyLeafMeerkatFilter","filters","callback","undefined","map","item","andPayload","and","orPayload","or"],"mappings":";+BAGaA;;;eAAAA;;;;AAAN,MAAMA,0BAA0B,CAAIC,SAA+BC;IACxE;;;;EAIA,GACA,IAAI,CAACD,SAAS,OAAOE;IACrB,OAAOF,QAAQG,GAAG,CAAC,CAACC;QAClB,IAAI,YAAYA,MAAM;YACpB,OAAOH,SAASG;QAClB,OAAO;YACL,MAAMC,aAA8B,SAASD,OAAOL,wBAAwBK,KAAKE,GAAG,EAAEL,YAAYC;YAClG,MAAMK,YAA6B,QAAQH,OAAQL,wBAAwBK,KAAKI,EAAE,EAAEP,YAAYC;YAEhG,OAAO,eACDG,aAAa;gBAAEC,KAAKD;YAAW,IAAI,CAAC,GACpCE,YAAY;gBAAEC,IAAID;YAAU,IAAI,CAAC;QAEzC;IACF;AACF"}

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

@@ -6,23 +6,23 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    isLogicalAndOR: function() {
-        return isLogicalAndOR;
+    hasChildren: function() {
+        return hasChildren;
+    },
+    isFilterArray: function() {
+        return isFilterArray;
     },
     isLogicalAnd: function() {
         return isLogicalAnd;
     },
+    isLogicalAndOR: function() {
+        return isLogicalAndOR;
+    },
     isLogicalOr: function() {
         return isLogicalOr;
     },
     isQueryFilter: function() {
         return isQueryFilter;
-    },
-    isFilterArray: function() {
-        return isFilterArray;
-    },
-    hasChildren: function() {
-        return hasChildren;
     }
 });
 function isLogicalAndOR(expression) {

package/utils/type-guards.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/utils/type-guards.ts"],"sourcesContent":["import { LogicalAndFilter, LogicalOrFilter, QueryFilter } from '../types/cube-types/query';\nimport { ConjunctionExpression, ParsedExpression } from '../types/duckdb-serialization-types/serialization/ParsedExpression';\n\nexport function isLogicalAndOR(\n  expression: QueryFilter | LogicalAndFilter | LogicalOrFilter\n): expression is LogicalAndFilter | LogicalOrFilter {\n  if (!expression) {\n    return false;\n  }\n  if (\n    Object.prototype.hasOwnProperty.call(expression, 'and') ||\n    Object.prototype.hasOwnProperty.call(expression, 'or')\n  ) {\n    return true;\n  }\n  return false;\n}\n\nexport function isLogicalAnd(\n  expression: QueryFilter | LogicalAndFilter | LogicalOrFilter\n): expression is LogicalAndFilter {\n  if (!expression) {\n    return false;\n  }\n  if (Object.prototype.hasOwnProperty.call(expression, 'and')) {\n    return true;\n  }\n  return false;\n}\n\nexport function isLogicalOr(\n  expression: QueryFilter | LogicalAndFilter | LogicalOrFilter\n): expression is LogicalOrFilter {\n  if (!expression) {\n    return false;\n  }\n  if (Object.prototype.hasOwnProperty.call(expression, 'or')) {\n    return true;\n  }\n  return false;\n}\n\nexport function isQueryFilter(\n  expression: QueryFilter | LogicalAndFilter | LogicalOrFilter\n): expression is QueryFilter {\n  if (!expression) {\n    return false;\n  }\n  if (Object.prototype.hasOwnProperty.call(expression, 'member')) {\n    return true;\n  }\n  return false;\n}\n\nexport function isFilterArray(\n  expression:\n    | (QueryFilter | LogicalAndFilter | LogicalOrFilter)\n    | (QueryFilter | LogicalAndFilter | LogicalOrFilter)[]\n): expression is (QueryFilter | LogicalAndFilter | LogicalOrFilter)[] {\n  if (!expression) {\n    return false;\n  }\n  if (Array.isArray(expression)) {\n    return true;\n  }\n  return false;\n}\n\nexport function hasChildren(\n  whereObj: ParsedExpression | null\n): whereObj is ConjunctionExpression {\n  if (!whereObj) {\n    return false;\n  }\n  if (Object.prototype.hasOwnProperty.call(whereObj, 'children')) {\n    return true;\n  }\n  return false;\n}\n"],"names":["hasChildren","isFilterArray","isLogicalAnd","isLogicalAndOR","isLogicalOr","isQueryFilter","expression","Object","prototype","hasOwnProperty","call","Array","isArray","whereObj"],"mappings":";;;;;;;;IAoEgBA,WAAW;eAAXA;;IAdAC,aAAa;eAAbA;;IApCAC,YAAY;eAAZA;;IAfAC,cAAc;eAAdA;;IA2BAC,WAAW;eAAXA;;IAYAC,aAAa;eAAbA;;;AAvCT,SAASF,eACdG,UAA4D;IAE5D,IAAI,CAACA,YAAY;QACf,OAAO;IACT;IACA,IACEC,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,YAAY,UACjDC,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,YAAY,OACjD;QACA,OAAO;IACT;IACA,OAAO;AACT;AAEO,SAASJ,aACdI,UAA4D;IAE5D,IAAI,CAACA,YAAY;QACf,OAAO;IACT;IACA,IAAIC,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,YAAY,QAAQ;QAC3D,OAAO;IACT;IACA,OAAO;AACT;AAEO,SAASF,YACdE,UAA4D;IAE5D,IAAI,CAACA,YAAY;QACf,OAAO;IACT;IACA,IAAIC,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,YAAY,OAAO;QAC1D,OAAO;IACT;IACA,OAAO;AACT;AAEO,SAASD,cACdC,UAA4D;IAE5D,IAAI,CAACA,YAAY;QACf,OAAO;IACT;IACA,IAAIC,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACJ,YAAY,WAAW;QAC9D,OAAO;IACT;IACA,OAAO;AACT;AAEO,SAASL,cACdK,UAEwD;IAExD,IAAI,CAACA,YAAY;QACf,OAAO;IACT;IACA,IAAIK,MAAMC,OAAO,CAACN,aAAa;QAC7B,OAAO;IACT;IACA,OAAO;AACT;AAEO,SAASN,YACda,QAAiC;IAEjC,IAAI,CAACA,UAAU;QACb,OAAO;IACT;IACA,IAAIN,OAAOC,SAAS,CAACC,cAAc,CAACC,IAAI,CAACG,UAAU,aAAa;QAC9D,OAAO;IACT;IACA,OAAO;AACT"}

package/src/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 { QueryFiltersWithInfo, QueryFiltersWithInfoSingular } from '../cube-to-duckdb/cube-filter-to-duckdb';\nimport { traverseAndFilter } from '../filter-params/filter-params-ast';\nimport { FilterType, MeerkatQueryFilter, Query } 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\n\nconst formatFilters = (queryFiltersWithInfo: QueryFiltersWithInfo, filterType?: FilterType) => {\n  /*\n  * If the type of filter is set to base filter where \n  */\n  return filterType === 'BASE_FILTER' ? queryFiltersWithInfo : modifyLeafMeerkatFilter(queryFiltersWithInfo, (item) => {\n    return {\n      ...item,\n      member: item.member.split('.').join('__')\n    };\n  }) as QueryFiltersWithInfo;\n}\n\n\nconst getFormattedFilters = ({ queryFiltersWithInfo, filterType, mapperFn, baseAST }: {\n  queryFiltersWithInfo: QueryFiltersWithInfo,\n  filterType?: FilterType,\n  baseAST: SelectStatement,\n  mapperFn: (val: QueryFiltersWithInfoSingular) => MeerkatQueryFilter | null\n}) => {\n  const filters = queryFiltersWithInfo.map(item => mapperFn(item)).filter(Boolean) as QueryFiltersWithInfoSingular[];\n  const formattedFilters = formatFilters(filters, filterType);\n  return cubeFilterToDuckdbAST(\n    formattedFilters,\n    baseAST\n  );\n}\n\nexport const cubeToDuckdbAST = (query: Query, tableSchema: TableSchema, 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) => traverseAndFilter(item, (value) =>  !query.measures.includes(value.member)),\n      queryFiltersWithInfo,\n      filterType: options?.filterType\n    })\n\n    const havingClause = getFormattedFilters({\n      baseAST,\n      mapperFn: (item) => traverseAndFilter(item, (value) =>  query.measures.includes(value.member)),\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 (query.measures.length && query.dimensions && query.dimensions?.length > 0) {\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) {\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","split","join","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","cubeOrderByToAST","limit","offset","cubeLimitOffsetToAST"],"mappings":";+BA0CaA;;;eAAAA;;;;yBA1CyB;wCACI;4CACL;wCACJ;iCAEC;yBAKP;sCACW;qCACE;AAGxC,MAAMC,gBAAgB,CAACC,sBAA4CC;IACjE;;EAEA,GACA,OAAOA,eAAe,gBAAgBD,uBAAuBE,IAAAA,4CAAuB,EAACF,sBAAsB,CAACG;QAC1G,OAAO,eACFA;YACHC,QAAQD,KAAKC,MAAM,CAACC,KAAK,CAAC,KAAKC,IAAI,CAAC;;IAExC;AACF;AAGA,MAAMC,sBAAsB,CAAC,EAAEP,oBAAoB,EAAEC,UAAU,EAAEO,QAAQ,EAAEC,OAAO,EAKjF;IACC,MAAMC,UAAUV,qBAAqBW,GAAG,CAACR,CAAAA,OAAQK,SAASL,OAAOS,MAAM,CAACC;IACxE,MAAMC,mBAAmBf,cAAcW,SAAST;IAChD,OAAOc,IAAAA,8BAAqB,EAC1BD,kBACAL;AAEJ;AAEO,MAAMX,kBAAkB,CAACkB,OAAcC,aAA0BC;QA2CrBF;IAzCjD;;GAEC,GACD,IAAI,CAACC,aAAa;QAChB,OAAO;IACT;IAEA,MAAMR,UAAUU,IAAAA,mBAAU;IAC1B,MAAMC,OAAOX,QAAQW,IAAI;IACzB,IAAIJ,MAAMN,OAAO,IAAIM,MAAMN,OAAO,CAACW,MAAM,GAAG,GAAG;QAC7C;;KAEC,GACD,MAAMrB,uBAAuBsB,IAAAA,2CAAqB,EAChDC,KAAKC,KAAK,CAACD,KAAKE,SAAS,CAACT,MAAMN,OAAO,IACvCO;QAGF,IAAI,CAACjB,sBAAsB;YACzB,OAAO;QACT;QAEA,MAAM0B,cAAcnB,oBAAoB;YACtCE;YACAD,UAAU,CAACL,OAASwB,IAAAA,kCAAiB,EAACxB,MAAM,CAACyB,QAAW,CAACZ,MAAMa,QAAQ,CAACC,QAAQ,CAACF,MAAMxB,MAAM;YAC7FJ;YACAC,UAAU,EAAEiB,2BAAAA,QAASjB,UAAU;QACjC;QAEA,MAAM8B,eAAexB,oBAAoB;YACvCE;YACAD,UAAU,CAACL,OAASwB,IAAAA,kCAAiB,EAACxB,MAAM,CAACyB,QAAWZ,MAAMa,QAAQ,CAACC,QAAQ,CAACF,MAAMxB,MAAM;YAC5FJ;YACAC,UAAU,EAAEiB,2BAAAA,QAASjB,UAAU;QACjC;QAEA,6DAA6D;QAC7D,YAAY;QACZmB,KAAKY,YAAY,GAAGN;QACpBN,KAAKa,MAAM,GAAGF;IAChB;IACA,IAAIf,MAAMa,QAAQ,CAACR,MAAM,IAAIL,MAAMkB,UAAU,IAAIlB,EAAAA,oBAAAA,MAAMkB,UAAU,qBAAhBlB,kBAAkBK,MAAM,IAAG,GAAG;QAC7ED,KAAKe,iBAAiB,GAAGC,IAAAA,iDAAyB,EAACpB,MAAMkB,UAAU;QACnE,MAAMG,YAAY,EAAE;QACpB;;KAEC,GACD,IAAK,IAAIC,IAAI,GAAGA,IAAIlB,KAAKe,iBAAiB,CAACd,MAAM,EAAEiB,IAAK;YACtDD,UAAUE,IAAI,CAACD;QACjB;QACAlB,KAAKoB,UAAU,GAAG;YAACH;SAAU;IAC/B;IACAjB,KAAKqB,SAAS,GAAG,EAAE;IACnB,IAAIzB,MAAM0B,KAAK,EAAE;QACftB,KAAKqB,SAAS,CAACF,IAAI,CAACI,IAAAA,wCAAgB,EAAC3B,MAAM0B,KAAK;IAClD;IACA,IAAI1B,MAAM4B,KAAK,IAAI5B,MAAM6B,MAAM,EAAE;QAC/B,wEAAwE;QACxE,6DAA6D;QAC7D,YAAY;QACZzB,KAAKqB,SAAS,CAACF,IAAI,CAACO,IAAAA,gDAAoB,EAAC9B,MAAM4B,KAAK,EAAE5B,MAAM6B,MAAM;IACpE;IAEA,OAAOpC;AACT"}

package/src/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/src/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/src/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":["validateExpressionNode","validateDimension","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":";;;;;;;;IAeaA,sBAAsB;eAAtBA;;IA8CAC,iBAAiB;eAAjBA;;;uBArDN;wBAEuB;AAKvB,MAAMD,yBAAyB,CACpCE,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,OAAOF,uBAAuBE,KAAKK,KAAK,EAAEJ;IAC5C;IAEA,sBAAsB;IACtB,IAAIK,IAAAA,2BAAoB,EAACN,OAAO;QAC9B,OAAOA,KAAKO,QAAQ,CAACC,KAAK,CAAC,CAACH,QAC1BP,uBAAuBO,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,QAC1BP,uBAAuBO,OAAOJ;IAElC;IAEA,kBAAkB;IAClB,IAAIY,IAAAA,uBAAgB,EAACb,OAAO;QAC1B,OACEA,KAAKc,WAAW,CAACN,KAAK,CAAC,CAACO,QACtBjB,uBAAuBiB,MAAMC,SAAS,EAAEf,oBACrCH,uBAAuBE,KAAKiB,SAAS,EAAEhB;IAEhD;IAEA,MAAM,IAAIW,MAAM,CAAC,yBAAyB,EAAEZ,KAAKkB,IAAI,CAAC,CAAC;AACzD;AAKO,MAAMnB,oBAAoB,CAC/BoB,qBACAlB;IAEA,MAAMD,OAAOoB,IAAAA,qBAAa,EAACD;IAE3B,MAAME,mBAAmB,IAAIC,IAAIrB;IAEjC,0BAA0B;IAC1B,IAAIH,uBAAuBE,MAAMqB,mBAAmB;QAClD,OAAO;IACT;IAEA,MAAM,IAAIT,MAAM;AAClB"}

package/src/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":["validateDimension","validateMeasure","getSelectNode"],"mappings":";;;;;;;;IAASA,iBAAiB;eAAjBA,qCAAiB;;IACjBC,eAAe;eAAfA,iCAAe;;IAEfC,aAAa;eAAbA,oBAAa;;;;oCAHY;kCACF;uBAClB;uBACgB"}

package/src/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":["validateExpressionNode","containsAggregation","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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"}