@sisense/sdk-data 1.10.1 → 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
@@ -92,7 +93,13 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      * Global filter identifier
      */
     readonly guid: string;
-    constructor(att: Attribute, filterType: string);
+    /**
+     * Boolean flag whether the filter is disabled
+     *
+     * @internal
+     */
+    disabled: boolean;
+    constructor(att: Attribute, filterType: string, guid?: string);
     get name(): string;
     /**
      * Gets JAQL representing this Filter instance
@@ -117,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
@@ -124,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
      */
@@ -143,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
      */
@@ -157,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
      */
@@ -185,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
      */
@@ -204,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
      */
@@ -222,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
      */
@@ -240,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;
@@ -269,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
@@ -286,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

@@ -25,7 +25,7 @@ export const TextOperators = {
     DoesntEqual: 'doesntEqual',
     DoesntStartWith: 'doesntStartWith',
     DoesntContain: 'doesntContain',
-    DoesntEndWith: 'doesntEndWidth',
+    DoesntEndWith: 'doesntEndWith',
     Like: 'like',
 };
 /**
@@ -85,6 +85,7 @@ export const FilterTypes = {
     numeric: 'numeric',
     date: 'date',
     relativeDate: 'relativeDate',
+    cascading: 'cascading',
 };
 // CLASSES
 /**
@@ -93,12 +94,13 @@ 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() {
         return hash(this.jaql());
@@ -118,6 +120,9 @@ class AbstractFilter extends DimensionalElement {
      * @param nested - defines whether the JAQL is nested within parent JAQL statement or a root JAQL element
      */
     jaql(nested) {
+        if (this.disabled) {
+            return AbstractFilter.disabledJaql(nested);
+        }
         const result = this.attribute.jaql(false);
         const level = this.attribute;
         if (level.getFormat && level.getFormat() !== undefined) {
@@ -142,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;
     }
@@ -180,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', {
@@ -212,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;
     }
@@ -262,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;
@@ -323,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;
     }
     /**
@@ -349,6 +397,9 @@ export class MeasureFilter extends DoubleOperatorFilter {
         return result;
     }
     jaql(nested) {
+        if (this.disabled) {
+            return AbstractFilter.disabledJaql(nested);
+        }
         const result = super.jaql(nested);
         if (this.measure instanceof DimensionalBaseMeasure) {
             Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {
@@ -362,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;
@@ -398,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();
         }
@@ -443,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;
         }
@@ -506,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/attribute-measure-util.d.ts

@@ -11,7 +11,7 @@ import { FilterJaqlInternal, RankingFilterJaql } from './types.js';
  * @param dataType - Data type
  * @returns attribute or level attribute
  */
-export declare const createAttributeHelper: (dim: string, table: string, column: string, level: string | undefined, dataType: string) => Attribute | LevelAttribute;
+export declare const createAttributeHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string) => Attribute | LevelAttribute;
 /**
  * Creates an attribute or level attribute from the provided filter JAQL object
  *
@@ -30,7 +30,7 @@ export declare const createAttributeFromFilterJaql: (jaql: FilterJaql | FilterJa
  * @param agg - Aggregation function
  * @returns measure
  */
-export declare const createMeasureHelper: (dim: string, table: string, column: string, level: string | undefined, dataType: string, agg: string) => BaseMeasure;
+export declare const createMeasureHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, agg: string) => BaseMeasure;
 /**
  * Creates a measure from the provided filter JAQL object
  *

package/dist/dimensional-model/filters/utils/attribute-measure-util.js

@@ -14,17 +14,20 @@ const DATA_MODEL_MODULE_NAME = 'DM';
  * @returns attribute or level attribute
  */
 export const createAttributeHelper = (dim, table, column, level, dataType) => {
+    // if table is undefined, extract it from dim
+    const dimTable = table !== null && table !== void 0 ? table : dim.slice(1, -1).split('.')[0];
     if (level) {
         const dateLevel = DimensionalLevelAttribute.translateJaqlToGranularity({ level });
-        const levelAttribute = new DimensionalLevelAttribute(column, dim, dateLevel);
-        levelAttribute.composeCode = normalizeAttributeName(table, column, level, DATA_MODEL_MODULE_NAME);
+        const format = DimensionalLevelAttribute.getDefaultFormatForGranularity(dateLevel);
+        const levelAttribute = new DimensionalLevelAttribute(column, dim, dateLevel, format);
+        levelAttribute.composeCode = normalizeAttributeName(dimTable, column, level, DATA_MODEL_MODULE_NAME);
         return levelAttribute;
     }
     const attributeType = isNumber(dataType)
         ? MetadataTypes.NumericAttribute
         : MetadataTypes.TextAttribute;
     const attribute = new DimensionalAttribute(column, dim, attributeType);
-    attribute.composeCode = normalizeAttributeName(table, column, undefined, DATA_MODEL_MODULE_NAME);
+    attribute.composeCode = normalizeAttributeName(dimTable, column, undefined, DATA_MODEL_MODULE_NAME);
     return attribute;
 };
 /**

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

@@ -35,12 +35,8 @@ export const getSelectedConditionOption = (filter) => {
         return ConditionFilterType.IS_WITHIN;
     if (isGreaterThanCondition(filter))
         return ConditionFilterType.GREATER_THAN;
-    if (isGreaterThanOrEqualCondition(filter))
-        return ConditionFilterType.GREATER_THAN_OR_EQUAL;
     if (isLessThanCondition(filter))
         return ConditionFilterType.LESS_THAN;
-    if (isLessThanOrEqualCondition(filter))
-        return ConditionFilterType.LESS_THAN_OR_EQUAL;
     if (isEqualsCondition(filter))
         return ConditionFilterType.EQUALS;
     if (isNotEqualCondition(filter))
@@ -61,14 +57,19 @@ export const getSelectedConditionOption = (filter) => {
         return ConditionFilterType.ENDS_WITH;
     if (isStartsWithCondition(filter))
         return ConditionFilterType.STARTS_WITH;
-    if (isBetweenCondition(filter))
-        return ConditionFilterType.BETWEEN;
     if (isNotBetweenCondition(filter))
         return ConditionFilterType.IS_NOT_BETWEEN;
     if (isMembersCondition(filter))
         return ConditionFilterType.IS;
     if (isMultipleCondition(filter))
         return ConditionFilterType.MULTIPLE_CONDITION;
+    // Need to verify BETWEEN case before the GREATER_THAN_OR_EQUAL and LESS_THAN_OR_EQUAL due to missing `filter.isBetween` property in some cases
+    if (isBetweenCondition(filter))
+        return ConditionFilterType.BETWEEN;
+    if (isGreaterThanOrEqualCondition(filter))
+        return ConditionFilterType.GREATER_THAN_OR_EQUAL;
+    if (isLessThanOrEqualCondition(filter))
+        return ConditionFilterType.LESS_THAN_OR_EQUAL;
     return ConditionFilterType.NONE;
 };
 /**
@@ -76,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:
@@ -140,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;