@devrev/meerkat-core 0.0.96 → 0.0.98

package/cube-filter-transformer/contains/contains.js

@@ -1,71 +0,0 @@
-"use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    containsDuckdbCondition: function() {
-        return containsDuckdbCondition;
-    },
-    containsTransform: function() {
-        return containsTransform;
-    }
-});
-const _constants = require("../../member-formatters/constants");
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const _or = require("../or/or");
-const containsDuckdbCondition = (columnName, value, memberInfo)=>{
-    return {
-        class: _Expression.ExpressionClass.FUNCTION,
-        type: _Expression.ExpressionType.FUNCTION,
-        alias: '',
-        function_name: '~~*',
-        schema: '',
-        children: [
-            {
-                class: 'COLUMN_REF',
-                type: 'COLUMN_REF',
-                alias: '',
-                column_names: columnName.split(_constants.COLUMN_NAME_DELIMITER)
-            },
-            {
-                class: 'CONSTANT',
-                type: 'VALUE_CONSTANT',
-                alias: '',
-                value: (0, _baseconditionbuilder.valueBuilder)(`%${value}%`, memberInfo)
-            }
-        ],
-        filter: null,
-        order_bys: {
-            type: 'ORDER_MODIFIER',
-            orders: []
-        },
-        distinct: false,
-        is_operator: true,
-        export_state: false,
-        catalog: ''
-    };
-};
-const containsTransform = (query)=>{
-    const { member, values, memberInfo } = query;
-    if (!values || values.length === 0) {
-        throw new Error('Contains filter must have at least one value');
-    }
-    /**
-   * If there is only one value, we can create a simple Contains condition
-   */ if (values.length === 1) {
-        return containsDuckdbCondition(member, values[0], memberInfo);
-    }
-    /**
-   * If there are multiple values, we need to create an OR condition
-   */ const orCondition = (0, _or.orDuckdbCondition)();
-    values.forEach((value)=>{
-        orCondition.children.push(containsDuckdbCondition(member, value, memberInfo));
-    });
-    return orCondition;
-};
-
-//# sourceMappingURL=contains.js.map

