@sisense/sdk-data 1.11.0 → 1.13.0

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

@@ -73,6 +73,8 @@ export declare const FilterTypes: {
     numeric: string;
     date: string;
     relativeDate: string;
+    cascading: string;
+    advanced: string;
 };
 /**
  * base implementation for filter classes
@@ -92,13 +94,15 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      * Global filter identifier
      */
     readonly guid: string;
+    private _disabled;
     /**
      * Boolean flag whether the filter is disabled
      *
      * @internal
      */
-    disabled: boolean;
-    constructor(att: Attribute, filterType: string);
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    constructor(att: Attribute, filterType: string, guid?: string);
     get name(): string;
     /**
      * Gets JAQL representing this Filter instance
@@ -123,6 +127,7 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      */
     jaql(nested?: boolean): any;
     static checkAttributeSupport(attribute: Attribute): void;
+    static disabledJaql(nested?: boolean): any;
 }
 /**
  * @internal
@@ -130,7 +135,7 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
 export declare class LogicalAttributeFilter extends AbstractFilter {
     readonly filters: Filter[];
     readonly operator: string;
-    constructor(filters: Filter[], operator: string);
+    constructor(filters: Filter[], operator: string, guid?: string);
     /**
      * gets the element's ID
      */
@@ -149,7 +154,9 @@ export declare class LogicalAttributeFilter extends AbstractFilter {
  */
 export declare class MembersFilter extends AbstractFilter {
     readonly members: any[];
-    constructor(attribute: Attribute, members?: any[]);
+    /** @internal */
+    _deactivatedMembers: any[];
+    constructor(attribute: Attribute, members?: any[], _deactivatedMembers?: any[], guid?: string);
     /**
      * gets the element's ID
      */
@@ -163,13 +170,35 @@ export declare class MembersFilter extends AbstractFilter {
      */
     filterJaql(): any;
 }
+/**
+ * @internal
+ */
+export declare class CascadingFilter extends AbstractFilter {
+    readonly filters: Filter[];
+    constructor(filters: Filter[], guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql(): any;
+    jaql(nested?: boolean): any;
+}
 /**
  * @internal
  */
 export declare class ExcludeFilter extends AbstractFilter {
     readonly filter: Filter;
     readonly input?: Filter;
-    constructor(filter: Filter, input?: Filter);
+    constructor(filter: Filter, input?: Filter, guid?: string);
     /**
      * gets the element's ID
      */
@@ -191,7 +220,7 @@ export declare class DoubleOperatorFilter<Type> extends AbstractFilter {
     operatorB?: string;
     valueA?: Type;
     valueB?: Type;
-    constructor(att: Attribute, filterType: string, operatorA?: string, valueA?: Type, operatorB?: string, valueB?: Type);
+    constructor(att: Attribute, filterType: string, operatorA?: string, valueA?: Type, operatorB?: string, valueB?: Type, guid?: string);
     /**
      * gets the element's ID
      */
@@ -210,7 +239,7 @@ export declare class DoubleOperatorFilter<Type> extends AbstractFilter {
  */
 export declare class MeasureFilter extends DoubleOperatorFilter<number> {
     measure: Measure;
-    constructor(att: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number);
+    constructor(att: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, guid?: string);
     /**
      * gets the element's ID
      */
@@ -228,7 +257,7 @@ export declare class RankingFilter extends AbstractFilter {
     count: number;
     operator: string;
     measure: Measure;
-    constructor(att: Attribute, measure: Measure, operator: string, count: number);
+    constructor(att: Attribute, measure: Measure, operator: string, count: number, guid?: string);
     /**
      * gets the element's ID
      */
@@ -246,19 +275,19 @@ export declare class RankingFilter extends AbstractFilter {
  * @internal
  */
 export declare class NumericFilter extends DoubleOperatorFilter<number> {
-    constructor(att: Attribute, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number);
+    constructor(att: Attribute, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, guid?: string);
 }
 /**
  * @internal
  */
 export declare class TextFilter extends DoubleOperatorFilter<string> {
-    constructor(att: Attribute, operator: string, value: string);
+    constructor(att: Attribute, operator: string, value: string, guid?: string);
 }
 /**
  * @internal
  */
 export declare class DateRangeFilter extends DoubleOperatorFilter<Date | string> {
-    constructor(l: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string);
+    constructor(l: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string, guid?: string);
     get level(): LevelAttribute;
     get from(): string;
     get to(): string;
@@ -275,7 +304,7 @@ export declare class RelativeDateFilter extends AbstractFilter {
     readonly count: number;
     readonly operator: string;
     readonly anchor?: Date | string;
-    constructor(l: LevelAttribute, offset: number, count: number, operator?: string, anchor?: Date | string);
+    constructor(l: LevelAttribute, offset: number, count: number, operator?: string, anchor?: Date | string, guid?: string);
     get level(): LevelAttribute;
     /**
      * gets the element's ID
@@ -292,7 +321,23 @@ export declare class RelativeDateFilter extends AbstractFilter {
     filterJaql(): any;
 }
 /**
- * @param json
+ * @internal
+ */
+export declare class CustomFilter extends AbstractFilter {
+    readonly jaqlExpression: any;
+    constructor(att: Attribute, jaql: any, guid?: string);
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql(): any;
+}
+/**
+ * @param json - Filter JSON representation
  * @internal
  */
 export declare function createFilter(json: any): Filter;

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

@@ -85,6 +85,8 @@ export const FilterTypes = {
     numeric: 'numeric',
     date: 'date',
     relativeDate: 'relativeDate',
+    cascading: 'cascading',
+    advanced: 'advanced',
 };
 // CLASSES
 /**
@@ -93,14 +95,25 @@ export const FilterTypes = {
  * @internal
  */
 class AbstractFilter extends DimensionalElement {
-    constructor(att, filterType) {
+    constructor(att, filterType, guid) {
         super('filter', MetadataTypes.Filter);
         this.filterType = filterType;
         AbstractFilter.checkAttributeSupport(att);
         this.attribute = att;
-        this.guid = guidFast(13);
+        this.guid = guid || guidFast(13);
         this.disabled = false;
     }
+    /**
+     * Boolean flag whether the filter is disabled
+     *
+     * @internal
+     */
+    get disabled() {
+        return this._disabled;
+    }
+    set disabled(value) {
+        this._disabled = value;
+    }
     get name() {
         return hash(this.jaql());
     }
@@ -119,9 +132,8 @@ class AbstractFilter extends DimensionalElement {
      * @param nested - defines whether the JAQL is nested within parent JAQL statement or a root JAQL element
      */
     jaql(nested) {
-        // if the filter is disabled, return empty filter JAQL
         if (this.disabled) {
-            return nested ? { filter: {} } : { jaql: { filter: {} } };
+            return AbstractFilter.disabledJaql(nested);
         }
         const result = this.attribute.jaql(false);
         const level = this.attribute;
@@ -147,13 +159,16 @@ class AbstractFilter extends DimensionalElement {
             throw new TranslatableError('errors.filter.unsupportedDatetimeLevel');
         }
     }
+    static disabledJaql(nested) {
+        return nested ? { filter: {} } : { jaql: { filter: {} } };
+    }
 }
 /**
  * @internal
  */
 export class LogicalAttributeFilter extends AbstractFilter {
-    constructor(filters, operator) {
-        super(filters[0].attribute, FilterTypes.logicalAttribute);
+    constructor(filters, operator, guid) {
+        super(filters[0].attribute, FilterTypes.logicalAttribute, guid);
         this.operator = operator;
         this.filters = filters;
     }
@@ -185,9 +200,10 @@ export class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export class MembersFilter extends AbstractFilter {
-    constructor(attribute, members) {
-        super(attribute, FilterTypes.members);
+    constructor(attribute, members, _deactivatedMembers, guid) {
+        super(attribute, FilterTypes.members, guid);
         this.members = members !== null && members !== void 0 ? members : [];
+        this._deactivatedMembers = _deactivatedMembers !== null && _deactivatedMembers !== void 0 ? _deactivatedMembers : [];
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
             throw new TranslatableError('errors.filter.membersFilterNullMember', {
                 attributeId: attribute.id,
@@ -217,12 +233,63 @@ export class MembersFilter extends AbstractFilter {
         };
     }
 }
+/**
+ * @internal
+ */
+export class CascadingFilter extends AbstractFilter {
+    constructor(filters, guid) {
+        super(filters[0].attribute, FilterTypes.cascading, guid);
+        this.filters = filters;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.filterType}_${this.filters.map((f) => f.id).join()}`;
+    }
+    get disabled() {
+        return super.disabled;
+    }
+    set disabled(value) {
+        super.disabled = value;
+        if (this.filters) {
+            this.filters.forEach((filter) => {
+                filter.disabled = value;
+            });
+        }
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.filters = this.filters.map((f) => f.serializable());
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        // return empty object as jaql is handled by jaql() method
+        return {};
+    }
+    jaql(nested) {
+        if (this.disabled) {
+            return AbstractFilter.disabledJaql(nested);
+        }
+        // return jaql of all level filters treated as scope filters
+        return this.filters.map((f) => {
+            f.isScope = true;
+            return f.jaql(nested);
+        });
+    }
+}
 /**
  * @internal
  */
 export class ExcludeFilter extends AbstractFilter {
-    constructor(filter, input) {
-        super(filter.attribute, FilterTypes.exclude);
+    constructor(filter, input, guid) {
+        super(filter.attribute, FilterTypes.exclude, guid);
         this.input = input;
         this.filter = filter;
     }
@@ -267,8 +334,8 @@ export class ExcludeFilter extends AbstractFilter {
  * @internal
  */
 export class DoubleOperatorFilter extends AbstractFilter {
-    constructor(att, filterType, operatorA, valueA, operatorB, valueB) {
-        super(att, filterType);
+    constructor(att, filterType, operatorA, valueA, operatorB, valueB, guid) {
+        super(att, filterType, guid);
         if (operatorA && valueA !== undefined) {
             this.valueA = valueA;
             this.operatorA = operatorA;
@@ -328,8 +395,8 @@ export class DoubleOperatorFilter extends AbstractFilter {
  * @internal
  */
 export class MeasureFilter extends DoubleOperatorFilter {
-    constructor(att, measure, operatorA, valueA, operatorB, valueB) {
-        super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB);
+    constructor(att, measure, operatorA, valueA, operatorB, valueB, guid) {
+        super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB, guid);
         this.measure = measure;
     }
     /**
@@ -354,9 +421,8 @@ export class MeasureFilter extends DoubleOperatorFilter {
         return result;
     }
     jaql(nested) {
-        // if the filter is disabled, return empty filter JAQL
         if (this.disabled) {
-            return nested ? { filter: {} } : { jaql: { filter: {} } };
+            return AbstractFilter.disabledJaql(nested);
         }
         const result = super.jaql(nested);
         if (this.measure instanceof DimensionalBaseMeasure) {
@@ -371,8 +437,8 @@ export class MeasureFilter extends DoubleOperatorFilter {
  * @internal
  */
 export class RankingFilter extends AbstractFilter {
-    constructor(att, measure, operator, count) {
-        super(att, FilterTypes.ranking);
+    constructor(att, measure, operator, count, guid) {
+        super(att, FilterTypes.ranking, guid);
         this.count = count;
         this.operator = operator;
         this.measure = measure;
@@ -407,24 +473,24 @@ export class RankingFilter extends AbstractFilter {
  * @internal
  */
 export class NumericFilter extends DoubleOperatorFilter {
-    constructor(att, operatorA, valueA, operatorB, valueB) {
-        super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB);
+    constructor(att, operatorA, valueA, operatorB, valueB, guid) {
+        super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB, guid);
     }
 }
 /**
  * @internal
  */
 export class TextFilter extends DoubleOperatorFilter {
-    constructor(att, operator, value) {
-        super(att, FilterTypes.text, operator, value);
+    constructor(att, operator, value, guid) {
+        super(att, FilterTypes.text, operator, value, undefined, undefined, guid);
     }
 }
 /**
  * @internal
  */
 export class DateRangeFilter extends DoubleOperatorFilter {
-    constructor(l, valueFrom, valueTo) {
-        super(l, FilterTypes.date, DateOperators.From, valueFrom, DateOperators.To, valueTo);
+    constructor(l, valueFrom, valueTo, guid) {
+        super(l, FilterTypes.date, DateOperators.From, valueFrom, DateOperators.To, valueTo, guid);
         if (typeof valueFrom === 'object') {
             this.valueA = valueFrom.toISOString();
         }
@@ -452,8 +518,8 @@ export class DateRangeFilter extends DoubleOperatorFilter {
  * @internal
  */
 export class RelativeDateFilter extends AbstractFilter {
-    constructor(l, offset, count, operator, anchor) {
-        super(l, FilterTypes.relativeDate);
+    constructor(l, offset, count, operator, anchor, guid) {
+        super(l, FilterTypes.relativeDate, guid);
         if (!operator) {
             operator = DateOperators.Next;
         }
@@ -515,7 +581,31 @@ export class RelativeDateFilter extends AbstractFilter {
     }
 }
 /**
- * @param json
+ * @internal
+ */
+export class CustomFilter extends AbstractFilter {
+    constructor(att, jaql, guid) {
+        super(att, FilterTypes.advanced, guid);
+        // remove filterType from jaql as it is not needed
+        delete jaql.filterType;
+        this.jaqlExpression = jaql;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `custom_${this.attribute.id}_${this.guid}`;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql() {
+        return this.jaqlExpression;
+    }
+}
+/**
+ * @param json - Filter JSON representation
  * @internal
  */
 export function createFilter(json) {

package/dist/dimensional-model/filters/utils/condition-filter-util.d.ts

@@ -6,14 +6,16 @@ export declare const getSelectedConditionOption: (filter: ConditionFilterJaql) =
  *
  * @param attribute - Provided attribute
  * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
  * @returns attribute filter
  */
-export declare const createAttributeFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql) => Filter;
+export declare const createAttributeFilterFromConditionFilterJaql: (attribute: Attribute, conditionFilterJaql: ConditionFilterJaql, guid?: string) => Filter;
 /**
  * Creates a measure filter from the provided measure and condition filter JAQL object
  *
  * @param measure - Provided measure
  * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
  * @returns measure filter
  */
-export declare const createMeasureFilterFromConditionFilterJaql: (measure: BaseMeasure, conditionFilterJaql: ConditionFilterJaql) => Filter;
+export declare const createMeasureFilterFromConditionFilterJaql: (measure: BaseMeasure, conditionFilterJaql: ConditionFilterJaql, guid?: string) => Filter;

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

@@ -77,56 +77,59 @@ export const getSelectedConditionOption = (filter) => {
  *
  * @param attribute - Provided attribute
  * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
  * @returns attribute filter
  */
-export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql) => {
-    var _a, _b;
+export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
+    var _a, _b, _c;
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.BOTTOM:
             if (conditionFilterJaql.by && 'agg' in conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.BOTTOM]);
+                return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.BOTTOM], guid);
             }
             break;
         case ConditionFilterType.EQUALS:
-            return withComposeCode(filterFactory.equals)(attribute, conditionFilterJaql[ConditionFilterType.EQUALS]);
+            return withComposeCode(filterFactory.equals)(attribute, conditionFilterJaql[ConditionFilterType.EQUALS], guid);
         case ConditionFilterType.GREATER_THAN:
-            return withComposeCode(filterFactory.greaterThan)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN]);
+            return withComposeCode(filterFactory.greaterThan)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN], guid);
         case ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL]);
+            return withComposeCode(filterFactory.greaterThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
         case ConditionFilterType.TOP:
             if (conditionFilterJaql.by) {
-                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.TOP]);
+                return withComposeCode(filterFactory.topRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.TOP], guid);
             }
             break;
         case ConditionFilterType.STARTS_WITH:
-            return withComposeCode(filterFactory.startsWith)(attribute, conditionFilterJaql[ConditionFilterType.STARTS_WITH]);
+            return withComposeCode(filterFactory.startsWith)(attribute, conditionFilterJaql[ConditionFilterType.STARTS_WITH], guid);
         case ConditionFilterType.DOESNT_START_WITH:
-            return withComposeCode(filterFactory.doesntStartWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_START_WITH]);
+            return withComposeCode(filterFactory.doesntStartWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_START_WITH], guid);
         case ConditionFilterType.ENDS_WITH:
-            return withComposeCode(filterFactory.endsWith)(attribute, conditionFilterJaql[ConditionFilterType.ENDS_WITH]);
+            return withComposeCode(filterFactory.endsWith)(attribute, conditionFilterJaql[ConditionFilterType.ENDS_WITH], guid);
         case ConditionFilterType.DOESNT_END_WITH:
-            return withComposeCode(filterFactory.doesntEndWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_END_WITH]);
+            return withComposeCode(filterFactory.doesntEndWith)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_END_WITH], guid);
         case ConditionFilterType.CONTAINS:
-            return withComposeCode(filterFactory.contains)(attribute, conditionFilterJaql[ConditionFilterType.CONTAINS]);
+            return withComposeCode(filterFactory.contains)(attribute, conditionFilterJaql[ConditionFilterType.CONTAINS], guid);
         case ConditionFilterType.DOESNT_CONTAIN:
-            return withComposeCode(filterFactory.doesntContain)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_CONTAIN]);
+            return withComposeCode(filterFactory.doesntContain)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_CONTAIN], guid);
         case ConditionFilterType.LESS_THAN:
-            return withComposeCode(filterFactory.lessThan)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN]);
+            return withComposeCode(filterFactory.lessThan)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN], guid);
         case ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.lessThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL]);
+            return withComposeCode(filterFactory.lessThanOrEqual)(attribute, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], guid);
         case ConditionFilterType.BETWEEN:
-            return withComposeCode(filterFactory.between)(attribute, conditionFilterJaql.from, conditionFilterJaql.to);
+            return withComposeCode(filterFactory.between)(attribute, conditionFilterJaql.from, conditionFilterJaql.to, guid);
         case ConditionFilterType.IS_NOT_BETWEEN:
-            return withComposeCode(filterFactory.exclude)(withComposeCode(filterFactory.between)(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to));
+            return withComposeCode(filterFactory.exclude)(withComposeCode(filterFactory.between)(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, guid), undefined, guid);
         case ConditionFilterType.MULTIPLE_CONDITION:
             if (conditionFilterJaql.and) {
-                return withComposeCode(filterFactory.intersection)(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c)));
+                return withComposeCode(filterFactory.intersection)(conditionFilterJaql.and.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
             }
             if (conditionFilterJaql.or) {
-                return withComposeCode(filterFactory.union)(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c)));
+                return withComposeCode(filterFactory.union)(conditionFilterJaql.or.map((c) => createAttributeFilterFromConditionFilterJaql(attribute, c, guid)), guid);
             }
             break;
+        case ConditionFilterType.IS_NOT:
+            return withComposeCode(filterFactory.exclude)(withComposeCode(filterFactory.members)(attribute, ((_c = conditionFilterJaql.exclude) === null || _c === void 0 ? void 0 : _c.members) || [], undefined, guid), undefined, guid);
         case ConditionFilterType.AFTER:
         case ConditionFilterType.BEFORE:
         case ConditionFilterType.IS_EMPTY:
@@ -141,23 +144,24 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
  *
  * @param measure - Provided measure
  * @param conditionFilterJaql - Condition filter JAQL object
+ * @param guid - Optional GUID for the filter
  * @returns measure filter
  */
-export const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql) => {
+export const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql, guid) => {
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.EQUALS:
-            return withComposeCode(filterFactory.measureEquals)(measure, conditionFilterJaql[ConditionFilterType.EQUALS]);
+            return withComposeCode(filterFactory.measureEquals)(measure, conditionFilterJaql[ConditionFilterType.EQUALS], guid);
         case ConditionFilterType.GREATER_THAN:
-            return withComposeCode(filterFactory.measureGreaterThan)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN]);
+            return withComposeCode(filterFactory.measureGreaterThan)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN], guid);
         case ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.measureGreaterThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL]);
+            return withComposeCode(filterFactory.measureGreaterThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.GREATER_THAN_OR_EQUAL], guid);
         case ConditionFilterType.LESS_THAN:
-            return withComposeCode(filterFactory.measureLessThan)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN]);
+            return withComposeCode(filterFactory.measureLessThan)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN], guid);
         case ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return withComposeCode(filterFactory.measureLessThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL]);
+            return withComposeCode(filterFactory.measureLessThanOrEqual)(measure, conditionFilterJaql[ConditionFilterType.LESS_THAN_OR_EQUAL], guid);
         case ConditionFilterType.BETWEEN:
-            return withComposeCode(filterFactory.measureBetween)(measure, conditionFilterJaql.from, conditionFilterJaql.to);
+            return withComposeCode(filterFactory.measureBetween)(measure, conditionFilterJaql.from, conditionFilterJaql.to, guid);
     }
     throw 'Jaql contains unsupported condition filter: ' + JSON.stringify(conditionFilterJaql);
 };

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

@@ -40,7 +40,11 @@ export function stringifyHelper(arg) {
  */
 export function withComposeCode(func) {
     return function (...args) {
-        const argValues = args.map(stringifyHelper).join(', ');
+        const argValues = args
+            .map(stringifyHelper)
+            .join(', ')
+            // remove any number of trailing commas
+            .replace(/(,\s*)+$/, '');
         const signature = `filterFactory.${func.name}(${argValues})`;
         const filter = func(...args);
         filter.composeCode = signature;