@sisense/sdk-data 1.11.0 → 1.12.0

package/dist/cjs/dimensional-model/filters/filters.test.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const filters_js_1 = require("./filters.js");
+const attributes_js_1 = require("../attributes.js");
+const measures_js_1 = require("../measures/measures.js");
+const types_js_1 = require("../types.js");
+describe('Filters jaql preparations', () => {
+    it('must prepare members filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'CommerceGender',
+                dim: '[Commerce.Gender]',
+                datatype: 'text',
+                filter: { members: ['Female'] },
+            },
+        };
+        const filter = new filters_js_1.MembersFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), ['Female']);
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare exclude filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'CommerceGender',
+                dim: '[Commerce.Gender]',
+                datatype: 'text',
+                filter: { exclude: { members: ['Female'] } },
+            },
+        };
+        const filter = new filters_js_1.ExcludeFilter(new filters_js_1.MembersFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), [
+            'Female',
+        ]));
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare date range filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'Years',
+                dim: '[Commerce.Date (Calendar)]',
+                level: 'years',
+                datatype: 'datetime',
+                filter: {
+                    from: '2010-01-01T00:00:00.000Z',
+                    to: '2012-01-01T00:00:00.000Z',
+                },
+            },
+        };
+        const filter = new filters_js_1.DateRangeFilter(new attributes_js_1.DimensionalLevelAttribute('Years', '[Commerce.Date (Calendar)]', 'Years'), new Date('2010-01-01'), new Date('2012-01-01'));
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare partial date range filters jaql', () => {
+        var _a, _b, _c, _d;
+        const filterFrom = new filters_js_1.DateRangeFilter(new attributes_js_1.DimensionalLevelAttribute('Years', '[Commerce.Date (Calendar)]', 'Years'), new Date('2010-01-01'));
+        const filterTo = new filters_js_1.DateRangeFilter(new attributes_js_1.DimensionalLevelAttribute('Years', '[Commerce.Date (Calendar)]', 'Years'), undefined, new Date('2012-01-01'));
+        const jaqlFrom = filterFrom.jaql();
+        const jaqlTo = filterTo.jaql();
+        expect((_a = jaqlFrom.jaql.filter) === null || _a === void 0 ? void 0 : _a.from).toBe('2010-01-01T00:00:00.000Z');
+        expect((_b = jaqlFrom.jaql.filter) === null || _b === void 0 ? void 0 : _b.to).toBeUndefined();
+        expect((_c = jaqlTo.jaql.filter) === null || _c === void 0 ? void 0 : _c.from).toBeUndefined();
+        expect((_d = jaqlTo.jaql.filter) === null || _d === void 0 ? void 0 : _d.to).toBe('2012-01-01T00:00:00.000Z');
+    });
+    it('must prepare logical attribute filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'CommerceGender',
+                dim: '[Commerce.Gender]',
+                datatype: 'text',
+                filter: {
+                    or: [{ members: ['Female'] }, { exclude: { members: ['Male'] } }],
+                },
+            },
+        };
+        const filter = new filters_js_1.LogicalAttributeFilter([
+            new filters_js_1.MembersFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), [
+                'Female',
+            ]),
+            new filters_js_1.ExcludeFilter(new filters_js_1.MembersFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), [
+                'Male',
+            ])),
+        ], 'or');
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare measure filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'Cost',
+                dim: '[Commerce.Cost]',
+                datatype: 'numeric',
+                agg: 'sum',
+                filter: {},
+            },
+        };
+        const filter = new filters_js_1.MeasureFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), new measures_js_1.DimensionalBaseMeasure('Cost', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), 'sum'));
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare relative date (years level)  filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'Years',
+                dim: '[Commerce.Date (Calendar)]',
+                level: 'years',
+                datatype: 'datetime',
+                filter: {
+                    last: { offset: 0, count: 2, anchor: '2012-01-01T00:00:00.000Z' },
+                },
+            },
+        };
+        const filter = new filters_js_1.RelativeDateFilter(new attributes_js_1.DimensionalLevelAttribute('Years', '[Commerce.Date (Calendar)]', 'Years'), 0, 2, filters_js_1.DateOperators.Last, new Date('2012-01-01'));
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare relative date (minutes level) filter jaql', () => {
+        const result = {
+            jaql: {
+                title: types_js_1.DateLevels.AggMinutesRoundTo15,
+                dim: '[Commerce.Date (Calendar)]',
+                level: 'minutes',
+                bucket: '15',
+                datatype: 'datetime',
+                filter: {
+                    last: { offset: 0, count: 2, anchor: '2012-01-01T00:00:00.000Z' },
+                },
+            },
+        };
+        const filter = new filters_js_1.RelativeDateFilter(new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.AggMinutesRoundTo15, '[Commerce.Date (Calendar)]', types_js_1.DateLevels.AggMinutesRoundTo15), 0, 2, filters_js_1.DateOperators.Last, new Date('2012-01-01'));
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare text filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'CommerceGender',
+                dim: '[Commerce.Gender]',
+                datatype: 'text',
+                filter: { contains: 'Male' },
+            },
+        };
+        const filter = new filters_js_1.TextFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), filters_js_1.TextOperators.Contains, 'Male');
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare numeric filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'CommerceCost',
+                dim: '[Commerce.Cost]',
+                datatype: 'numeric',
+                filter: { from: 1, to: 3 },
+            },
+        };
+        const filter = new filters_js_1.NumericFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), filters_js_1.NumericOperators.From, 1, filters_js_1.NumericOperators.To, 3);
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare ranking filter jaql', () => {
+        const result = {
+            jaql: {
+                title: 'CommerceCost',
+                dim: '[Commerce.Cost]',
+                datatype: 'numeric',
+                filter: {
+                    top: 2,
+                    by: { title: 'Cost', agg: 'sum', dim: '[Commerce.Cost]', datatype: 'numeric' },
+                },
+            },
+        };
+        const filter = new filters_js_1.RankingFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), new measures_js_1.DimensionalBaseMeasure('Cost', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), 'sum'), filters_js_1.RankingOperators.Top, 2);
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare cascading filter jaql', () => {
+        const result = [
+            {
+                jaql: {
+                    title: 'CategoryCategory',
+                    dim: '[Category.Category]',
+                    datatype: 'text',
+                    filter: {
+                        members: ['Apple Mac Desktops', 'Apple Mac Laptops', 'Calculators'],
+                    },
+                },
+                panel: 'scope',
+            },
+            {
+                jaql: {
+                    title: 'CommerceGender',
+                    dim: '[Commerce.Gender]',
+                    datatype: 'text',
+                    filter: {
+                        members: ['Female'],
+                    },
+                },
+                panel: 'scope',
+            },
+        ];
+        const levelFilter1 = new filters_js_1.MembersFilter(new attributes_js_1.DimensionalAttribute('[Category.Category]', '[Category.Category]'), ['Apple Mac Desktops', 'Apple Mac Laptops', 'Calculators']);
+        const levelFilter2 = new filters_js_1.MembersFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), ['Female']);
+        const filter = new filters_js_1.CascadingFilter([levelFilter1, levelFilter2]);
+        const jaql = filter.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+});
+describe('Disabled Filter', () => {
+    it('must prepare empty jaql for attribute filter', () => {
+        const filter = new filters_js_1.MembersFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), ['Female']);
+        expect(filter.disabled).toBe(false);
+        filter.disabled = true;
+        expect(filter.jaql(true)).toStrictEqual({ filter: {} });
+        expect(filter.jaql()).toStrictEqual({ jaql: { filter: {} } });
+    });
+    it('must prepare empty jaql for measure filter', () => {
+        const filter = new filters_js_1.MeasureFilter(new attributes_js_1.DimensionalAttribute('[Commerce.Gender]', '[Commerce.Gender]'), new measures_js_1.DimensionalBaseMeasure('Cost', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), 'sum'));
+        expect(filter.disabled).toBe(false);
+        filter.disabled = true;
+        expect(filter.jaql(true)).toStrictEqual({ filter: {} });
+        expect(filter.jaql()).toStrictEqual({ jaql: { filter: {} } });
+    });
+});

