@devrev/meerkat-core 0.0.77

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

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "getNestedTableSchema", {
+    enumerable: true,
+    get: function() {
+        return getNestedTableSchema;
+    }
+});
+const _joins = require("../joins/joins");
+const _cubetypes = require("../types/cube-types");
+const getNestedTableSchema = (tableSchemas, joinPath, depth)=>{
+    const tableSchemaSqlMap = {};
+    for (const schema of tableSchemas){
+        if (!schema) {
+            throw new Error('Schema is undefined');
+        }
+        tableSchemaSqlMap[schema.name] = schema.sql;
+    }
+    const directedGraph = (0, _joins.createDirectedGraph)(tableSchemas, tableSchemaSqlMap);
+    const hasLoop = (0, _joins.checkLoopInJoinPath)(joinPath);
+    if (hasLoop) {
+        throw new Error('A loop was detected in the joins paths');
+    }
+    const visitedNodes = {};
+    const startingNode = tableSchemas.find((schema)=>schema.name === joinPath[0][0].left);
+    visitedNodes[startingNode.name] = true;
+    const nestedTableSchema = {
+        name: startingNode.name,
+        measures: startingNode.measures.map((measure)=>({
+                schema: measure,
+                children: []
+            })),
+        dimensions: startingNode.dimensions.map((dimension)=>({
+                schema: dimension,
+                children: []
+            }))
+    };
+    const checkedPaths = {};
+    const buildNestedSchema = (edges, index, nestedTableSchema, tableSchemas)=>{
+        var _nestedDimension_children;
+        const edge = edges[index];
+        /**
+     * If there is no right table, return the nested schema immediately
+     * This means there is a single node in the path.
+     */ if (!(0, _cubetypes.isJoinNode)(edge)) {
+            return nestedTableSchema;
+        }
+        // If the path has been checked before, return the nested schema immediately
+        const pathKey = `${edge.left}-${edge.right}-${edge.on}`;
+        if (checkedPaths[pathKey]) {
+            nestedTableSchema.dimensions.map((dimension)=>{
+                var _dimension_children;
+                (_dimension_children = dimension.children) == null ? void 0 : _dimension_children.forEach((child)=>{
+                    if (child.name === edge.right) {
+                        return buildNestedSchema(edges, index + 1, child, tableSchemas);
+                    }
+                    return;
+                });
+            });
+            return nestedTableSchema;
+        }
+        const rightSchema = tableSchemas.find((schema)=>schema.name === edge.right);
+        if (!rightSchema) {
+            throw new Error(`The schema for ${edge.right} does not exist.`);
+        }
+        // Mark the path as checked
+        checkedPaths[pathKey] = true;
+        const nestedRightSchema = {
+            name: rightSchema.name,
+            measures: (rightSchema.measures || []).map((measure)=>({
+                    schema: measure,
+                    children: []
+                })),
+            dimensions: (rightSchema.dimensions || []).map((dimension)=>({
+                    schema: dimension,
+                    children: []
+                }))
+        };
+        const nestedDimension = nestedTableSchema.dimensions.find((dimension)=>dimension.schema.name === edge.on);
+        if (!nestedDimension) {
+            throw new Error(`The dimension ${edge.on} does not exist in the table schema.`);
+        }
+        (_nestedDimension_children = nestedDimension.children) == null ? void 0 : _nestedDimension_children.push(nestedRightSchema);
+        // Mark the right schema as visited
+        visitedNodes[rightSchema.name] = true;
+        if (index < edges.length - 1) {
+            buildNestedSchema(edges, index + 1, nestedRightSchema, tableSchemas);
+        }
+        return nestedTableSchema;
+    };
+    for(let i = 0; i < joinPath.length; i++){
+        buildNestedSchema(joinPath[i], 0, nestedTableSchema, tableSchemas);
+    }
+    getNextPossibleNodes(directedGraph, nestedTableSchema, visitedNodes, tableSchemas, depth);
+    return nestedTableSchema;
+};
+const getNextPossibleNodes = (directedGraph, nestedTableSchema, visitedNodes, tableSchemas, depth, currentDepth = 0)=>{
+    const currentNode = nestedTableSchema.name;
+    /**
+   * We are already iterating the next nodes for each dimension. It means we are already at the next level of depth.
+   * So we should return if the current depth is greater than or equal to the depth we want to go to.
+   */ if (currentDepth >= depth) {
+        return;
+    }
+    /**
+   * Iterating through each dimension of the current node
+   */ for(let i = 0; i < nestedTableSchema.dimensions.length; i++){
+        const dimension = nestedTableSchema.dimensions[i];
+        /**
+     * Gettting the next possible nodes for the current dimension
+     */ const nextPossibleNodes = directedGraph[currentNode];
+        if (!nextPossibleNodes) {
+            return;
+        }
+        for (const [node] of Object.entries(nextPossibleNodes)){
+            /**
+       * If the next node is not possible with the current dimension, continue to the next node
+       */ if (!nextPossibleNodes[node][dimension.schema.name]) {
+                continue;
+            }
+            const nextSchema = tableSchemas.find((schema)=>schema.name === node);
+            if (!nextSchema) {
+                throw new Error(`The schema for ${node} does not exist.`);
+            }
+            if (!visitedNodes[nextSchema.name]) {
+                var _dimension_children;
+                const nestedNextSchema = {
+                    name: nextSchema.name,
+                    measures: nextSchema.measures.map((measure)=>({
+                            schema: measure,
+                            children: []
+                        })),
+                    dimensions: nextSchema.dimensions.map((dimension)=>({
+                            schema: dimension,
+                            children: []
+                        }))
+                };
+                if (!((_dimension_children = dimension.children) == null ? void 0 : _dimension_children.some((child)=>child.name === nestedNextSchema.name))) {
+                    var _dimension_children1;
+                    (_dimension_children1 = dimension.children) == null ? void 0 : _dimension_children1.push(nestedNextSchema);
+                }
+            }
+            for (const children of dimension.children || []){
+                if (visitedNodes[children.name] && currentDepth > 0) {
+                    continue;
+                }
+                getNextPossibleNodes(directedGraph, children, visitedNodes, tableSchemas, depth, visitedNodes[children.name] ? 0 : currentDepth + 1);
+            }
+        }
+    }
+};
+
+//# sourceMappingURL=get-possible-nodes.js.map

