@finos/legend-application-repl 0.0.28 → 0.0.30

package/src/stores/dataCube/core/DataCubeQuerySnapshotBuilder.ts

@@ -0,0 +1,398 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/***************************************************************************************
+ * [CORE]
+ *
+ * These are utilities used to build the query snapshot from the executable query.
+ * This is needed when we initialize the application by loading a persisted query.
+ ***************************************************************************************/
+
+import {
+  V1_AppliedFunction,
+  V1_CInteger,
+  V1_ClassInstance,
+  V1_ColSpec,
+  V1_ColSpecArray,
+  V1_Collection,
+  V1_serializeValueSpecification,
+  extractElementNameFromPath as _name,
+  matchFunctionName,
+  type V1_ValueSpecification,
+} from '@finos/legend-graph';
+import type { DataCubeQuery } from '../../../server/models/DataCubeQuery.js';
+import {
+  DataCubeQuerySnapshot,
+  DataCubeQuerySnapshotSortDirection,
+  type DataCubeQuerySnapshotColumn,
+} from './DataCubeQuerySnapshot.js';
+import {
+  assertTrue,
+  assertType,
+  guaranteeNonNullable,
+  guaranteeType,
+  type Clazz,
+} from '@finos/legend-shared';
+import {
+  DataCubeFunction,
+  type DataCubeQueryFunctionMap,
+} from './DataCubeQueryEngine.js';
+
+// --------------------------------- UTILITIES ---------------------------------
+
+function _param<T extends V1_ValueSpecification>(
+  func: V1_AppliedFunction,
+  paramIdx: number,
+  clazz: Clazz<T>,
+): T {
+  assertTrue(
+    func.parameters.length >= paramIdx + 1,
+    `Can't process ${_name(func.function)}: Expected at least ${paramIdx + 1} parameter(s)`,
+  );
+  return guaranteeType(
+    func.parameters[paramIdx],
+    clazz,
+    `Can't process ${_name(func.function)}: Found unexpected type for parameter at index ${paramIdx}`,
+  );
+}
+
+function _colSpecParam(func: V1_AppliedFunction, paramIdx: number): V1_ColSpec {
+  return guaranteeType(
+    _param(func, paramIdx, V1_ClassInstance).value,
+    V1_ColSpec,
+    `Can't process ${_name(func.function)}: Expected parameter at index ${paramIdx} to be a column specification`,
+  );
+}
+
+function _colSpecArrayParam(
+  func: V1_AppliedFunction,
+  paramIdx: number,
+): V1_ColSpecArray {
+  return guaranteeType(
+    _param(func, paramIdx, V1_ClassInstance).value,
+    V1_ColSpecArray,
+    `Can't process ${_name(func.function)}: Expected parameter at index ${paramIdx} to be a column specification list`,
+  );
+}
+
+function _funcMatch(
+  value: V1_ValueSpecification,
+  functionNames: string | string[],
+): V1_AppliedFunction {
+  assertType(
+    value,
+    V1_AppliedFunction,
+    `Can't process function: Found unexpected value specification type`,
+  );
+  assertTrue(
+    matchFunctionName(
+      value.function,
+      Array.isArray(functionNames) ? functionNames : [functionNames],
+    ),
+    `Can't process function: Expected function name to be one of [${Array.isArray(functionNames) ? functionNames.join(', ') : functionNames}]`,
+  );
+  return value;
+}
+
+// --------------------------------- BUILDING BLOCKS ---------------------------------
+
+const _SUPPORTED_TOP_LEVEL_FUNCTIONS: {
+  func: string;
+  parameters: number;
+}[] = [
+  { func: DataCubeFunction.EXTEND, parameters: 1 },
+  { func: DataCubeFunction.FILTER, parameters: 1 },
+  { func: DataCubeFunction.GROUP_BY, parameters: 3 },
+  { func: DataCubeFunction.LIMIT, parameters: 1 },
+  { func: DataCubeFunction.PIVOT, parameters: 3 },
+  { func: DataCubeFunction.SELECT, parameters: 1 },
+  { func: DataCubeFunction.SORT, parameters: 1 },
+
+  { func: DataCubeFunction.CAST, parameters: 1 },
+];
+
+// NOTE: this corresponds to the sequence:
+// extend()->filter()->groupBy()->select()->pivot()->cast()->extend()->sort()->limit()
+// which represents the ONLY query shape that we currently support
+const _FUNCTION_SEQUENCE_COMPOSITION_PATTERN: {
+  func: string;
+  repeat?: boolean | undefined;
+  required?: boolean | undefined;
+}[] = [
+  { func: DataCubeFunction.EXTEND },
+  { func: DataCubeFunction.FILTER },
+  { func: DataCubeFunction.GROUP_BY },
+  { func: DataCubeFunction.PIVOT },
+  { func: DataCubeFunction.CAST },
+  { func: DataCubeFunction.EXTEND },
+  { func: DataCubeFunction.SELECT },
+  { func: DataCubeFunction.SORT },
+  { func: DataCubeFunction.LIMIT },
+];
+const _FUNCTION_SEQUENCE_COMPOSITION_PATTERN_REGEXP = new RegExp(
+  `^${_FUNCTION_SEQUENCE_COMPOSITION_PATTERN
+    .map(
+      (entry) =>
+        `(?:<${_name(entry.func)}>)${entry.repeat ? '*' : !entry.required ? '?' : ''}`,
+    )
+    .join('')}$`,
+);
+
+/**
+ * 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.
+ */
+function extractQueryFunctionSequence(query: V1_ValueSpecification) {
+  // Make sure this is a sequence of function calls
+  if (!(query instanceof V1_AppliedFunction)) {
+    throw new Error(
+      `Query must be a sequence of function calls (e.g. x()->y()->z())`,
+    );
+  }
+  const sequence: V1_AppliedFunction[] = [];
+  let currentQuery = query;
+  while (currentQuery instanceof V1_AppliedFunction) {
+    const supportedFunc = _SUPPORTED_TOP_LEVEL_FUNCTIONS.find((spec) =>
+      matchFunctionName(currentQuery.function, spec.func),
+    );
+
+    // Check that all functions in sequence are supported
+    if (!supportedFunc) {
+      throw new Error(`Found unsupported function ${currentQuery.function}()`);
+    }
+    if (currentQuery.parameters.length > supportedFunc.parameters) {
+      const vs = currentQuery.parameters[0];
+      if (!(vs instanceof V1_AppliedFunction)) {
+        throw new Error(
+          `Query must be a sequence of function calls (e.g. x()->y()->z())`,
+        );
+      }
+      currentQuery.parameters = currentQuery.parameters.slice(1);
+      sequence.unshift(currentQuery);
+      currentQuery = vs;
+    } else {
+      sequence.unshift(currentQuery);
+      break;
+    }
+  }
+
+  // Check that sequence follows the supported pattern
+  const sequenceFormText = sequence
+    .map((func) => `<${_name(func.function)}>`)
+    .join('');
+  if (!sequenceFormText.match(_FUNCTION_SEQUENCE_COMPOSITION_PATTERN_REGEXP)) {
+    throw new Error(
+      `Unsupported function composition ${sequence.map((fn) => `${_name(fn.function)}()`).join('->')} (supported composition: ${_FUNCTION_SEQUENCE_COMPOSITION_PATTERN.map((entry) => `${_name(entry.func)}()`).join('->')})`,
+    );
+  }
+
+  // Special checks
+  // Check that the first and second extend() must be separated by either groupBy() or pivot() (i.e. aggregation)
+  const firstExtendIndex = sequence.findIndex((func) =>
+    matchFunctionName(func.function, DataCubeFunction.EXTEND),
+  );
+  const secondExtendIndex = sequence.findLastIndex((func) =>
+    matchFunctionName(func.function, DataCubeFunction.EXTEND),
+  );
+  if (firstExtendIndex !== -1 && firstExtendIndex !== secondExtendIndex) {
+    const seq = sequence.slice(firstExtendIndex + 1, secondExtendIndex);
+    if (
+      !seq.some(
+        (func) =>
+          matchFunctionName(func.function, DataCubeFunction.GROUP_BY) ||
+          matchFunctionName(func.function, DataCubeFunction.PIVOT),
+      )
+    ) {
+      throw new Error(
+        `Found invalid usage of group-level extend() for query without aggregation such as pivot() and groupBy()`,
+      );
+    }
+  }
+
+  // Check that pivot() and cast() must co-present and stand consecutively in the sequence
+  const pivotFunc = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.PIVOT),
+  );
+  const castFunc = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.CAST),
+  );
+  if (Boolean(pivotFunc) !== Boolean(castFunc)) {
+    throw new Error(`Found usage of dynamic function pivot() without casting`);
+  }
+
+  return sequence;
+}
+
+/**
+ * Turn the function sequence into a map of available functions
+ * for easier construction of the snapshot
+ */
+function extractFunctionMap(
+  sequence: V1_AppliedFunction[],
+): DataCubeQueryFunctionMap {
+  let leafExtend: V1_AppliedFunction | undefined = undefined;
+  let groupExtend: V1_AppliedFunction | undefined = undefined;
+  const aggregationFuncIndex = sequence.findLastIndex((func) =>
+    matchFunctionName(func.function, [
+      DataCubeFunction.PIVOT,
+      DataCubeFunction.GROUP_BY,
+    ]),
+  );
+  const firstExtendIndex = sequence.findIndex((func) =>
+    matchFunctionName(func.function, DataCubeFunction.EXTEND),
+  );
+  const secondExtendIndex = sequence.findLastIndex((func) =>
+    matchFunctionName(func.function, DataCubeFunction.EXTEND),
+  );
+  if (aggregationFuncIndex !== -1) {
+    if (firstExtendIndex !== secondExtendIndex) {
+      leafExtend = sequence[firstExtendIndex];
+      groupExtend = sequence[secondExtendIndex];
+    }
+  } else {
+    if (firstExtendIndex !== -1) {
+      leafExtend = sequence[firstExtendIndex];
+    }
+  }
+
+  const filter = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.FILTER),
+  );
+  const groupBy = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.GROUP_BY),
+  );
+  const select = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.SELECT),
+  );
+  const pivot = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.PIVOT),
+  );
+  const cast = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.CAST),
+  );
+  const sort = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.SORT),
+  );
+  const limit = sequence.find((func) =>
+    matchFunctionName(func.function, DataCubeFunction.LIMIT),
+  );
+  return {
+    leafExtend,
+    filter,
+    groupBy,
+    pivot,
+    pivotCast: cast,
+    groupExtend,
+    select,
+    sort,
+    limit,
+  };
+}
+
+// --------------------------------- MAIN ---------------------------------
+
+/**
+ * Analyze the partial query to build a query snapshot.
+ *
+ * Implementation-wise, this extracts the function call sequence, then walk the
+ * sequence in order to fill in the information for the snapshot.
+ */
+export function validateAndBuildQuerySnapshot(
+  partialQuery: V1_ValueSpecification,
+  sourceQuery: V1_ValueSpecification,
+  baseQuery: DataCubeQuery,
+) {
+  // --------------------------------- BASE ---------------------------------
+  // Build the function call sequence and the function map to make the
+  // analysis more ergonomic
+
+  const sequence = extractQueryFunctionSequence(partialQuery);
+  const funcMap = extractFunctionMap(sequence);
+  const snapshot = DataCubeQuerySnapshot.create(
+    baseQuery.name,
+    baseQuery.source.runtime,
+    V1_serializeValueSpecification(sourceQuery, []),
+    baseQuery.configuration,
+  );
+  const data = snapshot.data;
+  const colsMap = new Map<string, DataCubeQuerySnapshotColumn>();
+  const _col = (colSpec: V1_ColSpec) =>
+    guaranteeNonNullable(colsMap.get(colSpec.name));
+
+  // --------------------------------- SOURCE ---------------------------------
+
+  data.originalColumns = baseQuery.source.columns;
+  data.originalColumns.map((col) => colsMap.set(col.name, col));
+
+  // --------------------------------- LEAF EXTEND ---------------------------------
+  // TODO: @akphi - implement this
+
+  // --------------------------------- FILTER ---------------------------------
+  // TODO: @akphi - implement this
+
+  // --------------------------------- GROUP BY ---------------------------------
+  // TODO: @akphi - implement this
+
+  // --------------------------------- PIVOT ---------------------------------
+  // TODO: @akphi - implement this
+
+  // --------------------------------- CAST ---------------------------------
+  // TODO: @akphi - implement this
+
+  // --------------------------------- GROUP EXTEND ---------------------------------
+  // TODO: @akphi - implement this
+
+  // --------------------------------- SORT ---------------------------------
+
+  if (funcMap.sort) {
+    data.sortColumns = _param(funcMap.sort, 0, V1_Collection).values.map(
+      (value) => {
+        const sortColFunc = _funcMatch(value, [
+          DataCubeFunction.ASC,
+          DataCubeFunction.DESC,
+        ]);
+        return {
+          ..._col(_colSpecParam(sortColFunc, 0)),
+          direction:
+            _name(sortColFunc.function) === DataCubeFunction.ASC
+              ? DataCubeQuerySnapshotSortDirection.ASCENDING
+              : DataCubeQuerySnapshotSortDirection.DESCENDING,
+        };
+      },
+    );
+  }
+
+  // --------------------------------- SELECT ---------------------------------
+
+  if (funcMap.select) {
+    data.selectColumns = _colSpecArrayParam(funcMap.select, 0).colSpecs.map(
+      (colSpec) => ({
+        ..._col(colSpec),
+      }),
+    );
+  }
+
+  // --------------------------------- LIMIT ---------------------------------
+
+  if (funcMap.limit) {
+    const value = funcMap.limit.parameters[0];
+    assertType(value, V1_CInteger);
+    data.limit = value.value;
+  }
+
+  return snapshot;
+}