package/cube-filter-transformer/contains/contains.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/contains/contains.ts"],"sourcesContent":["import { Member, QueryFilter } from '../../types/cube-types/query';\nimport { Dimension, Measure } from '../../types/cube-types/table';\n\nimport { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport interface ContainsFilters extends QueryFilter {\n  member: Member;\n  operator: 'contains';\n  values: string[];\n}\n\nexport const containsDuckdbCondition = (\n  columnName: string,\n  value: string,\n  memberInfo: Measure | Dimension\n) => {\n  return {\n    class: ExpressionClass.FUNCTION,\n    type: ExpressionType.FUNCTION,\n    alias: '',\n    function_name: '~~*',\n    schema: '',\n    children: [\n      {\n        class: 'COLUMN_REF',\n        type: 'COLUMN_REF',\n        alias: '',\n        column_names: columnName.split(COLUMN_NAME_DELIMITER),\n      },\n      {\n        class: 'CONSTANT',\n        type: 'VALUE_CONSTANT',\n        alias: '',\n        value: valueBuilder(`%${value}%`, memberInfo),\n      },\n    ],\n    filter: null,\n    order_bys: {\n      type: 'ORDER_MODIFIER',\n      orders: [],\n    },\n    distinct: false,\n    is_operator: true,\n    export_state: false,\n    catalog: '',\n  };\n};\n\nexport const containsTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('Contains filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple Contains condition\n   */\n  if (values.length === 1) {\n    return containsDuckdbCondition(member, values[0], memberInfo);\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      containsDuckdbCondition(member, value, memberInfo)\n    );\n  });\n  return orCondition;\n};\n"],"names":["containsDuckdbCondition","containsTransform","columnName","value","memberInfo","class","ExpressionClass","FUNCTION","type","ExpressionType","alias","function_name","schema","children","column_names","split","COLUMN_NAME_DELIMITER","valueBuilder","filter","order_bys","orders","distinct","is_operator","export_state","catalog","query","member","values","length","Error","orCondition","orDuckdbCondition","forEach","push"],"mappings":";;;;;;;;IAkBaA,uBAAuB;eAAvBA;;IAqCAC,iBAAiB;eAAjBA;;;2BApDyB;4BAI/B;sCACsB;oBAEK;AAQ3B,MAAMD,0BAA0B,CACrCE,YACAC,OACAC;IAEA,OAAO;QACLC,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACF,QAAQ;QAC7BG,OAAO;QACPC,eAAe;QACfC,QAAQ;QACRC,UAAU;YACR;gBACER,OAAO;gBACPG,MAAM;gBACNE,OAAO;gBACPI,cAAcZ,WAAWa,KAAK,CAACC,gCAAqB;YACtD;YACA;gBACEX,OAAO;gBACPG,MAAM;gBACNE,OAAO;gBACPP,OAAOc,IAAAA,kCAAY,EAAC,CAAC,CAAC,EAAEd,MAAM,CAAC,CAAC,EAAEC;YACpC;SACD;QACDc,QAAQ;QACRC,WAAW;YACTX,MAAM;YACNY,QAAQ,EAAE;QACZ;QACAC,UAAU;QACVC,aAAa;QACbC,cAAc;QACdC,SAAS;IACX;AACF;AAEO,MAAMvB,oBAAoD,CAACwB;IAChE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAEvB,UAAU,EAAE,GAAGqB;IAEvC,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAO5B,wBAAwB0B,QAAQC,MAAM,CAAC,EAAE,EAAEvB;IACpD;IAEA;;GAEC,GACD,MAAM0B,cAAcC,IAAAA,qBAAiB;IACrCJ,OAAOK,OAAO,CAAC,CAAC7B;QACd2B,YAAYjB,QAAQ,CAACoB,IAAI,CACvBjC,wBAAwB0B,QAAQvB,OAAOC;IAE3C;IACA,OAAO0B;AACT"}

package/cube-filter-transformer/equals/equals-array.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "equalsArrayTransform", {
-    enumerable: true,
-    get: function() {
-        return equalsArrayTransform;
-    }
-});
-const _constants = require("../../member-formatters/constants");
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _ResultModifier = require("../../types/duckdb-serialization-types/serialization/ResultModifier");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const equalsDuckDbCondition = (columnName, values, memberInfo)=>{
-    const columnRef = {
-        class: _Expression.ExpressionClass.COLUMN_REF,
-        type: _Expression.ExpressionType.COLUMN_REF,
-        alias: '',
-        column_names: columnName.split(_constants.COLUMN_NAME_DELIMITER)
-    };
-    const sqlTreeValues = values.map((value)=>{
-        const children = {
-            class: _Expression.ExpressionClass.CONSTANT,
-            type: _Expression.ExpressionType.VALUE_CONSTANT,
-            alias: '',
-            value: (0, _baseconditionbuilder.valueBuilder)(value, memberInfo)
-        };
-        return children;
-    });
-    const filterValuesArray = {
-        class: _Expression.ExpressionClass.FUNCTION,
-        type: _Expression.ExpressionType.FUNCTION,
-        alias: '',
-        function_name: 'list_value',
-        schema: 'main',
-        children: sqlTreeValues,
-        filter: null,
-        order_bys: {
-            type: _ResultModifier.ResultModifierType.ORDER_MODIFIER,
-            orders: []
-        },
-        distinct: false,
-        is_operator: false,
-        export_state: false,
-        catalog: ''
-    };
-    const sqlTree = {
-        class: _Expression.ExpressionClass.FUNCTION,
-        type: _Expression.ExpressionType.FUNCTION,
-        alias: '',
-        function_name: 'list_has_all',
-        schema: '',
-        children: [
-            columnRef,
-            filterValuesArray
-        ],
-        filter: null,
-        order_bys: {
-            type: _ResultModifier.ResultModifierType.ORDER_MODIFIER,
-            orders: []
-        },
-        distinct: false,
-        is_operator: false,
-        export_state: false,
-        catalog: ''
-    };
-    return sqlTree;
-};
-const equalsArrayTransform = (query)=>{
-    const { member, values, memberInfo } = query;
-    /**
-   * If there is only one value, we can create a simple equals condition
-   */ if (!values) {
-        throw new Error('In filter must have at least one value');
-    }
-    return equalsDuckDbCondition(member, values, memberInfo);
-};
-
-//# sourceMappingURL=equals-array.js.map

package/cube-filter-transformer/equals/equals-array.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/equals/equals-array.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport { Dimension, Measure } from '../../types/cube-types/table';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { ResultModifierType } from '../../types/duckdb-serialization-types/serialization/ResultModifier';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nconst equalsDuckDbCondition = (\n  columnName: string,\n  values: string[],\n  memberInfo: Measure | Dimension\n) => {\n  const columnRef = {\n    class: ExpressionClass.COLUMN_REF,\n    type: ExpressionType.COLUMN_REF,\n    alias: '',\n    column_names: columnName.split(COLUMN_NAME_DELIMITER),\n  };\n\n  const sqlTreeValues = values.map((value) => {\n    const children = {\n      class: ExpressionClass.CONSTANT,\n      type: ExpressionType.VALUE_CONSTANT,\n      alias: '',\n      value: valueBuilder(value, memberInfo),\n    };\n    return children;\n  });\n\n  const filterValuesArray = {\n    class: ExpressionClass.FUNCTION,\n    type: ExpressionType.FUNCTION,\n    alias: '',\n    function_name: 'list_value',\n    schema: 'main',\n    children: sqlTreeValues,\n    filter: null,\n    order_bys: {\n      type: ResultModifierType.ORDER_MODIFIER,\n      orders: [],\n    },\n    distinct: false,\n    is_operator: false,\n    export_state: false,\n    catalog: '',\n  };\n\n  const sqlTree = {\n    class: ExpressionClass.FUNCTION,\n    type: ExpressionType.FUNCTION,\n    alias: '',\n    function_name: 'list_has_all',\n    schema: '',\n    children: [columnRef, filterValuesArray],\n    filter: null,\n    order_bys: {\n      type: ResultModifierType.ORDER_MODIFIER,\n      orders: [],\n    },\n    distinct: false,\n    is_operator: false,\n    export_state: false,\n    catalog: '',\n  };\n  return sqlTree;\n};\n\nexport const equalsArrayTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (!values) {\n    throw new Error('In filter must have at least one value');\n  }\n  return equalsDuckDbCondition(member, values, memberInfo);\n};\n"],"names":["equalsArrayTransform","equalsDuckDbCondition","columnName","values","memberInfo","columnRef","class","ExpressionClass","COLUMN_REF","type","ExpressionType","alias","column_names","split","COLUMN_NAME_DELIMITER","sqlTreeValues","map","value","children","CONSTANT","VALUE_CONSTANT","valueBuilder","filterValuesArray","FUNCTION","function_name","schema","filter","order_bys","ResultModifierType","ORDER_MODIFIER","orders","distinct","is_operator","export_state","catalog","sqlTree","query","member","Error"],"mappings":";+BAsEaA;;;eAAAA;;;2BAtEyB;4BAK/B;gCAC4B;sCACN;AAG7B,MAAMC,wBAAwB,CAC5BC,YACAC,QACAC;IAEA,MAAMC,YAAY;QAChBC,OAAOC,2BAAe,CAACC,UAAU;QACjCC,MAAMC,0BAAc,CAACF,UAAU;QAC/BG,OAAO;QACPC,cAAcV,WAAWW,KAAK,CAACC,gCAAqB;IACtD;IAEA,MAAMC,gBAAgBZ,OAAOa,GAAG,CAAC,CAACC;QAChC,MAAMC,WAAW;YACfZ,OAAOC,2BAAe,CAACY,QAAQ;YAC/BV,MAAMC,0BAAc,CAACU,cAAc;YACnCT,OAAO;YACPM,OAAOI,IAAAA,kCAAY,EAACJ,OAAOb;QAC7B;QACA,OAAOc;IACT;IAEA,MAAMI,oBAAoB;QACxBhB,OAAOC,2BAAe,CAACgB,QAAQ;QAC/Bd,MAAMC,0BAAc,CAACa,QAAQ;QAC7BZ,OAAO;QACPa,eAAe;QACfC,QAAQ;QACRP,UAAUH;QACVW,QAAQ;QACRC,WAAW;YACTlB,MAAMmB,kCAAkB,CAACC,cAAc;YACvCC,QAAQ,EAAE;QACZ;QACAC,UAAU;QACVC,aAAa;QACbC,cAAc;QACdC,SAAS;IACX;IAEA,MAAMC,UAAU;QACd7B,OAAOC,2BAAe,CAACgB,QAAQ;QAC/Bd,MAAMC,0BAAc,CAACa,QAAQ;QAC7BZ,OAAO;QACPa,eAAe;QACfC,QAAQ;QACRP,UAAU;YAACb;YAAWiB;SAAkB;QACxCI,QAAQ;QACRC,WAAW;YACTlB,MAAMmB,kCAAkB,CAACC,cAAc;YACvCC,QAAQ,EAAE;QACZ;QACAC,UAAU;QACVC,aAAa;QACbC,cAAc;QACdC,SAAS;IACX;IACA,OAAOC;AACT;AAEO,MAAMnC,uBAAuD,CAACoC;IACnE,MAAM,EAAEC,MAAM,EAAElC,MAAM,EAAEC,UAAU,EAAE,GAAGgC;IACvC;;GAEC,GACD,IAAI,CAACjC,QAAQ;QACX,MAAM,IAAImC,MAAM;IAClB;IACA,OAAOrC,sBAAsBoC,QAAQlC,QAAQC;AAC/C"}

