@finos/legend-application-data-cube 0.1.6 → 0.1.8

package/src/stores/query-builder/LegendDataCubeQueryBuilderStore.tsx

@@ -0,0 +1,307 @@
+/**
+ * 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 { action, makeObservable, observable } from 'mobx';
+import type {
+  LegendDataCubeApplicationStore,
+  LegendDataCubeBaseStore,
+} from '../LegendDataCubeBaseStore.js';
+import {
+  type DataCubeAlertService,
+  type DataCubeAPI,
+  type DataCubeLayoutService,
+  type DataCubeTaskService,
+  DataCubeQuery,
+  DEFAULT_ALERT_WINDOW_CONFIG,
+  type DisplayState,
+} from '@finos/legend-data-cube';
+import { LegendDataCubeNewQueryState } from './LegendDataCubeNewQueryState.js';
+import {
+  PersistentDataCubeQuery,
+  type V1_EngineServerClient,
+  type V1_PureGraphManager,
+} from '@finos/legend-graph';
+import {
+  ActionState,
+  assertErrorThrown,
+  formatDate,
+  isString,
+  uuid,
+} from '@finos/legend-shared';
+import type { LegendDataCubeDataCubeEngine } from '../LegendDataCubeDataCubeEngine.js';
+import { LegendDataCubeQuerySaver } from '../../components/query-builder/LegendDataCubeQuerySaver.js';
+import { generateQueryBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
+import { LegendDataCubeQueryLoaderState } from './LegendDataCubeQueryLoaderState.js';
+import {
+  LegendDataCubeUserDataKey,
+  RECENTLY_VIEWED_QUERIES_LIMIT,
+} from '../../__lib__/LegendDataCubeUserData.js';
+import type { DepotServerClient } from '@finos/legend-server-depot';
+
+export class LegendDataCubeQueryBuilderState {
+  uuid = uuid();
+  startTime = Date.now();
+  query!: DataCubeQuery;
+  persistentQuery?: PersistentDataCubeQuery | undefined;
+  dataCube?: DataCubeAPI | undefined;
+
+  constructor(
+    query: DataCubeQuery,
+    persistentQuery?: PersistentDataCubeQuery | undefined,
+  ) {
+    makeObservable(this, {
+      dataCube: observable,
+      setDataCube: action,
+
+      query: observable,
+      persistentQuery: observable,
+      setPersistentQuery: action,
+    });
+
+    this.query = query;
+    this.persistentQuery = persistentQuery;
+  }
+
+  setDataCube(val: DataCubeAPI | undefined) {
+    this.dataCube = val;
+  }
+
+  setPersistentQuery(val: PersistentDataCubeQuery) {
+    this.persistentQuery = val;
+    this.query = DataCubeQuery.serialization.fromJson(val.content);
+    this.startTime = Date.now();
+  }
+}
+
+export class LegendDataCubeQueryBuilderStore {
+  readonly application: LegendDataCubeApplicationStore;
+  readonly baseStore: LegendDataCubeBaseStore;
+  readonly engine: LegendDataCubeDataCubeEngine;
+  readonly depotServerClient: DepotServerClient;
+  readonly engineServerClient: V1_EngineServerClient;
+  readonly graphManager: V1_PureGraphManager;
+  readonly taskService: DataCubeTaskService;
+  readonly layoutService: DataCubeLayoutService;
+  readonly alertService: DataCubeAlertService;
+
+  readonly newQueryState: LegendDataCubeNewQueryState;
+
+  readonly saveQueryState = ActionState.create();
+  readonly saverDisplay: DisplayState;
+
+  readonly loadQueryState = ActionState.create();
+  loader: LegendDataCubeQueryLoaderState;
+  builder?: LegendDataCubeQueryBuilderState | undefined;
+
+  constructor(baseStore: LegendDataCubeBaseStore) {
+    makeObservable(this, {
+      builder: observable,
+      setBuilder: action,
+    });
+
+    this.application = baseStore.application;
+    this.baseStore = baseStore;
+    this.engine = baseStore.engine;
+    this.depotServerClient = baseStore.depotServerClient;
+    this.engineServerClient = baseStore.engineServerClient;
+    this.graphManager = baseStore.graphManager;
+    this.taskService = baseStore.taskService;
+    this.alertService = baseStore.alertService;
+    this.layoutService = baseStore.layoutService;
+
+    this.newQueryState = new LegendDataCubeNewQueryState(this);
+    this.loader = new LegendDataCubeQueryLoaderState(this);
+    this.saverDisplay = this.layoutService.newDisplay(
+      'Save Query',
+      () => <LegendDataCubeQuerySaver />,
+      {
+        ...DEFAULT_ALERT_WINDOW_CONFIG,
+        height: 140,
+      },
+    );
+  }
+
+  setBuilder(val: LegendDataCubeQueryBuilderState | undefined) {
+    this.builder = val;
+  }
+
+  private updateWindowTitle(persistentQuery: PersistentDataCubeQuery) {
+    this.application.layoutService.setWindowTitle(
+      `\u229E ${persistentQuery.name}${this.builder ? ` - ${formatDate(new Date(this.builder.startTime), 'HH:mm:ss EEE MMM dd yyyy')}` : ''}`,
+    );
+  }
+
+  getRecentlyViewedQueries() {
+    const data = this.application.userDataService.getObjectValue(
+      LegendDataCubeUserDataKey.RECENTLY_VIEWED_QUERIES,
+    );
+    return data && Array.isArray(data) && data.every((id) => isString(id))
+      ? data
+      : [];
+  }
+
+  async loadQuery(queryId: string | undefined) {
+    if (queryId !== this.builder?.persistentQuery?.id) {
+      if (!queryId) {
+        this.setBuilder(undefined);
+        return;
+      }
+
+      this.loadQueryState.inProgress();
+
+      try {
+        const persistentQuery =
+          await this.baseStore.graphManager.getDataCubeQuery(queryId);
+        const query = DataCubeQuery.serialization.fromJson(
+          persistentQuery.content,
+        );
+        this.setBuilder(
+          new LegendDataCubeQueryBuilderState(query, persistentQuery),
+        );
+        this.updateWindowTitle(persistentQuery);
+
+        // update the list of stack of recently viewed queries
+        const recentlyViewedQueries = this.getRecentlyViewedQueries();
+        const idx = recentlyViewedQueries.findIndex((data) => data === queryId);
+        if (idx === -1) {
+          if (recentlyViewedQueries.length >= RECENTLY_VIEWED_QUERIES_LIMIT) {
+            recentlyViewedQueries.pop();
+          }
+          recentlyViewedQueries.unshift(queryId);
+        } else {
+          recentlyViewedQueries.splice(idx, 1);
+          recentlyViewedQueries.unshift(queryId);
+        }
+        this.application.userDataService.persistValue(
+          LegendDataCubeUserDataKey.RECENTLY_VIEWED_QUERIES,
+          recentlyViewedQueries,
+        );
+
+        this.loadQueryState.pass();
+      } catch (error) {
+        assertErrorThrown(error);
+        this.alertService.alertError(error, {
+          message: `Query Load Failure: ${error.message}`,
+        });
+        this.loadQueryState.fail();
+      }
+    }
+  }
+
+  private async generatePersistentQuery(
+    api: DataCubeAPI,
+    name: string,
+    existingPersistentQuery?: PersistentDataCubeQuery | undefined,
+  ) {
+    const query = await api.generateDataCubeQuery();
+    let persistentQuery: PersistentDataCubeQuery;
+    if (existingPersistentQuery) {
+      persistentQuery = existingPersistentQuery.clone();
+    } else {
+      persistentQuery = new PersistentDataCubeQuery();
+      persistentQuery.id = uuid();
+    }
+    persistentQuery.name = name;
+    persistentQuery.content = DataCubeQuery.serialization.toJson(query);
+    return persistentQuery;
+  }
+
+  async createQuery(name: string) {
+    if (!this.builder?.dataCube || this.saveQueryState.isInProgress) {
+      return;
+    }
+
+    this.saveQueryState.inProgress();
+    try {
+      const persistentQuery = await this.generatePersistentQuery(
+        this.builder.dataCube,
+        name,
+      );
+
+      const newQuery =
+        await this.baseStore.graphManager.createDataCubeQuery(persistentQuery);
+      // NOTE: reload is the cleanest, least bug-prone handling here
+      // but we can opt for just updating the URL to reflect the new query
+      // as an optimization. Also, it helps preserve the edition history
+      // on the existing data-cube.
+      //
+      // 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.application.navigationService.navigator.updateCurrentLocation(
+        generateQueryBuilderRoute(newQuery.id),
+      );
+      this.builder.setPersistentQuery(persistentQuery);
+      this.updateWindowTitle(persistentQuery);
+
+      this.saverDisplay.close();
+      this.saveQueryState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.alertService.alertError(error, {
+        message: `Query Creation Failure: ${error.message}`,
+      });
+      this.saveQueryState.fail();
+    }
+  }
+
+  async saveQuery(name: string, saveAsNewQuery: boolean) {
+    if (!this.builder?.dataCube || this.saveQueryState.isInProgress) {
+      return;
+    }
+
+    this.saveQueryState.inProgress();
+    try {
+      const persistentQuery = await this.generatePersistentQuery(
+        this.builder.dataCube,
+        name,
+        this.builder.persistentQuery,
+      );
+
+      if (saveAsNewQuery) {
+        persistentQuery.id = uuid();
+        const newQuery =
+          await this.baseStore.graphManager.createDataCubeQuery(
+            persistentQuery,
+          );
+        // NOTE: reload is the cleanest, least bug-prone handling here
+        // but we can opt for just updating the URL to reflect the new query
+        // as an optimization. Also, it helps preserve the edition history
+        // on the existing data-cube.
+        //
+        // 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.application.navigationService.navigator.updateCurrentLocation(
+          generateQueryBuilderRoute(newQuery.id),
+        );
+      } else {
+        await this.baseStore.graphManager.updateDataCubeQuery(persistentQuery);
+      }
+      this.builder.setPersistentQuery(persistentQuery);
+      this.updateWindowTitle(persistentQuery);
+
+      this.saverDisplay.close();
+      this.saveQueryState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this.alertService.alertError(error, {
+        message: `Query Update Failure: ${error.message}`,
+      });
+      this.saveQueryState.fail();
+    }
+  }
+}

package/src/stores/query-builder/LegendDataCubeQueryLoaderState.tsx

@@ -0,0 +1,260 @@
+/**
+ * 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 {
+  APPLICATION_EVENT,
+  DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH,
+  type GenericLegendApplicationStore,
+} from '@finos/legend-application';
+import {
+  type LightPersistentDataCubeQuery,
+  QuerySearchSpecification,
+  QuerySearchSortBy,
+  type V1_PureGraphManager,
+} from '@finos/legend-graph';
+import { ActionState, assertErrorThrown, LogEvent } from '@finos/legend-shared';
+import { makeObservable, observable, action } from 'mobx';
+import type { LegendDataCubeQueryBuilderStore } from './LegendDataCubeQueryBuilderStore.js';
+import { LegendDataCubeUserDataKey } from '../../__lib__/LegendDataCubeUserData.js';
+import {
+  type DataCubeAlertService,
+  DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
+  type DisplayState,
+} from '@finos/legend-data-cube';
+import { LegendDataCubeQueryLoader } from '../../components/query-builder/LegendDataCubeQueryLoader.js';
+import { generateQueryBuilderRoute } from '../../__lib__/LegendDataCubeNavigation.js';
+
+export const DATA_CUBE_QUERY_LOADER_TYPEAHEAD_SEARCH_LIMIT = 50;
+export const DATA_CUBE_QUERY_LOADER_DEFAULT_QUERY_SEARCH_LIMIT = 10;
+
+export enum DataCubeQuerySortByType {
+  LAST_CREATED = 'Last Created',
+  LAST_VIEWED = 'Last Viewed',
+  LAST_UPDATED = 'Last Updated',
+}
+
+export class LegendDataCubeQueryLoaderState {
+  private readonly _application: GenericLegendApplicationStore;
+  private readonly _store: LegendDataCubeQueryBuilderStore;
+  private readonly _graphManager: V1_PureGraphManager;
+  private readonly _alertService: DataCubeAlertService;
+
+  readonly display: DisplayState;
+  readonly searchState = ActionState.create();
+  readonly finalizeState = ActionState.create();
+
+  queries: LightPersistentDataCubeQuery[] = [];
+  selectedQuery?: LightPersistentDataCubeQuery | undefined;
+
+  searchText = '';
+  showCurrentUserQueriesOnly = false;
+  showingDefaultQueries = true;
+  sortBy = DataCubeQuerySortByType.LAST_VIEWED;
+
+  constructor(store: LegendDataCubeQueryBuilderStore) {
+    makeObservable(this, {
+      showingDefaultQueries: observable,
+      setShowingDefaultQueries: action,
+
+      searchText: observable,
+      setSearchText: action,
+
+      queries: observable,
+      setQueries: action,
+
+      showCurrentUserQueriesOnly: observable,
+      setShowCurrentUserQueriesOnly: action,
+
+      sortBy: observable,
+      setSortBy: action,
+
+      selectedQuery: observable,
+      setSelectedQuery: action,
+    });
+
+    this._application = store.application;
+    this._store = store;
+    this._graphManager = store.graphManager;
+    this._alertService = store.alertService;
+
+    this.display = store.layoutService.newDisplay(
+      'Load Query',
+      () => <LegendDataCubeQueryLoader />,
+      {
+        ...DEFAULT_TOOL_PANEL_WINDOW_CONFIG,
+        width: 500,
+        minWidth: 500,
+      },
+    );
+  }
+
+  setSearchText(val: string) {
+    this.searchText = val;
+  }
+
+  setQueries(val: LightPersistentDataCubeQuery[]) {
+    this.queries = val;
+  }
+
+  setShowingDefaultQueries(val: boolean) {
+    this.showingDefaultQueries = val;
+  }
+
+  setShowCurrentUserQueriesOnly(val: boolean): void {
+    this.showCurrentUserQueriesOnly = val;
+  }
+
+  setSortBy(val: DataCubeQuerySortByType) {
+    this.sortBy = val;
+  }
+
+  private getQuerySearchSortBy(sortByValue: string) {
+    switch (sortByValue) {
+      case DataCubeQuerySortByType.LAST_CREATED:
+        return QuerySearchSortBy.SORT_BY_CREATE;
+      case DataCubeQuerySortByType.LAST_UPDATED:
+        return QuerySearchSortBy.SORT_BY_UPDATE;
+      case DataCubeQuerySortByType.LAST_VIEWED:
+        return QuerySearchSortBy.SORT_BY_VIEW;
+      default:
+        return undefined;
+    }
+  }
+
+  setSelectedQuery(query: LightPersistentDataCubeQuery | undefined) {
+    this.selectedQuery = query;
+  }
+
+  canPerformAdvancedSearch(searchText: string) {
+    return !(
+      searchText.length < DEFAULT_TYPEAHEAD_SEARCH_MINIMUM_SEARCH_LENGTH &&
+      !this.showCurrentUserQueriesOnly
+    );
+  }
+
+  async searchQueries(searchText: string) {
+    // for the initial search, i.e. no search config is specified, fetch the default queries if possible
+    if (!this.canPerformAdvancedSearch(searchText)) {
+      if (!searchText) {
+        this.setShowingDefaultQueries(true);
+        this.searchState.inProgress();
+        this.setQueries([]);
+        let defaultQueries: LightPersistentDataCubeQuery[] = [];
+        try {
+          // first, try to fetch recently viewed queries
+          try {
+            const recentlyViewedQueryIDs =
+              this._store.getRecentlyViewedQueries();
+            if (recentlyViewedQueryIDs.length) {
+              defaultQueries = await this._graphManager.getDataCubeQueries(
+                recentlyViewedQueryIDs,
+              );
+            }
+          } catch (error) {
+            assertErrorThrown(error);
+            // if there's an error fetching recently viewed queries, most likely because
+            // some queries have been removed, just remove them all from the cached user data
+            this._application.userDataService.persistValue(
+              LegendDataCubeUserDataKey.RECENTLY_VIEWED_QUERIES,
+              undefined,
+            );
+          }
+          // if there's no recently viewed queries, just fetch queries of the current user
+          if (!defaultQueries.length) {
+            const searchSpecification = new QuerySearchSpecification();
+            searchSpecification.limit =
+              DATA_CUBE_QUERY_LOADER_DEFAULT_QUERY_SEARCH_LIMIT;
+            searchSpecification.showCurrentUserQueriesOnly = true;
+            defaultQueries =
+              await this._graphManager.searchDataCubeQueries(
+                searchSpecification,
+              );
+          }
+          this.setQueries(defaultQueries);
+          this.searchState.pass();
+        } catch (error) {
+          assertErrorThrown(error);
+          this._application.logService.error(
+            LogEvent.create(APPLICATION_EVENT.GENERIC_FAILURE),
+            error,
+          );
+          this.searchState.fail();
+        }
+      }
+      return;
+    }
+
+    this.setShowingDefaultQueries(false);
+    this.searchState.inProgress();
+
+    try {
+      const searchSpecification =
+        QuerySearchSpecification.createDefault(searchText);
+      searchSpecification.limit =
+        DATA_CUBE_QUERY_LOADER_TYPEAHEAD_SEARCH_LIMIT + 1;
+      searchSpecification.showCurrentUserQueriesOnly =
+        this.showCurrentUserQueriesOnly;
+      const querySearchSortBy = this.getQuerySearchSortBy(this.sortBy);
+      if (querySearchSortBy) {
+        searchSpecification.sortByOption = querySearchSortBy;
+      }
+      this.setQueries(
+        await this._graphManager.searchDataCubeQueries(searchSpecification),
+      );
+
+      // if sorting is not configured, sort by name
+      if (!querySearchSortBy) {
+        this.setQueries(
+          this.queries.toSorted((a, b) => a.name.localeCompare(b.name)),
+        );
+      }
+
+      this.searchState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this._alertService.alertError(error, {
+        message: `Query Search Failure: ${error.message}`,
+      });
+      this.searchState.fail();
+    }
+  }
+
+  async finalize() {
+    if (!this.selectedQuery) {
+      return;
+    }
+
+    this.finalizeState.inProgress();
+    try {
+      // just simply change the route here and the new query ID will get picked up
+      // and handled by the query builder to load the new query.
+      this._application.navigationService.navigator.updateCurrentLocation(
+        generateQueryBuilderRoute(this.selectedQuery.id),
+      );
+
+      // reset
+      this.setSelectedQuery(undefined);
+      this.display.close();
+      this.finalizeState.pass();
+    } catch (error) {
+      assertErrorThrown(error);
+      this._alertService.alertError(error, {
+        message: `Query Load Failure: ${error.message}`,
+      });
+      this.finalizeState.fail();
+    }
+  }
+}

package/src/stores/{source/LegendCubeViewer.ts → query-builder/source-builder/AdhocQueryDataCubeSourceBuilderState.ts}

@@ -14,15 +14,22 @@
  * limitations under the License.
  */
 
