@sisense/sdk-data 1.11.0 → 1.13.0

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

@@ -0,0 +1,167 @@
+import { Attribute, LevelAttribute, Dimension, DateDimension } from './interfaces.js';
+import { Sort } from './types.js';
+import { DimensionalElement } from './base.js';
+/**
+ * Represents a Dimension in a Dimensional Model
+ *
+ * @internal
+ */
+export declare class DimensionalDimension extends DimensionalElement implements Dimension, Attribute {
+    static parseType(type: string): string;
+    [propName: string]: any;
+    defaultAttribute: Attribute | undefined;
+    protected _dimensions: Dimension[];
+    protected _attributes: Attribute[];
+    private _expression;
+    protected _sort: Sort;
+    constructor(name: string, expression: string, attributes: Attribute[], dimensions?: Dimension[], type?: string, desc?: string, sort?: Sort);
+    private getAttachedName;
+    protected setDimensions(dimensions: Dimension[]): void;
+    protected setAttributes(attributes: Attribute[]): void;
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    /**
+     * Gets the child attributes
+     */
+    get attributes(): Attribute[];
+    /**
+     * Gets the child dimensions
+     */
+    get dimensions(): Dimension[];
+    get expression(): string;
+    /**
+     * Gets the sort definition of this instance
+     *
+     * @returns The Sort definition of this instance
+     */
+    getSort(): Sort;
+    /**
+     * Gets a sorted {@link Dimension} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Dimension} of this instance
+     */
+    sort(sort: Sort): Attribute;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * 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;
+}
+/**
+ * Represents a Date Dimension in a Dimensional Model
+ *
+ * @internal
+ */
+export declare class DimensionalDateDimension extends DimensionalDimension implements DateDimension {
+    constructor(name: string, expression: string, desc?: string, sort?: Sort);
+    /**
+     * Years level
+     */
+    readonly Years: LevelAttribute;
+    /**
+     * Quarters level
+     */
+    readonly Quarters: LevelAttribute;
+    /**
+     * Months level
+     */
+    readonly Months: LevelAttribute;
+    /**
+     * Weeks level
+     */
+    readonly Weeks: LevelAttribute;
+    /**
+     * Days level
+     */
+    readonly Days: LevelAttribute;
+    /**
+     * Hours level
+     */
+    readonly Hours: LevelAttribute;
+    /**
+     * Minutes (round to 30) level
+     */
+    readonly MinutesRoundTo30: LevelAttribute;
+    /**
+     * Minutes (round to 15) level
+     */
+    readonly MinutesRoundTo15: LevelAttribute;
+    /**
+     * Aggregated Hours  level
+     */
+    readonly AggHours: LevelAttribute;
+    /**
+     * Aggregated Minutes (round to 30) level
+     */
+    readonly AggMinutesRoundTo30: LevelAttribute;
+    /**
+     * Aggregated Minutes (round to 15) level
+     */
+    readonly AggMinutesRoundTo15: LevelAttribute;
+    /**
+     * Aggregated Minutes (every minute) level
+     */
+    readonly AggMinutesRoundTo1: LevelAttribute;
+    defaultLevel: string;
+    /**
+     * gets the element's ID
+     */
+    get id(): string;
+    protected setDimensions(): void;
+    protected setAttributes(attributes: Attribute[]): void;
+    /**
+     * Gets the sort definition of this instance
+     *
+     * @returns The Sort definition of this instance
+     */
+    getSort(): Sort;
+    /**
+     * Gets a sorted {@link Dimension} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Dimension} of this instance
+     */
+    sort(sort: Sort): Attribute;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable(): any;
+    /**
+     * 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;
+}
+/**
+ * Creates a new Dimension instance from the given JSON object.
+ *
+ * This function is used in the generated data model code to create dimensions for an input data source.
+ *
+ * See also functions {@link createDateDimension} and {@link createAttribute}.
+ *
+ * @param json - JSON object representing the Dimension
+ * @returns A new Dimension instance
+ * @group Data Model Utilities
+ */
+export declare function createDimension(json: any): Dimension;
+/**
+ * Creates a new Date Dimension instance from the given JSON object.
+ *
+ * This function is used in the generated data model code to create date dimensions for an input data source.
+ *
+ * See also functions {@link createDimension} and {@link createAttribute}.
+ *
+ * @param json - JSON object representing the Date Dimension
+ * @returns A new Date Dimension instance
+ * @group Data Model Utilities
+ */
+export declare function createDateDimension(json: any): DateDimension;

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

@@ -0,0 +1,307 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDateDimension = exports.createDimension = exports.DimensionalDateDimension = exports.DimensionalDimension = void 0;
+const types_js_1 = require("./types.js");
+const attributes_js_1 = require("./attributes.js");
+const base_js_1 = require("./base.js");
+/**
+ * Represents a Dimension in a Dimensional Model
+ *
+ * @internal
+ */
+class DimensionalDimension extends base_js_1.DimensionalElement {
+    constructor(name, expression, attributes, dimensions, type, desc, sort) {
+        super(name, type || types_js_1.MetadataTypes.Dimension, desc);
+        this._dimensions = [];
+        this._attributes = [];
+        this._sort = types_js_1.Sort.None;
+        this._sort = sort || types_js_1.Sort.None;
+        this._expression = expression;
+        this.setDimensions(dimensions || []);
+        this.setAttributes(attributes);
+    }
+    static parseType(type) {
+        switch (type) {
+            case 'datetime':
+            case types_js_1.MetadataTypes.DateDimension:
+                return types_js_1.MetadataTypes.DateDimension;
+            case 'text':
+            case types_js_1.MetadataTypes.TextDimension:
+                return types_js_1.MetadataTypes.TextDimension;
+            case 'numeric':
+            case types_js_1.MetadataTypes.NumericDimension:
+                return types_js_1.MetadataTypes.NumericDimension;
+        }
+        return types_js_1.MetadataTypes.TextDimension;
+    }
+    getAttachedName(name, expression) {
+        let result = (0, base_js_1.normalizeName)(name);
+        // if exists fallback to expression
+        if (result === 'id' ||
+            result === 'name' ||
+            Object.getOwnPropertyDescriptor(this, result) !== undefined ||
+            this[result] !== undefined) {
+            result = (0, base_js_1.normalizeName)(expression.replace('.', '_').replace('[', '').replace(']', ''));
+        }
+        return result;
+    }
+    setDimensions(dimensions) {
+        this._dimensions = dimensions;
+        for (let i = 0; i < dimensions.length; i++) {
+            const n = this.getAttachedName(dimensions[i].name, dimensions[i].attributes[0].expression);
+            this[n] = dimensions[i];
+            if (n != dimensions[i].name) {
+                dimensions[i].name = n;
+            }
+        }
+    }
+    setAttributes(attributes) {
+        this._attributes = attributes || [];
+        for (let i = 0; i < attributes.length; i++) {
+            const n = this.getAttachedName(attributes[i].name, attributes[i].expression);
+            this[n] = attributes[i];
+            if (attributes[i].name != n) {
+                attributes[i].name = n;
+            }
+            // attaching to dimension
+            //this.attributes[i].dimension = this;
+        }
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return this._expression;
+    }
+    /**
+     * Gets the child attributes
+     */
+    get attributes() {
+        return this._attributes;
+    }
+    /**
+     * Gets the child dimensions
+     */
+    get dimensions() {
+        return this._dimensions;
+    }
+    get expression() {
+        return this._expression;
+    }
+    /**
+     * Gets the sort definition of this instance
+     *
+     * @returns The Sort definition of this instance
+     */
+    getSort() {
+        return this._sort;
+    }
+    /**
+     * Gets a sorted {@link Dimension} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Dimension} of this instance
+     */
+    sort(sort) {
+        return new DimensionalDimension(this.name, this.expression, this.attributes, this.dimensions, this.type, this.description, sort);
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        result.expression = this.expression;
+        if (this.getSort() !== undefined) {
+            result.sort = this.getSort();
+        }
+        result.attributes = this._attributes.map((att) => att.serializable());
+        result.diemsnions = this._dimensions.map((dim) => dim.serializable());
+        if (this.defaultAttribute) {
+            result.defaultAttribute = this.defaultAttribute.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.defaultAttribute) {
+            return this.defaultAttribute.jaql(nested);
+        }
+        if (this.dimensions.length > 0) {
+            return this.dimensions[0].jaql(nested);
+        }
+        const result = {
+            jaql: {
+                title: this.name,
+                dim: this.expression,
+                datatype: (0, attributes_js_1.jaqlSimpleColumnType)(this.type),
+            },
+        };
+        if (this._sort != types_js_1.Sort.None) {
+            result.jaql.sort = this._sort == types_js_1.Sort.Ascending ? 'asc' : 'desc';
+        }
+        return nested === true ? result.jaql : result;
+    }
+}
+exports.DimensionalDimension = DimensionalDimension;
+/**
+ * Represents a Date Dimension in a Dimensional Model
+ *
+ * @internal
+ */
+class DimensionalDateDimension extends DimensionalDimension {
+    constructor(name, expression, desc, sort) {
+        super(name, expression, [], [], types_js_1.MetadataTypes.DateDimension, desc, sort);
+        this.defaultLevel = types_js_1.DateLevels.Years;
+        this.Years = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.Years, expression, types_js_1.DateLevels.Years, 'yyyy');
+        this.Quarters = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.Quarters, expression, types_js_1.DateLevels.Quarters, 'Q yyyy');
+        this.Months = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.Months, expression, types_js_1.DateLevels.Months, 'yyyy-MM');
+        this.Weeks = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.Weeks, expression, types_js_1.DateLevels.Weeks, 'ww yyyy');
+        this.Days = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.Days, expression, types_js_1.DateLevels.Days, 'yyyy-MM-dd');
+        this.Hours = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.Hours, expression, types_js_1.DateLevels.Hours, 'yyyy-MM-dd HH:mm');
+        this.MinutesRoundTo30 = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.MinutesRoundTo30, expression, types_js_1.DateLevels.MinutesRoundTo30, 'yyyy-MM-dd HH:mm');
+        this.MinutesRoundTo15 = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.MinutesRoundTo15, expression, types_js_1.DateLevels.MinutesRoundTo15, 'yyyy-MM-dd HH:mm');
+        this.AggHours = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.AggHours, expression, types_js_1.DateLevels.AggHours, 'HH:mm');
+        this.AggMinutesRoundTo30 = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.AggMinutesRoundTo30, expression, types_js_1.DateLevels.AggMinutesRoundTo30, 'HH:mm');
+        this.AggMinutesRoundTo15 = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.AggMinutesRoundTo15, expression, types_js_1.DateLevels.AggMinutesRoundTo15, 'HH:mm');
+        this.AggMinutesRoundTo1 = new attributes_js_1.DimensionalLevelAttribute(types_js_1.DateLevels.AggMinutesRoundTo1, expression, types_js_1.DateLevels.AggMinutesRoundTo1, 'HH:mm');
+        this.setAttributes([
+            this.Years,
+            this.Quarters,
+            this.Months,
+            this.Weeks,
+            this.Days,
+            this.Hours,
+            this.MinutesRoundTo30,
+            this.MinutesRoundTo15,
+            this.AggHours,
+            this.AggMinutesRoundTo30,
+            this.AggMinutesRoundTo15,
+            this.AggMinutesRoundTo1,
+        ]);
+    }
+    /**
+     * gets the element's ID
+     */
+    get id() {
+        return this.expression;
+    }
+    setDimensions() {
+        /* */
+    }
+    setAttributes(attributes) {
+        this._attributes = attributes;
+    }
+    /**
+     * Gets the sort definition of this instance
+     *
+     * @returns The Sort definition of this instance
+     */
+    getSort() {
+        return this._sort;
+    }
+    /**
+     * Gets a sorted {@link Dimension} with the given definition
+     *
+     * @param sort - Sort definition
+     * @returns An instance representing the sorted {@link Dimension} of this instance
+     */
+    sort(sort) {
+        return new DimensionalDateDimension(this.name, this.expression, this.description, sort);
+    }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serializable() {
+        const result = super.serializable();
+        if (this.defaultLevel) {
+            result.defaultLevel = this.defaultLevel;
+        }
+        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) {
+        const result = this[this.defaultLevel].jaql();
+        result.jaql.title = this.name;
+        return nested ? result.jaql : result;
+    }
+}
+exports.DimensionalDateDimension = DimensionalDateDimension;
+/**
+ * Creates a new Dimension instance from the given JSON object.
+ *
+ * This function is used in the generated data model code to create dimensions for an input data source.
+ *
+ * See also functions {@link createDateDimension} and {@link createAttribute}.
+ *
+ * @param json - JSON object representing the Dimension
+ * @returns A new Dimension instance
+ * @group Data Model Utilities
+ */
+function createDimension(json) {
+    const name = json.name || json.title;
+    const description = json.desc || json.description;
+    const expression = json.expression || json.dim;
+    const type = DimensionalDimension.parseType(json.dimtype || json.type);
+    // date dimension
+    if (type == types_js_1.MetadataTypes.DateDimension) {
+        return new DimensionalDateDimension(name, expression, description);
+    }
+    // attributes
+    const atts = Object.getOwnPropertyNames(json)
+        .map((p) => json[p])
+        .filter((v) => types_js_1.MetadataTypes.isAttribute(v.type));
+    if (atts.length == 0) {
+        if (json.attributes) {
+            let att;
+            for (let i = 0; i < json.attributes.length; i++) {
+                att = json.attributes[i];
+                atts.push(new attributes_js_1.DimensionalAttribute(att.name, att.expression, att.type, att.description));
+            }
+        }
+        // default attribute
+        else if (expression) {
+            atts.push(new attributes_js_1.DimensionalAttribute(name, expression, type, description));
+        }
+    }
+    // nested dimensions
+    const dims = Object.getOwnPropertyNames(json)
+        .map((p) => json[p])
+        .filter((v) => types_js_1.MetadataTypes.isDimension(v.type));
+    if (dims.length == 0 && json.dimensions) {
+        for (let i = 0; i < json.dimensions.length; i++) {
+            dims.push(createDimension(json.dimensions[i]));
+        }
+    }
+    const d = new DimensionalDimension(name, expression, atts, dims, type, description);
+    if (json.defaultAttribute) {
+        d.defaultAttribute = atts.find((a) => a.name === json.defaultAttribute);
+    }
+    return d;
+}
+exports.createDimension = createDimension;
+/**
+ * Creates a new Date Dimension instance from the given JSON object.
+ *
+ * This function is used in the generated data model code to create date dimensions for an input data source.
+ *
+ * See also functions {@link createDimension} and {@link createAttribute}.
+ *
+ * @param json - JSON object representing the Date Dimension
+ * @returns A new Date Dimension instance
+ * @group Data Model Utilities
+ */
+function createDateDimension(json) {
+    const name = json.name || json.title;
+    const expression = json.expression || json.dim;
+    const description = json.desc || json.description;
+    return new DimensionalDateDimension(name, expression, description);
+}
+exports.createDateDimension = createDateDimension;

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

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

