@finos/legend-data-cube 0.0.37 → 0.0.38

package/src/index.tsx

@@ -14,15 +14,14 @@
  * limitations under the License.
  */
 
-export * from './stores/core/models/DataCubeQuery.js';
-export * from './stores/core/models/DataCubeSource.js';
-export { type DataCubeColumn } from './stores/core/models/DataCubeColumn.js';
-export * from './stores/core/models/DataCubeConfiguration.js';
-export * from './stores/core/models/AdhocQueryDataCubeSource.js';
+export * from './stores/core/model/DataCubeQuery.js';
+export * from './stores/core/model/DataCubeSource.js';
+export { type DataCubeColumn } from './stores/core/model/DataCubeColumn.js';
+export * from './stores/core/model/DataCubeConfiguration.js';
+export * from './stores/core/model/AdhocQueryDataCubeSource.js';
 
 export * from './stores/core/DataCubeEngine.js';
 export * from './stores/core/DataCubeQueryEngine.js';
-export * from './stores/core/DataCubeLayoutManagerState.js';
 export * from './stores/core/DataCubeQueryBuilderUtils.js';
 
 export {
@@ -30,13 +29,25 @@ export {
   DataCubeSettingGroup,
   DataCubeSettingType,
   type DataCubeSettingValues,
-} from './stores/core/DataCubeSetting.js';
-export { DataCubeState } from './stores/DataCubeState.js';
+} from './stores/services/DataCubeSettingService.js';
+export {
+  DataCubeLayoutService,
+  WindowState,
+  DisplayState,
+  LayoutConfiguration,
+  DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
+  DEFAULT_ALERT_WINDOW_CONFIG,
+} from './stores/services/DataCubeLayoutService.js';
+export * from './stores/services/DataCubeTaskService.js';
+export * from './stores/services/DataCubeLogService.js';
+export * from './stores/services/DataCubeAlertService.js';
+export * from './components/core/DataCubeAlert.js';
+export * from './components/core/DataCubeLayout.js';
+
 export { useDataCube } from './components/DataCubeProvider.js';
-export * from './stores/DataCubeAPI.js';
+export { type DataCubeAPI } from './stores/DataCubeAPI.js';
 export * from './stores/DataCubeOptions.js';
-
 export * from './components/DataCube.js';
-export * from './components/core/DataCubeAlert.js';
+
 export * from './components/core/DataCubeFormUtils.js';
-export * from './components/core/DataCubeLayoutManager.js';
+export * from './components/DataCubePlaceholder.js';

package/src/stores/DataCubeAPI.ts

@@ -14,9 +14,64 @@
  * limitations under the License.
  */
 
-import type { DataCubeSettings } from './DataCubeSettings.js';
+import type { DataCubeQuery } from './core/model/DataCubeQuery.js';
+import type { DataCubeState } from './DataCubeState.js';
+import type { DataCubeViewState } from './view/DataCubeViewState.js';
 
+/**
+ * This is the API exposed externally by DataCube to restrict access to certain
+ * internal components and functionalities.
+ */
 export interface DataCubeAPI {
-  getSettings(): DataCubeSettings;
-  refreshFailedDataFetches(): void;
+  /**
+   * Generates the data cube query (including the query, configuration, and source)
+   * from the latest state of the DataCube.
+   */
+  generateDataCubeQuery(): Promise<DataCubeQuery>;
+  /**
+   * Retries all failed data fetches and rerender the grid.
+   */
+  retryFailedDataFetches(): void;
+  /**
+   * (Force) reload/rerender the DataCube component.
+   *
+   * This is often used when updating settings that requires a restart.
+   */
+  reload(): void;
+}
+
+/**
+ * This implementation wraps around DataCube state to expose a cleaner API to clients.
+ * It also provides a typing-hack for core components to access advanced functionalities,
+ * e.g. access to the internals of DataCube view state, grid client, etc., which should
+ * not be exposed externally via the public interface.
+ */
+export class INTERNAL__DataCubeAPI implements DataCubeAPI {
+  private readonly _dataCube: DataCubeState;
+
+  constructor(dataCube: DataCubeState) {
+    this._dataCube = dataCube;
+  }
+
+  _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._dataCube.view);
+  }
+
+  // ----------------------------- API -----------------------------
+
+  generateDataCubeQuery() {
+    return this._dataCube.view.generateDataCubeQuery();
+  }
+
+  retryFailedDataFetches() {
+    this._runTaskForEachView((view) => {
+      view.grid.client.retryServerSideLoads();
+    });
+  }
+
+  reload() {
+    this._dataCube.reload();
+  }
 }

package/src/stores/DataCubeOptions.ts