package/cube-filter-transformer/equals/equals.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "equalsTransform", {
-    enumerable: true,
-    get: function() {
-        return equalsTransform;
-    }
-});
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _isarraymembertype = require("../../utils/is-array-member-type");
-const _and = require("../and/and");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const _equalsarray = require("./equals-array");
-const equalsTransform = (query)=>{
-    const { member, values } = query;
-    /**
-   * If the member is an array, we need to use the array transform
-   */ if ((0, _isarraymembertype.isArrayTypeMember)(query.memberInfo.type)) {
-        return (0, _equalsarray.equalsArrayTransform)(query);
-    }
-    if (!values || values.length === 0) {
-        throw new Error('Equals filter must have at least one value');
-    }
-    /**
-   * If there is only one value, we can create a simple equals condition
-   */ if (values.length === 1) {
-        return (0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_EQUAL, values[0], query.memberInfo);
-    }
-    /**
-   * If there are multiple values, we need to create an AND condition
-   */ const andCondition = (0, _and.andDuckdbCondition)();
-    values.forEach((value)=>{
-        andCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_EQUAL, value, query.memberInfo));
-    });
-    return andCondition;
-};
-
-//# sourceMappingURL=equals.js.map

package/cube-filter-transformer/equals/equals.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/equals/equals.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { isArrayTypeMember } from '../../utils/is-array-member-type';\nimport { andDuckdbCondition } from '../and/and';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { equalsArrayTransform } from './equals-array';\n\nexport const equalsTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  /**\n   * If the member is an array, we need to use the array transform\n   */\n  if (isArrayTypeMember(query.memberInfo.type)) {\n    return equalsArrayTransform(query);\n  }\n\n  if (!values || values.length === 0) {\n    throw new Error('Equals filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_EQUAL,\n      values[0],\n      query.memberInfo\n    );\n  }\n\n  /**\n   * If there are multiple values, we need to create an AND condition\n   */\n  const andCondition = andDuckdbCondition();\n  values.forEach((value) => {\n    andCondition.children.push(\n      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_EQUAL,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return andCondition;\n};\n"],"names":["equalsTransform","query","member","values","isArrayTypeMember","memberInfo","type","equalsArrayTransform","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_EQUAL","andCondition","andDuckdbCondition","forEach","value","children","push"],"mappings":";+BAOaA;;;eAAAA;;;4BAPkB;mCACG;qBACC;sCACC;6BAEC;AAE9B,MAAMA,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B;;GAEC,GACD,IAAIG,IAAAA,oCAAiB,EAACH,MAAMI,UAAU,CAACC,IAAI,GAAG;QAC5C,OAAOC,IAAAA,iCAAoB,EAACN;IAC9B;IAEA,IAAI,CAACE,UAAUA,OAAOK,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIN,OAAOK,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBR,QACAS,0BAAc,CAACC,aAAa,EAC5BT,MAAM,CAAC,EAAE,EACTF,MAAMI,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMQ,eAAeC,IAAAA,uBAAkB;IACvCX,OAAOY,OAAO,CAAC,CAACC;QACdH,aAAaI,QAAQ,CAACC,IAAI,CACxBR,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,aAAa,EAC5BI,OACAf,MAAMI,UAAU;IAGtB;IACA,OAAOQ;AACT"}

package/cube-filter-transformer/factory.js

@@ -1,124 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "cubeFilterToDuckdbAST", {
-    enumerable: true,
-    get: function() {
-        return cubeFilterToDuckdbAST;
-    }
-});
-const _typeguards = require("../utils/type-guards");
-const _and = require("./and/and");
-const _contains = require("./contains/contains");
-const _equals = require("./equals/equals");
-const _gt = require("./gt/gt");
-const _gte = require("./gte/gte");
-const _indaterange = require("./in-date-range/in-date-range");
-const _in = require("./in/in");
-const _lt = require("./lt/lt");
-const _lte = require("./lte/lte");
-const _notIndaterange = require("./not-In-date-range/not-In-date-range");
-const _notcontains = require("./not-contains/not-contains");
-const _notequals = require("./not-equals/not-equals");
-const _notin = require("./not-in/not-in");
-const _notset = require("./not-set/not-set");
-const _or = require("./or/or");
-const _set = require("./set/set");
-// Comparison operators
-const cubeFilterOperatorsToDuckdb = (cubeFilter)=>{
-    switch(cubeFilter.operator){
-        case 'equals':
-            return (0, _equals.equalsTransform)(cubeFilter);
-        case 'notEquals':
-            return (0, _notequals.notEqualsTransform)(cubeFilter);
-        case 'in':
-            return (0, _in.inTransform)(cubeFilter);
-        case 'notIn':
-            return (0, _notin.notInTransform)(cubeFilter);
-        case 'contains':
-            return (0, _contains.containsTransform)(cubeFilter);
-        case 'notContains':
-            return (0, _notcontains.notContainsTransform)(cubeFilter);
-        case 'gt':
-            return (0, _gt.gtTransform)(cubeFilter);
-        case 'gte':
-            return (0, _gte.gteTransform)(cubeFilter);
-        case 'lt':
-            return (0, _lt.ltTransform)(cubeFilter);
-        case 'lte':
-            return (0, _lte.lteTransform)(cubeFilter);
-        case 'inDateRange':
-            return (0, _indaterange.inDataRangeTransform)(cubeFilter);
-        case 'notInDateRange':
-            return (0, _notIndaterange.notInDataRangeTransform)(cubeFilter);
-        case 'notSet':
-            {
-                return (0, _notset.notSetTransform)(cubeFilter);
-            }
-        case 'set':
-            {
-                return (0, _set.setTransform)(cubeFilter);
-            }
-        default:
-            throw new Error('Could not transform the filter');
-    }
-};
-const cubeFilterLogicalAndOrToDuckdb = (cubeFilter, whereObj)=>{
-    /**
-   * This condition is true when you are at the leaf most level of the filter
-   */ if (!(0, _typeguards.isFilterArray)(cubeFilter) && (0, _typeguards.isQueryFilter)(cubeFilter)) {
-        const data = cubeFilterOperatorsToDuckdb(cubeFilter);
-        if (!data) {
-            throw new Error('Could not transform the filter');
-        }
-        return data;
-    }
-    if (!(0, _typeguards.isFilterArray)(cubeFilter) && (0, _typeguards.isLogicalAnd)(cubeFilter)) {
-        if (cubeFilter.and.length === 0) {
-            return null;
-        }
-        // And or Or we need to recurse
-        const andDuckdbExpression = (0, _and.andDuckdbCondition)();
-        const data = cubeFilterLogicalAndOrToDuckdb(cubeFilter.and, andDuckdbExpression);
-        return data;
-    }
-    if (!(0, _typeguards.isFilterArray)(cubeFilter) && (0, _typeguards.isLogicalOr)(cubeFilter)) {
-        if (cubeFilter.or.length === 0) {
-            return null;
-        }
-        // And or Or we need to recurse
-        const orDuckdbExpression = (0, _or.orDuckdbCondition)();
-        const data = cubeFilterLogicalAndOrToDuckdb(cubeFilter.or, orDuckdbExpression);
-        return data;
-    }
-    if ((0, _typeguards.isFilterArray)(cubeFilter)) {
-        for (const filter of cubeFilter){
-            const data = cubeFilterLogicalAndOrToDuckdb(filter, whereObj);
-            if (data) {
-                if ((0, _typeguards.hasChildren)(whereObj)) {
-                    whereObj.children.push(data);
-                } else {
-                    whereObj = data;
-                }
-            }
-        }
-        return whereObj;
-    }
-    return whereObj;
-};
-const cubeFilterToDuckdbAST = (cubeFilter, ast)=>{
-    let whereObj = ast.node.where_clause || null;
-    if (cubeFilter.length > 1) {
-        console.error('We do not support multiple filters yet');
-        throw new Error('We do not support multiple filters yet');
-    }
-    const filter = cubeFilter[0];
-    if ((0, _typeguards.isQueryFilter)(filter)) {
-        whereObj = cubeFilterOperatorsToDuckdb(filter);
-    }
-    if ((0, _typeguards.isLogicalAndOR)(filter)) {
-        // And or Or we need to recurse
-        whereObj = cubeFilterLogicalAndOrToDuckdb(filter, whereObj || null);
-    }
-    return whereObj;
-};
-
-//# sourceMappingURL=factory.js.map

package/cube-filter-transformer/factory.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../meerkat-core/src/cube-filter-transformer/factory.ts"],"sourcesContent":["import {\n  QueryFilterWithInfo,\n  QueryFiltersWithInfo,\n  QueryOperatorsWithInfo,\n} from '../cube-to-duckdb/cube-filter-to-duckdb';\nimport { ParsedExpression } from '../types/duckdb-serialization-types/serialization/ParsedExpression';\nimport { SelectNode } from '../types/duckdb-serialization-types/serialization/QueryNode';\nimport { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';\nimport {\n  hasChildren,\n  isFilterArray,\n  isLogicalAnd,\n  isLogicalAndOR,\n  isLogicalOr,\n  isQueryFilter,\n} from '../utils/type-guards';\nimport { andDuckdbCondition } from './and/and';\nimport { containsTransform } from './contains/contains';\nimport { equalsTransform } from './equals/equals';\nimport { gtTransform } from './gt/gt';\nimport { gteTransform } from './gte/gte';\nimport { inDataRangeTransform } from './in-date-range/in-date-range';\nimport { inTransform } from './in/in';\nimport { ltTransform } from './lt/lt';\nimport { lteTransform } from './lte/lte';\nimport { notInDataRangeTransform } from './not-In-date-range/not-In-date-range';\nimport { notContainsTransform } from './not-contains/not-contains';\nimport { notEqualsTransform } from './not-equals/not-equals';\nimport { notInTransform } from './not-in/not-in';\nimport { notSetTransform } from './not-set/not-set';\nimport { orDuckdbCondition } from './or/or';\nimport { setTransform } from './set/set';\n\nexport type CubeToParseExpressionTransform = (\n  query: QueryOperatorsWithInfo\n) => ParsedExpression;\n\n// Comparison operators\nconst cubeFilterOperatorsToDuckdb = (cubeFilter: QueryOperatorsWithInfo) => {\n  switch (cubeFilter.operator) {\n    case 'equals':\n      return equalsTransform(cubeFilter);\n    case 'notEquals':\n      return notEqualsTransform(cubeFilter);\n    case 'in':\n      return inTransform(cubeFilter);\n    case 'notIn':\n      return notInTransform(cubeFilter);\n    case 'contains':\n      return containsTransform(cubeFilter);\n    case 'notContains':\n      return notContainsTransform(cubeFilter);\n    case 'gt':\n      return gtTransform(cubeFilter);\n    case 'gte':\n      return gteTransform(cubeFilter);\n    case 'lt':\n      return ltTransform(cubeFilter);\n    case 'lte':\n      return lteTransform(cubeFilter);\n    case 'inDateRange':\n      return inDataRangeTransform(cubeFilter);\n    case 'notInDateRange':\n      return notInDataRangeTransform(cubeFilter);\n    case 'notSet': {\n      return notSetTransform(cubeFilter);\n    }\n    case 'set': {\n      return setTransform(cubeFilter);\n    }\n    default:\n      throw new Error('Could not transform the filter');\n  }\n};\n\nconst cubeFilterLogicalAndOrToDuckdb = (\n  cubeFilter: QueryFilterWithInfo,\n  whereObj: ParsedExpression | null\n): ParsedExpression | null => {\n  /**\n   * This condition is true when you are at the leaf most level of the filter\n   */\n  if (!isFilterArray(cubeFilter) && isQueryFilter(cubeFilter)) {\n    const data = cubeFilterOperatorsToDuckdb(cubeFilter);\n    if (!data) {\n      throw new Error('Could not transform the filter');\n    }\n    return data;\n  }\n\n  if (!isFilterArray(cubeFilter) && isLogicalAnd(cubeFilter)) {\n    if (cubeFilter.and.length === 0) {\n      return null;\n    }\n    // And or Or we need to recurse\n    const andDuckdbExpression = andDuckdbCondition();\n    const data = cubeFilterLogicalAndOrToDuckdb(\n      cubeFilter.and,\n      andDuckdbExpression\n    );\n    return data;\n  }\n\n  if (!isFilterArray(cubeFilter) && isLogicalOr(cubeFilter)) {\n    if (cubeFilter.or.length === 0) {\n      return null;\n    }\n    // And or Or we need to recurse\n    const orDuckdbExpression = orDuckdbCondition();\n    const data = cubeFilterLogicalAndOrToDuckdb(\n      cubeFilter.or,\n      orDuckdbExpression\n    );\n    return data;\n  }\n\n  if (isFilterArray(cubeFilter)) {\n    for (const filter of cubeFilter) {\n      const data = cubeFilterLogicalAndOrToDuckdb(filter, whereObj);\n      if (data) {\n        if (hasChildren(whereObj)) {\n          whereObj.children.push(data);\n        } else {\n          whereObj = data;\n        }\n      }\n    }\n    return whereObj;\n  }\n  return whereObj;\n};\n\nexport const cubeFilterToDuckdbAST = (\n  cubeFilter: QueryFiltersWithInfo,\n  ast: SelectStatement\n) => {\n  let whereObj: ParsedExpression | null | undefined =\n    (ast.node as SelectNode).where_clause || null;\n\n  if (cubeFilter.length > 1) {\n    console.error('We do not support multiple filters yet');\n    throw new Error('We do not support multiple filters yet');\n  }\n\n  const filter = cubeFilter[0];\n\n  if (isQueryFilter(filter)) {\n    whereObj = cubeFilterOperatorsToDuckdb(filter);\n  }\n\n  if (isLogicalAndOR(filter)) {\n    // And or Or we need to recurse\n    whereObj = cubeFilterLogicalAndOrToDuckdb(filter, whereObj || null);\n  }\n\n  return whereObj;\n};\n"],"names":["cubeFilterToDuckdbAST","cubeFilterOperatorsToDuckdb","cubeFilter","operator","equalsTransform","notEqualsTransform","inTransform","notInTransform","containsTransform","notContainsTransform","gtTransform","gteTransform","ltTransform","lteTransform","inDataRangeTransform","notInDataRangeTransform","notSetTransform","setTransform","Error","cubeFilterLogicalAndOrToDuckdb","whereObj","isFilterArray","isQueryFilter","data","isLogicalAnd","and","length","andDuckdbExpression","andDuckdbCondition","isLogicalOr","or","orDuckdbExpression","orDuckdbCondition","filter","hasChildren","children","push","ast","node","where_clause","console","error","isLogicalAndOR"],"mappings":";+BAoIaA;;;eAAAA;;;4BArHN;qBAC4B;0BACD;wBACF;oBACJ;qBACC;6BACQ;oBACT;oBACA;qBACC;gCACW;6BACH;2BACF;uBACJ;wBACC;oBACE;qBACL;AAM7B,uBAAuB;AACvB,MAAMC,8BAA8B,CAACC;IACnC,OAAQA,WAAWC,QAAQ;QACzB,KAAK;YACH,OAAOC,IAAAA,uBAAe,EAACF;QACzB,KAAK;YACH,OAAOG,IAAAA,6BAAkB,EAACH;QAC5B,KAAK;YACH,OAAOI,IAAAA,eAAW,EAACJ;QACrB,KAAK;YACH,OAAOK,IAAAA,qBAAc,EAACL;QACxB,KAAK;YACH,OAAOM,IAAAA,2BAAiB,EAACN;QAC3B,KAAK;YACH,OAAOO,IAAAA,iCAAoB,EAACP;QAC9B,KAAK;YACH,OAAOQ,IAAAA,eAAW,EAACR;QACrB,KAAK;YACH,OAAOS,IAAAA,iBAAY,EAACT;QACtB,KAAK;YACH,OAAOU,IAAAA,eAAW,EAACV;QACrB,KAAK;YACH,OAAOW,IAAAA,iBAAY,EAACX;QACtB,KAAK;YACH,OAAOY,IAAAA,iCAAoB,EAACZ;QAC9B,KAAK;YACH,OAAOa,IAAAA,uCAAuB,EAACb;QACjC,KAAK;YAAU;gBACb,OAAOc,IAAAA,uBAAe,EAACd;YACzB;QACA,KAAK;YAAO;gBACV,OAAOe,IAAAA,iBAAY,EAACf;YACtB;QACA;YACE,MAAM,IAAIgB,MAAM;IACpB;AACF;AAEA,MAAMC,iCAAiC,CACrCjB,YACAkB;IAEA;;GAEC,GACD,IAAI,CAACC,IAAAA,yBAAa,EAACnB,eAAeoB,IAAAA,yBAAa,EAACpB,aAAa;QAC3D,MAAMqB,OAAOtB,4BAA4BC;QACzC,IAAI,CAACqB,MAAM;YACT,MAAM,IAAIL,MAAM;QAClB;QACA,OAAOK;IACT;IAEA,IAAI,CAACF,IAAAA,yBAAa,EAACnB,eAAesB,IAAAA,wBAAY,EAACtB,aAAa;QAC1D,IAAIA,WAAWuB,GAAG,CAACC,MAAM,KAAK,GAAG;YAC/B,OAAO;QACT;QACA,+BAA+B;QAC/B,MAAMC,sBAAsBC,IAAAA,uBAAkB;QAC9C,MAAML,OAAOJ,+BACXjB,WAAWuB,GAAG,EACdE;QAEF,OAAOJ;IACT;IAEA,IAAI,CAACF,IAAAA,yBAAa,EAACnB,eAAe2B,IAAAA,uBAAW,EAAC3B,aAAa;QACzD,IAAIA,WAAW4B,EAAE,CAACJ,MAAM,KAAK,GAAG;YAC9B,OAAO;QACT;QACA,+BAA+B;QAC/B,MAAMK,qBAAqBC,IAAAA,qBAAiB;QAC5C,MAAMT,OAAOJ,+BACXjB,WAAW4B,EAAE,EACbC;QAEF,OAAOR;IACT;IAEA,IAAIF,IAAAA,yBAAa,EAACnB,aAAa;QAC7B,KAAK,MAAM+B,UAAU/B,WAAY;YAC/B,MAAMqB,OAAOJ,+BAA+Bc,QAAQb;YACpD,IAAIG,MAAM;gBACR,IAAIW,IAAAA,uBAAW,EAACd,WAAW;oBACzBA,SAASe,QAAQ,CAACC,IAAI,CAACb;gBACzB,OAAO;oBACLH,WAAWG;gBACb;YACF;QACF;QACA,OAAOH;IACT;IACA,OAAOA;AACT;AAEO,MAAMpB,wBAAwB,CACnCE,YACAmC;IAEA,IAAIjB,WACF,AAACiB,IAAIC,IAAI,CAAgBC,YAAY,IAAI;IAE3C,IAAIrC,WAAWwB,MAAM,GAAG,GAAG;QACzBc,QAAQC,KAAK,CAAC;QACd,MAAM,IAAIvB,MAAM;IAClB;IAEA,MAAMe,SAAS/B,UAAU,CAAC,EAAE;IAE5B,IAAIoB,IAAAA,yBAAa,EAACW,SAAS;QACzBb,WAAWnB,4BAA4BgC;IACzC;IAEA,IAAIS,IAAAA,0BAAc,EAACT,SAAS;QAC1B,+BAA+B;QAC/Bb,WAAWD,+BAA+Bc,QAAQb,YAAY;IAChE;IAEA,OAAOA;AACT"}

package/cube-filter-transformer/gt/gt.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "gtTransform", {
-    enumerable: true,
-    get: function() {
-        return gtTransform;
-    }
-});
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const _or = require("../or/or");
-const gtTransform = (query)=>{
-    const { member, values } = query;
-    if (!values || values.length === 0) {
-        throw new Error('GT filter must have at least one value');
-    }
-    /**
-   * If there is only one value, we can create a simple equals condition
-   */ if (values.length === 1) {
-        return (0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_GREATERTHAN, values[0], query.memberInfo);
-    }
-    /**
-   * If there are multiple values, we need to create an OR condition
-   */ const orCondition = (0, _or.orDuckdbCondition)();
-    values.forEach((value)=>{
-        orCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_GREATERTHAN, value, query.memberInfo));
-    });
-    return orCondition;
-};
-
-//# sourceMappingURL=gt.js.map

