@finos/legend-application-query 13.8.8 → 13.8.10

package/src/stores/BaseTemplateQueryCreatorStore.ts

@@ -0,0 +1,203 @@
+/**
+ * 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 Query,
+  type QuerySearchSpecification,
+  type RawLambda,
+  type ValueSpecification,
+  QueryProjectCoordinates,
+  extractElementNameFromPath,
+} from '@finos/legend-graph';
+import { type DepotServerClient } from '@finos/legend-server-depot';
+import {
+  assertErrorThrown,
+  LogEvent,
+  uuid,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import type { QueryBuilderState } from '@finos/legend-query-builder';
+import {
+  type ProjectGAVCoordinates,
+  parseGACoordinates,
+} from '@finos/legend-storage';
+import {
+  type QueryPersistConfiguration,
+  QueryEditorStore,
+} from './QueryEditorStore.js';
+import type { LegendQueryApplicationStore } from './LegendQueryBaseStore.js';
+import { createQueryClassTaggedValue } from '@finos/legend-extension-dsl-data-space/application';
+import { processQueryParameters } from '../components/utils/QueryParameterUtils.js';
+import { LEGEND_QUERY_APP_EVENT } from '../__lib__/LegendQueryEvent.js';
+
+/**
+ * Abstract base store for template/sample query creator flows.
+ */
+export abstract class BaseTemplateQueryCreatorStore extends QueryEditorStore {
+  readonly groupId: string;
+  readonly artifactId: string;
+  readonly versionId: string;
+  readonly templateQueryId: string;
+  templateQueryTitle?: string;
+  urlQueryParamValues: Record<string, string> | undefined;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+    groupId: string,
+    artifactId: string,
+    versionId: string,
+    templateQueryId: string,
+    urlQueryParamValues: Record<string, string> | undefined,
+  ) {
+    super(applicationStore, depotServerClient);
+    this.groupId = groupId;
+    this.artifactId = artifactId;
+    this.versionId = versionId;
+    this.templateQueryId = templateQueryId;
+    this.urlQueryParamValues = urlQueryParamValues;
+  }
+
+  getProjectInfo(): ProjectGAVCoordinates {
+    return {
+      groupId: this.groupId,
+      artifactId: this.artifactId,
+      versionId: this.versionId,
+    };
+  }
+
+  override *buildGraph(): GeneratorFn<void> {
+    // do nothing — graph is built inside initializeQueryBuilderState
+  }
+
+  /**
+   * Returns the entity path (DataSpace path or DataProduct path) used for
+   * display names in persist configuration.
+   */
+  abstract getEntityPath(): string;
+
+  /**
+   * Returns the tagged values to attach to the search specification.
+   */
+  abstract getSearchTaggedValues(): {
+    profile: string;
+    tag: string;
+    value: string;
+  }[];
+
+  /**
+   * Returns the tagged values to attach to the persisted query
+   */
+  abstract getQueryDecoratorTaggedValues():
+    | { profile: string; tag: string; value: string }[]
+    | undefined;
+
+  /**
+   * Resolves URL query parameters into a default parameter values map.
+   * Shared by both DataSpace and DataProduct template/sample query flows.
+   */
+  async resolveDefaultParameters(
+    query: RawLambda,
+  ): Promise<Map<string, ValueSpecification> | undefined> {
+    const processedQueryParamValues = processQueryParameters(
+      query,
+      undefined,
+      this.urlQueryParamValues,
+      this.graphManagerState,
+    );
+    if (processedQueryParamValues?.size) {
+      try {
+        return 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}`,
+        );
+      }
+    }
+    return undefined;
+  }
+
+  getPersistConfiguration(
+    lambda: RawLambda,
+    options?: { update: boolean | undefined },
+  ): QueryPersistConfiguration {
+    const entityPath = this.getEntityPath();
+    return {
+      defaultName: options?.update
+        ? `${extractElementNameFromPath(entityPath)}`
+        : `New Query for ${extractElementNameFromPath(entityPath)}[${this.templateQueryId}]`,
+      decorator: (query: Query): void => {
+        query.id = uuid();
+        query.groupId = this.groupId;
+        query.artifactId = this.artifactId;
+        query.versionId = this.versionId;
+        const decoratorTaggedValues = this.getQueryDecoratorTaggedValues();
+        if (decoratorTaggedValues) {
+          const taggedValues = decoratorTaggedValues.map((tv) => ({
+            profile: tv.profile,
+            tag: tv.tag,
+            value: tv.value,
+          }));
+          if (this.queryBuilderState?.sourceClass) {
+            taggedValues.push(
+              createQueryClassTaggedValue(
+                this.queryBuilderState.sourceClass.path,
+              ),
+            );
+          }
+          query.taggedValues = taggedValues;
+        } else if (this.queryBuilderState?.sourceClass) {
+          // Subclass handles tagged values directly (e.g., DataSpace only sets class tag)
+          query.taggedValues = [
+            createQueryClassTaggedValue(
+              this.queryBuilderState.sourceClass.path,
+            ),
+          ];
+        }
+      },
+    };
+  }
+
+  override decorateSearchSpecification(
+    val: QuerySearchSpecification,
+  ): QuerySearchSpecification {
+    const currentProjectCoordinates = new QueryProjectCoordinates();
+    currentProjectCoordinates.groupId = this.groupId;
+    currentProjectCoordinates.artifactId = this.artifactId;
+    val.projectCoordinates = [
+      currentProjectCoordinates,
+      ...Array.from(
+        this.graphManagerState.graph.dependencyManager.projectDependencyModelsIndex.keys(),
+      ).map((dependencyKey) => {
+        const { groupId, artifactId } = parseGACoordinates(dependencyKey);
+        const coordinates = new QueryProjectCoordinates();
+        coordinates.groupId = groupId;
+        coordinates.artifactId = artifactId;
+        return coordinates;
+      }),
+    ];
+    val.taggedValues = this.getSearchTaggedValues();
+    val.combineTaggedValuesCondition = true;
+    return val;
+  }
+
+  abstract override initializeQueryBuilderState(): Promise<QueryBuilderState>;
+}

package/src/stores/QueryEditorStore.ts

@@ -42,7 +42,7 @@ import {
 } from '@finos/legend-shared';
 import {
   type LightQuery,
-  NativeModelExecutionContext,
+  type NativeModelExecutionContext,
   type RawLambda,
   type Runtime,
   type Service,
@@ -83,6 +83,8 @@ import {
   V1_ModelAccessPointGroupInfo,
   DataProductAccessType,
   type DataProductAnalysisQueryResult,
+  LakehouseAccessPoint,
+  type Accessor,
 } from '@finos/legend-graph';
 import {
   generateExistingQueryEditorRoute,
@@ -128,8 +130,9 @@ import {
   QueryBuilderDataBrowserWorkflow,
   QueryBuilderActionConfig,
   QUERY_LOADER_DEFAULT_QUERY_SEARCH_LIMIT,
-  NativeModelDataProductExecutionState,
   ModelAccessPointDataProductExecutionState,
+  LakehouseDataProductExecutionState,
+  resolveDataProductAccessor,
 } from '@finos/legend-query-builder';
 import { LegendQueryUserDataHelper } from '../__lib__/LegendQueryUserDataHelper.js';
 import { LegendQueryTelemetryHelper } from '../__lib__/LegendQueryTelemetryHelper.js';
@@ -1045,24 +1048,53 @@ export abstract class QueryEditorStore {
   resolveDataProductExecutionState(
     dataProduct: DataProduct,
     accessId: string | undefined,
-  ): NativeModelExecutionContext | ModelAccessPointGroup {
+  ):
+    | NativeModelExecutionContext
+    | ModelAccessPointGroup
+    | LakehouseAccessPoint {
     // Search model access point groups
     const modelGroups = dataProduct.accessPointGroups.filter(
       filterByType(ModelAccessPointGroup),
     );
-    if (!modelGroups.length) {
-      throw new UnsupportedOperationError(
-        `Only Data Product with Model Access Points are currently supported in Query. ${dataProduct.path} does not have any Model Access Point Groups.`,
-      );
-    }
     if (accessId) {
       const matchingGroup = modelGroups.find((g) => g.id === accessId);
       if (matchingGroup) {
         return matchingGroup;
       }
     }
-    throw new UnsupportedOperationError(
-      `Can't resolve execution state for data product '${dataProduct.path}'${accessId ? ` with access ID '${accessId}'` : ''}`,
+    // Search native model execution contexts
+    const nativeAccess = dataProduct.nativeModelAccess;
+    if (nativeAccess && accessId) {
+      const matchingContext = nativeAccess.nativeModelExecutionContexts.find(
+        (ctx) => ctx.key === accessId,
+      );
+      if (matchingContext) {
+        return matchingContext;
+      }
+    }
+
+    // Fall back: prioritize first model access point group over native default
+    const firstGroup = modelGroups[0];
+    if (firstGroup) {
+      return firstGroup;
+    }
+
+    // Search lakehouse access points
+    const lakehouseAccessPoints = dataProduct.accessPointGroups
+      .flatMap((group) => group.accessPoints)
+      .filter(filterByType(LakehouseAccessPoint));
+    if (accessId) {
+      const matchingLakehouseAP = lakehouseAccessPoints.find(
+        (ap) => ap.id === accessId,
+      );
+      if (matchingLakehouseAP) {
+        return matchingLakehouseAP;
+      }
+    }
+
+    return guaranteeNonNullable(
+      modelGroups[0] ?? nativeAccess?.defaultExecutionContext,
+      `Can't resolve execution state for data product '${dataProduct.path}'${accessId ? ` with access ID '${accessId}'` : ''}. Data product must have model access point groups or native model access.`,
     );
   }
 
@@ -1089,7 +1121,7 @@ export abstract class QueryEditorStore {
     );
 
     let userEnvironment: string | undefined = persistedInfo?.env;
-    const userWarehouse: string | undefined =
+    const userWarehouse: string =
       persistedInfo?.snowflakeWarehouse ?? 'LAKEHOUSE_CONSUMER_DEFAULT_WH';
     // 2. If no persisted environment, fetch from the server
     if (userEnvironment === undefined && this.lakehouseState) {
@@ -1180,16 +1212,6 @@ export abstract class QueryEditorStore {
         accessId,
         artifact,
       );
-    // 3.5. Create a LakehouseRuntime and add it to the graph
-    const packageableRuntime = await this.createLakehousePackageableRuntime(
-      dataProductPath,
-      {
-        groupId,
-        artifactId,
-        versionId,
-      },
-    );
-    this.graphManagerState.graph.addElement(packageableRuntime, '_internal_');
     // 4. Get the data product from the built graph
     const dataProduct =
       this.graphManagerState.graph.getDataProduct(dataProductPath);
@@ -1199,6 +1221,23 @@ export abstract class QueryEditorStore {
       accessId,
     );
 
+    // 5.5. Create LakehouseRuntime if the resolved state is a model access
+    // point group or a lakehouse access point
+    let packageableRuntime: PackageableRuntime | undefined;
+    if (
+      resolvedState instanceof ModelAccessPointGroup ||
+      resolvedState instanceof LakehouseAccessPoint
+    ) {
+      packageableRuntime = await this.createLakehousePackageableRuntime(
+        dataProductPath,
+        {
+          groupId,
+          artifactId,
+          versionId,
+        },
+      );
+      this.graphManagerState.graph.addElement(packageableRuntime, '_internal_');
+    }
     // 6. Create query builder state
     const projectInfo = { groupId, artifactId, versionId };
     const sourceInfo = {
@@ -1219,6 +1258,7 @@ export abstract class QueryEditorStore {
       this.depotServerClient,
       projectInfo,
       onDataProductChange,
+      (path, gav) => this.createLakehousePackageableRuntime(path, gav),
       productSelectorState ??
         new DataProductSelectorState(
           this.depotServerClient,
@@ -1226,44 +1266,58 @@ export abstract class QueryEditorStore {
         ),
       onLegacyDataSpaceChange,
       undefined,
-      undefined,
       this.applicationStore.config.options.queryBuilderConfig,
       sourceInfo,
     );
-    // Pass pre-resolved state to avoid double-resolution
-    queryBuilderState.initWithDataProduct(
-      dataProduct,
-      undefined,
-      resolvedState,
-    );
 
-    // 7. Wire in mapping coverage result
-    const mappingCoverageResult =
-      dataProductAnalysisResult.dataProductAnalysis.mappingToMappingCoverageResult?.get(
-        dataProductAnalysisResult.targetMappingPath,
+    if (
+      dataProductAnalysisResult.dataProductAnalysis
+        .mappingToMappingCoverageResult
+    ) {
+      queryBuilderState.mappingToMappingCoverageResult =
+        dataProductAnalysisResult.dataProductAnalysis.mappingToMappingCoverageResult;
+    }
+
+    let accessor: Accessor | undefined;
+    if (resolvedState instanceof LakehouseAccessPoint) {
+      accessor = resolveDataProductAccessor(
+        dataProduct,
+        resolvedState,
+        this.graphManagerState.graph,
+        artifact,
+        undefined,
       );
-    if (mappingCoverageResult) {
-      queryBuilderState.explorerState.mappingModelCoverageAnalysisResult =
-        mappingCoverageResult;
     }
+    // Pass pre-resolved state to avoid double-resolution
+    queryBuilderState.initWithDataProduct(dataProduct, accessor, resolvedState);
 
-    // init
-    const execValue = dataProductAnalysisResult.targetExecState;
-    queryBuilderState.executionState =
-      execValue instanceof NativeModelExecutionContext
-        ? new NativeModelDataProductExecutionState(execValue, queryBuilderState)
-        : new ModelAccessPointDataProductExecutionState(
-            execValue,
-            queryBuilderState,
-          ).withAdhocRuntime();
-    if (queryBuilderState.executionState.mapping) {
-      queryBuilderState.changeMapping(queryBuilderState.executionState.mapping);
+    // 8. Wire in lakehouse runtime and adhoc-runtime flag for MODEL or LAKEHOUSE mode
+    if (
+      queryBuilderState.executionState instanceof
+      ModelAccessPointDataProductExecutionState
+    ) {
+      queryBuilderState.executionState.withAdhocRuntime();
+      if (packageableRuntime) {
+        queryBuilderState.changeRuntime(
+          new RuntimePointer(
+            PackageableElementExplicitReference.create(packageableRuntime),
+          ),
+        );
+      }
+    } else if (
+      queryBuilderState.executionState instanceof
+      LakehouseDataProductExecutionState
+    ) {
+      queryBuilderState.executionState.withAdhocRuntime();
+      if (packageableRuntime) {
+        queryBuilderState.executionState.selectedRuntime = packageableRuntime;
+        queryBuilderState.changeRuntime(
+          new RuntimePointer(
+            PackageableElementExplicitReference.create(packageableRuntime),
+          ),
+        );
+      }
     }
-    queryBuilderState.changeRuntime(
-      new RuntimePointer(
-        PackageableElementExplicitReference.create(packageableRuntime),
-      ),
-    );
     return queryBuilderState;
   }
 }

package/src/stores/data-product/DataProductSampleQueryCreatorStore.ts

@@ -0,0 +1,135 @@
+/**
+ * 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 { DataProductAccessType } from '@finos/legend-graph';
+import { type DepotServerClient } from '@finos/legend-server-depot';
+import { IllegalStateError, guaranteeNonNullable } from '@finos/legend-shared';
+import type { QueryBuilderState } from '@finos/legend-query-builder';
+import type { LegendQueryApplicationStore } from '../LegendQueryBaseStore.js';
+import { generateDataProductSampleQueryRoute } from '../../__lib__/LegendQueryNavigation.js';
+import { DataProductSelectorState } from '../data-space/DataProductSelectorState.js';
+import { createQueryDataProductTaggedValue } from '../../components/data-product/QueryDataProductUtil.js';
+import { BaseTemplateQueryCreatorStore } from '../BaseTemplateQueryCreatorStore.js';
+
+export class DataProductSampleQueryCreatorStore extends BaseTemplateQueryCreatorStore {
+  readonly dataProductPath: string;
+
+  constructor(
+    applicationStore: LegendQueryApplicationStore,
+    depotServerClient: DepotServerClient,
+    groupId: string,
+    artifactId: string,
+    versionId: string,
+    dataProductPath: string,
+    sampleQueryId: string,
+    urlQueryParamValues: Record<string, string> | undefined,
+  ) {
+    super(
+      applicationStore,
+      depotServerClient,
+      groupId,
+      artifactId,
+      versionId,
+      sampleQueryId,
+      urlQueryParamValues,
+    );
+    this.dataProductPath = dataProductPath;
+  }
+
+  override getEditorRoute(): string {
+    return generateDataProductSampleQueryRoute(
+      this.groupId,
+      this.artifactId,
+      this.versionId,
+      this.dataProductPath,
+      this.templateQueryId,
+    );
+  }
+
+  override getEntityPath(): string {
+    return this.dataProductPath;
+  }
+
+  override getSearchTaggedValues(): {
+    profile: string;
+    tag: string;
+    value: string;
+  }[] {
+    return [createQueryDataProductTaggedValue(this.dataProductPath)];
+  }
+
+  override getQueryDecoratorTaggedValues():
+    | { profile: string; tag: string; value: string }[]
+    | undefined {
+    return [createQueryDataProductTaggedValue(this.dataProductPath)];
+  }
+
+  async initializeQueryBuilderState(): Promise<QueryBuilderState> {
+    const artifact = await this.fetchDataProductArtifact(
+      this.groupId,
+      this.artifactId,
+      this.versionId,
+      this.dataProductPath,
+    );
+
+    const nativeModelAccess = guaranteeNonNullable(
+      artifact.nativeModelAccess,
+      `Data product '${this.dataProductPath}' does not have native model access`,
+    );
+    const sampleQuery = nativeModelAccess.sampleQueries?.find(
+      (sq) => sq.info.id === this.templateQueryId,
+    );
+    if (!sampleQuery) {
+      throw new IllegalStateError(
+        `Can't find sample query with id '${this.templateQueryId}' in data product '${this.dataProductPath}'`,
+      );
+    }
+    this.templateQueryTitle = sampleQuery.title;
+
+    const accessId =
+      sampleQuery.info.executionContextKey ??
+      nativeModelAccess.defaultExecutionContext;
+
+    const queryBuilderState = await this.buildDataProductQueryBuilderState(
+      this.groupId,
+      this.artifactId,
+      this.versionId,
+      this.dataProductPath,
+      artifact,
+      accessId,
+      DataProductAccessType.NATIVE,
+      async () => {
+        this.applicationStore.notificationService.notifyWarning(
+          `Can't switch data product while visiting a sample query`,
+        );
+      },
+      undefined,
+      new DataProductSelectorState(
+        this.depotServerClient,
+        this.applicationStore,
+      ),
+    );
+
+    const query = await this.graphManagerState.graphManager.pureCodeToLambda(
+      sampleQuery.info.query,
+    );
+
+    const defaultParameters = await this.resolveDefaultParameters(query);
+    queryBuilderState.initializeWithQuery(query, defaultParameters);
+
+    return queryBuilderState;
+  }
+}

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

@@ -33,6 +33,19 @@ export const resolveDefaultDataProductAccessType = (
       id: modelAcessGroup.id,
     };
   }
+
+  // start on ModelAPG if it exists, then fallback to native access
+  const nativeAccess = dataProductArtifact.nativeModelAccess;
+  if (nativeAccess) {
+    const defaultKey = nativeAccess.defaultExecutionContext;
+    const native =
+      nativeAccess.nativeModelExecutionContexts.find(
+        (ctx) => ctx.key === defaultKey,
+      ) ?? nativeAccess.nativeModelExecutionContexts[0];
+    if (native) {
+      return { type: DataProductAccessType.NATIVE, id: native.key };
+    }
+  }
   throw new Error(
     `Data Product not supported for querying on legend query ${dataProductArtifact.dataProduct.path}. Must contain a model access point or native model access.`,
   );