@finos/legend-data-cube 0.0.36 → 0.0.38

package/src/stores/DataCubeState.tsx

@@ -16,153 +16,123 @@
 
 import { type DataCubeEngine } from './core/DataCubeEngine.js';
 import { DataCubeViewState } from './view/DataCubeViewState.js';
-import type { DisplayState } from './core/DataCubeLayoutManagerState.js';
-import { DocumentationPanel } from '../components/core/DataCubeDocumentationPanel.js';
-import { DataCubeSettingsPanel } from '../components/core/DataCubeSettingsPanel.js';
-import {
-  ActionState,
-  assertErrorThrown,
-  type DocumentationEntry,
-} from '@finos/legend-shared';
-import {
-  AlertType,
-  type ActionAlert,
-} from '../components/core/DataCubeAlert.js';
-import type { DataCubeSource } from './core/models/DataCubeSource.js';
+import { ActionState, assertErrorThrown, uuid } from '@finos/legend-shared';
 import { action, makeObservable, observable } from 'mobx';
-import { DataCubeSettings } from './DataCubeSettings.js';
-import type { DataCubeAPI } from './DataCubeAPI.js';
+import { DataCubeSettingService } from './services/DataCubeSettingService.js';
+import { INTERNAL__DataCubeAPI } from './DataCubeAPI.js';
 import type { DataCubeOptions } from './DataCubeOptions.js';