package/dist/cjs/dimensional-model/filters/utils/attribute-measure-util.d.ts

@@ -0,0 +1,47 @@
+import { Attribute, BaseMeasure, LevelAttribute } from '../../interfaces.js';
+import { FilterJaql } from '../../types.js';
+import { FilterJaqlInternal, RankingFilterJaql } from './types.js';
+/**
+ * Creates an attribute or level attribute from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @returns attribute or level attribute
+ */
+export declare const createAttributeHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string) => Attribute | LevelAttribute;
+/**
+ * Creates an attribute or level attribute from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns attribute or level attribute
+ */
+export declare const createAttributeFromFilterJaql: (jaql: FilterJaql | FilterJaqlInternal) => Attribute | LevelAttribute;
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @param agg - Aggregation function
+ * @returns measure
+ */
+export declare const createMeasureHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, agg: string) => BaseMeasure;
+/**
+ * Creates a measure from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns Measure
+ */
+export declare const createMeasureFromFilterJaql: (jaql: FilterJaqlInternal) => BaseMeasure | undefined;
+/**
+ * Creates a measure from the provided ranking filter JAQL object
+ *
+ * @param jaql - Ranking filter Jaql object
+ * @returns Measure
+ */
+export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql) => BaseMeasure;

package/dist/cjs/dimensional-model/filters/utils/attribute-measure-util.js