package/dist/cjs/dimensional-model/dimensions.test.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const attributes_js_1 = require("./attributes.js");
+const dimensions_js_1 = require("./dimensions.js");
+const types_js_1 = require("./types.js");
+describe('Dimension jaql preparations', () => {
+    it('must prepare simple text dimension jaql', () => {
+        const result = { jaql: { title: 'Brand', dim: '[Brand.Brand]', datatype: 'text' } };
+        const dimension = new dimensions_js_1.DimensionalDimension('Brand', '[Brand.Brand]', [new attributes_js_1.DimensionalAttribute('Brand', '[Brand.Brand]')], [], 'textdimension');
+        const jaql = dimension.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare simple text dimension with default attribute jaql', () => {
+        const result = { jaql: { title: 'Brand', dim: '[Brand.Brand]', datatype: 'text' } };
+        const attribute = new attributes_js_1.DimensionalAttribute('Brand', '[Brand.Brand]');
+        const dimension = new dimensions_js_1.DimensionalDimension('Brand', '[Brand.Brand]', [attribute], [], 'textdimension');
+        dimension.defaultAttribute = attribute;
+        const jaql = dimension.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare simple text dimension with nested dimension jaql', () => {
+        const result = { jaql: { title: 'Brand', dim: '[Brand.Brand]', datatype: 'text' } };
+        const dimension = new dimensions_js_1.DimensionalDimension('Brand', '', [new attributes_js_1.DimensionalAttribute('Brand', '')], [
+            new dimensions_js_1.DimensionalDimension('Brand', '[Brand.Brand]', [new attributes_js_1.DimensionalAttribute('Brand', '[Brand.Brand]')], [], 'textdimension'),
+        ], 'textdimension');
+        const jaql = dimension.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare date dimension jaql', () => {
+        const result = {
+            jaql: {
+                title: 'Date',
+                dim: '[Commerce.Date (Calendar)]',
+                level: 'years',
+                datatype: 'datetime',
+            },
+            format: { mask: { years: 'yyyy' } },
+        };
+        const dimension = new dimensions_js_1.DimensionalDateDimension('Date', '[Commerce.Date (Calendar)]');
+        const jaql = dimension.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must handle sort', () => {
+        const dimensionAscSort = new dimensions_js_1.DimensionalDimension('Brand', '[Brand.Brand]', [new attributes_js_1.DimensionalAttribute('Brand', '[Brand.Brand]')], [], 'textdimension', '', types_js_1.Sort.Ascending);
+        const dimensionDescSort = new dimensions_js_1.DimensionalDimension('Brand', '[Brand.Brand]', [new attributes_js_1.DimensionalAttribute('Brand', '[Brand.Brand]')], [], 'textdimension', '', types_js_1.Sort.Descending);
+        const jaqlAscSort = dimensionAscSort.jaql();
+        const jaqlDescSort = dimensionDescSort.jaql();
+        expect(jaqlAscSort.jaql.sort).toBe('asc');
+        expect(jaqlDescSort.jaql.sort).toBe('desc');
+    });
+});

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

