@sisense/sdk-data 0.11.3

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

@@ -0,0 +1,124 @@
+/**
+ * @param type
+ * @internal
+ */
+export const isInteger = (type) => {
+    return [
+        '__int4',
+        '__int8',
+        'int',
+        'tinyint',
+        'bigint',
+        'int2',
+        'int4',
+        'int8',
+        'smallint',
+        'mediumint',
+        'serial',
+        'integer',
+        'byteint',
+        'int64',
+    ].includes(type.toLowerCase());
+};
+/**
+ * @param type
+ * @internal
+ */
+export const isDecimal = (type) => {
+    return [
+        'basemeasure',
+        'calculatedmeasure',
+        'float',
+        'float4',
+        'float8',
+        'double precision',
+        'double',
+        'numeric',
+        'decimal',
+        'real',
+        'number',
+        'float64',
+    ].includes(type.toLowerCase());
+};
+/**
+ * @param type
+ * @internal
+ */
+export const isNumber = (type) => {
+    return isInteger(type) || isDecimal(type) || type === 'numeric-attribute';
+};
+/**
+ * @param type
+ * @internal
+ */
+export const isText = (type) => {
+    return [
+        'textdimension',
+        'string',
+        'varchar',
+        'text',
+        'ntext',
+        'char',
+        'character',
+        'character varying',
+        'smalltext',
+        'nchar',
+        'nvarchar',
+        'json',
+        'jsonb',
+        'object',
+        'text-attribute',
+    ].includes(type.toLowerCase());
+};
+/**
+ * @param type
+ * @internal
+ */
+export 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());
+};
+/**
+ * @param type
+ * @internal
+ */
+export const isBoolean = (type) => {
+    return ['bool', 'boolean', 'bit', 'logical'].includes(type.toLowerCase());
+};
+/**
+ * @param type
+ * @internal
+ */
+export const simpleColumnType = (type) => {
+    if (isNumber(type)) {
+        return 'number';
+    }
+    if (isDatetime(type)) {
+        return 'datetime';
+    }
+    if (isText(type)) {
+        return 'text';
+    }
+    if (isBoolean(type)) {
+        return 'boolean';
+    }
+    return 'text';
+};

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