@@ -0,0 +1,111 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMeasureFromRankingFilterJaql = exports.createMeasureFromFilterJaql = exports.createMeasureHelper = exports.createAttributeFromFilterJaql = exports.createAttributeHelper = void 0;
+const attributes_js_1 = require("../../attributes.js");
+const simple_column_types_js_1 = require("../../simple-column-types.js");
+const types_js_1 = require("../../types.js");
+const measureFactory = __importStar(require("../../measures/factory.js"));
+const DATA_MODEL_MODULE_NAME = 'DM';
+/**
+ * Creates an attribute or level attribute from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @returns attribute or level attribute
+ */
+const createAttributeHelper = (dim, table, column, level, dataType) => {
+    // if table is undefined, extract it from dim
+    const dimTable = table !== null && table !== void 0 ? table : dim.slice(1, -1).split('.')[0];
+    if (level) {
+        const dateLevel = attributes_js_1.DimensionalLevelAttribute.translateJaqlToGranularity({ level });
+        const format = attributes_js_1.DimensionalLevelAttribute.getDefaultFormatForGranularity(dateLevel);
+        const levelAttribute = new attributes_js_1.DimensionalLevelAttribute(column, dim, dateLevel, format);
+        levelAttribute.composeCode = (0, attributes_js_1.normalizeAttributeName)(dimTable, column, level, DATA_MODEL_MODULE_NAME);
+        return levelAttribute;
+    }
+    const attributeType = (0, simple_column_types_js_1.isNumber)(dataType)
+        ? types_js_1.MetadataTypes.NumericAttribute
+        : types_js_1.MetadataTypes.TextAttribute;
+    const attribute = new attributes_js_1.DimensionalAttribute(column, dim, attributeType);
+    attribute.composeCode = (0, attributes_js_1.normalizeAttributeName)(dimTable, column, undefined, DATA_MODEL_MODULE_NAME);
+    return attribute;
+};
+exports.createAttributeHelper = createAttributeHelper;
+/**
+ * Creates an attribute or level attribute from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns attribute or level attribute
+ */
+const createAttributeFromFilterJaql = (jaql) => {
+    return (0, exports.createAttributeHelper)(jaql.dim, jaql.table, jaql.column, jaql.level, jaql.datatype);
+};
+exports.createAttributeFromFilterJaql = createAttributeFromFilterJaql;
+/**
+ * Creates a measure from the provided parameters
+ *
+ * @param dim - Dimension expression
+ * @param table - Table name
+ * @param column - Column name
+ * @param level - Date level
+ * @param dataType - Data type
+ * @param agg - Aggregation function
+ * @returns measure
+ */
+const createMeasureHelper = (dim, table, column, level, dataType, agg) => {
+    const attribute = (0, exports.createAttributeHelper)(dim, table, column, level, dataType);
+    const measure = measureFactory.aggregate(attribute, agg);
+    measure.composeCode = `measureFactory.${agg}(${attribute.composeCode})`;
+    return measure;
+};
+exports.createMeasureHelper = createMeasureHelper;
+/**
+ * Creates a measure from the provided filter JAQL object
+ *
+ * @param jaql - Filter JAQL object
+ * @returns Measure
+ */
+const createMeasureFromFilterJaql = (jaql) => {
+    const { dim, table, column, level, datatype: dataType, agg } = jaql;
+    if (!agg)
+        return undefined;
+    return (0, exports.createMeasureHelper)(dim, table, column, level, dataType, agg);
+};
+exports.createMeasureFromFilterJaql = createMeasureFromFilterJaql;
+/**
+ * Creates a measure from the provided ranking filter JAQL object
+ *
+ * @param jaql - Ranking filter Jaql object
+ * @returns Measure
+ */
+const createMeasureFromRankingFilterJaql = (jaql) => {
+    const { dim, table, column, level, datatype: dataType, agg } = jaql;
+    return (0, exports.createMeasureHelper)(dim, table, column, level, dataType, agg);
+};
+exports.createMeasureFromRankingFilterJaql = createMeasureFromRankingFilterJaql;