package/cube-filter-transformer/gt/gt.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/gt/gt.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const gtTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('GT filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHAN,\n      values[0],\n      query.memberInfo\n    );\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_GREATERTHAN,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["gtTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_GREATERTHAN","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,cAA8C,CAACC;IAC1D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,mBAAmB,EAClCL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,mBAAmB,EAClCK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}

package/cube-filter-transformer/gte/gte.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "gteTransform", {
-    enumerable: true,
-    get: function() {
-        return gteTransform;
-    }
-});
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const _or = require("../or/or");
-const gteTransform = (query)=>{
-    const { member, values } = query;
-    if (!values || values.length === 0) {
-        throw new Error('GTE filter must have at least one value');
-    }
-    /**
-   * If there is only one value, we can create a simple equals condition
-   */ if (values.length === 1) {
-        return (0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_GREATERTHANOREQUALTO, values[0], query.memberInfo);
-    }
-    /**
-   * If there are multiple values, we need to create an OR condition
-   */ const orCondition = (0, _or.orDuckdbCondition)();
-    values.forEach((value)=>{
-        orCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_GREATERTHANOREQUALTO, value, query.memberInfo));
-    });
-    return orCondition;
-};
-
-//# sourceMappingURL=gte.js.map

package/cube-filter-transformer/gte/gte.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/gte/gte.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const gteTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('GTE filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHANOREQUALTO,\n      values[0],\n      query.memberInfo\n    );\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_GREATERTHANOREQUALTO,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["gteTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_GREATERTHANOREQUALTO","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,eAA+C,CAACC;IAC3D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,4BAA4B,EAC3CL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,4BAA4B,EAC3CK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}

package/cube-filter-transformer/in/in.js

@@ -1,78 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "inTransform", {
-    enumerable: true,
-    get: function() {
-        return inTransform;
-    }
-});
-const _constants = require("../../member-formatters/constants");
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const inDuckDbCondition = (columnName, values, memberInfo)=>{
-    const sqlTreeValues = values.map((value)=>{
-        return {
-            class: _Expression.ExpressionClass.CONSTANT,
-            type: _Expression.ExpressionType.VALUE_CONSTANT,
-            alias: '',
-            value: (0, _baseconditionbuilder.valueBuilder)(value, memberInfo)
-        };
-    });
-    const columnRef = {
-        class: 'COLUMN_REF',
-        type: 'COLUMN_REF',
-        alias: '',
-        column_names: columnName.split(_constants.COLUMN_NAME_DELIMITER)
-    };
-    switch(memberInfo.type){
-        case 'number_array':
-        case 'string_array':
-            {
-                return {
-                    class: _Expression.ExpressionClass.FUNCTION,
-                    type: _Expression.ExpressionType.FUNCTION,
-                    alias: '',
-                    function_name: '&&',
-                    schema: '',
-                    children: [
-                        columnRef,
-                        {
-                            class: _Expression.ExpressionClass.OPERATOR,
-                            type: _Expression.ExpressionType.ARRAY_CONSTRUCTOR,
-                            alias: '',
-                            children: sqlTreeValues
-                        }
-                    ],
-                    filter: null,
-                    order_bys: {
-                        type: 'ORDER_MODIFIER',
-                        orders: []
-                    },
-                    distinct: false,
-                    is_operator: true,
-                    export_state: false,
-                    catalog: ''
-                };
-            }
-        default:
-            {
-                return {
-                    class: _Expression.ExpressionClass.OPERATOR,
-                    type: _Expression.ExpressionType.COMPARE_IN,
-                    alias: '',
-                    children: [
-                        columnRef,
-                        ...sqlTreeValues
-                    ]
-                };
-            }
-    }
-};
-const inTransform = (query)=>{
-    const { member, values, memberInfo } = query;
-    if (!values) {
-        throw new Error('In filter must have at least one value');
-    }
-    return inDuckDbCondition(member, values, memberInfo);
-};
-
-//# sourceMappingURL=in.js.map

