@finos/legend-data-cube 0.0.3 → 0.0.5

package/src/stores/core/DataCubeQueryEngine.ts

@@ -80,6 +80,7 @@ export type DataCubeQueryFunctionMap = {
   pivot?: V1_AppliedFunction | undefined;
   pivotCast?: V1_AppliedFunction | undefined;
   groupBy?: V1_AppliedFunction | undefined;
+  groupBySort?: V1_AppliedFunction | undefined;
   groupExtend?: V1_AppliedFunction | undefined;
   select?: V1_AppliedFunction | undefined;
   sort?: V1_AppliedFunction | undefined;
@@ -96,14 +97,6 @@ export enum DataCubeNumberScale {
   AUTO = 'Auto (k/m/b/t)',
 }
 
-export enum DataCubeSelectionStat {
-  COUNT = 'Count',
-  SUM = 'Sum',
-  MIN = 'Min',
-  MAX = 'Max',
-  AVERAGE = 'Average',
-}
-
 export enum DataCubeFont {
   // sans-serif
   ARIAL = 'Arial',
@@ -190,6 +183,19 @@ export enum DataCubeAggregateOperator {
   // custom
 }
 
+export enum DataCubeClientSideAggregateOperator {
+  SUM = 'sum',
+  AVERAGE = 'avg',
+  MEDIAN = 'median',
+  COUNT = 'count',
+  MIN = 'min',
+  MAX = 'max',
+  VARIANCE_POPULATION = 'var',
+  VARIANCE_SAMPLE = 'var_sample',
+  STANDARD_DEVIATION_POPULATION = 'std',
+  STANDARD_DEVIATION_SAMPLE = 'std_sample',
+}
+
 export enum DataCubeQueryFilterOperator {
   LESS_THAN = '<', // DONE
   LESS_THAN_OR_EQUAL = '<=', // DONE
@@ -232,9 +238,9 @@ export enum DataCubeQueryFilterGroupOperator {
   OR = 'or',
 }
 
-export enum DataCubeQuerySortOperator {
-  ASCENDING = 'ascending',
-  DESCENDING = 'descending',
+export enum DataCubeQuerySortDirection {
+  ASCENDING = 'Ascending',
+  DESCENDING = 'Descending',
 }
 
 export enum DataCubeColumnPinPlacement {
@@ -281,6 +287,7 @@ export function ofDataType(
 }
 
 export const PIVOT_COLUMN_NAME_VALUE_SEPARATOR = '__|__';
+
 export function isPivotResultColumnName(columnName: string) {
   return columnName.includes(PIVOT_COLUMN_NAME_VALUE_SEPARATOR);
 }
@@ -296,10 +303,13 @@ export function getPivotResultColumnBaseColumnName(columnName: string) {
   );
 }
 
+export const TREE_COLUMN_VALUE_SEPARATOR = '__/__';
 export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
 
 export const DEFAULT_REPORT_NAME = 'New Report';
-export const DEFAULT_ROW_BUFFER = 20;
+export const DEFAULT_TREE_COLUMN_SORT_DIRECTION =
+  DataCubeQuerySortDirection.ASCENDING;
+export const DEFAULT_PIVOT_STATISTIC_COLUMN_NAME = 'Total';
 
 export const DEFAULT_URL_LABEL_QUERY_PARAM = 'dataCube.linkLabel';
 export const DEFAULT_MISSING_VALUE_DISPLAY_TEXT = '';

package/src/stores/core/DataCubeQuerySnapshot.ts

@@ -58,7 +58,7 @@ export type DataCubeQuerySnapshotSimpleExtendedColumn =
   };
 
 export type DataCubeQuerySnapshotSortColumn = DataCubeQuerySnapshotColumn & {
-  operation: string;
+  direction: string;
 };
 
 export type DataCubeQuerySnapshotGroupBy = {

package/src/stores/core/DataCubeQuerySnapshotBuilder.ts

@@ -40,7 +40,7 @@ import {
 } from './DataCubeQuerySnapshot.js';
 import { assertType, guaranteeNonNullable } from '@finos/legend-shared';
 import {
-  DataCubeQuerySortOperator,
+  DataCubeQuerySortDirection,
   DataCubeFunction,
   type DataCubeQueryFunctionMap,
 } from './DataCubeQueryEngine.js';
@@ -83,57 +83,124 @@ type FunctionSequenceCompositionGroupNodePattern =
     funcs: FunctionSequenceCompositionSimpleNodePattern[];
   };
 
-// NOTE: this corresponds to the sequence:
-// extend()->filter()->select()->sort()->pivot()->cast()->groupBy()->extend()->sort()->limit()
-// which represents the ONLY query shape that we currently support
+enum _FUNCTION_SEQUENCE_COMPOSITION_PART {
+  LEAF_EXTEND = 'leaf_extend',
+  FILTER = 'filter',
+  SELECT = 'select',
+  PIVOT__GROUP = 'pivot__group',
+  PIVOT_SORT = 'pivot_sort',
+  PIVOT = 'pivot',
+  PIVOT_CAST = 'pivot_cast',
+  GROUP_BY__GROUP = 'group_by__group',
+  GROUP_BY = 'group_by',
+  GROUP_BY_SORT = 'group_by_sort',
+  GROUP_EXTEND = 'group_extend',
+  SORT = 'sort',
+  LIMIT = 'limit',
+}
+
+// This corresponds to the function sequence that we currently support:
+//
+// -> extend()
+// ->filter()
+// ->select()
+// ->sort()->pivot()->cast()
+// ->groupBy()->sort()
+// ->extend()
+// ->sort()
+// ->limit()
+//
 const _FUNCTION_SEQUENCE_COMPOSITION_PATTERN: (
   | FunctionSequenceCompositionSimpleNodePattern
   | FunctionSequenceCompositionGroupNodePattern
 )[] = [
-  { name: 'leaf_extend', func: DataCubeFunction.EXTEND }, // leaf-level extend
-  { name: 'filter', func: DataCubeFunction.FILTER },
-  { name: 'select', func: DataCubeFunction.SELECT },
   {
-    name: 'pivot_group',
+    // leaf-level extend
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.LEAF_EXTEND,
+    func: DataCubeFunction.EXTEND,
+  },
+  {
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.FILTER,
+    func: DataCubeFunction.FILTER,
+  },
+  {
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.SELECT,
+    func: DataCubeFunction.SELECT,
+  },
+  {
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.PIVOT__GROUP,
+    funcs: [
+      {
+        // sort to ensure stable column ordering
+        name: _FUNCTION_SEQUENCE_COMPOSITION_PART.PIVOT_SORT,
+        func: DataCubeFunction.SORT,
+        required: true,
+      },
+      {
+        name: _FUNCTION_SEQUENCE_COMPOSITION_PART.PIVOT,
+        func: DataCubeFunction.PIVOT,
+        required: true,
+      },
+      {
+        // cast to a relation type post pivot() to enable type-checking
+        name: _FUNCTION_SEQUENCE_COMPOSITION_PART.PIVOT_CAST,
+        func: DataCubeFunction.CAST,
+        required: true,
+      },
+    ],
+  },
+  {
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.GROUP_BY__GROUP,
     funcs: [
-      { name: 'pivot_sort', func: DataCubeFunction.SORT, required: true }, // pre-pivot sort
-      { name: 'pivot', func: DataCubeFunction.PIVOT, required: true },
-      { name: 'pivot_cast', func: DataCubeFunction.CAST, required: true }, // cast to a relation type post pivot() to enable type-checking
+      {
+        name: _FUNCTION_SEQUENCE_COMPOSITION_PART.GROUP_BY,
+        func: DataCubeFunction.GROUP_BY,
+        required: true,
+      },
+      {
+        // sort to ensure stable row ordering
+        name: _FUNCTION_SEQUENCE_COMPOSITION_PART.GROUP_BY_SORT,
+        func: DataCubeFunction.SORT,
+        required: true,
+      },
     ],
   },
-  { name: 'group_by', func: DataCubeFunction.GROUP_BY },
-  { name: 'group_extend', func: DataCubeFunction.EXTEND }, // group-level extend
-  { name: 'sort', func: DataCubeFunction.SORT },
-  { name: 'limit', func: DataCubeFunction.LIMIT },
+  {
+    // group-level extend
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.GROUP_EXTEND,
+    func: DataCubeFunction.EXTEND,
+  },
+  {
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.SORT,
+    func: DataCubeFunction.SORT,
+  },
+  {
+    name: _FUNCTION_SEQUENCE_COMPOSITION_PART.LIMIT,
+    func: DataCubeFunction.LIMIT,
+  },
 ];
 const _FUNCTION_SEQUENCE_COMPOSITION_PATTERN_REGEXP = new RegExp(
   `^${_FUNCTION_SEQUENCE_COMPOSITION_PATTERN
     .map((node) =>
       'funcs' in node
-        ? `(${node.funcs.map(
-            (childNode) =>
-              `(?<${childNode.name}><${_name(childNode.func)}>)${childNode.repeat ? '*' : !childNode.required ? '?' : ''}`,
-          )})${node.repeat ? '*' : !node.required ? '?' : ''}`
-        : `(?<${node.name}><${_name(node.func)}>)${node.repeat ? '*' : !node.required ? '?' : ''}`,
+        ? `(${node.funcs
+            .map(
+              (childNode) =>
+                `(?<${childNode.name}><${_name(childNode.func)}>____\\d+)${childNode.repeat ? '*' : !childNode.required ? '?' : ''}`,
+            )
+            .join('')})${node.repeat ? '*' : !node.required ? '?' : ''}`
+        : `(?<${node.name}><${_name(node.func)}>____\\d+)${node.repeat ? '*' : !node.required ? '?' : ''}`,
     )
     .join('')}$`,
 );
 
-type FunctionSequenceMatchingResult = {
-  sequence: V1_AppliedFunction[];
-  leafExtend: boolean;
-  pivot: boolean;
-  groupExtend: boolean;
-  sort: boolean;
-};
 /**
- * Since the query created by DataCube will be a chain call of various functions,
- * this utility function will extract that sequence of function calls as well as
- * do various basic checks for the validity, composition, and order of those functions.
+ * Turn the function sequence into a map of available functions
+ * for easier construction of the snapshot
  */
-function extractQueryFunctionSequence(
+function extractFunctionMap(
   query: V1_ValueSpecification,
-): FunctionSequenceMatchingResult {
+): DataCubeQueryFunctionMap {
   // Make sure this is a sequence of function calls
   if (!(query instanceof V1_AppliedFunction)) {
     throw new Error(
@@ -169,7 +236,7 @@ function extractQueryFunctionSequence(
 
   // Check that sequence follows the supported pattern
   const sequenceFormText = sequence
-    .map((func) => `<${_name(func.function)}>`)
+    .map((func, idx) => `<${_name(func.function)}>____${idx}`)
     .join('');
   const matchResult = sequenceFormText.match(
     _FUNCTION_SEQUENCE_COMPOSITION_PATTERN_REGEXP,
@@ -180,83 +247,30 @@ function extractQueryFunctionSequence(
     );
   }
 
-  return {
-    sequence,
-    leafExtend: Boolean(matchResult.groups?.leaf_extend),
-    pivot: Boolean(matchResult.groups?.pivot),
-    groupExtend: Boolean(matchResult.groups?.group_extend),
-    sort: Boolean(matchResult.groups?.sort),
+  const _process = (key: string): V1_AppliedFunction | undefined => {
+    const match = matchResult.groups?.[key];
+    if (!match || match.indexOf('____') === -1) {
+      return undefined;
+    }
+    const idx = Number(match.split('____')[1]);
+    if (isNaN(idx) || idx >= sequence.length) {
+      return undefined;
+    }
+    return sequence[idx];
   };
-}
-
-/**
- * Turn the function sequence into a map of available functions
- * for easier construction of the snapshot
- */
-function extractFunctionMap(
-  sequenceMatchingResult: FunctionSequenceMatchingResult,
-): DataCubeQueryFunctionMap {
-  const {
-    sequence,
-    leafExtend: hasLeafExtend,
-    groupExtend: hasGroupExtend,
-    pivot: hasPivot,
-    sort: hasSort,
-  } = sequenceMatchingResult;
-  const leafExtend = hasLeafExtend
-    ? sequence.find((func) =>
-        matchFunctionName(func.function, DataCubeFunction.EXTEND),
-      )
-    : undefined;
-  const filter = sequence.find((func) =>
-    matchFunctionName(func.function, DataCubeFunction.FILTER),
-  );
-  const select = sequence.find((func) =>
-    matchFunctionName(func.function, DataCubeFunction.SELECT),
-  );
-  const pivotSort = hasPivot
-    ? sequence.find((func) =>
-        matchFunctionName(func.function, DataCubeFunction.SORT),
-      )
-    : undefined;
-  const pivot = hasPivot
-    ? sequence.find((func) =>
-        matchFunctionName(func.function, DataCubeFunction.PIVOT),
-      )
-    : undefined;
-  const pivotCast = hasPivot
-    ? sequence.find((func) =>
-        matchFunctionName(func.function, DataCubeFunction.CAST),
-      )
-    : undefined;
-  const groupBy = sequence.find((func) =>
-    matchFunctionName(func.function, DataCubeFunction.GROUP_BY),
-  );
-  const groupExtend = hasGroupExtend
-    ? sequence.find((func) =>
-        matchFunctionName(func.function, DataCubeFunction.EXTEND),
-      )
-    : undefined;
-  const sort = hasSort
-    ? sequence.find((func) =>
-        matchFunctionName(func.function, DataCubeFunction.SORT),
-      )
-    : undefined;
-  const limit = sequence.find((func) =>
-    matchFunctionName(func.function, DataCubeFunction.LIMIT),
-  );
 
   return {
-    leafExtend: leafExtend,
-    select,
-    filter,
-    groupBy,
-    pivotSort,
-    pivot,
-    pivotCast,
-    groupExtend,
-    sort,
-    limit,
+    leafExtend: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.LEAF_EXTEND),
+    select: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.SELECT),
+    filter: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.FILTER),
+    pivotSort: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.PIVOT_SORT),
+    pivot: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.PIVOT_CAST),
+    pivotCast: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.PIVOT_CAST),
+    groupBy: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.GROUP_BY),
+    groupBySort: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.GROUP_BY_SORT),
+    groupExtend: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.GROUP_EXTEND),
+    sort: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.SORT),
+    limit: _process(_FUNCTION_SEQUENCE_COMPOSITION_PART.LIMIT),
   };
 }
 
