@sisense/sdk-data 1.11.0 → 1.12.0

package/dist/cjs/dimensional-model/filters/utils/filter-from-jaql-util.test.js

@@ -0,0 +1,558 @@
+"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 });
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable vitest/expect-expect */
+const vitest_1 = require("vitest");
+const filter_from_jaql_util_js_1 = require("./filter-from-jaql-util.js");
+const filterFactory = __importStar(require("../factory.js"));
+const types_js_1 = require("./types.js");
+const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
+const condition_filter_util_js_1 = require("./condition-filter-util.js");
+(0, vitest_1.describe)('filter-from-jaql-util', () => {
+    (0, vitest_1.describe)('createFilterFromJaqlInternal', () => {
+        const guid = 'instanceid';
+        const expectEqualFilters = (actual, expected) => {
+            // delete compose code
+            delete actual.composeCode;
+            expect(Object.assign({}, actual)).toEqual(Object.assign({}, expected));
+            expect(actual.serializable()).toBeDefined();
+        };
+        (0, vitest_1.describe)('MembersFilter', () => {
+            it('should handle include all', () => {
+                const jaql = {
+                    table: 'Category',
+                    column: 'Category',
+                    dim: '[Category.Category]',
+                    datatype: 'text',
+                    filter: {
+                        explicit: true,
+                        multiSelection: true,
+                        all: true,
+                    },
+                    title: 'Category',
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.members(attribute, [], guid);
+                expectEqualFilters(filter, expectedFilter);
+            });
+            it('should handle members text', () => {
+                const jaql = {
+                    table: 'Category',
+                    column: 'Category',
+                    dim: '[Category.Category]',
+                    datatype: 'text',
+                    filter: {
+                        explicit: true,
+                        multiSelection: true,
+                        members: ['Cell Phones', 'GPS Devices'],
+                    },
+                    title: 'Category',
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, guid);
+                expectEqualFilters(filter, expectedFilter);
+            });
+            test('should handle members datetime', () => {
+                [
+                    {
+                        title: 'Years',
+                        table: 'Commerce',
+                        column: 'Date',
+                        dim: '[Commerce.Date (Calendar)]',
+                        datatype: 'datetime',
+                        level: 'years',
+                        filter: {
+                            explicit: true,
+                            multiSelection: true,
+                            members: ['2013-01-01T00:00:00', '2011-01-01T00:00:00'],
+                        },
+                    },
+                    {
+                        datasource: {
+                            title: 'Sample ECommerce',
+                            fullname: 'LocalHost/Sample ECommerce',
+                            id: 'localhost_aSampleIAAaECommerce',
+                            address: 'LocalHost',
+                            database: 'aSampleIAAaECommerce',
+                        },
+                        column: 'Date',
+                        dim: '[Commerce.Date (Calendar)]',
+                        datatype: 'datetime',
+                        level: 'years',
+                        title: 'YEARS',
+                        collapsed: true,
+                        isDashboardFilter: true,
+                        filter: {
+                            explicit: true,
+                            multiSelection: true,
+                            members: ['2013-01-01T00:00:00'],
+                        },
+                    },
+                ].forEach((jaql) => {
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                    const expectedFilter = filterFactory.members(attribute, jaql.filter.members, guid);
+                    expectEqualFilters(filter, expectedFilter);
+                });
+            });
+            test('should handle JAQL without table name', () => {
+                const jaql = {
+                    column: 'Category',
+                    dim: '[Category.Category]',
+                    datatype: 'text',
+                    filter: {
+                        explicit: true,
+                        multiSelection: true,
+                        members: ['Cell Phones', 'GPS Devices'],
+                    },
+                    title: 'Category',
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.members(attribute, jaql.filter.members, guid);
+                expectEqualFilters(filter, expectedFilter);
+            });
+        });
+        (0, vitest_1.describe)('NumericFilter', () => {
+            test('should handle unary operator for number', () => {
+                [
+                    { operator: types_js_1.ConditionFilterType.GREATER_THAN, factoryFunc: filterFactory.greaterThan },
+                    {
+                        operator: types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL,
+                        factoryFunc: filterFactory.greaterThanOrEqual,
+                    },
+                    { operator: types_js_1.ConditionFilterType.EQUALS, factoryFunc: filterFactory.equals },
+                    { operator: types_js_1.ConditionFilterType.LESS_THAN, factoryFunc: filterFactory.lessThan },
+                    {
+                        operator: types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL,
+                        factoryFunc: filterFactory.lessThanOrEqual,
+                    },
+                ].forEach((test) => {
+                    const jaql = {
+                        table: 'Commerce',
+                        column: 'Revenue',
+                        datatype: 'numeric',
+                        dim: '[Commerce.Revenue]',
+                        title: 'Revenue',
+                        filter: {
+                            [test.operator]: 1000,
+                        },
+                    };
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                    const expectedFilter = test.factoryFunc(attribute, jaql.filter[test.operator], guid);
+                    expectEqualFilters(filter, expectedFilter);
+                });
+            });
+            test('should handle unary operator for string', () => {
+                [
+                    { operator: types_js_1.ConditionFilterType.EQUALS, factoryFunc: filterFactory.equals },
+                    { operator: types_js_1.ConditionFilterType.STARTS_WITH, factoryFunc: filterFactory.startsWith },
+                    {
+                        operator: types_js_1.ConditionFilterType.DOESNT_START_WITH,
+                        factoryFunc: filterFactory.doesntStartWith,
+                    },
+                    {
+                        operator: types_js_1.ConditionFilterType.ENDS_WITH,
+                        factoryFunc: filterFactory.endsWith,
+                    },
+                    {
+                        operator: types_js_1.ConditionFilterType.DOESNT_END_WITH,
+                        factoryFunc: filterFactory.doesntEndWith,
+                    },
+                    {
+                        operator: types_js_1.ConditionFilterType.CONTAINS,
+                        factoryFunc: filterFactory.contains,
+                    },
+                    {
+                        operator: types_js_1.ConditionFilterType.DOESNT_CONTAIN,
+                        factoryFunc: filterFactory.doesntContain,
+                    },
+                ].forEach((test) => {
+                    const jaql = {
+                        table: 'Country',
+                        column: 'Country',
+                        datatype: 'text',
+                        dim: '[Country.Country]',
+                        title: 'Country',
+                        filter: {
+                            [test.operator]: 'ABC',
+                        },
+                    };
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                    const expectedFilter = test.factoryFunc(attribute, jaql.filter[test.operator], guid);
+                    expectEqualFilters(filter, expectedFilter);
+                });
+            });
+            test('should handle binary operator', () => {
+                [{ operator: types_js_1.ConditionFilterType.BETWEEN, factoryFunc: filterFactory.between }].forEach((test) => {
+                    const jaql = {
+                        table: 'Commerce',
+                        column: 'Revenue',
+                        datatype: 'numeric',
+                        dim: '[Commerce.Revenue]',
+                        title: 'Revenue',
+                        filter: {
+                            from: 1000,
+                            to: 2000,
+                        },
+                    };
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                    const expectedFilter = test.factoryFunc(attribute, jaql.filter.from, jaql.filter.to, guid);
+                    expectEqualFilters(filter, expectedFilter);
+                });
+            });
+            test('should handle not between operator', () => {
+                const jaql = {
+                    table: 'Commerce',
+                    column: 'Revenue',
+                    datatype: 'numeric',
+                    dim: '[Commerce.Revenue]',
+                    title: 'Revenue',
+                    filter: {
+                        exclude: {
+                            from: 1000,
+                            to: 2000,
+                        },
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.exclude(filterFactory.between(attribute, jaql.filter.exclude.from, jaql.filter.exclude.to, guid), undefined, guid);
+                expectEqualFilters(filter.filter, expectedFilter.filter);
+                expect(filter.serializable()).toBeDefined();
+                expect(filter.id).toEqual(expectedFilter.id);
+            });
+        });
+        (0, vitest_1.describe)('RelativeDateFilter', () => {
+            test('should handle dateRelativeFrom', () => {
+                [
+                    {
+                        jaql: {
+                            title: 'Years',
+                            table: 'Commerce',
+                            column: 'Date',
+                            dim: '[Commerce.Date (Calendar)]',
+                            datatype: 'datetime',
+                            level: 'months',
+                            filter: {
+                                next: {
+                                    count: 18,
+                                    offset: 0,
+                                    anchor: '2011-01',
+                                },
+                            },
+                        },
+                        factoryFunc: filterFactory.dateRelativeFrom,
+                    },
+                ].forEach(({ jaql, factoryFunc }) => {
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                    const expectedFilter = factoryFunc(attribute, jaql.filter.next.offset, jaql.filter.next.count, jaql.filter.next.anchor, guid);
+                    expectEqualFilters(filter, expectedFilter);
+                    expect(filter.serializable()).toBeDefined();
+                    expect(filter.jaql().jaql).toEqual(expectedFilter.jaql().jaql);
+                });
+            });
+            test('should handle dateRelativeTo', () => {
+                [
+                    {
+                        jaql: {
+                            title: 'Years',
+                            table: 'Commerce',
+                            column: 'Date',
+                            dim: '[Commerce.Date (Calendar)]',
+                            datatype: 'datetime',
+                            level: 'months',
+                            filter: {
+                                last: {
+                                    count: 18,
+                                    offset: 0,
+                                    anchor: '2011-01',
+                                },
+                            },
+                        },
+                        factoryFunc: filterFactory.dateRelativeTo,
+                    },
+                ].forEach(({ jaql, factoryFunc }) => {
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                    const expectedFilter = factoryFunc(attribute, jaql.filter.last.offset, jaql.filter.last.count, jaql.filter.last.anchor, guid);
+                    expectEqualFilters(filter, expectedFilter);
+                });
+            });
+        });
+        (0, vitest_1.describe)('DateRangeFilter', () => {
+            test('should handle', () => {
+                const jaql = {
+                    title: 'Years',
+                    table: 'Commerce',
+                    column: 'Date',
+                    dim: '[Commerce.Date (Calendar)]',
+                    datatype: 'datetime',
+                    level: 'years',
+                    filter: {
+                        from: '2010-01-01',
+                        to: '2012-01-01',
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.dateRange(attribute, '2010-01-01', '2012-01-01', guid);
+                expectEqualFilters(filter, expectedFilter);
+                expect(filter.from).toBeDefined();
+                expect(filter.to).toBeDefined();
+                expect(filter.level).toBeDefined();
+            });
+        });
+        (0, vitest_1.describe)('RankingFilter', () => {
+            it('should handle top', () => {
+                const jaql = {
+                    table: 'Brand',
+                    column: 'Brand',
+                    datatype: 'text',
+                    title: 'Top 10 Brand by Total Revenue',
+                    dim: '[Brand.Brand]',
+                    filter: {
+                        top: 10,
+                        by: {
+                            table: 'Commerce',
+                            column: 'Revenue',
+                            datatype: 'numeric',
+                            title: 'sum Revenue',
+                            dim: '[Commerce.Revenue]',
+                            agg: 'sum',
+                        },
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const measure = (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(jaql.filter.by);
+                const expectedFilter = filterFactory.topRanking(attribute, measure, jaql.filter.top, guid);
+                expectEqualFilters(filter, expectedFilter);
+            });
+            it('should handle bottom', () => {
+                const jaql = {
+                    table: 'Brand',
+                    column: 'Brand',
+                    datatype: 'text',
+                    title: 'Bottom 10 Brand by Total Revenue',
+                    dim: '[Brand.Brand]',
+                    filter: {
+                        bottom: 10,
+                        by: {
+                            table: 'Commerce',
+                            column: 'Revenue',
+                            datatype: 'numeric',
+                            title: 'sum Revenue',
+                            dim: '[Commerce.Revenue]',
+                            agg: 'sum',
+                        },
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const measure = (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(jaql.filter.by);
+                const expectedFilter = filterFactory.bottomRanking(attribute, measure, jaql.filter.bottom, guid);
+                expectEqualFilters(filter, expectedFilter);
+            });
+        });
+        (0, vitest_1.describe)('LogicalAttributeFilter', () => {
+            it('should handle or', () => {
+                const jaql = {
+                    table: 'Brand',
+                    column: 'Brand',
+                    datatype: 'text',
+                    title: 'Brand',
+                    dim: '[Brand.Brand]',
+                    filter: {
+                        or: [
+                            {
+                                startsWith: 'A',
+                            },
+                            {
+                                endsWith: 's',
+                            },
+                        ],
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.union(jaql.filter.or.map((c) => (0, condition_filter_util_js_1.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), guid);
+                expect(filter.type).toEqual(expectedFilter.type);
+                expect(filter.id).toEqual(expectedFilter.id);
+                expect(filter.serializable()).toBeDefined();
+            });
+            it('should handle and', () => {
+                const jaql = {
+                    table: 'Brand',
+                    column: 'Brand',
+                    datatype: 'text',
+                    title: 'Brand',
+                    dim: '[Brand.Brand]',
+                    filter: {
+                        and: [
+                            {
+                                startsWith: 'A',
+                            },
+                            {
+                                endsWith: 's',
+                            },
+                        ],
+                    },
+                };
+                const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+                const expectedFilter = filterFactory.intersection(jaql.filter.and.map((c) => (0, condition_filter_util_js_1.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), guid);
+                expect(filter.type).toEqual(expectedFilter.type);
+                expect(filter.id).toEqual(expectedFilter.id);
+                expect(filter.serializable()).toBeDefined();
+            });
+        });
+        (0, vitest_1.describe)('MeasureFilter', () => {
+            it('should handle unary operation', () => {
+                [
+                    {
+                        operator: types_js_1.ConditionFilterType.GREATER_THAN,
+                        factoryFunc: filterFactory.measureGreaterThan,
+                    },
+                    {
+                        operator: types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL,
+                        factoryFunc: filterFactory.measureGreaterThanOrEqual,
+                    },
+                    { operator: types_js_1.ConditionFilterType.EQUALS, factoryFunc: filterFactory.measureEquals },
+                    { operator: types_js_1.ConditionFilterType.LESS_THAN, factoryFunc: filterFactory.measureLessThan },
+                    {
+                        operator: types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL,
+                        factoryFunc: filterFactory.measureLessThanOrEqual,
+                    },
+                ].forEach((test) => {
+                    const jaql = {
+                        table: 'Commerce',
+                        column: 'Revenue',
+                        datatype: 'numeric',
+                        title: 'sum Revenue',
+                        dim: '[Commerce.Revenue]',
+                        agg: 'sum',
+                        filter: {
+                            [test.operator]: 2000,
+                        },
+                    };
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const measure = (0, attribute_measure_util_js_1.createMeasureFromFilterJaql)(jaql);
+                    expect(measure).toBeDefined();
+                    if (!measure)
+                        return;
+                    const expectedFilter = test.factoryFunc(measure, jaql.filter[test.operator], guid);
+                    expectEqualFilters(filter, expectedFilter);
+                });
+            });
+        });
+        (0, vitest_1.describe)('Generic filter (pass-through JAQL)', () => {
+            test('should fall back to generic filter (pass-through JAQL)', () => {
+                [
+                    // ADVANCED FILTER TYPE
+                    {
+                        table: 'Commerce',
+                        column: 'Revenue',
+                        datatype: 'numeric',
+                        title: 'sum Revenue',
+                        filter: {
+                            isAdvanced: true,
+                        },
+                    },
+                    // SIMULATE INVALID FILTER TYPE
+                    {
+                        table: 'Commerce',
+                        column: 'Revenue',
+                        datatype: 'numeric',
+                        title: 'sum Revenue',
+                        filter: {
+                            filterType: 'INVALID',
+                        },
+                    },
+                    {
+                        type: 'measure',
+                        formula: 'QUARTILE([042C4-365], 2)',
+                        context: {
+                            '[042C4-365]': {
+                                table: 'Commerce',
+                                column: 'Revenue',
+                                dim: '[Commerce.Revenue]',
+                                datatype: 'numeric',
+                                title: 'Revenue',
+                            },
+                        },
+                        title: 'QUARTILE([Revenue], 2)',
+                        datatype: 'numeric',
+                        filter: {
+                            fromNotEqual: '500',
+                        },
+                    },
+                    {
+                        table: 'Brand',
+                        column: 'Brand',
+                        dim: '[Brand.Brand]',
+                        datatype: 'text',
+                        merged: true,
+                        title: 'Brand',
+                        filter: {
+                            top: 10,
+                            by: {
+                                type: 'measure',
+                                formula: 'QUARTILE([042C4-365], 2)',
+                                context: {
+                                    '[042C4-365]': {
+                                        table: 'Commerce',
+                                        column: 'Revenue',
+                                        dim: '[Commerce.Revenue]',
+                                        datatype: 'numeric',
+                                        title: 'Revenue',
+                                    },
+                                },
+                                title: 'QUARTILE([Revenue], 2)',
+                                datatype: 'numeric',
+                            },
+                            rankingMessage: 'QUARTILE([Revenue], 2)',
+                        },
+                    },
+                ].forEach((item) => {
+                    const jaql = item;
+                    const filter = (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaql, guid);
+                    const expectedFilter = filterFactory.customFilter(jaql, guid);
+                    expect(filter.jaql()).toEqual(expectedFilter.jaql());
+                    expect(filter.jaql(true)).toEqual(expectedFilter.jaql(true));
+                    expect(filter.serializable()).toBeDefined();
+                    expect(filter.toJSON()).toBeDefined();
+                });
+            });
+        });
+    });
+});

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

@@ -0,0 +1,5 @@
+import { FilterJaql } from '../../types.js';
+declare type FilterMatcher = (value?: string | number) => boolean;
+/** @internal */
+export declare function createFilterMatcher(filterJaql: FilterJaql): FilterMatcher;
+export {};