package/dist/cjs/dimensional-model/filters/utils/condition-filter-util.d.ts

@@ -0,0 +1,21 @@
+import { ConditionFilterJaql, ConditionFilterType } from './types.js';
+import { Attribute, BaseMeasure, Filter } from '../../interfaces.js';
+export declare const getSelectedConditionOption: (filter: ConditionFilterJaql) => ConditionFilterType;
+/**
+ * Creates an attribute filter from the provided attribute and condition filter JAQL object
+ *
+ * @param attribute - Provided attribute
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
+ * @returns attribute filter
+ */
+export declare const createAttributeFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, guid?: string) => Filter;
+/**
+ * Creates a measure filter from the provided measure and condition filter JAQL object
+ *
+ * @param measure - Provided measure
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
+ * @returns measure filter
+ */
+export declare const createMeasureFilterFromConditionFilterJaql: (measure: BaseMeasure, conditionFilterJaql: ConditionFilterJaql, guid?: string) => Filter;

package/dist/cjs/dimensional-model/filters/utils/condition-filter-util.js

@@ -0,0 +1,194 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMeasureFilterFromConditionFilterJaql = exports.createAttributeFilterFromConditionFilterJaql = exports.getSelectedConditionOption = void 0;
+const types_js_1 = require("./types.js");
+const filter_code_util_js_1 = require("./filter-code-util.js");
+const filterFactory = __importStar(require("../factory.js"));
+const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
+const isTopCondition = (filter) => filter.top !== undefined;
+const isBottomCondition = (filter) => filter.bottom !== undefined;
+const isExcludeCondition = (filter) => { var _a; return !!((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members); };
+const isMembersCondition = (filter) => !!filter.members && !!filter.isCondition;
+const isWithinCondition = (filter) => { var _a, _b; return ((_a = filter.last) === null || _a === void 0 ? void 0 : _a.anchor) !== undefined || ((_b = filter.next) === null || _b === void 0 ? void 0 : _b.anchor) !== undefined; };
+const isGreaterThanCondition = (filter) => filter.fromNotEqual !== undefined;
+const isGreaterThanOrEqualCondition = (filter) => filter.from !== undefined && !filter.isBetween;
+const isLessThanCondition = (filter) => filter.toNotEqual !== undefined;
+const isLessThanOrEqualCondition = (filter) => filter.to !== undefined && !filter.isBetween;
+const isEqualsCondition = (filter) => filter.equals !== undefined;
+const isNotEqualCondition = (filter) => filter.doesntEqual !== undefined;
+const isEmptyCondition = (filter) => !!(filter.equals === '' && filter.isEmpty);
+const isNotEmptyCondition = (filter) => !!(filter.doesntEqual === '' && filter.isEmpty);
+const isContainsCondition = (filter) => filter.contains !== undefined;
+const isDoesntContainCondition = (filter) => filter.doesntContain !== undefined;
+const isStartsWithCondition = (filter) => filter.startsWith !== undefined;
+const isDoesntStartsWithCondition = (filter) => filter.doesntStartWith !== undefined;
+const isEndsWithCondition = (filter) => filter.endsWith !== undefined;
+const isDoesntEndWithCondition = (filter) => filter.doesntEndWith !== undefined;
+const isBetweenCondition = (filter) => filter.from !== undefined && filter.to !== undefined;
+const isNotBetweenCondition = (filter) => { var _a, _b; return ((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.from) !== undefined && ((_b = filter.exclude) === null || _b === void 0 ? void 0 : _b.to) !== undefined; };
+const isMultipleCondition = (filter) => !!(filter.or || filter.and);
+const getSelectedConditionOption = (filter) => {
+    if (isBottomCondition(filter))
+        return types_js_1.ConditionFilterType.BOTTOM;
+    if (isTopCondition(filter))
+        return types_js_1.ConditionFilterType.TOP;
+    if (isExcludeCondition(filter))
+        return types_js_1.ConditionFilterType.IS_NOT;
+    if (isWithinCondition(filter))
+        return types_js_1.ConditionFilterType.IS_WITHIN;
+    if (isGreaterThanCondition(filter))
+        return types_js_1.ConditionFilterType.GREATER_THAN;
+    if (isLessThanCondition(filter))
+        return types_js_1.ConditionFilterType.LESS_THAN;
+    if (isEqualsCondition(filter))
+        return types_js_1.ConditionFilterType.EQUALS;
+    if (isNotEqualCondition(filter))
+        return types_js_1.ConditionFilterType.DOESNT_EQUAL;
+    if (isEmptyCondition(filter))
+        return types_js_1.ConditionFilterType.IS_EMPTY;
+    if (isNotEmptyCondition(filter))
+        return types_js_1.ConditionFilterType.IS_NOT_EMPTY;
+    if (isContainsCondition(filter))
+        return types_js_1.ConditionFilterType.CONTAINS;
+    if (isDoesntContainCondition(filter))
+        return types_js_1.ConditionFilterType.DOESNT_CONTAIN;
+    if (isDoesntEndWithCondition(filter))
+        return types_js_1.ConditionFilterType.DOESNT_END_WITH;
+    if (isDoesntStartsWithCondition(filter))
+        return types_js_1.ConditionFilterType.DOESNT_START_WITH;
+    if (isEndsWithCondition(filter))
+        return types_js_1.ConditionFilterType.ENDS_WITH;
+    if (isStartsWithCondition(filter))
+        return types_js_1.ConditionFilterType.STARTS_WITH;
+    if (isNotBetweenCondition(filter))
+        return types_js_1.ConditionFilterType.IS_NOT_BETWEEN;
+    if (isMembersCondition(filter))
+        return types_js_1.ConditionFilterType.IS;
+    if (isMultipleCondition(filter))
+        return types_js_1.ConditionFilterType.MULTIPLE_CONDITION;
+    // Need to verify BETWEEN case before the GREATER_THAN_OR_EQUAL and LESS_THAN_OR_EQUAL due to missing `filter.isBetween` property in some cases
+    if (isBetweenCondition(filter))
+        return types_js_1.ConditionFilterType.BETWEEN;
+    if (isGreaterThanOrEqualCondition(filter))
+        return types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL;
+    if (isLessThanOrEqualCondition(filter))
+        return types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL;
+    return types_js_1.ConditionFilterType.NONE;
+};
+exports.getSelectedConditionOption = getSelectedConditionOption;
+/**
+ * Creates an attribute filter from the provided attribute and condition filter JAQL object
+ *
+ * @param attribute - Provided attribute
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
+ * @returns attribute filter
+ */
+const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
+    var _a, _b;
+    const conditionType = (0, exports.getSelectedConditionOption)(conditionFilterJaql);
+    switch (conditionType) {
+        case types_js_1.ConditionFilterType.BOTTOM:
+            if (conditionFilterJaql.by && 'agg' in conditionFilterJaql.by) {
+                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.bottomRanking)(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by), conditionFilterJaql[types_js_1.ConditionFilterType.BOTTOM], guid);
+            }
+            break;
+        case types_js_1.ConditionFilterType.EQUALS:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.equals)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.EQUALS], guid);
+        case types_js_1.ConditionFilterType.GREATER_THAN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.greaterThan)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN], guid);
+        case types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
+        case types_js_1.ConditionFilterType.TOP:
+            if (conditionFilterJaql.by) {
+                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.topRanking)(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by), conditionFilterJaql[types_js_1.ConditionFilterType.TOP], guid);
+            }
+            break;
+        case types_js_1.ConditionFilterType.STARTS_WITH:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.startsWith)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.STARTS_WITH], guid);
+        case types_js_1.ConditionFilterType.DOESNT_START_WITH:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.doesntStartWith)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_START_WITH], guid);
+        case types_js_1.ConditionFilterType.ENDS_WITH:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.endsWith)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.ENDS_WITH], guid);
+        case types_js_1.ConditionFilterType.DOESNT_END_WITH:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.doesntEndWith)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_END_WITH], guid);
+        case types_js_1.ConditionFilterType.CONTAINS:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.contains)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.CONTAINS], guid);
+        case types_js_1.ConditionFilterType.DOESNT_CONTAIN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.doesntContain)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_CONTAIN], guid);
+        case types_js_1.ConditionFilterType.LESS_THAN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.lessThan)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN], guid);
+        case types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.lessThanOrEqual)(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL], guid);
+        case types_js_1.ConditionFilterType.BETWEEN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.between)(attribute, conditionFilterJaql.from, conditionFilterJaql.to, guid);
+        case types_js_1.ConditionFilterType.IS_NOT_BETWEEN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.exclude)((0, filter_code_util_js_1.withComposeCode)(filterFactory.between)(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, guid));
+        case types_js_1.ConditionFilterType.MULTIPLE_CONDITION:
+            if (conditionFilterJaql.and) {
+                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.intersection)(conditionFilterJaql.and.map((c) => (0, exports.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), guid);
+            }
+            if (conditionFilterJaql.or) {
+                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.union)(conditionFilterJaql.or.map((c) => (0, exports.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), guid);
+            }
+            break;
+        case types_js_1.ConditionFilterType.AFTER:
+        case types_js_1.ConditionFilterType.BEFORE:
+        case types_js_1.ConditionFilterType.IS_EMPTY:
+        case types_js_1.ConditionFilterType.IS_NOT_EMPTY:
+            // TODO Handle these cases later; may need filterFactory function added first
+            break;
+    }
+    throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionFilterJaql);
+};
+exports.createAttributeFilterFromConditionFilterJaql = createAttributeFilterFromConditionFilterJaql;
+/**
+ * Creates a measure filter from the provided measure and condition filter JAQL object
+ *
+ * @param measure - Provided measure
+ * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
+ * @returns measure filter
+ */
+const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql, guid) => {
+    const conditionType = (0, exports.getSelectedConditionOption)(conditionFilterJaql);
+    switch (conditionType) {
+        case types_js_1.ConditionFilterType.EQUALS:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureEquals)(measure, conditionFilterJaql[types_js_1.ConditionFilterType.EQUALS], guid);
+        case types_js_1.ConditionFilterType.GREATER_THAN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureGreaterThan)(measure, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN], guid);
+        case types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureGreaterThanOrEqual)(measure, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
+        case types_js_1.ConditionFilterType.LESS_THAN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureLessThan)(measure, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN], guid);
+        case types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureLessThanOrEqual)(measure, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL], guid);
+        case types_js_1.ConditionFilterType.BETWEEN:
+            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureBetween)(measure, conditionFilterJaql.from, conditionFilterJaql.to, guid);
+    }
+    throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionFilterJaql);
+};
+exports.createMeasureFilterFromConditionFilterJaql = createMeasureFilterFromConditionFilterJaql;

