@sisense/sdk-data 2.21.0 → 2.23.0

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

@@ -113,14 +113,21 @@ export function isTrivialSingleNodeRelations(relations) {
 /**
  * Calculates new relations based on the changes in filters.
  *
+ * @param prevFilters - The previous array of filters that the relations were built for.
+ * @param prevRelations - The previous relation rules.
+ * @param newFilters - The updated array of filters to build new relations for.
+ * @param options - Optional flags controlling how the diff is computed:
+ *   - `shouldReplaceSameAttributeFilters`: when `true`, a new filter on the same attribute as
+ *     an existing one (but with a different GUID) is treated as an in-place replacement rather
+ *     than a remove + add pair, preserving the original relation tree structure.
  * @internal
  */
-export function calculateNewRelations(prevFilters, prevRelations, newFilters) {
+export function calculateNewRelations(prevFilters, prevRelations, newFilters, options = {}) {
     // If there are no previous relations - no need to recalculate them
     if (prevRelations === null) {
         return null;
     }
-    const performedActions = diffFilters(prevFilters, newFilters);
+    const performedActions = diffFilters(prevFilters, newFilters, options.shouldReplaceSameAttributeFilters);
     if (performedActions.length === 0) {
         return prevRelations;
     }
@@ -130,6 +137,8 @@ export function calculateNewRelations(prevFilters, prevRelations, newFilters) {
                 return addFilterToRelations(action.payload, relations);
             case 'remove':
                 return removeFilterFromRelations(action.payload, relations);
+            case 'replace':
+                return getRelationsWithReplacedFilter(relations, action.payload.prevFilter, action.payload.newFilter);
         }
     }, prevRelations);
 }