@@ -0,0 +1,17 @@
+import { Element } from './interfaces.js';
+/**
+ * Generate an array of dimension model instances out of the given JSON array
+ *
+ * @param items - a JSON array  to create an elements from
+ * @returns a dimensional model instances
+ * @internal
+ */
+export declare function createAll(items: Array<any>): Element[];
+/**
+ * Generate a dimension model instance out of the given JSON object
+ *
+ * @param item - a JSON object to create an Element from
+ * @returns a dimensional model instance
+ * @internal
+ */
+export declare function create(item: any): Element | Element[];

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = exports.createAll = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+const types_js_1 = require("./types.js");
+const measures_js_1 = require("./measures/measures.js");
+const filters_js_1 = require("./filters/filters.js");
+const dimensions_js_1 = require("./dimensions.js");
+const attributes_js_1 = require("./attributes.js");
+const translatable_error_js_1 = require("../translation/translatable-error.js");
+/**
+ * Generate an array of dimension model instances out of the given JSON array
+ *
+ * @param items - a JSON array  to create an elements from
+ * @returns a dimensional model instances
+ * @internal
+ */
+function createAll(items) {
+    return items.map((e) => create(e));
+}
+exports.createAll = createAll;
+/**
+ * Generate a dimension model instance out of the given JSON object
+ *
+ * @param item - a JSON object to create an Element from
+ * @returns a dimensional model instance
+ * @internal
+ */
+function create(item) {
+    if (Array.isArray(item)) {
+        return createAll(item);
+    }
+    // todo: implement filter generation
+    if (types_js_1.MetadataTypes.isFilter(item)) {
+        return (0, filters_js_1.createFilter)(item);
+    }
+    else if (types_js_1.MetadataTypes.isMeasure(item)) {
+        return (0, measures_js_1.createMeasure)(item);
+    }
+    else if (types_js_1.MetadataTypes.isAttribute(item)) {
+        return (0, attributes_js_1.createAttribute)(item);
+    }
+    // dimension
+    else if (types_js_1.MetadataTypes.isDimension(item) ||
+        item.dim ||
+        item.id ||
+        item.type === 'dimension' ||
+        item.attributes ||
+        item.dimtype) {
+        return (0, dimensions_js_1.createDimension)(item);
+    }
+    throw new translatable_error_js_1.TranslatableError('errors.unsupportedDimensionalElement');
+}
+exports.create = create;