@finos/legend-application-query 13.8.4 → 13.8.6

package/src/components/__test-utils__/QueryEditorComponentTestUtils.tsx

@@ -21,6 +21,7 @@ import {
   type AbstractPreset,
   filterByType,
   guaranteeNonNullable,
+  guaranteeType,
 } from '@finos/legend-shared';
 import { createMock, createSpy } from '@finos/legend-shared/test';
 import {
@@ -40,6 +41,7 @@ import {
   QueryDataProductModelAccessExecutionContextInfo,
   QueryDataProductNativeExecutionContextInfo,
   ModelAccessPointGroup,
+  V1_PureGraphManager,
 } from '@finos/legend-graph';
 import { DepotServerClient } from '@finos/legend-server-depot';
 import {
@@ -67,19 +69,34 @@ import {
 import { LegendQueryFrameworkProvider } from '../LegendQueryFrameworkProvider.js';
 import { TEST__BrowserEnvironmentProvider } from '@finos/legend-application/test';
 import { Core_LegendQueryApplicationPlugin } from '../Core_LegendQueryApplicationPlugin.js';
-import { Route, Routes } from '@finos/legend-application/browser';
+import {
+  Route,
+  Routes,
+  generateExtensionUrlPattern,
+} from '@finos/legend-application/browser';
 import {
   generateExistingQueryEditorRoute,
   LEGEND_QUERY_ROUTE_PATTERN,
 } from '../../__lib__/LegendQueryNavigation.js';
+import {
+  generateDataSpaceTemplateQueryCreatorRoute,
+  LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN,
+} from '../../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
+import { DataSpaceTemplateQueryCreator } from '../data-space/DataSpaceTemplateQueryCreator.js';
 import {
   type V1_DataSpaceAnalysisResult,
   DSL_DataSpace_getGraphManagerExtension,
 } from '@finos/legend-extension-dsl-data-space/graph';
 import { LegendQueryDataProductQueryBuilderState } from '../../stores/data-product/query-builder/LegendQueryDataProductQueryBuilderState.js';
 import { DataProductSelectorState } from '../../stores/data-space/DataProductSelectorState.js';
+import { DataSpaceTemplateQueryCreatorStore } from '../../stores/data-space/DataSpaceTemplateQueryCreatorStore.js';
 
 const TEST_QUERY_ID = 'test-query-id';
+const TEST_GROUP_ID = 'test-group';
+const TEST_ARTIFACT_ID = 'test-artifact';
+const TEST_VERSION_ID = 'test-version';
+const TEST_TEMPLATE_QUERY_ID = 'templateQuery';
+const TEST_DATA_SPACE_PATH = 'domain::COVIDDatapace';
 export const TEST_QUERY_NAME = 'MyTestQuery';
 
 export const TEST__provideMockedQueryEditorStore = (customization?: {
@@ -123,6 +140,52 @@ export const TEST__provideMockedQueryEditorStore = (customization?: {
   return value;
 };
 
+export const TEST__provideMockedDataSpaceTemplateQueryCreatorStore =
+  (customization?: {
+    mock?: DataSpaceTemplateQueryCreatorStore;
+    applicationStore?: LegendQueryApplicationStore;
+    graphManagerState?: GraphManagerState;
+    pluginManager?: LegendQueryPluginManager;
+    extraPlugins?: AbstractPlugin[];
+    extraPresets?: AbstractPreset[];
+  }): DataSpaceTemplateQueryCreatorStore => {
+    const pluginManager =
+      customization?.pluginManager ?? LegendQueryPluginManager.create();
+    pluginManager
+      .usePlugins([
+        new Core_LegendQueryApplicationPlugin(),
+        ...(customization?.extraPlugins ?? []),
+      ])
+      .usePresets([...(customization?.extraPresets ?? [])])
+      .install();
+    const applicationStore =
+      customization?.applicationStore ??
+      new ApplicationStore(
+        TEST__getTestLegendQueryApplicationConfig(),
+        pluginManager,
+      );
+    const depotServerClient = new DepotServerClient({
+      serverUrl: applicationStore.config.depotServerUrl,
+    });
+    depotServerClient.setTracerService(applicationStore.tracerService);
+    const value =
+      customization?.mock ??
+      new DataSpaceTemplateQueryCreatorStore(
+        applicationStore,
+        depotServerClient,
+        TEST_GROUP_ID,
+        TEST_ARTIFACT_ID,
+        TEST_VERSION_ID,
+        TEST_DATA_SPACE_PATH,
+        TEST_TEMPLATE_QUERY_ID,
+        { fips: 'value' },
+      );
+    const MOCK__QueryEditorStoreProvider = require('../QueryEditorStoreProvider.js'); // eslint-disable-line @typescript-eslint/no-require-imports,@typescript-eslint/no-unsafe-assignment
+    MOCK__QueryEditorStoreProvider.useQueryEditorStore = createMock();
+    MOCK__QueryEditorStoreProvider.useQueryEditorStore.mockReturnValue(value);
+    return value;
+  };
+
 export const TEST__setUpQueryEditor = async (
   MOCK__editorStore: ExistingQueryEditorStore,
   entities: PlainObject<Entity>[],
@@ -432,6 +495,147 @@ export const TEST__setUpDataSpaceExistingQueryEditor = async (
   };
 };
 
+export const TEST__setUpDataSpaceTemplateQueryEditor = async (
+  MOCK__editorStore: DataSpaceTemplateQueryCreatorStore,
+  V1_dataspaceAnalyticsResult: PlainObject<V1_DataSpaceAnalysisResult>,
+  dataSpacePath: string,
+  executionContext: string,
+  lambda: RawLambda,
+  entities: PlainObject<Entity>[],
+): Promise<{
+  renderResult: RenderResult;
+  queryBuilderState: QueryBuilderState;
+}> => {
+  const projectData = {
+    id: 'test-id',
+    groupId: MOCK__editorStore.groupId,
+    artifactId: MOCK__editorStore.artifactId,
+    projectId: 'test-project-id',
+    versions: [MOCK__editorStore.versionId],
+    latestVersion: MOCK__editorStore.versionId,
+  };
+
+  const graphManagerState = MOCK__editorStore.graphManagerState;
+
+  await graphManagerState.graphManager.initialize({
+    env: 'test',
+    tabSize: 2,
+    clientConfig: {},
+  });
+
+  await graphManagerState.initializeSystem();
+
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getProject',
+  ).mockResolvedValue(projectData);
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getEntities',
+  ).mockResolvedValue(entities);
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getIndexedDependencyEntities',
+  ).mockResolvedValue(new Map<string, EntitiesWithOrigin>());
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getEntitiesByClassifier',
+  ).mockResolvedValue([]);
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getGenerationContentByPath',
+  ).mockResolvedValue(JSON.stringify(V1_dataspaceAnalyticsResult));
+  createSpy(
+    MOCK__editorStore.depotServerClient,
+    'getGenerationFilesByType',
+  ).mockResolvedValue([]);
+  createSpy(
+    graphManagerState.graphManager,
+    'pureCodeToLambda',
+  ).mockResolvedValue(new RawLambda(lambda.parameters, lambda.body));
+  createSpy(
+    graphManagerState.graphManager,
+    'lambdaToPureCode',
+  ).mockResolvedValue('');
+  createSpy(graphManagerState.graphManager, 'surveyDatasets').mockResolvedValue(
+    [],
+  );
+  createSpy(
+    graphManagerState.graphManager,
+    'checkDatasetEntitlements',
+  ).mockResolvedValue([]);
+
+  // Mock engine's transformCodeToValueSpecifications to handle preset URL string parameter values.
+  const pureGraphManager = guaranteeType(
+    graphManagerState.graphManager,
+    V1_PureGraphManager,
+  );
+  createSpy(
+    pureGraphManager.engine,
+    'transformCodeToValueSpecifications',
+  ).mockImplementation(async (input: Record<string, { value: string }>) => {
+    const result = new Map<string, PlainObject>();
+    for (const [key, entry] of Object.entries(input)) {
+      const match = /^'(?<content>.*)'$/.exec(entry.value);
+      if (match?.groups) {
+        result.set(key, { _type: 'string', value: match.groups.content });
+      }
+    }
+    return result;
+  });
+
+  const graphManagerExtension = DSL_DataSpace_getGraphManagerExtension(
+    graphManagerState.graphManager,
+  );
+  const dataspaceAnalyticsResult =
+    await graphManagerExtension.buildDataSpaceAnalytics(
+      V1_dataspaceAnalyticsResult,
+      graphManagerState.graphManager.pluginManager.getPureProtocolProcessorPlugins(),
+    );
+  createSpy(graphManagerExtension, 'analyzeDataSpace').mockResolvedValue(
+    dataspaceAnalyticsResult,
+  );
+
+  MOCK__editorStore.buildGraph = createMock();
+  graphManagerState.graphManager.initialize = createMock();
+
+  const templateRoute = generateDataSpaceTemplateQueryCreatorRoute(
+    MOCK__editorStore.groupId,
+    MOCK__editorStore.artifactId,
+    MOCK__editorStore.versionId,
+    MOCK__editorStore.dataSpacePath,
+    MOCK__editorStore.templateQueryId,
+  );
+
+  const renderResult = render(
+    <ApplicationStoreProvider store={MOCK__editorStore.applicationStore}>
+      <TEST__BrowserEnvironmentProvider initialEntries={[templateRoute]}>
+        <LegendQueryFrameworkProvider>
+          <Routes>
+            <Route
+              path={generateExtensionUrlPattern(
+                LEGACY_DATA_SPACE_QUERY_ROUTE_PATTERN.TEMPLATE_QUERY,
+              )}
+              element={<DataSpaceTemplateQueryCreator />}
+            />
+          </Routes>
+        </LegendQueryFrameworkProvider>
+      </TEST__BrowserEnvironmentProvider>
+    </ApplicationStoreProvider>,
+  );
+  await waitFor(() =>
+    renderResult.getByTestId(QUERY_BUILDER_TEST_ID.QUERY_BUILDER),
+  );
+
+  return {
+    renderResult,
+    queryBuilderState: guaranteeNonNullable(
+      MOCK__editorStore.queryBuilderState,
+      `Query builder state should have been initialized`,
+    ),
+  };
+};
+
 export const TEST__setUpDataProductExistingQueryEditor = async (
   MOCK__editorStore: ExistingQueryEditorStore,
   dataProductPath: string,

package/src/components/data-space/DataSpaceTemplateQueryCreator.tsx

@@ -25,17 +25,22 @@ import { DataSpaceTemplateQueryCreatorStore } from '../../stores/data-space/Data
 import { QueryEditorStoreContext } from '../QueryEditorStoreProvider.js';
 import {
   DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN,
+  generateDataSpaceTemplateQueryCreatorRoute,
   type DataSpaceTemplateQueryCreatorPathParams,
 } from '../../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import { QueryEditor } from '../QueryEditor.js';
 import { guaranteeNonNullable } from '@finos/legend-shared';
+import { useApplicationStore } from '@finos/legend-application';
+import { extractQueryParams } from '../utils/QueryParameterUtils.js';
+import { useEffect } from 'react';
 
 const DataSpaceTemplateQueryCreatorStoreProvider: React.FC<{
   children: React.ReactNode;
   gav: string;
   dataSpacePath: string;
   templateQueryId: string;
-}> = ({ children, gav, dataSpacePath, templateQueryId }) => {
+  params: Record<string, string> | undefined;
+}> = ({ children, gav, dataSpacePath, templateQueryId, params }) => {
   const { groupId, artifactId, versionId } = parseGAVCoordinates(gav);
   const applicationStore = useLegendQueryApplicationStore();
   const baseStore = useLegendQueryBaseStore();
@@ -49,6 +54,7 @@ const DataSpaceTemplateQueryCreatorStoreProvider: React.FC<{
         versionId,
         dataSpacePath,
         templateQueryId,
+        params,
       ),
   );
   return (
@@ -59,6 +65,7 @@ const DataSpaceTemplateQueryCreatorStoreProvider: React.FC<{
 };
 
 export const DataSpaceTemplateQueryCreator = observer(() => {
+  const applicationStore = useApplicationStore();
   const parameters = useParams<DataSpaceTemplateQueryCreatorPathParams>();
   const gav = guaranteeNonNullable(
     parameters[DATA_SPACE_TEMPLATE_QUERY_CREATOR_ROUTE_PATTERN_TOKEN.GAV],
@@ -74,11 +81,31 @@ export const DataSpaceTemplateQueryCreator = observer(() => {
     ],
   );
 
+  const queryParams =
+    applicationStore.navigationService.navigator.getCurrentLocationParameters();
+  const processed = extractQueryParams(queryParams);
+
+  useEffect(() => {
+    // clear params
+    if (processed && Object.keys(processed).length) {
+      const { groupId, artifactId, versionId } = parseGAVCoordinates(gav);
+      applicationStore.navigationService.navigator.updateCurrentLocation(
+        generateDataSpaceTemplateQueryCreatorRoute(
+          groupId,
+          artifactId,
+          versionId,
+          dataSpacePath,
+          templateQueryId,
+        ),
+      );
+    }
+  }, [applicationStore, gav, dataSpacePath, templateQueryId, processed]);
   return (
     <DataSpaceTemplateQueryCreatorStoreProvider
       gav={gav}
       dataSpacePath={dataSpacePath}
       templateQueryId={templateQueryId}
+      params={processed}
     >
       <QueryEditor />
     </DataSpaceTemplateQueryCreatorStoreProvider>

package/src/components/utils/QueryParameterUtils.ts

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) 2026-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 GraphManagerState,
+  type QueryParameterValue,
+  type RawLambda,
+  buildLambdaVariableExpressions,
+  PrimitiveType,
+  VariableExpression,
+} from '@finos/legend-graph';
+import { filterByType, returnUndefOnError } from '@finos/legend-shared';
+
+const QUERY_PARAM_SUFFIX = 'p:';
+
+export const extractQueryParams = (
+  urlQuery: Record<string, string | undefined>,
+): Record<string, string> | undefined => {
+  const queryParamEntries = Array.from(Object.entries(urlQuery));
+  if (queryParamEntries.length) {
+    const paramValues: Record<string, string> = {};
+    queryParamEntries.forEach(([key, queryValue]) => {
+      if (queryValue && key.startsWith(QUERY_PARAM_SUFFIX)) {
+        paramValues[key.slice(QUERY_PARAM_SUFFIX.length)] = queryValue;
+      }
+    });
+    return Object.values(paramValues).length === 0 ? undefined : paramValues;
+  }
+
+  return undefined;
+};
+
+export const processQueryParameters = (
+  query: RawLambda,
+  savedQueryParams: QueryParameterValue[] | undefined,
+  urlParams: Record<string, string> | undefined,
+  graphManagerState: GraphManagerState,
+): Map<string, string> | undefined => {
+  const resolvedStringParams = new Map<string, string>();
+  savedQueryParams?.forEach((e) => {
+    resolvedStringParams.set(e.name, e.content);
+  });
+  // here we overwrite any params coming from the url
+  if (urlParams && Object.values(urlParams).length > 0) {
+    const compiledParams = returnUndefOnError(() =>
+      buildLambdaVariableExpressions(query, graphManagerState),
+    )?.filter(filterByType(VariableExpression));
+    Object.entries(urlParams).forEach(([key, value]) => {
+      const cP = compiledParams?.find((e) => e.name === key);
+      if (cP?.genericType?.value.rawType === PrimitiveType.STRING) {
+        resolvedStringParams.set(key, `'${value}'`);
+      } else if (
+        cP?.genericType?.value.rawType === PrimitiveType.DATE ||
+        cP?.genericType?.value.rawType === PrimitiveType.STRICTDATE ||
+        cP?.genericType?.value.rawType === PrimitiveType.DATETIME
+      ) {
+        resolvedStringParams.set(key, `%${value}`);
+      } else {
+        resolvedStringParams.set(key, value);
+      }
+    });
+  }
+  return resolvedStringParams.size > 0 ? resolvedStringParams : undefined;
+};

package/src/stores/QueryEditorStore.ts

@@ -68,9 +68,6 @@ import {
   cloneQueryStereotype,
   cloneQueryTaggedValue,
   QueryProjectCoordinates,
-  buildLambdaVariableExpressions,
-  VariableExpression,
-  PrimitiveType,
   CORE_PURE_PATH,
   isValidFullPath,
   QUERY_PROFILE_PATH,
@@ -157,6 +154,7 @@ import {
   LakehouseContractServerClient,
   LakehouseEnvironmentType,
 } from '@finos/legend-server-lakehouse';
+import { processQueryParameters } from '../components/utils/QueryParameterUtils.js';
 
 export interface QueryPersistConfiguration {
   defaultName?: string | undefined;
@@ -470,6 +468,11 @@ export abstract class QueryEditorStore {
   }
 
   abstract getProjectInfo(): ProjectGAVCoordinates | undefined;
+
+  getEditorRoute(): string | undefined {
+    return undefined;
+  }
+
   /**
    * Set up the editor state before building the graph
    */
@@ -1754,38 +1757,6 @@ const resolveExecutionContext = (
   return matchingExecContexts[0];
 };
 
-const processQueryParams = (
-  query: RawLambda,
-  savedQueryParams: QueryParameterValue[] | undefined,
-  urlParams: Record<string, string> | undefined,
-  graphManagerState: GraphManagerState,
-): Map<string, string> | undefined => {
-  const resolvedStringParams = new Map<string, string>();
-  savedQueryParams?.forEach((e) => {
-    resolvedStringParams.set(e.name, e.content);
-  });
-  // here we overwrite any params coming from the url
-  if (urlParams && Object.values(urlParams).length > 0) {
-    const compiledParams = returnUndefOnError(() =>
-      buildLambdaVariableExpressions(query, graphManagerState),
-    )?.filter(filterByType(VariableExpression));
-    Object.entries(urlParams).forEach(([key, value]) => {
-      const cP = compiledParams?.find((e) => e.name === key);
-      if (cP?.genericType?.value.rawType === PrimitiveType.STRING) {
-        resolvedStringParams.set(key, `'${value}'`);
-      } else if (
-        cP?.genericType?.value.rawType === PrimitiveType.DATE ||
-        cP?.genericType?.value.rawType === PrimitiveType.DATETIME
-      ) {
-        resolvedStringParams.set(key, `%${value}`);
-      } else {
-        resolvedStringParams.set(key, value);
-      }
-    });
-  }
-  return resolvedStringParams.size > 0 ? resolvedStringParams : undefined;
-};
-
 export class ExistingQueryEditorStore extends QueryEditorStore {
   private queryId: string;
   private _lightQuery?: LightQuery | undefined;
@@ -1823,6 +1794,10 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
     return guaranteeNonNullable(this._lightQuery, `Query has not been loaded`);
   }
 
+  override getEditorRoute(): string {
+    return generateExistingQueryEditorRoute(this.queryId);
+  }
+
   override get isPerformingBlockingAction(): boolean {
     return (
       super.isPerformingBlockingAction ||
@@ -2178,7 +2153,7 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
     // leverage initialization of query builder state to ensure we handle unsupported queries
     let defaultParameters: Map<string, ValueSpecification> | undefined =
       undefined;
-    const processedQueryParamValues = processQueryParams(
+    const processedQueryParamValues = processQueryParameters(
       existingQueryLambda,
       query.defaultParameterValues,
       this.urlQueryParamValues,

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

@@ -18,12 +18,15 @@ import {
   type Query,
   type QuerySearchSpecification,
   type RawLambda,
+  type ValueSpecification,
   QueryProjectCoordinates,
   extractElementNameFromPath,
 } from '@finos/legend-graph';
 import { type DepotServerClient } from '@finos/legend-server-depot';
 import {
+  assertErrorThrown,
   IllegalStateError,
+  LogEvent,
   uuid,
   type GeneratorFn,
 } from '@finos/legend-shared';
@@ -41,6 +44,7 @@ import {
   QueryEditorStore,
 } from '../QueryEditorStore.js';
 import type { LegendQueryApplicationStore } from '../LegendQueryBaseStore.js';
+import { generateDataSpaceTemplateQueryCreatorRoute } from '../../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import {
   DataSpacePackageableElementExecutable,
   getDataSpace,
@@ -54,6 +58,8 @@ import {
 } from '@finos/legend-extension-dsl-data-space/application';
 import { LegendQueryDataSpaceQueryBuilderState } from './query-builder/LegendQueryDataSpaceQueryBuilderState.js';
 import { DataProductSelectorState } from './DataProductSelectorState.js';
+import { processQueryParameters } from '../../components/utils/QueryParameterUtils.js';
+import { LEGEND_QUERY_APP_EVENT } from '../../__lib__/LegendQueryEvent.js';
 
 export class DataSpaceTemplateQueryCreatorStore extends QueryEditorStore {
   readonly groupId: string;
@@ -62,6 +68,7 @@ export class DataSpaceTemplateQueryCreatorStore extends QueryEditorStore {
   readonly dataSpacePath: string;
   readonly templateQueryId: string;
   templateQueryTitle?: string;
+  urlQueryParamValues: Record<string, string> | undefined;
 
   constructor(
     applicationStore: LegendQueryApplicationStore,
@@ -71,6 +78,7 @@ export class DataSpaceTemplateQueryCreatorStore extends QueryEditorStore {
     versionId: string,
     dataSpacePath: string,
     templateQueryId: string,
+    urlQueryParamValues: Record<string, string> | undefined,
   ) {
     super(applicationStore, depotServerClient);
 
@@ -79,6 +87,7 @@ export class DataSpaceTemplateQueryCreatorStore extends QueryEditorStore {
     this.versionId = versionId;
     this.dataSpacePath = dataSpacePath;
     this.templateQueryId = templateQueryId;
+    this.urlQueryParamValues = urlQueryParamValues;
   }
 
   getProjectInfo(): ProjectGAVCoordinates {
@@ -89,6 +98,16 @@ export class DataSpaceTemplateQueryCreatorStore extends QueryEditorStore {
     };
   }
 
+  override getEditorRoute(): string {
+    return generateDataSpaceTemplateQueryCreatorRoute(
+      this.groupId,
+      this.artifactId,
+      this.versionId,
+      this.dataSpacePath,
+      this.templateQueryId,
+    );
+  }
+
   override *buildGraph(): GeneratorFn<void> {
     // do nothing
   }
@@ -212,7 +231,31 @@ export class DataSpaceTemplateQueryCreatorStore extends QueryEditorStore {
     );
     queryBuilderState.setExecutionContext(executionContext);
     await queryBuilderState.propagateExecutionContextChange(true);
-    queryBuilderState.initializeWithQuery(query);
+
+    let defaultParameters: Map<string, ValueSpecification> | undefined =
+      undefined;
+    const processedQueryParamValues = processQueryParameters(
+      query,
+      undefined,
+      this.urlQueryParamValues,
+      this.graphManagerState,
+    );
+    if (processedQueryParamValues?.size) {
+      try {
+        defaultParameters =
+          await this.graphManagerState.graphManager.pureCodeToValueSpecifications(
+            processedQueryParamValues,
+            this.graphManagerState.graph,
+          );
+      } catch (error) {
+        assertErrorThrown(error);
+        this.applicationStore.logService.error(
+          LogEvent.create(LEGEND_QUERY_APP_EVENT.GENERIC_FAILURE),
+          `Error resolving preset query param values: ${error.message}`,
+        );
+      }
+    }
+    queryBuilderState.initializeWithQuery(query, defaultParameters);
     return queryBuilderState;
   }
 

package/src/stores/data-space/query-builder/LegendQueryDataSpaceQueryBuilderState.ts

@@ -54,6 +54,7 @@ import {
 } from '@finos/legend-query-builder';
 import { renderLegendQueryDataSpaceQueryBuilderSetupPanelContent } from '../../../components/data-space/LegendQueryDataSpaceQueryBuilder.js';
 import type { LegendQueryApplicationStore } from '../../LegendQueryBaseStore.js';
+import { QueryBuilderActionConfig_QueryApplication } from '../../QueryEditorStore.js';
 import {
   createViewProjectHandler,
   createViewSDLCProjectHandler,
@@ -162,23 +163,36 @@ export class LegendQueryDataSpaceQueryBuilderState extends DataSpaceQueryBuilder
   }
 
   override copyDataSpaceLinkToClipboard(): void {
-    const dataSpace = this.dataSpace;
-    const executionContext = this.executionContext;
-    const runtimePath =
-      this.executionContextState.runtimeValue instanceof RuntimePointer
-        ? this.executionContextState.runtimeValue.packageableRuntime.value.path
+    const editorStore =
+      this.workflowState.actionConfig instanceof
+      QueryBuilderActionConfig_QueryApplication
+        ? this.workflowState.actionConfig.editorStore
         : undefined;
+    const editorRoute = editorStore?.getEditorRoute();
+    let routePath: string;
+    if (editorRoute) {
+      routePath = editorRoute;
+    } else {
+      const dataSpace = this.dataSpace;
+      const executionContext = this.executionContext;
+      const runtimePath =
+        this.executionContextState.runtimeValue instanceof RuntimePointer
+          ? this.executionContextState.runtimeValue.packageableRuntime.value
+              .path
+          : undefined;
+      routePath = generateDataSpaceQueryCreatorRoute(
+        this.project.groupId,
+        this.project.artifactId,
+        this.project.versionId,
+        dataSpace.path,
+        executionContext.name,
+        runtimePath,
+        this.class?.path,
+      );
+    }
     const route =
       this.applicationStore.navigationService.navigator.generateAddress(
-        generateDataSpaceQueryCreatorRoute(
-          this.project.groupId,
-          this.project.artifactId,
-          this.project.versionId,
-          dataSpace.path,
-          executionContext.name,
-          runtimePath,
-          this.class?.path,
-        ),
+        routePath,
       );
 
     navigator.clipboard

package/tsconfig.json

@@ -66,6 +66,7 @@
     "./src/application/LegendQueryPluginManager.ts",
     "./src/components/data-product/QueryDataProductUtil.ts",
     "./src/components/data-space/QueryDataSpaceUtil.ts",
+    "./src/components/utils/QueryParameterUtils.ts",
     "./src/stores/CloneServiceQuerySetupStore.ts",
     "./src/stores/CreateMappingQuerySetupStore.ts",
     "./src/stores/EditExistingQuerySetupStore.ts",