@sisense/sdk-data 1.11.0 → 1.13.0

package/dist/cjs/utils.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFilterFromJaql = exports.isDataSourceInfo = exports.getDataSourceName = exports.getFilterListAndRelations = exports.guidFast = void 0;
+const cloneDeep_js_1 = __importDefault(require("lodash/cloneDeep.js"));
+const filter_from_jaql_util_js_1 = require("./dimensional-model/filters/utils/filter-from-jaql-util.js");
+/**
+ * A more performant, but slightly bulkier, RFC4122v4 implementation. Performance is improved by minimizing calls to random()
+ *
+ * @internal
+ */
+const guidFast = function (len) {
+    if (!len) {
+        len = 20;
+    }
+    const chars = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split('');
+    const uuid = new Array(len);
+    let rnd = 0;
+    let r;
+    for (let i = 0; i < len; i += 1) {
+        if (i > 0 && i % 5 == 0) {
+            uuid[i] = '-';
+            continue;
+        }
+        if (rnd <= 0x02) {
+            rnd = (0x2000000 + Math.random() * 0x1000000) | 0;
+        }
+        r = rnd & 0xf;
+        rnd = rnd >> 4;
+        uuid[i] = chars[i == 19 ? (r & 0x3) | 0x8 : r];
+    }
+    return uuid.join('');
+};
+exports.guidFast = guidFast;
+/**
+ * Function to separate list of filters from the provided relation and get logical relations for jaql
+ *
+ * @internal
+ */
+const getFilterListAndRelations = (filterRelations) => {
+    if (!filterRelations) {
+        return { filters: undefined, relations: undefined };
+    }
+    if (Array.isArray(filterRelations)) {
+        return { filters: filterRelations, relations: undefined };
+    }
+    const filters = new Set();
+    function traverse(node) {
+        if (!node)
+            return node;
+        if ('guid' in node) {
+            filters.add(node);
+            return { instanceid: node.guid };
+        }
+        else {
+            if ('left' in node) {
+                node.left = traverse(node.left);
+            }
+            if ('right' in node) {
+                node.right = traverse(node.right);
+            }
+            return node;
+        }
+    }
+    // Create a deep copy of filterRelations to avoid mutation
+    const copiedFilterRelations = (0, cloneDeep_js_1.default)(filterRelations);
+    const relations = traverse(copiedFilterRelations);
+    return { filters: Array.from(filters), relations };
+};
+exports.getFilterListAndRelations = getFilterListAndRelations;
+/**
+ * Gets the name of the data source
+ *
+ * @internal
+ */
+function getDataSourceName(dataSource) {
+    return typeof dataSource === 'string' ? dataSource : dataSource.title;
+}
+exports.getDataSourceName = getDataSourceName;
+/**
+ * Checks if the provided 'dataSource' is a data source info structure that contains more than just the data source name.
+ *
+ * @internal
+ */
+function isDataSourceInfo(dataSource) {
+    return typeof dataSource === 'object' && 'type' in dataSource && 'title' in dataSource;
+}
+exports.isDataSourceInfo = isDataSourceInfo;
+/**
+ * Creates a filter from a JAQL object.
+ *
+ * @param jaql - The filter JAQL object.
+ * @param instanceid - The instance ID.
+ * @returns - The created Filter object.
+ * @internal
+ */
+const createFilterFromJaql = (jaql, instanceid) => {
+    // translation logic is based on FilterJaqlInternal type (from internal modern-analytics-filters)
+    // TODO reconcile FilterJaql and FilterJaqlInternal
+    const jaqlInternal = jaql;
+    return (0, filter_from_jaql_util_js_1.createFilterFromJaqlInternal)(jaqlInternal, instanceid);
+};
+exports.createFilterFromJaql = createFilterFromJaql;

package/dist/cjs/utils.test.d.ts

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

package/dist/cjs/utils.test.js