package/dist/cjs/dimensional-model/filters/utils/date-time-filter-util.d.ts

@@ -0,0 +1,2 @@
+import { DatetimeLevel } from './types.js';
+export declare const getCorrectTimeLevel: (level?: DatetimeLevel, bucket?: string) => DatetimeLevel;

package/dist/cjs/dimensional-model/filters/utils/date-time-filter-util.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCorrectTimeLevel = void 0;
+const types_js_1 = require("./types.js");
+const getCorrectTimeLevel = (level, bucket) => {
+    let newLevel = level ? level.toLocaleLowerCase() : types_js_1.DatetimeLevel.YEARS;
+    if (newLevel === types_js_1.DatetimeLevel.MINUTES && bucket === '60') {
+        newLevel = types_js_1.DatetimeLevel.HOURS;
+    }
+    return newLevel;
+};
+exports.getCorrectTimeLevel = getCorrectTimeLevel;

package/dist/cjs/dimensional-model/filters/utils/filter-code-util.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Stringifies the argument
+ *
+ * @param arg - argument to stringify
+ * @returns stringified argument
+ */
+export declare function stringifyHelper(arg: any): string;
+/**
+ * High order function to construct compose code for filter factory functions
+ *
+ * @param func - filter factory function
+ */
+export declare function withComposeCode(func: (...args: any[]) => any): (...args: any[]) => any;