@devrev/meerkat-core 0.0.92 → 0.0.93

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

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

@@ -0,0 +1 @@
+{"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 { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\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 OR condition\n   */\n  const orCondition = orDuckdbCondition();\n  values.forEach((value) => {\n    orCondition.children.push(\n      baseDuckdbCondition(\n        member,\n        ExpressionType.COMPARE_EQUAL,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["equalsTransform","query","member","values","isArrayTypeMember","memberInfo","type","equalsArrayTransform","length","Error","baseDuckdbCondition","ExpressionType","COMPARE_EQUAL","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAOaA;;;eAAAA;;;4BAPkB;mCACG;sCACE;oBAEF;6BACG;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,cAAcC,IAAAA,qBAAiB;IACrCX,OAAOY,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBR,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,aAAa,EAC5BI,OACAf,MAAMI,UAAU;IAGtB;IACA,OAAOQ;AACT"}

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

@@ -0,0 +1 @@
+{"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":"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"}

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

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

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

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

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

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

@@ -0,0 +1 @@
+{"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"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not/not.ts"],"sourcesContent":["import {\n  ExpressionClass,\n  ExpressionType,\n  OperatorExpression,\n} from '../../types/duckdb-serialization-types/index';\n\nexport const notDuckdbCondition = (): OperatorExpression => {\n  return {\n    class: ExpressionClass.OPERATOR,\n    type: ExpressionType.OPERATOR_NOT,\n    alias: '',\n    children: [],\n  };\n};\n"],"names":["notDuckdbCondition","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_NOT","alias","children"],"mappings":";+BAMaA;;;eAAAA;;;uBAFN;AAEA,MAAMA,qBAAqB;IAChC,OAAO;QACLC,OAAOC,sBAAe,CAACC,QAAQ;QAC/BC,MAAMC,qBAAc,CAACC,YAAY;QACjCC,OAAO;QACPC,UAAU,EAAE;IACd;AACF"}

package/cube-filter-transformer/not-In-date-range/not-In-date-range.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-In-date-range/not-In-date-range.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 notInDataRangeTransform: CubeToParseExpressionTransform = (\n  query\n) => {\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 = orDuckdbCondition();\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_LESSTHAN,\n      values[0],\n      query.memberInfo\n    )\n  );\n\n  andCondition.children.push(\n    baseDuckdbCondition(\n      member,\n      ExpressionType.COMPARE_GREATERTHAN,\n      values[1],\n      query.memberInfo\n    )\n  );\n\n  return andCondition;\n};\n"],"names":["notInDataRangeTransform","query","member","values","length","Error","andCondition","orDuckdbCondition","children","push","baseDuckdbCondition","ExpressionType","COMPARE_LESSTHAN","memberInfo","COMPARE_GREATERTHAN"],"mappings":";+BAKaA;;;eAAAA;;;4BALkB;sCACK;oBAEF;AAE3B,MAAMA,0BAA0D,CACrEC;IAEA,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,qBAAiB;IAEtCD,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,gBAAgB,EAC/BT,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpBP,aAAaE,QAAQ,CAACC,IAAI,CACxBC,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACG,mBAAmB,EAClCX,MAAM,CAAC,EAAE,EACTF,MAAMY,UAAU;IAIpB,OAAOP;AACT"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-contains/not-contains.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport { Member, QueryFilter } from '../../types/cube-types/query';\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';\nimport { orDuckdbCondition } from '../or/or';\n\nexport interface NotContainsFilters extends QueryFilter {\n  member: Member;\n  operator: 'notContains';\n  values: string[];\n}\n\nexport const notContainsDuckdbCondition = (\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 notContainsTransform: 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 notContainsDuckdbCondition(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      notContainsDuckdbCondition(member, value, memberInfo)\n    );\n  });\n  return orCondition;\n};\n"],"names":["notContainsDuckdbCondition","notContainsTransform","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":";;;;;;;;IAiBaA,0BAA0B;eAA1BA;;IAqCAC,oBAAoB;eAApBA;;;2BAtDyB;4BAM/B;sCACsB;oBAEK;AAQ3B,MAAMD,6BAA6B,CACxCE,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,uBAAuD,CAACwB;IACnE,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,2BAA2B0B,QAAQC,MAAM,CAAC,EAAE,EAAEvB;IACvD;IAEA;;GAEC,GACD,MAAM0B,cAAcC,IAAAA,qBAAiB;IACrCJ,OAAOK,OAAO,CAAC,CAAC7B;QACd2B,YAAYjB,QAAQ,CAACoB,IAAI,CACvBjC,2BAA2B0B,QAAQvB,OAAOC;IAE9C;IACA,OAAO0B;AACT"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-equals/not-equals-array.ts"],"sourcesContent":["import { equalsArrayTransform } from '../equals/equals-array';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { notDuckdbCondition } from '../not/not';\n\nexport const notEqualsArrayTransform: CubeToParseExpressionTransform = (\n  query\n) => {\n  const { values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('Equals filter must have at least one value');\n  }\n\n  const notWrapper = notDuckdbCondition();\n  const equalsCondition = equalsArrayTransform(query);\n  /**\n   * We need to wrap the equals condition in a not condition\n   * Which basically means ! of ANY of the values\n   */\n  notWrapper.children = [equalsCondition];\n\n  return notWrapper;\n};\n"],"names":["notEqualsArrayTransform","query","values","length","Error","notWrapper","notDuckdbCondition","equalsCondition","equalsArrayTransform","children"],"mappings":";+BAIaA;;;eAAAA;;;6BAJwB;qBAEF;AAE5B,MAAMA,0BAA0D,CACrEC;IAEA,MAAM,EAAEC,MAAM,EAAE,GAAGD;IAEnB,IAAI,CAACC,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA,MAAMC,aAAaC,IAAAA,uBAAkB;IACrC,MAAMC,kBAAkBC,IAAAA,iCAAoB,EAACP;IAC7C;;;GAGC,GACDI,WAAWI,QAAQ,GAAG;QAACF;KAAgB;IAEvC,OAAOF;AACT"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-equals/not-equals.ts"],"sourcesContent":["import { Member, QueryFilter } from '../../types/cube-types/query';\nimport { ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { isArrayTypeMember } from '../../utils/is-array-member-type';\nimport { baseDuckdbCondition } from '../base-condition-builder/base-condition-builder';\nimport { CubeToParseExpressionTransform } from '../factory';\nimport { orDuckdbCondition } from '../or/or';\nimport { notEqualsArrayTransform } from './not-equals-array';\n\nexport interface NotEqualsFilters extends QueryFilter {\n  member: Member;\n  operator: 'notEquals';\n  values: string[];\n}\n\nexport const notEqualsTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values } = query;\n\n  if (!values || values.length === 0) {\n    throw new Error('Equals filter must have at least one value');\n  }\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 notEqualsArrayTransform(query);\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_NOTEQUAL,\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_NOTEQUAL,\n        value,\n        query.memberInfo\n      )\n    );\n  });\n  return orCondition;\n};\n"],"names":["notEqualsTransform","query","member","values","length","Error","isArrayTypeMember","memberInfo","type","notEqualsArrayTransform","baseDuckdbCondition","ExpressionType","COMPARE_NOTEQUAL","orCondition","orDuckdbCondition","forEach","value","children","push"],"mappings":";+BAcaA;;;eAAAA;;;4BAbkB;mCACG;sCACE;oBAEF;gCACM;AAQjC,MAAMA,qBAAqD,CAACC;IACjE,MAAM,EAAEC,MAAM,EAAEC,MAAM,EAAE,GAAGF;IAE3B,IAAI,CAACE,UAAUA,OAAOC,MAAM,KAAK,GAAG;QAClC,MAAM,IAAIC,MAAM;IAClB;IAEA;;GAEC,GACD,IAAIC,IAAAA,oCAAiB,EAACL,MAAMM,UAAU,CAACC,IAAI,GAAG;QAC5C,OAAOC,IAAAA,uCAAuB,EAACR;IACjC;IAEA;;GAEC,GACD,IAAIE,OAAOC,MAAM,KAAK,GAAG;QACvB,OAAOM,IAAAA,yCAAmB,EACxBR,QACAS,0BAAc,CAACC,gBAAgB,EAC/BT,MAAM,CAAC,EAAE,EACTF,MAAMM,UAAU;IAEpB;IAEA;;GAEC,GACD,MAAMM,cAAcC,IAAAA,qBAAiB;IACrCX,OAAOY,OAAO,CAAC,CAACC;QACdH,YAAYI,QAAQ,CAACC,IAAI,CACvBR,IAAAA,yCAAmB,EACjBR,QACAS,0BAAc,CAACC,gBAAgB,EAC/BI,OACAf,MAAMM,UAAU;IAGtB;IACA,OAAOM;AACT"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-in/not-in.ts"],"sourcesContent":["import { Dimension, Measure } from '../../types/cube-types/table';\nimport { CubeToParseExpressionTransform } from '../factory';\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';\n\nconst notInDuckDbCondition = (\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.OPERATOR,\n        type: ExpressionType.OPERATOR_NOT,\n        alias: '',\n        children: [\n          {\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      };\n    }\n    default: {\n      return {\n        class: ExpressionClass.OPERATOR,\n        type: ExpressionType.COMPARE_NOT_IN,\n        alias: '',\n        children: [columnRef, ...sqlTreeValues],\n      };\n    }\n  }\n};\n\nexport const notInTransform: CubeToParseExpressionTransform = (query) => {\n  const { member, values, memberInfo } = query;\n  if (!values) {\n    throw new Error('Not in filter must have at least one value');\n  }\n\n  return notInDuckDbCondition(member, values, memberInfo);\n};\n"],"names":["notInTransform","notInDuckDbCondition","columnName","values","memberInfo","sqlTreeValues","map","value","class","ExpressionClass","CONSTANT","type","ExpressionType","VALUE_CONSTANT","alias","valueBuilder","columnRef","column_names","split","COLUMN_NAME_DELIMITER","OPERATOR","OPERATOR_NOT","children","FUNCTION","function_name","schema","ARRAY_CONSTRUCTOR","filter","order_bys","orders","distinct","is_operator","export_state","catalog","COMPARE_NOT_IN","query","member","Error"],"mappings":";+BA4EaA;;;eAAAA;;;2BAzEyB;4BAI/B;sCACsB;AAE7B,MAAMC,uBAAuB,CAC3BC,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,CAACS,YAAY;oBACjCP,OAAO;oBACPQ,UAAU;wBACR;4BACEd,OAAOC,2BAAe,CAACc,QAAQ;4BAC/BZ,MAAMC,0BAAc,CAACW,QAAQ;4BAC7BT,OAAO;4BACPU,eAAe;4BACfC,QAAQ;4BACRH,UAAU;gCACRN;gCACA;oCACER,OAAOC,2BAAe,CAACW,QAAQ;oCAC/BT,MAAMC,0BAAc,CAACc,iBAAiB;oCACtCZ,OAAO;oCACPQ,UAAUjB;gCACZ;6BACD;4BACDsB,QAAQ;4BACRC,WAAW;gCACTjB,MAAM;gCACNkB,QAAQ,EAAE;4BACZ;4BACAC,UAAU;4BACVC,aAAa;4BACbC,cAAc;4BACdC,SAAS;wBACX;qBACD;gBACH;YACF;QACA;YAAS;gBACP,OAAO;oBACLzB,OAAOC,2BAAe,CAACW,QAAQ;oBAC/BT,MAAMC,0BAAc,CAACsB,cAAc;oBACnCpB,OAAO;oBACPQ,UAAU;wBAACN;2BAAcX;qBAAc;gBACzC;YACF;IACF;AACF;AAEO,MAAML,iBAAiD,CAACmC;IAC7D,MAAM,EAAEC,MAAM,EAAEjC,MAAM,EAAEC,UAAU,EAAE,GAAG+B;IACvC,IAAI,CAAChC,QAAQ;QACX,MAAM,IAAIkC,MAAM;IAClB;IAEA,OAAOpC,qBAAqBmC,QAAQjC,QAAQC;AAC9C"}