@@ -277,8 +291,7 @@ export function validateAndBuildQuerySnapshot(
   // Build the function call sequence and the function map to make the
   // analysis more ergonomic
 
-  const sequenceMatchingResult = extractQueryFunctionSequence(partialQuery);
-  const funcMap = extractFunctionMap(sequenceMatchingResult);
+  const funcMap = extractFunctionMap(partialQuery);
   const snapshot = DataCubeQuerySnapshot.create(
     baseQuery.name,
     baseQuery.source.runtime,
@@ -321,7 +334,7 @@ export function validateAndBuildQuerySnapshot(
 
   // --------------------------------- PIVOT ---------------------------------
   /** TODO: @datacube roundtrip */
-  // TODO: verify group-by agg columns, pivot agg columns and configuration agree
+  // TODO: verify groupBy agg columns, pivot agg columns and configuration agree
 
   // --------------------------------- GROUP BY ---------------------------------
 
@@ -330,7 +343,8 @@ export function validateAndBuildQuerySnapshot(
       columns: _colSpecArrayParam(funcMap.groupBy, 0).colSpecs.map((colSpec) =>
         _col(colSpec),
       ),
-      // TODO: verify group-by agg columns, pivot agg columns and configuration agree
+      // TODO: verify groupBy agg columns, pivot agg columns and configuration agree
+      // TODO: verify groupBy sort columns and configuration agree
     };
   }
 
@@ -348,10 +362,10 @@ export function validateAndBuildQuerySnapshot(
         ]);
         return {
           ..._col(_colSpecParam(sortColFunc, 0)),
-          operation:
+          direction:
             _name(sortColFunc.function) === DataCubeFunction.ASC
-              ? DataCubeQuerySortOperator.ASCENDING
-              : DataCubeQuerySortOperator.DESCENDING,
+              ? DataCubeQuerySortDirection.ASCENDING
+              : DataCubeQuerySortDirection.DESCENDING,
         };
       },
     );
