@sisense/sdk-data 1.10.1 → 1.12.0

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

@@ -0,0 +1,217 @@
+import { Attribute, Measure, BaseMeasure, MeasureTemplate, CalculatedMeasure, MeasureContext } from '../interfaces.js';
+import { Sort } from '../types.js';
+import { DimensionalElement } from '../base.js';
+/**
+ * @internal
+ */
+export declare abstract class AbstractMeasure extends DimensionalElement {
+    protected _sort: Sort;
+    protected _format: string | undefined;
+    constructor(name: string, type: string, format?: string, desc?: string, sort?: Sort);
+    /**
+     * gets the element's ID
+     */
+    abstract get id(): string;
+    /**
+     * Gets the sort definition of this instance
+     *
+     * @returns The Sort definition of this instance
+     */
+    getSort(): Sort;
+    /**
+     * The string formatting of this instance
+     *
+     * @returns string formatting
+     */
+    getFormat(): string | undefined;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets a sorted {@link Measure} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted  {@link Measure} of this instance
+     */
+    abstract sort(sort: Sort): Measure;
+    /**
+     * Gets a formatted {@link Measure} with the given definition
+     *
+     * @param format - Format string
+     * @returns An instance representing the formatted {@link Measure} of this instance
+     */
+    abstract format(format: string): Measure;
+}
+/**
+ * Stands for a Base measure - Aggregation over an Attribute
+ *
+ * @internal
+ */
+export declare class DimensionalBaseMeasure extends AbstractMeasure implements BaseMeasure {
+    static aggregationFromJAQL(agg: string): string;
+    static aggregationToJAQL(agg: string): string;
+    constructor(name: string, attribute: Attribute, agg: string, format?: string, desc?: string, sort?: Sort);
+    /**
+     * Aggregating attribute
+     */
+    readonly attribute: Attribute;
+    /**
+     * Aggregation type
+     */
+    readonly aggregation: string;
+    /**
+     * Gets a sorted {@link Measure} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Measure} of this instance
+     */
+    sort(sort: Sort): Measure;
+    /**
+     * Gets a formatted {@link Measure} with the given definition
+     *
+     * Input string is in Numeral format - @see http://numeraljs.com/
+     *
+     * @param format - Format string
+     * @returns An instance representing the formatted {@link Measure} of this instance
+     */
+    format(format: string): Measure;
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    jaql(nested?: boolean): any;
+}
+/**
+ * Stands for a Calculated Measure
+ *
+ * @see {https://sisense.dev/guides/querying/useJaql/#step-7-adding-a-formula}
+ * @internal
+ */
+export declare class DimensionalCalculatedMeasure extends AbstractMeasure implements CalculatedMeasure {
+    constructor(name: string, expression: string, context: MeasureContext, format?: string, desc?: string, sort?: Sort);
+    /**
+     * Defines the Calculated measure's expression
+     */
+    expression: string;
+    /**
+     * Defines the Calculated measure's context
+     */
+    context: MeasureContext;
+    /**
+     * Gets a sorted {@link Measure} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Measure} of this instance
+     */
+    sort(sort: Sort): Measure;
+    /**
+     * Gets a formatted {@link Measure} with the given definition
+     *
+     * Input string is in Numeral format - @see http://numeraljs.com/
+     *
+     * @param format - Format string
+     * @returns An instance representing the formatted {@link Measure} of this instance
+     */
+    format(format: string): Measure;
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    jaql(nested?: boolean): any;
+}
+/**
+ * Stands for a Measure template - generator for different aggregation over Attribute
+ *
+ * @internal
+ */
+export declare class DimensionalMeasureTemplate extends AbstractMeasure implements MeasureTemplate {
+    constructor(name: string, attribute: Attribute, format?: string, desc?: string, sort?: Sort);
+    /**
+     * Aggregating attribute
+     */
+    readonly attribute: Attribute;
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * Gets a sorted {@link MeasureTemplate} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link MeasureTemplate} of this instance
+     */
+    sort(sort: Sort): MeasureTemplate;
+    /**
+     * Gets a formatted {@link Measure} with the given definition
+     *
+     * @param format - Format string
+     * @returns An instance representing the formatted {@link Measure} of this instance
+     */
+    format(format: string): Measure;
+    /**
+     * 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?: boolean): any;
+    /**
+     * Gets an {@link Measure} defined with sum aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    sum(format?: string): Measure;
+    /**
+     * Gets an {@link Measure} defined with average aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    average(format?: string): Measure;
+    /**
+     * Gets an {@link Measure} defined with median aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    median(format?: string): Measure;
+    /**
+     * Gets an {@link Measure} defined with min aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    min(format?: string): Measure;
+    /**
+     * Gets an {@link Measure} defined with max aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    max(format?: string): Measure;
+    /**
+     * Gets an {@link Measure} defined with count aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    count(format?: string): Measure;
+    /**
+     * Gets an {@link Measure} defined with count distinct aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    countDistinct(format?: string): Measure;
+}
+/**
+ * @param json
+ * @internal
+ */
+export declare function createMeasure(json: any): Measure | BaseMeasure;

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

