@sisense/sdk-data 1.10.1 → 1.12.0

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

@@ -0,0 +1,79 @@
+"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 measures_js_1 = require("./measures.js");
+const attributes_js_1 = require("../attributes.js");
+const types_js_1 = require("../types.js");
+describe('Measures jaql preparations', () => {
+    it('must prepare simple measure jaql', () => {
+        const result = {
+            jaql: { title: 'Cost', agg: 'sum', dim: '[Commerce.Cost]', datatype: 'numeric' },
+        };
+        const measure = new measures_js_1.DimensionalBaseMeasure('Cost', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), 'sum');
+        const jaql = measure.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare constant as jaql', () => {
+        const result = {
+            jaql: {
+                title: '0',
+                formula: '0',
+                context: {},
+            },
+        };
+        const measure = new measures_js_1.DimensionalCalculatedMeasure('0', '0', {});
+        const jaql = measure.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare calculated measure jaql', () => {
+        const result = {
+            jaql: {
+                title: 'sum([Cost] + [Total Revenue])',
+                formula: 'sum([M1] + [M2])',
+                context: {
+                    '[M1]': { title: 'Revenue', agg: 'sum', dim: '[Commerce.Revenue]', datatype: 'numeric' },
+                    '[M2]': { title: 'Cost', agg: 'sum', dim: '[Commerce.Cost]', datatype: 'numeric' },
+                },
+            },
+        };
+        const measure = new measures_js_1.DimensionalCalculatedMeasure('sum([Cost] + [Total Revenue])', 'sum([M1] + [M2])', {
+            '[M1]': new measures_js_1.DimensionalBaseMeasure('Revenue', new attributes_js_1.DimensionalAttribute('[Commerce.Revenue]', '[Commerce.Revenue]', 'numeric-attribute'), 'sum'),
+            '[M2]': new measures_js_1.DimensionalBaseMeasure('Cost', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'), 'sum'),
+        });
+        const jaql = measure.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+    it('must prepare template measure jaql', () => {
+        const result = {
+            jaql: { title: 'sum CommerceCost', agg: 'sum', dim: '[Commerce.Cost]', datatype: 'numeric' },
+        };
+        const measure = new measures_js_1.DimensionalMeasureTemplate('Count', new attributes_js_1.DimensionalAttribute('[Commerce.Cost]', '[Commerce.Cost]', 'numeric-attribute'));
+        const jaql = measure.jaql();
+        expect(jaql).toStrictEqual(result);
+    });
+});
+describe('Measures aggregation transformations', () => {
+    const aggregationTypesMapping = {
+        [types_js_1.AggregationTypes.Sum]: 'sum',
+        [types_js_1.AggregationTypes.Average]: 'avg',
+        [types_js_1.AggregationTypes.Min]: 'min',
+        [types_js_1.AggregationTypes.Max]: 'max',
+        [types_js_1.AggregationTypes.Count]: 'countduplicates',
+        [types_js_1.AggregationTypes.CountDistinct]: 'count',
+        [types_js_1.AggregationTypes.Median]: 'median',
+        [types_js_1.AggregationTypes.Variance]: 'var',
+        [types_js_1.AggregationTypes.StandardDeviation]: 'stdev',
+    };
+    it('should correctly extract aggregation from jaql', () => {
+        Object.entries(aggregationTypesMapping).forEach(([aggType, jaqlAggType]) => {
+            expect(measures_js_1.DimensionalBaseMeasure.aggregationFromJAQL(jaqlAggType)).toEqual(aggType);
+        });
+    });
+    it('should correctly convert aggregation to jaql aggregation type', () => {
+        Object.entries(aggregationTypesMapping).forEach(([aggType, jaqlAggType]) => {
+            expect(measures_js_1.DimensionalBaseMeasure.aggregationToJAQL(aggType)).toEqual(jaqlAggType);
+        });
+    });
+});

package/dist/cjs/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;

package/dist/cjs/dimensional-model/simple-column-types.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.simpleColumnType = exports.isBoolean = exports.isDatetime = exports.isText = exports.isNumber = exports.isDecimal = exports.isInteger = void 0;
+/**
+ * @param type
+ * @internal
+ */
+const isInteger = (type) => {
+    return [
+        '__int4',
+        '__int8',
+        'int',
+        'tinyint',
+        'bigint',
+        'int2',
+        'int4',
+        'int8',
+        'smallint',
+        'mediumint',
+        'serial',
+        'integer',
+        'byteint',
+        'int64',
+    ].includes(type.toLowerCase());
+};
+exports.isInteger = isInteger;
+/**
+ * @param type
+ * @internal
+ */
+const isDecimal = (type) => {
+    return [
+        'basemeasure',
+        'calculatedmeasure',
+        'float',
+        'float4',
+        'float8',
+        'double precision',
+        'double',
+        'numeric',
+        'decimal',
+        'real',
+        'number',
+        'float64',
+    ].includes(type.toLowerCase());
+};
+exports.isDecimal = isDecimal;
+/**
+ * @param type
+ * @internal
+ */
+const isNumber = (type) => {
+    return (0, exports.isInteger)(type) || (0, exports.isDecimal)(type) || type === 'numeric-attribute';
+};
+exports.isNumber = isNumber;
+/**
+ * @param type
+ * @internal
+ */
+const isText = (type) => {
+    return [
+        'textdimension',
+        'string',
+        'varchar',
+        'text',
+        'ntext',
+        'char',
+        'character',
+        'character varying',
+        'smalltext',
+        'nchar',
+        'nvarchar',
+        'json',
+        'jsonb',
+        'object',
+        'text-attribute',
+    ].includes(type.toLowerCase());
+};
+exports.isText = isText;
+/**
+ * @param type
+ * @internal
+ */
+const isDatetime = (type) => {
+    return [
+        'datelevel',
+        'date',
+        'time',
+        'datetime',
+        'timestamp without time zone',
+        'timestamp',
+        'timestamp with time zone',
+        'timestamp(6)',
+        'timestamp_tz',
+        'timestamp_ntz',
+        'timestamp_ltz',
+        'timestampltz',
+        'timestampntz',
+        'timestamptz',
+        'datetime64[ns]',
+        'timewithtimezone',
+        'timestampwithtimezone',
+        'timestamp_with_timezone',
+    ].includes(type.toLowerCase());
+};
+exports.isDatetime = isDatetime;
+/**
+ * @param type
+ * @internal
+ */
+const isBoolean = (type) => {
+    return ['bool', 'boolean', 'bit', 'logical'].includes(type.toLowerCase());
+};
+exports.isBoolean = isBoolean;
+/**
+ * @param type
+ * @internal
+ */
+const simpleColumnType = (type) => {
+    if ((0, exports.isNumber)(type)) {
+        return 'number';
+    }
+    if ((0, exports.isDatetime)(type)) {
+        return 'datetime';
+    }
+    if ((0, exports.isText)(type)) {
+        return 'text';
+    }
+    if ((0, exports.isBoolean)(type)) {
+        return 'boolean';
+    }
+    return 'text';
+};
+exports.simpleColumnType = simpleColumnType;

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

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

package/dist/cjs/dimensional-model/simple-column-types.test.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const simple_column_types_js_1 = require("./simple-column-types.js");
+const typeMap = {
+    number: [
+        // INTEGER
+        '__int4',
+        '__int8',
+        'int',
+        'tinyint',
+        'bigint',
+        'int2',
+        'int4',
+        'int8',
+        'smallint',
+        'mediumint',
+        'serial',
+        'integer',
+        'byteint',
+        'int64',
+        // DECIMAL
+        'basemeasure',
+        'calculatedmeasure',
+        'float',
+        'float4',
+        'float8',
+        'double precision',
+        'double',
+        'numeric',
+        'decimal',
+        'real',
+        'number',
+        'float64',
+        // OTHER
+        'numeric-attribute',
+    ],
+    text: [
+        'textdimension',
+        'string',
+        'varchar',
+        'text',
+        'ntext',
+        'char',
+        'character',
+        'character varying',
+        'smalltext',
+        'nchar',
+        'nvarchar',
+        'json',
+        'jsonb',
+        'object',
+        'text-attribute',
+        'RANDOM_TEXT',
+    ],
+    datetime: [
+        'datelevel',
+        'date',
+        'time',
+        'datetime',
+        'timestamp without time zone',
+        'timestamp',
+        'timestamp with time zone',
+        'timestamp(6)',
+        'timestamp_tz',
+        'timestamp_ntz',
+        'timestamp_ltz',
+        'timestampltz',
+        'timestampntz',
+        'timestamptz',
+        'datetime64[ns]',
+        'timewithtimezone',
+        'timestampwithtimezone',
+        'timestamp_with_timezone',
+    ],
+    boolean: ['bool', 'boolean', 'bit', 'logical'],
+};
+describe('simpleColumnType', () => {
+    it('should return correct type', () => {
+        Object.entries(typeMap).forEach(([outputType, inputTypes]) => {
+            inputTypes.forEach((inputType) => {
+                expect((0, simple_column_types_js_1.simpleColumnType)(inputType)).toBe(outputType);
+            });
+        });
+    });
+});

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

@@ -0,0 +1,256 @@
+import { type ConditionFilterJaql } from './filters/utils/types.js';
+/**
+ * Different aggregation types
+ */
+export declare const AggregationTypes: {
+    /** Sum aggregation type */
+    Sum: string;
+    /** Average aggregation type */
+    Average: string;
+    /** Min aggregation type */
+    Min: string;
+    /** Max aggregation type */
+    Max: string;
+    /** Count aggregation type */
+    Count: string;
+    /** Count distinct aggregation type */
+    CountDistinct: string;
+    /** Median aggregation type */
+    Median: string;
+    /** Variance aggregation type */
+    Variance: string;
+    /** Standard deviation aggregation type */
+    StandardDeviation: string;
+};
+/**
+ * Different sort types.
+ */
+export declare enum Sort {
+    /** No sort definition  */
+    None = 0,
+    /** Sort Ascending */
+    Ascending = 1,
+    /** Sort Descending */
+    Descending = 2
+}
+/**
+ * Different metadata types
+ *
+ * @internal
+ */
+export declare const MetadataTypes: {
+    Measure: string;
+    MeasureTemplate: string;
+    BaseMeasure: string;
+    CalculatedMeasure: string;
+    Dimension: string;
+    DateDimension: string;
+    TextDimension: string;
+    NumericDimension: string;
+    DateLevel: string;
+    Attribute: string;
+    TextAttribute: string;
+    NumericAttribute: string;
+    Filter: string;
+    DimensionFilter: string;
+    MeasureFilter: string;
+    /**
+     * Checks whether the given object or type is a metadata element
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a metadata element
+     */
+    isMetadata(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a measure template
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a measure template
+     */
+    isMeasureTemplate(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a base measure
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a base measure
+     */
+    isBaseMeasure(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a measure - of any type
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a measure - of any type
+     */
+    isMeasure(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a calculated measure
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a calculated measure
+     */
+    isCalculatedMeasure(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a date dimension
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a date dimension
+     */
+    isDateDimension(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a text dimension
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a text dimension
+     */
+    isTextDimension(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a numeric dimension
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a numeric dimension
+     */
+    isNumericDimension(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a dimension - of any type
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a dimension - of any type
+     */
+    isDimension(o: any): boolean;
+    /**
+     * Checks whether the given object or type is an attribute - of any type
+     *
+     * @param o - object to check
+     * @returns true if the object or type is an attribute - of any type
+     */
+    isAttribute(o: any): boolean;
+    /**
+     * Checks whether the given object or type is a filter
+     *
+     * @param o - object to check
+     * @returns true if the object or type is a filter
+     */
+    isFilter(o: any): boolean;
+};
+/**
+ * Levels for {@link DateDimension}
+ */
+export declare const DateLevels: {
+    Years: string;
+    Quarters: string;
+    Months: string;
+    Weeks: string;
+    Days: string;
+    Hours: string;
+    MinutesRoundTo30: string;
+    MinutesRoundTo15: string;
+    AggHours: string;
+    AggMinutesRoundTo30: string;
+    AggMinutesRoundTo15: string;
+    AggMinutesRoundTo1: string;
+    /** @internal */
+    readonly all: string[];
+};
+/** @internal */
+export declare enum DataType {
+    TEXT = "text",
+    NUMERIC = "numeric",
+    DATETIME = "datetime"
+}
+/** @internal */
+export declare enum JaqlSortDirection {
+    ASC = "asc",
+    DESC = "desc"
+}
+/** @internal */
+export declare type Jaql = BaseJaql | FormulaJaql | FilterJaql | PivotJaql;
+/** @internal */
+export declare type PivotJaql = (BaseJaql | FormulaJaql) & {
+    sortDetails?: {
+        dir: JaqlSortDirection;
+        field: number;
+        measurePath?: Record<string, string> | null;
+    };
+    subtotalAgg?: 'sum' | 'min' | 'max' | 'avg' | 'median';
+};
+/** @internal */
+export declare type BaseJaql = {
+    agg?: string;
+    datatype: `${DataType}`;
+    dim: string;
+    table: string;
+    column: string;
+    title: string;
+    level?: 'years' | 'quarters' | 'months' | 'weeks' | 'minutes' | 'days';
+    sort?: `${JaqlSortDirection}`;
+    in?: {
+        selected?: {
+            jaql: FilterJaql;
+        };
+    };
+};
+/** @internal */
+export declare type FormulaID = string;
+/** @internal */
+export declare type FormulaContext = BaseJaql | FormulaJaql | FilterJaql;
+/** @internal */
+export declare type FormulaJaql = {
+    type?: 'measure';
+    sort?: JaqlSortDirection;
+    title: string;
+    formula: string;
+    context?: Record<FormulaID, FormulaContext>;
+};
+/** @internal */
+export declare type BaseFilter = IncludeAllFilter | IncludeMembersFilter | ExcludeMembersFilter | JaqlNumericFilter | ConditionFilterJaql | AndFilter<JaqlNumericFilter | ConditionFilterJaql> | OrFilter<JaqlNumericFilter | ConditionFilterJaql>;
+/** @internal */
+export declare type BackgroundFilter = BaseFilter & {
+    level?: 'string';
+};
+/** @internal */
+export declare type IncludeAllFilter = {
+    all: true;
+};
+/** @internal */
+export declare type IncludeMembersFilter = {
+    members: string[];
+};
+/** @internal */
+export declare type ExcludeMembersFilter = {
+    exclude: {
+        members: string[];
+    };
+};
+/** @internal */
+export declare type TurnOffMembersFilter = ExcludeMembersFilter & {
+    turnedOff: boolean;
+};
+/** @internal */
+export declare type FilterJaql = BaseJaql & {
+    filter: BaseFilter & {
+        filter?: BackgroundFilter | TurnOffMembersFilter;
+    };
+};
+declare type NumericFilterValue = number | FormulaJaql;
+/** @internal */
+export declare type JaqlNumericFilter = {
+    equals?: NumericFilterValue;
+    doesntEqual?: NumericFilterValue;
+    toNotEqual?: NumericFilterValue;
+    to?: NumericFilterValue;
+    fromNotEqual?: NumericFilterValue;
+    from?: NumericFilterValue;
+    '='?: NumericFilterValue;
+    '<'?: NumericFilterValue;
+    '>'?: NumericFilterValue;
+    '>='?: NumericFilterValue;
+    '<='?: NumericFilterValue;
+};
+declare type AndFilter<FilterItem> = {
+    and: FilterItem[];
+};
+/** @internal */
+export declare type OrFilter<FilterItem> = {
+    or: FilterItem[];
+};
+export {};