@finos/legend-data-cube 0.0.37 → 0.0.38

package/src/stores/services/DataCubeDocumentationService.tsx

@@ -0,0 +1,74 @@
+/**
+ * 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 type { DocumentationEntry } from '@finos/legend-shared';
+import { makeObservable, observable, action } from 'mobx';
+import { DocumentationPanel } from '../../components/core/DataCubeDocumentationPanel.js';
+import type {
+  DataCubeLayoutService,
+  DisplayState,
+} from './DataCubeLayoutService.js';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+
+export class DataCubeDocumentationService {
+  private readonly _engine: DataCubeEngine;
+  private readonly _layoutService: DataCubeLayoutService;
+
+  readonly display: DisplayState;
+
+  currentEntry?: DocumentationEntry | undefined;
+
+  constructor(engine: DataCubeEngine, layoutService: DataCubeLayoutService) {
+    makeObservable(this, {
+      currentEntry: observable,
+      setCurrentEntry: action,
+    });
+
+    this._engine = engine;
+    this._layoutService = layoutService;
+    this.display = this._layoutService.newDisplay(
+      'Documentation',
+      () => <DocumentationPanel />,
+      {
+        x: -50,
+        y: -50,
+        width: 400,
+        height: 400,
+        minWidth: 300,
+        minHeight: 200,
+        center: false,
+      },
+    );
+  }
+
+  getEntry(key: string) {
+    return this._engine.getDocumentationEntry(key);
+  }
+
+  setCurrentEntry(entry: DocumentationEntry | undefined) {
+    this.currentEntry = entry;
+  }
+
+  shouldDisplayDocumentationEntry(entry: DocumentationEntry) {
+    return (
+      /**
+       * Since we're displaying the documentation entry, we want only user-friendly docs
+       * and discard anything that doesn't come with a title, or does not have any content
+       */
+      Boolean(entry.title && (entry.text ?? entry.markdownText))
+    );
+  }
+}

package/src/stores/{core/DataCubeLayoutManagerState.ts → services/DataCubeLayoutService.tsx}

@@ -23,6 +23,13 @@ import {
   runInAction,
 } from 'mobx';
 
