@finos/legend-graph 32.3.38 → 32.4.0

package/src/graph-manager/AbstractPureGraphManager.ts

@@ -63,7 +63,11 @@ import {
   ActionState,
 } from '@finos/legend-shared';
 import type { LightQuery, Query, QueryInfo } from './action/query/Query.js';
-import type { EntitiesWithOrigin, Entity } from '@finos/legend-storage';
+import type {
+  EntitiesWithOrigin,
+  Entity,
+  ProjectGAVCoordinates,
+} from '@finos/legend-storage';
 import type { QuerySearchSpecification } from './action/query/QuerySearchSpecification.js';
 import type { ExternalFormatDescription } from './action/externalFormat/ExternalFormatDescription.js';
 import type { ConfigurationProperty } from '../graph/metamodel/pure/packageableElements/fileGeneration/ConfigurationProperty.js';
@@ -124,7 +128,9 @@ import type {
   RawLineageModel,
 } from '../graph/metamodel/pure/lineage/LineageModel.js';
 import type { DeployProjectResponse } from './action/dev-metadata/DeployProjectResponse.js';
+import type { DataProductAnalysisQueryResult } from './action/analytics/data-product/DataProductAnalysis.js';
 import type { MetadataRequestOptions } from './action/dev-metadata/MetadataRequestOptions.js';