package/src/stores/dataCube/core/DataCubeQuerySnapshotManager.ts

@@ -19,21 +19,26 @@ import type { DataCubeState } from '../DataCubeState.js';
 import type { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
 import type { DataCubeQuerySnapshotSubscriber } from './DataCubeQuerySnapshotSubscriber.js';
 import {
+  IllegalStateError,
   LogEvent,
   assertErrorThrown,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
+import type { DataCubeQuery } from '../../../server/models/DataCubeQuery.js';
 
 // TODO: use this when we implement undo/redo
 // const DATA_CUBE_MAX_SNAPSHOT_COUNT = 100;
 
 export class DataCubeQuerySnapshotManager {
-  private readonly dataCubeState: DataCubeState;
+  private readonly dataCube: DataCubeState;
   private readonly subscribers: DataCubeQuerySnapshotSubscriber[] = [];
   private readonly snapshots: DataCubeQuerySnapshot[] = [];
 
-  constructor(dataCubeState: DataCubeState) {
-    this.dataCubeState = dataCubeState;
+  private _initialSnapshot: DataCubeQuerySnapshot | undefined;
+  private _initialQuery: DataCubeQuery | undefined;
+
+  constructor(dataCube: DataCubeState) {
+    this.dataCube = dataCube;
   }
 
   get currentSnapshot(): DataCubeQuerySnapshot {
@@ -44,6 +49,33 @@ export class DataCubeQuerySnapshotManager {
     this.subscribers.push(subscriber);
   }
 
+  initialize(
+    initialSnapshot: DataCubeQuerySnapshot,
+    initialQuery: DataCubeQuery,
+  ): void {
+    if (this._initialSnapshot || this._initialQuery) {
+      throw new IllegalStateError(
+        `Snapshot manager has already been initialized`,
+      );
+    }
+    this._initialSnapshot = initialSnapshot;
+    this._initialQuery = initialQuery;
+  }
+
+  get initialSnapshot(): DataCubeQuerySnapshot {
+    return guaranteeNonNullable(
+      this._initialSnapshot,
+      `Snapshot manager has not been initialized`,
+    );
+  }
+
+  get initialQuery(): DataCubeQuery {
+    return guaranteeNonNullable(
+      this._initialQuery,
+      `Snapshot manager has not been initialized`,
+    );
+  }
+
   broadcastSnapshot(snapshot: DataCubeQuerySnapshot): void {
     this.snapshots.push(snapshot);
     this.subscribers.forEach((subscriber) => {
@@ -51,11 +83,11 @@ export class DataCubeQuerySnapshotManager {
       if (currentSnapshot?.uuid !== snapshot.uuid) {
         subscriber.receiveSnapshot(snapshot).catch((error: unknown) => {
           assertErrorThrown(error);
-          this.dataCubeState.applicationStore.logService.error(
+          this.dataCube.application.logService.error(
             LogEvent.create(
               APPLICATION_EVENT.ILLEGAL_APPLICATION_STATE_OCCURRED,
             ),
-            `Error ocurred when subscribers receive and apply new snapshot should be handled gracefully`,
+            `Subscribers receiving and applying new snapshot should be handled gracefully`,
             error,
           );
         });

package/src/stores/dataCube/core/DataCubeQuerySnapshotSubscriber.ts

@@ -14,18 +14,26 @@
  * limitations under the License.
  */
 
+import type { LegendREPLApplicationStore } from '../../LegendREPLBaseStore.js';
+import type { DataCubeState } from '../DataCubeState.js';
+import type { DataCubeEngine } from './DataCubeEngine.js';
 import type { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
-import type { DataCubeQuerySnapshotManager } from './DataCubeQuerySnapshotManager.js';
 
 export abstract class DataCubeQuerySnapshotSubscriber {
-  readonly manager: DataCubeQuerySnapshotManager;
+  readonly dataCube!: DataCubeState;
+  readonly application!: LegendREPLApplicationStore;
+  readonly engine!: DataCubeEngine;
+
   private latestSnapshot: DataCubeQuerySnapshot | undefined;
 
-  constructor(snapshotManager: DataCubeQuerySnapshotManager) {
-    this.manager = snapshotManager;
+  constructor(dataCube: DataCubeState) {
+    this.dataCube = dataCube;
+    this.application = dataCube.application;
+    this.engine = dataCube.engine;
   }
 
   abstract applySnapshot(snapshot: DataCubeQuerySnapshot): Promise<void>;
+  abstract initialize(): Promise<void>;
 
   async receiveSnapshot(snapshot: DataCubeQuerySnapshot): Promise<void> {
     this.latestSnapshot = snapshot;
@@ -34,7 +42,7 @@ export abstract class DataCubeQuerySnapshotSubscriber {
 
   publishSnapshot(snapshot: DataCubeQuerySnapshot): void {
     this.latestSnapshot = snapshot;
-    this.manager.broadcastSnapshot(snapshot);
+    this.dataCube.snapshotManager.broadcastSnapshot(snapshot);
   }
 
   getLatestSnapshot(): DataCubeQuerySnapshot | undefined {

package/src/stores/dataCube/editor/{DataCubeEditorCodeState.ts → DataCubeEditorCodePanelState.ts}

@@ -30,7 +30,7 @@ import {
   V1_ParserError,
 } from '@finos/legend-graph';
 
-export class DataCubeQueryEditorState {
+class DataCubeQueryEditorState {
   uuid = uuid();
   query: string;
   parserError?: ParserError | undefined;
@@ -77,13 +77,13 @@ export class DataCubeQueryEditorState {
   }
 }
 
-export class DataCubeQueryCodeEditorState {
-  readonly dataCubeState!: DataCubeState;
+export class DataCubeEditorCodePanelState {
+  readonly dataCube!: DataCubeState;
 
   queryEditorState!: DataCubeQueryEditorState;
   currentSubQuery?: string | undefined;
 
-  constructor(dataCubeState: DataCubeState) {
+  constructor(dataCube: DataCubeState) {
     makeObservable(this, {
       currentSubQuery: observable,
       queryEditorState: observable,
@@ -91,7 +91,7 @@ export class DataCubeQueryCodeEditorState {
       parseQuery: flow,
     });
 
-    this.dataCubeState = dataCubeState;
+    this.dataCube = dataCube;
     this.queryEditorState = new DataCubeQueryEditorState('');
   }
 
@@ -103,7 +103,7 @@ export class DataCubeQueryCodeEditorState {
     try {
       this.queryEditorState.setParserError(undefined);
       yield flowResult(
-        this.dataCubeState.editorStore.client.parseQuery({
+        this.dataCube.replStore.client.parseQuery({
           code: `|${this.queryEditorState.query}`,
         }),
       );

package/src/stores/dataCube/editor/DataCubeEditorColumnsSelectorState.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { makeObservable, observable, action } from 'mobx';
+
+export abstract class DataCubeEditorColumnsSelectorColumnState {
+  abstract get name(): string;
+}
+
+export class DataCubeEditorColumnsSelectorState<
+  T extends DataCubeEditorColumnsSelectorColumnState,
+> {
+  availableColumns: T[] = [];
+  selectedColumns: T[] = [];
+  availableColumnsSearchText = '';
+  selectedColumnsSearchText = '';
+
+  constructor() {
+    makeObservable(this, {
+      availableColumns: observable,
+      selectedColumns: observable,
+      availableColumnsSearchText: observable,
+      selectedColumnsSearchText: observable,
+      setAvailableColumns: action,
+      setSelectedColumns: action,
+      setSelectedColumnsSearchText: action,
+      setAvailableColumnsSearchText: action,
+    });
+  }
+
+  setAvailableColumns(val: T[]): void {
+    this.availableColumns = val
+      .slice()
+      .sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  setSelectedColumns(val: T[]): void {
+    this.selectedColumns = val;
+  }
+
+  setAvailableColumnsSearchText(val: string): void {
+    this.availableColumnsSearchText = val;
+  }
+
+  setSelectedColumnsSearchText(val: string): void {
+    this.selectedColumnsSearchText = val;
+  }
+}

package/src/stores/dataCube/editor/DataCubeEditorGeneralPropertiesPanelState.ts

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { action, makeObservable, observable } from 'mobx';
+import type { DataCubeState } from '../DataCubeState.js';
+import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
+import type { DataCubeQueryEditorPanelState } from './DataCubeEditorPanelState.js';
+
+export class DataCubeEditorGeneralPropertiesPanelState
+  implements DataCubeQueryEditorPanelState
+{
+  readonly dataCube!: DataCubeState;
+  name = '';
+  limit = -1;
+
+  constructor(dataCube: DataCubeState) {
+    this.dataCube = dataCube;
+
+    makeObservable(this, {
+      name: observable,
+      setName: action,
+
+      limit: observable,
+      setLimit: action,
+    });
+  }
+
+  setName(val: string): void {
+    this.name = val;
+  }
+
+  setLimit(val: number | undefined): void {
+    this.limit = Math.round(val === undefined || val < 0 ? -1 : val);
+  }
+
+  applySnaphot(snapshot: DataCubeQuerySnapshot): void {
+    this.setName(snapshot.data.name);
+    this.setLimit(snapshot.data.limit);
+  }
+
+  buildSnapshot(
+    newSnapshot: DataCubeQuerySnapshot,
+    baseSnapshot: DataCubeQuerySnapshot,
+  ): boolean {
+    const data = baseSnapshot.data;
+    // name
+    if (this.name !== data.name) {
+      data.name = this.name;
+      return true;
+    }
+
+    // limit
+    if (data.limit === undefined) {
+      if (this.limit !== -1) {
+        data.limit = this.limit;
+        return true;
+      }
+    } else {
+      if (this.limit !== data.limit) {
+        data.limit = this.limit;
+        return true;
+      }
+    }
+
+    return false;
+  }
+}