+export type WindowSpecification = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
 export type WindowConfiguration = {
   x?: number | undefined;
   y?: number | undefined;
@@ -51,13 +58,21 @@ export class WindowState {
   readonly uuid = uuid();
   readonly configuration: LayoutConfiguration;
   readonly onClose?: (() => void) | undefined;
+  ownerId?: string | undefined;
+  specification?: WindowSpecification | undefined;
 
   constructor(
     configuration: LayoutConfiguration,
     onClose?: (() => void) | undefined,
+    ownerId?: string | undefined,
   ) {
     this.configuration = configuration;
     this.onClose = onClose;
+    this.ownerId = ownerId;
+  }
+
+  setSpecification(val: WindowSpecification) {
+    this.specification = val;
   }
 }
 
@@ -75,7 +90,7 @@ export const DEFAULT_TOOL_PANEL_WINDOW_CONFIG: WindowConfiguration = {
   center: true,
 };
 
-export const DEFAULT_SMALL_ALERT_WINDOW_CONFIG: WindowConfiguration = {
+export const DEFAULT_ALERT_WINDOW_CONFIG: WindowConfiguration = {
   width: 500,
   height: 200,
   minWidth: 200,
@@ -83,23 +98,17 @@ export const DEFAULT_SMALL_ALERT_WINDOW_CONFIG: WindowConfiguration = {
   center: true,
 };
 
-export const DEFAULT_LARGE_ALERT_WINDOW_CONFIG: WindowConfiguration = {
-  width: 600,
-  height: 200,
-  minWidth: 300,
-  minHeight: 150,
-  center: true,
-};
-
 export class DisplayState {
-  private readonly layoutManagerState: LayoutManagerState;
+  private readonly layout: LayoutManager;
   readonly configuration: LayoutConfiguration;
+  readonly ownerId?: string | undefined;
   window?: WindowState | undefined;
 
   constructor(
-    layoutManagerState: LayoutManagerState,
+    layout: LayoutManager,
     title: string,
     contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
+    ownerId?: string | undefined,
   ) {
     makeObservable(this, {
       window: observable,
@@ -108,9 +117,10 @@ export class DisplayState {
       close: action,
     });
 
-    this.layoutManagerState = layoutManagerState;
+    this.layout = layout;
     this.configuration = new LayoutConfiguration(title, contentRenderer);
     this.configuration.window = DEFAULT_TOOL_PANEL_WINDOW_CONFIG;
+    this.ownerId = ownerId;
   }
 
   get isOpen() {
@@ -119,26 +129,30 @@ export class DisplayState {
 
   open() {
     if (this.window) {
-      this.layoutManagerState.bringWindowFront(this.window);
+      this.layout.bringWindowFront(this.window);
     } else {
-      this.window = new WindowState(this.configuration, () =>
-        runInAction(() => {
-          this.window = undefined;
-        }),
+      this.window = new WindowState(
+        this.configuration,
+        () =>
+          runInAction(() => {
+            this.window = undefined;
+          }),
+        this.ownerId,
       );
-      this.layoutManagerState.newWindow(this.window);
+      this.layout.newWindow(this.window, this.ownerId);
     }
   }
 
   close() {
     if (this.window) {
-      this.layoutManagerState.closeWindow(this.window);
+      this.layout.closeWindow(this.window);
       this.window = undefined;
     }
   }
 }
 
-export class LayoutManagerState {
+export class LayoutManager {
+  // TODO?: keep a hashmap, in parallel, for faster lookup
   windows: WindowState[] = [];
 
   constructor() {
@@ -147,6 +161,7 @@ export class LayoutManagerState {
       newWindow: action,
       bringWindowFront: action,
       closeWindow: action,
+      closeWindows: action,
     });
   }
 
@@ -154,15 +169,17 @@ export class LayoutManagerState {
     title: string,
     contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
     windowConfiguration?: WindowConfiguration | undefined,
-  ): DisplayState {
-    const display = new DisplayState(this, title, contentRenderer);
+    ownerId?: string | undefined,
+  ) {
+    const display = new DisplayState(this, title, contentRenderer, ownerId);
     if (windowConfiguration) {
       display.configuration.window = windowConfiguration;
     }
     return display;
   }
 
-  newWindow(window: WindowState) {
+  newWindow(window: WindowState, ownerId?: string | undefined) {
+    window.ownerId = window.ownerId ?? ownerId;
     this.windows.push(window);
   }
 
@@ -181,4 +198,60 @@ export class LayoutManagerState {
       window.onClose?.();
     }
   }
+
+  closeWindows(windows: WindowState[]) {
+    this.windows = this.windows.filter(
+      (window) => !windows.find((w) => w.uuid === window.uuid),
+    );
+    windows.forEach((window) => window.onClose?.());
+  }
+}
+
+export class DataCubeLayoutService {
+  readonly uuid = uuid();
+  readonly manager: LayoutManager;
+
+  constructor(manager?: LayoutManager | undefined) {
+    makeObservable(this, {
+      windows: computed,
+    });
+
+    this.manager = manager ?? new LayoutManager();
+  }
+
+  get windows() {
+    return this.manager.windows.filter(
+      (window) => window.ownerId === this.uuid,
+    );
+  }
+
+  newDisplay(
+    title: string,
+    contentRenderer: (config: LayoutConfiguration) => React.ReactNode,
+    windowConfiguration?: WindowConfiguration | undefined,
+  ) {
+    return this.manager.newDisplay(
+      title,
+      contentRenderer,
+      windowConfiguration,
+      this.uuid,
+    );
+  }
+
+  newWindow(window: WindowState) {
+    this.manager.newWindow(window, this.uuid);
+  }
+
+  bringWindowFront(window: WindowState) {
+    this.manager.bringWindowFront(window);
+  }
+
+  closeWindow(window: WindowState) {
+    this.manager.closeWindow(window);
+  }
+
+  dispose() {
+    // close all windows owned by this service
+    this.manager.closeWindows(this.windows);
+  }
 }

package/src/stores/services/DataCubeLogService.ts

@@ -0,0 +1,54 @@
+/**
+ * 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 type { LogEvent } from '@finos/legend-shared';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+
+export class DataCubeLogService {
+  private readonly _engine: DataCubeEngine;
+
+  constructor(engine: DataCubeEngine) {
+    this._engine = engine;
+  }
+
+  logDebug(message: string, ...data: unknown[]) {
+    this._engine.logDebug(message, ...data);
+  }
+
+  debugProcess(processName: string, ...data: [string, unknown][]) {
+    this._engine.debugProcess(processName, ...data);
+  }
+
+  logInfo(event: LogEvent, ...data: unknown[]) {
+    this._engine.logInfo(event, ...data);
+  }
+
+  logWarning(event: LogEvent, ...data: unknown[]) {
+    this._engine.logWarning(event, ...data);
+  }
+
+  logError(event: LogEvent, ...data: unknown[]) {
+    this._engine.logError(event, ...data);
+  }
+
+  logUnhandledError(error: Error) {
+    this._engine.logUnhandledError(error);
+  }
+
+  logIllegalStateError(message: string, error?: Error) {
+    this._engine.logIllegalStateError(message, error);
+  }
+}

package/src/stores/services/DataCubeNavigationService.ts

@@ -0,0 +1,29 @@
+/**
+ * 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 type { DataCubeEngine } from '../core/DataCubeEngine.js';
+
+export class DataCubeNavigationService {
+  private readonly _engine: DataCubeEngine;
+
+  constructor(engine: DataCubeEngine) {
+    this._engine = engine;
+  }
+
+  openLink(url: string) {
+    this._engine.openLink(url);
+  }
+}

package/src/stores/{view/DataCubeQuerySnapshotManager.ts → services/DataCubeQuerySnapshotService.ts}

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import type { DataCubeViewState } from './DataCubeViewState.js';
 import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
 import {
   IllegalStateError,
@@ -22,8 +21,11 @@ import {
   deepDiff,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
-import type { DataCubeQuery } from '../core/models/DataCubeQuery.js';
-import { DataCubeSettingKey } from '../core/DataCubeSetting.js';
+import type { DataCubeQuery } from '../core/model/DataCubeQuery.js';
+import { DataCubeSettingKey } from '../../__lib__/DataCubeSetting.js';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+import type { DataCubeSettingService } from './DataCubeSettingService.js';
+import type { DataCubeLogService } from './DataCubeLogService.js';
 
 // TODO: set a stack depth when we implement undo/redo
 // const DATA_CUBE_MAX_SNAPSHOT_COUNT = 100;
@@ -37,40 +39,52 @@ interface DataCubeQuerySnapshotSubscriber {
 export abstract class DataCubeQuerySnapshotController
   implements DataCubeQuerySnapshotSubscriber
 {
-  readonly view!: DataCubeViewState;
+  protected readonly _engine: DataCubeEngine;
+  protected readonly _settingService: DataCubeSettingService;
+  protected readonly _snapshotService: DataCubeQuerySnapshotService;
 
-  private latestSnapshot: DataCubeQuerySnapshot | undefined;
+  private _latestSnapshot: DataCubeQuerySnapshot | undefined;
 
-  constructor(view: DataCubeViewState) {
-    this.view = view;
+  constructor(
+    engine: DataCubeEngine,
+    settingService: DataCubeSettingService,
+    snapshotService: DataCubeQuerySnapshotService,
+  ) {
+    this._engine = engine;
+    this._settingService = settingService;
+    this._snapshotService = snapshotService;
   }
 
   abstract getSnapshotSubscriberName(): string;
 
-  abstract applySnapshot(
-    snapshot: DataCubeQuerySnapshot,
-    previousSnapshot: DataCubeQuerySnapshot | undefined,
-  ): Promise<void>;
+  getLatestSnapshot() {
+    return this._latestSnapshot;
+  }
 
   async receiveSnapshot(snapshot: DataCubeQuerySnapshot) {
-    const previousSnapshot = this.latestSnapshot;
-    this.latestSnapshot = snapshot;
+    const previousSnapshot = this._latestSnapshot;
+    this._latestSnapshot = snapshot;
 
     // NOTE: fully clone the snapshot before applying it to avoid any potential
     // mutation of the snapshot by the subscriber
     await this.applySnapshot(snapshot.INTERNAL__fullClone(), previousSnapshot);
   }
 
+  abstract applySnapshot(
+    snapshot: DataCubeQuerySnapshot,
+    previousSnapshot: DataCubeQuerySnapshot | undefined,
+  ): Promise<void>;
+
   publishSnapshot(snapshot: DataCubeQuerySnapshot) {
-    const previousSnapshot = this.latestSnapshot;
-    this.latestSnapshot = snapshot;
+    const previousSnapshot = this._latestSnapshot;
+    this._latestSnapshot = snapshot;
 
     if (
-      this.view.dataCube.settings.getBooleanValue(
+      this._settingService.getBooleanValue(
         DataCubeSettingKey.DEBUGGER__ENABLE_DEBUG_MODE,
       )
     ) {
-      this.view.engine.debugProcess(
+      this._engine.debugProcess(
         `New Snapshot`,
         ['Publisher', this.getSnapshotSubscriberName()],
         ['Snapshot', snapshot],
@@ -79,32 +93,30 @@ export abstract class DataCubeQuerySnapshotController
       );
     }
 
-    this.view.snapshotManager.broadcastSnapshot(snapshot);
-  }
-
-  getLatestSnapshot() {
-    return this.latestSnapshot;
+    this._snapshotService.broadcastSnapshot(snapshot);
   }
 }
 
-export class DataCubeQuerySnapshotManager {
-  private readonly view: DataCubeViewState;
-  private readonly subscribers: DataCubeQuerySnapshotSubscriber[] = [];
-  private readonly snapshots: DataCubeQuerySnapshot[] = [];
+export class DataCubeQuerySnapshotService {
+  private readonly _engine: DataCubeEngine;
+  private readonly _logService: DataCubeLogService;
 
+  private readonly _subscribers: DataCubeQuerySnapshotSubscriber[] = [];
+  private readonly _snapshots: DataCubeQuerySnapshot[] = []; // stack
   private _initialSnapshot: DataCubeQuerySnapshot | undefined;
   private _initialQuery: DataCubeQuery | undefined;
 
-  constructor(view: DataCubeViewState) {
-    this.view = view;
+  constructor(engine: DataCubeEngine, logService: DataCubeLogService) {
+    this._engine = engine;
+    this._logService = logService;
   }
 
   get currentSnapshot() {
-    return guaranteeNonNullable(this.snapshots[this.snapshots.length - 1]);
+    return guaranteeNonNullable(this._snapshots[this._snapshots.length - 1]);
   }
 
   registerSubscriber(subscriber: DataCubeQuerySnapshotSubscriber) {
-    const existingSubscriber = this.subscribers.find(
+    const existingSubscriber = this._subscribers.find(
       (sub) =>
         sub.getSnapshotSubscriberName() ===
         subscriber.getSnapshotSubscriberName(),
@@ -112,7 +124,7 @@ export class DataCubeQuerySnapshotManager {
     if (existingSubscriber) {
       // eslint-disable-next-line no-process-env
       if (process.env.NODE_ENV === 'development') {
-        this.view.engine.logDebug(
+        this._logService.logDebug(
           `Subscriber with name '${subscriber.getSnapshotSubscriberName()}' already exists`,
         );
       } else {
@@ -121,7 +133,7 @@ export class DataCubeQuerySnapshotManager {
         );
       }
     }
-    this.subscribers.push(subscriber);
+    this._subscribers.push(subscriber);
   }
 
   initialize(
@@ -153,18 +165,18 @@ export class DataCubeQuerySnapshotManager {
 
   broadcastSnapshot(snapshot: DataCubeQuerySnapshot) {
     if (!snapshot.isFinalized()) {
-      this.view.engine.logIllegalStateError(
+      this._logService.logIllegalStateError(
         `Snapshot must be finalized before broadcasting`,
       );
       return;
     }
-    this.snapshots.push(snapshot);
-    this.subscribers.forEach((subscriber) => {
+    this._snapshots.push(snapshot);
+    this._subscribers.forEach((subscriber) => {
       const currentSnapshot = subscriber.getLatestSnapshot();
       if (currentSnapshot?.uuid !== snapshot.uuid) {
         subscriber.receiveSnapshot(snapshot).catch((error: unknown) => {
           assertErrorThrown(error);
-          this.view.engine.logIllegalStateError(
+          this._logService.logIllegalStateError(
             `Error occured while subscribers receiving and applying new snapshot should be handled gracefully`,
             error,
           );
@@ -172,6 +184,4 @@ export class DataCubeQuerySnapshotManager {
       }
     });
   }
-
-  // TODO: replace snapshot (for minor modifications such as adjusting the cast columns)
 }