package/cube-filter-transformer/in/in.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/in/in.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport { Dimension, Measure } from '../../types/cube-types/table';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { valueBuilder } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nconst inDuckDbCondition = (\n  columnName: string,\n  values: string[],\n  memberInfo: Measure | Dimension\n) => {\n  const sqlTreeValues = values.map((value) => {\n    return {\n      class: ExpressionClass.CONSTANT,\n      type: ExpressionType.VALUE_CONSTANT,\n      alias: '',\n      value: valueBuilder(value, memberInfo),\n    };\n  });\n  const columnRef = {\n    class: 'COLUMN_REF',\n    type: 'COLUMN_REF',\n    alias: '',\n    column_names: columnName.split(COLUMN_NAME_DELIMITER),\n  };\n  switch (memberInfo.type) {\n    case 'number_array':\n    case 'string_array': {\n      return {\n        class: ExpressionClass.FUNCTION,\n        type: ExpressionType.FUNCTION,\n        alias: '',\n        function_name: '&&',\n        schema: '',\n        children: [\n          columnRef,\n          {\n            class: ExpressionClass.OPERATOR,\n            type: ExpressionType.ARRAY_CONSTRUCTOR,\n            alias: '',\n            children: sqlTreeValues,\n          },\n        ],\n        filter: null,\n        order_bys: {\n          type: 'ORDER_MODIFIER',\n          orders: [],\n        },\n        distinct: false,\n        is_operator: true,\n        export_state: false,\n        catalog: '',\n      };\n    }\n    default: {\n      return {\n        class: ExpressionClass.OPERATOR,\n        type: ExpressionType.COMPARE_IN,\n        alias: '',\n        children: [columnRef, ...sqlTreeValues],\n      };\n    }\n  }\n};\n\nexport const inTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  if (!values) {\n    throw new Error('In filter must have at least one value');\n  }\n  return inDuckDbCondition(member, values, memberInfo);\n};\n"],"names":["inTransform","inDuckDbCondition","columnName","values","memberInfo","sqlTreeValues","map","value","class","ExpressionClass","CONSTANT","type","ExpressionType","VALUE_CONSTANT","alias","valueBuilder","columnRef","column_names","split","COLUMN_NAME_DELIMITER","FUNCTION","function_name","schema","children","OPERATOR","ARRAY_CONSTRUCTOR","filter","order_bys","orders","distinct","is_operator","export_state","catalog","COMPARE_IN","query","member","Error"],"mappings":";+BAoEaA;;;eAAAA;;;2BApEyB;4BAK/B;sCACsB;AAG7B,MAAMC,oBAAoB,CACxBC,YACAC,QACAC;IAEA,MAAMC,gBAAgBF,OAAOG,GAAG,CAAC,CAACC;QAChC,OAAO;YACLC,OAAOC,2BAAe,CAACC,QAAQ;YAC/BC,MAAMC,0BAAc,CAACC,cAAc;YACnCC,OAAO;YACPP,OAAOQ,IAAAA,kCAAY,EAACR,OAAOH;QAC7B;IACF;IACA,MAAMY,YAAY;QAChBR,OAAO;QACPG,MAAM;QACNG,OAAO;QACPG,cAAcf,WAAWgB,KAAK,CAACC,gCAAqB;IACtD;IACA,OAAQf,WAAWO,IAAI;QACrB,KAAK;QACL,KAAK;YAAgB;gBACnB,OAAO;oBACLH,OAAOC,2BAAe,CAACW,QAAQ;oBAC/BT,MAAMC,0BAAc,CAACQ,QAAQ;oBAC7BN,OAAO;oBACPO,eAAe;oBACfC,QAAQ;oBACRC,UAAU;wBACRP;wBACA;4BACER,OAAOC,2BAAe,CAACe,QAAQ;4BAC/Bb,MAAMC,0BAAc,CAACa,iBAAiB;4BACtCX,OAAO;4BACPS,UAAUlB;wBACZ;qBACD;oBACDqB,QAAQ;oBACRC,WAAW;wBACThB,MAAM;wBACNiB,QAAQ,EAAE;oBACZ;oBACAC,UAAU;oBACVC,aAAa;oBACbC,cAAc;oBACdC,SAAS;gBACX;YACF;QACA;YAAS;gBACP,OAAO;oBACLxB,OAAOC,2BAAe,CAACe,QAAQ;oBAC/Bb,MAAMC,0BAAc,CAACqB,UAAU;oBAC/BnB,OAAO;oBACPS,UAAU;wBAACP;2BAAcX;qBAAc;gBACzC;YACF;IACF;AACF;AAEO,MAAML,cAA8C,CAACkC;IAC1D,MAAM,EAAEC,MAAM,EAAEhC,MAAM,EAAEC,UAAU,EAAE,GAAG8B;IACvC,IAAI,CAAC/B,QAAQ;QACX,MAAM,IAAIiC,MAAM;IAClB;IACA,OAAOnC,kBAAkBkC,QAAQhC,QAAQC;AAC3C"}

