@finos/legend-graph 32.3.39 → 32.4.1

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,
     );
   }

package/src/graph-manager/protocol/pure/v1/lakehouse/deploy/V1_DataProductArtifact.ts

@@ -45,6 +45,7 @@ import { V1_relationElementModelSchema } from '../../transformation/pureProtocol
 import { V1_pureModelContextDataPropSchema } from '../../transformation/pureProtocol/V1_PureProtocolSerialization.js';
 import type { V1_PureModelContextData } from '../../model/context/V1_PureModelContextData.js';
 import type { V1_Multiplicity } from '../../model/packageableElements/domain/V1_Multiplicity.js';
+import { V1_MappedEntity } from '../../engine/analytics/V1_MappingModelCoverageAnalysis.js';
 import { V1_multiplicityModelSchema } from '../../transformation/pureProtocol/serializationHelpers/V1_CoreSerializationHelper.js';
 
 export enum V1_DataProductTypeEnum {
@@ -275,11 +276,15 @@ export class V1_DiagramInfo {
 export class V1_MappingGenerationInfo {
   path!: string;
   model!: V1_PureModelContextData;
+  mappedEntities: V1_MappedEntity[] = [];
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_MappingGenerationInfo, {
       path: primitive(),
       model: V1_pureModelContextDataPropSchema,
+      mappedEntities: list(
+        usingModelSchema(V1_MappedEntity.serialization.schema),
+      ),
     }),
   );
 }

package/src/graph-manager/protocol/pure/v1/lakehouse/entitlements/V1_CoreEntitlements.ts

@@ -134,6 +134,12 @@ export class V1_DataBundle extends V1_ConsumerEntitlementResource {
 
 // -------------------------------------- Contract User Membership -------------------------------------
 
+export class V1_ContractUserMembership {
+  guid!: string;
+  user!: V1_User;
+  status!: V1_UserApprovalStatus;
+}
+
 export enum V1_UserApprovalStatus {
   PENDING = 'PENDING',
   APPROVED = 'APPROVED',
@@ -141,9 +147,3 @@ export enum V1_UserApprovalStatus {
   REVOKED = 'REVOKED',
   CLOSED = 'CLOSED',
 }
-
-export class V1_ContractUserMembership {
-  guid!: string;
-  user!: V1_User;
-  status!: V1_UserApprovalStatus;
-}

package/src/graph-manager/protocol/pure/v1/lakehouse/entitlements/V1_DataAccessRequest.ts

@@ -124,3 +124,7 @@ export class V1_DataRequestWithWorkflow {
 export class V1_DataRequestsWithWorkflowResponse {
   dataRequests: V1_DataRequestWithWorkflow[] = [];
 }
+
+export class V1_DataRequestTasksResponse {
+  workflowTasks: V1_WorkflowTask[] = [];
+}

package/src/graph-manager/protocol/pure/v1/lakehouse/entitlements/V1_Workflow.ts

@@ -0,0 +1,27 @@
+/**
+ * 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.
+ */
+
+export class V1_RawWorkflowTask {
+  completed!: boolean;
+  createdDate!: Date;
+  parentTaskId!: string;
+  potentialAssignees: string[] = [];
+  processInstanceId!: string;
+  reference!: string;
+  status!: string;
+  taskId!: string;
+  type!: string;
+}

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementFourthPassBuilder.ts

@@ -15,6 +15,7 @@
  */
 
 import {
+  AssertionError,
   UnsupportedOperationError,
   guaranteeType,
   isNonNullable,
@@ -47,8 +48,8 @@ import type { V1_FileGenerationSpecification } from '../../../model/packageableE
 import type { V1_GenerationSpecification } from '../../../model/packageableElements/generationSpecification/V1_GenerationSpecification.js';
 import type { V1_Measure } from '../../../model/packageableElements/domain/V1_Measure.js';
 import {
-  V1_buildDatabaseJoin,
   V1_buildDatabaseFilter,
+  V1_buildDatabaseJoin,
 } from './helpers/V1_DatabaseBuilderHelper.js';
 import type { V1_SectionIndex } from '../../../model/packageableElements/section/V1_SectionIndex.js';
 import { V1_buildAssociationMapping } from './helpers/V1_AssociationMappingHelper.js';
@@ -174,9 +175,15 @@ export class V1_ElementFourthPassBuilder
     const database = this.context.currentSubGraph.getOwnDatabase(
       V1_buildFullPath(element.package, element.name),
     );
-    database.joins = element.joins.map((join) =>
-      V1_buildDatabaseJoin(join, this.context, database),
-    );
+    element.joins.forEach((srcJoin, index) => {
+      const join = database.joins[index];
+      if (!join) {
+        throw new AssertionError(
+          `Can't find join '${srcJoin.name}' in metamodel database '${database.path}'`,
+        );
+      }
+      V1_buildDatabaseJoin(srcJoin, join, this.context, database);
+    });
     database.filters = element.filters.map((filter) =>
       V1_buildDatabaseFilter(filter, this.context, database),
     );

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementSecondPassBuilder.ts

@@ -147,6 +147,7 @@ import {
 } from './helpers/V1_DataProductBuilder.js';
 import type { V1_IngestDefinition } from '../../../model/packageableElements/ingest/V1_IngestDefinition.js';
 import { IncludeStore } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/model/IncludeStore.js';
+import { Join } from '../../../../../../../STO_Relational_Exports.js';
 
 export class V1_ElementSecondPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -515,6 +516,7 @@ export class V1_ElementSecondPassBuilder
     const database = this.context.currentSubGraph.getOwnDatabase(
       V1_buildFullPath(element.package, element.name),
     );
+    database.joins = element.joins.map((join) => new Join(join.name));
     database.includes = element.includedStores.map((includedStore) =>
       this.context.resolveDatabase(includedStore.path),
     );