@@ -0,0 +1,416 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMeasure = exports.DimensionalMeasureTemplate = exports.DimensionalCalculatedMeasure = exports.DimensionalBaseMeasure = exports.AbstractMeasure = void 0;
+/* eslint-disable max-params */
+/* eslint-disable no-underscore-dangle */
+/* 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 @typescript-eslint/no-unsafe-argument */
+const m = __importStar(require("./factory.js"));
+const types_js_1 = require("../types.js");
+const base_js_1 = require("../base.js");
+const attributes_js_1 = require("../attributes.js");
+const factory_js_1 = require("../factory.js");
+const translatable_error_js_1 = require("../../translation/translatable-error.js");
+/**
+ * @internal
+ */
+class AbstractMeasure extends base_js_1.DimensionalElement {
+    constructor(name, type, format, desc, sort) {
+        super(name, type, desc);
+        this._sort = types_js_1.Sort.None;
+        this._format = '#,#.00';
+        this._format = format;
+        this._sort = sort || types_js_1.Sort.None;
+    }
+    /**
+     * Gets the sort definition of this instance
+     *
+     * @returns The Sort definition of this instance
+     */
+    getSort() {
+        return this._sort;
+    }
+    /**
+     * The string formatting of this instance
+     *
+     * @returns string formatting
+     */
+    getFormat() {
+        return this._format;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        if (this.getFormat() !== undefined) {
+            result.format = this.getFormat();
+        }
+        if (this.getSort() !== undefined) {
+            result.sort = this.getSort();
+        }
+        return result;
+    }
+}
+exports.AbstractMeasure = AbstractMeasure;
+/**
+ * Stands for a Base measure - Aggregation over an Attribute
+ *
+ * @internal
+ */
+class DimensionalBaseMeasure extends AbstractMeasure {
+    constructor(name, attribute, agg, format, desc, sort) {
+        super(name, types_js_1.MetadataTypes.BaseMeasure, format, desc, sort);
+        this.attribute = attribute;
+        this.aggregation = agg;
+    }
+    static aggregationFromJAQL(agg) {
+        switch (agg) {
+            case 'sum':
+                return types_js_1.AggregationTypes.Sum;
+            case 'avg':
+                return types_js_1.AggregationTypes.Average;
+            case 'min':
+                return types_js_1.AggregationTypes.Min;
+            case 'max':
+                return types_js_1.AggregationTypes.Max;
+            case 'countduplicates':
+                return types_js_1.AggregationTypes.Count;
+            case 'median':
+                return types_js_1.AggregationTypes.Median;
+            case 'count':
+                return types_js_1.AggregationTypes.CountDistinct;
+            case 'var':
+                return types_js_1.AggregationTypes.Variance;
+            case 'stdev':
+                return types_js_1.AggregationTypes.StandardDeviation;
+        }
+        return types_js_1.AggregationTypes.Sum;
+    }
+    static aggregationToJAQL(agg) {
+        switch (agg) {
+            case types_js_1.AggregationTypes.Sum:
+                return 'sum';
+            case types_js_1.AggregationTypes.Average:
+                return 'avg';
+            case types_js_1.AggregationTypes.Min:
+                return 'min';
+            case types_js_1.AggregationTypes.Max:
+                return 'max';
+            case types_js_1.AggregationTypes.Count:
+                return 'countduplicates';
+            case types_js_1.AggregationTypes.CountDistinct:
+                return 'count';
+            case types_js_1.AggregationTypes.Median:
+                return 'median';
+            case types_js_1.AggregationTypes.Variance:
+                return 'var';
+            case types_js_1.AggregationTypes.StandardDeviation:
+                return 'stdev';
+        }
+        return types_js_1.AggregationTypes.Sum;
+    }
+    /**
+     * Gets a sorted {@link Measure} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Measure} of this instance
+     */
+    sort(sort) {
+        return new DimensionalBaseMeasure(this.name, this.attribute, this.aggregation, this._format, this.description, sort);
+    }
+    /**
+     * Gets a formatted {@link Measure} with the given definition
+     *
+     * Input string is in Numeral format - @see http://numeraljs.com/
+     *
+     * @param format - Format string
+     * @returns An instance representing the formatted {@link Measure} of this instance
+     */
+    format(format) {
+        return new DimensionalBaseMeasure(this.name, this.attribute, this.aggregation, format, this.description, this._sort);
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.attribute.expression}_${this.aggregation}`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.aggregation = this.aggregation;
+        result.attribute = this.attribute.serializable();
+        return result;
+    }
+    jaql(nested) {
+        const attributeJaql = this.attribute.jaql(true);
+        const r = {
+            jaql: Object.assign(Object.assign({}, attributeJaql), { title: this.name, agg: DimensionalBaseMeasure.aggregationToJAQL(this.aggregation) }),
+        };
+        if (this._format) {
+            r.format = { number: this._format };
+        }
+        if (this._sort != types_js_1.Sort.None) {
+            r.jaql.sort = this._sort == types_js_1.Sort.Ascending ? 'asc' : 'desc';
+        }
+        return nested === true ? r.jaql : r;
+    }
+}
+exports.DimensionalBaseMeasure = DimensionalBaseMeasure;
+/**
+ * Stands for a Calculated Measure
+ *
+ * @see {https://sisense.dev/guides/querying/useJaql/#step-7-adding-a-formula}
+ * @internal
+ */
+class DimensionalCalculatedMeasure extends AbstractMeasure {
+    constructor(name, expression, context, format, desc, sort) {
+        super(name, types_js_1.MetadataTypes.CalculatedMeasure, format, desc, sort);
+        this.expression = expression;
+        this.context = context;
+    }
+    /**
+     * Gets a sorted {@link Measure} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Measure} of this instance
+     */
+    sort(sort) {
+        return new DimensionalCalculatedMeasure(this.name, this.expression, this.context, this._format, this.description, sort);
+    }
+    /**
+     * Gets a formatted {@link Measure} with the given definition
+     *
+     * Input string is in Numeral format - @see http://numeraljs.com/
+     *
+     * @param format - Format string
+     * @returns An instance representing the formatted {@link Measure} of this instance
+     */
+    format(format) {
+        return new DimensionalCalculatedMeasure(this.name, this.expression, this.context, format, this.description, this._sort);
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return this.expression;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.expression = this.expression;
+        result.context = {};
+        Object.getOwnPropertyNames(this.context).forEach((p) => {
+            result.context[p] = this.context[p].serializable();
+        });
+        return result;
+    }
+    jaql(nested) {
+        const r = {
+            jaql: {
+                title: this.name,
+                formula: this.expression,
+            },
+        };
+        const context = {};
+        const keys = Object.getOwnPropertyNames(this.context);
+        keys.forEach((k) => (context[k] = this.context[k].jaql(true)));
+        r.jaql.context = context;
+        if (this._format) {
+            r.format = { number: this._format };
+        }
+        if (this._sort != types_js_1.Sort.None) {
+            r.jaql.sort = this._sort == types_js_1.Sort.Ascending ? 'asc' : 'desc';
+        }
+        return nested === true ? r.jaql : r;
+    }
+}
+exports.DimensionalCalculatedMeasure = DimensionalCalculatedMeasure;
+/**
+ * Stands for a Measure template - generator for different aggregation over Attribute
+ *
+ * @internal
+ */
+class DimensionalMeasureTemplate extends AbstractMeasure {
+    constructor(name, attribute, format, desc, sort) {
+        super(name, types_js_1.MetadataTypes.MeasureTemplate, format, desc, sort);
+        this.attribute = attribute;
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return `${this.attribute.expression}_*`;
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.attribute = this.attribute.serializable();
+        return result;
+    }
+    /**
+     * Gets a sorted {@link MeasureTemplate} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link MeasureTemplate} of this instance
+     */
+    sort(sort) {
+        return new DimensionalMeasureTemplate(this.name, this.attribute, this._format, this.description, sort);
+    }
+    /**
+     * Gets a formatted {@link Measure} with the given definition
+     *
+     * @param format - Format string
+     * @returns An instance representing the formatted {@link Measure} of this instance
+     */
+    format(format) {
+        return new DimensionalMeasureTemplate(this.name, this.attribute, format, this.description, this._sort);
+    }
+    /**
+     * 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) {
+        return this.sum().sort(this._sort).jaql(nested);
+    }
+    /**
+     * Gets an {@link Measure} defined with sum aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    sum(format) {
+        return m.sum(this.attribute, format).sort(this._sort);
+    }
+    /**
+     * Gets an {@link Measure} defined with average aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    average(format) {
+        return m.average(this.attribute, format).sort(this._sort);
+    }
+    /**
+     * Gets an {@link Measure} defined with median aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    median(format) {
+        return m.median(this.attribute, format).sort(this._sort);
+    }
+    /**
+     * Gets an {@link Measure} defined with min aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    min(format) {
+        return m.median(this.attribute, format).sort(this._sort);
+    }
+    /**
+     * Gets an {@link Measure} defined with max aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    max(format) {
+        return m.max(this.attribute, format).sort(this._sort);
+    }
+    /**
+     * Gets an {@link Measure} defined with count aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    count(format) {
+        return m.count(this.attribute, format).sort(this._sort);
+    }
+    /**
+     * Gets an {@link Measure} defined with count distinct aggregation
+     *
+     * @param format - optional format to apply on the resulting {@link Measure}
+     */
+    countDistinct(format) {
+        return m.countDistinct(this.attribute, format).sort(this._sort);
+    }
+}
+exports.DimensionalMeasureTemplate = DimensionalMeasureTemplate;
+/**
+ * @param json
+ * @internal
+ */
+function createMeasure(json) {
+    var _a;
+    const name = json.name || json.title;
+    const desc = json.desc || json.description;
+    const format = json.format;
+    const sort = (_a = json.sort) !== null && _a !== void 0 ? _a : json.sort;
+    let att = undefined;
+    // legacy
+    const exp = json.dim || json.expression;
+    if (exp) {
+        att = new attributes_js_1.DimensionalAttribute(exp, exp, undefined, desc);
+    }
+    // official SDK
+    if (json.attribute) {
+        att = (0, attributes_js_1.createAttribute)(json.attribute);
+    }
+    if (types_js_1.MetadataTypes.isCalculatedMeasure(json)) {
+        if (json.context === undefined) {
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalCalculatedMeasure.noContext');
+        }
+        const context = {};
+        Object.getOwnPropertyNames(json.context).forEach((pname) => {
+            context[pname] = (0, factory_js_1.create)(json.context[pname]);
+        });
+        return new DimensionalCalculatedMeasure(name, json.expression || json.formula, context, format, desc, sort);
+    }
+    else if (types_js_1.MetadataTypes.isMeasureTemplate(json)) {
+        if (att === undefined) {
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression');
+        }
+        return new DimensionalMeasureTemplate(name, att, format, desc);
+    }
+    else if (types_js_1.MetadataTypes.isBaseMeasure(json)) {
+        if (att === undefined) {
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression');
+        }
+        const agg = json.agg || json.aggregation;
+        if (!agg) {
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAggAggregation');
+        }
+        return new DimensionalBaseMeasure(name, att, agg, format, desc);
+    }
+    throw new translatable_error_js_1.TranslatableError('errors.measure.unsupportedType');
+}
+exports.createMeasure = createMeasure;

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

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