@sisense/sdk-data 1.34.0 → 2.1.0

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

@@ -1,6 +1,6 @@
 import { DimensionalElement } from './base.js';
 import { Attribute, LevelAttribute } from './interfaces.js';
-import { DateLevel, JaqlDataSource, Sort } from './types.js';
+import { DateLevel, JaqlDataSource, JSONObject, Sort } from './types.js';
 /**
  * @internal
  */
@@ -39,7 +39,7 @@ export declare class DimensionalAttribute extends DimensionalElement implements
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
 }
 /**
  * @internal
@@ -48,7 +48,7 @@ export declare class DimensionalLevelAttribute extends DimensionalAttribute impl
     private _format;
     readonly granularity: string;
     readonly panel: string;
-    constructor(l: string, expression: string, granularity: string, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string, panel?: string);
+    constructor(name: string, expression: string, granularity: string, format?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string, panel?: string);
     /**
      * gets the element's ID
      */
@@ -89,7 +89,7 @@ export declare class DimensionalLevelAttribute extends DimensionalAttribute impl
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets the JAQL representation of this instance
      *

package/dist/dimensional-model/attributes.js

@@ -4,7 +4,9 @@
 /* eslint-disable @typescript-eslint/no-unsafe-member-access */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
 /* eslint-disable sonarjs/no-nested-switch */
+import { parseExpression } from '../utils.js';
 import { DimensionalElement, normalizeName } from './base.js';
