@finos/legend-application-query 13.8.48 → 13.8.50

package/src/stores/__test-utils__/DataSpaceQueryBuilderStateTestUtils.ts

@@ -0,0 +1,138 @@
+/**
+ * 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 { ApplicationStore } from '@finos/legend-application';
+import {
+  Core_GraphManagerPreset,
+  DataProduct,
+  Mapping,
+  ModelAccessPointGroup,
+  PackageableElementExplicitReference,
+  PackageableRuntime,
+} from '@finos/legend-graph';
+import { TEST__getTestGraphManagerState } from '@finos/legend-graph/test';
+import {
+  QueryBuilderActionConfig,
+  QueryBuilderAdvancedWorkflowState,
+  QueryBuilder_GraphManagerPreset,
+  type QueryBuilderConfig,
+  TEST__LegendApplicationPluginManager,
+} from '@finos/legend-query-builder';
+import {
+  DataSpace,
+  DataSpaceExecutionContext,
+  DataSpaceMappingProvider,
+  DSL_DataSpace_GraphManagerPreset,
+} from '@finos/legend-extension-dsl-data-space/graph';
+import { DataSpaceQueryBuilderState } from '@finos/legend-extension-dsl-data-space/application';
+import { TEST__getTestLegendQueryApplicationConfig } from './LegendQueryApplicationTestUtils.js';
+
+export const TEST_DATA_SPACE_PATH = 'COVIDDatapace';
+
+const DEFAULT_MAPG_ID = 'PureAlloyUsageMAPG';
+
+export const buildRuntime = (name: string): PackageableRuntime =>
+  new PackageableRuntime(name);
+
+export const buildMapping = (name: string): Mapping => new Mapping(name);
+
+export const buildMappingProvider = (
+  mapping: Mapping,
+  groupId = DEFAULT_MAPG_ID,
+  dataProductName = 'Pure_Usage_Stats_Modeled',
+): DataSpaceMappingProvider => {
+  const group = new ModelAccessPointGroup();
+  group.id = groupId;
+  group.mapping = PackageableElementExplicitReference.create(mapping);
+  const dataProduct = new DataProduct(dataProductName);
+  dataProduct.accessPointGroups = [group];
+  const provider = new DataSpaceMappingProvider();
+  provider.element = PackageableElementExplicitReference.create(dataProduct);
+  provider.keys = [groupId];
+  return provider;
+};
+
+export const buildContext = (
+  name: string,
+  config: {
+    mapping?: Mapping | undefined;
+    mappingProvider?: DataSpaceMappingProvider | undefined;
+    defaultRuntime?: PackageableRuntime | undefined;
+  },
+): DataSpaceExecutionContext => {
+  const context = new DataSpaceExecutionContext();
+  context.name = name;
+  context.mapping = config.mapping
+    ? PackageableElementExplicitReference.create(config.mapping)
+    : undefined;
+  context.mappingProvider = config.mappingProvider;
+  context.defaultRuntime = config.defaultRuntime
+    ? PackageableElementExplicitReference.create(config.defaultRuntime)
+    : undefined;
+  return context;
+};
+
+export const buildDataSpace = (
+  name: string,
+  contexts: DataSpaceExecutionContext[] | undefined,
+  defaultContextName?: string | undefined,
+): DataSpace => {
+  const dataSpace = new DataSpace(name);
+  dataSpace.package = undefined;
+  dataSpace.executionContexts = contexts;
+  dataSpace.defaultExecutionContext =
+    defaultContextName && contexts
+      ? contexts.find((ctx) => ctx.name === defaultContextName)
+      : undefined;
+  return dataSpace;
+};
+
+export const buildState = (
+  dataSpace: DataSpace,
+  executionContext: DataSpaceExecutionContext,
+  options?: { config?: QueryBuilderConfig },
+): DataSpaceQueryBuilderState => {
+  const pluginManager = TEST__LegendApplicationPluginManager.create();
+  pluginManager
+    .usePresets([
+      new Core_GraphManagerPreset(),
+      new QueryBuilder_GraphManagerPreset(),
+      new DSL_DataSpace_GraphManagerPreset(),
+    ])
+    .install();
+  const applicationStore = new ApplicationStore(
+    TEST__getTestLegendQueryApplicationConfig(),
+    pluginManager,
+  );
+  return new DataSpaceQueryBuilderState(
+    applicationStore,
+    TEST__getTestGraphManagerState(pluginManager),
+    QueryBuilderAdvancedWorkflowState.INSTANCE,
+    QueryBuilderActionConfig.INSTANCE,
+    dataSpace,
+    executionContext,
+    false,
+    undefined,
+    async () => {
+      /* no-op */
+    },
+    undefined,
+    undefined,
+    undefined,
+    undefined,
+    options?.config,
+  );
+};

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

