@sisense/sdk-data 2.5.0 → 2.7.0

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

@@ -1,10 +1,11 @@
+/* eslint-disable max-lines */
 import hash from 'hash-it';
 import merge from 'lodash-es/merge.js';
 import omit from 'lodash-es/omit.js';
 import { TranslatableError } from '../../translation/translatable-error.js';
 import { DimensionalElement } from '../base.js';
 import { create } from '../factory.js';
-import { DimensionalBaseMeasure } from '../measures/measures.js';
+import { isDimensionalBaseMeasure } from '../measures/measures.js';
 import { DateLevels, MetadataTypes } from '../types.js';
 import { getDefaultBaseFilterConfig, getDefaultMembersFilterConfig, } from './filter-config-utils.js';
 /**
@@ -92,6 +93,10 @@ export const FilterTypes = {
 class AbstractFilter extends DimensionalElement {
     constructor(att, filterType, config, composeCode) {
         super('filter', MetadataTypes.Filter, undefined, undefined, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'AbstractFilter';
         this.filterType = filterType;
         // need to set isScope
         // to make filter complete for comparison
@@ -109,7 +114,6 @@ class AbstractFilter extends DimensionalElement {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'AbstractFilter';
         result.filterType = this.filterType;
         result.attribute = this.attribute.serialize();
         if (this.config) {
@@ -167,6 +171,10 @@ class AbstractFilter extends DimensionalElement {
 export class LogicalAttributeFilter extends AbstractFilter {
     constructor(filters, operator, config, composeCode) {
         super(filters[0].attribute, FilterTypes.logicalAttribute, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'LogicalAttributeFilter';
         this.operator = operator;
         this.filters = filters;
     }
@@ -181,7 +189,6 @@ export class LogicalAttributeFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'LogicalAttributeFilter';
         result.operator = this.operator;
         result.filters = this.filters.map((f) => f.serialize());
         return result;
@@ -201,6 +208,10 @@ export class LogicalAttributeFilter extends AbstractFilter {
 export class MembersFilter extends AbstractFilter {
     constructor(attribute, members, config, composeCode) {
         super(attribute, FilterTypes.members, undefined, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'MembersFilter';
         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', {
@@ -226,7 +237,6 @@ export class MembersFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'MembersFilter';
         if (this.config) {
             result.config = (this.config.backgroundFilter
                 ? Object.assign(Object.assign({}, this.config), { backgroundFilter: this.config.backgroundFilter.serialize() }) : this.config);
@@ -258,6 +268,10 @@ export class MembersFilter extends AbstractFilter {
 export class CascadingFilter extends AbstractFilter {
     constructor(filters, config, composeCode) {
         super(filters[0].attribute, FilterTypes.cascading, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'CascadingFilter';
         this._filters = filters;
     }
     /**
@@ -281,7 +295,6 @@ export class CascadingFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'CascadingFilter';
         result._filters = this.filters.map((f) => f.serialize());
         return result;
     }
@@ -309,6 +322,10 @@ export class CascadingFilter extends AbstractFilter {
 export class ExcludeFilter extends AbstractFilter {
     constructor(filter, input, config, composeCode) {
         super(filter.attribute, FilterTypes.exclude, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'ExcludeFilter';
         this.input = input;
         this.filter = filter;
     }
@@ -327,7 +344,6 @@ export class ExcludeFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'ExcludeFilter';
         result.filter = this.filter.serialize();
         if (this.input) {
             result.input = this.input.serialize();
@@ -356,6 +372,10 @@ export class ExcludeFilter extends AbstractFilter {
 export class DoubleOperatorFilter extends AbstractFilter {
     constructor(att, filterType, operatorA, valueA, operatorB, valueB, config, composeCode) {
         super(att, filterType, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'DoubleOperatorFilter';
         if (operatorA && valueA !== undefined) {
             this.valueA = valueA;
             this.operatorA = operatorA;
@@ -383,7 +403,6 @@ export class DoubleOperatorFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'DoubleOperatorFilter';
         if (this.operatorA) {
             result.operatorA = this.operatorA;
         }
@@ -418,6 +437,10 @@ export class DoubleOperatorFilter extends AbstractFilter {
 export class MeasureFilter extends DoubleOperatorFilter {
     constructor(att, measure, operatorA, valueA, operatorB, valueB, config, composeCode) {
         super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'MeasureFilter';
         this.measure = measure;
     }
     /**
@@ -438,7 +461,6 @@ export class MeasureFilter extends DoubleOperatorFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'MeasureFilter';
         result.measure = this.measure.serialize();
         return result;
     }
@@ -447,7 +469,7 @@ export class MeasureFilter extends DoubleOperatorFilter {
             return AbstractFilter.disabledJaql(nested);
         }
         const result = super.jaql(nested);
-        if (this.measure instanceof DimensionalBaseMeasure) {
+        if (isDimensionalBaseMeasure(this.measure)) {
             Object.entries(this.measure.jaql().jaql).forEach(([key, value]) => {
                 result.jaql[key] = value;
             });
@@ -461,6 +483,10 @@ export class MeasureFilter extends DoubleOperatorFilter {
 export class RankingFilter extends AbstractFilter {
     constructor(att, measure, operator, count, config, composeCode) {
         super(att, FilterTypes.ranking, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'RankingFilter';
         this.count = count;
         this.operator = operator;
         this.measure = measure;
@@ -476,7 +502,6 @@ export class RankingFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'RankingFilter';
         result.count = this.count;
         result.operator = this.operator;
         result.measure = this.measure.serialize();
@@ -498,14 +523,16 @@ export class RankingFilter extends AbstractFilter {
 export class NumericFilter extends DoubleOperatorFilter {
     constructor(att, operatorA, valueA, operatorB, valueB, config, composeCode) {
         super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'NumericFilter';
     }
     /**
      * Gets a serializable representation of the element
      */
     serialize() {
-        const result = super.serialize();
-        result.__serializable = 'NumericFilter';
-        return result;
+        return super.serialize();
     }
 }
 /**
@@ -514,14 +541,16 @@ export class NumericFilter extends DoubleOperatorFilter {
 export class TextFilter extends DoubleOperatorFilter {
     constructor(att, operator, value, config, composeCode) {
         super(att, FilterTypes.text, operator, value, undefined, undefined, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'TextFilter';
     }
     /**
      * Gets a serializable representation of the element
      */
     serialize() {
-        const result = super.serialize();
-        result.__serializable = 'TextFilter';
-        return result;
+        return super.serialize();
     }
 }
 /**
@@ -530,6 +559,10 @@ export class TextFilter extends DoubleOperatorFilter {
 export class DateRangeFilter extends DoubleOperatorFilter {
     constructor(levelAttribute, valueFrom, valueTo, config, composeCode) {
         super(levelAttribute, FilterTypes.dateRange, DateOperators.From, valueFrom, DateOperators.To, valueTo, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'DateRangeFilter';
         if (typeof valueFrom === 'object') {
             this.valueA = valueFrom.toISOString();
         }
@@ -556,9 +589,7 @@ export class DateRangeFilter extends DoubleOperatorFilter {
      * Gets a serializable representation of the element
      */
     serialize() {
-        const result = super.serialize();
-        result.__serializable = 'DateRangeFilter';
-        return result;
+        return super.serialize();
     }
 }
 /**
@@ -567,6 +598,10 @@ export class DateRangeFilter extends DoubleOperatorFilter {
 export class RelativeDateFilter extends AbstractFilter {
     constructor(levelAttribute, offset, count, operator, anchor, config, composeCode) {
         super(levelAttribute, FilterTypes.relativeDate, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'RelativeDateFilter';
         if (!operator) {
             operator = DateOperators.Next;
         }
@@ -598,7 +633,6 @@ export class RelativeDateFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'RelativeDateFilter';
         result.offset = this.offset;
         result.count = this.count;
         result.operator = this.operator;
@@ -634,6 +668,10 @@ export class RelativeDateFilter extends AbstractFilter {
 export class CustomFilter extends AbstractFilter {
     constructor(att, jaql, config, composeCode) {
         super(att, FilterTypes.advanced, config, composeCode);
+        /**
+         * @internal
+         */
+        this.__serializable = 'CustomFilter';
         // remove filterType from jaql as it is not needed
         delete jaql.filterType;
         this.jaqlExpression = jaql;