+import { DATA_MODEL_MODULE_NAME } from './consts.js';
 import { simpleColumnType } from './simple-column-types.js';
 import { DateLevels, MetadataTypes, Sort } from './types.js';
 /**
@@ -19,6 +21,11 @@ export class DimensionalAttribute extends DimensionalElement {
         super(name, type || MetadataTypes.Attribute, desc, dataSource, composeCode);
         this._sort = Sort.None;
         this.expression = expression;
+        // if composeCode is not explicitly set by the caller, extract it from expression
+        if (!composeCode && expression) {
+            const { table, column } = parseExpression(expression);
+            this.composeCode = normalizeAttributeName(table, column, '', DATA_MODEL_MODULE_NAME);
+        }
         // panel is not needed in most cases, this is to support break by columns functionality
         if (panel === 'columns') {
             this.panel = panel;
@@ -72,11 +79,12 @@ export class DimensionalAttribute extends DimensionalElement {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'DimensionalAttribute';
         result.expression = this.expression;
         if (this.getSort() !== Sort.None) {
-            result.sort = this.getSort().toString();
+            result.sort = this.getSort();
         }
         return result;
     }
@@ -85,10 +93,15 @@ export class DimensionalAttribute extends DimensionalElement {
  * @internal
  */
 export class DimensionalLevelAttribute extends DimensionalAttribute {
-    constructor(l, expression, granularity, format, desc, sort, dataSource, composeCode, panel) {
-        super(l, expression, MetadataTypes.DateLevel, desc, sort, dataSource, composeCode);
+    constructor(name, expression, granularity, format, desc, sort, dataSource, composeCode, panel) {
+        super(name, expression, MetadataTypes.DateLevel, desc, sort, dataSource, composeCode);
         this._format = format;
         this.granularity = granularity;
+        // if composeCode is not explicitly set by the caller, extract it from expression and granularity
+        if (!composeCode && expression) {
+            const { table, column } = parseExpression(expression);
+            this.composeCode = normalizeAttributeName(table, column, granularity, DATA_MODEL_MODULE_NAME);
+        }
         // panel is not needed in most cases, this is to support break by columns functionality
         if (panel === 'columns') {
             this.panel = panel;
@@ -152,8 +165,9 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'DimensionalLevelAttribute';
         result.granularity = this.granularity;
         if (this.getFormat() !== undefined) {
             result.format = this.getFormat();

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

@@ -1,5 +1,5 @@
 import { Element } from './interfaces.js';
-import { JaqlDataSource } from './types.js';
+import { JaqlDataSource, JSONObject } from './types.js';
 /**
  * @internal
  */
@@ -43,8 +43,8 @@ export declare abstract class DimensionalElement implements Element {
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
-    toJSON(): any;
+    serialize(): JSONObject;
+    toJSON(): JSONObject;
     abstract jaql(nested?: boolean): any;
     /**
      * Gets a string representation of the element

package/dist/dimensional-model/base.js

@@ -9,7 +9,9 @@ export class DimensionalElement {
         if (dataSource) {
             this._dataSource = dataSource;
         }
-        this.composeCode = composeCode;
+        if (composeCode) {
+            this.composeCode = composeCode;
+        }
     }
     /**
      * Defines the element's name
@@ -29,17 +31,18 @@ export class DimensionalElement {
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
+    serialize() {
         return {
             name: this.name,
             type: this.type,
-            desc: this.description,
+            description: this.description,
             dataSource: this.dataSource,
+            composeCode: this.composeCode,
             __serializable: 'DimensionalElement',
         };
     }
     toJSON() {
-        return this.serializable();
+        return this.serialize();
     }
     /**
      * Gets a string representation of the element

package/dist/dimensional-model/compose-code-utils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Stringifies the argument, with an option to exclude specific properties from objects without a 'composeCode'.
+ * Keys with spaces in objects will be enclosed in single quotes.
+ *
+ * @param arg - The argument to stringify.
+ * @param excludeProps - Optional array of property names to exclude when stringifying objects (that don't have 'composeCode').
+ * @returns The stringified representation of the argument.
+ */
+export declare function stringifyHelper(arg: any, excludeProps?: string[]): string;
+/**
+ * High order function to construct compose code for filter factory functions
+ *
+ * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @returns filter factory function with composeCode property added to the filter
+ */
+export declare function withComposeCodeForFilter<T extends (...args: any[]) => any>(func: T, funcName?: string): T;
+/**
+ * High order function to construct compose code for filter relations factory functions
+ *
+ * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @returns filter factory function with composeCode property added to the filter
+ */
+export declare function withComposeCodeForFilterRelations<T extends (...args: any[]) => any>(func: T, funcName?: string): T;
+/**
+ * High order function to construct compose code for analytics factory functions
+ *
+ * @param func - analytics factory function
+ * @param funcName - name of the analytics factory function. Needed if the function name is minified.
+ * @returns analytics factory function with composeCode property added to the analytics
+ */
+export declare function withComposeCodeForAnalytics<T extends (...args: any[]) => any>(func: T, funcName?: string): T;
+/**
+ * High order function to construct compose code for measure factory functions
+ *
+ * @param func - measure factory function
+ * @param funcName - name of the measure factory function. Needed if the function name is minified.
+ * @returns measure factory function with composeCode property added to the measure
+ */
+export declare function withComposeCodeForMeasure<T extends (...args: any[]) => any>(func: T, funcName?: string): T;

package/dist/dimensional-model/compose-code-utils.js

@@ -0,0 +1,119 @@
+import { escapeSingleQuotes } from '@sisense/sdk-common';
+/**
+ * Stringifies the argument, with an option to exclude specific properties from objects without a 'composeCode'.
+ * Keys with spaces in objects will be enclosed in single quotes.
+ *
+ * @param arg - The argument to stringify.
+ * @param excludeProps - Optional array of property names to exclude when stringifying objects (that don't have 'composeCode').
+ * @returns The stringified representation of the argument.
+ */
+export function stringifyHelper(arg, excludeProps = []) {
+    try {
+        if (arg === null || arg === undefined) {
+            return String(arg);
+        }
+        if (typeof arg === 'string') {
+            return `'${escapeSingleQuotes(arg)}'`;
+        }
+        if (typeof arg === 'number' || typeof arg === 'boolean') {
+            return String(arg);
+        }
+        if (arg instanceof Date) {
+            return `new Date('${arg.toISOString()}')`;
+        }
+        if (Array.isArray(arg)) {
+            return `[${arg.map((item) => stringifyHelper(item, excludeProps)).join(', ')}]`;
+        }
+        if (typeof arg === 'object' && arg !== null) {
+            if ('composeCode' in arg) {
+                return arg.composeCode;
+            }
+            const entries = Object.entries(arg)
+                .filter(([key]) => !excludeProps.includes(key))
+                .map(([key, value]) => {
+                const formattedKey = /[^a-zA-Z0-9_$]/.test(key) ? `'${key}'` : key;
+                return `${formattedKey}: ${stringifyHelper(value, excludeProps)}`;
+            });
+            return `{ ${entries.join(', ')} }`;
+        }
+        // Fallback for anything else
+        return JSON.stringify(arg);
+    }
+    catch (e) {
+        console.error(e, JSON.stringify(arg, null, 2));
+        return JSON.stringify(arg);
+    }
+}
+function trimTrailingUndefined(args) {
+    let i = args.length;
+    while (i > 0 && args[i - 1] === undefined) {
+        i--;
+    }
+    return args.slice(0, i);
+}
+/**
+ * Generic high order function to construct compose code for factory functions
+ *
+ * @param func - factory function
+ * @param factoryName - name of the factory (e.g. 'filterFactory', 'measureFactory')
+ * @param funcName - name of the factory function. Needed if the function name is minified.
+ * @returns factory function with composeCode property added
+ */
+function withComposeCode(factoryName, funcName) {
+    return function (func) {
+        return function (...args) {
+            const trimmedArgs = trimTrailingUndefined(args);
+            const length = trimmedArgs.length;
+            const argValues = trimmedArgs
+                .map((arg) => stringifyHelper(arg, ['guid']))
+                // Remove trivial arg values from the end of the array
+                .filter((str, index) => !(['', '{  }', '[]', 'undefined', 'null'].includes(str) && index === length - 1))
+                .join(', ');
+            const signature = `${factoryName}.${funcName !== null && funcName !== void 0 ? funcName : func.name}(${argValues})`;
+            // Call the original function and get the result
+            const result = func(...args);
+            result.composeCode = signature; // Type assertion needed here
+            return result;
+        };
+    };
+}
+/**
+ * High order function to construct compose code for filter factory functions
+ *
+ * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @returns filter factory function with composeCode property added to the filter
+ */
+export function withComposeCodeForFilter(func, funcName) {
+    return withComposeCode('filterFactory', funcName)(func);
+}
+/**
+ * High order function to construct compose code for filter relations factory functions
+ *
+ * @param func - filter factory function
+ * @param funcName - name of the filter factory function. Needed if the function name is minified.
+ * @returns filter factory function with composeCode property added to the filter
+ */
+export function withComposeCodeForFilterRelations(func, funcName) {
+    return withComposeCode('filterFactory.logic', funcName)(func);
+}
+/**
+ * High order function to construct compose code for analytics factory functions
+ *
+ * @param func - analytics factory function
+ * @param funcName - name of the analytics factory function. Needed if the function name is minified.
+ * @returns analytics factory function with composeCode property added to the analytics
+ */
+export function withComposeCodeForAnalytics(func, funcName) {
+    return withComposeCode('analyticsFactory', funcName)(func);
+}
+/**
+ * High order function to construct compose code for measure factory functions
+ *
+ * @param func - measure factory function
+ * @param funcName - name of the measure factory function. Needed if the function name is minified.
+ * @returns measure factory function with composeCode property added to the measure
+ */
+export function withComposeCodeForMeasure(func, funcName) {
+    return withComposeCode('measureFactory', funcName)(func);
+}

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

@@ -0,0 +1 @@
+export declare const DATA_MODEL_MODULE_NAME = "DM";

package/dist/dimensional-model/consts.js

@@ -0,0 +1 @@
+export const DATA_MODEL_MODULE_NAME = 'DM';

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

@@ -1,6 +1,6 @@
 import { DimensionalElement } from '../base.js';
 import { Attribute, DateDimension, Dimension, LevelAttribute } from '../interfaces.js';
-import { JaqlDataSource, Sort } from '../types.js';
+import { JaqlDataSource, JSONObject, Sort } from '../types.js';
 /**
  * Represents a Dimension in a Dimensional Model
  *
@@ -14,7 +14,7 @@ export declare class DimensionalDimension extends DimensionalElement implements
     protected _attributes: Attribute[];
     private _expression;
     protected _sort: Sort;
-    constructor(name: string, expression: string, attributes: Attribute[], dimensions?: Dimension[], type?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource);
+    constructor(name: string, expression: string, attributes: Attribute[], dimensions?: Dimension[], type?: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string, defaultAttribute?: Attribute);
     private getAttachedName;
     protected setDimensions(dimensions: Dimension[]): void;
     protected setAttributes(attributes: Attribute[]): void;
@@ -47,7 +47,7 @@ export declare class DimensionalDimension extends DimensionalElement implements
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets the JAQL representation of this instance
      *
@@ -61,7 +61,7 @@ export declare class DimensionalDimension extends DimensionalElement implements
  * @internal
  */
 export declare class DimensionalDateDimension extends DimensionalDimension implements DateDimension {
-    constructor(name: string, expression: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource);
+    constructor(name: string, expression: string, desc?: string, sort?: Sort, dataSource?: JaqlDataSource, composeCode?: string);
     /**
      * Years level
      */
@@ -141,7 +141,7 @@ export declare class DimensionalDateDimension extends DimensionalDimension imple
     /**
      * Gets a serializable representation of the element
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Gets the JAQL representation of this instance
      *

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

@@ -6,8 +6,10 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { DimensionalAttribute, DimensionalLevelAttribute, jaqlSimpleColumnType, } from '../attributes.js';
+import { parseExpression } from '../../utils.js';
+import { DimensionalAttribute, DimensionalLevelAttribute, jaqlSimpleColumnType, normalizeAttributeName, } from '../attributes.js';
 import { DimensionalElement, normalizeName } from '../base.js';
+import { DATA_MODEL_MODULE_NAME } from '../consts.js';
 import { DateLevels, MetadataTypes, Sort } from '../types.js';
 /**
  * Represents a Dimension in a Dimensional Model
@@ -15,15 +17,23 @@ import { DateLevels, MetadataTypes, Sort } from '../types.js';
  * @internal
  */
 export class DimensionalDimension extends DimensionalElement {
-    constructor(name, expression, attributes, dimensions, type, desc, sort, dataSource) {
-        super(name, type || MetadataTypes.Dimension, desc, dataSource);
+    constructor(name, expression, attributes, dimensions, type, desc, sort, dataSource, composeCode, defaultAttribute) {
+        super(name, type || MetadataTypes.Dimension, desc, dataSource, composeCode);
         this._dimensions = [];
         this._attributes = [];
         this._sort = Sort.None;
+        // if composeCode is not explicitly set by the caller, extract it from expression
+        if (!composeCode && expression) {
+            const { table, column } = parseExpression(expression);
+            this.composeCode = normalizeAttributeName(table, column, '', DATA_MODEL_MODULE_NAME);
+        }
         this._sort = sort || Sort.None;
         this._expression = expression;
         this.setDimensions(dimensions || []);
         this.setAttributes(attributes);
+        if (defaultAttribute) {
+            this.defaultAttribute = defaultAttribute;
+        }
     }
     static parseType(type) {
         switch (type) {
@@ -109,21 +119,22 @@ export class DimensionalDimension extends DimensionalElement {
      * @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, this.dataSource);
+        return new DimensionalDimension(this.name, this.expression, this.attributes, this.dimensions, this.type, this.description, sort, this.dataSource, this.composeCode, this.defaultAttribute);
     }
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'DimensionalDimension';
         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());
+        result.attributes = this._attributes.map((att) => att.serialize());
+        result.dimensions = this._dimensions.map((dim) => dim.serialize());
         if (this.defaultAttribute) {
-            result.defaultAttribute = this.defaultAttribute.serializable();
+            result.defaultAttribute = this.defaultAttribute.serialize();
         }
         return result;
     }
@@ -158,8 +169,8 @@ export class DimensionalDimension extends DimensionalElement {
  * @internal
  */
 export class DimensionalDateDimension extends DimensionalDimension {
-    constructor(name, expression, desc, sort, dataSource) {
-        super(name, expression, [], [], MetadataTypes.DateDimension, desc, sort, dataSource);
+    constructor(name, expression, desc, sort, dataSource, composeCode) {
+        super(name, expression, [], [], MetadataTypes.DateDimension, desc, sort, dataSource, composeCode);
         this.defaultLevel = DateLevels.Years;
         this.Years = new DimensionalLevelAttribute(DateLevels.Years, expression, DateLevels.Years, 'yyyy', desc, sort, dataSource);
         this.Quarters = new DimensionalLevelAttribute(DateLevels.Quarters, expression, DateLevels.Quarters, 'Q yyyy', desc, sort, dataSource);
@@ -219,16 +230,14 @@ export class DimensionalDateDimension extends DimensionalDimension {
      * @returns An instance representing the sorted {@link Dimension} of this instance
      */
     sort(sort) {
-        return new DimensionalDateDimension(this.name, this.expression, this.description, sort, this.dataSource);
+        return new DimensionalDateDimension(this.name, this.expression, this.description, sort, this.dataSource, this.composeCode);
     }
     /**
      * Gets a serializable representation of the element
      */
-    serializable() {
-        const result = super.serializable();
-        if (this.defaultLevel) {
-            result.defaultLevel = this.defaultLevel;
-        }
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'DimensionalDateDimension';
         return result;
     }
     /**