@sisense/sdk-data 1.34.0 → 2.1.0

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

@@ -1,6 +1,6 @@
 import { DimensionalElement } from '../base.js';
 import { Attribute, BaseFilterConfig, CompleteBaseFilterConfig, CompleteMembersFilterConfig, Filter, LevelAttribute, Measure, MembersFilterConfig } from '../interfaces.js';
-import { AnyObject } from '../types.js';
+import { AnyObject, JSONObject } from '../types.js';
 /**
  * Different text operators that can be used with text filters
  *
@@ -95,7 +95,7 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
      * Filter configuration
      */
     config: CompleteBaseFilterConfig;
-    constructor(att: Attribute, filterType: string, config?: BaseFilterConfig);
+    constructor(att: Attribute, filterType: string, config?: BaseFilterConfig, composeCode?: string);
     get name(): string;
     /**
      * Gets JAQL representing this Filter instance
@@ -112,7 +112,7 @@ declare abstract class AbstractFilter extends DimensionalElement implements Filt
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets the JAQL representation of this instance
      *
@@ -128,7 +128,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, config?: BaseFilterConfig);
+    constructor(filters: Filter[], operator: string, config?: BaseFilterConfig, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -136,7 +136,7 @@ export declare class LogicalAttributeFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets JAQL representing this Filter instance
      */
