@sisense/sdk-data 1.11.0 → 1.13.0

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

@@ -0,0 +1,663 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFilter = exports.CustomFilter = exports.RelativeDateFilter = exports.DateRangeFilter = exports.TextFilter = exports.NumericFilter = exports.RankingFilter = exports.MeasureFilter = exports.DoubleOperatorFilter = exports.ExcludeFilter = exports.CascadingFilter = exports.MembersFilter = exports.LogicalAttributeFilter = exports.FilterTypes = exports.RankingOperators = exports.LogicalOperators = exports.DateOperators = exports.NumericOperators = exports.TextOperators = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable max-params */
+/* eslint-disable @typescript-eslint/restrict-template-expressions */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+const object_hash_1 = __importDefault(require("object-hash"));
+const base_js_1 = require("../base.js");
+const types_js_1 = require("../types.js");
+const factory_js_1 = require("../factory.js");
+const measures_js_1 = require("../measures/measures.js");
+const translatable_error_js_1 = require("../../translation/translatable-error.js");
+const utils_js_1 = require("../../utils.js");
+/**
+ * Different text operators that can be used with text filters
+ *
+ * @internal
+ */
+exports.TextOperators = {
+    Contains: 'contains',
+    StartsWith: 'startsWith',
+    EndsWith: 'endsWith',
+    Equals: 'equals',
+    DoesntEqual: 'doesntEqual',
+    DoesntStartWith: 'doesntStartWith',
+    DoesntContain: 'doesntContain',
+    DoesntEndWith: 'doesntEndWith',
+    Like: 'like',
+};
+/**
+ * Different numeric operators that can be used with numeric filters
+ */
+exports.NumericOperators = {
+    Equals: 'equals',
+    DoesntEqual: 'doesntEqual',
+    From: 'from',
+    FromNotEqual: 'fromNotEqual',
+    To: 'to',
+    ToNotEqual: 'toNotEqual',
+};
+/**
+ * Different date operators that can be used with date filters
+ *
+ * @internal
+ */
+exports.DateOperators = {
+    From: 'from',
+    To: 'to',
+    Last: 'last',
+    Next: 'next',
+    Anchor: 'Anchor',
+};
+/**
+ * Different logical operators that can be used with logical filters
+ *
+ * @internal
+ */
+exports.LogicalOperators = {
+    Union: 'or',
+    Intersection: 'and',
+    Exclude: 'exclude',
+};
+/**
+ * Different ranking operators that can be used with ranking filter
+ *
+ * @internal
+ */
+exports.RankingOperators = {
+    Top: 'top',
+    Bottom: 'bottom',
+};
+/**
+ * Different filter types
+ *
+ * @internal
+ */
+exports.FilterTypes = {
+    logicalAttribute: 'logicalAttribute',
+    members: 'members',
+    exclude: 'exclude',
+    measure: 'measure',
+    ranking: 'ranking',
+    text: 'text',
+    numeric: 'numeric',
+    date: 'date',
+    relativeDate: 'relativeDate',
+    cascading: 'cascading',
+    advanced: 'advanced',
+};
+// CLASSES
+/**
+ * base implementation for filter classes
+ *
+ * @internal
+ */
+class AbstractFilter extends base_js_1.DimensionalElement {
+    constructor(att, filterType, guid) {
+        super('filter', types_js_1.MetadataTypes.Filter);
+        this.filterType = filterType;
+        AbstractFilter.checkAttributeSupport(att);
+        this.attribute = att;
+        this.guid = guid || (0, utils_js_1.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 (0, object_hash_1.default)(this.jaql());
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.filterType = this.filterType;
+        result.attribute = this.attribute.serializable();
+        return result;
+    }
+    /**
+     * Gets the JAQL representation of this instance
+     *
+     * @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) {
+            const granularityJaql = level.translateGranularityToJaql();
+            result.format = {
+                mask: {
+                    [granularityJaql.level]: level.getFormat(),
+                },
+            };
+        }
+        result.jaql.filter = this.filterJaql();
+        if (this.isScope) {
+            result.panel = 'scope';
+        }
+        return nested === true ? result.jaql : result;
+    }
+    static checkAttributeSupport(attribute) {
+        const { granularity } = attribute;
+        if (granularity === types_js_1.DateLevels.Hours ||
+            granularity === types_js_1.DateLevels.MinutesRoundTo30 ||
+            granularity === types_js_1.DateLevels.MinutesRoundTo15) {
+            throw new translatable_error_js_1.TranslatableError('errors.filter.unsupportedDatetimeLevel');
+        }
+    }
+    static disabledJaql(nested) {
+        return nested ? { filter: {} } : { jaql: { filter: {} } };
+    }
+}
+/**
+ * @internal
+ */
+class LogicalAttributeFilter extends AbstractFilter {
+    constructor(filters, operator, guid) {
+        super(filters[0].attribute, exports.FilterTypes.logicalAttribute, guid);
+        this.operator = operator;
+        this.filters = filters;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.operator}_${this.filters.map((f) => f.id).join()}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.operator = this.operator;
+        result.filters = this.filters.map((f) => f.serializable());
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        result[this.operator] = this.filters.map((f) => f.filterJaql());
+        return result;
+    }
+}
+exports.LogicalAttributeFilter = LogicalAttributeFilter;
+/**
+ * @internal
+ */
+class MembersFilter extends AbstractFilter {
+    constructor(attribute, members, _deactivatedMembers, guid) {
+        super(attribute, exports.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 translatable_error_js_1.TranslatableError('errors.filter.membersFilterNullMember', {
+                attributeId: attribute.id,
+            });
+        }
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.attribute.id}_${this.members.map((m) => m.toString()).join()}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.members = this.members;
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        return {
+            members: this.members.map((m) => m.toString()),
+        };
+    }
+}
+exports.MembersFilter = MembersFilter;
+/**
+ * @internal
+ */
+class CascadingFilter extends AbstractFilter {
+    constructor(filters, guid) {
+        super(filters[0].attribute, exports.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);
+        });
+    }
+}
+exports.CascadingFilter = CascadingFilter;
+/**
+ * @internal
+ */
+class ExcludeFilter extends AbstractFilter {
+    constructor(filter, input, guid) {
+        super(filter.attribute, exports.FilterTypes.exclude, guid);
+        this.input = input;
+        this.filter = filter;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `exclude_${this.filter.id}`;
+        if (this.input) {
+            result += '_from_' + this.input.id;
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.filter = this.filter.serializable();
+        if (this.input) {
+            result.input = this.input.serializable();
+        }
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        const exclusion = this.filter.filterJaql();
+        if (this.input) {
+            result.filter = this.input.filterJaql();
+            result.filter.filter = { exclude: exclusion };
+        }
+        else {
+            result.exclude = exclusion;
+        }
+        return result;
+    }
+}
+exports.ExcludeFilter = ExcludeFilter;
+/**
+ * @internal
+ */
+class DoubleOperatorFilter extends AbstractFilter {
+    constructor(att, filterType, operatorA, valueA, operatorB, valueB, guid) {
+        super(att, filterType, guid);
+        if (operatorA && valueA !== undefined) {
+            this.valueA = valueA;
+            this.operatorA = operatorA;
+        }
+        if (operatorB && valueB !== undefined) {
+            this.operatorB = operatorB;
+            this.valueB = valueB;
+        }
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `${this.attribute.id}`;
+        if (this.operatorA && this.valueA !== undefined) {
+            result += `_${this.operatorA}:${this.valueA}`;
+        }
+        if (this.operatorB && this.valueB !== undefined) {
+            result += `_${this.operatorB}:${this.valueB}`;
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        if (this.operatorA) {
+            result.operatorA = this.operatorA;
+        }
+        if (this.operatorB) {
+            result.operatorB = this.operatorB;
+        }
+        if (this.valueA !== undefined) {
+            result.valueA = this.valueA;
+        }
+        if (this.valueB !== undefined) {
+            result.valueB = this.valueB;
+        }
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        if (this.operatorA && this.valueA !== undefined) {
+            result[this.operatorA] = this.valueA;
+        }
+        if (this.operatorB && this.valueB !== undefined) {
+            result[this.operatorB] = this.valueB;
+        }
+        return result;
+    }
+}
+exports.DoubleOperatorFilter = DoubleOperatorFilter;
+/**
+ * @internal
+ */
+class MeasureFilter extends DoubleOperatorFilter {
+    constructor(att, measure, operatorA, valueA, operatorB, valueB, guid) {
+        super(att, exports.FilterTypes.measure, operatorA, valueA, operatorB, valueB, guid);
+        this.measure = measure;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `${this.attribute.id}_${this.measure.id}`;
+        if (this.operatorA && this.valueA !== undefined) {
+            result += `_${this.operatorA}:${this.valueA}`;
+        }
+        if (this.operatorB && this.valueB !== undefined) {
+            result += `_${this.operatorB}${this.valueB}`;
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.measure = this.measure.serializable();
+        return result;
+    }
+    jaql(nested) {
+        if (this.disabled) {
+            return AbstractFilter.disabledJaql(nested);
+        }
+        const result = super.jaql(nested);
+        if (this.measure instanceof measures_js_1.DimensionalBaseMeasure) {
+            Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {
+                result.jaql[key] = value;
+            });
+        }
+        return result;
+    }
+}
+exports.MeasureFilter = MeasureFilter;
+/**
+ * @internal
+ */
+class RankingFilter extends AbstractFilter {
+    constructor(att, measure, operator, count, guid) {
+        super(att, exports.FilterTypes.ranking, guid);
+        this.count = count;
+        this.operator = operator;
+        this.measure = measure;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.operator}_${this.count}_${this.attribute.id}_by_${this.measure.id}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.count = this.count;
+        result.operator = this.operator;
+        result.measure = this.measure.serializable();
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        const result = {};
+        result[this.operator] = this.count;
+        result.by = this.measure.jaql(true);
+        return result;
+    }
+}
+exports.RankingFilter = RankingFilter;
+/**
+ * @internal
+ */
+class NumericFilter extends DoubleOperatorFilter {
+    constructor(att, operatorA, valueA, operatorB, valueB, guid) {
+        super(att, exports.FilterTypes.numeric, operatorA, valueA, operatorB, valueB, guid);
+    }
+}
+exports.NumericFilter = NumericFilter;
+/**
+ * @internal
+ */
+class TextFilter extends DoubleOperatorFilter {
+    constructor(att, operator, value, guid) {
+        super(att, exports.FilterTypes.text, operator, value, undefined, undefined, guid);
+    }
+}
+exports.TextFilter = TextFilter;
+/**
+ * @internal
+ */
+class DateRangeFilter extends DoubleOperatorFilter {
+    constructor(l, valueFrom, valueTo, guid) {
+        super(l, exports.FilterTypes.date, exports.DateOperators.From, valueFrom, exports.DateOperators.To, valueTo, guid);
+        if (typeof valueFrom === 'object') {
+            this.valueA = valueFrom.toISOString();
+        }
+        if (typeof valueTo === 'object') {
+            this.valueB = valueTo.toISOString();
+        }
+    }
+    get level() {
+        return this.attribute;
+    }
+    get from() {
+        return this.valueA;
+    }
+    get to() {
+        return this.valueB;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     */
+    filterJaql() {
+        return super.filterJaql();
+    }
+}
+exports.DateRangeFilter = DateRangeFilter;
+/**
+ * @internal
+ */
+class RelativeDateFilter extends AbstractFilter {
+    constructor(l, offset, count, operator, anchor, guid) {
+        super(l, exports.FilterTypes.relativeDate, guid);
+        if (!operator) {
+            operator = exports.DateOperators.Next;
+        }
+        this.anchor = anchor;
+        this.operator = operator;
+        this.offset = offset;
+        this.count = count;
+    }
+    get level() {
+        return this.attribute;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        let result = `${this.level.id}_${this.operator}_${this.offset}_${this.count}`;
+        if (this.anchor) {
+            if (typeof this.anchor === 'string') {
+                result += `_${this.anchor}`;
+            }
+            else if (typeof this.anchor === 'object') {
+                result += `_${this.anchor.toISOString()}`;
+            }
+        }
+        return result;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.offset = this.offset;
+        result.count = this.count;
+        result.operator = this.operator;
+        if (this.anchor) {
+            result.anchor = this.anchor;
+        }
+        return result;
+    }
+    /**
+     * Gets JAQL representing this Filter instance
+     *
+     */
+    filterJaql() {
+        const result = {};
+        result[this.operator] = {
+            offset: this.offset,
+            count: this.count,
+        };
+        if (this.anchor) {
+            if (typeof this.anchor === 'string') {
+                result[this.operator].anchor = this.anchor;
+            }
+            else if (typeof this.anchor === 'object') {
+                result[this.operator].anchor = this.anchor.toISOString();
+            }
+        }
+        return result;
+    }
+}
+exports.RelativeDateFilter = RelativeDateFilter;
+/**
+ * @internal
+ */
+class CustomFilter extends AbstractFilter {
+    constructor(att, jaql, guid) {
+        super(att, exports.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;
+    }
+}
+exports.CustomFilter = CustomFilter;
+/**
+ * @param json - Filter JSON representation
+ * @internal
+ */
+function createFilter(json) {
+    switch (json.filterType) {
+        case exports.FilterTypes.logicalAttribute:
+            return new LogicalAttributeFilter(json.filters.map((f) => createFilter(f)), json.operator);
+            break;
+        case exports.FilterTypes.members:
+            return new MembersFilter((0, factory_js_1.create)(json.attribute), json.members);
+            break;
+        case exports.FilterTypes.exclude:
+            return new ExcludeFilter(createFilter(json.filter), json.input && createFilter(json.input));
+            break;
+        case exports.FilterTypes.measure:
+            return new MeasureFilter((0, factory_js_1.create)(json.attribute), (0, factory_js_1.create)(json.measure), json.operatorA, json.valueA, json.operatorB, json.valueB);
+            break;
+        case exports.FilterTypes.ranking:
+            return new RankingFilter((0, factory_js_1.create)(json.attribute), (0, factory_js_1.create)(json.measure), json.operator, json.count);
+            break;
+        case exports.FilterTypes.numeric:
+            return new NumericFilter((0, factory_js_1.create)(json.attribute), json.operatorA, json.valueA, json.operatorB, json.valueB);
+            break;
+        case exports.FilterTypes.text:
+            return new TextFilter((0, factory_js_1.create)(json.attribute), json.operatorA, json.valueA);
+            break;
+        case exports.FilterTypes.relativeDate:
+            return new RelativeDateFilter((0, factory_js_1.create)(json.attribute), json.offset, json.count, json.operator, json.anchor);
+            break;
+        case exports.FilterTypes.date:
+            return new DateRangeFilter((0, factory_js_1.create)(json.attribute), json.valueA, json.valueB);
+            break;
+    }
+    throw new translatable_error_js_1.TranslatableError('errors.filter.unsupportedType', {
+        filterType: json.filterType,
+    });
+}
+exports.createFilter = createFilter;

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

@@ -0,0 +1 @@
+export {};