@finos/legend-application-query 13.8.49 → 13.8.50

package/src/stores/QueryEditorStore.ts

@@ -50,6 +50,7 @@ import {
   type ValueSpecification,
   type GraphInitializationReport,
   PackageableRuntime,
+  createPath,
   type QueryInfo,
   GraphManagerState,
   Query,
@@ -69,6 +70,7 @@ import {
   cloneQueryTaggedValue,
   QueryProjectCoordinates,
   CORE_PURE_PATH,
+  INTERNAL_ELEMENT_PATH,
   isValidFullPath,
   QUERY_PROFILE_PATH,
   QueryDataSpaceExecutionContextInfo,
@@ -1143,24 +1145,9 @@ export abstract class QueryEditorStore {
     );
   }
 
-  /**
-   * Resolves the user's lakehouse environment and warehouse, creates a
-   * `LakehouseRuntime`, and wraps it in a `PackageableRuntime`.
-   *
-   * Resolution order:
-   * 1. Check local storage (`LakehouseUserInfo`) for a previously persisted value.
-   * 2. If not found, fetch from the lakehouse contract server via
-   *    `getUserEntitlementEnvs()` and persist the result to local storage.
-   */
-  async createLakehousePackageableRuntime(
-    dataProductPath: string,
-    gav: {
-      groupId: string;
-      artifactId: string;
-      versionId: string;
-    },
-  ): Promise<PackageableRuntime> {
-    // 1. Check local storage for persisted lakehouse user info
+  async resolveLakehouseEnvAndWarehouse(
+    isSnapshot: boolean,
+  ): Promise<{ env: string; warehouse: string }> {
     const persistedInfo = LegendQueryUserDataHelper.getLakehouseUserInfo(
       this.applicationStore.userDataService,
     );
@@ -1168,7 +1155,6 @@ export abstract class QueryEditorStore {
     let userEnvironment: string | undefined = persistedInfo?.env;
     const userWarehouse: string =
       persistedInfo?.snowflakeWarehouse ?? 'LAKEHOUSE_CONSUMER_DEFAULT_WH';
-    // 2. If no persisted environment, fetch from the server
     if (userEnvironment === undefined && this.lakehouseState) {
       try {
         const entitlementEnvs =
@@ -1179,7 +1165,6 @@ export abstract class QueryEditorStore {
         userEnvironment = entitlementEnvs.users
           .map((e) => e.lakehouseEnvironment)
           .at(0);
-        // Persist to local storage for future use
         LegendQueryUserDataHelper.persistLakehouseUserInfo(
           this.applicationStore.userDataService,
           {
@@ -1198,30 +1183,82 @@ export abstract class QueryEditorStore {
 
     if (userEnvironment === undefined) {
       throw new Error(
-        `Can't query data product '${dataProductPath}': unable to resolve lakehouse user environment. ` +
-          `Please ensure your lakehouse entitlements are configured.`,
+        `Unable to resolve lakehouse user environment. Please ensure your lakehouse entitlements are configured.`,
       );
     }
-    if (
-      isSnapshotVersion(gav.versionId) ||
-      gav.versionId === SNAPSHOT_VERSION_ALIAS
-    ) {
+    if (isSnapshot) {
       userEnvironment = decorateEnvWithRealm(
         userEnvironment,
         LakehouseEnvironmentType.PRODUCTION_PARALLEL,
       );
     }
-    const lakehouseRuntime = new LakehouseRuntime(
-      userEnvironment,
-      userWarehouse,
-    );
+    return { env: userEnvironment, warehouse: userWarehouse };
+  }
+
+  async createLakehousePackageableRuntime(
+    dataProductPath: string,
+    gav: {
+      groupId: string;
+      artifactId: string;
+      versionId: string;
+    },
+  ): Promise<PackageableRuntime> {
+    const isSnapshot =
+      isSnapshotVersion(gav.versionId) ||
+      gav.versionId === SNAPSHOT_VERSION_ALIAS;
+    const { env, warehouse } =
+      await this.resolveLakehouseEnvAndWarehouse(isSnapshot);
     const packageableRuntime = new PackageableRuntime(
       `${dataProductPath}_LakehouseRuntime`,
     );
-    packageableRuntime.runtimeValue = lakehouseRuntime;
+    packageableRuntime.runtimeValue = new LakehouseRuntime(env, warehouse);
     return packageableRuntime;
   }
 
+  async createOrGetDataSpaceLakehouseFallbackRuntime(
+    isSnapshot: boolean,
+  ): Promise<PackageableRuntime> {
+    const runtimePath = createPath(INTERNAL_ELEMENT_PATH, 'LakehouseRuntime');
+    const existing =
+      this.graphManagerState.graph.getNullableRuntime(runtimePath);
+    if (existing) {
+      return existing;
+    }
+    const { env, warehouse } =
+      await this.resolveLakehouseEnvAndWarehouse(isSnapshot);
+    const created = new PackageableRuntime('LakehouseRuntime');
+    created.runtimeValue = new LakehouseRuntime(env, warehouse);
+    this.graphManagerState.graph.addElement(created, INTERNAL_ELEMENT_PATH);
+    return created;
+  }
+
+  async attachDataSpaceFallbackRuntimes(
+    dataSpace: DataSpace,
+    dataSpaceAnalysisResult: DataSpaceAnalysisResult | undefined,
+    isSnapshot: boolean,
+  ): Promise<void> {
+    const contexts = dataSpace.executionContexts ?? [];
+    let sharedRuntime: PackageableRuntime | undefined;
+    for (const context of contexts) {
+      const analyticsContext =
+        dataSpaceAnalysisResult?.executionContextsIndex.get(context.name);
+
+      if (
+        context.mappingProvider === undefined ||
+        context.defaultRuntime !== undefined ||
+        (analyticsContext?.compatibleRuntimes.length ?? 0) !== 0
+      ) {
+        continue;
+      }
+      if (!sharedRuntime) {
+        sharedRuntime =
+          await this.createOrGetDataSpaceLakehouseFallbackRuntime(isSnapshot);
+      }
+      context.defaultRuntime =
+        PackageableElementExplicitReference.create(sharedRuntime);
+    }
+  }
+
   /**
    * Centralized method to build a data product query builder state.
    * Used by both the creator flow (new query from data product route/picker)
@@ -1281,7 +1318,10 @@ export abstract class QueryEditorStore {
           versionId,
         },
       );
-      this.graphManagerState.graph.addElement(packageableRuntime, '_internal_');
+      this.graphManagerState.graph.addElement(
+        packageableRuntime,
+        INTERNAL_ELEMENT_PATH,
+      );
     }
     // 6. Create query builder state
     const projectInfo = { groupId, artifactId, versionId };
@@ -2103,6 +2143,12 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         exec.dataSpacePath,
         this.graphManagerState.graph,
       );
+      await this.attachDataSpaceFallbackRuntimes(
+        dataSpace,
+        dataSpaceAnalysisResult,
+        isSnapshotVersion(queryInfo.versionId) ||
+          queryInfo.versionId === SNAPSHOT_VERSION_ALIAS,
+      );
       const mapping = queryInfo.mapping
         ? this.graphManagerState.graph.getMapping(queryInfo.mapping)
         : undefined;
@@ -2242,10 +2288,6 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
             `Execution context '${matchingExecutionContext.name}' in data space '${dataSpace.path}' sources its mapping from a data product access point group that does not exist.`,
           );
         }
-        const matchingExecutionContextRuntime = guaranteeNonNullable(
-          matchingExecutionContext.defaultRuntime,
-          `Execution context '${matchingExecutionContext.name}' does not have a default runtime`,
-        );
         const mappingModelCoverageAnalysisResult =
           matchingExecutionContextMapping
             ? dataSpaceAnalysisResult?.mappingToMappingCoverageResult?.get(
@@ -2256,15 +2298,17 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
           dataSpaceQueryBuilderState.explorerState.mappingModelCoverageAnalysisResult =
             mappingModelCoverageAnalysisResult;
         }
-        dataSpaceQueryBuilderState.executionContextState.setMapping(
-          matchingExecutionContextMapping,
-        );
+        if (matchingExecutionContextMapping) {
+          dataSpaceQueryBuilderState.executionContextState.setMapping(
+            matchingExecutionContextMapping,
+          );
+        }
+        const matchingExecutionContextRuntime =
+          matchingExecutionContext.defaultRuntime
+            ? new RuntimePointer(matchingExecutionContext.defaultRuntime)
+            : undefined;
         dataSpaceQueryBuilderState.executionContextState.setRuntimeValue(
-          new RuntimePointer(
-            PackageableElementExplicitReference.create(
-              matchingExecutionContextRuntime.value,
-            ),
-          ),
+          matchingExecutionContextRuntime,
         );
         return dataSpaceQueryBuilderState;
       } else {
@@ -2359,7 +2403,10 @@ export class ExistingQueryEditorStore extends QueryEditorStore {
         exec.ingestDefinitionPath,
         projectInfo,
       );
-      this.graphManagerState.graph.addElement(adhocRuntime, '_internal_');
+      this.graphManagerState.graph.addElement(
+        adhocRuntime,
+        INTERNAL_ELEMENT_PATH,
+      );
 
       // Tracked separately from the closure on `ingestQueryBuilderState` so
       // the swap callback can capture it directly without forming a self-

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,
@@ -452,6 +454,13 @@ export class DataProductQueryCreatorStore extends QueryEditorStore {
         `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,
       artifactId: queryableDataSpace.artifactId,

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

@@ -21,7 +21,11 @@ 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,
@@ -174,6 +178,12 @@ export class DataSpaceTemplateQueryCreatorStore extends BaseTemplateQueryCreator
         `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,

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 {
@@ -60,7 +63,7 @@ import {
   createViewSDLCProjectHandler,
 } from '../DataSpaceQueryBuilderHelper.js';
 import { type GeneratorFn } from '@finos/legend-shared';
-import { flowResult } from 'mobx';
+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 {
@@ -302,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,