@@ -17,24 +17,113 @@
 import type {
   DataCubeSetting,
   DataCubeSettingValues,
-} from './core/DataCubeSetting.js';
-import type { DataCubeSource } from './core/models/DataCubeSource.js';
-import type { DataCubeState } from './DataCubeState.js';
+} from './services/DataCubeSettingService.js';
+import type { DataCubeSource } from './core/model/DataCubeSource.js';
+import type { DataCubeAPI } from './DataCubeAPI.js';
+import type { LayoutManager } from './services/DataCubeLayoutService.js';
+import type { TaskManager } from './services/DataCubeTaskService.js';
+
+type DataCubeOptionsBaseEvent = {
+  api: DataCubeAPI;
+};
+export type DataCubeInitializedEvent = DataCubeOptionsBaseEvent;
+export type DataCubeViewInitializedEvent = DataCubeOptionsBaseEvent & {
+  source: DataCubeSource;
+};
+export type DataCubeNameChangedEvent = DataCubeOptionsBaseEvent & {
+  name: string;
+  source: DataCubeSource;
+};
+export type DataCubeSettingsChangedEvent = DataCubeOptionsBaseEvent & {
+  values: DataCubeSettingValues;
+};
+
+type DataCubeSettingsData = {
+  configurations?: DataCubeSetting[] | undefined;
+  values?: DataCubeSettingValues | undefined;
+};
+
+export type DataCubeMenuItem = {
+  label: string;
+  disabled?: boolean | undefined;
+  action: () => void;
+};
+
+type DataCubeOptionsBaseParams = {
+  api: DataCubeAPI;
+};
+export type DataCubeInnerHeaderComponentParams = DataCubeOptionsBaseParams;
 
 export type DataCubeOptions = {
-  gridClientLicense?: string | undefined;
+  // -------------------------- INFRASTRUCTURE ------------------------------
 
-  onInitialized?: ((dataCube: DataCubeState) => void) | undefined;
+  /**
+   * Provides a task manager that can be used by DataCube task service.
+   *
+   * This is useful when creating a seamless integration between DataCube and
+   * the application.
+   */
+  taskManager?: TaskManager | undefined;
+  /**
+   * DataCube has initialized and is ready for most API calls, but may not be fully rendered yet.
+   */
+  onInitialized?: ((event: DataCubeInitializedEvent) => void) | undefined;
+  /**
+   * DataCube main view has initialized, and is ready for most API calls, but may not be fully rendered yet.
+   * The query source has been fully resolved and analyzed, grid view is to be rendered right after.
+   */
+  onViewInitialized?:
+    | ((event: DataCubeViewInitializedEvent) => void)
+    | undefined;
 
-  onNameChanged?: ((name: string, source: DataCubeSource) => void) | undefined;
+  // ------------------------------ GRID ------------------------------
+
+  /**
+   * License key for the grid client (i.e. ag-grid) as DataCube makes use of
+   * fair number of advanced/enterprise features.
+   */
+  gridClientLicense?: string | undefined;
 
-  innerHeaderComponent?:
-    | ((dataCube: DataCubeState) => React.ReactNode)
+  // ------------------------------ LAYOUT ------------------------------
+
+  /**
+   * Provides a layout manager that can be used by DataCube layout service.
+   *
+   * This is useful when creating a seamless integration between DataCube and
+   * the application.
+   */
+  layoutManager?: LayoutManager | undefined;
+  /**
+   * The name of the DataCube main view is updated.
+   */
+  onNameChanged?: ((event: DataCubeNameChangedEvent) => void) | undefined;
+  /**
+   * Custom renderer for the inner header area, next to the title.
+   */
+  innerHeaderRenderer?:
+    | ((params: DataCubeInnerHeaderComponentParams) => React.ReactNode)
     | undefined;
 
-  getSettingItems?: (() => DataCubeSetting[]) | undefined;
-  getSettingValues?: (() => DataCubeSettingValues | undefined) | undefined;
-  onSettingValuesChanged?:
-    | ((values: DataCubeSettingValues) => void)
+  // ------------------------------ SETTINGS ------------------------------
+
+  /**
+   * DataCube settings values (retrieved externally), which would be set as initial values,
+   * and extra setting configurations that would be rendered in the settings panel.
+   */
+  settingsData?: DataCubeSettingsData | undefined;
+  /**
+   * Settings are changed and saved.
+   *
+   * This is useful when the application needs to persist the new settings values.
+   */
+  onSettingsChanged?:
+    | ((event: DataCubeSettingsChangedEvent) => void)
     | undefined;
+
+  // ------------------------------ DOCUMENTATION ------------------------------
+
+  /**
+   * URL to the documentation website.
+   */
+  documentationUrl?: string | undefined;
 };

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,