@sisense/sdk-data 1.19.0 → 1.21.0

package/dist/dimensional-model/attributes.js

@@ -9,8 +9,8 @@ export const jaqlSimpleColumnType = (datatype) => simpleColumnType(datatype).rep
  * @internal
  */
 export class DimensionalAttribute extends DimensionalElement {
-    constructor(name, expression, type, desc, sort) {
-        super(name, type || MetadataTypes.Attribute, desc);
+    constructor(name, expression, type, desc, sort, dataSource) {
+        super(name, type || MetadataTypes.Attribute, desc, dataSource);
         this._sort = Sort.None;
         this.expression = expression;
         this._sort = sort || Sort.None;
@@ -72,8 +72,8 @@ export class DimensionalAttribute extends DimensionalElement {
  * @internal
  */
 export class DimensionalLevelAttribute extends DimensionalAttribute {
-    constructor(l, expression, granularity, format, desc, sort) {
-        super(l, expression, MetadataTypes.DateLevel, desc, sort);
+    constructor(l, expression, granularity, format, desc, sort, dataSource) {
+        super(l, expression, MetadataTypes.DateLevel, desc, sort, dataSource);
         this._format = format;
         this.granularity = granularity;
     }

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

@@ -1,4 +1,5 @@
 import { Element } from './interfaces.js';
+import { JaqlDataSource } from './types.js';
 /**
  * @internal
  */
@@ -7,12 +8,20 @@ export declare abstract class DimensionalElement implements Element {
      * @internal
      */
     private _name;
+    /**
+     * @internal
+     */
+    private readonly _dataSource;
     /**
      * Defines the element's name
      */
     get name(): string;
     set name(value: string);
-    constructor(name: string, type: string, desc?: string);
+    /**
+     * Defines the element's data source
+     */
+    get dataSource(): JaqlDataSource;
+    constructor(name: string, type: string, desc?: string, dataSource?: JaqlDataSource);
     /**
      * gets the element's description
      */

package/dist/dimensional-model/base.js

@@ -2,10 +2,13 @@
  * @internal
  */
 export class DimensionalElement {
-    constructor(name, type, desc) {
+    constructor(name, type, desc, dataSource) {
         this._name = name;
         this.type = type;
         this.description = desc || '';
+        if (dataSource) {
+            this._dataSource = dataSource;
+        }
     }
     /**
      * Defines the element's name
@@ -16,6 +19,12 @@ export class DimensionalElement {
     set name(value) {
         this._name = value;
     }
+    /**
+     * Defines the element's data source
+     */
+    get dataSource() {
+        return this._dataSource;
+    }
     /**
      * Gets a serializable representation of the element
      */
@@ -24,6 +33,7 @@ export class DimensionalElement {
             name: this.name,
             type: this.type,
             desc: this.description,
+            dataSource: this.dataSource,
             __serializable: 'DimensionalElement',
         };
     }

package/dist/dimensional-model/filters/filters.js

@@ -160,6 +160,10 @@ class AbstractFilter extends DimensionalElement {
             };
         }
         result.jaql.filter = this.filterJaql();
+        // prioritize attribute dataSource for the use case of multi-source dashboard
+        if (this.attribute.dataSource) {
+            result.jaql.datasource = this.attribute.dataSource;
+        }
         if (this.isScope) {
             result.panel = 'scope';
         }

package/dist/dimensional-model/filters/utils/attribute-measure-util.d.ts

@@ -1,6 +1,6 @@
-import { Attribute, BaseMeasure, LevelAttribute } from '../../interfaces.js';
+import { Attribute, BaseMeasure, CalculatedMeasure, LevelAttribute } from '../../interfaces.js';
 import { FilterJaql } from '../../types.js';
-import { FilterJaqlInternal, RankingFilterJaql } from './types.js';
+import { CustomFormulaJaql, FilterJaqlInternal, JaqlDataSource, RankingFilterJaql } from './types.js';
 /**
  * Creates an attribute or level attribute from the provided parameters
  *
@@ -10,9 +10,10 @@ import { FilterJaqlInternal, RankingFilterJaql } from './types.js';
  * @param level - Date level
  * @param dataType - Data type
  * @param title - Attribute title
+ * @param dataSource - Jaql data source
  * @returns attribute or level attribute
  */
-export declare const createAttributeHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, title?: string) => Attribute | LevelAttribute;
+export declare const createAttributeHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, title?: string, dataSource?: JaqlDataSource) => Attribute | LevelAttribute;
 /**
  * Creates an attribute or level attribute from the provided filter JAQL object
  *
@@ -29,9 +30,18 @@ export declare const createAttributeFromFilterJaql: (jaql: FilterJaql | FilterJa
  * @param level - Date level
  * @param dataType - Data type
  * @param agg - Aggregation function
+ * @param title - Measure title
+ * @param dataSource - data source provided in JAQL
  * @returns measure
  */
-export declare const createMeasureHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, agg: string, title?: string) => BaseMeasure;
+export declare const createMeasureHelper: (dim: string, table: string | undefined, column: string, level: string | undefined, dataType: string, agg: string, title?: string, dataSource?: JaqlDataSource) => BaseMeasure;
+/**
+ * Creates a calculated measure from the provided filter JAQL object
+ *
+ * @param jaql - custom formula jaql
+ * @returns calculated measure
+ */
+export declare const createCalculatedMeasureFromJaql: (jaql: CustomFormulaJaql) => CalculatedMeasure;
 /**
  * Creates a measure from the provided filter JAQL object
  *
@@ -45,4 +55,4 @@ export declare const createMeasureFromFilterJaql: (jaql: FilterJaqlInternal) =>
  * @param jaql - Ranking filter Jaql object
  * @returns Measure
  */
-export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql) => BaseMeasure;
+export declare const createMeasureFromRankingFilterJaql: (jaql: RankingFilterJaql | CustomFormulaJaql) => BaseMeasure | CalculatedMeasure;

package/dist/dimensional-model/filters/utils/attribute-measure-util.js

@@ -2,6 +2,7 @@ import { DimensionalAttribute, DimensionalLevelAttribute, normalizeAttributeName
 import { isNumber } from '../../simple-column-types.js';
 import { MetadataTypes } from '../../types.js';
 import * as measureFactory from '../../measures/factory.js';
+import { transformCustomFormulaJaql } from '../../measures/factory.js';
 const DATA_MODEL_MODULE_NAME = 'DM';
 /**
  * Creates an attribute or level attribute from the provided parameters
@@ -12,22 +13,23 @@ const DATA_MODEL_MODULE_NAME = 'DM';
  * @param level - Date level
  * @param dataType - Data type
  * @param title - Attribute title
+ * @param dataSource - Jaql data source
  * @returns attribute or level attribute
  */
-export const createAttributeHelper = (dim, table, column, level, dataType, title) => {
+export const createAttributeHelper = (dim, table, column, level, dataType, title, dataSource) => {
     // if table is undefined, extract it from dim
     const dimTable = table !== null && table !== void 0 ? table : dim.slice(1, -1).split('.')[0];
     if (level) {
         const dateLevel = DimensionalLevelAttribute.translateJaqlToGranularity({ level });
         const format = DimensionalLevelAttribute.getDefaultFormatForGranularity(dateLevel);
-        const levelAttribute = new DimensionalLevelAttribute(title !== null && title !== void 0 ? title : column, dim, dateLevel, format);
+        const levelAttribute = new DimensionalLevelAttribute(title !== null && title !== void 0 ? title : column, dim, dateLevel, format, undefined, undefined, dataSource);
         levelAttribute.composeCode = normalizeAttributeName(dimTable, column, level, DATA_MODEL_MODULE_NAME);
         return levelAttribute;
     }
     const attributeType = isNumber(dataType)
         ? MetadataTypes.NumericAttribute
         : MetadataTypes.TextAttribute;
-    const attribute = new DimensionalAttribute(title !== null && title !== void 0 ? title : column, dim, attributeType);
+    const attribute = new DimensionalAttribute(title !== null && title !== void 0 ? title : column, dim, attributeType, undefined, undefined, dataSource);
     attribute.composeCode = normalizeAttributeName(dimTable, column, undefined, DATA_MODEL_MODULE_NAME);
     return attribute;
 };
@@ -38,7 +40,8 @@ export const createAttributeHelper = (dim, table, column, level, dataType, title
  * @returns attribute or level attribute
  */
 export const createAttributeFromFilterJaql = (jaql) => {
-    return createAttributeHelper(jaql.dim, jaql.table, jaql.column, jaql.level, jaql.datatype, jaql.title);
+    const { dim, table, column, level, datatype, title, datasource: dataSource } = jaql;
+    return createAttributeHelper(dim, table, column, level, datatype, title, dataSource);
 };
 /**
  * Creates a measure from the provided parameters
@@ -49,14 +52,29 @@ export const createAttributeFromFilterJaql = (jaql) => {
  * @param level - Date level
  * @param dataType - Data type
  * @param agg - Aggregation function
+ * @param title - Measure title
+ * @param dataSource - data source provided in JAQL
  * @returns measure
  */
-export const createMeasureHelper = (dim, table, column, level, dataType, agg, title) => {
-    const attribute = createAttributeHelper(dim, table, column, level, dataType, title);
+export const createMeasureHelper = (dim, table, column, level, dataType, agg, title, dataSource) => {
+    const attribute = createAttributeHelper(dim, table, column, level, dataType, title, dataSource);
     const measure = measureFactory.aggregate(attribute, agg);
     measure.composeCode = `measureFactory.${agg}(${attribute.composeCode})`;
     return measure;
 };
+/**
+ * Creates a calculated measure from the provided filter JAQL object
+ *
+ * @param jaql - custom formula jaql
+ * @returns calculated measure
+ */
+export const createCalculatedMeasureFromJaql = (jaql) => {
+    const measure = transformCustomFormulaJaql(jaql);
+    // TBD (SNS-108945)
+    // Handle preparation of 'composeCode' for formula
+    measure.composeCode = `'Formula code to be implemented'`;
+    return measure;
+};
 /**
  * Creates a measure from the provided filter JAQL object
  *
@@ -64,10 +82,10 @@ export const createMeasureHelper = (dim, table, column, level, dataType, agg, ti
  * @returns Measure
  */
 export const createMeasureFromFilterJaql = (jaql) => {
-    const { dim, table, column, title, level, datatype: dataType, agg } = jaql;
+    const { dim, table, column, title, level, datatype: dataType, agg, datasource: dataSource, } = jaql;
     if (!agg)
         return undefined;
-    return createMeasureHelper(dim, table, column, level, dataType, agg, title);
+    return createMeasureHelper(dim, table, column, level, dataType, agg, title, dataSource);
 };
 /**
  * Creates a measure from the provided ranking filter JAQL object
@@ -76,6 +94,8 @@ export const createMeasureFromFilterJaql = (jaql) => {
  * @returns Measure
  */
 export const createMeasureFromRankingFilterJaql = (jaql) => {
+    if ('formula' in jaql)
+        return createCalculatedMeasureFromJaql(jaql);
     const { dim, table, column, level, datatype: dataType, agg } = jaql;
     return createMeasureHelper(dim, table, column, level, dataType, agg);
 };

package/dist/dimensional-model/filters/utils/condition-filter-util.js

@@ -85,12 +85,14 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
     const conditionType = getSelectedConditionOption(conditionFilterJaql);
     switch (conditionType) {
         case ConditionFilterType.BOTTOM:
-            if (conditionFilterJaql.by && 'agg' in conditionFilterJaql.by) {
+            if (conditionFilterJaql.by) {
                 return withComposeCode(filterFactory.bottomRanking)(attribute, createMeasureFromRankingFilterJaql(conditionFilterJaql.by), conditionFilterJaql[ConditionFilterType.BOTTOM], guid);
             }
             break;
         case ConditionFilterType.EQUALS:
             return withComposeCode(filterFactory.equals)(attribute, conditionFilterJaql[ConditionFilterType.EQUALS], guid);
+        case ConditionFilterType.DOESNT_EQUAL:
+            return withComposeCode(filterFactory.doesntEqual)(attribute, conditionFilterJaql[ConditionFilterType.DOESNT_EQUAL], guid);
         case ConditionFilterType.GREATER_THAN:
             return withComposeCode(filterFactory.greaterThan)(attribute, conditionFilterJaql[ConditionFilterType.GREATER_THAN], guid);
         case ConditionFilterType.GREATER_THAN_OR_EQUAL:

package/dist/dimensional-model/filters/utils/filter-from-jaql-util.js

@@ -177,7 +177,7 @@ export const createFilterFromJaqlInternal = (jaql, guid) => {
     }
     catch (e) {
         // if a filter type is untranslatable, fall back to the generic pass-through JAQL filter
-        // console.error(e);
+        console.debug('Fall back to generic pass-through JAQL filter due to filter translation error:', e);
     }
     return createGenericFilter(jaql, guid);
 };

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

@@ -1,15 +1,21 @@
+import { FormulaContext, FormulaJaql } from '../../types.js';
 declare type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
 }[Keys];
 export declare type JaqlContext = Record<string, Partial<FilterJaqlInternal>>;
 export declare type Id = string;
-export declare type Datasource = {
-    address: Id;
-    database: string;
-    id: string;
+/**
+ * Data source as specified in the jaql
+ *
+ * @internal
+ */
+export declare type JaqlDataSource = {
+    address?: Id;
+    database?: string;
+    id?: string;
     title: string;
     live?: boolean;
-    fullname: string;
+    fullname?: string;
     lastBuildTime?: string;
     revisionId?: string;
 };
@@ -56,6 +62,9 @@ export interface RangeFilterJaql extends BaseFilterJaql {
     to?: string | number;
     multiSelection?: boolean;
 }
+export declare type CustomFormulaJaql = (FormulaJaql & {
+    context?: FormulaJaql | FormulaContext;
+}) | FormulaContext;
 export declare type RankingFilterJaql = {
     agg: string;
     column: string;
@@ -120,7 +129,7 @@ export declare enum DatetimeLevel {
 export declare type FilterJaqlInternal = {
     title: string;
     column: string;
-    datasource?: Datasource;
+    datasource?: JaqlDataSource;
     datatype: string;
     dim: string;
     dimension?: string;

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

@@ -1,5 +1,5 @@
 import { DataSource } from '../interfaces.js';
-import { Sort } from './types.js';
+import { JaqlDataSource, Sort } from './types.js';
 /**
  * @internal
  */
@@ -35,6 +35,12 @@ export interface Element {
      * @internal
      */
     readonly id: string;
+    /**
+     * Data Source
+     *
+     * @internal
+     */
+    readonly dataSource?: JaqlDataSource;
     /**
      * Gets a serializable representation of the element.
      *
@@ -440,6 +446,7 @@ export declare type FilterRelationsJaqlNode = FilterRelationsJaqlIdNode | Filter
 /**
  * Representation of filter logical relations (AND/OR)
  *
+ * @privateRemarks
  * Unlike {@link FilterRelationsModel} or {@link FilterRelationsJaql},
  * this interface contains filter objects, not just id nodes
  */
@@ -468,11 +475,18 @@ export interface FilterRelationsJaql {
     right: FilterRelationsJaqlNode;
     operator: 'AND' | 'OR';
 }
-/** A node of a {@link FilterRelationsJaql} tree that represents a filter */
+/**
+ * A node of a {@link FilterRelationsJaql} tree that represents a filter
+ *
+ * @internal
+ */
 export declare type FilterRelationsJaqlIdNode = {
     instanceid: string;
 };
-/** A node of a {@link FilterRelationsModel} tree that represents a filter */
+/**
+ * A node of a {@link FilterRelationsModel} tree that represents a filter
+ * @internal
+ */
 export declare type FilterRelationsModelIdNode = {
     instanceId: string;
 };

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

@@ -1,5 +1,6 @@
 import { Attribute, Measure, Filter, CalculatedMeasure, BaseMeasure, CustomFormulaContext } from '../interfaces.js';
 import { ForecastFormulaOptions, TrendFormulaOptions } from '../../interfaces.js';
+import { CustomFormulaJaql } from '../filters/utils/types.js';
 /**
  * Defines the different numeric operators that can be used with numeric filters
  *
@@ -32,6 +33,16 @@ export declare const RankingSortTypes: {
     Ascending: string;
     Descending: string;
 };
+/**
+ * Transforms a custom formula jaql into a calculated measure instance.
+ *
+ * As custom formulas can be nested, the function performs a recursive transformation via a helper function.
+ *
+ * @param jaql - Custom formula jaql
+ * @returns Calculated measure instance
+ * @internal
+ */
+export declare function transformCustomFormulaJaql(jaql: CustomFormulaJaql): CalculatedMeasure;
 /**
  * Creates a calculated measure for a valid custom formula built from [base functions](/guides/sdk/reference/functions.html#measured-value-functions).
  *
@@ -78,7 +89,6 @@ export declare const RankingSortTypes: {
  *   },
  * );
  * ```
- *
  * @param title - Title of the measure to be displayed in legend
  * @param formula - Formula to be used for the measure
  * @param context - Formula context as a map of strings to attributes, measures, or filters

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

@@ -103,8 +103,9 @@ function transformFormulaJaqlHelper(jaql) {
  *
  * @param jaql - Custom formula jaql
  * @returns Calculated measure instance
+ * @internal
  */
-function transformCustomFormulaJaql(jaql) {
+export function transformCustomFormulaJaql(jaql) {
     var _a;
     const isFormulaJaql = 'formula' in jaql;
     if (!isFormulaJaql) {
@@ -160,7 +161,6 @@ function transformCustomFormulaJaql(jaql) {
  *   },
  * );
  * ```
- *
  * @param title - Title of the measure to be displayed in legend
  * @param formula - Formula to be used for the measure
  * @param context - Formula context as a map of strings to attributes, measures, or filters

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

@@ -1,4 +1,9 @@
-import { type ConditionFilterJaql } from './filters/utils/types.js';
+import { JaqlDataSource, type ConditionFilterJaql } from './filters/utils/types.js';
+import { Attribute } from './interfaces.js';
+/**
+ * @internal
+ */
+export type { JaqlDataSource };
 /**
  * Different aggregation types
  */
@@ -123,7 +128,7 @@ export declare const MetadataTypes: {
      * @param o - object to check
      * @returns true if the object or type is an attribute - of any type
      */
-    isAttribute(o: any): boolean;
+    isAttribute(o: any): o is Attribute;
     /**
      * Checks whether the given object or type is a filter
      *
@@ -182,6 +187,7 @@ export declare type BaseJaql = {
     dim: string;
     table: string;
     column: string;
+    datasource?: JaqlDataSource;
     title: string;
     level?: 'years' | 'quarters' | 'months' | 'weeks' | 'minutes' | 'days';
     sort?: `${JaqlSortDirection}`;
@@ -260,4 +266,3 @@ export declare type OrFilter<FilterItem> = {
  * Abstract object with any unknown values
  */
 export declare type AnyObject = Record<string, any>;
-export {};