@@ -170,26 +179,54 @@ export function getRelationsWithReplacedFilter(relations, filterToReplace, newFi
  * Compares two arrays of Filter objects and determines the actions needed
  * to transform prevFilters into newFilters.
  *
+ * When `shouldReplaceSameAttributeFilters` is enabled, a new filter whose attribute matches
+ * an existing one (same `getFilterCompareId`) but has a different GUID is emitted as a single
+ * `replace` action instead of a `remove` + `add` pair. This preserves the relation tree node
+ * at the original position rather than appending the new filter with AND at the root.
+ * The disabled existing filters are excluded from the same-attribute replacement check
+ * and will therefore never be replaced in-place.
+ *
  * @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.
+ * @param shouldReplaceSameAttributeFilters - Optional flag to enable same-attribute filter replacement.
  * @returns An array of FilterAction objects representing the changes.
  */
-function diffFilters(prevFilters, newFilters) {
+function diffFilters(prevFilters, newFilters, shouldReplaceSameAttributeFilters = false) {
     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));
+    // Track which filters from each side have already been matched to avoid double-counting.
+    const matchedPrevFilters = new Set();
+    const matchedNewFilters = new Set();
+    if (shouldReplaceSameAttributeFilters) {
+        prevFilters.forEach((prevFilter, prevIdx) => {
+            // Disabled filters are never eligible for in-place replacement.
+            if (prevFilter.config.disabled) {
+                return;
+            }
+            // Look for a new filter on the same attribute with a different GUID.
+            const newIdx = newFilters.findIndex((newFilter, idx) => !matchedNewFilters.has(idx) &&
+                !areFiltersEqualForRelations(prevFilter, newFilter) &&
+                getFilterCompareId(prevFilter) === getFilterCompareId(newFilter));
+            if (newIdx !== -1) {
+                actions.push({ type: 'replace', payload: { prevFilter, newFilter: newFilters[newIdx] } });
+                matchedPrevFilters.add(prevIdx);
+                matchedNewFilters.add(newIdx);
+            }
+        });
+    }
+    // Removals: prev filters not matched by GUID in new filters (and not already handled as replace).
+    prevFilters.forEach((prevFilter, prevIdx) => {
+        if (matchedPrevFilters.has(prevIdx))
+            return;
+        const existsInNew = newFilters.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));
+    // Additions: new filters not matched by GUID in prev filters (and not already handled as replace).
+    newFilters.forEach((newFilter, newIdx) => {
+        if (matchedNewFilters.has(newIdx))
+            return;
+        const existsInPrev = prevFilters.some((prevFilter) => areFiltersEqualForRelations(newFilter, prevFilter));
         if (!existsInPrev) {
             actions.push({ type: 'add', payload: newFilter });
         }

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

@@ -5,7 +5,7 @@ import omit from 'lodash-es/omit.js';
 import { TranslatableError } from '../../translation/translatable-error.js';
 import { DimensionalElement } from '../base.js';
 import { create } from '../factory.js';
-import { isDimensionalBaseMeasure } from '../measures/measures.js';
+import { isDimensionalBaseMeasure, isDimensionalCalculatedMeasure } from '../measures/measures.js';
 import { DateLevels, MetadataTypes } from '../types.js';
 import { getDefaultBaseFilterConfig, getDefaultMembersFilterConfig, } from './filter-config-utils.js';
 /**
@@ -470,7 +470,7 @@ export class MeasureFilter extends DoubleOperatorFilter {
             return AbstractFilter.disabledJaql(nested);
         }
         const result = super.jaql(nested);
-        if (isDimensionalBaseMeasure(this.measure)) {
+        if (isDimensionalBaseMeasure(this.measure) || isDimensionalCalculatedMeasure(this.measure)) {
             Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {
                 result.jaql[key] = value;
             });
@@ -561,7 +561,7 @@ export class MeasureRankingFilter extends AbstractFilter {
             return AbstractFilter.disabledJaql(nested);
         }
         const result = super.jaql(nested);
-        if (isDimensionalBaseMeasure(this.measure)) {
+        if (isDimensionalBaseMeasure(this.measure) || isDimensionalCalculatedMeasure(this.measure)) {
             Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {
                 result.jaql[key] = value;
             });

package/dist/dimensional-model/interfaces.d.ts

@@ -82,6 +82,18 @@ export interface Element {
      * @internal
      */
     composeCode?: string;
+    /**
+     * Merged from DataSourceField. It is used for the aggregation filtering
+     *
+     * @internal
+     */
+    readonly merged?: boolean;
+    /**
+     * Indexed from DataSourceField. It is used for the aggregation filtering
+     *
+     * @internal
+     */
+    readonly indexed?: boolean;
 }
 /**
  * Base interface for measure, which is typically numeric aggregation over {@link Attribute}(s).

package/dist/dimensional-model/measures/measures.d.ts

@@ -1,6 +1,6 @@
 import { DimensionalElement } from '../base.js';
 import { Attribute, BaseMeasure, CalculatedMeasure, Measure, MeasureContext, MeasureTemplate } from '../interfaces.js';
-import { AnyObject, JaqlDataSource, JSONObject, Sort } from '../types.js';
+import { AggregationType, AnyObject, JaqlDataSource, JSONObject, Sort } from '../types.js';
 /**
  * @internal
  */
@@ -57,7 +57,7 @@ export declare class DimensionalBaseMeasure extends AbstractMeasure implements B
      * @internal
      */
     readonly __serializable: string;
-    static aggregationFromJAQL(agg: string): string;
+    static aggregationFromJAQL(agg: string): AggregationType;
     static aggregationToJAQL(agg: string): string;
     constructor(name: string, attribute: Attribute, agg: string, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
     /**

package/dist/dimensional-model/measures/measures.js

@@ -235,7 +235,10 @@ export class DimensionalCalculatedMeasure extends AbstractMeasure {
         };
         const context = {};
         const keys = Object.getOwnPropertyNames(this.context);
-        keys.forEach((k) => (context[k] = this.context[k].jaql(true)));
+        keys.forEach((k) => {
+            const v = this.context[k];
+            context[k] = v && typeof v.jaql === 'function' ? v.jaql(true) : v;
+        });
         r.jaql.context = context;
         if (this._format) {
             r.format = { number: this._format };

package/dist/dimensional-model/types.d.ts

@@ -9,24 +9,29 @@ export type { JaqlDataSource, JaqlDataSourceForDto };
  */
 export declare const AggregationTypes: {
     /** Sum aggregation type */
-    Sum: string;
+    readonly Sum: "sum";
     /** Average aggregation type */
-    Average: string;
+    readonly Average: "avg";
     /** Min aggregation type */
-    Min: string;
+    readonly Min: "min";
     /** Max aggregation type */
-    Max: string;
+    readonly Max: "max";
     /** Count aggregation type */
-    Count: string;
+    readonly Count: "count";
     /** Count distinct aggregation type */
-    CountDistinct: string;
+    readonly CountDistinct: "countDistinct";
     /** Median aggregation type */
-    Median: string;
+    readonly Median: "median";
     /** Variance aggregation type */
-    Variance: string;
+    readonly Variance: "var";
     /** Standard deviation aggregation type */
-    StandardDeviation: string;
+    readonly StandardDeviation: "stdev";
 };
+declare const aggTypes: ("sum" | "avg" | "min" | "max" | "count" | "countDistinct" | "median" | "var" | "stdev")[];
+/**
+ * @internal
+ */
+export declare type AggregationType = (typeof aggTypes)[number];
 /**
  * Different sort types.
  */
@@ -202,6 +207,7 @@ export declare type BaseJaql = {
             jaql: FilterJaql;
         };
     };
+    indexed?: boolean;
     merged?: boolean;
     panel?: 'rows' | 'columns';
 };

package/dist/dimensional-model/types.js

@@ -22,6 +22,7 @@ export const AggregationTypes = {
     /** Standard deviation aggregation type */
     StandardDeviation: 'stdev',
 };
+const aggTypes = Object.values(AggregationTypes);
 /**
  * Different sort types.
  */