package/cube-filter-transformer/not-set/not-set.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/not-set/not-set.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nexport const notSetTransform: CubeToParseExpressionTransform = (query) => {\n  const { member } = query;\n  return {\n    class: ExpressionClass.OPERATOR,\n    type: ExpressionType.OPERATOR_IS_NULL,\n    alias: '',\n    children: [\n      {\n        class: 'COLUMN_REF',\n        type: 'COLUMN_REF',\n        alias: '',\n        column_names: member.split(COLUMN_NAME_DELIMITER),\n      },\n    ],\n  };\n};\n"],"names":["notSetTransform","query","member","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_IS_NULL","alias","children","column_names","split","COLUMN_NAME_DELIMITER"],"mappings":";+BAOaA;;;eAAAA;;;2BAPyB;4BAI/B;AAGA,MAAMA,kBAAkD,CAACC;IAC9D,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,OAAO;QACLE,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACC,gBAAgB;QACrCC,OAAO;QACPC,UAAU;YACR;gBACEP,OAAO;gBACPG,MAAM;gBACNG,OAAO;gBACPE,cAAcT,OAAOU,KAAK,CAACC,gCAAqB;YAClD;SACD;IACH;AACF"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/or/or.ts"],"sourcesContent":["import { ConjunctionExpression } from '../../types/duckdb-serialization-types/serialization/ParsedExpression';\nimport { ExpressionClass, ExpressionType } from '../../types/duckdb-serialization-types/serialization/Expression';\n\nexport const orDuckdbCondition = (): ConjunctionExpression => {\n  return {\n    class: ExpressionClass.CONJUNCTION,\n    type: ExpressionType.CONJUNCTION_OR,\n    alias: '',\n    children: [],\n  };\n};\n"],"names":["orDuckdbCondition","class","ExpressionClass","CONJUNCTION","type","ExpressionType","CONJUNCTION_OR","alias","children"],"mappings":";+BAGaA;;;eAAAA;;;4BAFmC;AAEzC,MAAMA,oBAAoB;IAC/B,OAAO;QACLC,OAAOC,2BAAe,CAACC,WAAW;QAClCC,MAAMC,0BAAc,CAACC,cAAc;QACnCC,OAAO;QACPC,UAAU,EAAE;IACd;AACF"}

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/cube-filter-transformer/set/set.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from '../../member-formatters/constants';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../../types/duckdb-serialization-types/serialization/Expression';\nimport { CubeToParseExpressionTransform } from '../factory';\n\nexport const setTransform: CubeToParseExpressionTransform = (query) => {\n  const { member } = query;\n  return {\n    class: ExpressionClass.OPERATOR,\n    type: ExpressionType.OPERATOR_IS_NOT_NULL,\n    alias: '',\n    children: [\n      {\n        class: 'COLUMN_REF',\n        type: 'COLUMN_REF',\n        alias: '',\n        column_names: member.split(COLUMN_NAME_DELIMITER),\n      },\n    ],\n  };\n};\n"],"names":["setTransform","query","member","class","ExpressionClass","OPERATOR","type","ExpressionType","OPERATOR_IS_NOT_NULL","alias","children","column_names","split","COLUMN_NAME_DELIMITER"],"mappings":";+BAOaA;;;eAAAA;;;2BAPyB;4BAI/B;AAGA,MAAMA,eAA+C,CAACC;IAC3D,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,OAAO;QACLE,OAAOC,2BAAe,CAACC,QAAQ;QAC/BC,MAAMC,0BAAc,CAACC,oBAAoB;QACzCC,OAAO;QACPC,UAAU;YACR;gBACEP,OAAO;gBACPG,MAAM;gBACNG,OAAO;gBACPE,cAAcT,OAAOU,KAAK,CAACC,gCAAqB;YAClD;SACD;IACH;AACF"}

package/cube-group-by-transformer/cube-group-by-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-group-by-transformer/cube-group-by-transformer.ts"],"sourcesContent":["import { memberKeyToSafeKey } from '../member-formatters';\nimport { Member } from '../types/cube-types/query';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../types/duckdb-serialization-types/serialization/Expression';\n\nexport const cubeDimensionToGroupByAST = (dimensions: Member[]) => {\n  const groupByAST = dimensions.map((dimension) => {\n    const dimensionAST = {\n      class: ExpressionClass.COLUMN_REF,\n      type: ExpressionType.COLUMN_REF,\n      alias: '',\n      column_names: [memberKeyToSafeKey(dimension)],\n    };\n\n    return dimensionAST;\n  });\n\n  return groupByAST;\n};\n"],"names":["cubeDimensionToGroupByAST","dimensions","groupByAST","map","dimension","dimensionAST","class","ExpressionClass","COLUMN_REF","type","ExpressionType","alias","column_names","memberKeyToSafeKey"],"mappings":";+BAOaA;;;eAAAA;;;kCAPsB;4BAK5B;AAEA,MAAMA,4BAA4B,CAACC;IACxC,MAAMC,aAAaD,WAAWE,GAAG,CAAC,CAACC;QACjC,MAAMC,eAAe;YACnBC,OAAOC,2BAAe,CAACC,UAAU;YACjCC,MAAMC,0BAAc,CAACF,UAAU;YAC/BG,OAAO;YACPC,cAAc;gBAACC,IAAAA,oCAAkB,EAACT;aAAW;QAC/C;QAEA,OAAOC;IACT;IAEA,OAAOH;AACT"}

package/cube-limit-offset-transformer/cube-limit-offset-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-limit-offset-transformer/cube-limit-offset-transformer.ts"],"sourcesContent":["import { ExpressionClass, ExpressionType } from '../types/duckdb-serialization-types/serialization/Expression';\nimport { ResultModifierType } from '../types/duckdb-serialization-types/serialization/ResultModifier';\n\nexport const cubeLimitOffsetToAST = (\n  limit?: number | null,\n  offset?: number | null\n) => {\n  return {\n    type: ResultModifierType.LIMIT_MODIFIER,\n    limit: limit\n      ? {\n          class: ExpressionClass.CONSTANT,\n          type: ExpressionType.VALUE_CONSTANT,\n          alias: '',\n          value: {\n            type: {\n              id: 'INTEGER',\n              type_info: null,\n            },\n            is_null: false,\n            value: limit,\n          },\n        }\n      : null,\n    offset: offset\n      ? {\n          class: ExpressionClass.CONSTANT,\n          type: ExpressionType.VALUE_CONSTANT,\n          alias: '',\n          value: {\n            type: {\n              id: 'INTEGER',\n              type_info: null,\n            },\n            is_null: false,\n            value: offset,\n          },\n        }\n      : null,\n  };\n};\n"],"names":["cubeLimitOffsetToAST","limit","offset","type","ResultModifierType","LIMIT_MODIFIER","class","ExpressionClass","CONSTANT","ExpressionType","VALUE_CONSTANT","alias","value","id","type_info","is_null"],"mappings":";+BAGaA;;;eAAAA;;;4BAHmC;gCACb;AAE5B,MAAMA,uBAAuB,CAClCC,OACAC;IAEA,OAAO;QACLC,MAAMC,kCAAkB,CAACC,cAAc;QACvCJ,OAAOA,QACH;YACEK,OAAOC,2BAAe,CAACC,QAAQ;YAC/BL,MAAMM,0BAAc,CAACC,cAAc;YACnCC,OAAO;YACPC,OAAO;gBACLT,MAAM;oBACJU,IAAI;oBACJC,WAAW;gBACb;gBACAC,SAAS;gBACTH,OAAOX;YACT;QACF,IACA;QACJC,QAAQA,SACJ;YACEI,OAAOC,2BAAe,CAACC,QAAQ;YAC/BL,MAAMM,0BAAc,CAACC,cAAc;YACnCC,OAAO;YACPC,OAAO;gBACLT,MAAM;oBACJU,IAAI;oBACJC,WAAW;gBACb;gBACAC,SAAS;gBACTH,OAAOV;YACT;QACF,IACA;IACN;AACF"}

package/{src/cube-measure-transformer → cube-measure-transformer}/cube-measure-transformer.js

@@ -6,17 +6,17 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    applyProjectionToSQLQuery: function() {
+        return applyProjectionToSQLQuery;
+    },
     cubeMeasureToSQLSelectString: function() {
         return cubeMeasureToSQLSelectString;
     },
-    getSelectReplacedSql: function() {
-        return getSelectReplacedSql;
-    },
     getAllColumnUsedInMeasures: function() {
         return getAllColumnUsedInMeasures;
     },
-    applyProjectionToSQLQuery: function() {
-        return applyProjectionToSQLQuery;
+    getSelectReplacedSql: function() {
+        return getSelectReplacedSql;
     }
 });
 const _memberkeytosafekey = require("../member-formatters/member-key-to-safe-key");