-import type { DataCubeEngine } from '@finos/legend-data-cube';
-import type { DataCubeGenericSource } from '../model/DataCubeGenericSource.js';
+import { type PlainObject } from '@finos/legend-shared';
+import {
+  LegendDataCubeSourceBuilderState,
+  LegendDataCubeSourceBuilderType,
+} from './LegendDataCubeSourceBuilderState.js';
 
-export class LegendCubeViewer {
-  source: DataCubeGenericSource;
-  engine: DataCubeEngine;
+export class AdhocQueryDataCubeSourceBuilderState extends LegendDataCubeSourceBuilderState {
+  override get label(): LegendDataCubeSourceBuilderType {
+    return LegendDataCubeSourceBuilderType.ADHOC_QUERY;
+  }
+
+  override get isValid(): boolean {
+    return false;
+  }
 
-  constructor(source: DataCubeGenericSource, engine: DataCubeEngine) {
-    this.source = source;
-    this.engine = engine;
+  override build(): Promise<PlainObject> {
+    throw new Error('Method not implemented.');
   }
 }

package/src/stores/query-builder/source-builder/LegendDataCubeSourceBuilderState.ts

@@ -0,0 +1,43 @@
+/**
+ * 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, type PlainObject } from '@finos/legend-shared';
+import type { LegendDataCubeApplicationStore } from '../../LegendDataCubeBaseStore.js';
+import type { LegendDataCubeDataCubeEngine } from '../../LegendDataCubeDataCubeEngine.js';
+
+export enum LegendDataCubeSourceBuilderType {
+  LEGEND_QUERY = 'Legend Query',
+  ADHOC_QUERY = 'Ad hoc Query',
+}
+
+export abstract class LegendDataCubeSourceBuilderState {
+  protected readonly _application: LegendDataCubeApplicationStore;
+  protected readonly _engine: LegendDataCubeDataCubeEngine;
+
+  readonly buildState = ActionState.create();
+
+  constructor(
+    application: LegendDataCubeApplicationStore,
+    engine: LegendDataCubeDataCubeEngine,
+  ) {
+    this._application = application;
+    this._engine = engine;
+  }
+
+  abstract get label(): LegendDataCubeSourceBuilderType;
+  abstract get isValid(): boolean;
+  abstract build(): Promise<PlainObject>;
+}