@sisense/sdk-data 0.11.3

package/dist/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/dimensional-model/measures/measures.js

@@ -0,0 +1,388 @@
+/* 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 complexity */
+/* eslint-disable max-lines */
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable sonarjs/cognitive-complexity */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable @typescript-eslint/no-throw-literal */
+import * as m from './factory.js';
+import { Sort, AggregationTypes, MetadataTypes } from '../types.js';
+import { DimensionalElement } from '../base.js';
+import { DimensionalAttribute, createAttribute } from '../attributes.js';
+import { create } from '../factory.js';
+/**
+ * @internal
+ */
+export class AbstractMeasure extends DimensionalElement {
+    constructor(name, type, format, desc, sort) {
+        super(name, type, desc);
+        this._sort = Sort.None;
+        this._format = '#,#.00';
+        this._format = format;
+        this._sort = sort || 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;
+    }
+}
+/**
+ * Stands for a Base measure - Aggregation over an Attribute
+ *
+ * @internal
+ */
+export class DimensionalBaseMeasure extends AbstractMeasure {
+    constructor(name, attribute, agg, format, desc, sort) {
+        super(name, MetadataTypes.BaseMeasure, format, desc, sort);
+        this.attribute = attribute;
+        this.aggregation = agg;
+    }
+    static aggregationFromJAQL(agg) {
+        switch (agg) {
+            case 'sum':
+                return AggregationTypes.Sum;
+            case 'avg':
+                return AggregationTypes.Average;
+            case 'min':
+                return AggregationTypes.Min;
+            case 'max':
+                return AggregationTypes.Max;
+            case 'countduplicates':
+                return AggregationTypes.Count;
+            case 'median':
+                return AggregationTypes.Median;
+            case 'count':
+                return AggregationTypes.CountDistinct;
+            case 'var':
+                return AggregationTypes.Variance;
+            case 'stdev':
+                return AggregationTypes.StandardDeviation;
+        }
+        return AggregationTypes.Sum;
+    }
+    static aggregationToJAQL(agg) {
+        switch (agg) {
+            case AggregationTypes.Sum:
+                return 'sum';
+            case AggregationTypes.Average:
+                return 'avg';
+            case AggregationTypes.Min:
+                return 'min';
+            case AggregationTypes.Max:
+                return 'max';
+            case AggregationTypes.Count:
+                return 'countduplicates';
+            case AggregationTypes.CountDistinct:
+                return 'count';
+            case AggregationTypes.Median:
+                return 'median';
+            case AggregationTypes.Variance:
+                return 'var';
+            case AggregationTypes.StandardDeviation:
+                return 'stdev';
+        }
+        return 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 != Sort.None) {
+            r.jaql.sort = this._sort == Sort.Ascending ? 'asc' : 'desc';
+        }
+        return nested === true ? r.jaql : r;
+    }
+}
+/**
+ * Stands for a Calculated Measure
+ *
+ * @see {https://sisense.dev/guides/querying/useJaql/#step-7-adding-a-formula}
+ * @internal
+ */
+export class DimensionalCalculatedMeasure extends AbstractMeasure {
+    constructor(name, expression, context, format, desc, sort) {
+        super(name, 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 != Sort.None) {
+            r.jaql.sort = this._sort == Sort.Ascending ? 'asc' : 'desc';
+        }
+        return nested === true ? r.jaql : r;
+    }
+}
+/**
+ * Stands for a Measure template - generator for different aggregation over Attribute
+ *
+ * @internal
+ */
+export class DimensionalMeasureTemplate extends AbstractMeasure {
+    constructor(name, attribute, format, desc, sort) {
+        super(name, 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);
+    }
+}
+/**
+ * @param json
+ * @internal
+ */
+export 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 DimensionalAttribute(exp, exp);
+    }
+    // official SDK
+    if (json.attribute) {
+        att = createAttribute(json.attribute);
+    }
+    if (MetadataTypes.isCalculatedMeasure(json)) {
+        if (json.context === undefined) {
+            throw new Error(`DimensionalCalculatedMeasure must have context property`);
+        }
+        const context = {};
+        Object.getOwnPropertyNames(json.context).forEach((pname) => {
+            context[pname] = create(json.context[pname]);
+        });
+        return new DimensionalCalculatedMeasure(name, json.expression || json.formula, context, format, desc, sort);
+    }
+    else if (MetadataTypes.isMeasureTemplate(json)) {
+        if (att === undefined) {
+            throw new Error(`DimensionalBaseMeasure must have attribute/dim/expression property`);
+        }
+        return new DimensionalMeasureTemplate(name, att, format, desc);
+    }
+    else if (MetadataTypes.isBaseMeasure(json)) {
+        if (att === undefined) {
+            throw new Error(`DimensionalBaseMeasure must have attribute/dim/expression property`);
+        }
+        const agg = json.agg || json.aggregation;
+        if (!agg) {
+            throw `DimensionalBaseMeasure must have agg or aggregation property`;
+        }
+        return new DimensionalBaseMeasure(name, att, agg, format, desc);
+    }
+    throw 'unsupported measure type';
+}

package/dist/dimensional-model/simple-column-types.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @param type
+ * @internal
+ */
+export declare const isInteger: (type: string) => boolean;
+/**
+ * @param type
+ * @internal
+ */
+export declare const isDecimal: (type: string) => boolean;
+/**
+ * @param type
+ * @internal
+ */
+export declare const isNumber: (type: string) => boolean;
+/**
+ * @param type
+ * @internal
+ */
+export declare const isText: (type: string) => boolean;
+/**
+ * @param type
+ * @internal
+ */
+export declare const isDatetime: (type: string) => boolean;
+/**
+ * @param type
+ * @internal
+ */
+export declare const isBoolean: (type: string) => boolean;
+/**
+ * @internal
+ */
+export declare type SimpleColumnType = 'number' | 'text' | 'datetime' | 'boolean';
+/**
+ * @param type
+ * @internal
+ */
+export declare const simpleColumnType: (type: string) => SimpleColumnType;