@@ -656,7 +694,6 @@ export class CustomFilter extends AbstractFilter {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'CustomFilter';
         result.jaqlExpression = this.jaqlExpression;
         return result;
     }
@@ -668,7 +705,7 @@ export class CustomFilter extends AbstractFilter {
  * @internal
  */
 export function isCustomFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.advanced;
+    return filter && filter.__serializable === 'CustomFilter';
 }
 /**
  * Checks if a filter is a MembersFilter.
@@ -677,7 +714,7 @@ export function isCustomFilter(filter) {
  * @internal
  */
 export function isMembersFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.members;
+    return filter && filter.__serializable === 'MembersFilter';
 }
 /**
  * Checks if a filter is a NumericFilter.
@@ -686,7 +723,7 @@ export function isMembersFilter(filter) {
  * @internal
  */
 export function isNumericFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.numeric;
+    return filter && filter.__serializable === 'NumericFilter';
 }
 /**
  * Checks if a filter is a TextFilter.
@@ -695,7 +732,7 @@ export function isNumericFilter(filter) {
  * @internal
  */
 export function isRankingFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.ranking;
+    return filter && filter.__serializable === 'RankingFilter';
 }
 /**
  * Checks if a filter is a MeasureFilter.
@@ -704,7 +741,7 @@ export function isRankingFilter(filter) {
  * @internal
  */
 export function isMeasureFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.measure;
