@finos/legend-application-query 13.4.15 → 13.4.17

package/src/__lib__/LegendQueryUserDataHelper.ts

@@ -16,22 +16,38 @@
 
 import type { UserDataService } from '@finos/legend-application';
 import { returnUndefOnError } from '@finos/legend-shared';
-import { createSimpleSchema, deserialize, list, primitive } from 'serializr';
+import {
+  createSimpleSchema,
+  deserialize,
+  list,
+  primitive,
+  raw,
+} from 'serializr';
+import {
+  createVisitedDataspaceFromInfo,
+  createIdFromDataSpaceInfo,
+  createVisitedDataSpaceId,
+  type SavedVisitedDataSpaces,
+  type VisitedDataspace,
+} from './LegendQueryUserDataSpaceHelper.js';
+import type { DataSpaceInfo } from '@finos/legend-extension-dsl-data-space/application';
 
 export enum LEGEND_QUERY_USER_DATA_KEY {
   RECENTLY_VIEWED_QUERIES = 'query-editor.recent-queries',
+  RECENTLY_VIEWED_DATASPACES = 'query-editor.recent-dataSpaces',
 }
 
-const USER_DATA_RECENTLY_VIEWED_QUERIES_LIMIT = 10;
-type RecentlyViewedQueriesData = string[];
+export const USER_DATA_RECENTLY_VIEWED_QUERIES_LIMIT = 10;
+export const USER_DATA_QUERY_DATASPACE_LIMIT = 10;
+
+type SavedData = string[];
 
 export class LegendQueryUserDataHelper {
-  static getRecentlyViewedQueries(
+  static getPersistedData(
     service: UserDataService,
-  ): RecentlyViewedQueriesData {
-    const data = service.getObjectValue(
-      LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_QUERIES,
-    );
+    key: LEGEND_QUERY_USER_DATA_KEY,
+  ): SavedData {
+    const data = service.getObjectValue(key);
     return (
       // TODO: think of a better way to deserialize this data, maybe like settings, use JSON schema
       // See https://github.com/finos/legend-studio/issues/407
@@ -45,12 +61,41 @@ export class LegendQueryUserDataHelper {
               {
                 data,
               },
-            ) as { data: RecentlyViewedQueriesData }
+            ) as { data: SavedData }
           ).data,
       ) ?? []
     );
   }
 
