@sisense/sdk-data 2.18.1 → 2.20.0

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

@@ -30,9 +30,10 @@ class DimensionalAttribute extends base_js_1.DimensionalElement {
         this._sort = types_js_1.Sort.None;
         this.expression = expression;
         // if composeCode is not explicitly set by the caller, extract it from expression
+        // Use [[delimiters]] to preserve original names that need normalization
         if (!composeCode && expression) {
             const { table, column } = (0, utils_js_1.parseExpression)(expression);
-            this.composeCode = normalizeAttributeName(table, column, '', consts_js_1.DATA_MODEL_MODULE_NAME);
+            this.composeCode = `${consts_js_1.DATA_MODEL_MODULE_NAME}.${(0, base_js_1.wrapIfNeedsNormalization)(table)}.${(0, base_js_1.wrapIfNeedsNormalization)(column)}`;
         }
         // panel is not needed in most cases, this is to support break by columns functionality
         if (panel === 'columns') {
@@ -117,9 +118,11 @@ class DimensionalLevelAttribute extends DimensionalAttribute {
         this._format = format;
         this.granularity = granularity;
         // if composeCode is not explicitly set by the caller, extract it from expression and granularity
+        // Use [[delimiters]] to preserve original names that need normalization
         if (!composeCode && expression) {
             const { table, column } = (0, utils_js_1.parseExpression)(expression);
-            this.composeCode = normalizeAttributeName(table, column, granularity, consts_js_1.DATA_MODEL_MODULE_NAME);
+            const granularityPart = granularity ? `.${granularity}` : '';
+            this.composeCode = `${consts_js_1.DATA_MODEL_MODULE_NAME}.${(0, base_js_1.wrapIfNeedsNormalization)(table)}.${(0, base_js_1.wrapIfNeedsNormalization)(column)}${granularityPart}`;
         }
         // panel is not needed in most cases, this is to support break by columns functionality
         if (panel === 'columns') {

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

@@ -74,3 +74,32 @@ export declare abstract class DimensionalElement implements Element {
  * @internal
  */
 export declare function normalizeName(name: string): string;
+/**
+ * Checks if a name contains characters that would be modified by normalizeName().
+ * Includes: spaces, special chars (!@#$%^&*), dots, brackets, or starts with number.
+ *
+ * @example
+ * needsNormalization("Age Range")  // true (space)
+ * needsNormalization("Cost ($)")   // true (special chars)
+ * needsNormalization("Rev.2024")   // true (dot)
+ * needsNormalization("2024Data")   // true (starts with number)
+ * needsNormalization("Revenue")    // false
+ *
+ * @param name - The name to check
+ * @returns true if the name would be modified by normalizeName()
+ * @internal
+ */
+export declare function needsNormalization(name: string): boolean;
+/**
+ * Wraps name in [[delimiters]] if it would be modified by normalizeName().
+ * Used to preserve original names in composeCode while marking them for transformation.
+ *
+ * @example
+ * wrapIfNeedsNormalization("Age Range")  // "[[Age Range]]"
+ * wrapIfNeedsNormalization("Revenue")    // "Revenue" (unchanged)
+ *
+ * @param name - The name to potentially wrap
+ * @returns The name wrapped in [[]] if it needs normalization, otherwise unchanged
+ * @internal
+ */
+export declare function wrapIfNeedsNormalization(name: string): string;

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

@@ -1,7 +1,7 @@
 "use strict";
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.normalizeName = exports.DimensionalElement = void 0;
+exports.wrapIfNeedsNormalization = exports.needsNormalization = exports.normalizeName = exports.DimensionalElement = void 0;
 /**
  * @internal
  */
@@ -91,3 +91,41 @@ function normalizeName(name) {
     return normalizedName;
 }
 exports.normalizeName = normalizeName;
+/**
+ * Checks if a name contains characters that would be modified by normalizeName().
+ * Includes: spaces, special chars (!@#$%^&*), dots, brackets, or starts with number.
+ *
+ * @example
+ * needsNormalization("Age Range")  // true (space)
+ * needsNormalization("Cost ($)")   // true (special chars)
+ * needsNormalization("Rev.2024")   // true (dot)
+ * needsNormalization("2024Data")   // true (starts with number)
+ * needsNormalization("Revenue")    // false
+ *
+ * @param name - The name to check
+ * @returns true if the name would be modified by normalizeName()
+ * @internal
+ */
+function needsNormalization(name) {
+    // Check for invalid characters (anything not a-zA-Z0-9_)
+    // Note: dots are also "invalid" as they get replaced with underscores
+    // Check if starts with a number (gets prefixed with _)
+    return /[^a-zA-Z0-9_]/.test(name) || /^[0-9]/.test(name);
+}
+exports.needsNormalization = needsNormalization;
+/**
+ * Wraps name in [[delimiters]] if it would be modified by normalizeName().
+ * Used to preserve original names in composeCode while marking them for transformation.
+ *
+ * @example
+ * wrapIfNeedsNormalization("Age Range")  // "[[Age Range]]"
+ * wrapIfNeedsNormalization("Revenue")    // "Revenue" (unchanged)
+ *
+ * @param name - The name to potentially wrap
+ * @returns The name wrapped in [[]] if it needs normalization, otherwise unchanged
+ * @internal
+ */
+function wrapIfNeedsNormalization(name) {
+    return needsNormalization(name) ? `[[${name}]]` : name;
+}
+exports.wrapIfNeedsNormalization = wrapIfNeedsNormalization;

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

@@ -23,9 +23,10 @@ class DimensionalDimension extends base_js_1.DimensionalElement {
         this._attributes = [];
         this._sort = types_js_1.Sort.None;
         // if composeCode is not explicitly set by the caller, extract it from expression
+        // Use [[delimiters]] to preserve original names that need normalization
         if (!composeCode && expression) {
             const { table, column } = (0, utils_js_1.parseExpression)(expression);
-            this.composeCode = (0, attributes_js_1.normalizeAttributeName)(table, column, '', consts_js_1.DATA_MODEL_MODULE_NAME);
+            this.composeCode = `${consts_js_1.DATA_MODEL_MODULE_NAME}.${(0, base_js_1.wrapIfNeedsNormalization)(table)}.${(0, base_js_1.wrapIfNeedsNormalization)(column)}`;
         }
         this._sort = sort || types_js_1.Sort.None;
         this._expression = expression;

package/dist/cjs/dimensional-model/filters/filter-relations.js

@@ -514,7 +514,9 @@ function getFilterRelationsFromJaql(filters, highlights, filterRelations) {
         if ('instanceid' in node) {
             const filter = filters.find((filter) => filter.config.guid === node.instanceid);
             if (!filter) {
-                throw new translatable_error_js_1.TranslatableError('errors.unknownFilterInFilterRelations');
+                throw new translatable_error_js_1.TranslatableError('errors.unknownFilterInFilterRelations', {
+                    filterGuid: node.instanceid,
+                });
             }
             return filter;
         }

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

@@ -180,6 +180,7 @@ const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilter
     }
     throw new translatable_error_js_1.TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),
+        attributeName: attribute.name,
     });
 };
 exports.createAttributeFilterFromConditionFilterJaql = createAttributeFilterFromConditionFilterJaql;
@@ -216,6 +217,7 @@ const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql
     }
     throw new translatable_error_js_1.TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),