+import type { DataProductAccessType } from '../graph/metamodel/pure/dataProduct/DataProduct.js';
 
 export interface TEMPORARY__EngineSetupConfig {
   env: string;
@@ -177,6 +183,11 @@ export interface ExecutionOptions {
    * instead of providing in separate input property
    */
   forceFromExpression?: boolean | undefined;
+  /**
+   * Additional elements needed for execution that are not part of the immediate graph.
+   * These will be included alongside the graph data when sending the execution request.
+   */
+  floatingExecutionElements?: PackageableElement[] | undefined;
 }
 
 export interface ServiceRegistrationOptions {
@@ -738,6 +749,29 @@ export abstract class AbstractPureGraphManager {
     graphData: GraphData,
   ): Promise<DatasetEntitlementReport[]>;
 
+  abstract analyzeDataProductAndBuildMinimalGraph(
+    dataProductPath: string,
+    cacheRetriever: () => Promise<PlainObject>,
+    pureGraph: PureModel,
+    accessPointId: string,
+    dataProductAccessType: DataProductAccessType,
+    projectInfo: ProjectGAVCoordinates,
+    functionEntitiesRetriever?: () => Promise<
+      [PlainObject<Entity>[], PlainObject<Entity>[]]
+    >,
+    graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult>;
+
+  abstract buildDataProductAnalysis(
+    artifact: object,
+    dataProductPath: string,
+    pureGraph: PureModel,
+    accessPointId: string,
+    dataProductAccessType: DataProductAccessType,
+    projectInfo: ProjectGAVCoordinates,
+    graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult>;
+
   /**
    * TODO: Move these to store relational extension
    *

package/src/graph-manager/action/analytics/data-product/DataProductAnalysis.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 type {
+  ModelAccessPointGroup,
+  NativeModelExecutionContext,
+} from '../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
+import type { MappingModelCoverageAnalysisResult } from '../MappingModelCoverageAnalysis.js';
+
+export class DataProductAnalysis {
+  path!: string;
+  title: string | undefined;
+  description: string | undefined;
+  mappingToMappingCoverageResult?: Map<
+    string,
+    MappingModelCoverageAnalysisResult
+  >;
+}
+
+export class DataProductAnalysisQueryResult {
+  targetMappingPath: string;
+  dataProductAnalysis: DataProductAnalysis;
+  targetExecState: NativeModelExecutionContext | ModelAccessPointGroup;
+
+  constructor(
+    targetMappingPath: string,
+    dataProductAnalysis: DataProductAnalysis,
+    targetExecState: NativeModelExecutionContext | ModelAccessPointGroup,
+  ) {
+    this.targetMappingPath = targetMappingPath;
+    this.dataProductAnalysis = dataProductAnalysis;
+    this.targetExecState = targetExecState;
+  }
+}

package/src/graph-manager/action/query/Query.ts

@@ -46,9 +46,16 @@ export class QueryDataSpaceExecutionContext extends QueryExecutionContext {
   executionKey: string | undefined;
 }
 
-export class QueryDataProductExecutionContext extends QueryExecutionContext {
+export abstract class QueryDataProductExecutionContext extends QueryExecutionContext {
   dataProductPath!: string;
-  executionKey: string | undefined;
+}
+
+export class QueryDataProductNativeExecutionContext extends QueryDataProductExecutionContext {
+  executionKey!: string;
+}
+
+export class QueryDataProductModelAccessExecutionContext extends QueryDataProductExecutionContext {
+  accessPointGroupId!: string;
 }
 
 export interface QueryGridConfig {
@@ -162,7 +169,12 @@ export class QueryDataSpaceExecutionContextInfo extends QueryExecutionContextInf
 
 export class QueryDataProductNativeExecutionContextInfo extends QueryExecutionContextInfo {
   dataProductPath!: string;
-  executionKey: string | undefined;
+  executionKey!: string;
+}
+
+export class QueryDataProductModelAccessExecutionContextInfo extends QueryExecutionContextInfo {
+  dataProductPath!: string;
+  accessPointGroupId!: string;
 }
 
 export interface QueryInfo {

package/src/graph-manager/helpers/DataProductHelper.ts

@@ -102,7 +102,7 @@ export const resolveUsableDataProductClasses = (
     );
   }
   if (elements?.length) {
-    return compatibleClasses.filter((_class) => {
+    const filtered = compatibleClasses.filter((_class) => {
       const _classElements = elements
         .filter((e) => matchesDataElement(_class, e.element.value))
         // we sort because we respect the closest definition to the element.
@@ -114,6 +114,7 @@ export const resolveUsableDataProductClasses = (
       }
       return !_classElements[0]?.exclude;
     });
+    return filtered;
   }
   return compatibleClasses;
 };

package/src/graph-manager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -147,6 +147,7 @@ import { V1_GenerationSpecification } from './model/packageableElements/generati
 import { V1_Mapping } from './model/packageableElements/mapping/V1_Mapping.js';
 import { V1_ConcreteFunctionDefinition } from './model/packageableElements/function/V1_ConcreteFunctionDefinition.js';
 import { V1_PureModelContextComposite } from './model/context/V1_PureModelContextComposite.js';
+import { V1_PureModelContextCombination } from './model/context/V1_PureModelContextCombination.js';
 import { V1_LegendSDLC } from './model/context/V1_SDLC.js';
 import { V1_Protocol } from './model/V1_Protocol.js';
 import type { V1_PureModelContext } from './model/context/V1_PureModelContext.js';
@@ -211,6 +212,7 @@ import { V1_buildExecutionResult } from './engine/execution/V1_ExecutionHelper.j
 import {
   type Entity,
   type EntitiesWithOrigin,
+  type ProjectGAVCoordinates,
   ENTITY_PATH_DELIMITER,
 } from '@finos/legend-storage';
 import {
@@ -219,7 +221,10 @@ import {
   PureClientVersion,
   SystemGraphBuilderError,
 } from '../../../../graph-manager/GraphManagerUtils.js';
-import { PackageableElementReference } from '../../../../graph/metamodel/pure/packageableElements/PackageableElementReference.js';
+import {
+  PackageableElementExplicitReference,
+  PackageableElementReference,
+} from '../../../../graph/metamodel/pure/packageableElements/PackageableElementReference.js';
 import type { GraphManagerPluginManager } from '../../../GraphManagerPluginManager.js';
 import type { QuerySearchSpecification } from '../../../../graph-manager/action/query/QuerySearchSpecification.js';
 import type { ExternalFormatDescription } from '../../../../graph-manager/action/externalFormat/ExternalFormatDescription.js';
@@ -363,6 +368,22 @@ import {
   V1_createGenericTypeWithElementPath,
 } from './helpers/V1_DomainHelper.js';
 import { V1_DataProduct } from './model/packageableElements/dataProduct/V1_DataProduct.js';
+import {
+  V1_DataProductArtifact,
+  V1_ModelAccessPointGroupInfo,
+  type V1_NativeModelExecutionContextInfo,
+  type V1_MappingGenerationInfo,
+} from './lakehouse/deploy/V1_DataProductArtifact.js';
+import {
+  DataProductAnalysisQueryResult,
+  DataProductAnalysis,
+} from '../../../action/analytics/data-product/DataProductAnalysis.js';
+import {
+  DataProductAccessType,
+  ModelAccessPointGroup,
+  NativeModelAccess,
+  NativeModelExecutionContext,
+} from '../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
 import { V1_MemSQLFunction } from './model/packageableElements/function/V1_MemSQLFunction.js';
 import { LineageModel } from '../../../../graph/metamodel/pure/lineage/LineageModel.js';
 import {
@@ -2696,18 +2717,29 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
-  public createExecutionInput = (
+  public createExecutionInput = async (
     graph: PureModel,
     mapping: Mapping | undefined,
     lambda: RawLambda,
     runtime: Runtime | undefined,
     clientVersion: string | undefined,
     options?: ExecutionOptions,
-  ): V1_ExecuteInput =>
-    this.createExecutionInputWithPureModelContext(
-      graph.origin
-        ? this.buildPureModelSDLCPointer(graph.origin, undefined)
-        : this.getFullGraphModelData(graph),
+  ): Promise<V1_ExecuteInput> => {
+    let context: V1_PureModelContext = graph.origin
+      ? this.buildPureModelSDLCPointer(graph.origin, undefined)
+      : this.getFullGraphModelData(graph);
+    if (
+      options?.floatingExecutionElements &&
+      options.floatingExecutionElements.length > 0
+    ) {
+      const floatingData = new V1_PureModelContextData();
+      floatingData.elements = options.floatingExecutionElements.map((element) =>
+        this.elementToProtocol(element),
+      );
+      context = new V1_PureModelContextCombination([context, floatingData]);
+    }
+    return this.createExecutionInputWithPureModelContext(
+      context,
       mapping,
       lambda,
       runtime,
@@ -2715,15 +2747,16 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       new V1_ExecuteInput(),
       options,
     );
+  };
 
-  public createLineageInput = (
+  public createLineageInput = async (
     graph: PureModel,
     mapping: Mapping | undefined,
     lambda: RawLambda,
     runtime: Runtime | undefined,
     clientVersion: string | undefined,
-  ): V1_LineageInput => {
-    const executionInput = this.createExecutionInput(
+  ): Promise<V1_LineageInput> => {
+    const executionInput = await this.createExecutionInput(
       graph,
       mapping,
       lambda,
@@ -2933,13 +2966,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   }
 
   async _runQuery(
-    createV1ExecuteInputFunc: () => V1_ExecuteInput,
+    createV1ExecuteInputFunc: () => V1_ExecuteInput | Promise<V1_ExecuteInput>,
     options?: ExecutionOptions,
     _report?: GraphManagerOperationReport,
   ): Promise<ExecutionResultWithMetadata> {
     const report = _report ?? createGraphManagerOperationReport();
     const stopWatch = new StopWatch();
-    const input = createV1ExecuteInputFunc();
+    const input = await createV1ExecuteInputFunc();
     stopWatch.record(GRAPH_MANAGER_EVENT.V1_ENGINE_OPERATION_INPUT__SUCCESS);
 
     const result = await this.engine.runQuery(input, options);
@@ -2975,7 +3008,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const report = _report ?? createGraphManagerOperationReport();
     const stopWatch = new StopWatch();
 
-    const input = this.createExecutionInput(
+    const input = await this.createExecutionInput(
       graph,
       mapping,
       lambda,
@@ -3082,7 +3115,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const report = _report ?? createGraphManagerOperationReport();
     const stopWatch = new StopWatch();
 
-    const input = this.createExecutionInput(
+    const input = await this.createExecutionInput(
       graph,
       mapping,
       lambda,
@@ -3116,7 +3149,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const report = _report ?? createGraphManagerOperationReport();
     const stopWatch = new StopWatch();
 
-    const input = this.createExecutionInput(
+    const input = await this.createExecutionInput(
       graph,
       mapping,
       lambda,
@@ -3748,6 +3781,193 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  async analyzeDataProductAndBuildMinimalGraph(
+    dataProductPath: string,
+    cacheRetriever: () => Promise<PlainObject>,
+    pureGraph: PureModel,
+    accessPointId: string,
+    dataProductAccessType: DataProductAccessType,
+    projectInfo: ProjectGAVCoordinates,
+    functionEntitiesRetriever?: () => Promise<
+      [PlainObject<Entity>[], PlainObject<Entity>[]]
+    >,
+    graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult> {
+    // Fetch the data product artifact from cache
+    const artifactJson = await cacheRetriever();
+    const artifact =
+      V1_DataProductArtifact.serialization.fromJson(artifactJson);
+
+    return this.buildDataProductAnalysis(
+      artifact,
+      dataProductPath,
+      pureGraph,
+      accessPointId,
+      dataProductAccessType,
+      projectInfo,
+      graphReport,
+    );
+  }
+
+  async buildDataProductAnalysis(
+    artifact: V1_DataProductArtifact,
+    dataProductPath: string,
+    pureGraph: PureModel,
+    accessPointId: string,
+    dataProductAccessType: DataProductAccessType,
+    projectInfo: ProjectGAVCoordinates,
+    graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult> {
+    // Collect all mapping generation infos from model access point groups and native model access
+    const allMappingGenInfos = new Map<string, V1_MappingGenerationInfo>();
+
+    const modelAccessPointGroups = artifact.accessPointGroups.filter(
+      (group): group is V1_ModelAccessPointGroupInfo =>
+        group instanceof V1_ModelAccessPointGroupInfo,
+    );
+    for (const group of modelAccessPointGroups) {
+      allMappingGenInfos.set(
+        group.mappingGeneration.path,
+        group.mappingGeneration,
+      );
+    }
+
+    if (artifact.nativeModelAccess?.mappingGenerations) {
+      for (const [path, genInfo] of artifact.nativeModelAccess
+        .mappingGenerations) {
+        if (!allMappingGenInfos.has(path)) {
+          allMappingGenInfos.set(path, genInfo);
+        }
+      }
+    }
+
+    // Resolve mapping path from accessPointId and dataProductAccessType
+    let mappingPath: string | undefined;
+    let accessGroup:
+      | V1_ModelAccessPointGroupInfo
+      | V1_NativeModelExecutionContextInfo
+      | undefined = undefined;
+    if (dataProductAccessType === DataProductAccessType.MODEL) {
+      const group = modelAccessPointGroups.find((g) => g.id === accessPointId);
+      if (group) {
+        mappingPath = group.mappingGeneration.path;
+        accessGroup = group;
+      }
+    } else if (dataProductAccessType === DataProductAccessType.NATIVE) {
+      const nativeCtx =
+        artifact.nativeModelAccess?.nativeModelExecutionContexts.find(
+          (ctx) => ctx.key === accessPointId,
+        );
+      if (nativeCtx) {
+        mappingPath = nativeCtx.mapping;
+        accessGroup = nativeCtx;
+      }
+    }
+
+    if (!mappingPath) {
+      throw new Error(
+        `Can't resolve mapping path for access point '${accessPointId}' (type: ${dataProductAccessType}) in data product '${dataProductPath}'`,
+      );
+    }
+    if (!accessGroup) {
+      throw new Error(
+        `Can't resolve access group for access point '${accessPointId}' (type: ${dataProductAccessType}) in data product '${dataProductPath}'`,
+      );
+    }
+    // Build the minimal graph using ONLY the elements from the resolved mapping
+    const resolvedMappingGenInfo = mappingPath
+      ? allMappingGenInfos.get(mappingPath)
+      : undefined;
+
+    if (!resolvedMappingGenInfo) {
+      throw new Error(
+        `Can't find mapping generation info for access point '${accessPointId}' (type: ${dataProductAccessType}) in data product '${dataProductPath}'`,
+      );
+    }
+
+    // Create a dummy mapping for the resolved mapping path
+    const dummyMapping = new V1_Mapping();
+    dummyMapping.package = extractPackagePathFromPath(mappingPath) ?? '';
+    dummyMapping.name = extractElementNameFromPath(mappingPath);
+
+    // Create a dummy data product element
+    const dummyDataProduct = new V1_DataProduct();
+    dummyDataProduct.package =
+      extractPackagePathFromPath(dataProductPath) ?? '';
+    dummyDataProduct.name = extractElementNameFromPath(dataProductPath);
+    dummyDataProduct.title = artifact.dataProduct.title;
+    dummyDataProduct.description = artifact.dataProduct.description;
+    // Build the minimal graph from the resolved mapping's model elements + dummy mapping + dummy data product
+    const graphEntities = resolvedMappingGenInfo.model.elements
+      .concat([dummyMapping])
+      .concat(dummyDataProduct)
+      .filter((el) => !pureGraph.getNullableElement(el.path, false))
+      .map((el) => this.elementProtocolToEntity(el));
+    await this.buildGraph(
+      pureGraph,
+      graphEntities,
+      ActionState.create(),
+      {
+        origin: new LegendSDLC(
+          projectInfo.groupId,
+          projectInfo.artifactId,
+          projectInfo.versionId,
+        ),
+      },
+      graphReport,
+    );
+
+    const data = pureGraph.getDataProduct(dataProductPath);
+    // build access point group
+    let exec: ModelAccessPointGroup | NativeModelExecutionContext;
+    if (accessGroup instanceof V1_ModelAccessPointGroupInfo) {
+      const group = new ModelAccessPointGroup();
+      group.id = accessGroup.id;
+      data.accessPointGroups = [group];
+      group.mapping = PackageableElementExplicitReference.create(
+        pureGraph.getMapping(mappingPath),
+      );
+      exec = group;
+    } else {
+      const nativeAccess = new NativeModelExecutionContext();
+      nativeAccess.key = accessGroup.key;
+      nativeAccess.mapping = PackageableElementExplicitReference.create(
+        pureGraph.getMapping(mappingPath),
+      );
+      const na = new NativeModelAccess();
+      na.nativeModelExecutionContexts = [nativeAccess];
+      data.nativeModelAccess = na;
+      exec = nativeAccess;
+    }
+
+    // Build MappingModelCoverageAnalysisResult for the resolved mapping only
+    const mappingToMappingCoverageResult = new Map<
+      string,
+      MappingModelCoverageAnalysisResult
+    >();
+    const v1Result = new V1_MappingModelCoverageAnalysisResult();
+    v1Result.mappedEntities = resolvedMappingGenInfo.mappedEntities;
+    v1Result.model = resolvedMappingGenInfo.model;
+    mappingToMappingCoverageResult.set(
+      mappingPath,
+      V1_buildModelCoverageAnalysisResult(
+        v1Result,
+        this,
+        pureGraph.getMapping(mappingPath),
+        resolvedMappingGenInfo.model,
+      ),
+    );
+
+    // Build the analysis result
+    const result = new DataProductAnalysis();
+    result.path = dataProductPath;
+    result.title = artifact.dataProduct.title;
+    result.description = artifact.dataProduct.description;
+    result.mappingToMappingCoverageResult = mappingToMappingCoverageResult;
+
+    return new DataProductAnalysisQueryResult(mappingPath, result, exec);
+  }
+
   async buildDatabase(input: DatabaseBuilderInput): Promise<Entity[]> {
     const dbBuilderInput = new V1_DatabaseBuilderInput();
     dbBuilderInput.connection = V1_transformRelationalDatabaseConnection(
@@ -4764,7 +4984,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     const report = _report ?? createGraphManagerOperationReport();
     const stopWatch = new StopWatch();
 
-    const input = this.createLineageInput(
+    const input = await this.createLineageInput(
       graph,
       mapping,
       lambda,

package/src/graph-manager/protocol/pure/v1/engine/V1_EngineHelper.ts

@@ -32,7 +32,10 @@ import {
   type QueryExecutionContextInfo,
   QueryExplicitExecutionContextInfo,
   QueryDataSpaceExecutionContextInfo,
-  QueryDataProductExecutionContext,
+  QueryDataProductNativeExecutionContext,
+  QueryDataProductModelAccessExecutionContext,
+  QueryDataProductNativeExecutionContextInfo,
+  QueryDataProductModelAccessExecutionContextInfo,
 } from '../../../../../graph-manager/action/query/Query.js';
 import {
   type V1_LightQuery,
@@ -41,7 +44,8 @@ import {
   V1_QueryExplicitExecutionContext,
   V1_QueryDataSpaceExecutionContext,
   type V1_QueryExecutionContext,
-  V1_QueryDataProductExecutionContext,
+  V1_DataProductNativeExecutionContext,
+  V1_DataProductModelAccessExecutionContext,
 } from './query/V1_Query.js';
 import type { PureModel } from '../../../../../graph/PureModel.js';
 import { DEPRECATED__ServiceTestResult } from '../../../../../graph-manager/action/service/DEPRECATED__ServiceTestResult.js';
@@ -202,6 +206,20 @@ export const V1_buildExecutionContext = (
     exec.dataSpacePath = protocolExecContext.dataSpacePath;
     exec.executionKey = protocolExecContext.executionKey;
     return exec;
+  } else if (
+    protocolExecContext instanceof V1_DataProductNativeExecutionContext
+  ) {
+    const exec = new QueryDataProductNativeExecutionContext();
+    exec.dataProductPath = protocolExecContext.dataProductPath;
+    exec.executionKey = protocolExecContext.executionKey;
+    return exec;
+  } else if (
+    protocolExecContext instanceof V1_DataProductModelAccessExecutionContext
+  ) {
+    const exec = new QueryDataProductModelAccessExecutionContext();
+    exec.dataProductPath = protocolExecContext.dataProductPath;
+    exec.accessPointGroupId = protocolExecContext.accessPointGroupId;
+    return exec;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
 };
@@ -233,6 +251,18 @@ export const V1_buildExecutionContextInfo = (
     exec.dataSpacePath = v1_execContext.dataSpacePath;
     exec.executionKey = v1_execContext.executionKey;
     return exec;
+  } else if (v1_execContext instanceof V1_DataProductNativeExecutionContext) {
+    const exec = new QueryDataProductNativeExecutionContextInfo();
+    exec.dataProductPath = v1_execContext.dataProductPath;
+    exec.executionKey = v1_execContext.executionKey;
+    return exec;
+  } else if (
+    v1_execContext instanceof V1_DataProductModelAccessExecutionContext
+  ) {
+    const exec = new QueryDataProductModelAccessExecutionContextInfo();
+    exec.dataProductPath = v1_execContext.dataProductPath;
+    exec.accessPointGroupId = v1_execContext.accessPointGroupId;
+    return exec;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
 };
@@ -340,11 +370,18 @@ export const V1_transformQueryExecutionContext = (
     protocol.dataSpacePath = execContext.dataSpacePath;
     protocol.executionKey = execContext.executionKey;
     return protocol;
-  } else if (execContext instanceof QueryDataProductExecutionContext) {
-    const protocol = new V1_QueryDataProductExecutionContext();
+  } else if (execContext instanceof QueryDataProductNativeExecutionContext) {
+    const protocol = new V1_DataProductNativeExecutionContext();
     protocol.dataProductPath = execContext.dataProductPath;
     protocol.executionKey = execContext.executionKey;
     return protocol;
+  } else if (
+    execContext instanceof QueryDataProductModelAccessExecutionContext
+  ) {
+    const protocol = new V1_DataProductModelAccessExecutionContext();
+    protocol.dataProductPath = execContext.dataProductPath;
+    protocol.accessPointGroupId = execContext.accessPointGroupId;
+    return protocol;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
 };

package/src/graph-manager/protocol/pure/v1/engine/query/V1_Query.ts

@@ -65,7 +65,8 @@ export class V1_QueryExecutionContext {}
 export enum V1_QueryExecutionContextType {
   QUERY_EXPLICIT_EXECUTION_CONTEXT = 'explicitExecutionContext',
   QUERY_DATASAPCE_EXECUTION_CONTEXT = 'dataSpaceExecutionContext',
-  QUERY_DATAPRODUCT_EXECUTION_CONTEXT = 'dataProductExecutionContext',
+  QUERY_DATAPRODUCT_NATIVE_EXECUTION_CONTEXT = 'dataProductNativeExecutionContext',
+  QUERY_DATAPRODUCT_MODEL_ACCESS_EXECUTION_CONTEXT = 'dataProductModelAccessExecutionContext',
 }
 
 export class V1_QueryExplicitExecutionContext extends V1_QueryExecutionContext {
@@ -104,17 +105,37 @@ export class V1_QueryDataSpaceExecutionContext extends V1_QueryExecutionContext
   );
 }
 
-export class V1_QueryDataProductExecutionContext extends V1_QueryExecutionContext {
+export abstract class V1_QueryDataProductExecutionContext extends V1_QueryExecutionContext {
   dataProductPath!: string;
-  executionKey: string | undefined;
+}
+
+export class V1_DataProductNativeExecutionContext extends V1_QueryDataProductExecutionContext {
+  executionKey!: string;
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_QueryDataProductExecutionContext, {
+    createModelSchema(V1_DataProductNativeExecutionContext, {
       _type: usingConstantValueSchema(
-        V1_QueryExecutionContextType.QUERY_DATAPRODUCT_EXECUTION_CONTEXT,
+        V1_QueryExecutionContextType.QUERY_DATAPRODUCT_NATIVE_EXECUTION_CONTEXT,
       ),
       dataProductPath: primitive(),
-      executionKey: optional(primitive()),
+      executionKey: primitive(),
+    }),
+    {
+      deserializeNullAsUndefined: true,
+    },
+  );
+}
+
+export class V1_DataProductModelAccessExecutionContext extends V1_QueryDataProductExecutionContext {
+  accessPointGroupId!: string;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DataProductModelAccessExecutionContext, {
+      _type: usingConstantValueSchema(
+        V1_QueryExecutionContextType.QUERY_DATAPRODUCT_MODEL_ACCESS_EXECUTION_CONTEXT,
+      ),
+      dataProductPath: primitive(),
+      accessPointGroupId: primitive(),
     }),
     {
       deserializeNullAsUndefined: true,
@@ -136,9 +157,14 @@ export const V1_deserializeQueryExecutionContext = (
         V1_QueryDataSpaceExecutionContext.serialization.schema,
         json,
       );
-    case V1_QueryExecutionContextType.QUERY_DATAPRODUCT_EXECUTION_CONTEXT:
+    case V1_QueryExecutionContextType.QUERY_DATAPRODUCT_NATIVE_EXECUTION_CONTEXT:
       return deserialize(
-        V1_QueryDataProductExecutionContext.serialization.schema,
+        V1_DataProductNativeExecutionContext.serialization.schema,
+        json,
+      );
+    case V1_QueryExecutionContextType.QUERY_DATAPRODUCT_MODEL_ACCESS_EXECUTION_CONTEXT:
+      return deserialize(
+        V1_DataProductModelAccessExecutionContext.serialization.schema,
         json,
       );
     default: {
@@ -162,9 +188,14 @@ export const V1_serializeQueryExecutionContext = (
       V1_QueryDataSpaceExecutionContext.serialization.schema,
       protocol,
     );
-  } else if (protocol instanceof V1_QueryDataProductExecutionContext) {
+  } else if (protocol instanceof V1_DataProductNativeExecutionContext) {
+    return serialize(
+      V1_DataProductNativeExecutionContext.serialization.schema,
+      protocol,
+    );
+  } else if (protocol instanceof V1_DataProductModelAccessExecutionContext) {
     return serialize(
-      V1_QueryDataProductExecutionContext.serialization.schema,
+      V1_DataProductModelAccessExecutionContext.serialization.schema,
       protocol,
     );
   }