package/src/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/get-type-info.d.ts

@@ -0,0 +1,7 @@
+export declare function getTypeInfo(num: number): {
+    type: string;
+    alias: string;
+    width: number;
+    scale: number;
+};
+export declare const convertFloatToInt: (num: number) => number;

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

@@ -0,0 +1,44 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    getTypeInfo: function() {
+        return getTypeInfo;
+    },
+    convertFloatToInt: function() {
+        return convertFloatToInt;
+    }
+});
+function getTypeInfo(num) {
+    var _numString_split_;
+    const numString = num.toString();
+    let width = numString.length;
+    if (numString.includes('.')) {
+        width -= 1; // subtract 1 to exclude the dot from the count of digits
+    }
+    /**
+   * If the number is a whole number, then the scale is 0
+   * If the number is a floating point number, then the scale is the number of digits after the decimal
+   */ const scale = ((_numString_split_ = numString.split('.')[1]) == null ? void 0 : _numString_split_.length) || 0;
+    const typeInfo = {
+        type: 'DECIMAL_TYPE_INFO',
+        alias: '',
+        width: width,
+        scale: scale
+    };
+    return typeInfo;
+}
+const convertFloatToInt = (num)=>{
+    const numString = num.toString();
+    //Remove dot from the number string
+    const numStringWithoutDot = numString.replace('.', '');
+    //Convert the number string to a number
+    const numWithoutDot = parseInt(numStringWithoutDot);
+    return numWithoutDot;
+};
+
+//# sourceMappingURL=get-type-info.js.map

package/src/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":["getTypeInfo","convertFloatToInt","num","numString","toString","width","length","includes","scale","split","typeInfo","type","alias","numStringWithoutDot","replace","numWithoutDot","parseInt"],"mappings":";;;;;;;;IAAgBA,WAAW;eAAXA;;IAwBHC,iBAAiB;eAAjBA;;;AAxBN,SAASD,YAAYE,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,MAAMT,oBAAoB,CAACC;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/src/utils/is-array-member-type.d.ts

@@ -0,0 +1,4 @@
+import { DimensionType, MeasureType } from '../types/cube-types';
+type CubeType = DimensionType | MeasureType;
+export declare const isArrayTypeMember: (type: CubeType) => boolean;
+export {};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "isArrayTypeMember", {
+    enumerable: true,
+    get: function() {
+        return isArrayTypeMember;
+    }
+});
+const isArrayTypeMember = (type)=>{
+    return type.endsWith('_array');
+};
+
+//# sourceMappingURL=is-array-member-type.js.map

package/src/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/key-from-measures-dimension.d.ts