@@ -0,0 +1,158 @@
+"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 });
+const index_js_1 = require("./index.js");
+const utils_js_1 = require("./utils.js");
+const vitest_1 = require("vitest");
+const filterFactory = __importStar(require("./dimensional-model/filters/factory.js"));
+const attribute_measure_util_js_1 = require("./dimensional-model/filters/utils/attribute-measure-util.js");
+const mockFilter1 = { guid: 'filter-1', name: 'Filter 1' };
+const mockFilter2 = { guid: 'filter-2', name: 'Filter 2' };
+const mockSimpleFilterRelations = {
+    operator: 'OR',
+    left: mockFilter1,
+    right: mockFilter2,
+};
+const mockNestedFilterRelations = {
+    operator: 'AND',
+    left: mockFilter1,
+    right: mockSimpleFilterRelations,
+};
+const simpleFilterRelationsResult = {
+    operator: 'OR',
+    left: { instanceid: mockFilter1.guid },
+    right: { instanceid: mockFilter2.guid },
+};
+const nestedFilterRelationsResult = {
+    operator: 'AND',
+    left: { instanceid: mockFilter1.guid },
+    right: simpleFilterRelationsResult,
+};
+(0, vitest_1.describe)('utils', () => {
+    (0, vitest_1.describe)('guidFast', () => {
+        test('should return a string of default length if length is not provided', () => {
+            const guid = (0, utils_js_1.guidFast)();
+            expect(typeof guid).toBe('string');
+            expect(guid.length).toBe(20);
+        });
+        test('should return a string of provided length', () => {
+            const guid = (0, utils_js_1.guidFast)(10);
+            expect(typeof guid).toBe('string');
+            expect(guid.length).toBe(10);
+        });
+        test('should return unique uids with no regard to timestamp', () => {
+            const guids = Array(2)
+                .fill(0)
+                .map(() => (0, utils_js_1.guidFast)(13));
+            const timestamps = Array(2)
+                .fill(0)
+                .map(() => Date.now());
+            expect(timestamps[0]).toBe(timestamps[1]);
+            expect(guids[0]).not.toBe(guids[1]);
+        });
+    });
+    (0, vitest_1.describe)('getFilterListAndRelations', () => {
+        test('should return undefined filters and undefined relations when input is undefined', () => {
+            const result = (0, utils_js_1.getFilterListAndRelations)(undefined);
+            expect(result.filters).toBeUndefined();
+            expect(result.relations).toBeUndefined();
+        });
+        test('should return filter list and undefined relations when input is an empty array', () => {
+            const result = (0, utils_js_1.getFilterListAndRelations)([]);
+            expect(result.filters).toEqual([]);
+            expect(result.relations).toBeUndefined();
+        });
+        test('should return filter list and undefined relations when input is an array of filters', () => {
+            const filterArray = [mockFilter1, mockFilter2];
+            const result = (0, utils_js_1.getFilterListAndRelations)(filterArray);
+            expect(result.filters).toEqual(filterArray);
+            expect(result.relations).toBeUndefined();
+        });
+        test('should return filter list and relations when input is a simple FilterRelations', () => {
+            const result = (0, utils_js_1.getFilterListAndRelations)(mockSimpleFilterRelations);
+            expect(result.filters).toEqual([mockFilter1, mockFilter2]);
+            expect(result.relations).toEqual(simpleFilterRelationsResult);
+        });
+        test('should return filter list and relations when input is a nested FilterRelations', () => {
+            const result = (0, utils_js_1.getFilterListAndRelations)(mockNestedFilterRelations);
+            expect(result.filters).toEqual([mockFilter1, mockFilter2]);
+            expect(result.relations).toEqual(nestedFilterRelationsResult);
+        });
+    });
+    (0, vitest_1.describe)('getDataSourceName', () => {
+        test('should return the name of the data source if it is DataSourceInfo', () => {
+            const dataSourceName = 'data-source-name';
+            const dataSource = {
+                type: 'elasticube',
+                title: dataSourceName,
+            };
+            const result = (0, utils_js_1.getDataSourceName)(dataSource);
+            expect(result).toBe(dataSourceName);
+        });
+        test('should return the data source itself if it is a string', () => {
+            const dataSourceName = 'data-source-name';
+            const result = (0, utils_js_1.getDataSourceName)(dataSourceName);
+            expect(result).toBe(dataSourceName);
+        });
+    });
+    (0, vitest_1.describe)('isDataSourceInfo', () => {
+        test('should return true if the provided dataSource is a DataSourceInfo', () => {
+            const dataSource = {
+                type: 'elasticube',
+                title: 'data-source-name',
+            };
+            const result = (0, utils_js_1.isDataSourceInfo)(dataSource);
+            expect(result).toBe(true);
+        });
+        test('should return false if the provided dataSource is a string', () => {
+            const dataSourceName = 'data-source-name';
+            const result = (0, utils_js_1.isDataSourceInfo)(dataSourceName);
+            expect(result).toBe(false);
+        });
+    });
+    (0, vitest_1.describe)('createFilterFromJaql', () => {
+        const instanceid = 'instanceid';
+        // just one simple test to cover the function.
+        // See more tests in src/dimensional-model/filters/utils/filter-jaql-util.test.ts
+        test('MembersFilter members()', () => {
+            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, index_js_1.createFilterFromJaql)(jaql, instanceid);
+            const attribute = (0, attribute_measure_util_js_1.createAttributeFromFilterJaql)(jaql);
+            const expectedFilter = filterFactory.members(attribute, jaql.filter.members);
+            expect(filter.jaql().jaql).toEqual(expectedFilter.jaql().jaql);
+        });
+    });
+});

package/dist/dimensional-model/analytics/factory.js

@@ -96,8 +96,8 @@ export const boxWhiskerIqrOutliers = (target) => {
         Attr: target,
     });
     outliersAttrWithInnerFilter.name = `${outliersAttrWithInnerFilter.name} (Outliers)`;
-    outliersAttrWithInnerFilter.jaql = () => {
-        return Object.assign(Object.assign({}, target.jaql(true)), { filter: {
+    outliersAttrWithInnerFilter.jaql = (nested) => {
+        const jaql = Object.assign(Object.assign({}, target.jaql(true)), { filter: {
                 or: [
                     {
                         fromNotEqual: outliersMax.jaql(true),
@@ -107,6 +107,7 @@ export const boxWhiskerIqrOutliers = (target) => {
                     },
                 ],
             } });
+        return nested ? jaql : { jaql };
     };
     return outliersAttrWithInnerFilter;
 };
@@ -124,8 +125,8 @@ export const boxWhiskerStdDevOutliers = (target) => {
     const outliersMin = customFormula(BOX_WHISKER.OUTLIER_MIN_VALUE_NAME, '(LOWERWHISKERMAX_STDEVP([Attr]), all([Attr]))', {
         Attr: target,
     });
-    outliersAttrWithInnerFilter.jaql = () => {
-        return Object.assign(Object.assign({}, target.jaql(true)), { filter: {
+    outliersAttrWithInnerFilter.jaql = (nested) => {
+        const jaql = Object.assign(Object.assign({}, target.jaql(true)), { filter: {
                 or: [
                     {
                         fromNotEqual: outliersMax.jaql(true),
@@ -135,6 +136,7 @@ export const boxWhiskerStdDevOutliers = (target) => {
                     },
                 ],
             } });
+        return nested ? jaql : { jaql };
     };
     return outliersAttrWithInnerFilter;
 };