@sisense/sdk-data 1.33.0 → 2.0.0

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findFilter = exports.withReplacedFilter = exports.withoutFilters = exports.withoutFilter = exports.withAddedFilters = exports.withAddedFilter = void 0;
-const filter_relations_js_1 = require("./filter-relations.js");
 const index_js_1 = require("../../index.js");
+const filter_relations_js_1 = require("./filter-relations.js");
 /**
  * Returns a function that adds a filter to existing filters or filter relations.
  *
@@ -162,11 +162,11 @@ exports.withReplacedFilter = withReplacedFilter;
 /**
  * Finds a filter in an array of filters or filter relations.
  * Returns the first filter that satisfies the provided search function.
+ *
  * @group Filter Utilities
  * @param filters - An array of filters or filter relations to search.
  * @param searchFn - A function that takes a filter and returns a boolean indicating whether the filter satisfies the search criteria.
  * @returns The first filter that satisfies the search function, or `undefined` if no filter is found.
- *
  */
 function findFilter(filters, searchFn) {
     if (!filters) {

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

@@ -9,15 +9,11 @@ const utils_js_1 = require("../../../utils.js");
  * @returns attribute or level attribute
  */
 const createAttributeFromFilterJaql = (jaql) => {
-    const { dim, table, column, level, datatype, title, datasource: dataSource } = jaql;
+    const { dim, datatype, title, datasource: dataSource } = jaql;
     return (0, utils_js_1.createAttributeHelper)({
-        dim,
-        table,
-        column,
+        expression: dim,
         dataType: datatype,
-        level,
-        format: undefined,
-        sort: undefined,
+        granularity: (0, utils_js_1.getGranularityFromJaql)(jaql),
         title,
         dataSource,
     });
@@ -30,16 +26,14 @@ exports.createAttributeFromFilterJaql = createAttributeFromFilterJaql;
  * @returns Measure
  */
 const createMeasureFromFilterJaql = (jaql) => {
-    const { dim, table, column, title, level, datatype: dataType, agg, datasource: dataSource, } = jaql;
+    const { dim, title, datatype: dataType, agg, datasource: dataSource } = jaql;
     if (!agg)
         return undefined;
     return (0, utils_js_1.createMeasureHelper)({
-        dim,
-        table,
-        column,
+        expression: dim,
         dataType,
         agg,
-        level,
+        granularity: (0, utils_js_1.getGranularityFromJaql)(jaql),
         format: undefined,
         sort: undefined,
         title,
@@ -56,12 +50,10 @@ exports.createMeasureFromFilterJaql = createMeasureFromFilterJaql;
 const createMeasureFromRankingFilterJaql = (jaql, rankingMessage) => {
     if ('formula' in jaql)
         return (0, utils_js_1.createCalculatedMeasureHelper)(jaql);
-    const { dim, table, column, level, datatype: dataType, agg } = jaql;
+    const { dim, datatype: dataType, agg } = jaql;
     return (0, utils_js_1.createMeasureHelper)({
-        dim,
-        table,
-        column,
-        level,
+        expression: dim,
+        granularity: (0, utils_js_1.getGranularityFromJaql)(jaql),
         dataType,
         agg,
         format: undefined,

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

@@ -1,5 +1,5 @@
-import { ConditionFilterJaql, ConditionFilterType } from './types.js';
 import { Attribute, BaseMeasure, Filter } from '../../interfaces.js';
+import { ConditionFilterJaql, ConditionFilterType } from './types.js';
 export declare const getSelectedConditionOption: (filter: ConditionFilterJaql) => ConditionFilterType;
 /**
  * Creates an attribute filter from the provided attribute and condition filter JAQL object

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

@@ -24,12 +24,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMeasureFilterFromConditionFilterJaql = exports.createAttributeFilterFromConditionFilterJaql = exports.getSelectedConditionOption = void 0;
-const types_js_1 = require("./types.js");
-const filter_code_util_js_1 = require("./filter-code-util.js");
-const filterFactory = __importStar(require("../factory.js"));
-const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
 const translatable_error_js_1 = require("../../../translation/translatable-error.js");
+const filterFactory = __importStar(require("../factory.js"));
 const filter_config_utils_js_1 = require("../filter-config-utils.js");
+const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
+const types_js_1 = require("./types.js");
 const isTopCondition = (filter) => filter.top !== undefined;
 const isBottomCondition = (filter) => filter.bottom !== undefined;
 const isExcludeCondition = (filter) => { var _a; return !!((_a = filter.exclude) === null || _a === void 0 ? void 0 : _a.members); };
@@ -115,48 +114,48 @@ const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilter
     switch (conditionType) {
         case types_js_1.ConditionFilterType.BOTTOM:
             if (conditionFilterJaql.by) {
-                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.bottomRanking, 'bottomRanking')(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[types_js_1.ConditionFilterType.BOTTOM], { guid });
+                return filterFactory.bottomRanking(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[types_js_1.ConditionFilterType.BOTTOM], { guid });
             }
             break;
         case types_js_1.ConditionFilterType.EQUALS:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.equals, 'equals')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.EQUALS], { guid });
+            return filterFactory.equals(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.EQUALS], { guid });
         case types_js_1.ConditionFilterType.DOESNT_EQUAL:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.doesntEqual, 'doesntEqual')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_EQUAL], { guid });
+            return filterFactory.doesntEqual(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_EQUAL], { guid });
         case types_js_1.ConditionFilterType.GREATER_THAN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.greaterThan, 'greaterThan')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN], { guid });
+            return filterFactory.greaterThan(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN], { guid });
         case types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.greaterThanOrEqual, 'greaterThanOrEqual')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
+            return filterFactory.greaterThanOrEqual(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
         case types_js_1.ConditionFilterType.TOP:
             if (conditionFilterJaql.by) {
-                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.topRanking, 'topRanking')(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[types_js_1.ConditionFilterType.TOP], { guid });
+                return filterFactory.topRanking(attribute, (0, attribute_measure_util_js_1.createMeasureFromRankingFilterJaql)(conditionFilterJaql.by, conditionFilterJaql.rankingMessage), conditionFilterJaql[types_js_1.ConditionFilterType.TOP], { guid });
             }
             break;
         case types_js_1.ConditionFilterType.STARTS_WITH:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.startsWith, 'startsWith')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.STARTS_WITH], { guid });
+            return filterFactory.startsWith(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.STARTS_WITH], { guid });
         case types_js_1.ConditionFilterType.DOESNT_START_WITH:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.doesntStartWith, 'doesntStartWith')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_START_WITH], { guid });
+            return filterFactory.doesntStartWith(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_START_WITH], { guid });
         case types_js_1.ConditionFilterType.ENDS_WITH:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.endsWith, 'endsWith')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.ENDS_WITH], { guid });
+            return filterFactory.endsWith(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.ENDS_WITH], { guid });
         case types_js_1.ConditionFilterType.DOESNT_END_WITH:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.doesntEndWith, 'doesntEndWith')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_END_WITH], { guid });
+            return filterFactory.doesntEndWith(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_END_WITH], { guid });
         case types_js_1.ConditionFilterType.CONTAINS:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.contains, 'contains')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.CONTAINS], { guid });
+            return filterFactory.contains(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.CONTAINS], { guid });
         case types_js_1.ConditionFilterType.DOESNT_CONTAIN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.doesntContain, 'doesntContain')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_CONTAIN], { guid });
+            return filterFactory.doesntContain(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.DOESNT_CONTAIN], { guid });
         case types_js_1.ConditionFilterType.LESS_THAN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.lessThan, 'lessThan')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN], { guid });
+            return filterFactory.lessThan(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN], { guid });
         case types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.lessThanOrEqual, 'lessThanOrEqual')(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
+            return filterFactory.lessThanOrEqual(attribute, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
         case types_js_1.ConditionFilterType.BETWEEN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.between, 'between')(attribute, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
+            return filterFactory.between(attribute, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
         case types_js_1.ConditionFilterType.IS_NOT_BETWEEN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.exclude, 'exclude')((0, filter_code_util_js_1.withComposeCode)(filterFactory.between, 'between')(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, { guid }), undefined, { guid });
+            return filterFactory.exclude(filterFactory.between(attribute, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, { guid }), undefined, { guid });
         case types_js_1.ConditionFilterType.MULTIPLE_CONDITION:
             if (conditionFilterJaql.and) {
-                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.intersection, 'intersection')(conditionFilterJaql.and.map((c) => (0, exports.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), { guid });
+                return filterFactory.intersection(conditionFilterJaql.and.map((c) => (0, exports.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), { guid });
             }
             if (conditionFilterJaql.or) {
-                return (0, filter_code_util_js_1.withComposeCode)(filterFactory.union, 'union')(conditionFilterJaql.or.map((c) => (0, exports.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), { guid });
+                return filterFactory.union(conditionFilterJaql.or.map((c) => (0, exports.createAttributeFilterFromConditionFilterJaql)(attribute, c, guid)), { guid });
             }
             break;
         case types_js_1.ConditionFilterType.IS_NOT: {
@@ -170,7 +169,7 @@ const createAttributeFilterFromConditionFilterJaql = (attribute, conditionFilter
                 enableMultiSelection: (_g = conditionFilterJaql.multiSelection) !== null && _g !== void 0 ? _g : true,
                 deactivatedMembers,
             });
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.members, 'members')(attribute, selectedMembers, config);
+            return filterFactory.members(attribute, selectedMembers, config);
         }
         case types_js_1.ConditionFilterType.AFTER:
         case types_js_1.ConditionFilterType.BEFORE:
@@ -193,20 +192,23 @@ exports.createAttributeFilterFromConditionFilterJaql = createAttributeFilterFrom
  * @returns measure filter
  */
 const createMeasureFilterFromConditionFilterJaql = (measure, conditionFilterJaql, guid) => {
+    var _a, _b;
     const conditionType = (0, exports.getSelectedConditionOption)(conditionFilterJaql);
     switch (conditionType) {
         case types_js_1.ConditionFilterType.EQUALS:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureEquals, 'measureEquals')(measure, conditionFilterJaql[types_js_1.ConditionFilterType.EQUALS], { guid });
+            return filterFactory.measureEquals(measure, conditionFilterJaql[types_js_1.ConditionFilterType.EQUALS], { guid });
         case types_js_1.ConditionFilterType.GREATER_THAN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureGreaterThan, 'measureGreaterThan')(measure, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN], { guid });
+            return filterFactory.measureGreaterThan(measure, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN], { guid });
         case types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureGreaterThanOrEqual, 'measureGreaterThanOrEqual')(measure, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
+            return filterFactory.measureGreaterThanOrEqual(measure, conditionFilterJaql[types_js_1.ConditionFilterType.GREATER_THAN_OR_EQUAL], { guid });
         case types_js_1.ConditionFilterType.LESS_THAN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureLessThan, 'measureLessThan')(measure, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN], { guid });
+            return filterFactory.measureLessThan(measure, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN], { guid });
         case types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureLessThanOrEqual, 'measureLessThanOrEqual')(measure, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
+            return filterFactory.measureLessThanOrEqual(measure, conditionFilterJaql[types_js_1.ConditionFilterType.LESS_THAN_OR_EQUAL], { guid });
         case types_js_1.ConditionFilterType.BETWEEN:
-            return (0, filter_code_util_js_1.withComposeCode)(filterFactory.measureBetween, 'measureBetween')(measure, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
+            return filterFactory.measureBetween(measure, conditionFilterJaql.from, conditionFilterJaql.to, { guid });
+        case types_js_1.ConditionFilterType.IS_NOT_BETWEEN:
+            return filterFactory.exclude(filterFactory.measureBetween(measure, (_a = conditionFilterJaql.exclude) === null || _a === void 0 ? void 0 : _a.from, (_b = conditionFilterJaql.exclude) === null || _b === void 0 ? void 0 : _b.to, { guid }), undefined, { guid });
     }
     throw new translatable_error_js_1.TranslatableError('errors.filter.unsupportedConditionFilter', {
         filter: JSON.stringify(conditionFilterJaql),

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

@@ -1,6 +1,6 @@
-import { BaseFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
 import { Attribute, Filter, LevelAttribute } from '../../interfaces.js';
 import { FilterJaql } from '../../types.js';
+import { BaseFilterJaql, FilterJaqlInternal, PeriodFilterJaql, RangeFilterJaql, SpecificItemsFilterJaql } from './types.js';
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *

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

@@ -24,14 +24,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFilterFromJaqlInternal = exports.createFilterFromCustomFilterJaql = exports.createFilterFromPeriodFilterJaql = exports.createFilterFromNumericRangeJaql = exports.createFilterFromDateRangeFilterJaql = exports.createFilterFromSpecificItemsFilterJaql = exports.createFilterIncludeAll = exports.createGenericFilter = void 0;
-const types_js_1 = require("./types.js");
+const translatable_error_js_1 = require("../../../translation/translatable-error.js");
 const filterFactory = __importStar(require("../factory.js"));
+const filter_config_utils_js_1 = require("../filter-config-utils.js");
+const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
 const condition_filter_util_js_1 = require("./condition-filter-util.js");
 const filter_types_util_js_1 = require("./filter-types-util.js");
-const filter_code_util_js_1 = require("./filter-code-util.js");
-const attribute_measure_util_js_1 = require("./attribute-measure-util.js");
-const translatable_error_js_1 = require("../../../translation/translatable-error.js");
-const filter_config_utils_js_1 = require("../filter-config-utils.js");
+const types_js_1 = require("./types.js");
 /**
  * Creates a generic filter (aka pass-through JAQL filter) if the JAQL cannot be translated to a specific filter type.
  *
@@ -40,7 +39,7 @@ const filter_config_utils_js_1 = require("../filter-config-utils.js");
  * @returns A generic Filter object.
  */
 const createGenericFilter = (jaql, guid) => {
-    return {
+    const baseFilter = {
         config: Object.assign(Object.assign({}, (0, filter_config_utils_js_1.getDefaultBaseFilterConfig)()), { guid, originalFilterJaql: jaql }),
         jaql: (nested) => {
             if (nested) {
@@ -55,13 +54,8 @@ const createGenericFilter = (jaql, guid) => {
             id: jaql.dim,
         },
         type: 'filter',
-        serializable() {
-            return Object.assign(Object.assign({}, this), { jaql: this.jaql() });
-        },
-        toJSON() {
-            return this.serializable();
-        },
     };
+    return Object.assign({}, baseFilter);
 };
 exports.createGenericFilter = createGenericFilter;
 /**
@@ -78,7 +72,7 @@ const createFilterIncludeAll = (attribute, guid) => {
         guid,
         excludeMembers: true,
     };
-    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.members, 'members')(attribute, [], config);
+    return filterFactory.members(attribute, [], config);
 };
 exports.createFilterIncludeAll = createFilterIncludeAll;
 /**
@@ -98,7 +92,7 @@ const createFilterFromSpecificItemsFilterJaql = (attribute, specificItemsFilterJ
         enableMultiSelection: multiSelection !== null && multiSelection !== void 0 ? multiSelection : true,
         deactivatedMembers,
     });
-    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.members, 'members')(attribute, activeMembers, config);
+    return filterFactory.members(attribute, activeMembers, config);
 };
 exports.createFilterFromSpecificItemsFilterJaql = createFilterFromSpecificItemsFilterJaql;
 function getDeactivatedMembersFromFilterJaql(filterJaql) {
@@ -120,7 +114,7 @@ function getActiveMembersFromFilterJaql(filterJaql, deactivatedMembers) {
  * @returns Filter object
  */
 const createFilterFromDateRangeFilterJaql = (attribute, rangeFilterJaql, guid) => {
-    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.dateRange, 'dateRange')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
+    return filterFactory.dateRange(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 exports.createFilterFromDateRangeFilterJaql = createFilterFromDateRangeFilterJaql;
 /**
@@ -132,7 +126,7 @@ exports.createFilterFromDateRangeFilterJaql = createFilterFromDateRangeFilterJaq
  * @returns Filter object
  */
 const createFilterFromNumericRangeJaql = (attribute, rangeFilterJaql, guid) => {
-    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.between, 'between')(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
+    return filterFactory.between(attribute, rangeFilterJaql.from, rangeFilterJaql.to, { guid });
 };
 exports.createFilterFromNumericRangeJaql = createFilterFromNumericRangeJaql;
 /**
@@ -145,10 +139,10 @@ exports.createFilterFromNumericRangeJaql = createFilterFromNumericRangeJaql;
  */
 const createFilterFromPeriodFilterJaql = (attribute, periodFilterJaql, guid) => {
     if (periodFilterJaql.last) {
-        return (0, filter_code_util_js_1.withComposeCode)(filterFactory.dateRelativeTo, 'dateRelativeTo')(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, { guid });
+        return filterFactory.dateRelativeTo(attribute, periodFilterJaql.last.offset, periodFilterJaql.last.count, periodFilterJaql.last.anchor, { guid });
     }
     else {
-        return (0, filter_code_util_js_1.withComposeCode)(filterFactory.dateRelativeFrom, 'dateRelativeFrom')(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, { guid });
+        return filterFactory.dateRelativeFrom(attribute, periodFilterJaql.next.offset, periodFilterJaql.next.count, periodFilterJaql.next.anchor, { guid });
     }
 };
 exports.createFilterFromPeriodFilterJaql = createFilterFromPeriodFilterJaql;
@@ -161,7 +155,7 @@ exports.createFilterFromPeriodFilterJaql = createFilterFromPeriodFilterJaql;
  * @returns Filter object
  */
 const createFilterFromCustomFilterJaql = (attribute, customFilterJaql, guid) => {
-    return (0, filter_code_util_js_1.withComposeCode)(filterFactory.customFilter, 'customFilter')(attribute, customFilterJaql, {
+    return filterFactory.customFilter(attribute, customFilterJaql, {
         guid,
     });
 };

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

@@ -1,4 +1,4 @@
-import { FilterModalType, AnyTypeFilterJaql, DatetimeLevel, FilterType, SpecificItemsFilterJaql, ConditionFilterJaql, FilterJaqlInternal, FilterJaqlWrapperWithType } from './types.js';
+import { AnyTypeFilterJaql, ConditionFilterJaql, DatetimeLevel, FilterJaqlInternal, FilterJaqlWrapperWithType, FilterModalType, FilterType, SpecificItemsFilterJaql } from './types.js';
 export declare const isSpecificItemsFilter: (filter: AnyTypeFilterJaql) => filter is SpecificItemsFilterJaql;
 export declare const isNumericRangeFilter: (filter: AnyTypeFilterJaql) => boolean;
 export declare const isConditionFilter: (filter: AnyTypeFilterJaql) => filter is ConditionFilterJaql;

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

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractFilterTypeFromFilterJaql = exports.getFilterType = exports.isConditionFilter = exports.isNumericRangeFilter = exports.isSpecificItemsFilter = void 0;
 const condition_filter_util_js_1 = require("./condition-filter-util.js");
-const types_js_1 = require("./types.js");
 const date_time_filter_util_js_1 = require("./date-time-filter-util.js");
+const types_js_1 = require("./types.js");
 const isIncludeAllFilter = (filter) => filter === null || filter === void 0 ? void 0 : filter.all;
 const getInnerPeriodFilter = (filter) => (filter.last ? filter.last : filter.next);
 const isPeriodFilter = (filter) => { var _a; return ((_a = getInnerPeriodFilter(filter)) === null || _a === void 0 ? void 0 : _a.offset) < 2; };

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

@@ -19,6 +19,16 @@ export declare type JaqlDataSource = {
     lastBuildTime?: string;
     revisionId?: string;
 };
+/**
+ * Data source as specified in the jaql
+ * but with required filelds
+ *
+ * @internal
+ */
+export declare type JaqlDataSourceForDto = JaqlDataSource & {
+    id: string;
+    address?: string;
+};
 export declare enum GeneralFilterType {
     INCLUDE_ALL = "INCLUDE_ALL",
     ADVANCED = "ADVANCED",

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

@@ -1,5 +1,5 @@
 import { DataSource } from '../interfaces.js';
-import { FilterJaql, JaqlDataSource, Sort } from './types.js';
+import { DateLevel, FilterJaql, JaqlDataSource, JSONObject, Sort } from './types.js';
 /**
  * @internal
  */
@@ -46,13 +46,13 @@ export interface Element {
      *
      * @internal
      */
-    serializable(): any;
+    serialize(): JSONObject;
     /**
      * Overrides JSON.stringify() behavior.
      *
      * @internal
      */
-    toJSON(): any;
+    toJSON(): JSONObject;
     /**
      * Gets the JAQL representation of this instance.
      *
@@ -337,6 +337,14 @@ export interface LevelAttribute extends Attribute {
         dateTimeLevel?: string;
         bucket?: string;
     };
+    /**
+     * Gets a {@link LevelAttribute} with the given granularity
+     *
+     * @param granularity - Date granularity
+     * @returns New instance representing {@link LevelAttribute} with provided granularity
+     * @internal
+     */
+    setGranularity(granularity: DateLevel): LevelAttribute;
 }
 /**
  * Base filter configuration
@@ -514,10 +522,6 @@ export declare function isPivotMeasure(arg: Measure | PivotMeasure): arg is Pivo
  * Data options for grand totals of a pivot table
  */
 export declare type PivotGrandTotals = {
-    /**
-     * @deprecated
-     */
-    title?: string;
     rows?: boolean;
     columns?: boolean;
 };
@@ -550,6 +554,12 @@ export interface FilterRelations {
     left: FilterRelationsNode;
     right: FilterRelationsNode;
     operator: 'AND' | 'OR';
+    /**
+     * Compose code for the filter relations
+     *
+     * @internal
+     */
+    composeCode?: string;
 }
 /**
  * Model of filter logical relations (AND/OR) from Fusion dashboard

package/dist/cjs/dimensional-model/jaql-element.d.ts

@@ -1,6 +1,6 @@
 import { DimensionalElement } from './base.js';
 import { SortDirection } from './interfaces.js';
-import { MetadataItem, MetadataItemJaql } from './types.js';
+import { JSONObject, MetadataItem, MetadataItemJaql } from './types.js';
 /**
  * This implementation wraps metadata for a JAQL query. The metadata could be
  * for a dimension, measure, or filter. We do little to no interpretation of
@@ -26,6 +26,10 @@ export declare class JaqlElement extends DimensionalElement {
     get id(): string;
     jaql(nested?: true): MetadataItemJaql;
     jaql(nested?: false | undefined): MetadataItem;
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize(): JSONObject;
 }
 /**
  * Create a JaqlElement from a MetadataItem
@@ -35,3 +39,11 @@ export declare class JaqlElement extends DimensionalElement {
  * @internal
  */
 export declare function createJaqlElement(item: MetadataItem): JaqlElement;
+/**
+ * Create a DimensionalElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a DimensionalElement
+ * @internal
+ */
+export declare function createDimensionalElementFromMetadataItem(item: MetadataItem): import("./interfaces.js").Attribute | import("./interfaces.js").BaseMeasure | import("./interfaces.js").CalculatedMeasure | JaqlElement;

package/dist/cjs/dimensional-model/jaql-element.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJaqlElement = exports.JaqlElement = void 0;
-const base_js_1 = require("./base.js");
+exports.createDimensionalElementFromMetadataItem = exports.createJaqlElement = exports.JaqlElement = void 0;
 const utils_js_1 = require("../utils.js");
+const base_js_1 = require("./base.js");
 const types_js_1 = require("./types.js");
 /**
  * This implementation wraps metadata for a JAQL query. The metadata could be
@@ -50,6 +50,16 @@ class JaqlElement extends base_js_1.DimensionalElement {
     jaql(nested) {
         return nested === true ? this.metadataItem.jaql : this.metadataItem;
     }
+    /**
+     * Gets a serializable representation of the element
+     */
+    serialize() {
+        const result = super.serialize();
+        result.__serializable = 'JaqlElement';
+        result.metadataItem = this.metadataItem;
+        result.type = this.type;
+        return result;
+    }
 }
 exports.JaqlElement = JaqlElement;
 const toMetadataType = {
@@ -71,3 +81,45 @@ function createJaqlElement(item) {
     return new JaqlElement(item, (_a = toMetadataType[item.jaql.datatype]) !== null && _a !== void 0 ? _a : 'numeric');
 }
 exports.createJaqlElement = createJaqlElement;
+/**
+ * Create a DimensionalElement from a MetadataItem
+ *
+ * @param item - the metadata item in a JAQL query
+ * @returns a DimensionalElement
+ * @internal
+ */
+function createDimensionalElementFromMetadataItem(item) {
+    const { jaql } = item;
+    // calculated measure
+    if (jaql.formula) {
+        return (0, utils_js_1.createCalculatedMeasureHelper)(jaql);
+    }
+    // measure
+    if ('agg' in jaql && jaql.dim && jaql.datatype) {
+        return (0, utils_js_1.createMeasureHelper)({
+            expression: jaql.dim,
+            dataType: jaql.datatype,
+            agg: jaql.agg || '',
+            granularity: jaql.level,
+            format: undefined,
+            sort: jaql.sort,
+            title: jaql.title,
+            dataSource: jaql.datasource,
+        });
+    }
+    // attribute
+    if (jaql.dim && jaql.datatype) {
+        return (0, utils_js_1.createAttributeHelper)({
+            expression: jaql.dim,
+            dataType: jaql.datatype,
+            granularity: jaql.level,
+            sort: jaql.sort,
+            title: jaql.title,
+            panel: item.panel,
+            dataSource: jaql.datasource,
+        });
+    }
+    // fall back to createJaqlElement
+    return createJaqlElement(item);
+}
+exports.createDimensionalElementFromMetadataItem = createDimensionalElementFromMetadataItem;