@sisense/sdk-data 1.10.1 → 1.12.0

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withComposeCode = exports.stringifyHelper = void 0;
+/**
+ * Stringifies the argument
+ *
+ * @param arg - argument to stringify
+ * @returns stringified argument
+ */
+function stringifyHelper(arg) {
+    try {
+        if (arg === null || arg === undefined) {
+            return JSON.stringify(arg);
+        }
+        if (arg === Object(arg) && 'composeCode' in arg) {
+            return arg.composeCode;
+        }
+        if (Array.isArray(arg)) {
+            return ('[' +
+                arg
+                    .map((e) => {
+                    return stringifyHelper(e);
+                })
+                    .join(', ') +
+                ']');
+        }
+        if (typeof arg === 'string') {
+            return `'${arg}'`;
+        }
+        if (typeof arg === 'number' || !isNaN(arg)) {
+            return arg;
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return JSON.stringify(arg);
+}
+exports.stringifyHelper = stringifyHelper;
+/**
+ * High order function to construct compose code for filter factory functions
+ *
+ * @param func - filter factory function
+ */
+function withComposeCode(func) {
+    return function (...args) {
+        const argValues = args.map(stringifyHelper).join(', ').replace(/, $/, '');
+        const signature = `filterFactory.${func.name}(${argValues})`;
+        const filter = func(...args);
+        filter.composeCode = signature;
+        return filter;
+    };
+}
+exports.withComposeCode = withComposeCode;

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const attributes_js_1 = require("../../attributes.js");
+const filter_code_util_js_1 = require("./filter-code-util.js");
+describe('stringifyHelper', () => {
+    it('should stringify random argument', () => {
+        const arg = { foo: 'bar' };
+        const result = (0, filter_code_util_js_1.stringifyHelper)(arg);
+        expect(result).toBe('{"foo":"bar"}');
+    });
+    it('should stringify common argument', () => {
+        const arg = (0, attributes_js_1.createAttribute)({
+            name: 'AgeRange',
+            type: 'text-attribute',
+            expression: '[Commerce.Age Range]',
+        });
+        arg.composeCode = 'some code';
+        const result = (0, filter_code_util_js_1.stringifyHelper)(arg);
+        expect(result).toBe('some code');
+    });
+    it('should stringify null', () => {
+        const arg = null;
+        const result = (0, filter_code_util_js_1.stringifyHelper)(arg);
+        expect(result).toBe('null');
+    });
+    it('should stringify undefined', () => {
+        const arg = undefined;
+        const result = (0, filter_code_util_js_1.stringifyHelper)(arg);
+        expect(result).toBeUndefined();
+    });
+    // Add more test cases as needed
+});

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

@@ -0,0 +1,73 @@
+import { ConditionFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
+import { Attribute, BaseMeasure, Filter, LevelAttribute } from '../../interfaces.js';
+import { FilterJaql } from '../../types.js';
+/**
+ * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
+ *
+ * @param jaql - The JAQL object.
+ * @param guid - Optional GUID for the filter
+ * @returns A generic Filter object.
+ */
+export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, guid?: string) => Filter;
+/**
+ * Creates a filter that includes all members of the attribute.
+ *
+ * @param attribute - The attribute.
+ * @param guid - Optional GUID for the filter
+ * @returns The created Filter object.
+ */
+export declare const createFilterIncludeAll: (attribute: Attribute, guid?: string) => Filter;
+/**
+ * Creates a filter from a specific items filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+export declare const createFilterFromSpecificItemsFilterJaql: (attribute: Attribute, specificItemsFilterJaql: SpecificItemsFilterJaql, guid?: string) => Filter;
+/**
+ * Creates a filter from a date range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+export declare const createFilterFromDateRangeFilterJaql: (attribute: LevelAttribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
+/**
+ * Creates a filter from a numeric range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+export declare const createFilterFromNumericRangeJaql: (attribute: Attribute, rangeFilterJaql: RangeFilterJaql, guid?: string) => Filter;
+/**
+ * Creates a filter from a period filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param periodFilterJaql - Period Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+export declare const createFilterFromPeriodFilterJaql: (attribute: LevelAttribute, periodFilterJaql: PeriodFilterJaql, guid?: string) => Filter;
+/**
+ * Creates a filter from a condition filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param conditionFilterJaql - Condition Filter Jaql
+ * @param measure - measure
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+export declare const createFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, measure?: BaseMeasure, guid?: string) => Filter;
+/**
+ * Creates a filter from a filter JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object.
+ */
+export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, guid?: string) => Filter;

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

@@ -0,0 +1,190 @@
+"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.createFilterFromJaqlInternal = exports.createFilterFromConditionFilterJaql = exports.createFilterFromPeriodFilterJaql = exports.createFilterFromNumericRangeJaql = exports.createFilterFromDateRangeFilterJaql = exports.createFilterFromSpecificItemsFilterJaql = exports.createFilterIncludeAll = exports.createGenericFilter = void 0;
+const types_js_1 = require("./types.js");
+const filterFactory = __importStar(require("../factory.js"));
+const condition_filter_util_js_1 = require("./condition-filter-util.js");
+const filter_types_util_js_1 = require("./filter-types-util.js");
+const filter_code_util_js_1 = require("./filter-code-util.js");
+const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
+const utils_js_1 = require("../../../utils.js");
+/**
+ * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
+ *
+ * @param jaql - The JAQL object.
+ * @param guid - Optional GUID for the filter
+ * @returns A generic Filter object.
+ */
+const createGenericFilter = (jaql, guid) => {
+    return {
+        guid: guid || (0, utils_js_1.guidFast)(13),
+        jaql: (nested) => {
+            if (nested) {
+                return jaql;
+            }
+            return {
+                jaql,
+                panel: 'scope',
+            };
+        },
+        attribute: {
+            id: jaql.dim,
+        },
+        type: 'filter',
+        serializable() {
+            return Object.assign(Object.assign({}, this), { jaql: this.jaql() });
+        },
+        toJSON() {
+            return this.serializable();
+        },
+    };
+};
+exports.createGenericFilter = createGenericFilter;
+/**
+ * Creates a filter that includes all members of the attribute.
+ *
+ * @param attribute - The attribute.
+ * @param guid - Optional GUID for the filter
+ * @returns The created Filter object.
+ */
+const createFilterIncludeAll = (attribute, guid) => {
+    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.members)(attribute, [], guid);
+};
+exports.createFilterIncludeAll = createFilterIncludeAll;
+/**
+ * Creates a filter from a specific items filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param specificItemsFilterJaql - Specific Items Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJaql, guid) => {
+    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.members)(attribute, specificItemsFilterJaql.members, guid);
+};
+exports.createFilterFromSpecificItemsFilterJaql = createFilterFromSpecificItemsFilterJaql;
+/**
+ * Creates a filter from a date range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql, guid) => {
+    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.dateRange)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
+};
+exports.createFilterFromDateRangeFilterJaql = createFilterFromDateRangeFilterJaql;
+/**
+ * Creates a filter from a numeric range filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param rangeFilterJaql - Range Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql, guid) => {
+    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.between)(attribute, rangeFilterJaql.from, rangeFilterJaql.to, guid);
+};
+exports.createFilterFromNumericRangeJaql = createFilterFromNumericRangeJaql;
+/**
+ * Creates a filter from a period filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param periodFilterJaql - Period Filter Jaql
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql, guid) => {
+    if (periodFilterJaql.last) {
+        return (0, filter_code_util_js_1.withComposeCode)(filterFactory.dateRelativeTo)(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, guid);
+    }
+    else {
+        return (0, filter_code_util_js_1.withComposeCode)(filterFactory.dateRelativeFrom)(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, guid);
+    }
+};
+exports.createFilterFromPeriodFilterJaql = createFilterFromPeriodFilterJaql;
+/**
+ * Creates a filter from a condition filter JAQL object.
+ *
+ * @param attribute - attribute
+ * @param conditionFilterJaql - Condition Filter Jaql
+ * @param measure - measure
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object
+ */
+const createFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, measure, guid) => {
+    if (measure) {
+        return (0, condition_filter_util_js_1.createMeasureFilterFromConditionFilterJaql)(measure, conditionFilterJaql, guid);
+    }
+    else {
+        return (0, condition_filter_util_js_1.createAttributeFilterFromConditionFilterJaql)(attribute, conditionFilterJaql, guid);
+    }
+};
+exports.createFilterFromConditionFilterJaql = createFilterFromConditionFilterJaql;
+/**
+ * Creates a filter from a filter JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param guid - Optional GUID for the filter
+ * @returns Filter object.
+ */
+const createFilterFromJaqlInternal = (jaql, guid) => {
+    try {
+        if ('formula' in jaql) {
+            // generic pass-through JAQL filter will be used instead
+            throw 'Formula-based filter not supported yet: ' + JSON.stringify(jaql);
+        }
+        const filterJaqlWrapperWithType = (0, filter_types_util_js_1.extractFilterTypeFromFilterJaql)(jaql, jaql.datatype);
+        const { filter: filterJaqlWithType } = filterJaqlWrapperWithType;
+        const { filterType } = filterJaqlWithType;
+        const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+        const measure = (0, attribute_measure_util_js_1.createMeasureFromFilterJaql)(jaql);
+        switch (filterType) {
+            case types_js_1.FILTER_TYPES.INCLUDE_ALL:
+                return (0, exports.createFilterIncludeAll)(attribute, guid);
+            case types_js_1.FILTER_TYPES.SPECIFIC_ITEMS:
+                return (0, exports.createFilterFromSpecificItemsFilterJaql)(attribute, filterJaqlWithType, guid);
+            case types_js_1.FILTER_TYPES.CONDITION:
+                return (0, exports.createFilterFromConditionFilterJaql)(attribute, filterJaqlWithType, measure, guid);
+            case types_js_1.FILTER_TYPES.DATE_RANGE:
+                return (0, exports.createFilterFromDateRangeFilterJaql)(attribute, filterJaqlWithType, guid);
+            case types_js_1.FILTER_TYPES.PERIOD:
+                return (0, exports.createFilterFromPeriodFilterJaql)(attribute, filterJaqlWithType, guid);
+            case types_js_1.FILTER_TYPES.NUMERIC_RANGE:
+                return (0, exports.createFilterFromNumericRangeJaql)(attribute, filterJaqlWithType, guid);
+            case types_js_1.FILTER_TYPES.ADVANCED:
+            case types_js_1.FILTER_TYPES.INVALID:
+                return (0, exports.createGenericFilter)(jaql, guid);
+        }
+    }
+    catch (e) {
+        // if a filter type is untranslatable, fall back to the generic pass-through JAQL filter
+        // console.error(e);
+    }
+    return (0, exports.createGenericFilter)(jaql, guid);
+};
+exports.createFilterFromJaqlInternal = createFilterFromJaqlInternal;

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

@@ -0,0 +1 @@
+export {};