@@ -37,6 +37,7 @@ import type {
 } from '@finos/legend-storage';
 import {
   LegendSDLC,
+  INTERNAL_ELEMENT_PATH,
   type PackageableRuntime,
   type Class,
   type DataProduct,
@@ -144,7 +145,10 @@ export class LegendQueryDataProductQueryBuilderState extends DataProductQueryBui
           versionId: origin.versionId,
         },
       );
-      this.graphManagerState.graph.addElement(packageableRuntime, '_internal_');
+      this.graphManagerState.graph.addElement(
+        packageableRuntime,
+        INTERNAL_ELEMENT_PATH,
+      );
 
       if (!this.executionState.adhocRuntime) {
         this.executionState.withAdhocRuntime();
@@ -163,7 +167,10 @@ export class LegendQueryDataProductQueryBuilderState extends DataProductQueryBui
           versionId: origin.versionId,
         },
       );
-      this.graphManagerState.graph.addElement(packageableRuntime, '_internal_');
+      this.graphManagerState.graph.addElement(
+        packageableRuntime,
+        INTERNAL_ELEMENT_PATH,
+      );
       this.executionState.changeSelectedRuntime(packageableRuntime);
     }
     await super.prepareAccessForExecution();

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

@@ -27,7 +27,9 @@ import {
 } from '@finos/legend-graph';
 import {
   type DepotServerClient,
+  isSnapshotVersion,
   LATEST_VERSION_ALIAS,
+  SNAPSHOT_VERSION_ALIAS,
 } from '@finos/legend-server-depot';
 import {
   LogEvent,
@@ -51,10 +53,12 @@ import {
 import {
   type DataSpaceExecutionContext,
   getDataSpace,
+  resolveExecutionContextMapping,
 } from '@finos/legend-extension-dsl-data-space/graph';
 import {
   QueryBuilderActionConfig_QueryApplication,
   QueryEditorStore,
+  resolveExecutionContext,
   type QueryPersistConfiguration,
 } from '../QueryEditorStore.js';
 import type { LegendQueryApplicationStore } from '../LegendQueryBaseStore.js';
@@ -431,11 +435,31 @@ export class DataProductQueryCreatorStore extends QueryEditorStore {
       queryableDataSpace.dataSpacePath,
       this.graphManagerState.graph,
     );
-    const executionContext = guaranteeNonNullable(
-      dataSpace.executionContexts?.find(
-        (context) => context.name === queryableDataSpace.executionContext,
-      ),
-      `Can't find execution context '${queryableDataSpace.executionContext}'`,
+    const executionContext = resolveExecutionContext(
+      dataSpace,
+      queryableDataSpace.executionContext,
+      undefined,
+      undefined,
+    );
+    if (!executionContext) {
+      throw new Error(
+        `Execution context '${queryableDataSpace.executionContext}' does not exist in data space '${dataSpace.path}'.`,
+      );
+    }
+    if (
+      executionContext.mappingProvider &&
+      !resolveExecutionContextMapping(executionContext)
+    ) {
+      throw new Error(
+        `Execution context '${executionContext.name}' in data space '${dataSpace.path}' sources its mapping from a data product access point group that does not exist.`,
+      );
+    }
+
+    await this.attachDataSpaceFallbackRuntimes(
+      dataSpace,
+      dataSpaceAnalysisResult,
+      isSnapshotVersion(queryableDataSpace.versionId) ||
+        queryableDataSpace.versionId === SNAPSHOT_VERSION_ALIAS,
     );
     const sourceInfo = {
       groupId: queryableDataSpace.groupId,
@@ -494,7 +518,6 @@ export class DataProductQueryCreatorStore extends QueryEditorStore {
       this.productSelectorState.legacyDataProducts,
       this.productSelectorState.dataProducts,
     );
-    queryBuilderState.setExecutionContext(executionContext);
     await queryBuilderState.propagateExecutionContextChange(true);
 
     // set runtime if already chosen

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

@@ -21,13 +21,18 @@ import {
 } from '@finos/legend-query-builder';
 import { QueryBuilderActionConfig_QueryApplication } from '../QueryEditorStore.js';
 import type { LegendQueryApplicationStore } from '../LegendQueryBaseStore.js';
-import type { DepotServerClient } from '@finos/legend-server-depot';
+import {
+  type DepotServerClient,
+  isSnapshotVersion,
+  SNAPSHOT_VERSION_ALIAS,
+} from '@finos/legend-server-depot';
 import { generateDataSpaceTemplateQueryCreatorRoute } from '../../__lib__/DSL_DataSpace_LegendQueryNavigation.js';
 import {
   DataSpacePackageableElementExecutable,
   getDataSpace,
   getExecutionContextFromDataspaceExecutable,
   getQueryFromDataspaceExecutable,
+  resolveExecutionContextMapping,
 } from '@finos/legend-extension-dsl-data-space/graph';
 import {
   type ResolvedDataSpaceEntityWithOrigin,
@@ -157,7 +162,7 @@ export class DataSpaceTemplateQueryCreatorStore extends BaseTemplateQueryCreator
     }
     if (!query) {
       throw new IllegalStateError(
-        `Can't fetch query from data product executable`,
+        `Can't fetch query from data space executable`,
       );
     }
     if (!executionContext) {
@@ -165,6 +170,20 @@ export class DataSpaceTemplateQueryCreatorStore extends BaseTemplateQueryCreator
         `Can't find a correpsonding execution context`,
       );
     }
+    if (
+      executionContext.mappingProvider &&
+      !resolveExecutionContextMapping(executionContext)
+    ) {
+      throw new IllegalStateError(
+        `Execution context '${executionContext.name}' in data space '${dataSpace.path}' sources its mapping from a data product access point group that does not exist.`,
+      );
+    }
+    await this.attachDataSpaceFallbackRuntimes(
+      dataSpace,
+      dataSpaceAnalysisResult,
+      isSnapshotVersion(this.versionId) ||
+        this.versionId === SNAPSHOT_VERSION_ALIAS,
+    );
     const sourceInfo = {
       groupId: this.groupId,
       artifactId: this.artifactId,
@@ -188,7 +207,7 @@ export class DataSpaceTemplateQueryCreatorStore extends BaseTemplateQueryCreator
       undefined,
       async (dataSpaceInfo: ResolvedDataSpaceEntityWithOrigin) => {
         this.applicationStore.notificationService.notifyWarning(
-          `Can't switch data product to visit current template query`,
+          `Can't switch data space to visit current template query`,
         );
       },
       new DataProductSelectorState(
@@ -197,7 +216,7 @@ export class DataSpaceTemplateQueryCreatorStore extends BaseTemplateQueryCreator
       ),
       () => {
         this.applicationStore.notificationService.notifyWarning(
-          `Can't switch data product to visit current template query`,
+          `Can't switch data space to visit current template query`,
         );
       },
       dataSpaceAnalysisResult,

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

@@ -40,11 +40,14 @@ import {
 } from '@finos/legend-server-depot';
 import {
   GraphDataWithOrigin,
+  INTERNAL_ELEMENT_PATH,
+  LakehouseRuntime,
   LegendSDLC,
   RuntimePointer,
   type Class,
   type GraphData,
   type GraphManagerState,
+  type PackageableElement,
   type Runtime,
 } from '@finos/legend-graph';
 import {
@@ -59,8 +62,8 @@ import {
   createViewProjectHandler,
   createViewSDLCProjectHandler,
 } from '../DataSpaceQueryBuilderHelper.js';
-import { guaranteeNonNullable, type GeneratorFn } from '@finos/legend-shared';
-import { flowResult } from 'mobx';
+import { type GeneratorFn } from '@finos/legend-shared';
+import { action, flowResult, makeObservable, observable, reaction } from 'mobx';
 import type {
   DepotEntityWithOrigin,
   ProjectGAVCoordinates,
@@ -68,9 +71,6 @@ import type {
 } from '@finos/legend-storage';
 import type { DataProductSelectorState } from '../DataProductSelectorState.js';
 
-/**
- * Legend Query DataSpace query builder state.
- */
 export class LegendQueryDataSpaceQueryBuilderState extends DataSpaceQueryBuilderState {
   declare applicationStore: LegendQueryApplicationStore;
   depotServerClient: DepotServerClient;
@@ -78,6 +78,8 @@ export class LegendQueryDataSpaceQueryBuilderState extends DataSpaceQueryBuilder
   readonly onDataProductChange: (val: DepotEntityWithOrigin) => void;
   productSelectorState: DataProductSelectorState;
 
+  injectedLakehouseRuntime: LakehouseRuntime | undefined;
+
   override TEMPORARY__setupPanelContentRenderer = (): React.ReactNode =>
     renderLegendQueryDataSpaceQueryBuilderSetupPanelContent(this);
 
@@ -129,6 +131,38 @@ export class LegendQueryDataSpaceQueryBuilderState extends DataSpaceQueryBuilder
     this.depotServerClient = depotServerClient;
     this.productSelectorState = productSelectorState;
     this.onDataProductChange = onDataProductChange;
+    this.injectedLakehouseRuntime = this.resolveInjectedLakehouseRuntime();
+
+    makeObservable(this, {
+      injectedLakehouseRuntime: observable,
+      setInjectedLakehouseRuntime: action,
+    });
+
+    reaction(
+      () => this.executionContextState.runtimeValue,
+      () =>
+        this.setInjectedLakehouseRuntime(
+          this.resolveInjectedLakehouseRuntime(),
+        ),
+    );
+  }
+
+  setInjectedLakehouseRuntime(val: LakehouseRuntime | undefined): void {
+    this.injectedLakehouseRuntime = val;
+  }
+
+  private resolveInjectedLakehouseRuntime(): LakehouseRuntime | undefined {
+    const runtime = this.executionContextState.runtimeValue;
+    if (!(runtime instanceof RuntimePointer)) {
+      return undefined;
+    }
+    const packageableRuntime = runtime.packageableRuntime.value;
+    if (packageableRuntime.package?.path !== INTERNAL_ELEMENT_PATH) {
+      return undefined;
+    }
+    return packageableRuntime.runtimeValue instanceof LakehouseRuntime
+      ? packageableRuntime.runtimeValue
+      : undefined;
   }
 
   override get isAdvancedDataSpaceSearchEnabled(): boolean {
@@ -220,10 +254,7 @@ export class LegendQueryDataSpaceQueryBuilderState extends DataSpaceQueryBuilder
         this.dataSpace.title,
         this.dataSpace.name,
         this.dataSpace.path,
-        guaranteeNonNullable(
-          this.dataSpace.defaultExecutionContext,
-          `Data space '${this.dataSpace.path}' does not have a default execution context`,
-        ).name,
+        this.dataSpace.defaultExecutionContext?.name,
       ),
     };
   }
@@ -296,10 +327,7 @@ export class LegendQueryDataSpaceQueryBuilderState extends DataSpaceQueryBuilder
         dataSpace.title,
         dataSpace.name,
         dataSpace.path,
-        guaranteeNonNullable(
-          dataSpace.defaultExecutionContext,
-          `Data space '${dataSpace.path}' does not have a default execution context`,
-        ).name,
+        dataSpace.defaultExecutionContext?.name,
       ),
       this.project.versionId === SNAPSHOT_VERSION_ALIAS,
     );
@@ -308,4 +336,14 @@ export class LegendQueryDataSpaceQueryBuilderState extends DataSpaceQueryBuilder
   override getGraphData(): GraphData {
     return new GraphDataWithOrigin(this.sdlc);
   }
+
+  override get floatingExecutionElements(): PackageableElement[] | undefined {
+    if (!this.injectedLakehouseRuntime) {
+      return undefined;
+    }
+    const runtime = this.executionContextState.runtimeValue;
+    return runtime instanceof RuntimePointer
+      ? [runtime.packageableRuntime.value]
+      : undefined;
+  }
 }

package/src/stores/ingest/IngestQueryCreatorStore.ts

@@ -36,6 +36,7 @@ import {
   type Query,
   type RawLambda,
   GRAPH_MANAGER_EVENT,
+  INTERNAL_ELEMENT_PATH,
   IngestDefinition,
 } from '@finos/legend-graph';
 import type { LegendQueryApplicationStore } from '../LegendQueryBaseStore.js';
@@ -196,7 +197,10 @@ export class IngestQueryCreatorStore extends QueryEditorStore {
         versionId: this.versionId,
       },
     );
-    this.graphManagerState.graph.addElement(adhocRuntime, '_internal_');
+    this.graphManagerState.graph.addElement(
+      adhocRuntime,
+      INTERNAL_ELEMENT_PATH,
+    );
 
     const queryBuilderState = new IngestLegendQueryBuilderState(
       this.applicationStore,

package/tsconfig.json

@@ -78,6 +78,7 @@
     "./src/stores/QueryProductionizerSetupStore.ts",
     "./src/stores/QuerySetupStore.ts",
     "./src/stores/UpdateExistingServiceQuerySetupStore.ts",
+    "./src/stores/__test-utils__/DataSpaceQueryBuilderStateTestUtils.ts",
     "./src/stores/__test-utils__/LegendQueryApplicationTestUtils.ts",
     "./src/stores/data-cube/ExistingQueryDataCubeViewer.ts",
     "./src/stores/data-product/DataProductSampleQueryCreatorStore.ts",