+    return filter && filter.__serializable === 'MeasureFilter';
 }
 /**
  * Checks if a filter is a ExcludeFilter.
@@ -713,7 +750,7 @@ export function isMeasureFilter(filter) {
  * @internal
  */
 export function isExcludeFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.exclude;
+    return filter && filter.__serializable === 'ExcludeFilter';
 }
 /**
  * Checks if a filter is a LogicalAttributeFilter.
@@ -722,7 +759,7 @@ export function isExcludeFilter(filter) {
  * @internal
  */
 export function isLogicalAttributeFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.logicalAttribute;
+    return filter && filter.__serializable === 'LogicalAttributeFilter';
 }
 /**
  * Checks if a filter is a CascadingFilter.
@@ -731,7 +768,7 @@ export function isLogicalAttributeFilter(filter) {
  * @internal
  */
 export function isCascadingFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.cascading;
+    return filter && filter.__serializable === 'CascadingFilter';
 }
 /**
  * Checks if a filter is a RelativeDateFilter.
@@ -740,7 +777,7 @@ export function isCascadingFilter(filter) {
  * @internal
  */
 export function isRelativeDateFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.relativeDate;
+    return filter && filter.__serializable === 'RelativeDateFilter';
 }
 /**
  * Checks if a filter is a TextFilter.
@@ -749,7 +786,7 @@ export function isRelativeDateFilter(filter) {
  * @internal
  */
 export function isTextFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.text;
+    return filter && filter.__serializable === 'TextFilter';
 }
 /**
  * Checks if a filter is a DateRangeFilter.
@@ -758,7 +795,7 @@ export function isTextFilter(filter) {
  * @internal
  */
 export function isDateRangeFilter(filter) {
-    return 'filterType' in filter && filter.filterType === FilterTypes.dateRange;
+    return filter && filter.__serializable === 'DateRangeFilter';
 }
 /**
  * @param json - Filter JSON representation

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

@@ -41,6 +41,10 @@ export interface Element {
      * @internal
      */
     readonly dataSource?: JaqlDataSource;