@@ -148,7 +148,7 @@ export declare class LogicalAttributeFilter extends AbstractFilter {
 export declare class MembersFilter extends AbstractFilter {
     readonly members: string[];
     config: CompleteMembersFilterConfig;
-    constructor(attribute: Attribute, members?: string[], config?: MembersFilterConfig);
+    constructor(attribute: Attribute, members?: string[], config?: MembersFilterConfig, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -157,7 +157,7 @@ export declare class MembersFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets JAQL representing this Filter instance
      */
@@ -168,7 +168,7 @@ export declare class MembersFilter extends AbstractFilter {
  */
 export declare class CascadingFilter extends AbstractFilter {
     readonly _filters: Filter[];
-    constructor(filters: Filter[], config?: BaseFilterConfig);
+    constructor(filters: Filter[], config?: BaseFilterConfig, composeCode?: string);
     /**
      * Returns the level filters with the root config applied.
      */
@@ -180,7 +180,7 @@ export declare class CascadingFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets JAQL representing this Filter instance
      */
@@ -193,7 +193,7 @@ export declare class CascadingFilter extends AbstractFilter {
 export declare class ExcludeFilter extends AbstractFilter {
     readonly filter: Filter;
     readonly input?: Filter;
-    constructor(filter: Filter, input?: Filter, config?: BaseFilterConfig);
+    constructor(filter: Filter, input?: Filter, config?: BaseFilterConfig, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -201,7 +201,7 @@ export declare class ExcludeFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets JAQL representing this Filter instance
      */
@@ -215,7 +215,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, config?: BaseFilterConfig);
+    constructor(att: Attribute, filterType: string, operatorA?: string, valueA?: Type, operatorB?: string, valueB?: Type, config?: BaseFilterConfig, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -223,7 +223,7 @@ export declare class DoubleOperatorFilter<Type> extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets JAQL representing this Filter instance
      */
@@ -234,7 +234,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, config?: BaseFilterConfig);
+    constructor(att: Attribute, measure: Measure, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, config?: BaseFilterConfig, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -242,7 +242,7 @@ export declare class MeasureFilter extends DoubleOperatorFilter<number> {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     jaql(nested?: boolean | undefined): any;
 }
 /**
@@ -252,7 +252,7 @@ export declare class RankingFilter extends AbstractFilter {
     count: number;
     operator: string;
     measure: Measure;
-    constructor(att: Attribute, measure: Measure, operator: string, count: number, config?: BaseFilterConfig);
+    constructor(att: Attribute, measure: Measure, operator: string, count: number, config?: BaseFilterConfig, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -260,7 +260,7 @@ export declare class RankingFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets JAQL representing this Filter instance
      */
@@ -270,19 +270,27 @@ 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, config?: BaseFilterConfig);
+    constructor(att: Attribute, operatorA?: string, valueA?: number, operatorB?: string, valueB?: number, config?: BaseFilterConfig, composeCode?: string);
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize(): JSONObject;
 }
 /**
  * @internal
  */
 export declare class TextFilter extends DoubleOperatorFilter<string> {
-    constructor(att: Attribute, operator: string, value: string, config?: BaseFilterConfig);
+    constructor(att: Attribute, operator: string, value: string, config?: BaseFilterConfig, composeCode?: string);
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize(): JSONObject;
 }
 /**
  * @internal
  */
 export declare class DateRangeFilter extends DoubleOperatorFilter<Date | string> {
-    constructor(l: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string, config?: BaseFilterConfig);
+    constructor(levelAttribute: LevelAttribute, valueFrom?: Date | string, valueTo?: Date | string, config?: BaseFilterConfig, composeCode?: string);
     get level(): LevelAttribute;
     get from(): string;
     get to(): string;
@@ -290,6 +298,10 @@ export declare class DateRangeFilter extends DoubleOperatorFilter<Date | string>
      * Gets JAQL representing this Filter instance
      */
     filterJaql(): any;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize(): JSONObject;
 }
 /**
  * @internal
@@ -299,7 +311,7 @@ export declare class RelativeDateFilter extends AbstractFilter {
     readonly count: number;
     readonly operator: typeof DateOperators.Last | typeof DateOperators.Next;
     readonly anchor?: Date | string;
-    constructor(l: LevelAttribute, offset: number, count: number, operator?: typeof DateOperators.Last | typeof DateOperators.Next, anchor?: Date | string, config?: BaseFilterConfig);
+    constructor(levelAttribute: LevelAttribute, offset: number, count: number, operator?: typeof DateOperators.Last | typeof DateOperators.Next, anchor?: Date | string, config?: BaseFilterConfig, composeCode?: string);
     get level(): LevelAttribute;
     /**
      * gets the element's ID
@@ -308,7 +320,7 @@ export declare class RelativeDateFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets JAQL representing this Filter instance
      *
@@ -320,7 +332,7 @@ export declare class RelativeDateFilter extends AbstractFilter {
  */
 export declare class CustomFilter extends AbstractFilter {
     readonly jaqlExpression: any;
-    constructor(att: Attribute, jaql: any, config?: BaseFilterConfig);
+    constructor(att: Attribute, jaql: any, config?: BaseFilterConfig, composeCode?: string);
     /**
      * gets the element's ID
      */
@@ -330,6 +342,10 @@ export declare class CustomFilter extends AbstractFilter {
      *
      */
     filterJaql(): any;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize(): JSONObject;
 }
 /**
  * Checks if a filter is a CustomFilter.

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

@@ -90,8 +90,8 @@ export const FilterTypes = {
  * @internal
  */
 class AbstractFilter extends DimensionalElement {
-    constructor(att, filterType, config) {
-        super('filter', MetadataTypes.Filter);
+    constructor(att, filterType, config, composeCode) {
+        super('filter', MetadataTypes.Filter, undefined, undefined, composeCode);
         this.filterType = filterType;
         // need to set isScope
         // to make filter complete for comparison
@@ -107,10 +107,15 @@ class AbstractFilter extends DimensionalElement {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'AbstractFilter';
         result.filterType = this.filterType;
-        result.attribute = this.attribute.serializable();
+        result.attribute = this.attribute.serialize();
+        if (this.config) {
+            result.config = this.config;
+        }
+        result.composeCode = this.composeCode;
         return result;
     }
     /**
@@ -160,8 +165,8 @@ class AbstractFilter extends DimensionalElement {
  * @internal
  */
 export class LogicalAttributeFilter extends AbstractFilter {
-    constructor(filters, operator, config) {
-        super(filters[0].attribute, FilterTypes.logicalAttribute, config);
+    constructor(filters, operator, config, composeCode) {
+        super(filters[0].attribute, FilterTypes.logicalAttribute, config, composeCode);
         this.operator = operator;
         this.filters = filters;
     }
@@ -174,10 +179,11 @@ export class LogicalAttributeFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'LogicalAttributeFilter';
         result.operator = this.operator;
-        result.filters = this.filters.map((f) => f.serializable());
+        result.filters = this.filters.map((f) => f.serialize());
         return result;
     }
     /**
@@ -193,8 +199,8 @@ export class LogicalAttributeFilter extends AbstractFilter {
  * @internal
  */
 export class MembersFilter extends AbstractFilter {
-    constructor(attribute, members, config) {
-        super(attribute, FilterTypes.members);
+    constructor(attribute, members, config, composeCode) {
+        super(attribute, FilterTypes.members, undefined, composeCode);
         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', {
@@ -218,8 +224,13 @@ export class MembersFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    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);
+        }
         result.members = this.members;
         return result;
     }
@@ -245,8 +256,8 @@ export class MembersFilter extends AbstractFilter {
  * @internal
  */
 export class CascadingFilter extends AbstractFilter {
-    constructor(filters, config) {
-        super(filters[0].attribute, FilterTypes.cascading, config);
+    constructor(filters, config, composeCode) {
+        super(filters[0].attribute, FilterTypes.cascading, config, composeCode);
         this._filters = filters;
     }
     /**
@@ -268,9 +279,10 @@ export class CascadingFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
-        result.filters = this.filters.map((f) => f.serializable());
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'CascadingFilter';
+        result._filters = this.filters.map((f) => f.serialize());
         return result;
     }
     /**
@@ -295,8 +307,8 @@ export class CascadingFilter extends AbstractFilter {
  * @internal
  */
 export class ExcludeFilter extends AbstractFilter {
-    constructor(filter, input, config) {
-        super(filter.attribute, FilterTypes.exclude, config);
+    constructor(filter, input, config, composeCode) {
+        super(filter.attribute, FilterTypes.exclude, config, composeCode);
         this.input = input;
         this.filter = filter;
     }
@@ -313,11 +325,12 @@ export class ExcludeFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
-        result.filter = this.filter.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'ExcludeFilter';
+        result.filter = this.filter.serialize();
         if (this.input) {
-            result.input = this.input.serializable();
+            result.input = this.input.serialize();
         }
         return result;
     }
@@ -341,8 +354,8 @@ export class ExcludeFilter extends AbstractFilter {
  * @internal
  */
 export class DoubleOperatorFilter extends AbstractFilter {
-    constructor(att, filterType, operatorA, valueA, operatorB, valueB, config) {
-        super(att, filterType, config);
+    constructor(att, filterType, operatorA, valueA, operatorB, valueB, config, composeCode) {
+        super(att, filterType, config, composeCode);
         if (operatorA && valueA !== undefined) {
             this.valueA = valueA;
             this.operatorA = operatorA;
@@ -368,8 +381,9 @@ export class DoubleOperatorFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'DoubleOperatorFilter';
         if (this.operatorA) {
             result.operatorA = this.operatorA;
         }
@@ -402,8 +416,8 @@ export class DoubleOperatorFilter extends AbstractFilter {
  * @internal
  */
 export class MeasureFilter extends DoubleOperatorFilter {
-    constructor(att, measure, operatorA, valueA, operatorB, valueB, config) {
-        super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB, config);
+    constructor(att, measure, operatorA, valueA, operatorB, valueB, config, composeCode) {
+        super(att, FilterTypes.measure, operatorA, valueA, operatorB, valueB, config, composeCode);
         this.measure = measure;
     }
     /**
@@ -422,9 +436,10 @@ export class MeasureFilter extends DoubleOperatorFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
-        result.measure = this.measure.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'MeasureFilter';
+        result.measure = this.measure.serialize();
         return result;
     }
     jaql(nested) {
@@ -444,8 +459,8 @@ export class MeasureFilter extends DoubleOperatorFilter {
  * @internal
  */
 export class RankingFilter extends AbstractFilter {
-    constructor(att, measure, operator, count, config) {
-        super(att, FilterTypes.ranking, config);
+    constructor(att, measure, operator, count, config, composeCode) {
+        super(att, FilterTypes.ranking, config, composeCode);
         this.count = count;
         this.operator = operator;
         this.measure = measure;
@@ -459,11 +474,12 @@ export class RankingFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'RankingFilter';
         result.count = this.count;
         result.operator = this.operator;
-        result.measure = this.measure.serializable();
+        result.measure = this.measure.serialize();
         return result;
     }
     /**
@@ -480,24 +496,40 @@ export class RankingFilter extends AbstractFilter {
  * @internal
  */
 export class NumericFilter extends DoubleOperatorFilter {
-    constructor(att, operatorA, valueA, operatorB, valueB, config) {
-        super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB, config);
+    constructor(att, operatorA, valueA, operatorB, valueB, config, composeCode) {
+        super(att, FilterTypes.numeric, operatorA, valueA, operatorB, valueB, config, composeCode);
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'NumericFilter';
+        return result;
     }
 }
 /**
  * @internal
  */
 export class TextFilter extends DoubleOperatorFilter {
-    constructor(att, operator, value, config) {
-        super(att, FilterTypes.text, operator, value, undefined, undefined, config);
+    constructor(att, operator, value, config, composeCode) {
+        super(att, FilterTypes.text, operator, value, undefined, undefined, config, composeCode);
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'TextFilter';
+        return result;
     }
 }
 /**
  * @internal
  */
 export class DateRangeFilter extends DoubleOperatorFilter {
-    constructor(l, valueFrom, valueTo, config) {
-        super(l, FilterTypes.dateRange, DateOperators.From, valueFrom, DateOperators.To, valueTo, config);
+    constructor(levelAttribute, valueFrom, valueTo, config, composeCode) {
+        super(levelAttribute, FilterTypes.dateRange, DateOperators.From, valueFrom, DateOperators.To, valueTo, config, composeCode);
         if (typeof valueFrom === 'object') {
             this.valueA = valueFrom.toISOString();
         }
@@ -520,13 +552,21 @@ export class DateRangeFilter extends DoubleOperatorFilter {
     filterJaql() {
         return super.filterJaql();
     }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'DateRangeFilter';
+        return result;
+    }
 }
 /**
  * @internal
  */
 export class RelativeDateFilter extends AbstractFilter {
-    constructor(l, offset, count, operator, anchor, config) {
-        super(l, FilterTypes.relativeDate, config);
+    constructor(levelAttribute, offset, count, operator, anchor, config, composeCode) {
+        super(levelAttribute, FilterTypes.relativeDate, config, composeCode);
         if (!operator) {
             operator = DateOperators.Next;
         }
@@ -556,13 +596,14 @@ export class RelativeDateFilter extends AbstractFilter {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'RelativeDateFilter';
         result.offset = this.offset;
         result.count = this.count;
         result.operator = this.operator;
         if (this.anchor) {
-            result.anchor = this.anchor;
+            result.anchor = typeof this.anchor === 'string' ? this.anchor : this.anchor.toISOString();
         }
         return result;
     }
@@ -591,8 +632,8 @@ export class RelativeDateFilter extends AbstractFilter {
  * @internal
  */
 export class CustomFilter extends AbstractFilter {
-    constructor(att, jaql, config) {
-        super(att, FilterTypes.advanced, config);
+    constructor(att, jaql, config, composeCode) {
+        super(att, FilterTypes.advanced, config, composeCode);
         // remove filterType from jaql as it is not needed
         delete jaql.filterType;
         this.jaqlExpression = jaql;
@@ -610,6 +651,15 @@ export class CustomFilter extends AbstractFilter {
     filterJaql() {
         return this.jaqlExpression;
     }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'CustomFilter';
+        result.jaqlExpression = this.jaqlExpression;
+        return result;
+    }
 }
 /**
  * Checks if a filter is a CustomFilter.

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

@@ -6,15 +6,11 @@ import { createAttributeHelper, createCalculatedMeasureHelper, createMeasureHelp
  * @returns attribute or level attribute
  */
 export const createAttributeFromFilterJaql = (jaql) => {
-    const { dim, table, column, datatype, title, datasource: dataSource } = jaql;
+    const { dim, datatype, title, datasource: dataSource } = jaql;
     return createAttributeHelper({
-        dim,
-        table,
-        column,
+        expression: dim,
         dataType: datatype,
         granularity: getGranularityFromJaql(jaql),
-        format: undefined,
-        sort: undefined,
         title,
         dataSource,
     });
@@ -26,13 +22,11 @@ export const createAttributeFromFilterJaql = (jaql) => {
  * @returns Measure
  */
 export const createMeasureFromFilterJaql = (jaql) => {
-    const { dim, table, column, title, datatype: dataType, agg, datasource: dataSource } = jaql;
+    const { dim, title, datatype: dataType, agg, datasource: dataSource } = jaql;
     if (!agg)
         return undefined;
     return createMeasureHelper({
-        dim,
-        table,
-        column,
+        expression: dim,
         dataType,
         agg,
         granularity: getGranularityFromJaql(jaql),
@@ -51,11 +45,9 @@ export const createMeasureFromFilterJaql = (jaql) => {
 export const createMeasureFromRankingFilterJaql = (jaql, rankingMessage) => {
     if ('formula' in jaql)
         return createCalculatedMeasureHelper(jaql);
-    const { dim, table, column, datatype: dataType, agg } = jaql;
+    const { dim, datatype: dataType, agg } = jaql;
     return createMeasureHelper({
-        dim,
-        table,
-        column,
+        expression: dim,
         granularity: getGranularityFromJaql(jaql),
         dataType,
         agg,