@finos/legend-application-data-cube 0.3.2 → 0.3.3

package/src/stores/builder/LegendDataCubeBuilderStore.tsx

@@ -41,6 +41,7 @@ import {
   ActionState,
   assertErrorThrown,
   formatDate,
+  guaranteeNonNullable,
   isString,
   uuid,
 } from '@finos/legend-shared';
@@ -58,7 +59,10 @@ import {
 import type { DepotServerClient } from '@finos/legend-server-depot';
 import { LegendDataCubeBlockingWindowState } from '../../components/LegendDataCubeBlockingWindow.js';
 import { LegendDataCubeDeleteConfirmation } from '../../components/builder/LegendDataCubeDeleteConfirmation.js';
-import { LegendDataCubeAbout } from '../../components/builder/LegendDataCubeBuilder.js';
+import {
+  LegendDataCubeAbout,
+  LegendDataCubeReleaseLogManager,
+} from '../../components/builder/LegendDataCubeBuilder.js';
 import { LegendDataCubeSourceViewer } from '../../components/builder/LegendDataCubeSourceViewer.js';
 
 export class LegendDataCubeBuilderState {
@@ -121,6 +125,8 @@ export class LegendDataCubeBuilderStore {
 
   readonly initializeState = ActionState.create();
   readonly aboutDisplay: DisplayState;
+  readonly releaseLogDisplay: DisplayState;
+  readonly releaseNotesDisplay: DisplayState;
 
   readonly creator: LegendDataCubeCreatorState;
 
@@ -169,6 +175,23 @@ export class LegendDataCubeBuilderStore {
       },
     );
 
+    this.releaseLogDisplay = this.layoutService.newDisplay(
+      'Release Log',
+      () => <LegendDataCubeReleaseLogManager showOnlyLatestNotes={false} />,
+      {
+        ...DEFAULT_ALERT_WINDOW_CONFIG,
+        height: 500,
+      },
+    );
+    this.releaseNotesDisplay = this.layoutService.newDisplay(
+      'Release Notes',
+      () => <LegendDataCubeReleaseLogManager showOnlyLatestNotes={true} />,
+      {
+        ...DEFAULT_ALERT_WINDOW_CONFIG,
+        height: 350,
+      },
+    );
+
     this.creator = new LegendDataCubeCreatorState(this);
     this.loader = new LegendDataCubeLoaderState(this);
     this.saverDisplay = new LegendDataCubeBlockingWindowState(
@@ -253,6 +276,38 @@ export class LegendDataCubeBuilderStore {
     }
   }
 
+  loadPartialSourceDataCube() {
+    if (!this.loader.isPartialSourceResolved()) {
+      this.application.navigationService.navigator.updateCurrentLocation(
+        generateBuilderRoute(null),
+      );
+    }
+    try {
+      const persistentDataCube = guaranteeNonNullable(
+        this.loader.getPersistentDataCube(),
+      );
+      const dataCubeId = persistentDataCube.id;
+      const specification = DataCubeSpecification.serialization.fromJson(
+        persistentDataCube.content,
+      );
+      specification.source = guaranteeNonNullable(
+        this.loader.getResolvedSource(),
+      );
+      this.postLoad(specification, persistentDataCube, dataCubeId);
+      this.loadState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.alertService.alertError(error, {
+        message: `DataCube Load Failure: ${error.message}`,
+      });
+      this.application.navigationService.navigator.updateCurrentLocation(
+        generateBuilderRoute(null),
+      );
+      this.loadState.fail();
+      throw error;
+    }
+  }
+
   async loadDataCube(dataCubeId: string | undefined) {
     // internalize the parameters and clean them from the URL
     const sourceData =
@@ -295,31 +350,16 @@ export class LegendDataCubeBuilderStore {
         const specification = DataCubeSpecification.serialization.fromJson(
           persistentDataCube.content,
         );
-        this.setBuilder(
-          new LegendDataCubeBuilderState(specification, persistentDataCube),
-        );
-        this.updateWindowTitle(persistentDataCube);
 
-        // update the list of stack of recently viewed DataCubes
-        const recentlyViewedDataCubes = this.getRecentlyViewedDataCubes();
-        const idx = recentlyViewedDataCubes.findIndex(
-          (data) => data === dataCubeId,
-        );
-        if (idx === -1) {
-          if (
-            recentlyViewedDataCubes.length >= RECENTLY_VIEWED_DATA_CUBES_LIMIT
-          ) {
-            recentlyViewedDataCubes.pop();
-          }
-          recentlyViewedDataCubes.unshift(dataCubeId);
-        } else {
-          recentlyViewedDataCubes.splice(idx, 1);
-          recentlyViewedDataCubes.unshift(dataCubeId);
+        if (this.loader.isPartialSource(specification.source)) {
+          this.loader.resolvePartialSource(
+            specification.source,
+            persistentDataCube,
+          );
+          return;
         }
-        this.application.userDataService.persistValue(
-          LegendDataCubeUserDataKey.RECENTLY_VIEWED_DATA_CUBES,
-          recentlyViewedDataCubes,
-        );
+
+        this.postLoad(specification, persistentDataCube, dataCubeId);
 
         this.loadState.pass();
       } catch (error) {
@@ -336,6 +376,36 @@ export class LegendDataCubeBuilderStore {
     }
   }
 
+  private postLoad(
+    specification: DataCubeSpecification,
+    persistentDataCube: PersistentDataCube,
+    dataCubeId: string,
+  ) {
+    this.setBuilder(
+      new LegendDataCubeBuilderState(specification, persistentDataCube),
+    );
+    this.updateWindowTitle(persistentDataCube);
+
+    // update the list of stack of recently viewed DataCubes
+    const recentlyViewedDataCubes = this.getRecentlyViewedDataCubes();
+    const idx = recentlyViewedDataCubes.findIndex(
+      (data) => data === dataCubeId,
+    );
+    if (idx === -1) {
+      if (recentlyViewedDataCubes.length >= RECENTLY_VIEWED_DATA_CUBES_LIMIT) {
+        recentlyViewedDataCubes.pop();
+      }
+      recentlyViewedDataCubes.unshift(dataCubeId);
+    } else {
+      recentlyViewedDataCubes.splice(idx, 1);
+      recentlyViewedDataCubes.unshift(dataCubeId);
+    }
+    this.application.userDataService.persistValue(
+      LegendDataCubeUserDataKey.RECENTLY_VIEWED_DATA_CUBES,
+      recentlyViewedDataCubes,
+    );
+  }
+
   private async generatePersistentDataCube(
     api: DataCubeAPI,
     name: string,
@@ -391,6 +461,7 @@ export class LegendDataCubeBuilderStore {
       // Another way to avoid reloading the whole app it to force update
       // the <DataCube/> component using the key prop that ties to an ID
       // of the builder.
+      this.builder.setPersistentDataCube(newPersistentDataCube);
       this.application.navigationService.navigator.updateCurrentLocation(
         generateBuilderRoute(newPersistentDataCube.id),
       );
@@ -439,6 +510,7 @@ export class LegendDataCubeBuilderStore {
         // Another way to avoid reloading the whole app it to force update
         // the <DataCube/> component using the key prop that ties to an ID
         // of the builder.
+        this.builder.setPersistentDataCube(newPersistentDataCube);
         this.application.navigationService.navigator.updateCurrentLocation(
           generateBuilderRoute(newPersistentDataCube.id),
         );

package/src/stores/builder/LegendDataCubeLoaderState.tsx

@@ -24,8 +24,14 @@ import {
   QuerySearchSpecification,
   QuerySearchSortBy,
   type V1_PureGraphManager,
+  type PersistentDataCube,
 } from '@finos/legend-graph';
-import { ActionState, assertErrorThrown, LogEvent } from '@finos/legend-shared';
+import {
+  ActionState,
+  assertErrorThrown,
+  LogEvent,
+  type PlainObject,
+} from '@finos/legend-shared';
 import { makeObservable, observable, action } from 'mobx';
 import type { LegendDataCubeBuilderStore } from './LegendDataCubeBuilderStore.js';
 import { LegendDataCubeUserDataKey } from '../../__lib__/LegendDataCubeUserData.js';
@@ -36,6 +42,9 @@ import {
 } from '@finos/legend-data-cube';
 import { LegendDataCubeLoader } from '../../components/builder/LegendDataCubeLoader.js';
 import { generateBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
+import { LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE } from '../model/LocalFileDataCubeSource.js';
+import { LegendDataCubeSourceLoaderState } from './LegendDataCubeSourceLoaderState.js';
+import type { LegendDataCubeBlockingWindowState } from '../../components/LegendDataCubeBlockingWindow.js';
 
 export const DATA_CUBE_LOADER_TYPEAHEAD_SEARCH_LIMIT = 50;
 export const DATA_CUBE_LOADER_DEFAULT_SEARCH_LIMIT = 10;
@@ -64,6 +73,9 @@ export class LegendDataCubeLoaderState {
   showingDefaultResults = true;
   sortBy = DataCubeSortByType.LAST_VIEWED;
 
+  readonly sourceLoader: LegendDataCubeSourceLoaderState;
+  readonly sourceLoaderDisplay: LegendDataCubeBlockingWindowState;
+
   constructor(store: LegendDataCubeBuilderStore) {
     makeObservable(this, {
       showingDefaultResults: observable,
@@ -89,6 +101,7 @@ export class LegendDataCubeLoaderState {
     this._store = store;
     this._graphManager = store.graphManager;
     this._alertService = store.alertService;
+    this.sourceLoader = new LegendDataCubeSourceLoaderState(store);
 
     this.display = store.layoutService.newDisplay(
       'Load DataCube',
@@ -99,6 +112,7 @@ export class LegendDataCubeLoaderState {
         minWidth: 500,
       },
     );
+    this.sourceLoaderDisplay = this.sourceLoader.display;
   }
 
   setSearchText(val: string) {
@@ -145,6 +159,35 @@ export class LegendDataCubeLoaderState {
     );
   }
 
+  isPartialSource(source: PlainObject): boolean {
+    const type = source._type as string;
+    if (type === LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE) {
+      this.sourceLoader.setPartialSourceResolved(false);
+      return true;
+    }
+    return false;
+  }
+
+  isPartialSourceResolved() {
+    return this.sourceLoader.partialSourceResolved;
+  }
+
+  getResolvedSource() {
+    return this.sourceLoader.source;
+  }
+
+  getPersistentDataCube() {
+    return this.sourceLoader.persistentDataCube;
+  }
+
+  resolvePartialSource(
+    partialSource: PlainObject,
+    persistentDataCube: PersistentDataCube | undefined,
+  ) {
+    this.sourceLoader.initialize(partialSource, persistentDataCube);
+    this.sourceLoaderDisplay.open();
+  }
+
   async searchDataCubes(searchText: string) {
     // for the initial search, i.e. no search config is specified, fetch the default entries if possible
     if (!this.canPerformAdvancedSearch(searchText)) {

package/src/stores/builder/LegendDataCubeSourceLoaderState.tsx

@@ -0,0 +1,145 @@
+/**
+ * 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 {
+  ActionState,
+  assertErrorThrown,
+  guaranteeNonNullable,
+  UnsupportedOperationError,
+  type PlainObject,
+} from '@finos/legend-shared';
+import { makeObservable, observable, action } from 'mobx';
+import type { LegendDataCubeBuilderStore } from './LegendDataCubeBuilderStore.js';
+import {
+  DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
+  type DataCubeAlertService,
+} from '@finos/legend-data-cube';
+import { LegendDataCubePartialSourceLoader } from '../../components/builder/LegendDataCubePartialSourceLoader.js';
+import type { LegendDataCubeDataCubeEngine } from '../LegendDataCubeDataCubeEngine.js';
+import type { LegendDataCubeApplicationStore } from '../LegendDataCubeBaseStore.js';
+import type { LegendDataCubePartialSourceLoaderState } from './source/loader/LegendDataCubePartialSourceLoaderState.js';
+import { LocalFileDataCubePartialSourceLoaderState } from './source/loader/LocalFileDataCubePartialSourceLoaderState.js';
+import { LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE } from '../model/LocalFileDataCubeSource.js';
+import { LegendDataCubeBlockingWindowState } from '../../components/LegendDataCubeBlockingWindow.js';
+import type { PersistentDataCube } from '@finos/legend-graph';
+
+export enum LegendDataCubeSourceLoaderType {
+  LOCAL_FILE = 'Local File',
+}
+
+export class LegendDataCubeSourceLoaderState {
+  private readonly _application: LegendDataCubeApplicationStore;
+  private readonly _engine: LegendDataCubeDataCubeEngine;
+  private readonly _alertService: DataCubeAlertService;
+
+  source: PlainObject | undefined;
+  persistentDataCube: PersistentDataCube | undefined;
+
+  readonly display: LegendDataCubeBlockingWindowState;
+  readonly searchState = ActionState.create();
+  readonly finalizeState = ActionState.create();
+
+  partialSourceLoader: LegendDataCubePartialSourceLoaderState;
+
+  partialSourceResolved = false;
+
+  constructor(store: LegendDataCubeBuilderStore) {
+    makeObservable(this, {
+      source: observable,
+      setSource: action,
+
+      partialSourceResolved: observable,
+      setPartialSourceResolved: action,
+    });
+
+    this._application = store.application;
+    this._engine = store.engine;
+    this._alertService = store.alertService;
+    this.partialSourceLoader = this.createSourceLoader(
+      LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE,
+    );
+
+    this.display = new LegendDataCubeBlockingWindowState(
+      'Load DataCube',
+      () => <LegendDataCubePartialSourceLoader />,
+      {
+        ...DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
+        width: 500,
+        minWidth: 500,
+      },
+      () => {
+        store.loader.sourceLoaderDisplay.close();
+        store.loadPartialSourceDataCube();
+      },
+    );
+  }
+
+  initialize(
+    source: PlainObject,
+    persistentDataCube: PersistentDataCube | undefined,
+  ) {
+    this.setSource(source);
+    this.setPersistentDataCube(persistentDataCube);
+  }
+
+  setSource(source: PlainObject) {
+    this.source = source;
+  }
+
+  setPersistentDataCube(persistentDataCube: PersistentDataCube | undefined) {
+    this.persistentDataCube = guaranteeNonNullable(persistentDataCube);
+  }
+
+  setPartialSourceResolved(sourceResolved: boolean) {
+    this.partialSourceResolved = sourceResolved;
+  }
+
+  changeSourceLoader(type: string): void {
+    this.partialSourceLoader = this.createSourceLoader(type);
+  }
+
+  private createSourceLoader(
+    type: string,
+  ): LegendDataCubePartialSourceLoaderState {
+    // We can add more partial sources
+    switch (type) {
+      case LOCAL_FILE_QUERY_DATA_CUBE_SOURCE_TYPE:
+        return new LocalFileDataCubePartialSourceLoaderState(
+          this._application,
+          this._engine,
+        );
+      default:
+        throw new UnsupportedOperationError(
+          `Can't create source loader for unsupported type '${type}'`,
+        );
+    }
+  }
+
+  async finalize() {
+    try {
+      this.finalizeState.inProgress();
+      this.setSource(await this.partialSourceLoader.load(this.source));
+      this.display.close();
+      this.finalizeState.pass();
+      this.setPartialSourceResolved(true);
+    } catch (error) {
+      assertErrorThrown(error);
+      this._alertService.alertError(error, {
+        message: `DataCube Source Load Failure: ${error.message}`,
+      });
+      this.finalizeState.fail();
+    }
+  }
+}

package/src/stores/builder/source/LocalFileDataCubeSourceBuilderState.ts

@@ -17,7 +17,7 @@
 import {
   ActionState,
   csvStringify,
-  guaranteeType,
+  guaranteeNonNullable,
   IllegalStateError,
   parseCSVFile,
   type PlainObject,
@@ -30,7 +30,6 @@ import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseSto
 import { action, makeObservable, observable } from 'mobx';
 import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
 import {
-  LocalFileDataCubeSource,
   LocalFileDataCubeSourceFormat,
   RawLocalFileQueryDataCubeSource,
 } from '../../model/LocalFileDataCubeSource.js';
@@ -39,7 +38,7 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
   readonly processState = ActionState.create();
 
   fileName?: string | undefined;
-  fileFormat?: string | undefined;
+  fileFormat?: LocalFileDataCubeSourceFormat | undefined;
   // NOTE: type string is suitable for CSV/Excel, etc. but will not be appropriate
   // for other format that we want to support, e.g. arrow/parquet
   fileData?: string | undefined;
@@ -74,7 +73,7 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
     this.fileName = fileName;
   }
 
-  setFileFormat(format: string | undefined) {
+  setFileFormat(format: LocalFileDataCubeSourceFormat | undefined) {
     this.fileFormat = format;
   }
 
@@ -114,7 +113,7 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
               csvStringify(result.data, { escapeChar: `'`, quoteChar: `'` }),
             );
             this.setFileName(fileName);
-            this.setFileFormat(fileFormat);
+            this.setFileFormat(LocalFileDataCubeSourceFormat.CSV);
             this.setRowCount(result.data.length);
             this.setPreviewText(
               csvStringify(result.data.slice(0, 100), {
@@ -160,19 +159,15 @@ export class LocalFileDataCubeSourceBuilderState extends LegendDataCubeSourceBui
       );
     }
 
-    const source = guaranteeType(
+    const tableDetails = guaranteeNonNullable(
       await this._engine.ingestLocalFileData(this.fileData, this.fileFormat),
-      LocalFileDataCubeSource,
-      `Can't generate data source`,
+      `Can't generate source data: failed to ingest data from local file`,
     );
     const rawSource = new RawLocalFileQueryDataCubeSource();
-    rawSource.count = this.rowCount;
     rawSource.fileName = this.fileName;
-    rawSource.db = source.db;
-    rawSource.model = source.model;
-    rawSource.schema = source.schema;
-    rawSource.table = source.table;
-    rawSource.runtime = source.runtime;
+    rawSource.fileFormat = this.fileFormat;
+    rawSource._ref = tableDetails.dbReference;
+    rawSource.columnNames = tableDetails.columnNames;
 
     return RawLocalFileQueryDataCubeSource.serialization.toJson(rawSource);
   }

package/src/stores/builder/source/loader/LegendDataCubePartialSourceLoaderState.ts

@@ -0,0 +1,41 @@
+/**
+ * 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 { LegendDataCubeApplicationStore } from '../../../LegendDataCubeBaseStore.js';
+import type { LegendDataCubeDataCubeEngine } from '../../../LegendDataCubeDataCubeEngine.js';
+import type { LegendDataCubeSourceLoaderType } from '../../LegendDataCubeSourceLoaderState.js';
+
+export abstract class LegendDataCubePartialSourceLoaderState {
+  protected readonly _application: LegendDataCubeApplicationStore;
+  protected readonly _engine: LegendDataCubeDataCubeEngine;
+
+  constructor(
+    application: LegendDataCubeApplicationStore,
+    engine: LegendDataCubeDataCubeEngine,
+  ) {
+    this._application = application;
+    this._engine = engine;
+  }
+
+  abstract initialize(): void;
+
+  abstract get label(): LegendDataCubeSourceLoaderType;
+
+  abstract get isValid(): boolean;
+
+  abstract load(source: PlainObject | undefined): Promise<PlainObject>;
+}