@sisense/sdk-data 1.28.0 → 1.29.0

package/dist/dimensional-model/filters/filter-relations.js

@@ -0,0 +1,507 @@
+/* eslint-disable @typescript-eslint/default-param-last */
+import { DimensionalLevelAttribute, isCascadingFilter, } from '../../index.js';
+import { cloneDeep, isArray } from 'lodash-es';
+import { TranslatableError } from '../../translation/translatable-error.js';
+/**
+ * Type guard for checking if the provided filters are FilterRelations.
+ *
+ * @param filters - The filters to check.
+ * @returns `true` if the filters are FilterRelations, `false` otherwise.
+ * @group Filter Utilities
+ */
+export function isFilterRelations(filters) {
+    return (!!filters &&
+        'operator' in filters &&
+        (filters.operator === 'AND' || filters.operator === 'OR') &&
+        !!filters.right &&
+        !!filters.left);
+}
+/**
+ * Merges source filters with target filters and recalculates relations.
+ *
+ * @param sourceFilters - The source filters or filter relations to merge.
+ * @param targetFilters - The target filters or filter relations to merge with.
+ * @returns Updated source filters merged with target filters. If the source filters are FilterRelations, the relations are recalculated.
+ * @internal
+ */
+export function mergeFiltersOrFilterRelations(sourceFilters = [], targetFilters = []) {
+    if (!isFilterRelations(sourceFilters) && !isFilterRelations(targetFilters)) {
+        return mergeFilters(sourceFilters, targetFilters);
+    }
+    const { filters: pureSourceFilters, relations: sourceRelations } = splitFiltersAndRelations(sourceFilters);
+    const pureTargetFilters = getFiltersArray(targetFilters);
+    const mergedFilters = mergeFilters(pureSourceFilters, pureTargetFilters);
+    const mergedRelations = calculateNewRelations(pureSourceFilters, sourceRelations, mergedFilters);
+    return combineFiltersAndRelations(mergedFilters, mergedRelations);
+}
+/**
+ * Splits filters or filter relations into filters and relations rules.
+ * @internal
+ */
+export function splitFiltersAndRelations(filtersOrFilterRelations) {
+    if (!filtersOrFilterRelations) {
+        return { filters: [], relations: null };
+    }
+    if (isArray(filtersOrFilterRelations)) {
+        return { filters: filtersOrFilterRelations, relations: null };
+    }
+    const filtersSet = new Set();
+    function traverse(node) {
+        if (isFilterNode(node)) {
+            filtersSet.add(node);
+            return { instanceid: node.config.guid };
+        }
+        if (isFilterRelations(node)) {
+            const left = traverse(node.left);
+            const right = traverse(node.right);
+            return { left, right, operator: node.operator };
+        }
+        throw new UnknownRelationsNodeError();
+    }
+    const relations = traverse(filtersOrFilterRelations);
+    return {
+        filters: Array.from(filtersSet),
+        relations,
+    };
+}
+/**
+ * Returns pure filters array from the given filters or filter relations.
+ * @internal
+ */
+export function getFiltersArray(filtersOrFilterRelations) {
+    if (!filtersOrFilterRelations) {
+        return [];
+    }
+    return splitFiltersAndRelations(filtersOrFilterRelations).filters;
+}
+/**
+ * Combines filters and relations into a single FilterRelations object.
+ * If the relations are empty or relations are trivial (single node), the filters are returned as is.
+ * @internal
+ */
+export function combineFiltersAndRelations(filters, relations) {
+    if (!relations || isTrivialSingleNodeRelations(relations)) {
+        return filters;
+    }
+    const resultRelations = traverse(relations);
+    return isFilterNode(resultRelations) ? [resultRelations] : resultRelations;
+    function traverse(node) {
+        if (isRelationsRuleIdNode(node)) {
+            return filters.find((filter) => filter.config.guid === node.instanceid);
+        }
+        if (isRelationsRule(node)) {
+            return {
+                left: traverse(node.left),
+                right: traverse(node.right),
+                operator: node.operator,
+            };
+        }
+        throw new UnknownRelationsNodeError();
+    }
+}
+/** Type guard for checking if a node is a single relations node (trivial case when relations are needless).
+ * @internal
+ */
+export function isTrivialSingleNodeRelations(relations) {
+    return !!relations && 'instanceid' in relations;
+}
+/**
+ * Calculates new relations based on the changes in filters.
+ * @internal
+ */
+export function calculateNewRelations(prevFilters, prevRelations, newFilters) {
+    // If there are no previous relations - no need to recalculate them
+    if (prevRelations === null) {
+        return null;
+    }
+    const performedActions = diffFilters(prevFilters, newFilters);
+    if (performedActions.length === 0) {
+        return prevRelations;
+    }
+    return performedActions.reduce((relations, action) => {
+        switch (action.type) {
+            case 'add':
+                return addFilterToRelations(action.payload, relations);
+            case 'remove':
+                return removeFilterFromRelations(action.payload, relations);
+        }
+    }, prevRelations);
+}
+/**
+ * Compares two filters and determines if they are equal in terms of relations.
+ */
+function areFiltersEqualForRelations(filter1, filter2) {
+    return filter1.config.guid === filter2.config.guid;
+}
+/**
+ * Replaces a filter in the relations tree with a new filter.
+ * @internal
+ */
+export function getRelationsWithReplacedFilter(relations, filterToReplace, newFilter) {
+    if (!relations) {
+        return null;
+    }
+    const replacedRelations = traverse(relations);
+    return replacedRelations;
+    function traverse(node) {
+        if (isRelationsRuleIdNode(node)) {
+            return node.instanceid === filterToReplace.config.guid
+                ? { instanceid: newFilter.config.guid }
+                : node;
+        }
+        if (isRelationsRule(node)) {
+            return {
+                left: traverse(node.left),
+                right: traverse(node.right),
+                operator: node.operator,
+            };
+        }
+        throw new UnknownRelationsNodeError();
+    }
+}
+/**
+ * Compares two arrays of Filter objects and determines the actions needed
+ * to transform prevFilters into newFilters.
+ *
+ * @param prevFilters - The original array of filters.
+ * @param newFilters - The updated array of filters.
+ * @param isEqualFilters - A function to determine if two filters are equal.
+ * @returns An array of FilterAction objects representing the changes.
+ */
+function diffFilters(prevFilters, newFilters) {
+    const actions = [];
+    // Clone the arrays to avoid mutating the original data
+    const prevFiltersCopy = [...prevFilters];
+    const newFiltersCopy = [...newFilters];
+    // Determine removals
+    prevFiltersCopy.forEach((prevFilter) => {
+        const existsInNew = newFiltersCopy.some((newFilter) => areFiltersEqualForRelations(prevFilter, newFilter));
+        if (!existsInNew) {
+            actions.push({ type: 'remove', payload: prevFilter });
+        }
+    });
+    // Determine additions
+    newFiltersCopy.forEach((newFilter) => {
+        const existsInPrev = prevFiltersCopy.some((prevFilter) => areFiltersEqualForRelations(newFilter, prevFilter));
+        if (!existsInPrev) {
+            actions.push({ type: 'add', payload: newFilter });
+        }
+    });
+    return actions;
+}
+/**
+ * Adds a filter to root of relations tree as a new node connected with AND operator.
+ * If the relations tree is empty, the filter is added as the root node.
+ */
+function addFilterToRelations(filter, relations) {
+    if (!relations) {
+        return { instanceid: filter.config.guid };
+    }
+    return {
+        left: relations,
+        right: { instanceid: filter.config.guid },
+        operator: 'AND',
+    };
+}
+/**
+ * Removes a filter from the relations tree.
+ * If the filter is not found, the relations tree is returned as is.
+ */
+function removeFilterFromRelations(filter, relations) {
+    if (!relations) {
+        return null;
+    }
+    if (isTrivialSingleNodeRelations(relations)) {
+        return relations.instanceid === filter.config.guid ? null : relations;
+    }
+    const leftAfterRemoval = removeFilterFromRelations(filter, relations.left);
+    const rightAfterRemoval = removeFilterFromRelations(filter, relations.right);
+    if (leftAfterRemoval === null && !!rightAfterRemoval) {
+        return rightAfterRemoval;
+    }
+    if (rightAfterRemoval === null && !!leftAfterRemoval) {
+        return leftAfterRemoval;
+    }
+    if (leftAfterRemoval === null && rightAfterRemoval === null) {
+        return null;
+    }
+    return {
+        left: leftAfterRemoval,
+        right: rightAfterRemoval,
+        operator: relations.operator,
+    };
+}
+/**
+ * Converts filter relations model from Fusion to internal CSDK filter relations rules.
+ * @internal
+ */
+export function convertFilterRelationsModelToRelationRules(filterRelationsModel, filters) {
+    if (!filterRelationsModel) {
+        return null;
+    }
+    function traverse(node) {
+        if (isModelIdNode(node)) {
+            return { instanceid: node.instanceId };
+        }
+        if (isModelBracketNode(node)) {
+            return traverse(node.value);
+        }
+        if (isModelRelationNode(node)) {
+            const newNode = {
+                operator: node.operator,
+                left: traverse(node.left),
+                right: traverse(node.right),
+            };
+            return newNode;
+        }
+        if (isModelCascadeNode(node)) {
+            // CSDK filter relations model work with cascading filters as with a single node.
+            const cascadingFilterForThisCascade = filters.find((filter) => {
+                if (!isCascadingFilter(filter)) {
+                    return false;
+                }
+                const levelIds = filter.filters.map((f) => f.config.guid);
+                return node.levels.every((levelFilter) => levelIds.includes(levelFilter.instanceId));
+            });
+            if (cascadingFilterForThisCascade) {
+                return { instanceid: cascadingFilterForThisCascade.config.guid };
+            }
+            throw new Error('Broken filter relations model. Cascading filter not found.');
+        }
+        throw new Error('Broken filter relations model. Unknown node type.');
+    }
+    return traverse(filterRelationsModel);
+}
+function isModelIdNode(node) {
+    return 'instanceId' in node;
+}
+function isModelBracketNode(node) {
+    return 'value' in node;
+}
+function isModelRelationNode(node) {
+    return 'operator' in node;
+}
+function isModelCascadeNode(node) {
+    return 'levels' in node && isArray(node.levels);
+}
+/**
+ * @internal
+ */
+export function isRelationsRuleIdNode(node) {
+    return 'instanceid' in node;
+}
+/**
+ * @internal
+ */
+export function isRelationsRule(node) {
+    return 'operator' in node;
+}
+function isFilterNode(node) {
+    return 'config' in node && 'guid' in node.config;
+}
+/**
+ * Converts internal CSDK filter relations rules to filter relations model for Fusion.
+ * @internal
+ */
+export function filterRelationRulesToFilterRelationsModel(filterRelationRules, filters) {
+    if (!filterRelationRules) {
+        return undefined;
+    }
+    function traverse(node) {
+        if (isRelationsRuleIdNode(node)) {
+            // Check if this instanceid corresponds to a cascading filter
+            const filter = filters.find((f) => f.config.guid === node.instanceid);
+            if (filter && isCascadingFilter(filter)) {
+                // Build a CascadingIdentifier node
+                const levels = filter.filters.map((levelFilter) => ({
+                    type: 'Identifier',
+                    instanceId: levelFilter.config.guid,
+                }));
+                return {
+                    type: 'CascadingIdentifier',
+                    levels,
+                };
+            }
+            else {
+                // Build an Identifier node
+                return {
+                    type: 'Identifier',
+                    instanceId: node.instanceid,
+                };
+            }
+        }
+        else if (isRelationsRule(node)) {
+            // Build a LogicalExpression node
+            return {
+                type: 'LogicalExpression',
+                operator: node.operator,
+                left: traverse(node.left),
+                right: traverse(node.right),
+            };
+        }
+        else {
+            throw new Error('Unknown node type in filter relations rules.');
+        }
+    }
+    return traverse(filterRelationRules);
+}
+/**
+ * @internal
+ */
+export function findFilterByGuid(filters, guid) {
+    return filters.find((filter) => filter.config.guid === guid);
+}
+/**
+ * Error thrown when an unknown node type is encountered in filter relations.
+ * @internal
+ */
+export class UnknownRelationsNodeError extends Error {
+    constructor() {
+        super('Broken filter relations. Unknown node type.');
+    }
+}
+/**
+ * @internal
+ */
+export function isOpenBracketDescriptionNode(node) {
+    return node.nodeType === 'openBracket';
+}
+/**
+ * @internal
+ */
+export function isCloseBracketDescriptionNode(node) {
+    return node.nodeType === 'closeBracket';
+}
+/**
+ * @internal
+ */
+export function isAttributeDescriptionNode(node) {
+    return node.nodeType === 'attribute';
+}
+/**
+ * @internal
+ */
+export function isOperatorDescriptionNode(node) {
+    return node.nodeType === 'operator';
+}
+/**
+ * Gets a unique identifier for a filter, combining its attribute expression and granularity if available.
+ *
+ * @param {Filter} filter - The filter object to generate the unique identifier for.
+ * @returns {string} - The unique identifier for the filter.
+ * @internal
+ */
+export function getFilterCompareId(filter) {
+    if (isCascadingFilter(filter)) {
+        return filter.filters.map(getFilterCompareId).join('-');
+    }
+    // TODO: remove fallback on 'filter.jaql()' after removing temporal 'jaql()' workaround from filter translation layer
+    const { attribute: filterAttribute } = filter;
+    const filterJaql = filter.jaql().jaql;
+    const expression = filterAttribute.expression || filterJaql.dim;
+    const granularity = filterAttribute.granularity ||
+        ((filterJaql === null || filterJaql === void 0 ? void 0 : filterJaql.datatype) === 'datetime'
+            ? DimensionalLevelAttribute.translateJaqlToGranularity(filterJaql)
+            : '');
+    return `${expression}${granularity}`;
+}
+/**
+ * Merges two arrays of filter objects, prioritizing 'targetFilters' over 'sourceFilters',
+ * and removes duplicates based on filter compare id.
+ *
+ * Saves the 'sourceFilters' filters order, while adds new filters to the end of the array.
+ *
+ * @param {Filter[]} [sourceFilters=[]] - The source array of filter objects.
+ * @param {Filter[]} [targetFilters=[]] - The target array of filter objects.
+ * @returns {Filter[]} - The merged array of filter objects.
+ * @internal
+ */
+export function mergeFilters(sourceFilters = [], targetFilters = []) {
+    const filters = [...sourceFilters];
+    targetFilters.forEach((filter) => {
+        const existingFilterIndex = filters.findIndex((existingFilter) => getFilterCompareId(filter) === getFilterCompareId(existingFilter));
+        const isFilterAlreadyExist = existingFilterIndex !== -1;
+        if (isFilterAlreadyExist) {
+            filters[existingFilterIndex] = filter;
+        }
+        else {
+            filters.push(filter);
+        }
+    });
+    return filters;
+}
+/**
+ * Replaces nodes of filter reations tree with fetched filters by instance id.
+ *
+ * @param filters - The filters.
+ * @param highlights - The highlights
+ * @param filterRelations - Fetched filter relations.
+ * @returns Filter relations with filters in nodes.
+ * @internal
+ */
+/* eslint-disable-next-line sonarjs/cognitive-complexity */
+export function getFilterRelationsFromJaql(filters, highlights, filterRelations) {
+    if (!filterRelations) {
+        return filters;
+    }
+    // If highlights are present, nodes in filter relations reference both filters and highlights
+    // and thus cannot be replaced with filters. Return filters in this case.
+    if (highlights.length) {
+        return filters;
+    }
+    const mergedFilterRelations = cloneDeep(filterRelations);
+    function traverse(node) {
+        if ('instanceid' in node) {
+            const filter = filters.find((filter) => filter.config.guid === node.instanceid);
+            if (!filter) {
+                throw new TranslatableError('errors.unknownFilterInFilterRelations');
+            }
+            return filter;
+        }
+        if ('operator' in node) {
+            const newNode = { operator: node.operator };
+            if ('left' in node) {
+                newNode.left = traverse(node.left);
+            }
+            if ('right' in node) {
+                newNode.right = traverse(node.right);
+            }
+            return newNode;
+        }
+        return node;
+    }
+    return traverse(mergedFilterRelations);
+}
+/**
+ * Converts filter relations model to filter relations jaql.
+ *
+ * @param filterRelations - Filter relations model.
+ * @returns Filter relations jaql.
+ * @internal
+ */
+export function convertFilterRelationsModelToJaql(filterRelations) {
+    if (!filterRelations) {
+        return filterRelations;
+    }
+    const convertedFilterRelations = cloneDeep(filterRelations);
+    function traverse(node) {
+        if ('instanceId' in node) {
+            return { instanceid: node.instanceId };
+        }
+        if ('value' in node) {
+            return traverse(node.value);
+        }
+        if ('operator' in node) {
+            const newNode = { operator: node.operator };
+            if ('left' in node) {
+                newNode.left = traverse(node.left);
+            }
+            if ('right' in node) {
+                newNode.right = traverse(node.right);
+            }
+            return newNode;
+        }
+        return node;
+    }
+    return traverse(convertedFilterRelations);
+}

