@devrev/meerkat-core 0.0.77

package/README.md

@@ -0,0 +1,11 @@
+# meerkat-core
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build meerkat-core` to build the library.
+
+## Running unit tests
+
+Run `nx test meerkat-core` to execute the unit tests via [Jest](https://jestjs.io).

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@devrev/meerkat-core",
+  "version": "0.0.77",
+  "dependencies": {
+    "@swc/helpers": "~0.5.0"
+  },
+  "scripts": {
+    "release": "semantic-release"
+  },
+  "release": {
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/github"
+    ]
+  },
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devrev/meerkat.git"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "keywords": [],
+  "author": "devrev",
+  "license": "ISC"
+}

package/src/ast-builder/ast-builder.d.ts

@@ -0,0 +1,6 @@
+import { FilterType, Query } from '../types/cube-types/query';
+import { TableSchema } from '../types/cube-types/table';
+import { SelectStatement } from '../types/duckdb-serialization-types';
+export declare const cubeToDuckdbAST: (query: Query, tableSchema: TableSchema, options?: {
+    filterType: FilterType;
+}) => SelectStatement | null;

package/src/ast-builder/ast-builder.js

@@ -0,0 +1,89 @@
+"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 _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: item.member.split('.').join('__')
+        });
+    });
+};
+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) {
+        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/src/ast-builder/ast-builder.js.map

@@ -0,0 +1 @@
+{"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.d.ts

@@ -0,0 +1,5 @@
+import { SelectStatement } from '../types/duckdb-serialization-types';
+export declare const astDeserializerQuery: (ast: SelectStatement) => string;
+export declare const deserializeQuery: (queryOutput: {
+    [key: string]: string;
+}[]) => string;

package/src/ast-deserializer/ast-deserializer.js

@@ -0,0 +1,30 @@
+"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/src/ast-deserializer/ast-deserializer.js.map

@@ -0,0 +1 @@
+{"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/context-params/context-params-ast.d.ts

@@ -0,0 +1,11 @@
+import { ContextParams } from '../types/cube-types/table';
+export declare const detectAllContextParams: (sql: string) => {
+    memberKey: string;
+    matchKey: string;
+}[];
+export declare const applyContextParamsToBaseSQL: (baseSQL: string, contextParamsSQL: {
+    memberKey: string;
+    contextParamSQL: string;
+    matchKey: string;
+}[]) => string;
+export declare const detectApplyContextParamsToBaseSQL: (baseSQL: string, contextParams: ContextParams) => string;

package/src/context-params/context-params-ast.js

@@ -0,0 +1,55 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    detectAllContextParams: function() {
+        return detectAllContextParams;
+    },
+    applyContextParamsToBaseSQL: function() {
+        return applyContextParamsToBaseSQL;
+    },
+    detectApplyContextParamsToBaseSQL: function() {
+        return detectApplyContextParamsToBaseSQL;
+    }
+});
+const detectAllContextParams = (sql)=>{
+    const regex = /\$\{CONTEXT_PARAMS\.([^}]*)\}/g;
+    const matches = [];
+    let match;
+    while((match = regex.exec(sql)) !== null){
+        matches.push({
+            memberKey: match[1],
+            matchKey: match[0]
+        });
+    }
+    return matches;
+};
+const applyContextParamsToBaseSQL = (baseSQL, contextParamsSQL)=>{
+    let newSQL = baseSQL;
+    for (const contextParamSQL of contextParamsSQL){
+        // Replace matchKey with contextParamSQL
+        newSQL = newSQL.replace(contextParamSQL.matchKey, contextParamSQL.contextParamSQL);
+    }
+    return newSQL;
+};
+const detectApplyContextParamsToBaseSQL = (baseSQL, contextParams)=>{
+    const contextParamsSQL = [];
+    const contextParamsKeys = detectAllContextParams(baseSQL);
+    for (const contextParamsKey of contextParamsKeys){
+        const contextParamSQL = contextParams[contextParamsKey.memberKey];
+        if (contextParamSQL) {
+            contextParamsSQL.push({
+                memberKey: contextParamsKey.memberKey,
+                matchKey: contextParamsKey.matchKey,
+                contextParamSQL: contextParamSQL
+            });
+        }
+    }
+    return applyContextParamsToBaseSQL(baseSQL, contextParamsSQL);
+};
+
+//# sourceMappingURL=context-params-ast.js.map

package/src/context-params/context-params-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/context-params/context-params-ast.ts"],"sourcesContent":["import { ContextParams } from '../types/cube-types/table';\n\nexport const detectAllContextParams = (\n  sql: string\n): {\n  memberKey: string;\n  matchKey: string;\n}[] => {\n  const regex = /\\$\\{CONTEXT_PARAMS\\.([^}]*)\\}/g;\n  const matches = [];\n  let match;\n\n  while ((match = regex.exec(sql)) !== null) {\n    matches.push({\n      memberKey: match[1],\n      matchKey: match[0],\n    });\n  }\n\n  return matches;\n};\n\nexport const applyContextParamsToBaseSQL = (\n  baseSQL: string,\n  contextParamsSQL: {\n    memberKey: string;\n    contextParamSQL: string;\n    matchKey: string;\n  }[]\n) => {\n  let newSQL = baseSQL;\n  for (const contextParamSQL of contextParamsSQL) {\n    // Replace matchKey with contextParamSQL\n    newSQL = newSQL.replace(\n      contextParamSQL.matchKey,\n      contextParamSQL.contextParamSQL\n    );\n  }\n  return newSQL;\n};\n\nexport const detectApplyContextParamsToBaseSQL = (\n  baseSQL: string,\n  contextParams: ContextParams\n) => {\n  const contextParamsSQL = [];\n  const contextParamsKeys = detectAllContextParams(baseSQL);\n\n  for (const contextParamsKey of contextParamsKeys) {\n    const contextParamSQL = contextParams[contextParamsKey.memberKey];\n    if (contextParamSQL) {\n      contextParamsSQL.push({\n        memberKey: contextParamsKey.memberKey,\n        matchKey: contextParamsKey.matchKey,\n        contextParamSQL: contextParamSQL,\n      });\n    }\n  }\n\n  return applyContextParamsToBaseSQL(baseSQL, contextParamsSQL);\n};\n"],"names":["detectAllContextParams","applyContextParamsToBaseSQL","detectApplyContextParamsToBaseSQL","sql","regex","matches","match","exec","push","memberKey","matchKey","baseSQL","contextParamsSQL","newSQL","contextParamSQL","replace","contextParams","contextParamsKeys","contextParamsKey"],"mappings":";;;;;;;;IAEaA,sBAAsB;eAAtBA;;IAoBAC,2BAA2B;eAA3BA;;IAmBAC,iCAAiC;eAAjCA;;;AAvCN,MAAMF,yBAAyB,CACpCG;IAKA,MAAMC,QAAQ;IACd,MAAMC,UAAU,EAAE;IAClB,IAAIC;IAEJ,MAAO,AAACA,CAAAA,QAAQF,MAAMG,IAAI,CAACJ,IAAG,MAAO,KAAM;QACzCE,QAAQG,IAAI,CAAC;YACXC,WAAWH,KAAK,CAAC,EAAE;YACnBI,UAAUJ,KAAK,CAAC,EAAE;QACpB;IACF;IAEA,OAAOD;AACT;AAEO,MAAMJ,8BAA8B,CACzCU,SACAC;IAMA,IAAIC,SAASF;IACb,KAAK,MAAMG,mBAAmBF,iBAAkB;QAC9C,wCAAwC;QACxCC,SAASA,OAAOE,OAAO,CACrBD,gBAAgBJ,QAAQ,EACxBI,gBAAgBA,eAAe;IAEnC;IACA,OAAOD;AACT;AAEO,MAAMX,oCAAoC,CAC/CS,SACAK;IAEA,MAAMJ,mBAAmB,EAAE;IAC3B,MAAMK,oBAAoBjB,uBAAuBW;IAEjD,KAAK,MAAMO,oBAAoBD,kBAAmB;QAChD,MAAMH,kBAAkBE,aAAa,CAACE,iBAAiBT,SAAS,CAAC;QACjE,IAAIK,iBAAiB;YACnBF,iBAAiBJ,IAAI,CAAC;gBACpBC,WAAWS,iBAAiBT,SAAS;gBACrCC,UAAUQ,iBAAiBR,QAAQ;gBACnCI,iBAAiBA;YACnB;QACF;IACF;IAEA,OAAOb,4BAA4BU,SAASC;AAC9C"}

package/src/cube-filter-transformer/and/and.d.ts

@@ -0,0 +1,2 @@
+import { ConjunctionExpression } from '../../types/duckdb-serialization-types/index';
+export declare const andDuckdbCondition: () => ConjunctionExpression;

package/src/cube-filter-transformer/and/and.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "andDuckdbCondition", {
+    enumerable: true,
+    get: function() {
+        return andDuckdbCondition;
+    }
+});
+const _index = require("../../types/duckdb-serialization-types/index");
+const andDuckdbCondition = ()=>{
+    return {
+        class: _index.ExpressionClass.CONJUNCTION,
+        type: _index.ExpressionType.CONJUNCTION_AND,
+        alias: '',
+        children: []
+    };
+};
+
+//# sourceMappingURL=and.js.map

package/src/cube-filter-transformer/and/and.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/and/and.ts"],"sourcesContent":["import {\n  ConjunctionExpression,\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/index';\n\nexport const andDuckdbCondition = (): ConjunctionExpression => {\n  return {\n    class: ExpressionClass.CONJUNCTION,\n    type: ExpressionType.CONJUNCTION_AND,\n    alias: '',\n    children: [],\n  };\n};\n"],"names":["andDuckdbCondition","class","ExpressionClass","CONJUNCTION","type","ExpressionType","CONJUNCTION_AND","alias","children"],"mappings":";+BAMaA;;;eAAAA;;;uBAFN;AAEA,MAAMA,qBAAqB;IAChC,OAAO;QACLC,OAAOC,sBAAe,CAACC,WAAW;QAClCC,MAAMC,qBAAc,CAACC,eAAe;QACpCC,OAAO;QACPC,UAAU,EAAE;IACd;AACF"}

package/src/cube-filter-transformer/base-condition-builder/base-condition-builder.d.ts

@@ -0,0 +1,154 @@
+import { Dimension, Measure } from '../../types/cube-types/index';
+import { ExpressionClass, ExpressionType, QueryNodeType, SubqueryType } from '../../types/duckdb-serialization-types/index';
+export declare const baseDuckdbCondition: (columnName: string, type: ExpressionType, value: string, memberInfo: Measure | Dimension) => {
+    class: ExpressionClass;
+    type: ExpressionType;
+    alias: string;
+    left: {
+        class: ExpressionClass;
+        type: ExpressionType;
+        alias: string;
+        column_names: string[];
+    };
+    right: {
+        class: ExpressionClass;
+        type: ExpressionType;
+        alias: string;
+        value: {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: string;
+        } | {
+            type: {
+                id: string;
+                type_info: {
+                    type: string;
+                    alias: string;
+                    width: number;
+                    scale: number;
+                };
+            };
+            is_null: boolean;
+            value: number;
+        } | {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: boolean;
+        };
+    };
+};
+export declare const baseArrayDuckdbCondition: (columnName: string, type: ExpressionType, value: string, memberInfo: Measure | Dimension) => {
+    class: ExpressionClass;
+    type: ExpressionType;
+    alias: string;
+    subquery_type: SubqueryType;
+    subquery: {
+        node: {
+            type: QueryNodeType;
+            modifiers: never[];
+            cte_map: {
+                map: never[];
+            };
+            select_list: {
+                class: ExpressionClass;
+                type: ExpressionType;
+                alias: string;
+                function_name: string;
+                schema: string;
+                children: {
+                    class: ExpressionClass;
+                    type: ExpressionType;
+                    alias: string;
+                    column_names: string[];
+                }[];
+                filter: null;
+                order_bys: {
+                    type: string;
+                    orders: never[];
+                };
+                distinct: boolean;
+                is_operator: boolean;
+                export_state: boolean;
+                catalog: string;
+            }[];
+            from_table: {
+                type: string;
+                alias: string;
+                sample: null;
+            };
+            where_clause: null;
+            group_expressions: never[];
+            group_sets: never[];
+            aggregate_handling: string;
+            having: null;
+            sample: null;
+            qualify: null;
+        };
+    };
+    child: {
+        class: string;
+        type: string;
+        alias: string;
+        value: {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: string;
+        } | {
+            type: {
+                id: string;
+                type_info: {
+                    type: string;
+                    alias: string;
+                    width: number;
+                    scale: number;
+                };
+            };
+            is_null: boolean;
+            value: number;
+        } | {
+            type: {
+                id: string;
+                type_info: null;
+            };
+            is_null: boolean;
+            value: boolean;
+        };
+    };
+    comparison_type: ExpressionType;
+};
+export declare const valueBuilder: (value: string, memberInfo: Measure | Dimension) => {
+    type: {
+        id: string;
+        type_info: null;
+    };
+    is_null: boolean;
+    value: string;
+} | {
+    type: {
+        id: string;
+        type_info: {
+            type: string;
+            alias: string;
+            width: number;
+            scale: number;
+        };
+    };
+    is_null: boolean;
+    value: number;
+} | {
+    type: {
+        id: string;
+        type_info: null;
+    };
+    is_null: boolean;
+    value: boolean;
+};

package/src/cube-filter-transformer/base-condition-builder/base-condition-builder.js

@@ -0,0 +1,159 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    baseDuckdbCondition: function() {
+        return baseDuckdbCondition;
+    },
+    baseArrayDuckdbCondition: function() {
+        return baseArrayDuckdbCondition;
+    },
+    valueBuilder: function() {
+        return valueBuilder;
+    }
+});
+const _index = require("../../types/duckdb-serialization-types/index");
+const _cubetypetoduckdbtype = require("../../utils/cube-type-to-duckdb-type");
+const _gettypeinfo = require("../../utils/get-type-info");
+const baseDuckdbCondition = (columnName, type, value, memberInfo)=>{
+    return {
+        class: _index.ExpressionClass.COMPARISON,
+        type: type,
+        alias: '',
+        left: {
+            class: _index.ExpressionClass.COLUMN_REF,
+            type: _index.ExpressionType.COLUMN_REF,
+            alias: '',
+            column_names: columnName.split('.')
+        },
+        right: {
+            class: _index.ExpressionClass.CONSTANT,
+            type: _index.ExpressionType.VALUE_CONSTANT,
+            alias: '',
+            value: valueBuilder(value, memberInfo)
+        }
+    };
+};
+const baseArrayDuckdbCondition = (columnName, type, value, memberInfo)=>{
+    return {
+        class: _index.ExpressionClass.SUBQUERY,
+        type: _index.ExpressionType.SUBQUERY,
+        alias: '',
+        subquery_type: _index.SubqueryType.ANY,
+        subquery: {
+            node: {
+                type: _index.QueryNodeType.SELECT_NODE,
+                modifiers: [],
+                cte_map: {
+                    map: []
+                },
+                select_list: [
+                    {
+                        class: _index.ExpressionClass.FUNCTION,
+                        type: _index.ExpressionType.FUNCTION,
+                        alias: '',
+                        function_name: 'unnest',
+                        schema: '',
+                        children: [
+                            {
+                                class: _index.ExpressionClass.COLUMN_REF,
+                                type: _index.ExpressionType.COLUMN_REF,
+                                alias: '',
+                                column_names: columnName.split('.')
+                            }
+                        ],
+                        filter: null,
+                        order_bys: {
+                            type: 'ORDER_MODIFIER',
+                            orders: []
+                        },
+                        distinct: false,
+                        is_operator: false,
+                        export_state: false,
+                        catalog: ''
+                    }
+                ],
+                from_table: {
+                    type: 'EMPTY',
+                    alias: '',
+                    sample: null
+                },
+                where_clause: null,
+                group_expressions: [],
+                group_sets: [],
+                aggregate_handling: 'STANDARD_HANDLING',
+                having: null,
+                sample: null,
+                qualify: null
+            }
+        },
+        child: {
+            class: 'CONSTANT',
+            type: 'VALUE_CONSTANT',
+            alias: '',
+            value: valueBuilder(value, memberInfo)
+        },
+        comparison_type: type
+    };
+};
+const valueBuilder = (value, memberInfo)=>{
+    switch(memberInfo.type){
+        case 'string':
+            return {
+                type: {
+                    id: _cubetypetoduckdbtype.CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],
+                    type_info: null
+                },
+                is_null: false,
+                value: value
+            };
+        case 'number':
+            {
+                const parsedValue = parseFloat(value);
+                return {
+                    type: {
+                        id: _cubetypetoduckdbtype.CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],
+                        type_info: (0, _gettypeinfo.getTypeInfo)(parsedValue)
+                    },
+                    is_null: false,
+                    value: (0, _gettypeinfo.convertFloatToInt)(parsedValue)
+                };
+            }
+        case 'boolean':
+            {
+                const parsedValue = value === 'true';
+                return {
+                    type: {
+                        id: _cubetypetoduckdbtype.CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],
+                        type_info: null
+                    },
+                    is_null: false,
+                    value: parsedValue
+                };
+            }
+        case 'time':
+            return {
+                type: {
+                    id: _cubetypetoduckdbtype.CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],
+                    type_info: null
+                },
+                is_null: false,
+                value: value
+            };
+        default:
+            return {
+                type: {
+                    id: _cubetypetoduckdbtype.CUBE_TYPE_TO_DUCKDB_TYPE.string,
+                    type_info: null
+                },
+                is_null: false,
+                value: value
+            };
+    }
+};
+
+//# sourceMappingURL=base-condition-builder.js.map

package/src/cube-filter-transformer/base-condition-builder/base-condition-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../meerkat-core/src/cube-filter-transformer/base-condition-builder/base-condition-builder.ts"],"sourcesContent":["import { Dimension, Measure } from '../../types/cube-types/index';\n\nimport {\n  ExpressionClass,\n  ExpressionType,\n  QueryNodeType,\n  SubqueryType,\n} from '../../types/duckdb-serialization-types/index';\nimport { CUBE_TYPE_TO_DUCKDB_TYPE } from '../../utils/cube-type-to-duckdb-type';\nimport { convertFloatToInt, getTypeInfo } from '../../utils/get-type-info';\n\nexport const baseDuckdbCondition = (\n  columnName: string,\n  type: ExpressionType,\n  value: string,\n  memberInfo: Measure | Dimension\n) => {\n  return {\n    class: ExpressionClass.COMPARISON,\n    type: type,\n    alias: '',\n    left: {\n      class: ExpressionClass.COLUMN_REF,\n      type: ExpressionType.COLUMN_REF,\n      alias: '',\n      column_names: columnName.split('.'),\n    },\n    right: {\n      class: ExpressionClass.CONSTANT,\n      type: ExpressionType.VALUE_CONSTANT,\n      alias: '',\n      value: valueBuilder(value, memberInfo),\n    },\n  };\n};\n\nexport const baseArrayDuckdbCondition = (\n  columnName: string,\n  type: ExpressionType,\n  value: string,\n  memberInfo: Measure | Dimension\n) => {\n  return {\n    class: ExpressionClass.SUBQUERY,\n    type: ExpressionType.SUBQUERY,\n    alias: '',\n    subquery_type: SubqueryType.ANY,\n    subquery: {\n      node: {\n        type: QueryNodeType.SELECT_NODE,\n        modifiers: [],\n        cte_map: {\n          map: [],\n        },\n        select_list: [\n          {\n            class: ExpressionClass.FUNCTION,\n            type: ExpressionType.FUNCTION,\n            alias: '',\n            function_name: 'unnest',\n            schema: '',\n            children: [\n              {\n                class: ExpressionClass.COLUMN_REF,\n                type: ExpressionType.COLUMN_REF,\n                alias: '',\n                column_names: columnName.split('.'),\n              },\n            ],\n            filter: null,\n            order_bys: {\n              type: 'ORDER_MODIFIER',\n              orders: [],\n            },\n            distinct: false,\n            is_operator: false,\n            export_state: false,\n            catalog: '',\n          },\n        ],\n        from_table: {\n          type: 'EMPTY',\n          alias: '',\n          sample: null,\n        },\n        where_clause: null,\n        group_expressions: [],\n        group_sets: [],\n        aggregate_handling: 'STANDARD_HANDLING',\n        having: null,\n        sample: null,\n        qualify: null,\n      },\n    },\n    child: {\n      class: 'CONSTANT',\n      type: 'VALUE_CONSTANT',\n      alias: '',\n      value: valueBuilder(value, memberInfo),\n    },\n    comparison_type: type,\n  };\n};\n\nexport const valueBuilder = (\n  value: string,\n  memberInfo: Measure | Dimension\n) => {\n  switch (memberInfo.type) {\n    case 'string':\n      return {\n        type: {\n          id: CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],\n          type_info: null,\n        },\n        is_null: false,\n        value: value,\n      };\n\n    case 'number': {\n      const parsedValue = parseFloat(value);\n      return {\n        type: {\n          id: CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],\n          type_info: getTypeInfo(parsedValue),\n        },\n        is_null: false,\n        value: convertFloatToInt(parsedValue),\n      };\n    }\n    case 'boolean': {\n      const parsedValue = value === 'true';\n      return {\n        type: {\n          id: CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],\n          type_info: null,\n        },\n        is_null: false,\n        value: parsedValue,\n      };\n    }\n    case 'time':\n      return {\n        type: {\n          id: CUBE_TYPE_TO_DUCKDB_TYPE[memberInfo.type],\n          type_info: null,\n        },\n        is_null: false,\n        value: value,\n      };\n\n    default:\n      return {\n        type: {\n          id: CUBE_TYPE_TO_DUCKDB_TYPE.string,\n          type_info: null,\n        },\n        is_null: false,\n        value: value,\n      };\n  }\n};\n"],"names":["baseDuckdbCondition","baseArrayDuckdbCondition","valueBuilder","columnName","type","value","memberInfo","class","ExpressionClass","COMPARISON","alias","left","COLUMN_REF","ExpressionType","column_names","split","right","CONSTANT","VALUE_CONSTANT","SUBQUERY","subquery_type","SubqueryType","ANY","subquery","node","QueryNodeType","SELECT_NODE","modifiers","cte_map","map","select_list","FUNCTION","function_name","schema","children","filter","order_bys","orders","distinct","is_operator","export_state","catalog","from_table","sample","where_clause","group_expressions","group_sets","aggregate_handling","having","qualify","child","comparison_type","id","CUBE_TYPE_TO_DUCKDB_TYPE","type_info","is_null","parsedValue","parseFloat","getTypeInfo","convertFloatToInt","string"],"mappings":"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"}