package/cube-measure-transformer/cube-measure-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-measure-transformer/cube-measure-transformer.ts"],"sourcesContent":["import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';\nimport { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';\nimport { Member } from '../types/cube-types/query';\nimport { Measure, TableSchema } from '../types/cube-types/table';\nimport { meerkatPlaceholderReplacer } from '../utils/meerkat-placeholder-replacer';\n\nexport const cubeMeasureToSQLSelectString = (\n  measures: Member[],\n  tableSchema: TableSchema\n) => {\n  let base = 'SELECT';\n  for (let i = 0; i < measures.length; i++) {\n    const measure = measures[i];\n    if (measure === '*') {\n      base += ` ${tableSchema.name}.*`;\n      continue;\n    }\n    const [tableSchemaName, measureKeyWithoutTable] =\n      splitIntoDataSourceAndFields(measure);\n\n    const aliasKey = memberKeyToSafeKey(measure);\n    const measureSchema = tableSchema.measures.find(\n      (m) => m.name === measureKeyWithoutTable\n    );\n    if (!measureSchema) {\n      continue;\n    }\n    if (i > 0) {\n      base += ', ';\n    }\n    let meerkatReplacedSqlString = meerkatPlaceholderReplacer(\n      measureSchema.sql,\n      tableSchema.name\n    );\n\n    /**\n     * Here we extract the columns used in the measure and replace them with the safeKey.\n     * We need to do this because the columns used in the measure are not directly available in the joined table.\n     * Thus we need to project them and use them in the join.\n     */\n\n    const columnsUsedInMeasure = getColumnsFromSQL(\n      meerkatReplacedSqlString,\n      tableSchemaName\n    );\n\n    //Replace all the columnsUsedInMeasure with safeKey\n    columnsUsedInMeasure?.forEach((measureKey) => {\n      const [_, column] = splitIntoDataSourceAndFields(measureKey);\n      const memberKey = `${tableSchemaName}.${column}`;\n      const columnKey = memberKeyToSafeKey(memberKey);\n      meerkatReplacedSqlString = meerkatReplacedSqlString.replace(\n        memberKey,\n        columnKey\n      );\n    });\n\n    base += ` ${meerkatReplacedSqlString} AS ${aliasKey} `;\n  }\n  return base;\n};\n\nconst addDimensionToSQLProjection = (\n  dimensions: Member[],\n  selectString: string,\n  tableSchema: TableSchema\n) => {\n  if (dimensions.length === 0) {\n    return selectString;\n  }\n  let newSelectString = selectString;\n  for (let i = 0; i < dimensions.length; i++) {\n    const dimension = dimensions[i];\n    const [_, dimensionKeyWithoutTable] =\n      splitIntoDataSourceAndFields(dimension);\n    const dimensionSchema = tableSchema.dimensions.find(\n      (m) => m.name === dimensionKeyWithoutTable\n    );\n    const aliasKey = memberKeyToSafeKey(dimension);\n\n    if (!dimensionSchema) {\n      continue;\n    }\n    if (i > 0) {\n      newSelectString += ',';\n    }\n    // since alias key is expected to have been unfurled in the base query, we can just use it as is.\n    newSelectString += `  ${aliasKey}`;\n  }\n  return newSelectString;\n};\n\nexport const getSelectReplacedSql = (sql: string, selectString: string) => {\n  /*\n   ** Replaces the select portion of a SQL string with the selectString passed.\n   */\n  const selectRegex = /SELECT\\s\\*/;\n  const match = sql.match(selectRegex);\n  if (!match) {\n    return sql;\n  }\n  const selectIndex = match.index;\n  if (selectIndex === undefined) {\n    throw new Error('SELECT * not found in SQL string');\n  }\n  const selectLength = match[0].length;\n  const beforeSelect = sql.substring(0, selectIndex);\n  const afterSelect = sql.substring(selectIndex + selectLength);\n  return `${beforeSelect}${selectString}${afterSelect}`;\n};\n\n/**\n * Get all the columns used in the measures.\n * This is used for extracting the columns used in the measures needed for the projection.\n * Example: The joins implementation uses this to get the columns used in the measures to join the tables.\n * like the SQL for the measure is `SUM(table.total)` and the table name is `table`, then the column used is `total`\n * table cannot be used directly here because the joined table would have column name ambiguity.\n * Thus these columns are projected and directly used in the join.\n */\nexport const getAllColumnUsedInMeasures = (\n  measures: Measure[],\n  tableSchema: TableSchema\n) => {\n  let columns: string[] = [];\n  measures.forEach((measure) => {\n    const columnMatch = getColumnsFromSQL(measure.sql, tableSchema.name);\n    if (columnMatch && columnMatch.length > 0) {\n      columns = [...columns, ...columnMatch];\n    }\n  });\n  // Remove duplicates\n  return [...new Set(columns)];\n};\n\nconst getColumnsFromSQL = (sql: string, tableName: string) => {\n  const regex = new RegExp(`(${tableName}\\\\.[a-zA-Z0-9_]+)`, 'g');\n  const columnMatch = sql.match(regex);\n  return columnMatch;\n};\n\n/**\n * Replace the first SELECT * from the sqlToReplace with the cube measure\n * @param measures\n * @param tableSchema\n * @param sqlToReplace\n * @returns\n */\nexport const applyProjectionToSQLQuery = (\n  dimensions: Member[],\n  measures: Member[],\n  tableSchema: TableSchema,\n  sqlToReplace: string\n) => {\n  let measureSelectString = cubeMeasureToSQLSelectString(measures, tableSchema);\n\n  if (measures.length > 0 && dimensions.length > 0) {\n    measureSelectString += ', ';\n  }\n  const selectString = addDimensionToSQLProjection(\n    dimensions,\n    measureSelectString,\n    tableSchema\n  );\n\n  return getSelectReplacedSql(sqlToReplace, selectString);\n};\n"],"names":["applyProjectionToSQLQuery","cubeMeasureToSQLSelectString","getAllColumnUsedInMeasures","getSelectReplacedSql","measures","tableSchema","base","i","length","measure","name","tableSchemaName","measureKeyWithoutTable","splitIntoDataSourceAndFields","aliasKey","memberKeyToSafeKey","measureSchema","find","m","meerkatReplacedSqlString","meerkatPlaceholderReplacer","sql","columnsUsedInMeasure","getColumnsFromSQL","forEach","measureKey","_","column","memberKey","columnKey","replace","addDimensionToSQLProjection","dimensions","selectString","newSelectString","dimension","dimensionKeyWithoutTable","dimensionSchema","selectRegex","match","selectIndex","index","undefined","Error","selectLength","beforeSelect","substring","afterSelect","columns","columnMatch","Set","tableName","regex","RegExp","sqlToReplace","measureSelectString"],"mappings":"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"}

package/cube-order-by-transformer/cube-order-by-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-order-by-transformer/cube-order-by-transformer.ts"],"sourcesContent":["import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';\nimport {\n  ExpressionClass,\n  ExpressionType,\n} from '../types/duckdb-serialization-types/serialization/Expression';\nimport { OrderType } from '../types/duckdb-serialization-types/serialization/Nodes';\nimport { ResultModifierType } from '../types/duckdb-serialization-types/serialization/ResultModifier';\n\nexport const cubeOrderByToAST = (order: { [key: string]: 'asc' | 'desc' }) => {\n  const orderArr = [];\n  for (const key in order) {\n    const value = order[key];\n    const astOrderBy =\n      value === 'asc' ? OrderType.ASCENDING : OrderType.DESCENDING;\n    const orderByAST = {\n      type: astOrderBy,\n      null_order: OrderType.ORDER_DEFAULT,\n      expression: {\n        class: ExpressionClass.COLUMN_REF,\n        type: ExpressionType.COLUMN_REF,\n        alias: '',\n        /**\n         * We need to convert the key in the __ format as they are being projected in this format\n         */\n        column_names: [memberKeyToSafeKey(key)],\n      },\n    };\n    orderArr.push(orderByAST);\n  }\n  return {\n    type: ResultModifierType.ORDER_MODIFIER,\n    orders: orderArr,\n  };\n};\n"],"names":["cubeOrderByToAST","order","orderArr","key","value","astOrderBy","OrderType","ASCENDING","DESCENDING","orderByAST","type","null_order","ORDER_DEFAULT","expression","class","ExpressionClass","COLUMN_REF","ExpressionType","alias","column_names","memberKeyToSafeKey","push","ResultModifierType","ORDER_MODIFIER","orders"],"mappings":";+BAQaA;;;eAAAA;;;oCARsB;4BAI5B;uBACmB;gCACS;AAE5B,MAAMA,mBAAmB,CAACC;IAC/B,MAAMC,WAAW,EAAE;IACnB,IAAK,MAAMC,OAAOF,MAAO;QACvB,MAAMG,QAAQH,KAAK,CAACE,IAAI;QACxB,MAAME,aACJD,UAAU,QAAQE,gBAAS,CAACC,SAAS,GAAGD,gBAAS,CAACE,UAAU;QAC9D,MAAMC,aAAa;YACjBC,MAAML;YACNM,YAAYL,gBAAS,CAACM,aAAa;YACnCC,YAAY;gBACVC,OAAOC,2BAAe,CAACC,UAAU;gBACjCN,MAAMO,0BAAc,CAACD,UAAU;gBAC/BE,OAAO;gBACP;;SAEC,GACDC,cAAc;oBAACC,IAAAA,sCAAkB,EAACjB;iBAAK;YACzC;QACF;QACAD,SAASmB,IAAI,CAACZ;IAChB;IACA,OAAO;QACLC,MAAMY,kCAAkB,CAACC,cAAc;QACvCC,QAAQtB;IACV;AACF"}

package/cube-to-duckdb/cube-filter-to-duckdb.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/cube-to-duckdb/cube-filter-to-duckdb.ts"],"names":[],"mappings":""}

package/{src/filter-params → filter-params}/filter-params-ast.js

@@ -6,20 +6,20 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    traverseAndFilter: function() {
-        return traverseAndFilter;
-    },
-    getFilterByMemberKey: function() {
-        return getFilterByMemberKey;
+    applyFilterParamsToBaseSQL: function() {
+        return applyFilterParamsToBaseSQL;
     },
     detectAllFilterParamsFromSQL: function() {
         return detectAllFilterParamsFromSQL;
     },
+    getFilterByMemberKey: function() {
+        return getFilterByMemberKey;
+    },
     getFilterParamsAST: function() {
         return getFilterParamsAST;
     },
-    applyFilterParamsToBaseSQL: function() {
-        return applyFilterParamsToBaseSQL;
+    traverseAndFilter: function() {
+        return traverseAndFilter;
     }
 });
 const _astbuilder = require("../ast-builder/ast-builder");

package/filter-params/filter-params-ast.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/filter-params/filter-params-ast.ts"],"sourcesContent":["import { cubeToDuckdbAST } from '../ast-builder/ast-builder';\nimport {\n  FilterType,\n  LogicalAndFilter,\n  LogicalOrFilter,\n  MeerkatQueryFilter,\n  Query,\n  QueryFilter,\n  TableSchema\n} from '../types/cube-types';\nimport { SelectStatement } from '../types/duckdb-serialization-types/serialization/Statement';\n\n/**\n * Get the query filter with only where filterKey matches\n */\n\nexport const traverseAndFilter = (\n  filter: MeerkatQueryFilter,\n  callback: (value: QueryFilter) => boolean\n): MeerkatQueryFilter | null => {\n  if ('member' in filter) {\n    return callback(filter) ? filter : null;\n  }\n\n  if ('and' in filter) {\n    const filteredAndFilters = filter.and\n      .map((subFilter) => traverseAndFilter(subFilter, callback))\n      .filter(Boolean) as MeerkatQueryFilter[];\n    const obj =\n      filteredAndFilters.length > 0 ? { and: filteredAndFilters } : null;\n    return obj as LogicalAndFilter;\n  }\n\n  if ('or' in filter) {\n    const filteredOrFilters = filter.or\n      .map((subFilter) => traverseAndFilter(subFilter, callback))\n      .filter(Boolean);\n    const obj = filteredOrFilters.length > 0 ? { or: filteredOrFilters } : null;\n    return obj as LogicalOrFilter;\n  }\n\n  return null;\n};\n\n\nexport const getFilterByMemberKey = (\n  filters: MeerkatQueryFilter[] | undefined,\n  memberKey: string\n): MeerkatQueryFilter[] => {\n  if (!filters) return [];\n  return filters\n    .map((filter) => traverseAndFilter(filter, (value) =>  value.member === memberKey))\n    .filter(Boolean) as MeerkatQueryFilter[];\n};\n\n/**\n * Syntax for filter params in SQL:\n * FILTER_PARAMS.cube_name.member_name.filter(sql_expression)\n * Example:\n *  SELECT *\n *  FROM orders\n *  WHERE ${FILTER_PARAMS.order_facts.date.filter('date')}\n * @param sql\n */\nexport const detectAllFilterParamsFromSQL = (\n  sql: string\n): {\n  memberKey: string;\n  filterExpression: string;\n  matchKey: string;\n}[] => {\n  const regex = /\\${FILTER_PARAMS\\.(\\w+\\.\\w+)\\.filter\\('(\\w+)'\\)}/g;\n  const matches = [];\n  let match;\n  while ((match = regex.exec(sql)) !== null) {\n    matches.push({\n      memberKey: match[1],\n      filterExpression: match[2],\n      matchKey: match[0],\n    });\n  }\n  return matches;\n};\n\n\n\nexport const getFilterParamsAST = (\n  query: Query,\n  tableSchema: TableSchema,\n  filterType: FilterType = 'PROJECTION_FILTER'\n): {\n  memberKey: string;\n  ast: SelectStatement | null;\n  matchKey: string;\n}[] => {\n  const filterParamKeys = detectAllFilterParamsFromSQL(tableSchema.sql);\n  const filterParamsAST = [];\n  \n  for (const filterParamKey of filterParamKeys) {\n    const filters = getFilterByMemberKey(\n      query.filters,\n      filterParamKey.memberKey\n    );\n   \n    if (filters && filters.length > 0) {\n      filterParamsAST.push({\n        memberKey: filterParamKey.memberKey,\n        matchKey: filterParamKey.matchKey,\n        ast: cubeToDuckdbAST(\n          { filters, measures: [], dimensions: [] },\n          tableSchema,\n          {\n            filterType\n          }\n        ),\n      });\n    }\n  }\n\n  return filterParamsAST;\n};\n\ntype FilterParamsSQL = {\n  memberKey: string;\n  sql: string;\n  matchKey: string;\n}\n\nconst replaceWhereClauseWithFiltersParamsSQL = (baseSQL: string, filterParamsSQL: FilterParamsSQL[]) => {\n  let finalSQL = baseSQL;\n\n  for (const filterParam of filterParamsSQL) {\n    /**\n     * Get SQL expression after WHERE clause\n     */\n    const whereClause = filterParam.sql.split('WHERE')[1];\n    /**\n     * Replace filter param with SQL expression\n     */\n    finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);\n  }\n  return finalSQL\n}\n\nexport const applyFilterParamsToBaseSQL = (\n  baseSQL: string,\n  filterParamsSQL: FilterParamsSQL[]\n) => {\n  let finalSQL = replaceWhereClauseWithFiltersParamsSQL(baseSQL, filterParamsSQL);\n  for (const filterParam of filterParamsSQL) {\n    /**\n     * Get SQL expression after WHERE clause\n     */\n    const whereClause = filterParam.sql.split('WHERE')[1];\n    /**\n     * Replace filter param with SQL expression\n     */\n    finalSQL = finalSQL.replace(filterParam.matchKey, whereClause);\n  }\n  /**\n   * Find all remaining filter params and replace them with TRUE\n   */\n  const remainingFilterParams = detectAllFilterParamsFromSQL(finalSQL);\n\n  for (const filterParam of remainingFilterParams) {\n    finalSQL = finalSQL.replace(filterParam.matchKey, 'TRUE');\n  }\n  return finalSQL;\n};\n"],"names":["applyFilterParamsToBaseSQL","detectAllFilterParamsFromSQL","getFilterByMemberKey","getFilterParamsAST","traverseAndFilter","filter","callback","filteredAndFilters","and","map","subFilter","Boolean","obj","length","filteredOrFilters","or","filters","memberKey","value","member","sql","regex","matches","match","exec","push","filterExpression","matchKey","query","tableSchema","filterType","filterParamKeys","filterParamsAST","filterParamKey","ast","cubeToDuckdbAST","measures","dimensions","replaceWhereClauseWithFiltersParamsSQL","baseSQL","filterParamsSQL","finalSQL","filterParam","whereClause","split","replace","remainingFilterParams"],"mappings":"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"}

package/get-filter-params-sql/get-filter-params-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-filter-params-sql/get-filter-params-sql.ts"],"sourcesContent":["import { astDeserializerQuery, deserializeQuery } from \"../ast-deserializer/ast-deserializer\";\nimport { getFilterParamsAST } from \"../filter-params/filter-params-ast\";\nimport { FilterType, Query, TableSchema } from \"../types/cube-types\";\n\nexport const getFilterParamsSQL = async ({\n  query,\n  tableSchema,\n  filterType,\n  getQueryOutput\n}: {\n  query: Query;\n  tableSchema: TableSchema;\n  filterType?: FilterType;\n  getQueryOutput: (query: string) => Promise<any>;\n}) => {\n  const filterParamsAST = getFilterParamsAST(\n    query,\n    tableSchema,\n    filterType\n  );\n  const filterParamsSQL = [];\n  for (const filterParamAST of filterParamsAST) {\n    if (!filterParamAST.ast) {\n      continue;\n    }\n\n    const queryOutput = await getQueryOutput(astDeserializerQuery(filterParamAST.ast))\n    const sql = deserializeQuery(queryOutput);\n\n    filterParamsSQL.push({\n      memberKey: filterParamAST.memberKey,\n      sql: sql,\n      matchKey: filterParamAST.matchKey,\n    });\n  }\n  return filterParamsSQL;\n};\n"],"names":["getFilterParamsSQL","query","tableSchema","filterType","getQueryOutput","filterParamsAST","getFilterParamsAST","filterParamsSQL","filterParamAST","ast","queryOutput","astDeserializerQuery","sql","deserializeQuery","push","memberKey","matchKey"],"mappings":";+BAIaA;;;eAAAA;;;iCAJ0C;iCACpB;AAG5B,MAAMA,qBAAqB,OAAO,EACvCC,KAAK,EACLC,WAAW,EACXC,UAAU,EACVC,cAAc,EAMf;IACC,MAAMC,kBAAkBC,IAAAA,mCAAkB,EACxCL,OACAC,aACAC;IAEF,MAAMI,kBAAkB,EAAE;IAC1B,KAAK,MAAMC,kBAAkBH,gBAAiB;QAC5C,IAAI,CAACG,eAAeC,GAAG,EAAE;YACvB;QACF;QAEA,MAAMC,cAAc,MAAMN,eAAeO,IAAAA,qCAAoB,EAACH,eAAeC,GAAG;QAChF,MAAMG,MAAMC,IAAAA,iCAAgB,EAACH;QAE7BH,gBAAgBO,IAAI,CAAC;YACnBC,WAAWP,eAAeO,SAAS;YACnCH,KAAKA;YACLI,UAAUR,eAAeQ,QAAQ;QACnC;IACF;IACA,OAAOT;AACT"}

