@finos/legend-application-query 13.7.193 → 13.7.196

package/src/stores/QueryEditorStore.ts

@@ -119,10 +119,7 @@ import {
 } from '@finos/legend-query-builder';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
 import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
-import {
-  DataSpaceQueryBuilderState,
-  type DataSpaceInfo,
-} from '@finos/legend-extension-dsl-data-space/application';
+import { type ResolvedDataSpaceEntityWithOrigin } from '@finos/legend-extension-dsl-data-space/application';
 import {
   type DataSpace,
   type DataSpaceExecutionContext,
@@ -135,7 +132,7 @@ import {
 } from '@finos/legend-extension-dsl-data-space/graph';
 import { generateDataSpaceQueryCreatorRoute } from '../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import { hasDataSpaceInfoBeenVisited } from '../__lib__/LegendQueryUserDataSpaceHelper.js';
-import { createDataSpaceDepoRepo } from './data-space/DataSpaceQueryBuilderHelper.js';
+import { LegendQueryDataSpaceQueryBuilderState } from './data-space/query-builder/LegendQueryDataSpaceQueryBuilderState.js';
 
 export interface QueryPersistConfiguration {
   defaultName?: string | undefined;
@@ -1100,7 +1097,7 @@ export class ExistingQueryUpdateState {
   readonly editorStore: ExistingQueryEditorStore;
   readonly updateQueryState = ActionState.create();
   fetchProjectVersionState = ActionState.create();
-  queryRenamer = false;
+  isQueryRenameDialogOpen = false;
   saveModal = false;
   showQueryInfo = false;
   queryVersionId: string | undefined;
@@ -1111,7 +1108,7 @@ export class ExistingQueryUpdateState {
     this.editorStore = editorState;
 
     makeObservable(this, {
-      queryRenamer: observable,
+      isQueryRenameDialogOpen: observable,
       saveModal: observable,
       showQueryInfo: observable,
       queryVersionId: observable,
@@ -1124,7 +1121,7 @@ export class ExistingQueryUpdateState {
       setProjectVersions: action,
       setQueryVersionId: action,
       closeSaveModal: action,
-      setQueryRenamer: action,
+      setIsQueryRenameDialogOpen: action,
       updateQuery: flow,
       fetchProjectVersions: flow,
       updateQueryVersionId: flow,
@@ -1132,8 +1129,8 @@ export class ExistingQueryUpdateState {
     this.queryVersionId = this.editorStore.query?.versionId;
   }
 
-  setQueryRenamer(val: boolean): void {
-    this.queryRenamer = val;
+  setIsQueryRenameDialogOpen(val: boolean): void {
+    this.isQueryRenameDialogOpen = val;
   }
 
   setShowQueryInfo(val: boolean): void {
@@ -1186,6 +1183,7 @@ export class ExistingQueryUpdateState {
   *updateQuery(
     queryName: string | undefined,
     queryVersionId: string | undefined,
+    queryDescription?: string | undefined,
   ): GeneratorFn<void> {
     try {
       this.updateQueryState.inProgress();
@@ -1209,7 +1207,9 @@ export class ExistingQueryUpdateState {
       query.versionId = queryVersionId ?? query.versionId;
 
       query.description =
-        this.editorStore.query?.description ?? query.description;
+        queryDescription ??
+        this.editorStore.query?.description ??
+        query.description;
       const updatedQuery =
         (yield this.editorStore.graphManagerState.graphManager.updateQuery(
           query,
@@ -1515,92 +1515,101 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
           LegendQueryUserDataHelper.getRecentlyVisitedDataSpaces(
             this.applicationStore.userDataService,
           );
-        const dataSpaceQueryBuilderState = new DataSpaceQueryBuilderState(
-          this.applicationStore,
-          this.graphManagerState,
-          QueryBuilderDataBrowserWorkflow.INSTANCE,
-          new QueryBuilderActionConfig_QueryApplication(this),
-          dataSpace,
-          matchingExecutionContext,
-          isLightGraphEnabled,
-          createDataSpaceDepoRepo(
-            this,
-            queryInfo.groupId,
-            queryInfo.artifactId,
-            queryInfo.versionId,
-            (dataSpaceInfo: DataSpaceInfo) =>
+        const dataSpaceQueryBuilderState =
+          new LegendQueryDataSpaceQueryBuilderState(
+            this.applicationStore,
+            this.graphManagerState,
+            QueryBuilderDataBrowserWorkflow.INSTANCE,
+            new QueryBuilderActionConfig_QueryApplication(this),
+            dataSpace,
+            matchingExecutionContext,
+            isLightGraphEnabled,
+            this.depotServerClient,
+            {
+              groupId: queryInfo.groupId,
+              artifactId: queryInfo.artifactId,
+              versionId: queryInfo.versionId,
+            },
+            (dataSpaceInfo: ResolvedDataSpaceEntityWithOrigin) =>
               hasDataSpaceInfoBeenVisited(dataSpaceInfo, visitedDataSpaces),
-          ),
-          async (dataSpaceInfo: DataSpaceInfo) => {
-            if (dataSpaceInfo.defaultExecutionContext) {
-              const proceed = (): void =>
-                this.applicationStore.navigationService.navigator.goToLocation(
-                  generateDataSpaceQueryCreatorRoute(
-                    guaranteeNonNullable(dataSpaceInfo.groupId),
-                    guaranteeNonNullable(dataSpaceInfo.artifactId),
-                    LATEST_VERSION_ALIAS, //always default to latest
-                    dataSpaceInfo.path,
-                    guaranteeNonNullable(dataSpaceInfo.defaultExecutionContext),
-                    undefined,
-                    undefined,
-                  ),
-                );
-              const updateQueryAndProceed = async (): Promise<void> => {
-                try {
-                  await flowResult(
-                    this.updateState.updateQuery(undefined, undefined),
-                  );
-                  proceed();
-                } catch (error) {
-                  assertErrorThrown(error);
-                  this.applicationStore.logService.error(
-                    LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE),
-                    error,
-                  );
-                  this.applicationStore.notificationService.notifyError(error);
-                }
-              };
+            async (dataSpaceInfo: ResolvedDataSpaceEntityWithOrigin) => {
               if (
-                !queryInfo.isCurrentUserQuery ||
-                !this.queryBuilderState?.changeDetectionState.hasChanged
+                dataSpaceInfo.defaultExecutionContext &&
+                dataSpaceInfo.origin
               ) {
-                proceed();
-              } else {
-                this.applicationStore.alertService.setActionAlertInfo({
-                  message: `To change the data product, you need to save the current query
+                const origin = dataSpaceInfo.origin;
+                const proceed = (): void =>
+                  this.applicationStore.navigationService.navigator.goToLocation(
+                    generateDataSpaceQueryCreatorRoute(
+                      origin.groupId,
+                      origin.artifactId,
+                      LATEST_VERSION_ALIAS, //always default to latest
+                      dataSpaceInfo.path,
+                      guaranteeNonNullable(
+                        dataSpaceInfo.defaultExecutionContext,
+                      ),
+                      undefined,
+                      undefined,
+                    ),
+                  );
+                const updateQueryAndProceed = async (): Promise<void> => {
+                  try {
+                    await flowResult(
+                      this.updateState.updateQuery(undefined, undefined),
+                    );
+                    proceed();
+                  } catch (error) {
+                    assertErrorThrown(error);
+                    this.applicationStore.logService.error(
+                      LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE),
+                      error,
+                    );
+                    this.applicationStore.notificationService.notifyError(
+                      error,
+                    );
+                  }
+                };
+                if (
+                  !queryInfo.isCurrentUserQuery ||
+                  !this.queryBuilderState?.changeDetectionState.hasChanged
+                ) {
+                  proceed();
+                } else {
+                  this.applicationStore.alertService.setActionAlertInfo({
+                    message: `To change the data product, you need to save the current query
                      to proceed`,
-                  type: ActionAlertType.CAUTION,
-                  actions: [
-                    {
-                      label: 'Save query and Proceed',
-                      type: ActionAlertActionType.PROCEED_WITH_CAUTION,
-                      handler: () => {
-                        updateQueryAndProceed().catch(
-                          this.applicationStore.alertUnhandledError,
-                        );
+                    type: ActionAlertType.CAUTION,
+                    actions: [
+                      {
+                        label: 'Save query and Proceed',
+                        type: ActionAlertActionType.PROCEED_WITH_CAUTION,
+                        handler: () => {
+                          updateQueryAndProceed().catch(
+                            this.applicationStore.alertUnhandledError,
+                          );
+                        },
                       },
-                    },
-                    {
-                      label: 'Abort',
-                      type: ActionAlertActionType.PROCEED,
-                      default: true,
-                    },
-                  ],
-                });
+                      {
+                        label: 'Abort',
+                        type: ActionAlertActionType.PROCEED,
+                        default: true,
+                      },
+                    ],
+                  });
+                }
+              } else {
+                this.applicationStore.notificationService.notifyWarning(
+                  `Can't switch data product: default execution context not specified`,
+                );
               }
-            } else {
-              this.applicationStore.notificationService.notifyWarning(
-                `Can't switch data product: default execution context not specified`,
-              );
-            }
-          },
-          dataSpaceAnalysisResult,
-          undefined,
-          undefined,
-          undefined,
-          this.applicationStore.config.options.queryBuilderConfig,
-          sourceInfo,
-        );
+            },
+            dataSpaceAnalysisResult,
+            undefined,
+            undefined,
+            undefined,
+            this.applicationStore.config.options.queryBuilderConfig,
+            sourceInfo,
+          );
         const mappingModelCoverageAnalysisResult =
           dataSpaceAnalysisResult?.mappingToMappingCoverageResult?.get(
             matchingExecutionContext.mapping.value.path,

package/src/stores/data-product/query-builder/LegendQueryDataProductQueryBuilderState.ts

@@ -0,0 +1,129 @@
+/**
+ * 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 {
+  DataProductQueryBuilderState,
+  type QueryBuilderActionConfig,
+  type QueryBuilderConfig,
+  type QueryBuilderWorkflowState,
+  type ExtraOptionsConfig,
+} from '@finos/legend-query-builder';
+import type { LegendQueryApplicationStore } from '../../LegendQueryBaseStore.js';
+import {
+  resolveVersion,
+  type DepotServerClient,
+} from '@finos/legend-server-depot';
+import type {
+  DepotEntityWithOrigin,
+  ProjectGAVCoordinates,
+  QueryableSourceInfo,
+} from '@finos/legend-storage';
+import {
+  LegendSDLC,
+  type Class,
+  type DataProduct,
+  type GraphManagerState,
+  type NativeModelAccess,
+  type NativeModelExecutionContext,
+  type V1_DataProductArtifact,
+} from '@finos/legend-graph';
+import {
+  DATA_PRODUCT_EXECUTION_TYPE,
+  generateDataProductRoute,
+} from '../../../__lib__/LegendQueryNavigation.js';
+
+export class LegendQueryDataProductQueryBuilderState extends DataProductQueryBuilderState {
+  declare applicationStore: LegendQueryApplicationStore;
+  depotServerClient: DepotServerClient;
+  project: ProjectGAVCoordinates;
+  declare extraOptionsConfig: ExtraOptionsConfig<DepotEntityWithOrigin>;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    graphManagerState: GraphManagerState,
+    workflow: QueryBuilderWorkflowState,
+    actionConfig: QueryBuilderActionConfig,
+    dataProduct: DataProduct,
+    artifact: V1_DataProductArtifact | undefined,
+    nativeNativeModelAccess: NativeModelAccess,
+    nativeModelExecContext: NativeModelExecutionContext,
+    isLightGraphEnabled: boolean,
+    depotServerClient: DepotServerClient,
+    project: ProjectGAVCoordinates,
+    onDataProductChange: (val: DepotEntityWithOrigin) => Promise<void>,
+    onExecutionContextChange?:
+      | ((val: NativeModelExecutionContext) => void)
+      | undefined,
+    onClassChange?: ((val: Class) => void) | undefined,
+    config?: QueryBuilderConfig | undefined,
+    sourceInfo?: QueryableSourceInfo | undefined,
+  ) {
+    super(
+      applicationStore,
+      graphManagerState,
+      workflow,
+      dataProduct,
+      artifact,
+      actionConfig,
+      nativeNativeModelAccess,
+      nativeModelExecContext,
+      undefined,
+      onDataProductChange,
+      onExecutionContextChange,
+      onClassChange,
+      config,
+      sourceInfo,
+    );
+    this.project = project;
+    this.depotServerClient = depotServerClient;
+  }
+
+  get sdlc(): LegendSDLC {
+    return new LegendSDLC(
+      this.project.groupId,
+      this.project.artifactId,
+      resolveVersion(this.project.versionId),
+    );
+  }
+
+  override copyDataProductLinkToClipBoard(): void {
+    const dataSpace = this.dataProduct;
+    const executionContext = this.selectedExecContext;
+    const route =
+      this.applicationStore.navigationService.navigator.generateAddress(
+        generateDataProductRoute(
+          this.project.groupId,
+          this.project.artifactId,
+          this.project.versionId,
+          dataSpace.path,
+          DATA_PRODUCT_EXECUTION_TYPE.NATIVE,
+          executionContext.key,
+        ),
+      );
+
+    navigator.clipboard
+      .writeText(route)
+      .catch(() =>
+        this.applicationStore.notificationService.notifyError(
+          'Error copying data product query set up link to clipboard',
+        ),
+      );
+
+    this.applicationStore.notificationService.notifySuccess(
+      'Copied data product query set up link to clipboard',
+    );
+  }
+}

package/src/stores/data-space/DataSpaceQueryBuilderHelper.ts

@@ -21,11 +21,6 @@ import {
 import { EXTERNAL_APPLICATION_NAVIGATION__generateStudioSDLCProjectViewUrl } from '../../__lib__/LegendQueryNavigation.js';
 import type { LegendQueryApplicationStore } from '../LegendQueryBaseStore.js';
 import { parseProjectIdentifier } from '@finos/legend-storage';
-import type { QueryEditorStore } from '../QueryEditorStore.js';
-import {
-  DataSpacesDepotRepository,
-  type DataSpaceInfo,
-} from '@finos/legend-extension-dsl-data-space/application';
 import { EXTERNAL_APPLICATION_NAVIGATION__generateStudioProjectViewUrl } from '@finos/legend-application';
 
 export const createViewProjectHandler =
@@ -80,27 +75,3 @@ export const createViewSDLCProjectHandler =
       );
     }
   };
-
-export const createDataSpaceDepoRepo = (
-  editorStore: QueryEditorStore,
-  groupId: string,
-  artifactId: string,
-  versionId: string,
-  prioritizeDataSpaceFunc: ((val: DataSpaceInfo) => boolean) | undefined,
-): DataSpacesDepotRepository =>
-  new DataSpacesDepotRepository(
-    editorStore.depotServerClient,
-    editorStore.applicationStore,
-    editorStore.graphManagerState,
-    {
-      groupId,
-      artifactId,
-      versionId,
-    },
-    createViewProjectHandler(editorStore.applicationStore),
-    createViewSDLCProjectHandler(
-      editorStore.applicationStore,
-      editorStore.depotServerClient,
-    ),
-    prioritizeDataSpaceFunc,
-  );