package/cube-filter-transformer/in-date-range/in-date-range.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "inDataRangeTransform", {
-    enumerable: true,
-    get: function() {
-        return inDataRangeTransform;
-    }
-});
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _and = require("../and/and");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const inDataRangeTransform = (query)=>{
-    const { member, values } = query;
-    if (!values || values.length === 0) {
-        throw new Error('GT filter must have at least one value');
-    }
-    /**
-   * If there are multiple values, we need to create an OR condition
-   */ const andCondition = (0, _and.andDuckdbCondition)();
-    andCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_GREATERTHANOREQUALTO, values[0], query.memberInfo));
-    andCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHANOREQUALTO, values[1], query.memberInfo));
-    return andCondition;
-};
-
-//# sourceMappingURL=in-date-range.js.map

package/cube-filter-transformer/in-date-range/in-date-range.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/in-date-range/in-date-range.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { andDuckdbCondition } from '../and/and';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nexport const inDataRangeTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('GT filter must have at least one value');\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const andCondition = andDuckdbCondition();\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHANOREQUALTO,\n      values[0],\n      query.memberInfo\n    )\n  );\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHANOREQUALTO,\n      values[1],\n      query.memberInfo\n    )\n  );\n\n  return andCondition;\n};\n"],"names":["inDataRangeTransform","query","member","values","length","Error","andCondition","andDuckdbCondition","children","push","baseDuckdbCondition","ExpressionType","COMPARE_GREATERTHANOREQUALTO","memberInfo","COMPARE_LESSTHANOREQUALTO"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;qBACI;sCACC;AAG7B,MAAMA,uBAAuD,CAACC;IACnE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,MAAMC,eAAeC,IAAAA,uBAAkB;IAEvCD,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,4BAA4B,EAC3CT,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpBP,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACG,yBAAyB,EACxCX,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpB,OAAOP;AACT"}