package/get-final-base-sql/get-final-base-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-final-base-sql/get-final-base-sql.ts"],"sourcesContent":["import { applyFilterParamsToBaseSQL } from \"../filter-params/filter-params-ast\";\nimport { getFilterParamsSQL } from \"../get-filter-params-sql/get-filter-params-sql\";\nimport { getWrappedBaseQueryWithProjections } from \"../get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections\";\nimport { Query } from \"../types/cube-types/query\";\nimport { TableSchema } from \"../types/cube-types/table\";\n\nexport const getFinalBaseSQL = async ({\n  query,\n  getQueryOutput,\n  tableSchema,\n}: { query: Query, tableSchema: TableSchema, getQueryOutput: (query: string) => Promise<any> }) => {\n  /**\n   * Apply transformation to the supplied base query.\n   * This involves updating the filter placeholder with the actual filter values.\n   */\n  const baseFilterParamsSQL = await getFilterParamsSQL({\n    query: query,\n    tableSchema,\n    filterType: 'BASE_FILTER',\n    getQueryOutput,\n  });\n  const baseSQL = applyFilterParamsToBaseSQL(\n    tableSchema.sql,\n    baseFilterParamsSQL\n  );\n  const baseSQLWithFilterProjection = getWrappedBaseQueryWithProjections({\n    baseQuery: baseSQL,\n    tableSchema,\n    query: query,\n  });\n  return baseSQLWithFilterProjection;\n};\n  \n"],"names":["getFinalBaseSQL","query","getQueryOutput","tableSchema","baseFilterParamsSQL","getFilterParamsSQL","filterType","baseSQL","applyFilterParamsToBaseSQL","sql","baseSQLWithFilterProjection","getWrappedBaseQueryWithProjections","baseQuery"],"mappings":";+BAMaA;;;eAAAA;;;iCAN8B;oCACR;oDACgB;AAI5C,MAAMA,kBAAkB,OAAO,EACpCC,KAAK,EACLC,cAAc,EACdC,WAAW,EACiF;IAC5F;;;GAGC,GACD,MAAMC,sBAAsB,MAAMC,IAAAA,sCAAkB,EAAC;QACnDJ,OAAOA;QACPE;QACAG,YAAY;QACZJ;IACF;IACA,MAAMK,UAAUC,IAAAA,2CAA0B,EACxCL,YAAYM,GAAG,EACfL;IAEF,MAAMM,8BAA8BC,IAAAA,sEAAkC,EAAC;QACrEC,WAAWL;QACXJ;QACAF,OAAOA;IACT;IACA,OAAOS;AACT"}

package/{src/get-wrapped-base-query-with-projections → get-wrapped-base-query-with-projections}/get-aliased-columns-from-filters.js

@@ -6,14 +6,14 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    getAliasedColumnsFromFilters: function() {
+        return getAliasedColumnsFromFilters;
+    },
     getDimensionProjection: function() {
         return getDimensionProjection;
     },
     getFilterMeasureProjection: function() {
         return getFilterMeasureProjection;
-    },
-    getAliasedColumnsFromFilters: function() {
-        return getAliasedColumnsFromFilters;
     }
 });
 const _memberkeytosafekey = require("../member-formatters/member-key-to-safe-key");