package/dist/dimensional-model/filters/helpers.d.ts

@@ -0,0 +1,112 @@
+import { Filter, FilterRelations } from '../../index.js';
+/**
+ * Returns a function that adds a filter to existing filters or filter relations.
+ *
+ * @param filter - The filter to add.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the new filter added.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange];
+ * const updatedFilters = withAddedFilter(filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByCost]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withAddedFilter(filterByCost)(originalFilterRelations);
+ * // (filterByAgeRange OR filterByRevenue) AND filterByCost
+ * ```
+ */
+export declare function withAddedFilter(filter: Filter): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that adds multiple filters to existing filters or filter relations.
+ *
+ * @param filtersToAdd - An array of filters to add.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the new filters added.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange];
+ * const updatedFilters = withAddedFilters([filterByCost, filterByRevenue])(originalFilters);
+ * // [filterByAgeRange, filterByCost, filterByRevenue]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withAddedFilters([filterByCost, filterByRevenue])(originalFilterRelations);
+ * // (filterByAgeRange OR filterByRevenue) AND filterByCost AND filterByRevenue
+ * ```
+ */
+export declare function withAddedFilters(filtersToAdd: Filter[]): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that removes a filter from existing filters or filter relations.
+ *
+ * @param filterToRemove - The filter to remove.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations without the specified filter.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue, filterByCost];
+ * const updatedFilters = withoutFilter(filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByRevenue]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFiltersRelations = withoutFilter(filterByRevenue)(originalFilterRelations);
+ * // filterByAgeRange
+ * ```
+ */
+export declare function withoutFilter(filterToRemove: Filter): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that removes multiple filters from existing filters or filter relations.
+ *
+ * @param filtersToRemove - An array of filters to remove.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations without the specified filters.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue, filterByCost];
+ * const updatedFilters = withRemovedFilters([filterByRevenue, filterByCost])(originalFilters);
+ * // [filterByAgeRange]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFiltersRelations = withRemovedFilters([filterByRevenue])(originalFilterRelations);
+ * // filterByAgeRange
+ * ```
+ */
+export declare function withoutFilters(filtersToRemove: Filter[]): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Returns a function that replaces a filter with a new filter in existing filters or filter relations.
+ *
+ * @param filterToReplace - The filter to replace.
+ * @param newFilter - The new filter to use as a replacement.
+ * @returns A function that takes existing filters or filter relations and returns updated filters or filter relations with the filter replaced.
+ * @group Filter Utilities
+ * @example
+ * ```ts
+ * // Using with an array of filters
+ * const originalFilters = [filterByAgeRange, filterByRevenue];
+ * const updatedFilters = withReplacedFilter(filterByRevenue, filterByCost)(originalFilters);
+ * // [filterByAgeRange, filterByCost]
+ *
+ * // Using with filter relations
+ * const originalFilterRelations = filterFactory.logic.or(filterByAgeRange, filterByRevenue);
+ * const updatedFilterRelations = withReplacedFilter(filterByRevenue, filterByCost)(originalFilterRelations);
+ * // (filterByAgeRange OR filterByCost)
+ * ```
+ */
+export declare function withReplacedFilter(filterToReplace: Filter, newFilter: Filter): (filters: Filter[] | FilterRelations | undefined) => Filter[] | FilterRelations;
+/**
+ * Finds a filter in an array of filters or filter relations.
+ * Returns the first filter that satisfies the provided search function.
+ * @group Filter Utilities
+ * @param filters - An array of filters or filter relations to search.
+ * @param searchFn - A function that takes a filter and returns a boolean indicating whether the filter satisfies the search criteria.
+ * @returns The first filter that satisfies the search function, or `undefined` if no filter is found.
+ *
+ */
+export declare function findFilter(filters: Filter[] | FilterRelations | undefined, searchFn: (filter: Filter) => boolean): Filter | undefined;