package/cube-filter-transformer/lt/lt.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "ltTransform", {
-    enumerable: true,
-    get: function() {
-        return ltTransform;
-    }
-});
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const _or = require("../or/or");
-const ltTransform = (query)=>{
-    const { member, values } = query;
-    if (!values || values.length === 0) {
-        throw new Error('lt filter must have at least one value');
-    }
-    /**
-   * If there is only one value, we can create a simple equals condition
-   */ if (values.length === 1) {
-        return (0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHAN, values[0], query.memberInfo);
-    }
-    /**
-   * If there are multiple values, we need to create an OR condition
-   */ const orCondition = (0, _or.orDuckdbCondition)();
-    values.forEach((value)=>{
-        orCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHAN, value, query.memberInfo));
-    });
-    return orCondition;
-};
-
-//# sourceMappingURL=lt.js.map

package/cube-filter-transformer/lt/lt.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/lt/lt.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const ltTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('lt filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHAN,\n      values[0],\n      query.memberInfo\n    );\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_LESSTHAN,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["ltTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_LESSTHAN","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,cAA8C,CAACC;IAC1D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,gBAAgB,EAC/BL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,gBAAgB,EAC/BK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}

package/cube-filter-transformer/lte/lte.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "lteTransform", {
-    enumerable: true,
-    get: function() {
-        return lteTransform;
-    }
-});
-const _Expression = require("../../types/duckdb-serialization-types/serialization/Expression");
-const _baseconditionbuilder = require("../base-condition-builder/base-condition-builder");
-const _or = require("../or/or");
-const lteTransform = (query)=>{
-    const { member, values } = query;
-    if (!values || values.length === 0) {
-        throw new Error('lte filter must have at least one value');
-    }
-    /**
-   * If there is only one value, we can create a simple equals condition
-   */ if (values.length === 1) {
-        return (0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHANOREQUALTO, values[0], query.memberInfo);
-    }
-    /**
-   * If there are multiple values, we need to create an OR condition
-   */ const orCondition = (0, _or.orDuckdbCondition)();
-    values.forEach((value)=>{
-        orCondition.children.push((0, _baseconditionbuilder.baseDuckdbCondition)(member, _Expression.ExpressionType.COMPARE_LESSTHANOREQUALTO, value, query.memberInfo));
-    });
-    return orCondition;
-};
-
-//# sourceMappingURL=lte.js.map

package/cube-filter-transformer/lte/lte.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/lte/lte.ts"],"sourcesContent":["import { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\n\nexport const lteTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('lte filter must have at least one value');\n  }\n\n  /**\n   * If there is only one value, we can create a simple equals condition\n   */\n  if (values.length === 1) {\n    return baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHANOREQUALTO,\n      values[0],\n      query.memberInfo\n    );\n  }\n\n  /**\n   * If there are multiple values, we need to create an OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_LESSTHANOREQUALTO,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["lteTransform","query","member","values","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_LESSTHANOREQUALTO","memberInfo","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,eAA+C,CAACC;IAC3D,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIF,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOE,IAAAA,yCAAmB,EACxBJ,QACAK,0BAAc,CAACC,yBAAyB,EACxCL,MAAM,CAAC,EAAE,EACTF,MAAMQ,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMC,cAAcC,IAAAA,qBAAiB;IACrCR,OAAOS,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBT,IAAAA,yCAAmB,EACjBJ,QACAK,0BAAc,CAACC,yBAAyB,EACxCK,OACAZ,MAAMQ,UAAU;IAGtB;IACA,OAAOC;AACT"}