+        attributeName: measure.name,
     });
 };
 exports.createMeasureFilterFromConditionFilterJaql = createMeasureFilterFromConditionFilterJaql;

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

@@ -163,11 +163,13 @@ exports.createFilterFromCustomFilterJaql = createFilterFromCustomFilterJaql;
  * @returns Filter object.
  */
 const createFilterFromJaqlInternal = (jaql, guid) => {
+    var _a, _b;
     try {
         if ('formula' in jaql) {
             // generic pass-through JAQL filter will be used instead
             throw new translatable_error_js_1.TranslatableError('errors.filter.formulaFiltersNotSupported', {
                 filter: JSON.stringify(jaql),
+                attributeName: (_b = (_a = jaql.title) !== null && _a !== void 0 ? _a : jaql.column) !== null && _b !== void 0 ? _b : jaql.dim,
             });
         }
         const filterJaqlWrapperWithType = (0, filter_types_util_js_1.extractFilterTypeFromFilterJaql)(jaql, jaql.datatype);

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

@@ -81,10 +81,12 @@ 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
+ * @param format - Optional format string for the measure
+ * @param description - Optional description of the measure
  * @returns A calculated measure instance
  * @group Advanced Analytics
  */
-export declare const customFormula: (title: string, formula: string, context: CustomFormulaContext) => CalculatedMeasure;
+export declare const customFormula: (title: string, formula: string, context: CustomFormulaContext, format?: string, description?: string) => CalculatedMeasure;
 /**
  * Creates an aggregated measure.
  *

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

@@ -124,13 +124,15 @@ function measureFunction(measure, name, func, options) {
  * @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
+ * @param format - Optional format string for the measure
+ * @param description - Optional description of the measure
  * @returns A calculated measure instance
  * @group Advanced Analytics
  */
-exports.customFormula = (0, compose_code_utils_js_1.withComposeCodeForMeasure)((title, formula, context) => {
+exports.customFormula = (0, compose_code_utils_js_1.withComposeCodeForMeasure)((title, formula, context, format, description) => {
     // context keys must be in brackets
     const newContext = Object.fromEntries(Object.entries(context).map(([key, val]) => [key.startsWith('[') ? key : `[${key}]`, val]));
-    return new measures_js_1.DimensionalCalculatedMeasure(title, formula, newContext);
+    return new measures_js_1.DimensionalCalculatedMeasure(title, formula, newContext, format, description);
 }, 'customFormula');
 function arithmetic(operand1, operator, operand2, name, withParentheses) {
     const builder = [];

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

@@ -424,7 +424,9 @@ function createMeasure(json) {
     }
     if (types_js_1.MetadataTypes.isCalculatedMeasure(json)) {
         if (json.context === undefined) {
-            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalCalculatedMeasure.noContext');
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalCalculatedMeasure.noContext', {
+                measureName: name,
+            });
         }
         const context = {};
         Object.getOwnPropertyNames(json.context).forEach((pname) => {
@@ -434,20 +436,22 @@ function createMeasure(json) {
     }
     else if (types_js_1.MetadataTypes.isMeasureTemplate(json)) {
         if (att === undefined) {
-            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression');
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression', { measureName: name });
         }
         return new DimensionalMeasureTemplate(name, att, format, desc, sort);
     }
     else if (types_js_1.MetadataTypes.isBaseMeasure(json)) {
         if (att === undefined) {
-            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression');
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAttributeDimExpression', { measureName: name });
         }
         const agg = json.agg || json.aggregation;
         if (!agg) {
-            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAggAggregation');
+            throw new translatable_error_js_1.TranslatableError('errors.measure.dimensionalBaseMeasure.noAggAggregation', {
+                measureName: name,
+            });
         }
         return new DimensionalBaseMeasure(name, att, agg, format, desc, sort);
     }
-    throw new translatable_error_js_1.TranslatableError('errors.measure.unsupportedType');
+    throw new translatable_error_js_1.TranslatableError('errors.measure.unsupportedType', { measureName: name });
 }
 exports.createMeasure = createMeasure;

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

@@ -217,6 +217,7 @@ export declare type FormulaJaql = {
     formula: string;
     context?: Record<FormulaID, FormulaContext>;
     datasource?: JaqlDataSource;
+    description?: string;
 };
 /** @internal */
 export declare type BaseFilterJaql = IncludeAllFilterJaql | IncludeMembersFilterJaql | ExcludeMembersFilterJaql | NumericFilterJaql | ConditionFilterJaql | AndFilterJaql<NumericFilterJaql | ConditionFilterJaql> | OrFilterJaql<NumericFilterJaql | ConditionFilterJaql>;

package/dist/cjs/translation/resources/en.d.ts

@@ -12,9 +12,8 @@ export declare const translation: {
                 noAttributeDimExpression: string;
                 noAggAggregation: string;
             };
-            notAFormula: string;
         };
-        dataModelConfig: {
+        dataModel: {
             noName: string;
             noMetadata: string;
         };

package/dist/cjs/translation/resources/en.js

@@ -7,26 +7,25 @@ exports.translation = void 0;
 exports.translation = {
     errors: {
         measure: {
-            unsupportedType: 'Unsupported measure type',
+            unsupportedType: 'Unsupported measure type for measure: {{measureName}}',
             dimensionalCalculatedMeasure: {
-                noContext: "DimensionalCalculatedMeasure must have 'context' property",
+                noContext: "DimensionalCalculatedMeasure {{measureName}} must have 'context' property",
             },
             dimensionalBaseMeasure: {
-                noAttributeDimExpression: "DimensionalBaseMeasure must have 'attribute'/'dim'/'expression' property",
-                noAggAggregation: "DimensionalBaseMeasure must have 'agg' or 'aggregation' property",
+                noAttributeDimExpression: "DimensionalBaseMeasure {{measureName}} must have 'attribute'/'dim'/'expression' property",
+                noAggAggregation: "DimensionalBaseMeasure {{measureName}} must have 'agg' or 'aggregation' property",
             },
-            notAFormula: 'Jaql is not a formula',
         },
-        dataModelConfig: {
+        dataModel: {
             noName: "'name' must be specified in config for DataModel",
             noMetadata: "'metadata' must be specified in config for DataModel",
         },
         filter: {
             unsupportedType: 'Unsupported filter type: {{filterType}}',
-            unsupportedDatetimeLevel: 'Filters do not support the next "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
+            unsupportedDatetimeLevel: 'Filters do not support the following "datetime" levels: Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
             membersFilterNullMember: 'MembersFilter of {{attributeId}} - member cannot be null',
-            unsupportedConditionFilter: 'Jaql contains unsupported condition filter: {{filter}}',
-            formulaFiltersNotSupported: 'Formula-based filter not supported yet: {{filter}}',
+            unsupportedConditionFilter: 'Jaql for {{attributeName}} contains unsupported condition filter: {{filter}}',
+            formulaFiltersNotSupported: 'Formula-based filter for {{attributeName}} not supported yet: {{filter}}',
         },
         unsupportedDimensionalElement: 'Unsupported dimensional element type',
     },

package/dist/cjs/translation/resources/index.d.ts

@@ -19,9 +19,8 @@ export declare const resources: {
                     noAttributeDimExpression: string;
                     noAggAggregation: string;
                 };
-                notAFormula: string;
             };
-            dataModelConfig: {
+            dataModel: {
                 noName: string;
                 noMetadata: string;
             };
@@ -46,9 +45,8 @@ export declare const resources: {
                     noAttributeDimExpression: string;
                     noAggAggregation: string;
                 };
-                notAFormula: string;
             };
-            dataModelConfig: {
+            dataModel: {
                 noName: string;
                 noMetadata: string;
             };

package/dist/cjs/translation/resources/uk.js

@@ -7,17 +7,16 @@ exports.translation = void 0;
 exports.translation = {
     errors: {
         measure: {
-            unsupportedType: 'Непідтримуваний тип measure',
+            unsupportedType: 'Непідтримуваний тип measure: {{measureName}}',
             dimensionalCalculatedMeasure: {
-                noContext: "DimensionalCalculatedMeasure має мати властивість 'context'",
+                noContext: "DimensionalCalculatedMeasure {{measureName}} має мати властивість 'context'",
             },
             dimensionalBaseMeasure: {
-                noAttributeDimExpression: "DimensionalBaseMeasure має мати властивість 'attribute'/'dim'/'expression'",
-                noAggAggregation: "DimensionalBaseMeasure має мати властивість 'agg' або 'aggregation'",
+                noAttributeDimExpression: "DimensionalBaseMeasure {{measureName}} має мати властивість 'attribute'/'dim'/'expression'",
+                noAggAggregation: "DimensionalBaseMeasure {{measureName}} має мати властивість 'agg' або 'aggregation'",
             },
-            notAFormula: 'Jaql не формула',
         },
-        dataModelConfig: {
+        dataModel: {
             noName: "'name' має бути вказано в конфігурації для DataModel",
             noMetadata: "'metadata' має бути вказано в конфігурації для DataModel",
         },
@@ -25,8 +24,8 @@ exports.translation = {
             unsupportedType: 'Непідтримуваний тип фільтра: {{filterType}}',
             unsupportedDatetimeLevel: 'Фільтри не підтримують наступні рівні "datetime": Hours, MinutesRoundTo30, MinutesRoundTo15, Minutes, Seconds',
             membersFilterNullMember: 'MembersFilter у {{attributeId}} - member не може бути нульовим',
-            unsupportedConditionFilter: 'Jaql містить непідтримуваний condition фільтр: {{filter}}',
-            formulaFiltersNotSupported: 'Фільтри, що містять формули наразі не підтримуються: {{filter}}',
+            unsupportedConditionFilter: 'Jaql для {{attributeName}} містить непідтримуваний condition фільтр: {{filter}}',
+            formulaFiltersNotSupported: 'Фільтри, що містять формули для {{attributeName}} наразі не підтримуються: {{filter}}',
         },
         unsupportedDimensionalElement: 'Непідтримуваний тип елемента',
     },

package/dist/cjs/utils.d.ts

@@ -184,3 +184,14 @@ export declare function createDimensionalElementFromJaql(jaql: Jaql, datetimeFor
  * @internal
  */
 export declare function getGranularityFromJaql(jaql: BaseJaql | FilterJaql | FilterJaqlInternal | RankingFilterJaql | MetadataItemJaql): string | undefined;
+/**
+ * Translates Fusion FormulaJaql structures to CSDK CalculatedMeasure array.
+ *
+ * This is a pure Node.js function that converts Fusion structures to CSDK structures.
+ *
+ * @param formulas - Array of Fusion FormulaJaql structures
+ * @returns Array of CSDK CalculatedMeasure objects
+ * @throws Error if any formula cannot be converted (includes formula title in error message)
+ * @internal
+ */
+export declare function translateSharedFormulas(formulas: FormulaJaql[]): CalculatedMeasure[];

package/dist/cjs/utils.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getGranularityFromJaql = exports.createDimensionalElementFromJaql = exports.createCalculatedMeasureHelper = exports.createMeasureHelper = exports.createAttributeHelper = exports.getSortType = exports.getColumnNameFromAttribute = exports.getTableNameFromAttribute = exports.parseExpression = exports.createFilterFromJaql = exports.convertSortDirectionToSort = exports.convertSort = exports.convertJaqlDataSourceForDto = exports.convertJaqlDataSource = exports.convertDataSource = exports.isDataSourceInfo = exports.getDataSourceName = exports.getFilterListAndRelationsJaql = exports.guidFast = exports.secureRandom = void 0;
+exports.translateSharedFormulas = exports.getGranularityFromJaql = exports.createDimensionalElementFromJaql = exports.createCalculatedMeasureHelper = exports.createMeasureHelper = exports.createAttributeHelper = exports.getSortType = exports.getColumnNameFromAttribute = exports.getTableNameFromAttribute = exports.parseExpression = exports.createFilterFromJaql = exports.convertSortDirectionToSort = exports.convertSort = exports.convertJaqlDataSourceForDto = exports.convertJaqlDataSource = exports.convertDataSource = exports.isDataSourceInfo = exports.getDataSourceName = exports.getFilterListAndRelationsJaql = exports.guidFast = exports.secureRandom = void 0;
 const cloneDeep_js_1 = __importDefault(require("lodash-es/cloneDeep.js"));
 const mapValues_js_1 = __importDefault(require("lodash-es/mapValues.js"));
 const attributes_js_1 = require("./dimensional-model/attributes.js");
@@ -399,7 +399,7 @@ const createCalculatedMeasureHelper = (jaql) => {
         }
         return jaqlContextValue && createDimensionalElementFromJaql(jaqlContextValue);
     });
-    const measure = measureFactory.customFormula(jaql.title, jaql.formula, context);
+    const measure = measureFactory.customFormula(jaql.title, jaql.formula, context, undefined, jaql.description);
     // Apply sort if present in the JAQL
     if (jaql.sort) {
         const sortEnum = convertSort(jaql.sort);
@@ -464,3 +464,29 @@ function getGranularityFromJaql(jaql) {
         : undefined;
 }
 exports.getGranularityFromJaql = getGranularityFromJaql;
+/**
+ * Translates Fusion FormulaJaql structures to CSDK CalculatedMeasure array.
+ *
+ * This is a pure Node.js function that converts Fusion structures to CSDK structures.
+ *
+ * @param formulas - Array of Fusion FormulaJaql structures
+ * @returns Array of CSDK CalculatedMeasure objects
+ * @throws Error if any formula cannot be converted (includes formula title in error message)
+ * @internal
+ */
+function translateSharedFormulas(formulas) {
+    return formulas.map((formula) => {
+        try {
+            const result = createDimensionalElementFromJaql(formula);
+            if (!('expression' in result && 'context' in result)) {
+                throw new Error(`Expected CalculatedMeasure but got ${result.__serializable || 'unknown type'}`);
+            }
+            return result;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : 'Unknown error';
+            throw new Error(`Failed to translate shared formula "${formula.title}": ${msg}`);
+        }
+    });
+}
+exports.translateSharedFormulas = translateSharedFormulas;

package/dist/dimensional-model/attributes.js

@@ -5,7 +5,7 @@
 /* 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 { DimensionalElement, normalizeName, wrapIfNeedsNormalization } 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';
@@ -26,9 +26,10 @@ export class DimensionalAttribute extends DimensionalElement {
         this._sort = Sort.None;
         this.expression = expression;
         // if composeCode is not explicitly set by the caller, extract it from expression
+        // Use [[delimiters]] to preserve original names that need normalization
         if (!composeCode && expression) {
             const { table, column } = parseExpression(expression);
-            this.composeCode = normalizeAttributeName(table, column, '', DATA_MODEL_MODULE_NAME);
+            this.composeCode = `${DATA_MODEL_MODULE_NAME}.${wrapIfNeedsNormalization(table)}.${wrapIfNeedsNormalization(column)}`;
         }
         // panel is not needed in most cases, this is to support break by columns functionality
         if (panel === 'columns') {
@@ -111,9 +112,11 @@ export class DimensionalLevelAttribute extends DimensionalAttribute {
         this._format = format;
         this.granularity = granularity;
         // if composeCode is not explicitly set by the caller, extract it from expression and granularity
+        // Use [[delimiters]] to preserve original names that need normalization
         if (!composeCode && expression) {
             const { table, column } = parseExpression(expression);
-            this.composeCode = normalizeAttributeName(table, column, granularity, DATA_MODEL_MODULE_NAME);
+            const granularityPart = granularity ? `.${granularity}` : '';
+            this.composeCode = `${DATA_MODEL_MODULE_NAME}.${wrapIfNeedsNormalization(table)}.${wrapIfNeedsNormalization(column)}${granularityPart}`;
         }
         // panel is not needed in most cases, this is to support break by columns functionality
         if (panel === 'columns') {

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

@@ -74,3 +74,32 @@ export declare abstract class DimensionalElement implements Element {
  * @internal
  */
 export declare function normalizeName(name: string): string;
+/**
+ * Checks if a name contains characters that would be modified by normalizeName().
+ * Includes: spaces, special chars (!@#$%^&*), dots, brackets, or starts with number.
+ *
+ * @example
+ * needsNormalization("Age Range")  // true (space)
+ * needsNormalization("Cost ($)")   // true (special chars)
+ * needsNormalization("Rev.2024")   // true (dot)
+ * needsNormalization("2024Data")   // true (starts with number)
+ * needsNormalization("Revenue")    // false
+ *
+ * @param name - The name to check
+ * @returns true if the name would be modified by normalizeName()
+ * @internal
+ */
+export declare function needsNormalization(name: string): boolean;
+/**
+ * Wraps name in [[delimiters]] if it would be modified by normalizeName().
+ * Used to preserve original names in composeCode while marking them for transformation.
+ *
+ * @example
+ * wrapIfNeedsNormalization("Age Range")  // "[[Age Range]]"
+ * wrapIfNeedsNormalization("Revenue")    // "Revenue" (unchanged)
+ *
+ * @param name - The name to potentially wrap
+ * @returns The name wrapped in [[]] if it needs normalization, otherwise unchanged
+ * @internal
+ */
+export declare function wrapIfNeedsNormalization(name: string): string;

package/dist/dimensional-model/base.js

@@ -86,3 +86,39 @@ export function normalizeName(name) {
     }
     return normalizedName;
 }
+/**
+ * Checks if a name contains characters that would be modified by normalizeName().
+ * Includes: spaces, special chars (!@#$%^&*), dots, brackets, or starts with number.
+ *
+ * @example
+ * needsNormalization("Age Range")  // true (space)
+ * needsNormalization("Cost ($)")   // true (special chars)
+ * needsNormalization("Rev.2024")   // true (dot)
+ * needsNormalization("2024Data")   // true (starts with number)
+ * needsNormalization("Revenue")    // false
+ *
+ * @param name - The name to check
+ * @returns true if the name would be modified by normalizeName()
+ * @internal
+ */
+export function needsNormalization(name) {
+    // Check for invalid characters (anything not a-zA-Z0-9_)
+    // Note: dots are also "invalid" as they get replaced with underscores
+    // Check if starts with a number (gets prefixed with _)
+    return /[^a-zA-Z0-9_]/.test(name) || /^[0-9]/.test(name);
+}
+/**
+ * Wraps name in [[delimiters]] if it would be modified by normalizeName().
+ * Used to preserve original names in composeCode while marking them for transformation.
+ *
+ * @example
+ * wrapIfNeedsNormalization("Age Range")  // "[[Age Range]]"
+ * wrapIfNeedsNormalization("Revenue")    // "Revenue" (unchanged)
+ *
+ * @param name - The name to potentially wrap
+ * @returns The name wrapped in [[]] if it needs normalization, otherwise unchanged
+ * @internal
+ */
+export function wrapIfNeedsNormalization(name) {
+    return needsNormalization(name) ? `[[${name}]]` : name;
+}

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

@@ -1,7 +1,7 @@
 /* eslint-disable sonarjs/no-duplicate-string */
 import { parseExpression } from '../../utils.js';
-import { DimensionalAttribute, DimensionalLevelAttribute, jaqlSimpleColumnType, normalizeAttributeName, } from '../attributes.js';
-import { DimensionalElement, normalizeName } from '../base.js';
+import { DimensionalAttribute, DimensionalLevelAttribute, jaqlSimpleColumnType, } from '../attributes.js';
+import { DimensionalElement, normalizeName, wrapIfNeedsNormalization } from '../base.js';
 import { DATA_MODEL_MODULE_NAME } from '../consts.js';
 import { DateLevels, MetadataTypes, Sort, } from '../types.js';
 /**
@@ -20,9 +20,10 @@ export class DimensionalDimension extends DimensionalElement {
         this._attributes = [];
         this._sort = Sort.None;
         // if composeCode is not explicitly set by the caller, extract it from expression
+        // Use [[delimiters]] to preserve original names that need normalization
         if (!composeCode && expression) {
             const { table, column } = parseExpression(expression);
-            this.composeCode = normalizeAttributeName(table, column, '', DATA_MODEL_MODULE_NAME);
+            this.composeCode = `${DATA_MODEL_MODULE_NAME}.${wrapIfNeedsNormalization(table)}.${wrapIfNeedsNormalization(column)}`;
         }
         this._sort = sort || Sort.None;
         this._expression = expression;

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

@@ -465,7 +465,9 @@ export function getFilterRelationsFromJaql(filters, highlights, filterRelations)
         if ('instanceid' in node) {
             const filter = filters.find((filter) => filter.config.guid === node.instanceid);
             if (!filter) {
-                throw new TranslatableError('errors.unknownFilterInFilterRelations');
+                throw new TranslatableError('errors.unknownFilterInFilterRelations', {
+                    filterGuid: node.instanceid,
+                });
             }
             return filter;
         }

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

@@ -153,6 +153,7 @@ export const createAttributeFilterFromConditionFilterJaql = (attribute, conditio
     }
     throw new TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),
+        attributeName: attribute.name,
     });
 };
 /**
@@ -188,5 +189,6 @@ export const createMeasureFilterFromConditionFilterJaql = (measure, conditionFil
     }
     throw new TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),
+        attributeName: measure.name,
     });
 };

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

@@ -130,11 +130,13 @@ export const createFilterFromCustomFilterJaql = (attribute, customFilterJaql, gu
  * @returns Filter object.
  */
 export const createFilterFromJaqlInternal = (jaql, guid) => {
+    var _a, _b;
     try {
         if ('formula' in jaql) {
             // generic pass-through JAQL filter will be used instead
             throw new TranslatableError('errors.filter.formulaFiltersNotSupported', {
                 filter: JSON.stringify(jaql),
+                attributeName: (_b = (_a = jaql.title) !== null && _a !== void 0 ? _a : jaql.column) !== null && _b !== void 0 ? _b : jaql.dim,
             });
         }
         const filterJaqlWrapperWithType = extractFilterTypeFromFilterJaql(jaql, jaql.datatype);

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

@@ -81,10 +81,12 @@ 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
+ * @param format - Optional format string for the measure
+ * @param description - Optional description of the measure
  * @returns A calculated measure instance
  * @group Advanced Analytics
  */
-export declare const customFormula: (title: string, formula: string, context: CustomFormulaContext) => CalculatedMeasure;
+export declare const customFormula: (title: string, formula: string, context: CustomFormulaContext, format?: string, description?: string) => CalculatedMeasure;
 /**
  * Creates an aggregated measure.
  *

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

@@ -121,13 +121,15 @@ function measureFunction(measure, name, func, options) {
  * @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
+ * @param format - Optional format string for the measure
+ * @param description - Optional description of the measure
  * @returns A calculated measure instance
  * @group Advanced Analytics
  */
-export const customFormula = withComposeCodeForMeasure((title, formula, context) => {
+export const customFormula = withComposeCodeForMeasure((title, formula, context, format, description) => {
     // context keys must be in brackets
     const newContext = Object.fromEntries(Object.entries(context).map(([key, val]) => [key.startsWith('[') ? key : `[${key}]`, val]));
-    return new DimensionalCalculatedMeasure(title, formula, newContext);
+    return new DimensionalCalculatedMeasure(title, formula, newContext, format, description);
 }, 'customFormula');
 function arithmetic(operand1, operator, operand2, name, withParentheses) {
     const builder = [];