@@ -0,0 +1,2 @@
+import { Measure, TableSchema } from '../types/cube-types/table';
+export declare const getMemberInfoFromTableSchema: (memberKey: string, tableSchema: TableSchema) => Measure | undefined;

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "getMemberInfoFromTableSchema", {
+    enumerable: true,
+    get: function() {
+        return getMemberInfoFromTableSchema;
+    }
+});
+const getMemberInfoFromTableSchema = (memberKey, tableSchema)=>{
+    let memberInfo;
+    const memberKeyName = memberKey.split('.')[1];
+    /**
+   * 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;
+};
+
+//# sourceMappingURL=key-from-measures-dimension.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/utils/key-from-measures-dimension.ts"],"sourcesContent":["import { 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 = memberKey.split('.')[1];\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","split","i","measures","length","measure","key","name","dimensions","dimension"],"mappings":";+BAEaA;;;eAAAA;;;AAAN,MAAMA,+BAA+B,CAC1CC,WACAC;IAEA,IAAIC;IAEJ,MAAMC,gBAAgBH,UAAUI,KAAK,CAAC,IAAI,CAAC,EAAE;IAE7C;;GAEC,GACD,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,YAAYK,QAAQ,CAACC,MAAM,EAAEF,IAAK;QACpD,MAAMG,UAAUP,YAAYK,QAAQ,CAACD,EAAE;QACvC,MAAMI,MAAMD,QAAQE,IAAI;QACxB,IAAI,CAACD,OAAOA,QAAQN,eAAe;YACjC;QACF;QAEAD,aAAaM;QACb,OAAON;IACT;IAEA,IAAK,IAAIG,IAAI,GAAGA,IAAIJ,YAAYU,UAAU,CAACJ,MAAM,EAAEF,IAAK;QACtD,MAAMO,YAAYX,YAAYU,UAAU,CAACN,EAAE;QAC3C,MAAMI,MAAMG,UAAUF,IAAI;QAE1B,IAAI,CAACD,OAAOA,QAAQN,eAAe;YACjC;QACF;QAEAD,aAAaU;QACb,OAAOV;IACT;IACA;AACF"}

package/src/utils/meerkat-placeholder-replacer.d.ts

@@ -0,0 +1 @@
+export declare const meerkatPlaceholderReplacer: (sql: string, tableName: string) => string;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "meerkatPlaceholderReplacer", {
+    enumerable: true,
+    get: function() {
+        return meerkatPlaceholderReplacer;
+    }
+});
+const _constants = require("./constants");
+const meerkatPlaceholderReplacer = (sql, tableName)=>{
+    const tableNameEncapsulationRegEx = /\{MEERKAT\}\./g;
+    return sql.replace(tableNameEncapsulationRegEx, tableName + _constants.MEERKAT_OUTPUT_DELIMITER);
+};
+
+//# sourceMappingURL=meerkat-placeholder-replacer.js.map

package/src/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 \"./constants\";\n\nexport const meerkatPlaceholderReplacer = (sql: string, tableName: string) => {\n    const tableNameEncapsulationRegEx =/\\{MEERKAT\\}\\./g;\n    return sql.replace(tableNameEncapsulationRegEx, tableName + MEERKAT_OUTPUT_DELIMITER )\n}\n"],"names":["meerkatPlaceholderReplacer","sql","tableName","tableNameEncapsulationRegEx","replace","MEERKAT_OUTPUT_DELIMITER"],"mappings":";+BAEaA;;;eAAAA;;;2BAF4B;AAElC,MAAMA,6BAA6B,CAACC,KAAaC;IACpD,MAAMC,8BAA6B;IACnC,OAAOF,IAAIG,OAAO,CAACD,6BAA6BD,YAAYG,mCAAwB;AACxF"}

package/src/utils/member-key-to-safe-key.d.ts

@@ -0,0 +1 @@
+export declare const memberKeyToSafeKey: (memberKey: string) => string;

package/src/utils/member-key-to-safe-key.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "memberKeyToSafeKey", {
+    enumerable: true,
+    get: function() {
+        return memberKeyToSafeKey;
+    }
+});
+const _constants = require("./constants");
+const memberKeyToSafeKey = (memberKey)=>{
+    return memberKey.split(_constants.MEERKAT_INPUT_DELIMITER).join(_constants.MEERKAT_OUTPUT_DELIMITER);
+};
+
+//# sourceMappingURL=member-key-to-safe-key.js.map

package/src/utils/member-key-to-safe-key.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/utils/member-key-to-safe-key.ts"],"sourcesContent":["import { MEERKAT_INPUT_DELIMITER, MEERKAT_OUTPUT_DELIMITER } from \"./constants\";\n\nexport const memberKeyToSafeKey = (memberKey: string) => {\n  return memberKey.split(MEERKAT_INPUT_DELIMITER).join(MEERKAT_OUTPUT_DELIMITER);\n};\n"],"names":["memberKeyToSafeKey","memberKey","split","MEERKAT_INPUT_DELIMITER","join","MEERKAT_OUTPUT_DELIMITER"],"mappings":";+BAEaA;;;eAAAA;;;2BAFqD;AAE3D,MAAMA,qBAAqB,CAACC;IACjC,OAAOA,UAAUC,KAAK,CAACC,kCAAuB,EAAEC,IAAI,CAACC,mCAAwB;AAC/E"}

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

@@ -0,0 +1,3 @@
+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;

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "modifyLeafMeerkatFilter", {
+    enumerable: true,
+    get: function() {
+        return modifyLeafMeerkatFilter;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+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 ? modifyLeafMeerkatFilter(item.and, callback) : undefined;
+            const orPayload = 'or' in item ? modifyLeafMeerkatFilter(item.or, callback) : undefined;
+            return _extends._({}, andPayload ? {
+                and: andPayload
+            } : {}, orPayload ? {
+                or: orPayload
+            } : {});
+        }
+    });
+};
+
+//# sourceMappingURL=modify-meerkat-filter.js.map

package/src/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/type-guards.d.ts

@@ -0,0 +1,8 @@
+import { LogicalAndFilter, LogicalOrFilter, QueryFilter } from '../types/cube-types/query';
+import { ConjunctionExpression, ParsedExpression } from '../types/duckdb-serialization-types/serialization/ParsedExpression';
+export declare function isLogicalAndOR(expression: QueryFilter | LogicalAndFilter | LogicalOrFilter): expression is LogicalAndFilter | LogicalOrFilter;
+export declare function isLogicalAnd(expression: QueryFilter | LogicalAndFilter | LogicalOrFilter): expression is LogicalAndFilter;
+export declare function isLogicalOr(expression: QueryFilter | LogicalAndFilter | LogicalOrFilter): expression is LogicalOrFilter;
+export declare function isQueryFilter(expression: QueryFilter | LogicalAndFilter | LogicalOrFilter): expression is QueryFilter;
+export declare function isFilterArray(expression: (QueryFilter | LogicalAndFilter | LogicalOrFilter) | (QueryFilter | LogicalAndFilter | LogicalOrFilter)[]): expression is (QueryFilter | LogicalAndFilter | LogicalOrFilter)[];
+export declare function hasChildren(whereObj: ParsedExpression | null): whereObj is ConjunctionExpression;

package/src/utils/type-guards.js

@@ -0,0 +1,83 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isLogicalAndOR: function() {
+        return isLogicalAndOR;
+    },
+    isLogicalAnd: function() {
+        return isLogicalAnd;
+    },
+    isLogicalOr: function() {
+        return isLogicalOr;
+    },
+    isQueryFilter: function() {
+        return isQueryFilter;
+    },
+    isFilterArray: function() {
+        return isFilterArray;
+    },
+    hasChildren: function() {
+        return hasChildren;
+    }
+});
+function isLogicalAndOR(expression) {
+    if (!expression) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(expression, 'and') || Object.prototype.hasOwnProperty.call(expression, 'or')) {
+        return true;
+    }
+    return false;
+}
+function isLogicalAnd(expression) {
+    if (!expression) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(expression, 'and')) {
+        return true;
+    }
+    return false;
+}
+function isLogicalOr(expression) {
+    if (!expression) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(expression, 'or')) {
+        return true;
+    }
+    return false;
+}
+function isQueryFilter(expression) {
+    if (!expression) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(expression, 'member')) {
+        return true;
+    }
+    return false;
+}
+function isFilterArray(expression) {
+    if (!expression) {
+        return false;
+    }
+    if (Array.isArray(expression)) {
+        return true;
+    }
+    return false;
+}
+function hasChildren(whereObj) {
+    if (!whereObj) {
+        return false;
+    }
+    if (Object.prototype.hasOwnProperty.call(whereObj, 'children')) {
+        return true;
+    }
+    return false;
+}
+
+//# sourceMappingURL=type-guards.js.map

package/src/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":["isLogicalAndOR","isLogicalAnd","isLogicalOr","isQueryFilter","isFilterArray","hasChildren","expression","Object","prototype","hasOwnProperty","call","Array","isArray","whereObj"],"mappings":";;;;;;;;IAGgBA,cAAc;eAAdA;;IAeAC,YAAY;eAAZA;;IAYAC,WAAW;eAAXA;;IAYAC,aAAa;eAAbA;;IAYAC,aAAa;eAAbA;;IAcAC,WAAW;eAAXA;;;AAjET,SAASL,eACdM,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,SAASL,aACdK,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,SAASJ,YACdI,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,SAASH,cACdG,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,SAASF,cACdE,UAEwD;IAExD,IAAI,CAACA,YAAY;QACf,OAAO;IACT;IACA,IAAIK,MAAMC,OAAO,CAACN,aAAa;QAC7B,OAAO;IACT;IACA,OAAO;AACT;AAEO,SAASD,YACdQ,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"}