@finos/legend-application-repl 0.0.21 → 0.0.23

package/src/server/models/DataCubeQuery.ts

@@ -0,0 +1,130 @@
+/**
+ * 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 {
+  SerializationFactory,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+  usingModelSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  deserialize,
+  list,
+  primitive,
+  raw,
+  serialize,
+} from 'serializr';
+
+export abstract class DataCubeQuerySource {
+  columns: DataCubeQueryColumn[] = [];
+  query!: string;
+  runtime!: string;
+}
+
+export class DataCubeQueryColumn {
+  name!: string;
+  type!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeQueryColumn, {
+      name: primitive(),
+      type: primitive(),
+    }),
+  );
+}
+
+enum DATA_CUBE_QUERY_SOURCE_TYPE {
+  REPL_EXECUTED_QUERY = 'REPLExecutedQuery',
+}
+
+export class DataCubeQuerySourceREPLExecutedQuery extends DataCubeQuerySource {
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeQuerySourceREPLExecutedQuery, {
+      _type: usingConstantValueSchema(
+        DATA_CUBE_QUERY_SOURCE_TYPE.REPL_EXECUTED_QUERY,
+      ),
+      columns: list(usingModelSchema(DataCubeQueryColumn.serialization.schema)),
+      query: primitive(),
+      runtime: primitive(),
+    }),
+  );
+}
+
+function deserializeQuerySource(
+  json: PlainObject<DataCubeQuerySource>,
+): DataCubeQuerySource {
+  switch (json._type) {
+    case DATA_CUBE_QUERY_SOURCE_TYPE.REPL_EXECUTED_QUERY:
+      return deserialize(
+        DataCubeQuerySourceREPLExecutedQuery.serialization.schema,
+        json,
+      );
+    default:
+      throw new UnsupportedOperationError(
+        `Can't deserialize data cube query source of type '${json._type}'`,
+      );
+  }
+}
+
+function serializeQuerySource(
+  object: DataCubeQuerySource,
+): PlainObject<DataCubeQuerySource> {
+  if (object instanceof DataCubeQuerySourceREPLExecutedQuery) {
+    return serialize(
+      DataCubeQuerySourceREPLExecutedQuery.serialization.schema,
+      object,
+    );
+  }
+  throw new UnsupportedOperationError(
+    `Can't serialize data cube query source`,
+    object,
+  );
+}
+
+export class DataCubeConfiguration {
+  // TODO
+}
+
+export class DataCubeQuery {
+  name!: string;
+  query!: string;
+  partialQuery!: string;
+  source!: DataCubeQuerySource;
+  configuration!: DataCubeConfiguration;
+
+  constructor(
+    name: string,
+    query: string,
+    configuration: DataCubeConfiguration,
+  ) {
+    this.name = name;
+    this.query = query;
+    this.configuration = configuration;
+  }
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(DataCubeQuery, {
+      configuration: raw(), // TODO: @akphi - populate this once we know the shape better
+      name: primitive(),
+      partialQuery: primitive(),
+      query: primitive(),
+      source: custom(serializeQuerySource, deserializeQuerySource),
+    }),
+  );
+}

package/src/stores/{LegendREPLGridClientApplicationPlugin.ts → LegendREPLApplicationPlugin.ts}

@@ -15,16 +15,16 @@
  */
 
 import { LegendApplicationPlugin } from '@finos/legend-application';
-import type { LegendREPLGridClientPluginManager } from '../application/LegendREPLGridClientPluginManager.js';
+import type { LegendREPLPluginManager } from '../application/LegendREPLPluginManager.js';
 
