@sisense/sdk-data 1.11.0 → 1.12.0

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

@@ -73,6 +73,7 @@ export declare const FilterTypes: {
     numeric: string;
     date: string;
     relativeDate: string;
+    cascading: string;
 };
 /**
  * base implementation for filter classes
@@ -98,7 +99,7 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      * @internal
      */
     disabled: boolean;
-    constructor(att: Attribute, filterType: string);
+    constructor(att: Attribute, filterType: string, guid?: string);
     get name(): string;
     /**
      * Gets JAQL representing this Filter instance
@@ -123,6 +124,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 +132,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 +151,7 @@ export declare class LogicalAttributeFilter extends AbstractFilter {
  */
 export declare class MembersFilter extends AbstractFilter {
     readonly members: any[];
-    constructor(attribute: Attribute, members?: any[]);
+    constructor(attribute: Attribute, members?: any[], guid?: string);
     /**
      * gets the element's ID
      */
@@ -163,13 +165,33 @@ 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;
+    /**
+     * 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 +213,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 +232,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 +250,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 +268,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 +297,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 +314,7 @@ export declare class RelativeDateFilter extends AbstractFilter {
     filterJaql(): any;
 }
 /**
- * @param json
+ * @param json - Filter JSON representation
  * @internal
  */
 export declare function createFilter(json: any): Filter;

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

@@ -85,6 +85,7 @@ export const FilterTypes = {
     numeric: 'numeric',
     date: 'date',
     relativeDate: 'relativeDate',
+    cascading: 'cascading',
 };
 // CLASSES
 /**
@@ -93,12 +94,12 @@ 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;
     }
     get name() {
@@ -119,9 +120,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 +147,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,8 +188,8 @@ export class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export class MembersFilter extends AbstractFilter {
-    constructor(attribute, members) {
-        super(attribute, FilterTypes.members);
+    constructor(attribute, members, guid) {
+        super(attribute, FilterTypes.members, guid);
         this.members = members !== null && members !== void 0 ? members : [];
         if (this.members.filter((m) => m === null || m === undefined).length > 0) {
             throw new TranslatableError('errors.filter.membersFilterNullMember', {
@@ -217,12 +220,52 @@ 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()}`;
+    }
+    /**
+     * 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 +310,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 +371,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 +397,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 +413,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 +449,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 +494,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 +557,7 @@ export class RelativeDateFilter extends AbstractFilter {
     }
 }
 /**
- * @param json
+ * @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,54 +77,55 @@ 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) => {
+export const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilterJaql, guid) => {
     var _a, _b;
     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));
         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.AFTER:
@@ -141,23 +142,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,7 @@ export function stringifyHelper(arg) {
  */
 export function withComposeCode(func) {
     return function (...args) {
-        const argValues = args.map(stringifyHelper).join(', ');
+        const argValues = args.map(stringifyHelper).join(', ').replace(/, $/, '');
         const signature = `filterFactory.${func.name}(${argValues})`;
         const filter = func(...args);
         filter.composeCode = signature;

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

@@ -5,63 +5,69 @@ 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 instanceid - The instance ID.
+ * @param guid - Optional GUID for the filter
  * @returns A generic Filter object.
  */
-export declare const createGenericFilter: (jaql: FilterJaql | FilterJaqlInternal, instanceid?: string) => Filter;
+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) => Filter;
+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) => Filter;
+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) => Filter;
+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) => Filter;
+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) => Filter;
+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) => Filter;
+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 instanceid - The instance ID.
+ * @param guid - Optional GUID for the filter
  * @returns Filter object.
  */
-export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, instanceid?: string) => Filter;
+export declare const createFilterFromJaqlInternal: (jaql: FilterJaqlInternal, guid?: string) => Filter;