@finos/legend-data-cube 0.0.37 → 0.0.38

package/src/stores/{DataCubeSettings.tsx → services/DataCubeSettingService.tsx}

@@ -14,15 +14,7 @@
  * limitations under the License.
  */
 
-import type { DataCubeState } from './DataCubeState.js';
-import {
-  DataCubeSettingGroup,
-  DataCubeSettingKey,
-  DataCubeSettingType,
-  type DataCubeSetting,
-  type DataCubeSettingValue,
-  type DataCubeSettingValues,
-} from './core/DataCubeSetting.js';
+import { DataCubeSettingKey } from '../../__lib__/DataCubeSetting.js';
 import {
   hashArray,
   IllegalStateError,
@@ -32,8 +24,8 @@ import {
   LogEvent,
   UnsupportedOperationError,
 } from '@finos/legend-shared';
-import { DataCubeEvent } from '../__lib__/DataCubeEvent.js';
-import type { DataCubeOptions } from './DataCubeOptions.js';
+import { DataCubeEvent } from '../../__lib__/DataCubeEvent.js';
+import type { DataCubeOptions } from '../DataCubeOptions.js';
 import {
   action,
   computed,
@@ -41,40 +33,95 @@ import {
   observable,
   runInAction,
 } from 'mobx';
-import type { DisplayState } from './core/DataCubeLayoutManagerState.js';
-import { DataCubeSettingsPanel } from '../components/core/DataCubeSettingsPanel.js';
+import type {
+  DataCubeLayoutService,
+  DisplayState,
+} from './DataCubeLayoutService.js';
+import { DataCubeSettingsPanel } from '../../components/core/DataCubeSettingsPanel.js';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+import type { DataCubeAPI, INTERNAL__DataCubeAPI } from '../DataCubeAPI.js';
+import type { DataCubeLogService } from './DataCubeLogService.js';
+
+export type DataCubeSettingValue =
+  | string
+  | number
+  | boolean
+  | object
+  | undefined;
+
+export type DataCubeSettingValues = {
+  [key: string]: DataCubeSettingValue;
+};
+
+export enum DataCubeSettingGroup {
+  DEBUG = 'Debug',
+  GRID = 'Grid',
+}
+
+export enum DataCubeSettingType {
+  BOOLEAN = 'boolean',
+  NUMERIC = 'numeric',
+  STRING = 'string',
+  ACTION = 'action',
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type DataCubeSetting<T extends DataCubeSettingValue = any> = {
+  key: string;
+  title: string;
+  group: string;
+  type: DataCubeSettingType;
+  defaultValue: T;
+  action?: ((api: DataCubeAPI, newValue: T) => void) | undefined;
+  description?: string | undefined;
+  valueOptional?: boolean | undefined;
+  requiresReload?: boolean | undefined;
+  // numeric value specifics - TODO: we might want to break these downw to separate types
+  numericValueMin?: number | undefined;
+  numericValueMax?: number | undefined;
+  numericValueStep?: number | undefined;
+};
+
+export class DataCubeSettingService {
+  private readonly _engine: DataCubeEngine;
+  private readonly _logService: DataCubeLogService;
+  private readonly _layoutService: DataCubeLayoutService;
+  private readonly _options?: DataCubeOptions | undefined;
 
-export class DataCubeSettings {
-  readonly dataCube: DataCubeState;
   readonly display: DisplayState;
   readonly configurations = new Map<string, DataCubeSetting>();
   readonly defaultValues = new Map<string, DataCubeSettingValue>();
-  readonly defaultValuesHashCode!: string;
+  private readonly _defaultValuesHashCode!: string;
   readonly values = new Map<string, DataCubeSettingValue>();
   readonly currentValues = new Map<string, DataCubeSettingValue>();
 
-  getSettingValues?: (() => DataCubeSettingValues | undefined) | undefined;
-  onSettingValuesChanged?:
-    | ((values: DataCubeSettingValues) => void)
-    | undefined;
-  gridClientLicense?: string | undefined;
-
-  constructor(dataCube: DataCubeState, options?: DataCubeOptions | undefined) {
-    makeObservable(this, {
+  constructor(
+    engine: DataCubeEngine,
+    logService: DataCubeLogService,
+    layoutService: DataCubeLayoutService,
+    options?: DataCubeOptions | undefined,
+  ) {
+    makeObservable<
+      DataCubeSettingService,
+      'valuesHashCode' | 'currentValuesHashCode'
+    >(this, {
       values: observable,
       save: action,
       valuesHashCode: computed,
 
       currentValues: observable,
-      resetDefaultValues: action,
+      restoreDefaultValues: action,
       currentValuesHashCode: computed,
+
+      allowRestoreDefaultValues: computed,
     });
 
-    this.dataCube = dataCube;
-    this.getSettingValues = options?.getSettingValues;
-    this.onSettingValuesChanged = options?.onSettingValuesChanged;
+    this._engine = engine;
+    this._logService = logService;
+    this._layoutService = layoutService;
+    this._options = options;
 
-    this.display = this.dataCube.engine.layout.newDisplay(
+    this.display = this._layoutService.newDisplay(
       'Settings',
       () => <DataCubeSettingsPanel />,
       {
@@ -97,6 +144,15 @@ export class DataCubeSettings {
         type: DataCubeSettingType.BOOLEAN,
         defaultValue: false,
       } satisfies DataCubeSetting<boolean>,
+      {
+        key: DataCubeSettingKey.DEBUGGER__ACTION__RELOAD,
+        title: `Reload`,
+        description: `Manually reload DataCube (keeping all states). This is needed when making changes to settings that require reloading to take effect.`,
+        group: DataCubeSettingGroup.DEBUG,
+        type: DataCubeSettingType.ACTION,
+        action: (api) => api.reload(),
+        defaultValue: undefined,
+      } satisfies DataCubeSetting,
       {
         key: DataCubeSettingKey.GRID_CLIENT__SUPPRESS_LARGE_DATASET_WARNING,
         title: `Large Dataset Warning: Disabled`,
@@ -114,8 +170,8 @@ export class DataCubeSettings {
         defaultValue: 50,
         numericValueMin: 10,
         numericValueStep: 10,
-        action: (newValue) =>
-          this.dataCube.runTaskForEachView((view) => {
+        action: (api, newValue) =>
+          (api as INTERNAL__DataCubeAPI)._runTaskForEachView((view) => {
             view.grid.client.updateGridOptions({
               rowBuffer: newValue,
             });
@@ -128,36 +184,36 @@ export class DataCubeSettings {
         group: DataCubeSettingGroup.GRID,
         type: DataCubeSettingType.BOOLEAN,
         defaultValue: false,
-        action: (newValue) =>
-          this.dataCube.runTaskForEachView((view) => {
+        action: (api, newValue) =>
+          (api as INTERNAL__DataCubeAPI)._runTaskForEachView((view) => {
             view.grid.client.updateGridOptions({
               purgeClosedRowNodes: newValue,
             });
           }),
       } satisfies DataCubeSetting<boolean>,
       {
-        key: DataCubeSettingKey.GRID_CLIENT__ACTION__REFRESH_FAILED_DATA_FETCHES,
-        title: `Refresh Failed Data Fetch: Action`,
+        key: DataCubeSettingKey.GRID_CLIENT__ACTION__RETRY_FAILED_DATA_FETCHES,
+        title: `Retry Failed Data Fetches: Action`,
         description: `Manually re-runs all failed data fetches in the grid.`,
         group: DataCubeSettingGroup.GRID,
         type: DataCubeSettingType.ACTION,
-        action: () => this.dataCube.refreshFailedDataFetches(),
+        action: (api) => api.retryFailedDataFetches(),
         defaultValue: undefined,
       } satisfies DataCubeSetting,
     ];
 
-    [...CORE_SETTINGS, ...(options?.getSettingItems?.() ?? [])].forEach(
-      (configuration) => {
-        this.configurations.set(configuration.key, configuration);
-        this.setValue(configuration.key, configuration.defaultValue, [
-          this.defaultValues,
-          this.values,
-          this.currentValues,
-        ]);
-      },
-    );
+    const { configurations, values } = options?.settingsData ?? {};
+
+    [...CORE_SETTINGS, ...(configurations ?? [])].forEach((configuration) => {
+      this.configurations.set(configuration.key, configuration);
+      this.setValue(configuration.key, configuration.defaultValue, [
+        this.defaultValues,
+        this.values,
+        this.currentValues,
+      ]);
+    });
 
-    const settingValues = this.getSettingValues?.() ?? {};
+    const settingValues = values ?? {};
     Object.keys(settingValues).forEach((key) => {
       const value = settingValues[key];
       // for unknown settings (e.g. outdated settings, settings' keys changed, etc.), we ignore them
@@ -172,7 +228,9 @@ export class DataCubeSettings {
     // be processed here, as they should override the settings retrieved from
     // cache.
 
-    this.defaultValuesHashCode = this.computeValuesHashCode(this.defaultValues);
+    this._defaultValuesHashCode = this.computeValuesHashCode(
+      this.defaultValues,
+    );
   }
 
   private setValue(
@@ -182,7 +240,7 @@ export class DataCubeSettings {
   ) {
     const configuration = this.configurations.get(key);
     if (!configuration) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
         ),
@@ -198,7 +256,7 @@ export class DataCubeSettings {
             (value === undefined && configuration.valueOptional)
           )
         ) {
-          this.dataCube.engine.logWarning(
+          this._logService.logWarning(
             LogEvent.create(
               DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
             ),
@@ -215,7 +273,7 @@ export class DataCubeSettings {
             (value === undefined && configuration.valueOptional)
           )
         ) {
-          this.dataCube.engine.logWarning(
+          this._logService.logWarning(
             LogEvent.create(
               DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
             ),
@@ -232,7 +290,7 @@ export class DataCubeSettings {
             (value === undefined && configuration.valueOptional)
           )
         ) {
-          this.dataCube.engine.logWarning(
+          this._logService.logWarning(
             LogEvent.create(
               DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
             ),
@@ -259,7 +317,7 @@ export class DataCubeSettings {
   private getConfiguration(key: string) {
     const configuration = this.configurations.get(key);
     if (!configuration) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
         ),
@@ -279,7 +337,7 @@ export class DataCubeSettings {
       configuration.type !== DataCubeSettingType.BOOLEAN ||
       !isBoolean(value)
     ) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__RETRIEVE_INCOMPATIBLE_VALUE,
         ),
@@ -299,7 +357,7 @@ export class DataCubeSettings {
       configuration.type !== DataCubeSettingType.NUMERIC ||
       !isNumber(value)
     ) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__RETRIEVE_INCOMPATIBLE_VALUE,
         ),
@@ -316,7 +374,7 @@ export class DataCubeSettings {
     const value = this.values.get(key);
     const configuration = this.getConfiguration(key);
     if (configuration.type !== DataCubeSettingType.STRING || !isString(value)) {
-      this.dataCube.engine.logWarning(
+      this._logService.logWarning(
         LogEvent.create(
           DataCubeEvent.SETTINGS__FAILURE__RETRIEVE_INCOMPATIBLE_VALUE,
         ),
@@ -329,29 +387,6 @@ export class DataCubeSettings {
     return value;
   }
 
-  updateValue(key: string, value: DataCubeSettingValue) {
-    const configuration = this.configurations.get(key);
-    if (!configuration) {
-      this.dataCube.engine.logWarning(
-        LogEvent.create(
-          DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
-        ),
-        `Can't set value for unregistered setting '${key}'`,
-      );
-      return;
-    }
-
-    if (!this.setValue(key, value, [this.values, this.currentValues])) {
-      return;
-    }
-
-    // trigger hook
-    this.onSettingValuesChanged?.(this.getCurrentSettingValues());
-
-    // trigger action
-    configuration.action?.(value);
-  }
-
   private computeValuesHashCode(values: Map<string, DataCubeSettingValue>) {
     return hashArray(
       Array.from(values.entries())
@@ -360,22 +395,26 @@ export class DataCubeSettings {
     );
   }
 
-  get valuesHashCode() {
+  private get valuesHashCode() {
     return this.computeValuesHashCode(this.values);
   }
 
-  get currentValuesHashCode() {
+  private get currentValuesHashCode() {
     return this.computeValuesHashCode(this.currentValues);
   }
 
-  resetDefaultValues() {
+  get allowRestoreDefaultValues() {
+    return this._defaultValuesHashCode !== this.currentValuesHashCode;
+  }
+
+  restoreDefaultValues() {
     this.currentValues.clear();
     this.defaultValues.forEach((value, key) =>
       this.currentValues.set(key, value),
     );
   }
 
-  private getCurrentSettingValues(): DataCubeSettingValues {
+  private getCurrentSettingValues() {
     const settingValues: DataCubeSettingValues = {};
     this.values.forEach((value, key) => {
       const configuration = this.configurations.get(key);
@@ -387,7 +426,33 @@ export class DataCubeSettings {
     return settingValues;
   }
 
-  save() {
+  updateValue(api: DataCubeAPI, key: string, value: DataCubeSettingValue) {
+    const configuration = this.configurations.get(key);
+    if (!configuration) {
+      this._logService.logWarning(
+        LogEvent.create(
+          DataCubeEvent.SETTINGS__FAILURE__FOUND_UNREGISTERED_SETTING,
+        ),
+        `Can't set value for unregistered setting '${key}'`,
+      );
+      return;
+    }
+
+    if (!this.setValue(key, value, [this.values, this.currentValues])) {
+      return;
+    }
+
+    // trigger hook
+    this._options?.onSettingsChanged?.({
+      api,
+      values: this.getCurrentSettingValues(),
+    });
+
+    // trigger action
+    configuration.action?.(api, value);
+  }
+
+  save(api: DataCubeAPI) {
     const changedSettingKeys = new Set<string>();
     this.values.forEach((value, key) => {
       if (value !== this.currentValues.get(key)) {
@@ -400,7 +465,10 @@ export class DataCubeSettings {
     this.currentValues.forEach((value, key) => this.values.set(key, value));
 
     // trigger hook
-    this.onSettingValuesChanged?.(this.getCurrentSettingValues());
+    this._options?.onSettingsChanged?.({
+      api,
+      values: this.getCurrentSettingValues(),
+    });
 
     // trigger action
     let requiresReload = false;
@@ -410,12 +478,12 @@ export class DataCubeSettings {
         requiresReload = true;
       }
       if (configuration?.action) {
-        configuration.action(this.values.get(key));
+        configuration.action(api, this.values.get(key));
       }
     }
 
     if (requiresReload) {
-      this.dataCube.reload();
+      api.reload();
     }
   }
 }

package/src/stores/services/DataCubeTaskService.ts

@@ -0,0 +1,102 @@
+/**
+ * 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 { uuid } from '@finos/legend-shared';
+import { action, computed, makeObservable, observable } from 'mobx';
+
+export class Task {
+  readonly uuid = uuid();
+  readonly name: string;
+  readonly startTime = Date.now();
+  readonly ownerId?: string | undefined;
+
+  endTime?: number | undefined;
+
+  constructor(name: string, ownerId?: string | undefined) {
+    this.name = name;
+    this.ownerId = ownerId;
+  }
+
+  end() {
+    this.endTime = Date.now();
+  }
+}
+
+export class TaskManager {
+  // TODO?: keep a hashmap, in parallel, for faster lookup
+  tasks: Task[] = [];
+
+  constructor() {
+    makeObservable(this, {
+      tasks: observable,
+      newTask: action,
+      endTask: action,
+      endTasks: action,
+    });
+  }
+
+  newTask(name: string, ownerId?: string | undefined) {
+    const task = new Task(name, ownerId);
+    this.tasks.push(task);
+    return task;
+  }
+
+  endTask(task: Task) {
+    const match = this.tasks.find((t) => t.uuid === task.uuid);
+    if (match) {
+      this.tasks = this.tasks.filter((t) => t.uuid !== task.uuid);
+      task.end();
+    }
+    return task;
+  }
+
+  endTasks(tasks: Task[]) {
+    this.tasks = this.tasks.filter(
+      (task) => !tasks.find((t) => t.uuid === task.uuid),
+    );
+    tasks.forEach((task) => task.end());
+  }
+}
+
+export class DataCubeTaskService {
+  readonly uuid = uuid();
+  readonly manager: TaskManager;
+
+  constructor(manager?: TaskManager | undefined) {
+    makeObservable(this, {
+      tasks: computed,
+    });
+
+    this.manager = manager ?? new TaskManager();
+  }
+
+  get tasks() {
+    return this.manager.tasks.filter((task) => task.ownerId === this.uuid);
+  }
+
+  newTask(name: string) {
+    return this.manager.newTask(name, this.uuid);
+  }
+
+  endTask(task: Task) {
+    return this.manager.endTask(task);
+  }
+
+  dispose() {
+    // remove all tasks owned by this service
+    this.manager.endTasks(this.tasks);
+  }
+}

package/src/stores/services/DataCubeTelemetryService.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { PlainObject } from '@finos/legend-shared';
+import type { DataCubeEngine } from '../core/DataCubeEngine.js';
+
+export class DataCubeTelemetryService {
+  private readonly _engine: DataCubeEngine;
+
+  constructor(engine: DataCubeEngine) {
+    this._engine = engine;
+  }
+
+  sendTelemetry(event: string, data: PlainObject) {
+    this._engine.sendTelemetry(event, data);
+  }
+}

package/src/stores/view/DataCubeInfoState.ts

@@ -16,9 +16,9 @@
 
 import { action, makeObservable, observable } from 'mobx';
 import type { DataCubeViewState } from './DataCubeViewState.js';
-import { DataCubeQuerySnapshotController } from './DataCubeQuerySnapshotManager.js';
+import { DataCubeQuerySnapshotController } from '../services/DataCubeQuerySnapshotService.js';
 import type { DataCubeQuerySnapshot } from '../core/DataCubeQuerySnapshot.js';
-import { DataCubeConfiguration } from '../core/models/DataCubeConfiguration.js';
+import { DataCubeConfiguration } from '../core/model/DataCubeConfiguration.js';
 
 /**
  * Unlike other query editor state, this state does not support making any
@@ -26,17 +26,21 @@ import { DataCubeConfiguration } from '../core/models/DataCubeConfiguration.js';
  * from the latest snapshot to help display latest static info about the query.
  */
 export class DataCubeInfoState extends DataCubeQuerySnapshotController {
+  private readonly _view: DataCubeViewState;
+
   name = '';
   // TODO: filter preview text
 
   constructor(view: DataCubeViewState) {
-    super(view);
+    super(view.engine, view.settingService, view.snapshotService);
 
     makeObservable(this, {
       name: observable,
 
       applySnapshot: action,
     });
+
+    this._view = view;
   }
 
   override getSnapshotSubscriberName() {
@@ -55,7 +59,11 @@ export class DataCubeInfoState extends DataCubeQuerySnapshotController {
     if (configuration.name !== this.name) {
       this.name = configuration.name;
       // TODO: make sure we only call this for the main view of data cube when we support multi views
-      this.view.dataCube.onNameChanged?.(this.name, this.view.source);
+      this._view.dataCube.options?.onNameChanged?.({
+        api: this._view.dataCube.api,
+        name: this.name,
+        source: this._view.source,
+      });
     }
 
     // TODO: filter preview text