+  static persistValue(
+    service: UserDataService,
+    value: string,
+    persistedData: SavedData,
+    opts: {
+      key: LEGEND_QUERY_USER_DATA_KEY;
+      limit: number;
+    },
+  ): void {
+    const idx = persistedData.findIndex((data) => data === value);
+    if (idx === -1) {
+      if (persistedData.length >= opts.limit) {
+        persistedData.pop();
+      }
+      persistedData.unshift(value);
+    } else {
+      persistedData.splice(idx, 1);
+      persistedData.unshift(value);
+    }
+    service.persistValue(opts.key, persistedData);
+  }
+
+  static getRecentlyViewedQueries(service: UserDataService): SavedData {
+    return LegendQueryUserDataHelper.getPersistedData(
+      service,
+      LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_QUERIES,
+    );
+  }
+
   static removeRecentlyViewedQueries(service: UserDataService): void {
     service.persistValue(
       LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_QUERIES,
@@ -79,21 +124,150 @@ export class LegendQueryUserDataHelper {
     queryId: string,
   ): void {
     const queries = LegendQueryUserDataHelper.getRecentlyViewedQueries(service);
-    const idx = queries.findIndex((query) => query === queryId);
+    LegendQueryUserDataHelper.persistValue(service, queryId, queries, {
+      limit: USER_DATA_RECENTLY_VIEWED_QUERIES_LIMIT,
+      key: LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_QUERIES,
+    });
+  }
+  // DataSpaces
+  static getRecentlyVisitedDataSpaces(
+    service: UserDataService,
+  ): SavedVisitedDataSpaces {
+    const data = service.getObjectValue(
+      LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_DATASPACES,
+    );
+    return (
+      // TODO: think of a better way to deserialize this data, maybe like settings, use JSON schema
+      // See https://github.com/finos/legend-studio/issues/407
+      returnUndefOnError(
+        () =>
+          (
+            deserialize(
+              createSimpleSchema({
+                data: raw(),
+              }),
+              {
+                data,
+              },
+            ) as { data: SavedVisitedDataSpaces }
+          ).data,
+      ) ?? []
+    );
+  }
+
+  static findRecentlyVisitedDataSpace(
+    service: UserDataService,
+    id: string,
+  ): VisitedDataspace | undefined {
+    return LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(service).find(
+      (v) => v.id === id,
+    );
+  }
+
+  static getRecentlyVisitedDataSpace(
+    service: UserDataService,
+  ): VisitedDataspace | undefined {
+    return LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(service)[0];
+  }
+
+  static persistVisitedDataspace(
+    service: UserDataService,
+    value: VisitedDataspace,
+    persistedData: SavedVisitedDataSpaces,
+    limit = USER_DATA_QUERY_DATASPACE_LIMIT,
+  ): void {
+    const key = LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_DATASPACES;
+    const idx = persistedData.findIndex((data) => data.id === value.id);
     if (idx === -1) {
-      if (queries.length < USER_DATA_RECENTLY_VIEWED_QUERIES_LIMIT) {
-        queries.unshift(queryId);
-      } else {
-        queries.pop();
-        queries.unshift(queryId);
+      if (persistedData.length >= limit) {
+        persistedData.pop();
       }
+      persistedData.unshift(value);
     } else {
-      queries.splice(idx, 1);
-      queries.unshift(queryId);
+      persistedData.splice(idx, 1);
+      persistedData.unshift(value);
     }
+    service.persistValue(key, persistedData);
+  }
+
+  static removeRecentlyViewedDataSpaces(service: UserDataService): void {
+    service.persistValue(
+      LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_DATASPACES,
+      [],
+    );
+  }
+
+  static removeRecentlyViewedDataSpace(
+    service: UserDataService,
+    id: string,
+  ): void {
+    const dataSpaces =
+      LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(service);
+    const idx = dataSpaces.findIndex(
+      (visitedDataspace) => visitedDataspace.id === id,
+    );
+    if (idx === -1) {
+      return;
+    }
+    dataSpaces.splice(idx, 1);
     service.persistValue(
       LEGEND_QUERY_USER_DATA_KEY.RECENTLY_VIEWED_QUERIES,
-      queries,
+      dataSpaces,
     );
   }
+
+  static removeDataSpace(service: UserDataService, info: DataSpaceInfo): void {
+    const id = createIdFromDataSpaceInfo(info);
+    if (id) {
+      LegendQueryUserDataHelper.removeRecentlyViewedDataSpace(service, id);
+    }
+  }
+
+  static addRecentlyVistedDatspace(
+    service: UserDataService,
+    info: DataSpaceInfo,
+    execContext: string | undefined,
+  ): void {
+    const visited = createVisitedDataspaceFromInfo(info, execContext);
+    if (visited) {
+      const dataspaces =
+        LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(service);
+      LegendQueryUserDataHelper.persistVisitedDataspace(
+        service,
+        visited,
+        dataspaces,
+      );
+    }
+  }
+  static addVisitedDatspace(
+    service: UserDataService,
+    visited: VisitedDataspace,
+  ): void {
+    const dataspaces =
+      LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(service);
+    LegendQueryUserDataHelper.persistVisitedDataspace(
+      service,
+      visited,
+      dataspaces,
+    );
+  }
+
+  static updateVisitedDataSpaceExecContext(
+    service: UserDataService,
+    groupId: string,
+    artifactId: string,
+    dataspace: string,
+    exec: string,
+  ): boolean {
+    const visited = LegendQueryUserDataHelper.findRecentlyVisitedDataSpace(
+      service,
+      createVisitedDataSpaceId(groupId, artifactId, dataspace),
+    );
+    if (visited) {
+      visited.execContext = exec;
+      LegendQueryUserDataHelper.addVisitedDatspace(service, visited);
+      return true;
+    }
+    return false;
+  }
 }

package/src/__lib__/LegendQueryUserDataSpaceHelper.ts

@@ -0,0 +1,98 @@
+/**
+ * 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 { DataSpaceInfo } from '@finos/legend-extension-dsl-data-space/application';
+import { GAV_DELIMITER, generateGAVCoordinates } from '@finos/legend-storage';
+
+export interface VisitedDataspace {
+  id: string;
+  groupId: string;
+  artifactId: string;
+  path: string;
+  versionId: string | undefined;
+  execContext?: string | undefined;
+}
+
+export type SavedVisitedDataSpaces = VisitedDataspace[];
+
+export const createVisitedDataSpaceId = (
+  groupId: string,
+  artifactId: string,
+  dataSpace: string,
+): string =>
+  // we will consider unique dataSpace if it belongs to the same project. i.e we will not save 2 dataspaces visited for 2 different versionss
+  generateGAVCoordinates(groupId, artifactId, undefined) +
+  GAV_DELIMITER +
+  dataSpace;
+
+export const createIdFromDataSpaceInfo = (
+  info: DataSpaceInfo,
+): string | undefined => {
+  const groupId = info.groupId;
+  const artifactId = info.artifactId;
+  if (groupId && artifactId) {
+    return createVisitedDataSpaceId(groupId, artifactId, info.path);
+  }
+  return undefined;
+};
+
+export const createSimpleVisitedDataspace = (
+  groupId: string,
+  artifactId: string,
+  versionId: string | undefined,
+  path: string,
+  exec: string | undefined,
+): VisitedDataspace => ({
+  id: createVisitedDataSpaceId(groupId, artifactId, path),
+  groupId,
+  artifactId,
+  versionId,
+  path,
+  execContext: exec,
+});
+
+export const createVisitedDataspaceFromInfo = (
+  info: DataSpaceInfo,
+  execContext: string | undefined,
+): VisitedDataspace | undefined => {
+  const groupId = info.groupId;
+  const artifactId = info.artifactId;
+  const versionId = info.versionId;
+  const path = info.path;
+  if (groupId && artifactId) {
+    return createSimpleVisitedDataspace(
+      groupId,
+      artifactId,
+      versionId,
+      path,
+      execContext,
+    );
+  }
+  return undefined;
+};
+
+export const hasDataSpaceInfoBeenVisited = (
+  val: DataSpaceInfo,
+  visited: SavedVisitedDataSpaces,
+): boolean =>
+  Boolean(
+    visited.find((_visit) => {
+      if (_visit.id === createIdFromDataSpaceInfo(val)) {
+        return true;
+      }
+      return false;
+    }),
+  );

package/src/components/CloneQueryServiceSetup.tsx

@@ -27,6 +27,7 @@ import {
   assertErrorThrown,
   guaranteeNonNullable,
   guaranteeType,
+  compareSemVerVersions,
 } from '@finos/legend-shared';
 import { flowResult } from 'mobx';
 import { observer, useLocalObservable } from 'mobx-react-lite';
@@ -53,7 +54,6 @@ import {
   type ProjectOption,
   type VersionOption,
 } from './QuerySetup.js';
-import { compareSemVerVersions } from '@finos/legend-storage';
 
 const CloneServiceQuerySetupStoreProvider: React.FC<{
   children: React.ReactNode;

package/src/components/Core_LegendQueryApplicationPlugin.tsx

@@ -50,6 +50,8 @@ import {
   LEGEND_QUERY_ROUTE_PATTERN,
 } from '../__lib__/LegendQueryNavigation.js';
 import {
+  ActionAlertActionType,
+  ActionAlertType,
   type ApplicationPageEntry,
   type LegendApplicationSetup,
 } from '@finos/legend-application';
@@ -65,14 +67,13 @@ import {
   generateDataSpaceQueryCreatorRoute,
   generateDataSpaceQuerySetupRoute,
 } from '../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
-import type {
-  QueryBuilderHeaderActionConfiguration,
-  QueryBuilderMenuActionConfiguration,
+import {
+  type QueryBuilderHeaderActionConfiguration,
+  type QueryBuilderMenuActionConfiguration,
 } from '@finos/legend-query-builder';
 import {
   ExistingQueryEditorStore,
   QueryBuilderActionConfig_QueryApplication,
-  createViewProjectHandler,
   createViewSDLCProjectHandler,
 } from '../stores/QueryEditorStore.js';
 import {
@@ -238,6 +239,7 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
       },
     ];
   }
+
   getExtraQueryBuilderExportMenuActionConfigurations?(): QueryBuilderMenuActionConfiguration[] {
     return [
       {
@@ -315,6 +317,19 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
         key: 'about-query-info',
         title: 'Get Query Info',
         label: 'About Query Info',
+        disableFunc: (queryBuilderState): boolean => {
+          if (
+            queryBuilderState.workflowState.actionConfig instanceof
+            QueryBuilderActionConfig_QueryApplication
+          ) {
+            const editorStore =
+              queryBuilderState.workflowState.actionConfig.editorStore;
+            if (editorStore instanceof ExistingQueryEditorStore) {
+              return false;
+            }
+          }
+          return true;
+        },
         onClick: (queryBuilderState): void => {
           if (
             queryBuilderState.workflowState.actionConfig instanceof
@@ -330,35 +345,22 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
         icon: <InfoCircleIcon />,
       },
       {
-        key: 'about-query-project',
+        key: 'about-query-sdlc-project',
         title: 'Go to Project',
         label: 'Go to Project',
-        onClick: (queryBuilderState): void => {
+        disableFunc: (queryBuilderState): boolean => {
           if (
             queryBuilderState.workflowState.actionConfig instanceof
             QueryBuilderActionConfig_QueryApplication
           ) {
             const editorStore =
               queryBuilderState.workflowState.actionConfig.editorStore;
-            LegendQueryTelemetryHelper.logEvent_QueryViewProjectLaunched(
-              editorStore.applicationStore.telemetryService,
-            );
-            const { groupId, artifactId, versionId } =
-              editorStore.getProjectInfo();
-            createViewProjectHandler(editorStore.applicationStore)(
-              groupId,
-              artifactId,
-              versionId,
-              undefined,
-            );
+            if (editorStore instanceof ExistingQueryEditorStore) {
+              return false;
+            }
           }
+          return true;
         },
-        icon: <InfoCircleIcon />,
-      },
-      {
-        key: 'about-query-sdlc-project',
-        title: 'Go to SDLC Project',
-        label: 'Go to SDLC Project',
         onClick: (queryBuilderState): void => {
           if (
             queryBuilderState.workflowState.actionConfig instanceof
@@ -380,6 +382,22 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
         },
         icon: <InfoCircleIcon />,
       },
+      {
+        key: 'about-legend-query',
+        title: 'About Legend Query',
+        label: 'About Legend Query',
+        onClick: (queryBuilderState): void => {
+          if (
+            queryBuilderState.workflowState.actionConfig instanceof
+            QueryBuilderActionConfig_QueryApplication
+          ) {
+            const editorStore =
+              queryBuilderState.workflowState.actionConfig.editorStore;
+            editorStore.setShowAppInfo(true);
+          }
+        },
+        icon: <InfoCircleIcon />,
+      },
     ];
   }
 
@@ -425,8 +443,6 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
           ) {
             const editorStore =
               queryBuilderState.workflowState.actionConfig.editorStore;
-            const isExistingQuery =
-              editorStore instanceof ExistingQueryEditorStore;
             const handleNewQuery = (): void => {
               if (editorStore instanceof ExistingQueryEditorStore) {
                 const query = editorStore.query;
@@ -463,24 +479,50 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
                     }
                   }
                 }
+              } else {
+                if (
+                  queryBuilderState.changeHistoryState.canUndo ||
+                  queryBuilderState.changeHistoryState.canRedo
+                ) {
+                  queryBuilderState.applicationStore.alertService.setActionAlertInfo(
+                    {
+                      message:
+                        'Current query will be lost when creating a new query. Do you still want to proceed?',
+                      type: ActionAlertType.CAUTION,
+                      actions: [
+                        {
+                          label: 'Proceed',
+                          type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+                          handler:
+                            queryBuilderState.applicationStore.guardUnhandledError(
+                              async () => queryBuilderState.resetQueryContent(),
+                            ),
+                        },
+                        {
+                          label: 'Cancel',
+                          type: ActionAlertActionType.PROCEED,
+                          default: true,
+                        },
+                      ],
+                    },
+                  );
+                } else {
+                  queryBuilderState.resetQueryContent();
+                }
               }
             };
             return (
-              <>
-                {isExistingQuery && (
-                  <Button
-                    className="query-editor__header__action btn--dark"
-                    disabled={editorStore.isPerformingBlockingAction}
-                    onClick={handleNewQuery}
-                    title="New query"
-                  >
-                    <SaveCurrIcon />
-                    <div className="query-editor__header__action__label">
-                      New Query
-                    </div>
-                  </Button>
-                )}
-              </>
+              <Button
+                className="query-editor__header__action btn--dark"
+                disabled={editorStore.isPerformingBlockingAction}
+                onClick={handleNewQuery}
+                title="New query"
+              >
+                <SaveCurrIcon />
+                <div className="query-editor__header__action__label">
+                  New Query
+                </div>
+              </Button>
             );
           }
           return undefined;
@@ -595,7 +637,13 @@ export class Core_LegendQueryApplicationPlugin extends LegendQueryApplicationPlu
                 </div>
               );
             }
-            return undefined;
+            return (
+              <div className="query-editor__dataspace__header">
+                <div className="query-editor__header__content__main query-editor__header__content__title__text query-editor__header__content__title__text--unsaved">
+                  Unsaved Query
+                </div>
+              </div>
+            );
           };
           return (
             <div className="query-editor__header__content">

package/src/components/CreateMappingQuerySetup.tsx

@@ -28,6 +28,7 @@ import {
   getNullableFirstEntry,
   guaranteeNonNullable,
   guaranteeType,
+  compareSemVerVersions,
 } from '@finos/legend-shared';
 import { flowResult } from 'mobx';
 import { observer, useLocalObservable } from 'mobx-react-lite';
@@ -51,7 +52,6 @@ import {
   type ProjectOption,
   type VersionOption,
 } from './QuerySetup.js';
-import { compareSemVerVersions } from '@finos/legend-storage';
 import type { Mapping, PackageableRuntime } from '@finos/legend-graph';
 import {
   buildElementOption,