package/get-wrapped-base-query-with-projections/get-aliased-columns-from-filters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-wrapped-base-query-with-projections/get-aliased-columns-from-filters.ts"],"sourcesContent":["import { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';\nimport { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';\nimport { MeerkatQueryFilter, Query, TableSchema } from '../types/cube-types';\nimport {\n  findInDimensionSchema,\n  findInMeasureSchema,\n} from '../utils/find-in-table-schema';\nimport { getModifiedSqlExpression, Modifier } from './sql-expression-modifiers';\n\nexport const getDimensionProjection = ({\n  key,\n  tableSchema,\n  modifiers,\n  query,\n}: {\n  key: string;\n  tableSchema: TableSchema;\n  modifiers: Modifier[];\n  query: Query;\n}) => {\n  // Find the table access key\n  const [tableName, measureWithoutTable] = splitIntoDataSourceAndFields(key);\n\n  const foundMember = findInDimensionSchema(measureWithoutTable, tableSchema);\n  if (!foundMember || tableName !== tableSchema.name) {\n    // If the selected member is not found in the table schema or if it is already selected, continue.\n    // If the selected member is not from the current table, don't create an alias.\n    return {\n      sql: undefined,\n      foundMember: undefined,\n      aliasKey: undefined,\n    };\n  }\n\n  const modifiedSql = getModifiedSqlExpression({\n    dimension: foundMember,\n    key: key,\n    modifiers: modifiers,\n    sqlExpression: foundMember.sql,\n    query,\n  });\n\n  const aliasKey = memberKeyToSafeKey(key);\n  // Add the alias key to the set. So we have a reference to all the previously selected members.\n  return { sql: `${modifiedSql} AS ${aliasKey}`, foundMember, aliasKey };\n};\n\nexport const getFilterMeasureProjection = ({\n  key,\n  tableSchema,\n  measures,\n}: {\n  key: string;\n  tableSchema: TableSchema;\n  measures: string[];\n}) => {\n  const [tableName, measureWithoutTable] = splitIntoDataSourceAndFields(key);\n  const foundMember = findInMeasureSchema(measureWithoutTable, tableSchema);\n  const isMeasure = measures.includes(key);\n  if (!foundMember || isMeasure || tableName !== tableSchema.name) {\n    // If the selected member is not found in the table schema or if it is already selected, continue.\n    // If the selected member is a measure, don't create an alias. Since measure computation is done in the outermost level of the query\n    // If the selected member is not from the current table, don't create an alias.\n    return {\n      sql: undefined,\n      foundMember: undefined,\n      aliasKey: undefined,\n    };\n  }\n  const aliasKey = memberKeyToSafeKey(key);\n  return { sql: `${key} AS ${aliasKey}`, foundMember, aliasKey };\n};\n\nconst getFilterProjections = ({\n  member,\n  tableSchema,\n  measures,\n  query,\n}: {\n  member: string;\n  tableSchema: TableSchema;\n  measures: string[];\n  query: Query;\n}) => {\n  const [, memberWithoutTable] = splitIntoDataSourceAndFields(member);\n  const isDimension = findInDimensionSchema(memberWithoutTable, tableSchema);\n  if (isDimension) {\n    return getDimensionProjection({\n      key: member,\n      tableSchema,\n      modifiers: [],\n      query,\n    });\n  }\n  const isMeasure = findInMeasureSchema(memberWithoutTable, tableSchema);\n  if (isMeasure) {\n    return getFilterMeasureProjection({ key: member, tableSchema, measures });\n  }\n  return {\n    sql: undefined,\n    foundMember: undefined,\n    aliasKey: undefined,\n  };\n};\n\nexport const getAliasedColumnsFromFilters = ({\n  baseSql,\n  meerkatFilters,\n  tableSchema,\n  aliasedColumnSet,\n  query,\n}: {\n  meerkatFilters?: MeerkatQueryFilter[];\n  tableSchema: TableSchema;\n  baseSql: string;\n  aliasedColumnSet: Set<string>;\n  query: Query;\n}) => {\n  let sql = baseSql;\n  const { measures } = query;\n  meerkatFilters?.forEach((filter) => {\n    if ('and' in filter) {\n      // Traverse through the passed 'and' filters\n      sql += getAliasedColumnsFromFilters({\n        baseSql: '',\n        meerkatFilters: filter.and,\n        tableSchema,\n        aliasedColumnSet,\n        query,\n      });\n    }\n    if ('or' in filter) {\n      // Traverse through the passed 'or' filters\n      sql += getAliasedColumnsFromFilters({\n        baseSql: '',\n        tableSchema,\n        meerkatFilters: filter.or,\n        aliasedColumnSet,\n        query,\n      });\n    }\n    if ('member' in filter) {\n      const {\n        aliasKey,\n        foundMember,\n        sql: memberSql,\n      } = getFilterProjections({\n        member: filter.member,\n        tableSchema,\n        measures,\n        query,\n      });\n      if (!foundMember || aliasedColumnSet.has(aliasKey)) {\n        // If the selected member is not found in the table schema or if it is already selected, continue.\n        return;\n      }\n      if (aliasKey) {\n        aliasedColumnSet.add(aliasKey);\n      }\n      // Add the alias key to the set. So we have a reference to all the previously selected members.\n      sql += `, ${memberSql}`;\n    }\n  });\n  return sql;\n};\n"],"names":["getAliasedColumnsFromFilters","getDimensionProjection","getFilterMeasureProjection","key","tableSchema","modifiers","query","tableName","measureWithoutTable","splitIntoDataSourceAndFields","foundMember","findInDimensionSchema","name","sql","undefined","aliasKey","modifiedSql","getModifiedSqlExpression","dimension","sqlExpression","memberKeyToSafeKey","measures","findInMeasureSchema","isMeasure","includes","getFilterProjections","member","memberWithoutTable","isDimension","baseSql","meerkatFilters","aliasedColumnSet","forEach","filter","and","or","memberSql","has","add"],"mappings":"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"}

package/get-wrapped-base-query-with-projections/get-projection-clause.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-wrapped-base-query-with-projections/get-projection-clause.ts"],"sourcesContent":["import { getAllColumnUsedInMeasures } from '../cube-measure-transformer/cube-measure-transformer';\nimport { memberKeyToSafeKey } from '../member-formatters/member-key-to-safe-key';\nimport { splitIntoDataSourceAndFields } from '../member-formatters/split-into-data-source-and-fields';\nimport { Query, TableSchema } from '../types/cube-types';\nimport {\n  getDimensionProjection,\n  getFilterMeasureProjection,\n} from './get-aliased-columns-from-filters';\nimport { MODIFIERS } from './sql-expression-modifiers';\n\nconst memberClauseAggregator = ({\n  member,\n  aliasedColumnSet,\n  acc,\n  sql,\n}: {\n  member: string;\n  aliasedColumnSet: Set<string>;\n  acc: string[];\n  sql?: string;\n  currentIndex: number;\n  members: string[];\n}) => {\n  if (aliasedColumnSet.has(member) || !sql) {\n    return acc;\n  }\n  aliasedColumnSet.add(member);\n  acc.push(sql);\n  return acc;\n};\n\nexport const getProjectionClause = (\n  query: Query,\n  tableSchema: TableSchema,\n  aliasedColumnSet: Set<string>\n) => {\n  const { measures, dimensions = [] } = query;\n  const filteredDimensions = dimensions.filter((dimension) => {\n    const [dimensionDataSource] = splitIntoDataSourceAndFields(dimension);\n    return dimensionDataSource === tableSchema.name;\n  });\n  const filteredMeasures = measures.filter((measure) => {\n    const [measureDataSource] = splitIntoDataSourceAndFields(measure);\n    return measureDataSource === tableSchema.name;\n  });\n  const dimensionsProjectionsArr = filteredDimensions.reduce(\n    (acc, member, currentIndex, members) => {\n      const { sql: memberSql } = getDimensionProjection({\n        key: member,\n        tableSchema,\n        modifiers: MODIFIERS,\n        query,\n      });\n      return memberClauseAggregator({\n        member: memberKeyToSafeKey(member),\n        aliasedColumnSet,\n        acc,\n        currentIndex,\n        members,\n        sql: memberSql,\n      });\n    },\n    [] as string[]\n  );\n  const dimensionsProjections = dimensionsProjectionsArr.join(', ');\n\n  const measureProjectionsArr = filteredMeasures.reduce(\n    (acc, member, currentIndex, members) => {\n      const { sql: memberSql } = getFilterMeasureProjection({\n        key: member,\n        tableSchema,\n        measures,\n      });\n      return memberClauseAggregator({\n        member,\n        aliasedColumnSet,\n        acc,\n        currentIndex,\n        members,\n        sql: memberSql,\n      });\n    },\n    [] as string[]\n  );\n\n  const measureProjections = measureProjectionsArr.join(', ');\n\n  const usedMeasureObjects = tableSchema.measures.filter((measure) => {\n    return (\n      measures.findIndex((key) => {\n        const [, keyWithoutTable] = splitIntoDataSourceAndFields(key);\n        return keyWithoutTable === measure.name;\n      }) !== -1\n    );\n  });\n  const columnsUsedInMeasures = getAllColumnUsedInMeasures(\n    usedMeasureObjects,\n    tableSchema\n  );\n\n  let columnsUsedInMeasuresInProjection = '';\n  columnsUsedInMeasures.forEach((column, index) => {\n    const safeKey = memberKeyToSafeKey(column);\n    columnsUsedInMeasuresInProjection += `${column} AS ${safeKey}`;\n    if (index !== columnsUsedInMeasures.length - 1) {\n      columnsUsedInMeasuresInProjection += ', ';\n    }\n  });\n\n  const combinedStr = [\n    dimensionsProjections,\n    measureProjections,\n    columnsUsedInMeasuresInProjection,\n  ];\n\n  return combinedStr.filter((str) => str.length > 0).join(', ');\n};\n"],"names":["getProjectionClause","memberClauseAggregator","member","aliasedColumnSet","acc","sql","has","add","push","query","tableSchema","measures","dimensions","filteredDimensions","filter","dimension","dimensionDataSource","splitIntoDataSourceAndFields","name","filteredMeasures","measure","measureDataSource","dimensionsProjectionsArr","reduce","currentIndex","members","memberSql","getDimensionProjection","key","modifiers","MODIFIERS","memberKeyToSafeKey","dimensionsProjections","join","measureProjectionsArr","getFilterMeasureProjection","measureProjections","usedMeasureObjects","findIndex","keyWithoutTable","columnsUsedInMeasures","getAllColumnUsedInMeasures","columnsUsedInMeasuresInProjection","forEach","column","index","safeKey","length","combinedStr","str"],"mappings":";+BA+BaA;;;eAAAA;;;wCA/B8B;oCACR;8CACU;8CAKtC;wCACmB;AAE1B,MAAMC,yBAAyB,CAAC,EAC9BC,MAAM,EACNC,gBAAgB,EAChBC,GAAG,EACHC,GAAG,EAQJ;IACC,IAAIF,iBAAiBG,GAAG,CAACJ,WAAW,CAACG,KAAK;QACxC,OAAOD;IACT;IACAD,iBAAiBI,GAAG,CAACL;IACrBE,IAAII,IAAI,CAACH;IACT,OAAOD;AACT;AAEO,MAAMJ,sBAAsB,CACjCS,OACAC,aACAP;IAEA,MAAM,EAAEQ,QAAQ,EAAEC,aAAa,EAAE,EAAE,GAAGH;IACtC,MAAMI,qBAAqBD,WAAWE,MAAM,CAAC,CAACC;QAC5C,MAAM,CAACC,oBAAoB,GAAGC,IAAAA,0DAA4B,EAACF;QAC3D,OAAOC,wBAAwBN,YAAYQ,IAAI;IACjD;IACA,MAAMC,mBAAmBR,SAASG,MAAM,CAAC,CAACM;QACxC,MAAM,CAACC,kBAAkB,GAAGJ,IAAAA,0DAA4B,EAACG;QACzD,OAAOC,sBAAsBX,YAAYQ,IAAI;IAC/C;IACA,MAAMI,2BAA2BT,mBAAmBU,MAAM,CACxD,CAACnB,KAAKF,QAAQsB,cAAcC;QAC1B,MAAM,EAAEpB,KAAKqB,SAAS,EAAE,GAAGC,IAAAA,oDAAsB,EAAC;YAChDC,KAAK1B;YACLQ;YACAmB,WAAWC,iCAAS;YACpBrB;QACF;QACA,OAAOR,uBAAuB;YAC5BC,QAAQ6B,IAAAA,sCAAkB,EAAC7B;YAC3BC;YACAC;YACAoB;YACAC;YACApB,KAAKqB;QACP;IACF,GACA,EAAE;IAEJ,MAAMM,wBAAwBV,yBAAyBW,IAAI,CAAC;IAE5D,MAAMC,wBAAwBf,iBAAiBI,MAAM,CACnD,CAACnB,KAAKF,QAAQsB,cAAcC;QAC1B,MAAM,EAAEpB,KAAKqB,SAAS,EAAE,GAAGS,IAAAA,wDAA0B,EAAC;YACpDP,KAAK1B;YACLQ;YACAC;QACF;QACA,OAAOV,uBAAuB;YAC5BC;YACAC;YACAC;YACAoB;YACAC;YACApB,KAAKqB;QACP;IACF,GACA,EAAE;IAGJ,MAAMU,qBAAqBF,sBAAsBD,IAAI,CAAC;IAEtD,MAAMI,qBAAqB3B,YAAYC,QAAQ,CAACG,MAAM,CAAC,CAACM;QACtD,OACET,SAAS2B,SAAS,CAAC,CAACV;YAClB,MAAM,GAAGW,gBAAgB,GAAGtB,IAAAA,0DAA4B,EAACW;YACzD,OAAOW,oBAAoBnB,QAAQF,IAAI;QACzC,OAAO,CAAC;IAEZ;IACA,MAAMsB,wBAAwBC,IAAAA,kDAA0B,EACtDJ,oBACA3B;IAGF,IAAIgC,oCAAoC;IACxCF,sBAAsBG,OAAO,CAAC,CAACC,QAAQC;QACrC,MAAMC,UAAUf,IAAAA,sCAAkB,EAACa;QACnCF,qCAAqC,CAAC,EAAEE,OAAO,IAAI,EAAEE,QAAQ,CAAC;QAC9D,IAAID,UAAUL,sBAAsBO,MAAM,GAAG,GAAG;YAC9CL,qCAAqC;QACvC;IACF;IAEA,MAAMM,cAAc;QAClBhB;QACAI;QACAM;KACD;IAED,OAAOM,YAAYlC,MAAM,CAAC,CAACmC,MAAQA,IAAIF,MAAM,GAAG,GAAGd,IAAI,CAAC;AAC1D"}

package/get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections.ts"],"sourcesContent":["import { getSelectReplacedSql } from '../cube-measure-transformer/cube-measure-transformer';\nimport { Query, TableSchema } from '../types/cube-types';\nimport { getAliasedColumnsFromFilters } from './get-aliased-columns-from-filters';\nimport {\n  getProjectionClause\n} from './get-projection-clause';\n\ninterface GetWrappedBaseQueryWithProjectionsParams {\n  baseQuery: string;\n  tableSchema: TableSchema;\n  query: Query;\n}\n\nexport const getWrappedBaseQueryWithProjections = ({\n  baseQuery,\n  tableSchema,\n  query,\n}: GetWrappedBaseQueryWithProjectionsParams) => {\n  /*\n   * Im order to be able to filter on computed metric from a query, we need to project the computed metric in the base query.\n   * If theres filters supplied, we can safely return the original base query. Since nothing need to be projected and filtered in this case\n   */\n  // Wrap the query into another 'SELECT * FROM (baseQuery) AS baseTable'' in order to project everything in the base query, and other computed metrics to be able to filter on them\n  const newBaseSql = `SELECT * FROM (${baseQuery}) AS ${tableSchema.name}`;\n  const aliasedColumnSet = new Set<string>();\n\n  const memberProjections = getProjectionClause(\n    query,\n    tableSchema,\n    aliasedColumnSet\n  );\n\n  const aliasFromFilters = getAliasedColumnsFromFilters({\n    aliasedColumnSet,\n    baseSql: 'SELECT *',\n    // setting measures to empty array, since we don't want to project measures present in the filters in the base query\n    tableSchema: tableSchema,\n    query,\n    meerkatFilters: query.filters,\n  });\n\n  const formattedMemberProjection = memberProjections\n    ? `, ${memberProjections}`\n    : '';\n\n  const finalAliasedColumnsClause =\n    aliasFromFilters + formattedMemberProjection;\n\n  const sqlWithFilterProjects = getSelectReplacedSql(\n    newBaseSql,\n    finalAliasedColumnsClause\n  );\n  return sqlWithFilterProjects;\n};\n"],"names":["getWrappedBaseQueryWithProjections","baseQuery","tableSchema","query","newBaseSql","name","aliasedColumnSet","Set","memberProjections","getProjectionClause","aliasFromFilters","getAliasedColumnsFromFilters","baseSql","meerkatFilters","filters","formattedMemberProjection","finalAliasedColumnsClause","sqlWithFilterProjects","getSelectReplacedSql"],"mappings":";+BAaaA;;;eAAAA;;;wCAbwB;8CAEQ;qCAGtC;AAQA,MAAMA,qCAAqC,CAAC,EACjDC,SAAS,EACTC,WAAW,EACXC,KAAK,EACoC;IACzC;;;GAGC,GACD,kLAAkL;IAClL,MAAMC,aAAa,CAAC,eAAe,EAAEH,UAAU,KAAK,EAAEC,YAAYG,IAAI,CAAC,CAAC;IACxE,MAAMC,mBAAmB,IAAIC;IAE7B,MAAMC,oBAAoBC,IAAAA,wCAAmB,EAC3CN,OACAD,aACAI;IAGF,MAAMI,mBAAmBC,IAAAA,0DAA4B,EAAC;QACpDL;QACAM,SAAS;QACT,oHAAoH;QACpHV,aAAaA;QACbC;QACAU,gBAAgBV,MAAMW,OAAO;IAC/B;IAEA,MAAMC,4BAA4BP,oBAC9B,CAAC,EAAE,EAAEA,kBAAkB,CAAC,GACxB;IAEJ,MAAMQ,4BACJN,mBAAmBK;IAErB,MAAME,wBAAwBC,IAAAA,4CAAoB,EAChDd,YACAY;IAEF,OAAOC;AACT"}

package/{src/get-wrapped-base-query-with-projections → get-wrapped-base-query-with-projections}/sql-expression-modifiers.js

@@ -6,17 +6,17 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    arrayFieldUnNestModifier: function() {
-        return arrayFieldUnNestModifier;
-    },
-    shouldUnnest: function() {
-        return shouldUnnest;
-    },
     MODIFIERS: function() {
         return MODIFIERS;
     },
+    arrayFieldUnNestModifier: function() {
+        return arrayFieldUnNestModifier;
+    },
     getModifiedSqlExpression: function() {
         return getModifiedSqlExpression;
+    },
+    shouldUnnest: function() {
+        return shouldUnnest;
     }
 });
 const _isarraymembertype = require("../utils/is-array-member-type");

package/get-wrapped-base-query-with-projections/sql-expression-modifiers.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/get-wrapped-base-query-with-projections/sql-expression-modifiers.ts"],"sourcesContent":["import { Dimension, Query } from \"../types/cube-types\";\nimport { isArrayTypeMember } from \"../utils/is-array-member-type\";\n\nexport interface DimensionModifier {\n  sqlExpression: string,\n  dimension: Dimension,\n  key: string,\n  query: Query\n}\n\nexport const arrayFieldUnNestModifier = ({ sqlExpression }: DimensionModifier): string => {\n return `array[unnest(${sqlExpression})]`;\n}\n\nexport const shouldUnnest = ({ dimension, query }: DimensionModifier): boolean => {\n  const isArrayType =  isArrayTypeMember(dimension.type);\n  const hasUnNestedGroupBy = dimension.modifier?.shouldUnnestGroupBy;\n  return !!(isArrayType && hasUnNestedGroupBy && query.measures.length > 0);\n}\n\n\nexport type Modifier = {\n  name: string,\n  matcher: (modifier: DimensionModifier) => boolean,\n  modifier: (modifier: DimensionModifier) => string\n}\n\nexport const MODIFIERS: Modifier[] = [{\n  name: 'shouldUnnestGroupBy',\n  matcher: shouldUnnest,\n  modifier: arrayFieldUnNestModifier\n}]\n\n\nexport const getModifiedSqlExpression = ({ sqlExpression, dimension, key, modifiers, query }: DimensionModifier & {\n  modifiers: Modifier[]\n}) => {\n  let finalDimension: string = sqlExpression;\n  modifiers.forEach(({ modifier, matcher }) => {\n    const shouldModify = matcher({ sqlExpression: finalDimension, dimension, key, query });\n    if (shouldModify) {\n      finalDimension = modifier({ sqlExpression: finalDimension, dimension, key, query });\n    }\n  })\n  return finalDimension;\n} "],"names":["MODIFIERS","arrayFieldUnNestModifier","getModifiedSqlExpression","shouldUnnest","sqlExpression","dimension","query","isArrayType","isArrayTypeMember","type","hasUnNestedGroupBy","modifier","shouldUnnestGroupBy","measures","length","name","matcher","key","modifiers","finalDimension","forEach","shouldModify"],"mappings":";;;;;;;;IA2BaA,SAAS;eAATA;;IAjBAC,wBAAwB;eAAxBA;;IAwBAC,wBAAwB;eAAxBA;;IApBAC,YAAY;eAAZA;;;mCAbqB;AAS3B,MAAMF,2BAA2B,CAAC,EAAEG,aAAa,EAAqB;IAC5E,OAAO,CAAC,aAAa,EAAEA,cAAc,EAAE,CAAC;AACzC;AAEO,MAAMD,eAAe,CAAC,EAAEE,SAAS,EAAEC,KAAK,EAAqB;QAEvCD;IAD3B,MAAME,cAAeC,IAAAA,oCAAiB,EAACH,UAAUI,IAAI;IACrD,MAAMC,sBAAqBL,sBAAAA,UAAUM,QAAQ,qBAAlBN,oBAAoBO,mBAAmB;IAClE,OAAO,CAAC,CAAEL,CAAAA,eAAeG,sBAAsBJ,MAAMO,QAAQ,CAACC,MAAM,GAAG,CAAA;AACzE;AASO,MAAMd,YAAwB;IAAC;QACpCe,MAAM;QACNC,SAASb;QACTQ,UAAUV;IACZ;CAAE;AAGK,MAAMC,2BAA2B,CAAC,EAAEE,aAAa,EAAEC,SAAS,EAAEY,GAAG,EAAEC,SAAS,EAAEZ,KAAK,EAEzF;IACC,IAAIa,iBAAyBf;IAC7Bc,UAAUE,OAAO,CAAC,CAAC,EAAET,QAAQ,EAAEK,OAAO,EAAE;QACtC,MAAMK,eAAeL,QAAQ;YAAEZ,eAAee;YAAgBd;YAAWY;YAAKX;QAAM;QACpF,IAAIe,cAAc;YAChBF,iBAAiBR,SAAS;gBAAEP,eAAee;gBAAgBd;gBAAWY;gBAAKX;YAAM;QACnF;IACF;IACA,OAAOa;AACT"}

