@finos/legend-data-cube 0.1.0 → 0.1.2

package/src/stores/view/DataCubeViewState.ts

@@ -24,13 +24,6 @@ import {
 import { DataCubeQuerySnapshotService } from '../services/DataCubeQuerySnapshotService.js';
 import { DataCubeInfoState } from './DataCubeInfoState.js';
 import { validateAndBuildQuerySnapshot } from '../core/DataCubeQuerySnapshotBuilder.js';
-import {
-  action,
-  computed,
-  makeObservable,
-  observable,
-  runInAction,
-} from 'mobx';
 import { DataCubeFilterEditorState } from './filter/DataCubeFilterEditorState.js';
 import { DataCubeExtendManagerState } from './extend/DataCubeExtendManagerState.js';
 import type { DataCubeState } from '../DataCubeState.js';
@@ -43,6 +36,9 @@ import { DataCubeConfiguration } from '../core/model/DataCubeConfiguration.js';
 import type { DataCubeLayoutService } from '../services/DataCubeLayoutService.js';
 import type { DataCubeAlertService } from '../services/DataCubeAlertService.js';
 import type { DataCubeSettingService } from '../services/DataCubeSettingService.js';
+import { CachedDataCubeSource } from '../core/model/CachedDataCubeSource.js';
+import { DataCubeSettingKey } from '../../__lib__/DataCubeSetting.js';
+import { PureClientVersion } from '@finos/legend-graph';
 
 export class DataCubeViewState {
   readonly dataCube: DataCubeState;
@@ -61,18 +57,12 @@ export class DataCubeViewState {
   readonly extend: DataCubeExtendManagerState;
 
   readonly initializeState = ActionState.create();
+  readonly processCacheState = ActionState.create();
 
   private _source?: DataCubeSource | undefined;
   private _originalSource?: DataCubeSource | undefined;
 
   constructor(dataCube: DataCubeState) {
-    makeObservable<DataCubeViewState, '_source'>(this, {
-      _source: observable,
-      source: computed,
-
-      initialize: action,
-    });
-
     this.dataCube = dataCube;
     this.engine = dataCube.engine;
     this.logService = dataCube.logService;
@@ -93,6 +83,10 @@ export class DataCubeViewState {
     this.extend = new DataCubeExtendManagerState(this);
   }
 
+  getOriginalSource() {
+    return this._originalSource;
+  }
+
   async generateDataCubeQuery() {
     const snapshot = this.snapshotService.currentSnapshot;
     const query = new DataCubeQuery();
@@ -112,23 +106,62 @@ export class DataCubeViewState {
   }
 
   async initializeCache() {
-    this.initializeState.inProgress();
-    const cachedSource = await this.engine.initializeCache(this.source);
-    if (cachedSource !== undefined) {
-      this._originalSource = this._source;
-      this._source = cachedSource;
+    this.processCacheState.inProgress();
+    const task = this.taskService.newTask('Initializing cache...');
+
+    try {
+      const cachedSource = await this.engine.initializeCache(this.source, {
+        debug: this.settingService.getBooleanValue(
+          DataCubeSettingKey.DEBUGGER__ENABLE_DEBUG_MODE,
+        ),
+        clientVersion: this.settingService.getBooleanValue(
+          DataCubeSettingKey.DEBUGGER__USE_DEV_CLIENT_PROTOCOL_VERSION,
+        )
+          ? PureClientVersion.VX_X_X
+          : undefined,
+      });
+      if (cachedSource) {
+        this._source = cachedSource;
+      }
+      this.processCacheState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.alertService.alertError(error, {
+        message: `Cache Processing Failure: ${error.message}`,
+      });
+      this._source = this._originalSource;
+      this.processCacheState.fail();
+    } finally {
+      this.taskService.endTask(task);
     }
-    this.initializeState.pass();
   }
 
-  async clearCache() {
-    await this.engine.clearCache();
+  async disposeCache() {
+    if (!(this._source instanceof CachedDataCubeSource)) {
+      return;
+    }
+    const cachedSource = this._source;
     this._source = this._originalSource;
+
+    this.processCacheState.inProgress();
+    const task = this.taskService.newTask('Disposing cache...');
+
+    try {
+      await this.engine.disposeCache(cachedSource);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.alertService.alertError(error, {
+        message: `Cache Processing Failure: ${error.message}`,
+      });
+    } finally {
+      this.processCacheState.complete();
+      this.taskService.endTask(task);
+    }
   }
 
   async initialize(query: DataCubeQuery) {
     this.initializeState.inProgress();
-    const task = this.taskService.newTask('Initializing');
+    const task = this.taskService.newTask('Initializing...');
 
     try {
       await Promise.all(
@@ -144,9 +177,8 @@ export class DataCubeViewState {
         }),
       );
       const source = await this.engine.processQuerySource(query.source);
-      runInAction(() => {
-        this._source = source;
-      });
+      this._source = source;
+      this._originalSource = source;
       const partialQuery = await this.engine.parseValueSpecification(
         query.query,
       );
@@ -156,7 +188,6 @@ export class DataCubeViewState {
         query,
         this.engine,
       );
-      this.engine.processInitialSnapshot?.(source, initialSnapshot);
       this.snapshotService.broadcastSnapshot(initialSnapshot);
       this.dataCube.options?.onViewInitialized?.({
         api: this.dataCube.api,

package/src/stores/view/editor/DataCubeEditorState.tsx

@@ -164,7 +164,7 @@ export class DataCubeEditorState extends DataCubeQuerySnapshotController {
     // finalize
     newSnapshot.finalize();
     if (newSnapshot.hashCode !== baseSnapshot.hashCode) {
-      const task = this.view.taskService.newTask('Validate query');
+      const task = this.view.taskService.newTask('Validating query...');
       // NOTE: Compile the query to validate. This is a helpful check for a lot of different scenarios
       // where the consistency of the query might be thrown off by changes from various parts that the
       // editor does not have full control over (i.e. extended columns, pivot cast columns, etc.)

package/src/stores/view/extend/DataCubeColumnEditorState.tsx

@@ -47,11 +47,7 @@ import {
 } from '@finos/legend-graph';
 import type { DataCubeColumnConfiguration } from '../../core/model/DataCubeConfiguration.js';
 import type { DataCubeQuerySnapshotExtendedColumn } from '../../core/DataCubeQuerySnapshot.js';
-import {
-  _lambda,
-  _serializeValueSpecification,
-  _deserializeValueSpecification,
-} from '../../core/DataCubeQueryBuilderUtils.js';
+import { _lambda } from '../../core/DataCubeQueryBuilderUtils.js';
 import { _findCol } from '../../core/model/DataCubeColumn.js';
 
 export abstract class DataCubeColumnBaseEditorState {
@@ -220,13 +216,9 @@ export abstract class DataCubeColumnBaseEditorState {
     return _lambda(
       [],
       [
-        buildExecutableQuery(
-          snapshot,
-          this.view.source,
-          () => undefined,
-          this.view.engine.filterOperations,
-          this.view.engine.aggregateOperations,
-        ),
+        buildExecutableQuery(snapshot, this.view.source, this.view.engine, {
+          skipExecutionContext: true,
+        }),
       ],
     );
   }
@@ -390,7 +382,7 @@ export class DataCubeNewColumnState extends DataCubeColumnBaseEditorState {
       {
         name: this.name,
         type: returnType,
-        mapFn: _serializeValueSpecification(query),
+        mapFn: this.view.engine.serializeValueSpecification(query),
       },
       this.isGroupLevel,
       this.columnKind,
@@ -440,7 +432,7 @@ export class DataCubeExistingColumnEditorState extends DataCubeColumnBaseEditorS
 
   override async getInitialCode(): Promise<string> {
     return this.view.engine.getValueSpecificationCode(
-      _deserializeValueSpecification(this.initialData.mapFn),
+      this.view.engine.deserializeValueSpecification(this.initialData.mapFn),
       true,
     );
   }
@@ -516,7 +508,7 @@ export class DataCubeExistingColumnEditorState extends DataCubeColumnBaseEditorS
       {
         name: this.name,
         type: returnType,
-        mapFn: _serializeValueSpecification(query),
+        mapFn: this.view.engine.serializeValueSpecification(query),
       },
       this.isGroupLevel,
       this.columnKind,

package/src/stores/view/extend/DataCubeExtendManagerState.tsx

@@ -208,7 +208,7 @@ export class DataCubeExtendManagerState extends DataCubeQuerySnapshotController
       _findCol(this.columnConfigurations, columnName),
     );
 
-    const task = this.view.taskService.newTask('Column update check');
+    const task = this.view.taskService.newTask('Checking column update...');
 
     const currentSnapshot = guaranteeNonNullable(this.getLatestSnapshot());
     const tempSnapshot = currentSnapshot.clone();
@@ -333,7 +333,7 @@ export class DataCubeExtendManagerState extends DataCubeQuerySnapshotController
       return;
     }
 
-    const task = this.view.taskService.newTask('Column delete check');
+    const task = this.view.taskService.newTask('Checking column deletion...');
 
     const currentSnapshot = guaranteeNonNullable(this.getLatestSnapshot());
     const tempSnapshot = currentSnapshot.clone();

package/src/stores/view/grid/DataCubeGridClientEngine.ts

@@ -31,11 +31,7 @@ import {
   pruneObject,
 } from '@finos/legend-shared';
 import { buildExecutableQuery } from '../../core/DataCubeQueryBuilder.js';
-import {
-  PureClientVersion,
-  type TabularDataSet,
-  V1_Lambda,
-} from '@finos/legend-graph';
+import { PureClientVersion, type TabularDataSet } from '@finos/legend-graph';
 import { makeObservable, observable, runInAction } from 'mobx';
 import type {
   DataCubeConfiguration,
@@ -55,6 +51,8 @@ import {
 import { _colSpecArrayParam } from '../../core/DataCubeQuerySnapshotBuilderUtils.js';
 import { DataCubeSettingKey } from '../../../__lib__/DataCubeSetting.js';
 import { DEFAULT_ALERT_WINDOW_CONFIG } from '../../services/DataCubeLayoutService.js';
+import type { DataCubeExecutionResult } from '../../core/DataCubeEngine.js';
+import { _lambda } from '../../core/DataCubeQueryBuilderUtils.js';
 
 type DataCubeGridClientCellValue = string | number | boolean | null | undefined;
 type DataCubeGridClientRowData = {
@@ -265,43 +263,31 @@ async function getCastColumns(
   snapshot.data.groupExtendedColumns = [];
   snapshot.data.sortColumns = [];
   snapshot.data.limit = 0;
-  const query = buildExecutableQuery(
-    snapshot,
+  const query = buildExecutableQuery(snapshot, view.source, view.engine, {
+    postProcessor: (_snapshot, sequence, funcMap, configuration, engine) => {
+      // when both pivot and groupBy present, we need to account for the count column
+      // in the cast expression
+      if (funcMap.pivot && currentSnapshot.data.groupBy) {
+        _colSpecArrayParam(funcMap.pivot, 1).colSpecs.push(_aggCountCol());
+      }
+    },
+  });
+
+  const result = await view.engine.executeQuery(
+    _lambda([], [query]),
     view.source,
-    (source) => view.engine.buildExecutionContext(source),
-    view.engine.filterOperations,
-    view.engine.aggregateOperations,
     {
-      postProcessor: (
-        _snapshot,
-        sequence,
-        funcMap,
-        configuration,
-        filterOperations,
-        aggregateOperations,
-      ) => {
-        // when both pivot and groupBy present, we need to account for the count column
-        // in the cast expression
-        if (funcMap.pivot && currentSnapshot.data.groupBy) {
-          _colSpecArrayParam(funcMap.pivot, 1).colSpecs.push(_aggCountCol());
-        }
-      },
+      debug: view.settingService.getBooleanValue(
+        DataCubeSettingKey.DEBUGGER__ENABLE_DEBUG_MODE,
+      ),
+      clientVersion: view.settingService.getBooleanValue(
+        DataCubeSettingKey.DEBUGGER__USE_DEV_CLIENT_PROTOCOL_VERSION,
+      )
+        ? PureClientVersion.VX_X_X
+        : undefined,
     },
   );
 
-  const lambda = new V1_Lambda();
-  lambda.body.push(query);
-  const result = await view.engine.executeQuery(lambda, view.source, {
-    debug: view.settingService.getBooleanValue(
-      DataCubeSettingKey.DEBUGGER__ENABLE_DEBUG_MODE,
-    ),
-    clientVersion: view.settingService.getBooleanValue(
-      DataCubeSettingKey.DEBUGGER__USE_DEV_CLIENT_PROTOCOL_VERSION,
-    )
-      ? PureClientVersion.VX_X_X
-      : undefined,
-  });
-
   return result.result.builder.columns.map((column) => ({
     name: column.name,
     type: column.type as string,
@@ -338,7 +324,7 @@ export class DataCubeGridClientServerSideDataSource
   }
 
   async fetchRows(params: IServerSideGetRowsParams<unknown, unknown>) {
-    const task = this._view.taskService.newTask('Fetching data');
+    const task = this._view.taskService.newTask('Fetching data...');
 
     // ------------------------------ SNAPSHOT ------------------------------
 
@@ -408,20 +394,18 @@ export class DataCubeGridClientServerSideDataSource
 
     // ------------------------------ DATA ------------------------------
 
+    const executableQuery = buildGridDataFetchExecutableQuery(
+      request,
+      newSnapshot,
+      this._view.source,
+      this._view.engine,
+      this._grid.isPaginationEnabled,
+    );
+    let result: DataCubeExecutionResult;
+
     try {
-      const executableQuery = buildGridDataFetchExecutableQuery(
-        request,
-        newSnapshot,
-        this._view.source,
-        (source) => this._view.engine.buildExecutionContext(source),
-        this._view.engine.filterOperations,
-        this._view.engine.aggregateOperations,
-        this._grid.isPaginationEnabled,
-      );
-      const lambda = new V1_Lambda();
-      lambda.body.push(executableQuery);
-      const result = await this._view.engine.executeQuery(
-        lambda,
+      result = await this._view.engine.executeQuery(
+        _lambda([], [executableQuery]),
         this._view.source,
         {
           debug: this._view.settingService.getBooleanValue(
@@ -434,137 +418,134 @@ export class DataCubeGridClientServerSideDataSource
             : undefined,
         },
       );
-      const rowData = buildRowData(result.result.result, newSnapshot);
-      if (
-        this._view.settingService.getBooleanValue(
-          DataCubeSettingKey.DEBUGGER__ENABLE_DEBUG_MODE,
-        )
-      ) {
-        this._view.engine.debugProcess(
-          `Execution`,
-          ['Query', result.executedQuery],
-          ['Config', `pagination=${this._grid.isPaginationEnabled}`],
-          [
-            'Stats',
-            `${rowData.length} rows, ${result.result.result.columns.length} columns`,
-          ],
-          ['SQL', result.executedSQL],
-          ['SQL Execution Time', result.executionTime],
-        );
-      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this._view.alertService.alertError(error, {
+        message: `Data Fetch Failure: ${error.message}`,
+      });
+      this._view.taskService.endTask(task);
+      params.fail();
+      return;
+    }
 
-      if (this._grid.isPaginationEnabled) {
-        params.success({ rowData });
-        // only update row count when loading the top-level drilldown data
-        if (isTopLevelRequest) {
-          runInAction(() => {
-            this.rowCount = (request.startRow ?? 0) + rowData.length;
-          });
-        }
+    const rowData = buildRowData(result.result.result, newSnapshot);
+    if (
+      this._view.settingService.getBooleanValue(
+        DataCubeSettingKey.DEBUGGER__ENABLE_DEBUG_MODE,
+      )
+    ) {
+      this._view.engine.debugProcess(
+        `Execution`,
+        ['Query', result.executedQuery],
+        [
+          'Stats',
+          `${rowData.length} rows, ${result.result.result.columns.length} columns`,
+        ],
+        ['SQL', result.executedSQL],
+        ['SQL Execution Time', result.executionTime],
+      );
+    }
+
+    if (this._grid.isPaginationEnabled) {
+      params.success({ rowData });
+      // only update row count when loading the top-level drilldown data
+      if (isTopLevelRequest) {
+        runInAction(() => {
+          this.rowCount = (request.startRow ?? 0) + rowData.length;
+        });
+      }
 
-        // toggle no-rows overlay
+      // toggle no-rows overlay
+      if (isTopLevelRequest && request.startRow === 0 && rowData.length === 0) {
+        this._grid.client.showNoRowsOverlay();
+      } else {
+        this._grid.client.hideOverlay();
+      }
+    } else {
+      // NOTE: When pagination is disabled and the user currently scrolls to somewhere in the grid, as data is fetched
+      // and the operation does not force a scroll top (for example, grouping will always force scrolling to the
+      // top, while sorting will leave scroll position as is), the grid ends up showing the wrong data because
+      // the data being displayed does not take into account the scroll position, but by the start and end row
+      // which stay constant as pagination is disabled.
+      //
+      // In order to handle this, when pagination is disabled, we tune the start and end row by setting the cache block size
+      // to a high-enough value (100k-1m). However, ag-grid use cache block size to pre-allocate memory for the rows,
+      // which means we must cap/tune this value reasonably to prevent the app from crashing.
+      //
+      // When there are just too many rows (exceeding the maximum cache block size), we will fallback to a slightly less ideal
+      // behavior by forcing a scroll top for every data fetch and also reset the cache block size to the default value to save memory
+      if (rowData.length > INTERNAL__GRID_CLIENT_MAX_CACHE_BLOCK_SIZE) {
         if (
-          isTopLevelRequest &&
-          request.startRow === 0 &&
-          rowData.length === 0
+          !this._view.settingService.getBooleanValue(
+            DataCubeSettingKey.GRID_CLIENT__SUPPRESS_LARGE_DATASET_WARNING,
+          )
         ) {
-          this._grid.client.showNoRowsOverlay();
-        } else {
-          this._grid.client.hideOverlay();
-        }
-      } else {
-        // NOTE: When pagination is disabled and the user currently scrolls to somewhere in the grid, as data is fetched
-        // and the operation does not force a scroll top (for example, grouping will always force scrolling to the
-        // top, while sorting will leave scroll position as is), the grid ends up showing the wrong data because
-        // the data being displayed does not take into account the scroll position, but by the start and end row
-        // which stay constant as pagination is disabled.
-        //
-        // In order to handle this, when pagination is disabled, we tune the start and end row by setting the cache block size
-        // to a high-enough value (100k-1m). However, ag-grid use cache block size to pre-allocate memory for the rows,
-        // which means we must cap/tune this value reasonably to prevent the app from crashing.
-        //
-        // When there are just too many rows (exceeding the maximum cache block size), we will fallback to a slightly less ideal
-        // behavior by forcing a scroll top for every data fetch and also reset the cache block size to the default value to save memory
-        if (rowData.length > INTERNAL__GRID_CLIENT_MAX_CACHE_BLOCK_SIZE) {
-          if (
-            !this._view.settingService.getBooleanValue(
-              DataCubeSettingKey.GRID_CLIENT__SUPPRESS_LARGE_DATASET_WARNING,
-            )
-          ) {
-            this._view.alertService.alert({
-              message: `Large dataset (>${INTERNAL__GRID_CLIENT_MAX_CACHE_BLOCK_SIZE} rows) detected!`,
-              text: `Overall app performance can be impacted by large dataset due to longer query execution time and increased memory usage. At its limit, the engine can crash!\nTo boost performance, consider enabling pagination while working with large dataset.`,
-              type: AlertType.WARNING,
-              actions: [
-                {
-                  label: 'Enable Pagination',
-                  handler: () => {
-                    this._grid.setPaginationEnabled(true);
-                  },
+          this._view.alertService.alert({
+            message: `Large dataset (>${INTERNAL__GRID_CLIENT_MAX_CACHE_BLOCK_SIZE} rows) detected!`,
+            text: `Overall app performance can be impacted by large dataset due to longer query execution time and increased memory usage. At its limit, the engine can crash!\nTo boost performance, consider enabling pagination while working with large dataset.`,
+            type: AlertType.WARNING,
+            actions: [
+              {
+                label: 'Enable Pagination',
+                handler: () => {
+                  this._grid.setPaginationEnabled(true);
                 },
-                {
-                  label: 'Dismiss Warning',
-                  handler: () => {
-                    this._view.settingService.updateValue(
-                      this._view.dataCube.api,
-                      DataCubeSettingKey.GRID_CLIENT__SUPPRESS_LARGE_DATASET_WARNING,
-                      true,
-                    );
-                  },
+              },
+              {
+                label: 'Dismiss Warning',
+                handler: () => {
+                  this._view.settingService.updateValue(
+                    this._view.dataCube.api,
+                    DataCubeSettingKey.GRID_CLIENT__SUPPRESS_LARGE_DATASET_WARNING,
+                    true,
+                  );
                 },
-              ],
-              windowConfig: {
-                ...DEFAULT_ALERT_WINDOW_CONFIG,
-                width: 600,
-                minWidth: 300,
-                minHeight: 150,
               },
-            });
-          }
-
-          // NOTE: when drilldown occurs, we will scroll top until the drilldown row is reached
-          params.api.ensureIndexVisible(params.parentNode.rowIndex ?? 0, 'top');
-        }
-
-        params.success({
-          rowData,
-          // Setting row count to disable infinite-scrolling when pagination is disabled
-          // See https://www.ag-grid.com/react-data-grid/infinite-scrolling/#setting-last-row-index
-          rowCount: rowData.length,
-        });
-
-        // only update row count when loading the top-level drilldown data
-        if (isTopLevelRequest) {
-          runInAction(() => {
-            this.rowCount = rowData.length;
+            ],
+            windowConfig: {
+              ...DEFAULT_ALERT_WINDOW_CONFIG,
+              width: 600,
+              minWidth: 300,
+              minHeight: 150,
+            },
           });
         }
 
-        // toggle no-rows overlay
-        if (isTopLevelRequest && rowData.length === 0) {
-          this._grid.client.showNoRowsOverlay();
-        } else {
-          this._grid.client.hideOverlay();
-        }
+        // NOTE: when drilldown occurs, we will scroll top until the drilldown row is reached
+        params.api.ensureIndexVisible(params.parentNode.rowIndex ?? 0, 'top');
       }
 
-      // Resize columns to fit content on all actions (drilldown, changing queries, fetching new page, etc.)
-      // NOTE: we might want to restrict this to only happen on certain actions
-      //
-      // `setTimeout()` is need to ensure this runs after the grid has been updated with the new data
-      // since ag-grid does not provide an event hook for this action for server-side row model.
-      setTimeout(() => {
-        this._grid.client.autoSizeAllColumns();
-      }, 0);
-    } catch (error) {
-      assertErrorThrown(error);
-      this._view.alertService.alertError(error, {
-        message: `Data Fetch Failure: ${error.message}`,
+      params.success({
+        rowData,
+        // Setting row count to disable infinite-scrolling when pagination is disabled
+        // See https://www.ag-grid.com/react-data-grid/infinite-scrolling/#setting-last-row-index
+        rowCount: rowData.length,
       });
-      params.fail();
-    } finally {
-      this._view.taskService.endTask(task);
+
+      // only update row count when loading the top-level drilldown data
+      if (isTopLevelRequest) {
+        runInAction(() => {
+          this.rowCount = rowData.length;
+        });
+      }
+
+      // toggle no-rows overlay
+      if (isTopLevelRequest && rowData.length === 0) {
+        this._grid.client.showNoRowsOverlay();
+      } else {
+        this._grid.client.hideOverlay();
+      }
     }
+
+    // Resize columns to fit content on all actions (drilldown, changing queries, fetching new page, etc.)
+    // NOTE: we might want to restrict this to only happen on certain actions
+    //
+    // `setTimeout()` is need to ensure this runs after the grid has been updated with the new data
+    // since ag-grid does not provide an event hook for this action for server-side row model.
+    setTimeout(() => {
+      this._grid.client.autoSizeAllColumns();
+    }, 0);
+    this._view.taskService.endTask(task);
   }
 
   getRows(params: IServerSideGetRowsParams<unknown, unknown>) {

package/src/stores/view/grid/DataCubeGridConfigurationBuilder.tsx

@@ -62,7 +62,6 @@ import {
 } from './DataCubeGridClientEngine.js';
 import {
   at,
-  last,
   getQueryParameters,
   getQueryParameterValue,
   isNonNullable,
@@ -758,15 +757,15 @@ function generateDefinitionForPivotResultColumns(
 
       // sort the leaf level columns based on the order of selected/configuration columns
       (currentCollection as ColDef[]).sort((a, b) => {
-        const colAName = last(
-          a.colId?.split(PIVOT_COLUMN_NAME_VALUE_SEPARATOR) ?? [],
-        );
+        const colAName = (
+          a.colId?.split(PIVOT_COLUMN_NAME_VALUE_SEPARATOR) ?? []
+        ).at(-1);
         const colAConf = colAName
           ? _findCol(configuration.columns, colAName)
           : undefined;
-        const colBName = last(
-          b.colId?.split(PIVOT_COLUMN_NAME_VALUE_SEPARATOR) ?? [],
-        );
+        const colBName = (
+          b.colId?.split(PIVOT_COLUMN_NAME_VALUE_SEPARATOR) ?? []
+        ).at(-1);
         const colBConf = colBName
           ? _findCol(configuration.columns, colBName)
           : undefined;