@@ -394,12 +408,13 @@ export function validateAndBuildQuerySnapshot(
     DataCubeConfiguration.serialization.toJson(configuration);
   /**
    * TODO: @datacube roundtrip - implement the logic to reconcile the configuration with the query
-   * - columns (missing/extra columns - remove or generate default column configuration)
-   * - column kind
-   * - column type
-   * - base off the type, check the settings
-   * - aggregation
-   * - verify group-by agg columns, pivot agg columns and configuration agree
+   * - [ ] columns (missing/extra columns - remove or generate default column configuration)
+   * - [ ] column kind
+   * - [ ] column type
+   * - [ ] base off the type, check the settings
+   * - [ ] aggregation
+   * - [ ] verify groupBy agg columns, pivot agg columns and configuration agree
+   * - [ ] verify groupBy sort columns and tree column sort direction configuration agree
    */
 
   return snapshot.finalize();

package/src/stores/core/DataCubeQuerySnapshotBuilderUtils.ts

@@ -19,7 +19,6 @@ import {
   V1_ClassInstance,
   V1_ColSpec,
   V1_ColSpecArray,
-  V1_Lambda,
   extractElementNameFromPath as _name,
   matchFunctionName,
   type V1_ValueSpecification,
@@ -28,14 +27,11 @@ import { type DataCubeQuerySnapshotColumn } from './DataCubeQuerySnapshot.js';
 import {
   assertTrue,
   assertType,
+  guaranteeNonNullable,
   guaranteeType,
-  UnsupportedOperationError,
   type Clazz,
 } from '@finos/legend-shared';
-import {
-  DataCubeFunction,
-  DataCubeAggregateOperator,
-} from './DataCubeQueryEngine.js';
+import { TREE_COLUMN_VALUE_SEPARATOR } from './DataCubeQueryEngine.js';
 
 // --------------------------------- UTILITIES ---------------------------------
 
@@ -90,108 +86,38 @@ export function _funcMatch(
   return value;
 }
 
-// TODO: move these functions out into aggregator utils when we make agg operator handling systematic
-// similar to what we did with filter
-function _aggFuncMatch(
-  value: V1_ValueSpecification | undefined,
-  functionNames: string | string[],
-) {
-  assertType(
-    value,
-    V1_Lambda,
-    `Can't process aggregation: Found unexpected value specification type`,
-  );
-  return _funcMatch(value.body[0], functionNames);
-}
+// --------------------------------- BUILDING BLOCKS ---------------------------------
 
-export function _aggCol(
-  colSpec: V1_ColSpec,
-  column: DataCubeQuerySnapshotColumn,
+/**
+ * This method prunes expanded paths that are no longer valid due to changes in group by columns.
+ * It finds the last common group by column between the previous and current group by columns and
+ * prune the expanded paths beyond that point.
+ */
+export function _pruneExpandedPaths(
+  prevGroupByCols: DataCubeQuerySnapshotColumn[],
+  currentGroupByCols: DataCubeQuerySnapshotColumn[],
+  expandedPaths: string[],
 ) {
-  const func = _aggFuncMatch(
-    colSpec.function2,
-    Object.values(DataCubeFunction),
-  );
-  if (matchFunctionName(func.function, DataCubeFunction.COUNT)) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.COUNT,
-      parameters: [],
-    };
-  } else if (matchFunctionName(func.function, DataCubeFunction.SUM)) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.SUM,
-      parameters: [],
-    };
-  } else if (matchFunctionName(func.function, DataCubeFunction.AVERAGE)) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.AVERAGE,
-      parameters: [],
-    };
-  } else if (matchFunctionName(func.function, DataCubeFunction.MIN)) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.MIN,
-      parameters: [],
-    };
-  } else if (matchFunctionName(func.function, DataCubeFunction.MAX)) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.MAX,
-      parameters: [],
-    };
-  } else if (matchFunctionName(func.function, DataCubeFunction.FIRST)) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.FIRST,
-      parameters: [],
-    };
-  } else if (matchFunctionName(func.function, DataCubeFunction.LAST)) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.LAST,
-      parameters: [],
-    };
-  } else if (
-    matchFunctionName(func.function, DataCubeFunction.VARIANCE_POPULATION)
-  ) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.VARIANCE_POPULATION,
-      parameters: [],
-    };
-  } else if (
-    matchFunctionName(func.function, DataCubeFunction.VARIANCE_SAMPLE)
-  ) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.VARIANCE_SAMPLE,
-      parameters: [],
-    };
-  } else if (
-    matchFunctionName(
-      func.function,
-      DataCubeFunction.STANDARD_DEVIATION_POPULATION,
-    )
-  ) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.STANDARD_DEVIATION_POPULATION,
-      parameters: [],
-    };
-  } else if (
-    matchFunctionName(func.function, DataCubeFunction.STANDARD_DEVIATION_SAMPLE)
-  ) {
-    return {
-      ...column,
-      operation: DataCubeAggregateOperator.STANDARD_DEVIATION_SAMPLE,
-      parameters: [],
-    };
-  } else {
-    throw new UnsupportedOperationError(
-      `Unsupported aggregate function '${func.function}'`,
-    );
+  const length = Math.min(prevGroupByCols.length, currentGroupByCols.length);
+  if (!length) {
+    return [];
+  }
+  let lastCommonIndex = -1;
+  for (let i = 0; i < length; i++) {
+    if (
+      guaranteeNonNullable(prevGroupByCols[i]).name !==
+        guaranteeNonNullable(currentGroupByCols[i]).name ||
+      guaranteeNonNullable(prevGroupByCols[i]).type !==
+        guaranteeNonNullable(currentGroupByCols[i]).type
+    ) {
+      break;
+    }
+    lastCommonIndex = i;
   }
+  return expandedPaths
+    .filter(
+      (path) =>
+        path.split(TREE_COLUMN_VALUE_SEPARATOR).length <= lastCommonIndex + 1,
+    )
+    .sort();
 }