package/{src/index.js → index.js}

@@ -6,8 +6,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    detectApplyContextParamsToBaseSQL: function() {
-        return _contextparamsast.detectApplyContextParamsToBaseSQL;
+    BASE_TABLE_NAME: function() {
+        return _baseast.BASE_TABLE_NAME;
+    },
+    FilterType: function() {
+        return _cubetypes.FilterType;
     },
     applyFilterParamsToBaseSQL: function() {
         return _filterparamsast.applyFilterParamsToBaseSQL;
@@ -15,6 +18,9 @@ _export(exports, {
     detectAllFilterParamsFromSQL: function() {
         return _filterparamsast.detectAllFilterParamsFromSQL;
     },
+    detectApplyContextParamsToBaseSQL: function() {
+        return _contextparamsast.detectApplyContextParamsToBaseSQL;
+    },
     getFilterParamsAST: function() {
         return _filterparamsast.getFilterParamsAST;
     },
@@ -27,12 +33,6 @@ _export(exports, {
     getWrappedBaseQueryWithProjections: function() {
         return _getwrappedbasequerywithprojections.getWrappedBaseQueryWithProjections;
     },
-    FilterType: function() {
-        return _cubetypes.FilterType;
-    },
-    BASE_TABLE_NAME: function() {
-        return _baseast.BASE_TABLE_NAME;
-    },
     meerkatPlaceholderReplacer: function() {
         return _meerkatplaceholderreplacer.meerkatPlaceholderReplacer;
     }

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../meerkat-core/src/index.ts"],"sourcesContent":["export * from './ast-builder/ast-builder';\nexport * from './ast-deserializer/ast-deserializer';\nexport * from './ast-serializer/ast-serializer';\nexport * from './ast-validator';\nexport { detectApplyContextParamsToBaseSQL } from './context-params/context-params-ast';\nexport * from './cube-measure-transformer/cube-measure-transformer';\nexport * from './cube-to-duckdb/cube-filter-to-duckdb';\nexport {\n  applyFilterParamsToBaseSQL,\n  detectAllFilterParamsFromSQL,\n  getFilterParamsAST,\n} from './filter-params/filter-params-ast';\nexport { getFilterParamsSQL } from './get-filter-params-sql/get-filter-params-sql';\nexport { getFinalBaseSQL } from './get-final-base-sql/get-final-base-sql';\nexport { getWrappedBaseQueryWithProjections } from './get-wrapped-base-query-with-projections/get-wrapped-base-query-with-projections';\nexport * from './joins/joins';\nexport * from './member-formatters';\nexport { FilterType } from './types/cube-types';\nexport * from './types/cube-types/index';\nexport * from './types/duckdb-serialization-types/index';\nexport * from './types/utils';\nexport { BASE_TABLE_NAME } from './utils/base-ast';\nexport * from './utils/cube-to-table-schema';\nexport * from './utils/get-column-names-from-ast';\nexport * from './utils/get-possible-nodes';\nexport { meerkatPlaceholderReplacer } from './utils/meerkat-placeholder-replacer';\n"],"names":["BASE_TABLE_NAME","FilterType","applyFilterParamsToBaseSQL","detectAllFilterParamsFromSQL","detectApplyContextParamsToBaseSQL","getFilterParamsAST","getFilterParamsSQL","getFinalBaseSQL","getWrappedBaseQueryWithProjections","meerkatPlaceholderReplacer"],"mappings":";;;;;;;;IAqBSA,eAAe;eAAfA,wBAAe;;IAJfC,UAAU;eAAVA,qBAAU;;IATjBC,0BAA0B;eAA1BA,2CAA0B;;IAC1BC,4BAA4B;eAA5BA,6CAA4B;;IALrBC,iCAAiC;eAAjCA,mDAAiC;;IAMxCC,kBAAkB;eAAlBA,mCAAkB;;IAEXC,kBAAkB;eAAlBA,sCAAkB;;IAClBC,eAAe;eAAfA,gCAAe;;IACfC,kCAAkC;eAAlCA,sEAAkC;;IAWlCC,0BAA0B;eAA1BA,sDAA0B;;;;uBAzBrB;uBACA;uBACA;uBACA;kCACoC;uBACpC;uBACA;iCAKP;oCAC4B;iCACH;oDACmB;uBACrC;uBACA;2BACa;uBACb;uBACA;uBACA;yBACkB;uBAClB;uBACA;uBACA;4CAC6B"}

package/{src/joins → joins}/joins.js

@@ -6,14 +6,14 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    generateSqlQuery: function() {
-        return generateSqlQuery;
+    checkLoopInJoinPath: function() {
+        return checkLoopInJoinPath;
     },
     createDirectedGraph: function() {
         return createDirectedGraph;
     },
-    checkLoopInJoinPath: function() {
-        return checkLoopInJoinPath;
+    generateSqlQuery: function() {
+        return generateSqlQuery;
     },
     getCombinedTableSchema: function() {
         return getCombinedTableSchema;

package/joins/joins.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/joins/joins.ts"],"sourcesContent":["import { JoinPath, Query, TableSchema, isJoinNode } from '../types/cube-types';\n\nexport type Graph = {\n  [key: string]: { [key: string]: { [key: string]: string } };\n};\n\nexport function generateSqlQuery(\n  path: JoinPath[],\n  tableSchemaSqlMap: { [key: string]: string },\n  directedGraph: Graph\n): string {\n  if (path.length === 0) {\n    throw new Error(\n      'Invalid path, multiple data sources are present without a join path.'\n    );\n  }\n\n  const startingNode = path[0][0].left;\n  let query = `${tableSchemaSqlMap[startingNode]}`;\n\n  /**\n   * If the starting node is not a join node, then return the query as is.\n   * It means that the query is a single node query.\n   */\n  if (!isJoinNode(path[0][0])) {\n    return query;\n  }\n\n  const visitedNodes = new Map();\n\n  for (let i = 0; i < path.length; i++) {\n    if (path[i][0].left !== startingNode) {\n      throw new Error(\n        'Invalid path, starting node is not the same for all paths.'\n      );\n    }\n    for (let j = 0; j < path[i].length; j++) {\n      const currentEdge = path[i][j];\n\n      if (!isJoinNode(currentEdge)) {\n        continue;\n      }\n\n      const visitedFrom = visitedNodes.get(currentEdge.right);\n\n      // If node is already visited from the same edge, continue to next iteration\n      if (visitedFrom && visitedFrom.left === currentEdge.left) {\n        continue;\n      }\n      // If node is already visited from a different edge, throw ambiguity error\n      if (visitedFrom) {\n        throw new Error(\n          `Path ambiguity, node ${currentEdge.right} visited from different sources`\n        );\n      }\n\n      // If visitedFrom is undefined, this is the first visit to the node\n      visitedNodes.set(currentEdge.right, currentEdge);\n\n      query += ` LEFT JOIN (${tableSchemaSqlMap[currentEdge.right]}) AS ${\n        currentEdge.right\n      }  ON ${\n        directedGraph[currentEdge.left][currentEdge.right][currentEdge.on]\n      }`;\n    }\n  }\n\n  return query;\n}\n\nexport const createDirectedGraph = (\n  tableSchema: TableSchema[],\n  tableSchemaSqlMap: { [key: string]: string }\n) => {\n  const directedGraph: {\n    [key: string]: { [key: string]: { [key: string]: string } };\n  } = {};\n\n  function addEdge(\n    table1: string,\n    table2: string,\n    joinOn: string,\n    joinCondition: string\n  ) {\n    if (\n      table1 === table2 ||\n      (directedGraph[table1] &&\n        directedGraph[table1][table2] &&\n        directedGraph[table1][table2][joinOn])\n    ) {\n      throw new Error('An invalid path was detected.');\n    }\n    if (!directedGraph[table1]) directedGraph[table1] = {};\n    if (!directedGraph[table1][table2]) directedGraph[table1][table2] = {};\n    directedGraph[table1][table2][joinOn] = joinCondition;\n  }\n  /**\n   * Iterate through the table schema and add the edges to the directed graph.\n   * The edges are added based on the join conditions provided in the table schema.\n   * The SQL is split by the '=' sign and the tables columns involved in the joins are extracted.\n   * The tables are then added as edges to the directed graph.\n   */\n  tableSchema.forEach((schema) => {\n    schema?.joins?.forEach((join) => {\n      const tables = join.sql.split('=').map((str) => str.split('.')[0].trim());\n      const conditions = join.sql\n        .split('=')\n        .map((str) => str.split('.')[1].trim());\n\n      /**\n       * If the join SQL does not contain exactly 2 tables, then the join is invalid.\n       */\n      if (tables.length !== 2) {\n        throw new Error(`Invalid join SQL: ${join.sql}`);\n      }\n\n      /**\n       * If the tables are the same, then the join is invalid.\n       */\n      if (tables[0] === tables[1]) {\n        throw new Error(`Invalid join SQL: ${join.sql}`);\n      }\n\n      /**\n       * If the tables are not found in the table schema, then the join is invalid.\n       */\n\n      if (tables[0] !== schema.name && tables[1] !== schema.name) {\n        throw new Error(\n          `Table \"${schema.name}\" not found in provided join SQL: ${join.sql}`\n        );\n      }\n\n      /**\n       * Check if the tables are found in the table schema SQL map.\n       */\n      if (!tableSchemaSqlMap[tables[0]] || !tableSchemaSqlMap[tables[1]]) {\n        return;\n      }\n      /**\n       * If the table is the source table, then add the edge from the source to the target.\n       * Thus find which table is the source and which is the target and add the edge accordingly.\n       */\n      if (tables[0] === schema.name) {\n        addEdge(tables[0], tables[1], conditions[0], join.sql);\n      } else {\n        addEdge(tables[1], tables[0], conditions[1], join.sql);\n      }\n    });\n  });\n\n  return directedGraph;\n};\n\nexport const checkLoopInJoinPath = (joinPath: JoinPath[]) => {\n  for (let i = 0; i < joinPath.length; i++) {\n    const visitedNodes = new Set<string>();\n    const currentJoinPath = joinPath[i];\n    visitedNodes.add(currentJoinPath[0].left);\n    for (let j = 0; j < currentJoinPath.length; j++) {\n      const currentEdge = currentJoinPath[j];\n      if (isJoinNode(currentEdge) && visitedNodes.has(currentEdge.right)) {\n        if (visitedNodes.has(currentEdge.right)) {\n          return true;\n        }\n        visitedNodes.add(currentEdge.right);\n      }\n    }\n  }\n  return false;\n};\n\nexport const getCombinedTableSchema = async (\n  tableSchema: TableSchema[],\n  cubeQuery: Query\n) => {\n  if (tableSchema.length === 1) {\n    return tableSchema[0];\n  }\n\n  const tableSchemaSqlMap = tableSchema.reduce(\n    (acc: { [key: string]: string }, schema: TableSchema) => {\n      return { ...acc, [schema.name]: schema.sql };\n    },\n    {}\n  );\n\n  const directedGraph = createDirectedGraph(tableSchema, tableSchemaSqlMap);\n  const hasLoop = checkLoopInJoinPath(cubeQuery.joinPaths || []);\n  if (hasLoop) {\n    throw new Error(\n      `A loop was detected in the joins. ${JSON.stringify(\n        cubeQuery.joinPaths || []\n      )}`\n    );\n  }\n\n  const baseSql = generateSqlQuery(\n    cubeQuery.joinPaths || [],\n    tableSchemaSqlMap,\n    directedGraph\n  );\n\n  const combinedTableSchema = tableSchema.reduce(\n    (acc: TableSchema, schema: TableSchema) => {\n      return {\n        name: 'MEERKAT_GENERATED_TABLE',\n        sql: baseSql,\n        measures: [...acc.measures, ...schema.measures],\n        dimensions: [...acc.dimensions, ...schema.dimensions],\n        joins: [],\n      };\n    },\n    {\n      name: '',\n      sql: '',\n      measures: [],\n      dimensions: [],\n      joins: [],\n    }\n  );\n  return combinedTableSchema;\n};\n"],"names":["checkLoopInJoinPath","createDirectedGraph","generateSqlQuery","getCombinedTableSchema","path","tableSchemaSqlMap","directedGraph","length","Error","startingNode","left","query","isJoinNode","visitedNodes","Map","i","j","currentEdge","visitedFrom","get","right","set","on","tableSchema","addEdge","table1","table2","joinOn","joinCondition","forEach","schema","joins","join","tables","sql","split","map","str","trim","conditions","name","joinPath","Set","currentJoinPath","add","has","cubeQuery","reduce","acc","hasLoop","joinPaths","JSON","stringify","baseSql","combinedTableSchema","measures","dimensions"],"mappings":"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"}

package/member-formatters/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/member-formatters/constants.ts"],"sourcesContent":["export const COLUMN_NAME_DELIMITER = '.';\nexport const MEERKAT_OUTPUT_DELIMITER = '__';\n"],"names":["COLUMN_NAME_DELIMITER","MEERKAT_OUTPUT_DELIMITER"],"mappings":";;;;;;;;IAAaA,qBAAqB;eAArBA;;IACAC,wBAAwB;eAAxBA;;;AADN,MAAMD,wBAAwB;AAC9B,MAAMC,2BAA2B"}

package/member-formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/member-formatters/index.ts"],"sourcesContent":["export { COLUMN_NAME_DELIMITER } from './constants';\nexport { memberKeyToSafeKey } from './member-key-to-safe-key';\nexport { splitIntoDataSourceAndFields } from './split-into-data-source-and-fields';\n"],"names":["COLUMN_NAME_DELIMITER","memberKeyToSafeKey","splitIntoDataSourceAndFields"],"mappings":";;;;;;;;IAASA,qBAAqB;eAArBA,gCAAqB;;IACrBC,kBAAkB;eAAlBA,sCAAkB;;IAClBC,4BAA4B;eAA5BA,0DAA4B;;;2BAFC;oCACH;8CACU"}

package/member-formatters/member-key-to-safe-key.js.map

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

package/member-formatters/split-into-data-source-and-fields.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../meerkat-core/src/member-formatters/split-into-data-source-and-fields.ts"],"sourcesContent":["import { COLUMN_NAME_DELIMITER } from './constants';\n\nexport const splitIntoDataSourceAndFields = (member: string) => {\n  const [dataSource, ...fields] = member.split(COLUMN_NAME_DELIMITER);\n  return [dataSource, fields.join(COLUMN_NAME_DELIMITER)];\n};\n"],"names":["splitIntoDataSourceAndFields","member","dataSource","fields","split","COLUMN_NAME_DELIMITER","join"],"mappings":";+BAEaA;;;eAAAA;;;2BAFyB;AAE/B,MAAMA,+BAA+B,CAACC;IAC3C,MAAM,CAACC,YAAY,GAAGC,OAAO,GAAGF,OAAOG,KAAK,CAACC,gCAAqB;IAClE,OAAO;QAACH;QAAYC,OAAOG,IAAI,CAACD,gCAAqB;KAAE;AACzD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devrev/meerkat-core",
-  "version": "0.0.92",
+  "version": "0.0.93",
   "dependencies": {
     "@swc/helpers": "~0.5.0"
   },
@@ -26,5 +26,6 @@
   },
   "keywords": [],
   "author": "devrev",
-  "license": "ISC"
-}
+  "license": "ISC",
+  "types": "./src/index.d.ts"
+}

package/types/cube-types/index.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/types/cube-types/index.d.ts"],"sourcesContent":["export * from './query';\nexport * from './table';\n"],"names":[],"mappings":";;uBAAc;uBACA"}

package/types/cube-types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/types/cube-types/index.ts"],"sourcesContent":["export * from './query';\nexport * from './table';\n"],"names":[],"mappings":";;uBAAc;uBACA"}

package/types/cube-types/query.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/types/cube-types/query.d.ts"],"sourcesContent":["/**\n * Request type data type.\n */\ntype RequestType = 'multi';\n/**\n * Result type data type.\n */\ntype ResultType = 'default' | 'compact';\n/**\n * API type data type.\n */\ntype ApiType = 'sql' | 'graphql' | 'rest' | 'ws' | 'stream';\n/**\n * Parsed query type data type.\n */\ntype QueryType = 'regularQuery' | 'compareDateRangeQuery' | 'blendingQuery';\n/**\n * String that represent query member type.\n */\ntype MemberType = 'measures' | 'dimensions' | 'segments';\n/**\n * Member identifier. Should satisfy to the following regexp: /^[a-zA-Z0-9_]+\\.[a-zA-Z0-9_]+$/\n */\ntype Member = string;\n/**\n * Datetime member identifier. Should satisfy to the following\n * regexp: /^[a-zA-Z0-9_]+\\.[a-zA-Z0-9_]+(\\.(second|minute|hour|day|week|month|year))?$/\n */\ntype TimeMember = string;\n/**\n * Filter operator string.\n */\ntype FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'in' | 'notIn' | 'gt' | 'gte' | 'lt' | 'lte' | 'set' | 'notSet' | 'inDateRange' | 'notInDateRange' | 'onTheDate' | 'beforeDate' | 'afterDate' | 'measureFilter';\n/**\n * Time dimension granularity data type.\n */\ntype QueryTimeDimensionGranularity = 'quarter' | 'day' | 'month' | 'year' | 'week' | 'hour' | 'minute' | 'second';\n/**\n * Query order data type.\n */\ntype QueryOrderType = 'asc' | 'desc';\n/**\n * ApiScopes data type.\n */\ntype ApiScopes = 'graphql' | 'meta' | 'data' | 'jobs';\ninterface QueryFilter {\n    member: Member;\n    operator: FilterOperator;\n    values?: string[];\n}\n/**\n * Query 'and'-filters type definition.\n */\ntype LogicalAndFilter = {\n    and: (QueryFilter | {\n        or: (QueryFilter | LogicalAndFilter)[];\n    })[];\n};\n/**\n * Query 'or'-filters type definition.\n */\ntype LogicalOrFilter = {\n    or: (QueryFilter | LogicalAndFilter)[];\n};\n/**\n * Query datetime dimention interface.\n */\ninterface QueryTimeDimension {\n    dimension: Member;\n    dateRange?: string[] | string;\n    granularity?: QueryTimeDimensionGranularity;\n}\n/**\n * Incoming network query data type.\n */\ninterface Query {\n    measures: Member[];\n    dimensions?: (Member | TimeMember)[];\n    filters?: (QueryFilter | LogicalAndFilter | LogicalOrFilter)[];\n    timeDimensions?: QueryTimeDimension[];\n    segments?: Member[];\n    limit?: null | number;\n    offset?: number;\n    total?: boolean;\n    totalQuery?: boolean;\n    order?: any;\n    timezone?: string;\n    renewQuery?: boolean;\n    ungrouped?: boolean;\n    responseFormat?: ResultType;\n}\n/**\n * Normalized filter interface.\n */\ninterface NormalizedQueryFilter extends QueryFilter {\n    dimension?: Member;\n}\n/**\n * Normalized query interface.\n */\ninterface NormalizedQuery extends Query {\n    filters?: NormalizedQueryFilter[];\n    rowLimit?: null | number;\n    order?: [{\n        id: string;\n        desc: boolean;\n    }];\n}\nexport { ApiScopes, ApiType, FilterOperator, LogicalAndFilter, LogicalOrFilter, Member, MemberType, NormalizedQuery, NormalizedQueryFilter, Query, QueryFilter, QueryOrderType, QueryTimeDimension, QueryTimeDimensionGranularity, QueryType, RequestType, ResultType, TimeMember, };\n"],"names":[],"mappings":"AAAA;;CAEC"}

package/types/cube-types/query.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../meerkat-core/src/types/cube-types/query.ts"],"sourcesContent":["/**\n * Request type data type.\n */\ntype RequestType = 'multi';\n\n/**\n * Result type data type.\n */\ntype ResultType = 'default' | 'compact';\n\n/**\n * API type data type.\n */\ntype ApiType = 'sql' | 'graphql' | 'rest' | 'ws' | 'stream';\n\n/**\n * Parsed query type data type.\n */\ntype QueryType = 'regularQuery' | 'compareDateRangeQuery' | 'blendingQuery';\n\n/**\n * String that represent query member type.\n */\ntype MemberType = 'measures' | 'dimensions' | 'segments';\n\n/**\n * Member identifier. Should satisfy to the following regexp: /^[a-zA-Z0-9_]+\\.[a-zA-Z0-9_]+$/\n */\ntype Member = string;\n\n\n/**\n * Filter operator string.\n */\ntype FilterOperator =\n  | 'equals'\n  | 'notEquals'\n  | 'contains'\n  | 'notContains'\n  | 'in'\n  | 'notIn'\n  | 'gt'\n  | 'gte'\n  | 'lt'\n  | 'lte'\n  | 'set'\n  | 'notSet'\n  | 'inDateRange'\n  | 'notInDateRange'\n  | 'onTheDate'\n  | 'beforeDate'\n  | 'afterDate'\n  | 'measureFilter';\n\n/**\n * Query order data type.\n */\ntype QueryOrderType = 'asc' | 'desc';\n\n/**\n * ApiScopes data type.\n */\ntype ApiScopes = 'graphql' | 'meta' | 'data' | 'jobs';\n\nexport type FilterType = 'BASE_FILTER' | 'PROJECTION_FILTER';\n\ninterface QueryFilter {\n  member: Member;\n  operator: FilterOperator;\n  values?: string[];\n}\n\n/**\n * Query 'and'-filters type definition.\n */\ntype LogicalAndFilter = {\n  and: (QueryFilter | { or: (QueryFilter | LogicalAndFilter)[] })[];\n};\n\n/**\n * Query 'or'-filters type definition.\n */\ntype LogicalOrFilter = {\n  or: (QueryFilter | LogicalAndFilter)[];\n};\n\n\n/**\n * Join Edge data type.\n */\n\ninterface JoinNode {\n  /**\n   * Left node.\n   */\n  left: Member;\n\n  /**\n   * Right node.\n   */\n  right: Member;\n\n  /**\n   * On condition.\n   */\n  on: string;\n\n  /**\n   * Example\n   * [\n   *  [\n   *    {\n   *      left:  dim_ticket,\n   *      right: dim_user\n   *      on: 'created_by_id'\n   *    },\n   *   {\n   *     left : dim_user,\n   *     right: dim_user_role,\n   *     on: 'role_id'\n   *   }\n   *  ]\n   * ]\n   *\n   *\n   */\n}\n\n/**\n * Single node data type.\n * This is the case when there is no join. Just a single node.\n */\ninterface SingleNode {\n  /**\n   * Left node.\n   */\n  left: Member;\n}\n\ntype JoinPath = [JoinNode | SingleNode, ...JoinNode[]];\n\nexport const isJoinNode = (node: JoinNode | SingleNode): node is JoinNode => {\n  return 'right' in node;\n};\n\n/**\n * Incoming network query data type.\n */\n\ntype MeerkatQueryFilter = QueryFilter | LogicalAndFilter | LogicalOrFilter;\n\ninterface Query {\n  measures: Member[];\n  dimensions?: Member[];\n  filters?: MeerkatQueryFilter[];\n  joinPaths?: JoinPath[];\n  limit?: null | number;\n  offset?: number;\n  order?: Record<string, QueryOrderType>;\n}\n\n\nexport {\n  ApiScopes,\n  ApiType,\n  FilterOperator,\n  JoinPath,\n  LogicalAndFilter,\n  LogicalOrFilter,\n  MeerkatQueryFilter,\n  Member,\n  MemberType,\n  Query,\n  QueryFilter,\n  QueryOrderType,\n  QueryType,\n  RequestType,\n  ResultType\n};\n"],"names":["isJoinNode","node"],"mappings":"AAAA;;CAEC;+BA2IYA;;;eAAAA;;;AAAN,MAAMA,aAAa,CAACC;IACzB,OAAO,WAAWA;AACpB"}