@finos/legend-data-cube 0.0.37 → 0.0.39

package/src/stores/DataCubeState.tsx

@@ -16,44 +16,44 @@
 
 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 {
-  ActionState,
-  assertErrorThrown,
-  uuid,
-  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';
-import type { DataCubeQuery } from './core/models/DataCubeQuery.js';
-
-export class DataCubeState implements DataCubeAPI {
-  uuid = uuid();
-
+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 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 settings!: DataCubeSettings;
-  readonly documentationDisplay: DisplayState;
-  readonly initializeState = ActionState.create();
-
-  onInitialized?: ((dataCube: DataCubeState) => void) | undefined;
-  onNameChanged?: ((name: string, source: DataCubeSource) => void) | undefined;
-  innerHeaderComponent?:
-    | ((dataCube: DataCubeState) => React.ReactNode)
-    | undefined;
+  readonly options?: DataCubeOptions | undefined;
 
-  currentDocumentationEntry?: DocumentationEntry | undefined;
-  currentActionAlert?: ActionAlert | 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
   view: DataCubeViewState;
@@ -64,92 +64,75 @@ export class DataCubeState implements DataCubeAPI {
     options?: DataCubeOptions | undefined,
   ) {
     makeObservable(this, {
-      currentDocumentationEntry: observable,
-      openDocumentationEntry: action,
-
-      currentActionAlert: observable,
-      alertAction: action,
-
       uuid: observable,
       reload: action,
     });
 
-    this.query = query;
     this.engine = engine;
-    this.settings = new DataCubeSettings(this, options);
-    this.view = new DataCubeViewState(this);
-
-    this.documentationDisplay = this.engine.layout.newDisplay(
-      'Documentation',
-      () => <DocumentationPanel />,
-      {
-        x: -50,
-        y: -50,
-        width: 400,
-        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.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.onInitialized = options?.onInitialized;
-    this.onNameChanged = options?.onNameChanged;
-    this.innerHeaderComponent = options?.innerHeaderComponent;
-  }
+    this.api = new INTERNAL__DataCubeAPI(this);
+    this.query = query;
+    this.options = options;
 
-  reload() {
     this.view = new DataCubeViewState(this);
-    this.uuid = uuid();
-  }
-
-  getSettings() {
-    return this.settings;
-  }
-
-  openDocumentationEntry(entry: DocumentationEntry | undefined) {
-    this.currentDocumentationEntry = entry;
-  }
-
-  alertAction(alert: ActionAlert | undefined) {
-    this.currentActionAlert = alert;
-  }
-
-  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);
   }
 
   async initialize() {
     if (!this.initializeState.isInInitialState) {
-      this.engine.logDebug('DataCube state is re-initialized');
+      this.logService.logDebug('DataCube state is re-initialized');
       return;
     }
     this.initializeState.inProgress();
 
     try {
-      await this.engine.initialize({
-        gridClientLicense: this.settings.gridClientLicense,
+      // set up the components
+      if (this.options?.gridClientLicense) {
+        LicenseManager.setLicenseKey(this.options.gridClientLicense);
+      }
+      await configureCodeEditor(DataCubeFont.ROBOTO_MONO, (error) => {
+        throw error;
       });
+      setupPureLanguageService({});
 
-      this.onInitialized?.(this);
+      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.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,41 +63,19 @@ 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 } 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 { DataCubeColumn } from './model/DataCubeColumn.js';
 import {
   type DataCubeSource,
   INTERNAL__DataCubeSource,
-} from './models/DataCubeSource.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';
 
 export type CompletionItem = {
   completion: string;
@@ -119,8 +96,15 @@ export type DataCubeExecutionResult = {
   executedSQL: string;
 };
 
+/**
+ * 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(),
@@ -169,19 +153,7 @@ export abstract class DataCubeEngine {
     new DataCubeQueryAggregateOperation__JoinStrings(),
   ];
 
-  async initialize(options?: {
-    gridClientLicense?: string | undefined;
-  }): Promise<void> {
-    if (options?.gridClientLicense) {
-      LicenseManager.setLicenseKey(options.gridClientLicense);
-    }
-    await configureCodeEditor(DataCubeFont.ROBOTO_MONO, (error) => {
-      throw error;
-    });
-    setupPureLanguageService({});
-  }
-
-  // ------------------------------- CORE OPERATIONS -------------------------------
+  // ------------------------------- UTILITIES -------------------------------
 
   getFilterOperation(value: string) {
     return getFilterOperation(value, this.filterOperations);
@@ -219,7 +191,7 @@ export abstract class DataCubeEngine {
     ).substring(`''->`.length);
   }
 
-  // ---------------------------------- INTERFACE ----------------------------------
+  // ---------------------------------- PROCESSOR ----------------------------------
 
   abstract processQuerySource(value: PlainObject): Promise<DataCubeSource>;
 
@@ -239,11 +211,6 @@ export abstract class DataCubeEngine {
     source: DataCubeSource,
   ): Promise<CompletionItem[]>;
 
-  abstract getQueryRelationType(
-    query: V1_Lambda,
-    source: DataCubeSource,
-  ): Promise<DataCubeRelationType>;
-
   abstract getQueryCodeRelationReturnType(
     code: string,
     baseQuery: V1_ValueSpecification,
@@ -260,21 +227,7 @@ export abstract class DataCubeEngine {
     source: DataCubeSource,
   ): V1_AppliedFunction | undefined;
 
-  // ---------------------------------- DOCUMENTATION ----------------------------------
-
-  getDocumentationURL(): string | undefined {
-    return undefined;
-  }
-
-  getDocumentationEntry(key: string): DocumentationEntry | undefined {
-    return undefined;
-  }
-
-  shouldDisplayDocumentationEntry(entry: DocumentationEntry) {
-    return false;
-  }
-
-  // ---------------------------------- LOGGING ----------------------------------
+  // ---------------------------------- APPLICATION ----------------------------------
 
   logDebug(message: string, ...data: unknown[]) {
     // do nothing
@@ -304,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,

package/src/stores/core/DataCubeQueryBuilderUtils.ts

@@ -60,7 +60,7 @@ import {
   type DataCubeQuerySnapshotFilter,
   type DataCubeQuerySnapshot,
 } from './DataCubeQuerySnapshot.js';
-import { type DataCubeColumn } from './models/DataCubeColumn.js';
+import { type DataCubeColumn } from './model/DataCubeColumn.js';
 import {
   guaranteeNonNullable,
   guaranteeIsString,
@@ -87,7 +87,7 @@ import type { DataCubeQueryAggregateOperation } from './aggregation/DataCubeQuer
 import {
   DataCubeColumnConfiguration,
   type DataCubeConfiguration,
-} from './models/DataCubeConfiguration.js';
+} from './model/DataCubeConfiguration.js';
 
 // --------------------------------- UTILITIES ---------------------------------
 

package/src/stores/core/DataCubeQueryEngine.ts

@@ -198,39 +198,39 @@ export enum DataCubeQueryClientSideAggregateOperator {
 }
 
 export enum DataCubeQueryFilterOperator {
-  LESS_THAN = '<', // DONE
-  LESS_THAN_OR_EQUAL = '<=', // DONE
-  EQUAL = '=', // DONE
-  NOT_EQUAL = '!=', // DONE
-  GREATER_THAN = '>', // DONE
-  GREATER_THAN_OR_EQUAL = '>=', // DONE
+  LESS_THAN = '<',
+  LESS_THAN_OR_EQUAL = '<=',
+  EQUAL = '=',
+  NOT_EQUAL = '!=',
+  GREATER_THAN = '>',
+  GREATER_THAN_OR_EQUAL = '>=',
   IN = 'in',
   NOT_IN = 'not in',
-  IS_NULL = 'is null', // DONE
-  IS_NOT_NULL = 'is not null', // DONE
+  IS_NULL = 'is null',
+  IS_NOT_NULL = 'is not null',
   // string ONLY
-  EQUAL_CASE_INSENSITIVE = '= (case-insensitive)', // DONE
-  NOT_EQUAL_CASE_INSENSITIVE = '!= (case-insensitive)', // DONE
+  EQUAL_CASE_INSENSITIVE = '= (case-insensitive)',
+  NOT_EQUAL_CASE_INSENSITIVE = '!= (case-insensitive)',
   IN_CASE_INSENSITIVE = 'in (case-insensitive)',
   NOT_IN_CASE_INSENSITIVE = 'not in (case-insensitive)',
-  CONTAIN = 'contains', // DONE
-  CONTAIN_CASE_INSENSITIVE = 'contains (case-insensitive)', // DONE
-  NOT_CONTAIN = 'does not contain', // DONE
-  START_WITH = 'starts with', // DONE
-  START_WITH_CASE_INSENSITIVE = 'starts with (case-insensitive)', // DONE
-  NOT_START_WITH = 'does not start with', // DONE
-  END_WITH = 'ends with', // DONE
-  END_WITH_CASE_INSENSITIVE = 'ends with (case-insensitive)', // DONE
-  NOT_END_WITH = 'does not end with', // DONE
+  CONTAIN = 'contains',
+  CONTAIN_CASE_INSENSITIVE = 'contains (case-insensitive)',
+  NOT_CONTAIN = 'does not contain',
+  START_WITH = 'starts with',
+  START_WITH_CASE_INSENSITIVE = 'starts with (case-insensitive)',
+  NOT_START_WITH = 'does not start with',
+  END_WITH = 'ends with',
+  END_WITH_CASE_INSENSITIVE = 'ends with (case-insensitive)',
+  NOT_END_WITH = 'does not end with',
   // column
-  LESS_THAN_COLUMN = '< value in column', // DONE
-  LESS_THAN_OR_EQUAL_COLUMN = '<= value in column', // DONE
-  EQUAL_COLUMN = '= value in column', // DONE
-  EQUAL_CASE_INSENSITIVE_COLUMN = '= (case-insensitive) value in column', // DONE
-  NOT_EQUAL_COLUMN = '!= value in column', // DONE
-  NOT_EQUAL_CASE_INSENSITIVE_COLUMN = '!= (case-insensitive) value in column', // DONE
-  GREATER_THAN_COLUMN = '> value in column', // DONE
-  GREATER_THAN_OR_EQUAL_COLUMN = '>= value in column', // DONE
+  LESS_THAN_COLUMN = '< value in column',
+  LESS_THAN_OR_EQUAL_COLUMN = '<= value in column',
+  EQUAL_COLUMN = '= value in column',
+  EQUAL_CASE_INSENSITIVE_COLUMN = '= (case-insensitive) value in column',
+  NOT_EQUAL_COLUMN = '!= value in column',
+  NOT_EQUAL_CASE_INSENSITIVE_COLUMN = '!= (case-insensitive) value in column',
+  GREATER_THAN_COLUMN = '> value in column',
+  GREATER_THAN_OR_EQUAL_COLUMN = '>= value in column',
   // TODO?: having, having in aggregate, between
 }
 

package/src/stores/core/DataCubeQuerySnapshot.ts

@@ -15,7 +15,7 @@
  */
 
 import type { V1_AppliedFunction, V1_Lambda } from '@finos/legend-graph';
-import type { DataCubeConfiguration } from './models/DataCubeConfiguration.js';
+import type { DataCubeConfiguration } from './model/DataCubeConfiguration.js';
 import {
   IllegalStateError,
   hashObject,
@@ -28,7 +28,7 @@ import type {
   DataCubeOperationValue,
   DataCubeQuerySortDirection,
 } from './DataCubeQueryEngine.js';
-import type { DataCubeColumn } from './models/DataCubeColumn.js';
+import type { DataCubeColumn } from './model/DataCubeColumn.js';
 
 export type DataCubeQuerySnapshotFilterCondition = DataCubeColumn & {
   value: DataCubeOperationValue | undefined;