+    /**
+     * @internal
+     */
+    readonly __serializable: string;
     /**
      * Gets a serializable representation of the element.
      *

package/dist/dimensional-model/jaql-element.d.ts

@@ -1,6 +1,6 @@
 import { DimensionalElement } from './base.js';
 import { SortDirection } from './interfaces.js';
-import { JSONObject, MetadataItem, MetadataItemJaql } from './types.js';
+import { AnyObject, JSONObject, MetadataItem, MetadataItemJaql } from './types.js';
 /**
  * This implementation wraps metadata for a JAQL query. The metadata could be
  * for a dimension, measure, or filter. We do little to no interpretation of
@@ -16,6 +16,10 @@ import { JSONObject, MetadataItem, MetadataItemJaql } from './types.js';
  * @internal
  */
 export declare class JaqlElement extends DimensionalElement {
+    /**
+     * @internal
+     */
+    readonly __serializable: string;
     private readonly metadataItem;
     expression: string;
     skipValidation: boolean;
@@ -31,6 +35,10 @@ export declare class JaqlElement extends DimensionalElement {
      */
     serialize(): JSONObject;
 }
+/**
+ * @internal
+ */
+export declare const isJaqlElement: (v: AnyObject) => v is JaqlElement;
 /**
  * Create a JaqlElement from a MetadataItem
  *

package/dist/dimensional-model/jaql-element.js

@@ -1,5 +1,4 @@
-import { createAttributeHelper, createCalculatedMeasureHelper, createMeasureHelper, getSortType, } from '../utils.js';
-import { DimensionalLevelAttribute } from './attributes.js';
+import { createAttributeHelper, createCalculatedMeasureHelper, createMeasureHelper, getGranularityFromJaql, getSortType, } from '../utils.js';
 import { DimensionalElement } from './base.js';
 import { MetadataTypes, } from './types.js';
 /**
@@ -20,6 +19,10 @@ export class JaqlElement extends DimensionalElement {
     constructor(item, type) {
         var _a;
         super((_a = item.jaql.title) !== null && _a !== void 0 ? _a : '', type);
+        /**
+         * @internal
+         */
+        this.__serializable = 'JaqlElement';
         this.expression = (item.jaql.dim || item.jaql.formula);
         this.metadataItem = item;
         if (item.jaql.agg) {
@@ -53,7 +56,6 @@ export class JaqlElement extends DimensionalElement {
      */
     serialize() {
         const result = super.serialize();
-        result.__serializable = 'JaqlElement';
         result.metadataItem = this.metadataItem;
         result.type = this.type;
         return result;
@@ -64,6 +66,12 @@ const toMetadataType = {
     numeric: MetadataTypes.NumericAttribute,
     datetime: MetadataTypes.DateLevel,
 };
+/**
+ * @internal
+ */
+export const isJaqlElement = (v) => {
+    return v && v.__serializable === 'JaqlElement';
+};
 /**
  * Create a JaqlElement from a MetadataItem
  *
@@ -90,7 +98,7 @@ export function createDimensionalElementFromMetadataItem(item) {
     if (jaql.formula) {
         return createCalculatedMeasureHelper(jaql);
     }
-    const granularity = DimensionalLevelAttribute.translateJaqlToGranularity(jaql);
+    const granularity = getGranularityFromJaql(jaql);
     // measure
     if ('agg' in jaql && jaql.dim && jaql.datatype) {
         return createMeasureHelper({

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

@@ -1,10 +1,14 @@
 import { DimensionalElement } from '../base.js';
 import { Attribute, BaseMeasure, CalculatedMeasure, Measure, MeasureContext, MeasureTemplate } from '../interfaces.js';
-import { JaqlDataSource, JSONObject, Sort } from '../types.js';
+import { AnyObject, JaqlDataSource, JSONObject, Sort } from '../types.js';
 /**
  * @internal
  */
 export declare abstract class AbstractMeasure extends DimensionalElement {
+    /**
+     * @internal
+     */
+    readonly __serializable: string;
     protected _sort: Sort;
     protected _format: string | undefined;
     constructor(name: string, type: string, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
@@ -49,6 +53,10 @@ export declare abstract class AbstractMeasure extends DimensionalElement {
  * @internal
  */
 export declare class DimensionalBaseMeasure extends AbstractMeasure implements BaseMeasure {
+    /**
+     * @internal
+     */
+    readonly __serializable: string;
     static aggregationFromJAQL(agg: string): string;
     static aggregationToJAQL(agg: string): string;
     constructor(name: string, attribute: Attribute, agg: string, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
@@ -86,6 +94,10 @@ export declare class DimensionalBaseMeasure extends AbstractMeasure implements B
     serialize(): JSONObject;
     jaql(nested?: boolean): any;
 }
+/**
+ * @internal
+ */
+export declare const isDimensionalBaseMeasure: (v: AnyObject) => v is DimensionalBaseMeasure;
 /**
  * Stands for a Calculated Measure
  *
@@ -93,6 +105,10 @@ export declare class DimensionalBaseMeasure extends AbstractMeasure implements B
  * @internal
  */
 export declare class DimensionalCalculatedMeasure extends AbstractMeasure implements CalculatedMeasure {
+    /**
+     * @internal
+     */
+    readonly __serializable: string;
     constructor(name: string, expression: string, context: MeasureContext, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
     /**
      * Defines the Calculated measure's expression
@@ -128,12 +144,20 @@ export declare class DimensionalCalculatedMeasure extends AbstractMeasure implem
     serialize(): JSONObject;
     jaql(nested?: boolean): any;
 }
+/**
+ * @internal
+ */
+export declare const isDimensionalCalculatedMeasure: (v: AnyObject) => v is DimensionalCalculatedMeasure;
 /**
  * Stands for a Measure template - generator for different aggregation over Attribute
  *
  * @internal
  */
 export declare class DimensionalMeasureTemplate extends AbstractMeasure implements MeasureTemplate {
+    /**
+     * @internal
+     */
+    readonly __serializable: string;
     constructor(name: string, attribute: Attribute, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
     /**
      * Aggregating attribute
@@ -211,7 +235,11 @@ export declare class DimensionalMeasureTemplate extends AbstractMeasure implemen
     countDistinct(format?: string): Measure;
 }
 /**
- * @param json
+ * @internal
+ */
+export declare const isDimensionalMeasureTemplate: (v: AnyObject) => v is DimensionalMeasureTemplate;
+/**
+ * @param json - The JSON object to create a measure from
  * @internal
  */
 export declare function createMeasure(json: any): Measure | BaseMeasure;