-export abstract class LegendREPLGridClientApplicationPlugin extends LegendApplicationPlugin {
+export abstract class LegendREPLApplicationPlugin extends LegendApplicationPlugin {
   /**
    * This helps to better type-check for this empty abtract type
    * See https://github.com/finos/legend-studio/blob/master/docs/technical/typescript-usage.md#understand-typescript-structual-type-system
    */
-  private readonly _$nominalTypeBrand!: 'LegendREPLGridClientApplicationPlugin';
+  private readonly _$nominalTypeBrand!: 'LegendREPLApplicationPlugin';
 
-  install(pluginManager: LegendREPLGridClientPluginManager): void {
+  install(pluginManager: LegendREPLPluginManager): void {
     pluginManager.registerApplicationPlugin(this);
   }
 }

package/src/stores/{LegendREPLGridClientBaseStore.ts → LegendREPLBaseStore.ts}

@@ -15,19 +15,19 @@
  */
 
 import type { ApplicationStore } from '@finos/legend-application';
-import type { LegendREPLGridClientApplicationConfig } from '../application/LegendREPLGridClientApplicationConfig.js';
-import type { LegendREPLGridClientPluginManager } from '../application/LegendREPLGridClientPluginManager.js';
+import type { LegendREPLApplicationConfig } from '../application/LegendREPLApplicationConfig.js';
+import type { LegendREPLPluginManager } from '../application/LegendREPLPluginManager.js';
 
-export type LegendREPLGridClientApplicationStore = ApplicationStore<
-  LegendREPLGridClientApplicationConfig,
-  LegendREPLGridClientPluginManager
+export type LegendREPLApplicationStore = ApplicationStore<
+  LegendREPLApplicationConfig,
+  LegendREPLPluginManager
 >;
 
-export class LegendREPLGridClientBaseStore {
-  readonly applicationStore: LegendREPLGridClientApplicationStore;
-  readonly pluginManager: LegendREPLGridClientPluginManager;
+export class LegendREPLBaseStore {
+  readonly applicationStore: LegendREPLApplicationStore;
+  readonly pluginManager: LegendREPLPluginManager;
 
-  constructor(applicationStore: LegendREPLGridClientApplicationStore) {
+  constructor(applicationStore: LegendREPLApplicationStore) {
     this.applicationStore = applicationStore;
     this.pluginManager = applicationStore.pluginManager;
   }

package/src/stores/dataCube/DataCubeMetaModelConst.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.
+ */
+
+export enum DATA_CUBE_FUNCTIONS {
+  // relation
+  EXTEND = 'meta::pure::functions::relation::extend',
+  FILTER = 'meta::pure::functions::relation::filter',
+  GROUP_BY = 'meta::pure::functions::relation::groupBy',
+  LIMIT = 'meta::pure::functions::relation::limit',
+  PIVOT = 'meta::pure::functions::relation::pivot',
+  RENAME = 'meta::pure::functions::relation::rename',
+  SELECT = 'meta::pure::functions::relation::select',
+  SLICE = 'meta::pure::functions::relation::slice',
+  SORT = 'meta::pure::functions::relation::sort',
+
+  // core
+  CAST = 'meta::pure::functions::lang::cast',
+  FROM = 'meta::pure::mapping::from',
+
+  // sort
+  ASC = 'meta::pure::functions::relation::ascending',
+  DESC = 'meta::pure::functions::relation::descending',
+
+  // filter
+  AND = 'meta::pure::functions::boolean::and',
+  NOT = 'meta::pure::functions::boolean::not',
+  OR = 'meta::pure::functions::boolean::or',
+
+  // aggregate
+}
+
+export const DEFAULT_LAMBDA_VARIABLE_NAME = 'x';
+export const PIVOT_COLUMN_NAME_VALUE_SEPARATOR = '__|__';
+
+export enum DATA_CUBE_AGGREGATE_FUNCTION {
+  SUM = 'sum',
+  MIN = 'min',
+  MAX = 'max',
+  COUNT = 'count',
+  AVG = 'avg',
+  FIRST = 'first',
+  LAST = 'last',
+}
+
+export enum DATA_CUBE_COLUMN_SORT_DIRECTION {
+  ASCENDING = 'ascending',
+  DESCENDING = 'descending',
+}

package/src/stores/dataCube/DataCubeState.ts

@@ -14,320 +14,56 @@
  * limitations under the License.
  */
 
-import { flow, flowResult, makeObservable, observable } from 'mobx';
-import type { REPLGridClientStore } from '../REPLGridClientStore.js';
-import { DataCubeGridState } from './DataCubeGridState.js';
-import { DataCubeQueryTextEditorState } from './DataCubeQueryTextEditorState.js';
-import { DataCubeConfigState } from './DataCubeConfigState.js';
-import { DataCubePropertiesPanelState } from './DataCubePropertiesPanelState.js';
-import {
-  ActionState,
-  HttpStatus,
-  LogEvent,
-  NetworkClientError,
-  assertErrorThrown,
-  guaranteeNonNullable,
-  guaranteeType,
-  type GeneratorFn,
-  type PlainObject,
-} from '@finos/legend-shared';
-import { generatePath } from '@finos/legend-application/browser';
-import {
-  V1_serializeValueSpecification,
-  type V1_TDSExecutionResult,
-  V1_buildExecutionResult,
-  V1_serializeExecutionResult,
-  TDSExecutionResult,
-  V1_ParserError,
-  ParserError,
-  SourceInformation,
-  V1_Lambda,
-  V1_deserializeValueSpecification,
-} from '@finos/legend-graph';
-import {
-  languages as monacoLanguagesAPI,
-  type IPosition,
-  type editor as monacoEditorAPI,
-} from 'monaco-editor';
-import { LEGEND_REPL_EVENT } from '../../Const.js';
-import {
-  LEGEND_REPL_GRID_CLIENT_ROUTE_PATTERN,
-  LEGEND_REPL_GRID_CLIENT_PATTERN_TOKEN,
-} from '../../components/LegendREPLGridClientApplication.js';
-import { REPLGridServerResult } from '../../components/grid/REPLGridServerResult.js';
-import { buildLambdaExpressions } from '../../components/grid/TDSLambdaBuilder.js';
-import { TDSQuery } from '../../components/grid/TDSQuery.js';
-import { TDSRequest, TDSGroupby } from '../../components/grid/TDSRequest.js';
-import { CompletionItem } from '../CompletionResult.js';
+import { flowResult } from 'mobx';
+import type { REPLStore } from './DataCubeStore.js';
+import { DataCubeGridState } from './grid/DataCubeGridState.js';
+import { DataCubeEditorState } from './editor/DataCubeEditorState.js';
+import type { DataCubeQuery } from '../../server/models/DataCubeQuery.js';
+import { ActionState, assertErrorThrown } from '@finos/legend-shared';
+import { DataCubeEngine } from './core/DataCubeEngine.js';
+import { DataCubeQuerySnapshotManager } from './core/DataCubeQuerySnapshotManager.js';
+import { buildSnapshotFromQuery } from './core/DataCubeQueryAnalyzer.js';
+import type { LegendREPLApplicationStore } from '../LegendREPLBaseStore.js';
 
 export class DataCubeState {
-  readonly editorStore!: REPLGridClientStore;
+  readonly editorStore: REPLStore;
+  readonly applicationStore: LegendREPLApplicationStore;
+  readonly engine: DataCubeEngine;
+  readonly snapshotManager: DataCubeQuerySnapshotManager;
+  readonly grid: DataCubeGridState;
+  readonly editor: DataCubeEditorState;
+  readonly initState = ActionState.create();
 
-  gridState!: DataCubeGridState;
-  queryTextEditorState!: DataCubeQueryTextEditorState;
-  configState!: DataCubeConfigState;
-  propertiesPanelState!: DataCubePropertiesPanelState;
-
-  executeAction = ActionState.create();
-
-  constructor(editorStore: REPLGridClientStore) {
-    makeObservable(this, {
-      gridState: observable,
-      queryTextEditorState: observable,
-      configState: observable,
-      propertiesPanelState: observable,
-      executeAction: observable,
-      getREPLGridServerResult: flow,
-      getInitialQueryLambda: flow,
-      getInitialREPLGridServerResult: flow,
-      getLicenseKey: flow,
-      executeLambda: flow,
-      parseQuery: flow,
-      saveQuery: flow,
-    });
+  baseQuery!: DataCubeQuery;
 
+  constructor(editorStore: REPLStore) {
     this.editorStore = editorStore;
+    this.applicationStore = editorStore.applicationStore;
+    this.engine = new DataCubeEngine(this.editorStore.client);
 
-    this.gridState = new DataCubeGridState(this);
-    this.queryTextEditorState = new DataCubeQueryTextEditorState(this);
-    this.configState = new DataCubeConfigState(this);
-    this.propertiesPanelState = new DataCubePropertiesPanelState(this);
-  }
-
-  *getREPLGridServerResult(tdsRequest: TDSRequest): GeneratorFn<void> {
-    try {
-      const isSubQuery = tdsRequest.groupBy.groupKeys.length !== 0;
-      const lambda = buildLambdaExpressions(
-        guaranteeNonNullable(this.gridState.initialQueryLambda?.body[0]),
-        tdsRequest,
-        this.configState.isPaginationEnabled,
-      );
-      const resultObj = (yield flowResult(
-        this.editorStore.client.getREPLGridServerResult(
-          V1_serializeValueSpecification(lambda, []),
-        ),
-      )) as PlainObject<REPLGridServerResult>;
-      const replGridResult =
-        REPLGridServerResult.serialization.fromJson(resultObj);
-      const tdsResult = JSON.parse(
-        replGridResult.result,
-      ) as PlainObject<V1_TDSExecutionResult>;
-      this.gridState.setCurrentResult(
-        guaranteeType(
-          V1_buildExecutionResult(V1_serializeExecutionResult(tdsResult)),
-          TDSExecutionResult,
-        ),
-      );
-      if (isSubQuery) {
-        this.queryTextEditorState.setCurrentSubQuery(
-          replGridResult.currentQuery,
-        );
-      } else {
-        this.queryTextEditorState.queryEditorState.setQuery(
-          replGridResult.currentQuery.substring(1),
-        );
-        this.queryTextEditorState.setCurrentSubQuery(undefined);
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
-  }
-
-  async getTypeaheadResults(
-    position: IPosition,
-    model: monacoEditorAPI.ITextModel,
-  ): Promise<monacoLanguagesAPI.CompletionItem[]> {
-    try {
-      const textUntilPosition = model.getValueInRange({
-        startLineNumber: 1,
-        startColumn: 1,
-        endLineNumber: position.lineNumber,
-        endColumn: position.column,
-      });
-      const resultObj =
-        await this.editorStore.client.getTypeaheadResults(textUntilPosition);
-      const result = resultObj.map((res) =>
-        CompletionItem.serialization.fromJson(res),
-      );
-      const currentWord = model.getWordUntilPosition(position);
-      return result.map((res) => ({
-        label: res.display,
-        kind: monacoLanguagesAPI.CompletionItemKind.Text,
-        range: {
-          startLineNumber: position.lineNumber,
-          startColumn: currentWord.startColumn + 1,
-          endLineNumber: position.lineNumber,
-          endColumn: currentWord.endColumn + 1,
-        },
-        insertText: res.completion,
-      })) as monacoLanguagesAPI.CompletionItem[];
-    } catch (e) {
-      return [];
-    }
-  }
-
-  *executeLambda(): GeneratorFn<void> {
-    try {
-      this.executeAction.inProgress();
-      const resultObj = (yield this.editorStore.client.executeLambda(
-        this.queryTextEditorState.queryEditorState.query,
-        this.configState.isPaginationEnabled,
-      )) as PlainObject<REPLGridServerResult>;
-      const replGridResult =
-        REPLGridServerResult.serialization.fromJson(resultObj);
-      const tdsResultObj = JSON.parse(
-        replGridResult.result,
-      ) as PlainObject<V1_TDSExecutionResult>;
-      const tdsResult = guaranteeType(
-        V1_buildExecutionResult(V1_serializeExecutionResult(tdsResultObj)),
-        TDSExecutionResult,
-      );
-      this.gridState.setInitialResult(tdsResult);
-      this.queryTextEditorState.queryEditorState.setQuery(
-        replGridResult.currentQuery.substring(1),
-      );
-      this.queryTextEditorState.setCurrentSubQuery(undefined);
-      this.gridState.setColumns(tdsResult.result.columns);
-
-      yield flowResult(this.getInitialQueryLambda());
-      this.executeAction.complete();
-    } catch (error) {
-      this.executeAction.fail();
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
+    // NOTE: snapshot manager must be instantiated before subscribers
+    this.snapshotManager = new DataCubeQuerySnapshotManager(this);
+    this.grid = new DataCubeGridState(this);
+    this.editor = new DataCubeEditorState(this);
   }
 
-  *parseQuery(): GeneratorFn<void> {
+  async initialize(): Promise<void> {
+    this.initState.inProgress();
     try {
-      this.queryTextEditorState.queryEditorState.setParserError(undefined);
-      yield flowResult(
-        this.editorStore.client.parseQuery(
-          `|${this.queryTextEditorState.queryEditorState.query}`,
-        ),
+      await flowResult(this.grid.initialize());
+      this.snapshotManager.registerSubscriber(this.grid);
+      this.snapshotManager.registerSubscriber(this.editor);
+
+      this.baseQuery = await this.engine.getBaseQuery();
+      const initialSnapshot = await buildSnapshotFromQuery(
+        this.baseQuery,
+        this.engine,
       );
-    } catch (error) {
+      this.snapshotManager.broadcastSnapshot(initialSnapshot);
+      this.initState.complete();
+    } catch (error: unknown) {
       assertErrorThrown(error);
-      if (
-        error instanceof NetworkClientError &&
-        error.response.status === HttpStatus.BAD_REQUEST
-      ) {
-        const protocol = V1_ParserError.serialization.fromJson(
-          error.payload as PlainObject<V1_ParserError>,
-        );
-        const parserError = new ParserError(protocol.message);
-        if (protocol.sourceInformation) {
-          parserError.sourceInformation = new SourceInformation(
-            protocol.sourceInformation.sourceId,
-            protocol.sourceInformation.startLine,
-            protocol.sourceInformation.startColumn,
-            protocol.sourceInformation.endLine,
-            protocol.sourceInformation.endColumn,
-          );
-        }
-        this.queryTextEditorState.queryEditorState.setParserError(parserError);
-      }
+      this.initState.fail();
     }
   }
-
-  *saveQuery(): GeneratorFn<void> {
-    try {
-      const query = TDSQuery.serialization.toJson(
-        new TDSQuery(
-          guaranteeNonNullable(this.gridState.initialQueryLambda),
-          this.gridState.lastQueryTDSRequest ??
-            new TDSRequest([], [], [], new TDSGroupby([], [], []), 0, 100),
-        ),
-      );
-      const queryId = (yield flowResult(
-        this.editorStore.client.saveQuery(query),
-      )) as string;
-      this.editorStore.applicationStore.navigationService.navigator.goToLocation(
-        generatePath(LEGEND_REPL_GRID_CLIENT_ROUTE_PATTERN.SAVED_QUERY, {
-          [LEGEND_REPL_GRID_CLIENT_PATTERN_TOKEN.QUERY_ID]: queryId,
-        }),
-      );
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
-  }
-
-  *getInitialQueryLambda(queryId?: string): GeneratorFn<void> {
-    if (!queryId) {
-      const lambdaObj =
-        (yield this.editorStore.client.getIntialQueryLambda()) as PlainObject<V1_Lambda>;
-      const lambda = V1_deserializeValueSpecification(lambdaObj, []);
-      if (lambda instanceof V1_Lambda) {
-        this.gridState.setInitialQueryLambda(lambda);
-      }
-      // this.replGridState.setCurrentQueryTDSRequest(undefined);
-    } else {
-      const queryObj = (yield this.editorStore.client.getREPLQuery(
-        queryId,
-      )) as PlainObject<TDSQuery>;
-      const query = TDSQuery.serialization.fromJson(queryObj);
-      this.gridState.setCurrentQueryTDSRequest(query.currentQueryInfo);
-      this.gridState.setInitialQueryLambda(query.initialQuery);
-    }
-  }
-
-  *getInitialREPLGridServerResult(queryId?: string): GeneratorFn<void> {
-    try {
-      this.executeAction.inProgress();
-      if (!this.configState.licenseKey) {
-        yield flowResult(this.getLicenseKey());
-      }
-
-      yield flowResult(this.getInitialQueryLambda(queryId));
-
-      const resultObj =
-        (yield this.editorStore.client.getInitialREPLGridServerResult(
-          this.configState.isPaginationEnabled,
-        )) as PlainObject<REPLGridServerResult>;
-      const replGridResult =
-        REPLGridServerResult.serialization.fromJson(resultObj);
-      const tdsResultObj = JSON.parse(
-        replGridResult.result,
-      ) as PlainObject<V1_TDSExecutionResult>;
-      const tdsResult = guaranteeType(
-        V1_buildExecutionResult(V1_serializeExecutionResult(tdsResultObj)),
-        TDSExecutionResult,
-      );
-      this.gridState.setInitialResult(tdsResult);
-      this.queryTextEditorState.queryEditorState.setQuery(
-        replGridResult.currentQuery.substring(1),
-      );
-      this.queryTextEditorState.setCurrentSubQuery(undefined);
-      this.gridState.setColumns(tdsResult.result.columns);
-      this.executeAction.complete();
-    } catch (error) {
-      this.executeAction.fail();
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.notificationService.notifyError(error);
-      this.editorStore.applicationStore.logService.error(
-        LogEvent.create(LEGEND_REPL_EVENT.FETCH_TDS_FAILURE),
-        error,
-      );
-    }
-  }
-
-  *getLicenseKey(): GeneratorFn<void> {
-    const licenseKey =
-      (yield this.editorStore.client.getLicenseKey()) as string;
-    this.configState.setLicenseKey(licenseKey);
-  }
 }

package/src/stores/{REPLGridClientStore.ts → dataCube/DataCubeStore.ts}

@@ -14,18 +14,20 @@
  * limitations under the License.
  */
 
-import type { LegendREPLGridClientApplicationStore } from './LegendREPLGridClientBaseStore.js';
-import { REPLServerClient } from '../server/REPLServerClient.js';
+import type { LegendREPLApplicationStore } from '../LegendREPLBaseStore.js';
+import { REPLServerClient } from '../../server/REPLServerClient.js';
 import { NetworkClient } from '@finos/legend-shared';
 import { makeObservable, observable } from 'mobx';
-import { DataCubeState } from './dataCube/DataCubeState.js';
+import { DataCubeState } from './DataCubeState.js';
 
-export class REPLGridClientStore {
-  readonly applicationStore: LegendREPLGridClientApplicationStore;
+export class REPLStore {
+  readonly applicationStore: LegendREPLApplicationStore;
   readonly client: REPLServerClient;
+
+  // TODO: when we support multi-view, we would need to support multiple states
   dataCubeState!: DataCubeState;
 
-  constructor(applicationStore: LegendREPLGridClientApplicationStore) {
+  constructor(applicationStore: LegendREPLApplicationStore) {
     makeObservable(this, {
       dataCubeState: observable,
     });