-
-export class DataCubeState implements DataCubeAPI {
+import type { DataCubeQuery } from './core/model/DataCubeQuery.js';
+import { LicenseManager } from 'ag-grid-enterprise';
+import {
+  configureCodeEditor,
+  setupPureLanguageService,
+} from '@finos/legend-code-editor';
+import { DataCubeFont } from './core/DataCubeQueryEngine.js';
+import { DataCubeDocumentationService } from './services/DataCubeDocumentationService.js';
+import { DataCubeLayoutService } from './services/DataCubeLayoutService.js';
+import { DataCubeAlertService } from './services/DataCubeAlertService.js';
+import { DataCubeTelemetryService } from './services/DataCubeTelemetryService.js';
+import { DataCubeNavigationService } from './services/DataCubeNavigationService.js';
+import { DataCubeLogService } from './services/DataCubeLogService.js';
+import { DataCubeTaskService } from './services/DataCubeTaskService.js';
+
+export class DataCubeState {
   readonly engine: DataCubeEngine;
-  readonly settings!: DataCubeSettings;
-  readonly initState = ActionState.create();
-  readonly settingsDisplay: DisplayState;
-  readonly documentationDisplay: DisplayState;
+  readonly logService: DataCubeLogService;
+  readonly taskService: DataCubeTaskService;
+  readonly layoutService: DataCubeLayoutService;
+  readonly settingService: DataCubeSettingService;
+  readonly documentationService: DataCubeDocumentationService;
+  readonly alertService: DataCubeAlertService;
+  readonly navigationService: DataCubeNavigationService;
+  readonly telemetryService: DataCubeTelemetryService;
+
+  readonly query: DataCubeQuery;
+  readonly options?: DataCubeOptions | undefined;
+
+  readonly initializeState = ActionState.create();
+  readonly api: INTERNAL__DataCubeAPI;
+
+  uuid = uuid();
   // NOTE: when we support multiview, there can be multiple view states to support
   // the first one in that list will be taken as the main view state
-  readonly view: DataCubeViewState;
+  view: DataCubeViewState;
 
-  onNameChanged?: ((name: string, source: DataCubeSource) => void) | undefined;
-  onSettingChanged?:
-    | ((
-        key: string,
-        value: string | number | boolean | object | undefined,
-      ) => void)
-    | undefined;
-  innerHeaderComponent?:
-    | ((dataCube: DataCubeState) => React.ReactNode)
-    | undefined;
-
-  currentDocumentationEntry?: DocumentationEntry | undefined;
-  currentActionAlert?: ActionAlert | undefined;
-
-  constructor(engine: DataCubeEngine, options?: DataCubeOptions | undefined) {
+  constructor(
+    query: DataCubeQuery,
+    engine: DataCubeEngine,
+    options?: DataCubeOptions | undefined,
+  ) {
     makeObservable(this, {
-      currentDocumentationEntry: observable,
-      openDocumentationEntry: action,
-
-      currentActionAlert: observable,
-      alertAction: action,
+      uuid: observable,
+      reload: action,
     });
 
     this.engine = engine;
-    this.settings = new DataCubeSettings(this);
-    this.view = new DataCubeViewState(this);
-
-    this.settingsDisplay = this.engine.layout.newDisplay(
-      'Settings',
-      () => <DataCubeSettingsPanel />,
-      {
-        x: -50,
-        y: 50,
-        width: 600,
-        height: 400,
-        minWidth: 300,
-        minHeight: 200,
-        center: false,
-      },
+    this.logService = new DataCubeLogService(this.engine);
+    this.taskService = new DataCubeTaskService(options?.taskManager);
+    this.layoutService = new DataCubeLayoutService(options?.layoutManager);
+    this.settingService = new DataCubeSettingService(
+      this.engine,
+      this.logService,
+      this.layoutService,
+      options,
     );
-    this.documentationDisplay = this.engine.layout.newDisplay(
-      'Documentation',
-      () => <DocumentationPanel />,
-      {
-        x: -50,
-        y: -50,
-        width: 400,
-        height: 400,
-        minWidth: 300,
-        minHeight: 200,
-        center: false,
-      },
+    this.documentationService = new DataCubeDocumentationService(
+      this.engine,
+      this.layoutService,
     );
+    this.alertService = new DataCubeAlertService(
+      this.logService,
+      this.layoutService,
+    );
+    this.navigationService = new DataCubeNavigationService(this.engine);
+    this.telemetryService = new DataCubeTelemetryService(this.engine);
 
-    this.onNameChanged = options?.onNameChanged;
-    this.onSettingChanged = options?.onSettingChanged;
-    this.innerHeaderComponent = options?.innerHeaderComponent;
-
-    this.settings.enableDebugMode =
-      options?.enableDebugMode !== undefined
-        ? options.enableDebugMode
-        : this.settings.enableDebugMode;
-    this.settings.gridClientRowBuffer =
-      options?.gridClientRowBuffer !== undefined
-        ? options.gridClientRowBuffer
-        : this.settings.gridClientRowBuffer;
-    this.settings.gridClientPurgeClosedRowNodes =
-      options?.gridClientPurgeClosedRowNodes !== undefined
-        ? options.gridClientPurgeClosedRowNodes
-        : this.settings.gridClientPurgeClosedRowNodes;
-    this.settings.gridClientSuppressLargeDatasetWarning =
-      options?.gridClientSuppressLargeDatasetWarning !== undefined
-        ? options.gridClientSuppressLargeDatasetWarning
-        : this.settings.gridClientSuppressLargeDatasetWarning;
-  }
-
-  getSettings() {
-    return this.settings;
-  }
-
-  openDocumentationEntry(entry: DocumentationEntry | undefined) {
-    this.currentDocumentationEntry = entry;
-  }
-
-  alertAction(alert: ActionAlert | undefined) {
-    this.currentActionAlert = alert;
-  }
+    this.api = new INTERNAL__DataCubeAPI(this);
+    this.query = query;
+    this.options = options;
 
-  refreshFailedDataFetches() {
-    this.runTaskForEachView((view) => {
-      view.grid.client.retryServerSideLoads();
-    });
-  }
-
-  runTaskForEachView(runner: (view: DataCubeViewState) => void) {
-    // TODO: When we support multi-view (i.e. multiple instances of DataCubes) we would need
-    // to traverse through and update the configurations of all of their grid clients
-    runner(this.view);
+    this.view = new DataCubeViewState(this);
   }
 
   async initialize() {
-    if (!this.initState.isInInitialState) {
-      this.engine.logDebug('REPL store is re-initialized');
+    if (!this.initializeState.isInInitialState) {
+      this.logService.logDebug('DataCube state is re-initialized');
       return;
     }
-    this.initState.inProgress();
+    this.initializeState.inProgress();
 
     try {
-      await this.engine.initialize();
-      this.initState.pass();
-    } catch (error: unknown) {
+      // set up the components
+      if (this.options?.gridClientLicense) {
+        LicenseManager.setLicenseKey(this.options.gridClientLicense);
+      }
+      await configureCodeEditor(DataCubeFont.ROBOTO_MONO, (error) => {
+        throw error;
+      });
+      setupPureLanguageService({});
+
+      this.options?.onInitialized?.(this);
+      this.initializeState.pass();
+    } catch (error) {
       assertErrorThrown(error);
-      this.alertAction({
+      this.alertService.alertError(error, {
         message: `Initialization Failure: ${error.message}`,
-        prompt: `Resolve the issue and reload the engine.`,
-        type: AlertType.ERROR,
-        actions: [],
+        text: `Resolve the issue and reload the engine.`,
       });
-      this.initState.fail();
+      this.initializeState.fail();
     }
   }
+
+  dispose() {
+    this.view.dispose();
+    this.layoutService.dispose();
+    this.taskService.dispose();
+  }
+
+  reload() {
+    this.view = new DataCubeViewState(this);
+    this.uuid = uuid();
+  }
 }

package/src/stores/core/DataCubeConfigurationBuilder.ts

@@ -18,13 +18,13 @@ import { PRIMITIVE_TYPE } from '@finos/legend-graph';
 import {
   DataCubeColumnConfiguration,
   DataCubeConfiguration,
-} from './models/DataCubeConfiguration.js';
+} from './model/DataCubeConfiguration.js';
 import {
   DataCubeQueryAggregateOperator,
   DataCubeColumnKind,
   DataCubeFontTextAlignment,
 } from './DataCubeQueryEngine.js';
-import type { DataCubeColumn } from './models/DataCubeColumn.js';
+import type { DataCubeColumn } from './model/DataCubeColumn.js';
 
 export function buildDefaultColumnConfiguration(
   column: DataCubeColumn,

package/src/stores/core/DataCubeEngine.tsx

@@ -20,7 +20,6 @@ import {
   type TDSExecutionResult,
   type V1_AppliedFunction,
   PRIMITIVE_TYPE,
-  type EngineError,
 } from '@finos/legend-graph';
 import { getFilterOperation } from './filter/DataCubeQueryFilterOperation.js';
 import { getAggregateOperation } from './aggregation/DataCubeQueryAggregateOperation.js';
@@ -64,70 +63,48 @@ import { DataCubeQueryFilterOperation__EndWithCaseInsensitive } from './filter/D
 import { DataCubeQueryFilterOperation__NotEndWith } from './filter/DataCubeQueryFilterOperation__NotEndWith.js';
 import { DataCubeQueryFilterOperation__IsNull } from './filter/DataCubeQueryFilterOperation__IsNull.js';
 import { DataCubeQueryFilterOperation__IsNotNull } from './filter/DataCubeQueryFilterOperation__IsNotNull.js';
-import {
-  CODE_EDITOR_LANGUAGE,
-  configureCodeEditor,
-  setupPureLanguageService,
-} from '@finos/legend-code-editor';
-import { DataCubeFont, DataCubeFunction } from './DataCubeQueryEngine.js';
 import type { DataCubeQuerySnapshot } from './DataCubeQuerySnapshot.js';
 import { buildExecutableQuery } from './DataCubeQueryBuilder.js';
-import type { DataCubeColumn } from './models/DataCubeColumn.js';
-import { LicenseManager } from 'ag-grid-enterprise';
-import type { DataCubeQuery } from './models/DataCubeQuery.js';
+import type { DataCubeColumn } from './model/DataCubeColumn.js';
 import {
   type DataCubeSource,
   INTERNAL__DataCubeSource,
-} from './models/DataCubeSource.js';
-import {
-  _cols,
-  _colSpec,
-  _function,
-  _primitiveValue,
-} from './DataCubeQueryBuilderUtils.js';
+} from './model/DataCubeSource.js';
+import { _primitiveValue } from './DataCubeQueryBuilderUtils.js';
 import {
-  uuid,
   type DocumentationEntry,
   type LogEvent,
   type PlainObject,
 } from '@finos/legend-shared';
-import {
-  Alert,
-  AlertType,
-  type ActionAlertAction,
-} from '../../components/core/DataCubeAlert.js';
-import {
-  DEFAULT_SMALL_ALERT_WINDOW_CONFIG,
-  LayoutConfiguration,
-  LayoutManagerState,
-  WindowState,
-  type WindowConfiguration,
-} from './DataCubeLayoutManagerState.js';
-import { editor as monacoEditorAPI, Uri } from 'monaco-editor';
-import { DataCubeCodeCheckErrorAlert } from '../../components/core/DataCubeCodeCheckErrorAlert.js';
-import type { DataCubeAPI } from '../DataCubeAPI.js';
 
 export type CompletionItem = {
   completion: string;
   display: string;
 };
 
-export type RelationType = {
+export type DataCubeRelationType = {
   columns: DataCubeColumn[];
 };
 
+export type DataCubeExecutionOptions = {
+  debug?: boolean | undefined;
+};
+
 export type DataCubeExecutionResult = {
   result: TDSExecutionResult;
   executedQuery: string;
   executedSQL: string;
 };
 
-export type DataCubeEngineConfiguration = {
-  gridClientLicense?: string | undefined;
-};
-
+/**
+ * This is the base engine of DataCube, it provides capabilities that DataCube cannot itself
+ * handle, such as query execution, compilation, etc.
+ *
+ * Note that we want to make sure this class is stateless, since from the perspective of DataCube,
+ * the engine simply should not hold any state. This does not mean any implementations of this engine
+ * must be stateless as well, that's totally up to their authors.
+ */
 export abstract class DataCubeEngine {
-  readonly layout = new LayoutManagerState();
   readonly filterOperations = [
     new DataCubeQueryFilterOperation__LessThan(),
     new DataCubeQueryFilterOperation__LessThanOrEqual(),
@@ -176,24 +153,7 @@ export abstract class DataCubeEngine {
     new DataCubeQueryAggregateOperation__JoinStrings(),
   ];
 
-  protected async fetchConfiguration(): Promise<DataCubeEngineConfiguration> {
-    return {
-      gridClientLicense: undefined,
-    };
-  }
-
-  async initialize(): Promise<void> {
-    const config = await this.fetchConfiguration();
-    if (config.gridClientLicense) {
-      LicenseManager.setLicenseKey(config.gridClientLicense);
-    }
-    await configureCodeEditor(DataCubeFont.ROBOTO_MONO, (error) => {
-      throw error;
-    });
-    setupPureLanguageService({});
-  }
-
-  // ------------------------------- CORE OPERATIONS -------------------------------
+  // ------------------------------- UTILITIES -------------------------------
 
   getFilterOperation(value: string) {
     return getFilterOperation(value, this.filterOperations);
@@ -203,46 +163,6 @@ export abstract class DataCubeEngine {
     return getAggregateOperation(value, this.aggregateOperations);
   }
 
-  abstract getBaseQuery(): Promise<DataCubeQuery | undefined>;
-  abstract processQuerySource(value: PlainObject): Promise<DataCubeSource>;
-
-  abstract parseValueSpecification(
-    code: string,
-    returnSourceInformation?: boolean | undefined,
-  ): Promise<V1_ValueSpecification>;
-
-  abstract getValueSpecificationCode(
-    value: V1_ValueSpecification,
-    pretty?: boolean | undefined,
-  ): Promise<string>;
-
-  abstract getQueryTypeahead(
-    code: string,
-    baseQuery: V1_Lambda,
-    source: DataCubeSource,
-  ): Promise<CompletionItem[]>;
-
-  abstract getQueryRelationType(
-    query: V1_Lambda,
-    source: DataCubeSource,
-  ): Promise<RelationType>;
-
-  abstract getQueryCodeRelationReturnType(
-    code: string,
-    baseQuery: V1_ValueSpecification,
-    source: DataCubeSource,
-  ): Promise<RelationType>;
-
-  abstract executeQuery(
-    query: V1_Lambda,
-    source: DataCubeSource,
-    api: DataCubeAPI,
-  ): Promise<DataCubeExecutionResult>;
-
-  abstract buildExecutionContext(
-    source: DataCubeSource,
-  ): V1_AppliedFunction | undefined;
-
   /**
    * By default, for a function chain, Pure grammar composer will extract the first parameter of the first function
    * and render it as the caller of that function rather than a parameter
@@ -271,27 +191,43 @@ export abstract class DataCubeEngine {
     ).substring(`''->`.length);
   }
 
-  generateInitialQuery(snapshot: DataCubeQuerySnapshot): V1_AppliedFunction {
-    return _function(DataCubeFunction.SELECT, [
-      _cols(snapshot.data.sourceColumns.map((col) => _colSpec(col.name))),
-    ]);
-  }
+  // ---------------------------------- PROCESSOR ----------------------------------
 
-  // ---------------------------------- DOCUMENTATION ----------------------------------
+  abstract processQuerySource(value: PlainObject): Promise<DataCubeSource>;
 
-  getDocumentationURL(): string | undefined {
-    return undefined;
-  }
+  abstract parseValueSpecification(
+    code: string,
+    returnSourceInformation?: boolean | undefined,
+  ): Promise<V1_ValueSpecification>;
 
-  getDocumentationEntry(key: string): DocumentationEntry | undefined {
-    return undefined;
-  }
+  abstract getValueSpecificationCode(
+    value: V1_ValueSpecification,
+    pretty?: boolean | undefined,
+  ): Promise<string>;
 
-  shouldDisplayDocumentationEntry(entry: DocumentationEntry) {
-    return false;
-  }
+  abstract getQueryTypeahead(
+    code: string,
+    baseQuery: V1_Lambda,
+    source: DataCubeSource,
+  ): Promise<CompletionItem[]>;
+
+  abstract getQueryCodeRelationReturnType(
+    code: string,
+    baseQuery: V1_ValueSpecification,
+    source: DataCubeSource,
+  ): Promise<DataCubeRelationType>;
+
+  abstract executeQuery(
+    query: V1_Lambda,
+    source: DataCubeSource,
+    options?: DataCubeExecutionOptions | undefined,
+  ): Promise<DataCubeExecutionResult>;
+
+  abstract buildExecutionContext(
+    source: DataCubeSource,
+  ): V1_AppliedFunction | undefined;
 
-  // ---------------------------------- LOGGING ----------------------------------
+  // ---------------------------------- APPLICATION ----------------------------------
 
   logDebug(message: string, ...data: unknown[]) {
     // do nothing
@@ -321,129 +257,10 @@ export abstract class DataCubeEngine {
     // do nothing
   }
 
-  // ---------------------------------- ALERT ----------------------------------
-
-  alert(options: {
-    message: string;
-    type: AlertType;
-    text?: string | undefined;
-    actions?: ActionAlertAction[] | undefined;
-    windowTitle?: string | undefined;
-    windowConfig?: WindowConfiguration | undefined;
-  }) {
-    const { message, type, text, actions, windowTitle, windowConfig } = options;
-    const window = new WindowState(
-      new LayoutConfiguration(windowTitle ?? '', () => (
-        <Alert
-          type={type}
-          message={message}
-          text={text}
-          actions={actions}
-          onClose={() => this.layout.closeWindow(window)}
-        />
-      )),
-    );
-    window.configuration.window =
-      windowConfig ?? DEFAULT_SMALL_ALERT_WINDOW_CONFIG;
-    this.layout.newWindow(window);
-  }
-
-  alertError(
-    error: Error,
-    options: {
-      message: string;
-      text?: string | undefined;
-      actions?: ActionAlertAction[] | undefined;
-      windowTitle?: string | undefined;
-      windowConfig?: WindowConfiguration | undefined;
-    },
-  ) {
-    const { message, text, actions, windowTitle, windowConfig } = options;
-    const window = new WindowState(
-      new LayoutConfiguration(windowTitle ?? 'Error', () => (
-        <Alert
-          type={AlertType.ERROR}
-          message={message}
-          text={text}
-          actions={actions}
-        />
-      )),
-    );
-    window.configuration.window =
-      windowConfig ?? DEFAULT_SMALL_ALERT_WINDOW_CONFIG;
-    this.layout.newWindow(window);
-  }
-
-  alertUnhandledError(error: Error) {
-    this.logUnhandledError(error);
-    this.alertError(error, {
-      message: error.message,
-    });
-  }
-
-  alertCodeCheckError(
-    error: EngineError,
-    code: string,
-    codePrefix: string,
-    options: {
-      message: string;
-      text?: string | undefined;
-      actions?: ActionAlertAction[] | undefined;
-      windowTitle?: string | undefined;
-      windowConfig?: WindowConfiguration | undefined;
-    },
-  ) {
-    const { message, text, windowTitle, windowConfig } = options;
-    // correct the source information since we added prefix to the code
-    // and reveal error in the editor
-    if (error.sourceInformation) {
-      error.sourceInformation.startColumn -=
-        error.sourceInformation.startLine === 1 ? codePrefix.length : 0;
-      error.sourceInformation.endColumn -=
-        error.sourceInformation.endLine === 1 ? codePrefix.length : 0;
-      const editorModel = monacoEditorAPI.createModel(
-        code,
-        CODE_EDITOR_LANGUAGE.PURE,
-        Uri.file(`/${uuid()}.pure`),
-      );
-
-      const fullRange = editorModel.getFullModelRange();
-      if (
-        error.sourceInformation.startLine < 1 ||
-        (error.sourceInformation.startLine === 1 &&
-          error.sourceInformation.startColumn < 1) ||
-        error.sourceInformation.endLine > fullRange.endLineNumber ||
-        (error.sourceInformation.endLine === fullRange.endLineNumber &&
-          error.sourceInformation.endColumn > fullRange.endColumn)
-      ) {
-        error.sourceInformation.startColumn = fullRange.startColumn;
-        error.sourceInformation.startLine = fullRange.startLineNumber;
-        error.sourceInformation.endColumn = fullRange.endColumn;
-        error.sourceInformation.endLine = fullRange.endLineNumber;
-      }
-      const window = new WindowState(
-        new LayoutConfiguration(windowTitle ?? 'Error', () => (
-          <DataCubeCodeCheckErrorAlert
-            editorModel={editorModel}
-            error={error}
-            message={message}
-            text={text}
-          />
-        )),
-      );
-      window.configuration.window = windowConfig ?? {
-        width: 500,
-        height: 400,
-        minWidth: 300,
-        minHeight: 300,
-        center: true,
-      };
-      this.layout.newWindow(window);
-    }
+  getDocumentationEntry(key: string): DocumentationEntry | undefined {
+    return undefined;
   }
 
-  // ---------------------------------- MISC ----------------------------------
-
   openLink(url: string) {
     // do nothing
   }

package/src/stores/core/DataCubeQueryBuilder.ts

@@ -29,7 +29,7 @@ import {
   DataCubeQuerySortDirection,
   type DataCubeQueryFunctionMap,
 } from './DataCubeQueryEngine.js';
-import { DataCubeConfiguration } from './models/DataCubeConfiguration.js';
+import { DataCubeConfiguration } from './model/DataCubeConfiguration.js';
 import type { DataCubeQueryFilterOperation } from './filter/DataCubeQueryFilterOperation.js';
 import {
   _col,
@@ -49,7 +49,7 @@ import {
   _extendRootAggregation,
 } from './DataCubeQueryBuilderUtils.js';
 import type { DataCubeQueryAggregateOperation } from './aggregation/DataCubeQueryAggregateOperation.js';
-import type { DataCubeSource } from './models/DataCubeSource.js';
+import type { DataCubeSource } from './model/DataCubeSource.js';
 
 export function buildExecutableQuery(
   snapshot: DataCubeQuerySnapshot,
@@ -79,6 +79,7 @@ export function buildExecutableQuery(
           end: number;
         }
       | undefined;
+    skipExecutionContext?: boolean;
   },
 ) {
   const data = snapshot.data;