package/src/stores/core/DataCubeQuerySnapshotManager.ts

@@ -63,7 +63,7 @@ export abstract class DataCubeQuerySnapshotController
         '\nPrevious Snapshot',
         this.latestSnapshot ?? {},
         '\nDiff',
-        deepDiff(snapshot, this.latestSnapshot ?? {}),
+        deepDiff(this.latestSnapshot ?? {}, snapshot),
       );
     }
     this.latestSnapshot = snapshot;

package/src/stores/editor/DataCubeEditorGeneralPropertiesPanelState.ts

@@ -16,7 +16,7 @@
 
 import { action, makeObservable, observable } from 'mobx';
 import type { DataCubeViewState } from '../DataCubeViewState.js';
-import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
+import { type DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
 import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
 import type { DataCubeEditorState } from './DataCubeEditorState.js';
 import { DataCubeEditorMutableConfiguration } from './DataCubeEditorMutableConfiguration.js';
@@ -34,14 +34,15 @@ export class DataCubeEditorGeneralPropertiesPanelState
 
   constructor(editor: DataCubeEditorState) {
     makeObservable(this, {
+      configuration: observable,
+
       name: observable,
       setName: action,
 
       limit: observable,
       setLimit: action,
 
-      configuration: observable,
-      setConfiguration: action,
+      applySnaphot: action,
     });
 
     this.editor = editor;
@@ -56,10 +57,6 @@ export class DataCubeEditorGeneralPropertiesPanelState
     this.limit = val;
   }
 
-  setConfiguration(val: DataCubeEditorMutableConfiguration) {
-    this.configuration = val;
-  }
-
   applySnaphot(
     snapshot: DataCubeQuerySnapshot,
     configuration: DataCubeConfiguration,
@@ -70,8 +67,8 @@ export class DataCubeEditorGeneralPropertiesPanelState
         ? snapshot.data.limit
         : -1,
     );
-    this.setConfiguration(
-      DataCubeEditorMutableConfiguration.create(snapshot.data.configuration),
+    this.configuration = DataCubeEditorMutableConfiguration.create(
+      snapshot.data.configuration,
     );
   }