@@ -0,0 +1,152 @@
+/**
+ * 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[];
+};

package/dist/dimensional-model/types.js

@@ -0,0 +1,284 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable max-lines */
+/*
+ * Types
+ */
+/**
+ * Different aggregation types
+ */
+export const AggregationTypes = {
+    /** Sum aggregation type */
+    Sum: 'sum',
+    /** Average aggregation type */
+    Average: 'avg',
+    /** Min aggregation type */
+    Min: 'min',
+    /** Max aggregation type */
+    Max: 'max',
+    /** Count aggregation type */
+    Count: 'count',
+    /** Count distinct aggregation type */
+    CountDistinct: 'countdistinct',
+    /** Median aggregation type */
+    Median: 'median',
+    /** Variance aggregation type */
+    Variance: 'var',
+    /** Standard deviation aggregation type */
+    StandardDeviation: 'stdev',
+};
+/**
+ * Different sort types.
+ */
+export var Sort;
+(function (Sort) {
+    /** No sort definition  */
+    Sort[Sort["None"] = 0] = "None";
+    /** Sort Ascending */
+    Sort[Sort["Ascending"] = 1] = "Ascending";
+    /** Sort Descending */
+    Sort[Sort["Descending"] = 2] = "Descending";
+})(Sort = Sort || (Sort = {}));
+/**
+ * Different metadata types
+ *
+ * @internal
+ */
+export const MetadataTypes = {
+    Measure: 'measure',
+    MeasureTemplate: 'measuretemplate',
+    BaseMeasure: 'basemeasure',
+    CalculatedMeasure: 'calculatedmeasure',
+    Dimension: 'dimension',
+    DateDimension: 'datedimension',
+    TextDimension: 'textdimension',
+    NumericDimension: 'numericdimension',
+    DateLevel: 'datelevel',
+    Attribute: 'attribute',
+    TextAttribute: 'text-attribute',
+    NumericAttribute: 'numeric-attribute',
+    Filter: 'filter',
+    DimensionFilter: 'dimensionfilter',
+    MeasureFilter: 'measurefilter',
+    /**
+     * 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) {
+        return (MetadataTypes.isMeasure(o) ||
+            MetadataTypes.isDimension(o) ||
+            MetadataTypes.isAttribute(o) ||
+            MetadataTypes.isFilter(o));
+    },
+    /**
+     * 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) {
+        if (!o) {
+            return false;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return type.toLowerCase() === MetadataTypes.MeasureTemplate;
+        }
+        return (o.agg === '*' ||
+            o.aggregation === '*' ||
+            (o.type && o.type.toLowerCase() === MetadataTypes.MeasureTemplate));
+    },
+    /**
+     * 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) {
+        if (!o) {
+            return false;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return type.toLowerCase() === MetadataTypes.BaseMeasure;
+        }
+        return (o.agg || o.aggregation) && o.attribute && !this.isMeasureTemplate(o);
+    },
+    /**
+     * 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) {
+        if (!o) {
+            return false;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return (type.toLowerCase() === MetadataTypes.Measure ||
+                type.toLowerCase() === MetadataTypes.BaseMeasure ||
+                type.toLowerCase() === MetadataTypes.MeasureTemplate ||
+                type.toLowerCase() === MetadataTypes.CalculatedMeasure);
+        }
+        return this.isBaseMeasure(o) || this.isCalculatedMeasure(o) || this.isMeasureTemplate(o);
+    },
+    /**
+     * 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) {
+        if (!o) {
+            return false;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return type.toLowerCase() === MetadataTypes.CalculatedMeasure;
+        }
+        return (o.expression || o.formula) && o.context;
+    },
+    /**
+     * 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) {
+        if (!o) {
+            return false;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return type.toLowerCase() === MetadataTypes.DateDimension;
+        }
+        return (o.dim || o.expression) && o.level;
+    },
+    /**
+     * 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) {
+        if (!o) {
+            return false;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return type.toLowerCase() === MetadataTypes.TextDimension;
+        }
+        return false;
+    },
+    /**
+     * 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) {
+        if (!o) {
+            return false;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return type.toLowerCase() === MetadataTypes.NumericDimension;
+        }
+        return false;
+    },
+    /**
+     * 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) {
+        if (typeof o === 'object') {
+            o = o.type;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return (type.toLowerCase() === MetadataTypes.DateDimension ||
+                type.toLowerCase() === MetadataTypes.Dimension ||
+                type.toLowerCase() === MetadataTypes.TextDimension ||
+                type.toLowerCase() === MetadataTypes.NumericDimension);
+        }
+        return false;
+    },
+    /**
+     * 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) {
+        if (typeof o === 'string') {
+            const type = o;
+            return (type.toLowerCase() === MetadataTypes.Attribute ||
+                type.toLowerCase() === MetadataTypes.TextAttribute ||
+                type.toLowerCase() === MetadataTypes.NumericAttribute ||
+                type.toLowerCase() === MetadataTypes.DateLevel);
+        }
+        if (o && o.type) {
+            return this.isAttribute(o.type);
+        }
+        return false;
+    },
+    /**
+     * 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) {
+        if (typeof o === 'object') {
+            o = o.type;
+        }
+        if (typeof o === 'string') {
+            const type = o;
+            return (type.toLowerCase() === MetadataTypes.Filter ||
+                type.toLowerCase() === MetadataTypes.DimensionFilter ||
+                type.toLowerCase() === MetadataTypes.MeasureFilter);
+        }
+        return false;
+    },
+};
+/**
+ * Levels for {@link DateDimension}
+ */
+export const DateLevels = {
+    Years: 'Years',
+    Quarters: 'Quarters',
+    Months: 'Months',
+    Weeks: 'Weeks',
+    Days: 'Days',
+    Hours: 'Hours',
+    MinutesRoundTo30: 'MinutesRoundTo30',
+    MinutesRoundTo15: 'MinutesRoundTo15',
+    AggHours: 'AggHours',
+    AggMinutesRoundTo30: 'AggMinutesRoundTo30',
+    AggMinutesRoundTo15: 'AggMinutesRoundTo15',
+    AggMinutesRoundTo1: 'AggMinutesRoundTo1',
+    /** @internal */
+    get all() {
+        return [
+            DateLevels.Years,
+            DateLevels.Quarters,
+            DateLevels.Months,
+            DateLevels.Weeks,
+            DateLevels.Days,
+            DateLevels.Hours,
+            DateLevels.MinutesRoundTo30,
+            DateLevels.MinutesRoundTo15,
+            DateLevels.AggHours,
+            DateLevels.AggMinutesRoundTo30,
+            DateLevels.AggMinutesRoundTo15,
+            DateLevels.AggMinutesRoundTo1,
+        ];
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @packageDocumentation
+ * @beta
+ */
+export * from './interfaces.js';
+export * from './dimensional-model/types.js';
+export * from './dimensional-model/interfaces.js';
+export * from './dimensional-model/base.js';
+export * from './dimensional-model/data-model.js';
+export * from './dimensional-model/attributes.js';
+export * from './dimensional-model/dimensions.js';
+export * from './dimensional-model/factory.js';
+export * from './dimensional-model/filters/filters.js';
+/**
+ * Functions to create date, text, or numeric filters on certain data columns
+ *
+ * They are similar to [Dashboard and Widget Filters](https://docs.sisense.com/main/SisenseLinux/build-formulas.htm) in Sisense.
+ *
+ * Filters created with these functions can be used in the data options of UI components such as
+ * {@link @sisense/sdk-ui!ChartProps | Chart}, {@link @sisense/sdk-ui!ChartWidgetProps | ChartWidget},
+ * and {@link @sisense/sdk-ui!ExecuteQueryProps | ExecuteQuery}.
+ *
+ * @example
+ * Example of using the component to query the `Sample ECommerce` data source.
+ * Function `filters.greaterThan` is used to create a filter on `Revenue` to get values
+ * greater than 1000.
+ * ```tsx
+ * <ExecuteQuery
+ *   dataSource={DM.DataSource}
+ *   dimensions={[DM.Commerce.AgeRange]}
+ *   measures={[measures.sum(DM.Commerce.Revenue)]}
+ *   filters={[filters.greaterThan(DM.Commerce.Revenue, 1000)]}
+ * >
+ * {
+ *   (data) => {
+ *     if (data) {
+ *       console.log(data);
+ *       return <div>{`Total Rows: ${data.rows.length}`}</div>;
+ *     }
+ *   }
+ * }
+ * </ExecuteQuery>
+ * ```
+ */
+export * as filters from './dimensional-model/filters/factory.js';
+export * from './dimensional-model/measures/measures.js';
+/**
+ * Functions to build formulas that aggregate, summarize, and accumulate data,
+ * plus show changes in data over time.
+ *
+ * They are similar to [Formulas](https://docs.sisense.com/main/SisenseLinux/build-formulas.htm) in Sisense.
+ *
+ * Measures created with these functions can be used in the data options of UI components such as
+ * {@link @sisense/sdk-ui!ChartProps | Chart}, {@link @sisense/sdk-ui!ChartWidgetProps | ChartWidget},
+ * and {@link @sisense/sdk-ui!ExecuteQueryProps | ExecuteQuery}.
+ *
+ * @example
+ * Example of using the component to query the `Sample ECommerce` data source.
+ * Function `measures.sum` is used to create a measure that sums the `Revenue` column.
+ * ```tsx
+ * <ExecuteQuery
+ *   dataSource={DM.DataSource}
+ *   dimensions={[DM.Commerce.AgeRange]}
+ *   measures={[measures.sum(DM.Commerce.Revenue)]}
+ *   filters={[filters.greaterThan(DM.Commerce.Revenue, 1000)]}
+ * >
+ * {
+ *   (data) => {
+ *     if (data) {
+ *       console.log(data);
+ *       return <div>{`Total Rows: ${data.rows.length}`}</div>;
+ *     }
+ *   }
+ * }
+ * </ExecuteQuery>
+ * ```
+ */
+export * as measures from './dimensional-model/measures/factory.js';
+export * from './dimensional-model/simple-column-types.js';