@finos/legend-graph 32.5.2 → 32.6.0

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

@@ -15,6 +15,7 @@
  */
 
 import type {
+  LakehouseAccessPoint,
   ModelAccessPointGroup,
   NativeModelExecutionContext,
 } from '../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
@@ -31,14 +32,20 @@ export class DataProductAnalysis {
 }
 
 export class DataProductAnalysisQueryResult {
-  targetMappingPath: string;
+  targetMappingPath: string | undefined;
   dataProductAnalysis: DataProductAnalysis;
-  targetExecState: NativeModelExecutionContext | ModelAccessPointGroup;
+  targetExecState:
+    | NativeModelExecutionContext
+    | ModelAccessPointGroup
+    | LakehouseAccessPoint;
 
   constructor(
-    targetMappingPath: string,
+    targetMappingPath: string | undefined,
     dataProductAnalysis: DataProductAnalysis,
-    targetExecState: NativeModelExecutionContext | ModelAccessPointGroup,
+    targetExecState:
+      | NativeModelExecutionContext
+      | ModelAccessPointGroup
+      | LakehouseAccessPoint,
   ) {
     this.targetMappingPath = targetMappingPath;
     this.dataProductAnalysis = dataProductAnalysis;

package/src/graph-manager/action/changeDetection/DataProductObserveHelper.ts

@@ -33,7 +33,9 @@ import {
   UnknownDataProductIcon,
   type Expertise,
   type DataProductOperationalMetadata,
+  AppDirOwner,
 } from '../../../graph/metamodel/pure/dataProduct/DataProduct.js';
+import { type AppDirNode } from '../../../graph/metamodel/pure/packageableElements/ingest/IngestDefinition.js';
 import {
   observe_Abstract_PackageableElement,
   observe_PackageableElementReference,
@@ -225,6 +227,31 @@ export const observe_DataProductIcon = skipObserved(
   },
 );
 
+export const observe_AppDirNode = skipObserved(
+  (metamodel: AppDirNode): AppDirNode => {
+    makeObservable(metamodel, {
+      appDirId: observable,
+    });
+    return metamodel;
+  },
+);
+
+export const observe_AppDirOwner = skipObserved(
+  (metamodel: AppDirOwner): AppDirOwner => {
+    makeObservable(metamodel, {
+      production: observable,
+      prodParallel: observable,
+    });
+    if (metamodel.production) {
+      observe_AppDirNode(metamodel.production);
+    }
+    if (metamodel.prodParallel) {
+      observe_AppDirNode(metamodel.prodParallel);
+    }
+    return metamodel;
+  },
+);
+
 export const observe_DataProduct = skipObserved(
   (metamodel: DataProduct): DataProduct => {
     observe_Abstract_PackageableElement(metamodel);
@@ -238,6 +265,7 @@ export const observe_DataProduct = skipObserved(
       icon: observable,
       type: observable,
       operationalMetadata: observable,
+      owner: observable,
     });
 
     if (metamodel.supportInfo) {
@@ -249,6 +277,9 @@ export const observe_DataProduct = skipObserved(
     if (metamodel.operationalMetadata) {
       observe_OperationalMetadata(metamodel.operationalMetadata);
     }
+    if (metamodel.owner instanceof AppDirOwner) {
+      observe_AppDirOwner(metamodel.owner);
+    }
     metamodel.accessPointGroups.forEach(observe_APG);
     return metamodel;
   },

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

@@ -60,6 +60,7 @@ export class QueryDataProductModelAccessExecutionContext extends QueryDataProduc
 
 export class QueryDataProductLakehouseExecutionContext extends QueryDataProductExecutionContext {
   accessPointId!: string;
+  accessGroupId!: string;
 }
 
 export interface QueryGridConfig {
@@ -184,6 +185,7 @@ export class QueryDataProductModelAccessExecutionContextInfo extends QueryExecut
 export class QueryDataProductLakehouseExecutionContextInfo extends QueryExecutionContextInfo {
   dataProductPath!: string;
   accessPointId!: string;
+  accessGroupId!: string;
 }
 
 export interface QueryInfo {

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

@@ -381,8 +381,10 @@ import {
   DataProductAnalysis,
 } from '../../../action/analytics/data-product/DataProductAnalysis.js';
 import {
+  AccessPointGroup,
   DataProductAccessType,
   DataProductElementScope,
+  LakehouseAccessPoint,
   ModelAccessPointGroup,
   NativeModelAccess,
   NativeModelExecutionContext,
@@ -3760,46 +3762,222 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     dataProductAccessType: DataProductAccessType,
     projectInfo: ProjectGAVCoordinates,
     graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult> {
+    switch (dataProductAccessType) {
+      case DataProductAccessType.MODEL:
+        return this.buildModelAccessDataProductAnalysis(
+          artifact,
+          dataProductPath,
+          pureGraph,
+          accessPointId,
+          projectInfo,
+          graphReport,
+        );
+      case DataProductAccessType.NATIVE:
+        return this.buildNativeAccessDataProductAnalysis(
+          artifact,
+          dataProductPath,
+          pureGraph,
+          accessPointId,
+          projectInfo,
+          graphReport,
+        );
+      case DataProductAccessType.LAKEHOUSE:
+        return this.buildLakehouseAccessDataProductAnalysis(
+          artifact,
+          dataProductPath,
+          pureGraph,
+          accessPointId,
+          projectInfo,
+          graphReport,
+        );
+      default:
+        throw new UnsupportedOperationError(
+          `Unsupported data product access type: '${dataProductAccessType}'`,
+        );
+    }
+  }
+
+  private async buildModelAccessDataProductAnalysis(
+    artifact: V1_DataProductArtifact,
+    dataProductPath: string,
+    pureGraph: PureModel,
+    accessPointId: string,
+    projectInfo: ProjectGAVCoordinates,
+    graphReport?: GraphManagerOperationReport,
   ): Promise<DataProductAnalysisQueryResult> {
     const modelAccessPointGroups = artifact.accessPointGroups.filter(
       (group): group is V1_ModelAccessPointGroupInfo =>
         group instanceof V1_ModelAccessPointGroupInfo,
     );
-
-    // Resolve the target access group and mapping path
-    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;
-      }
-    }
+    const accessGroup = modelAccessPointGroups.find(
+      (g) => g.id === accessPointId,
+    );
     if (!accessGroup) {
       throw new Error(
-        `Can't resolve access point '${accessPointId}' (type: ${dataProductAccessType}) in data product '${dataProductPath}'`,
+        `Can't resolve access point '${accessPointId}' (type: ${DataProductAccessType.MODEL}) in data product '${dataProductPath}'`,
+      );
+    }
+    const mappingPath = accessGroup.mappingGeneration.path;
+
+    return this.buildDataProductAnalysisCore(
+      artifact,
+      dataProductPath,
+      pureGraph,
+      mappingPath,
+      accessGroup,
+      undefined, // no resolved runtime path for MODEL access
+      projectInfo,
+      graphReport,
+    );
+  }
+
+  private async buildNativeAccessDataProductAnalysis(
+    artifact: V1_DataProductArtifact,
+    dataProductPath: string,
+    pureGraph: PureModel,
+    accessPointId: string,
+    projectInfo: ProjectGAVCoordinates,
+    graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult> {
+    const nativeCtx =
+      artifact.nativeModelAccess?.nativeModelExecutionContexts.find(
+        (ctx) => ctx.key === accessPointId,
+      );
+    if (!nativeCtx) {
+      throw new Error(
+        `Can't resolve access point '${accessPointId}' (type: ${DataProductAccessType.NATIVE}) in data product '${dataProductPath}'`,
       );
     }
+    const mappingPath = nativeCtx.mapping;
     if (!mappingPath) {
       throw new Error(
-        `Can't resolve mapping path '${mappingPath}' for access point '${accessPointId}' (type: ${dataProductAccessType}) in data product '${dataProductPath}'`,
+        `Can't resolve mapping path for access point '${accessPointId}' (type: ${DataProductAccessType.NATIVE}) in data product '${dataProductPath}'`,
       );
     }
 
-    // prevent refetching artifact
+    // Resolve runtime path for the native context
+    const resolvedRuntimePath = nativeCtx.runtimeGeneration?.path;
+
+    return this.buildDataProductAnalysisCore(
+      artifact,
+      dataProductPath,
+      pureGraph,
+      mappingPath,
+      nativeCtx,
+      resolvedRuntimePath,
+      projectInfo,
+      graphReport,
+    );
+  }
+
+  private async buildLakehouseAccessDataProductAnalysis(
+    artifact: V1_DataProductArtifact,
+    dataProductPath: string,
+    pureGraph: PureModel,
+    accessPointId: string,
+    projectInfo: ProjectGAVCoordinates,
+    graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult> {
+    // 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 graph with only the data product
+    const graphEntities = [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);
+
+    // Create access point groups with LakehouseAccessPoints from artifact data
+    data.accessPointGroups = artifact.accessPointGroups
+      .filter(
+        (groupInfo) => !(groupInfo instanceof V1_ModelAccessPointGroupInfo),
+      )
+      .map((groupInfo) => {
+        const apGroup = new AccessPointGroup();
+        apGroup.id = groupInfo.id;
+        apGroup.description = groupInfo.description;
+        apGroup.accessPoints = groupInfo.accessPointImplementations.map(
+          (apImpl) => {
+            const lakehouseAP = new LakehouseAccessPoint(
+              apImpl.id,
+              '', // targetEnvironment is not available in the artifact
+              new RawLambda(undefined, undefined),
+              apGroup,
+            );
+            lakehouseAP.description = apImpl.description;
+            return lakehouseAP;
+          },
+        );
+        return apGroup;
+      });
+
+    // Find the lakehouse access point matching the requested id
+    const lakehouseResult = data.accessPointGroups
+      .flatMap((group) => group.accessPoints)
+      .find(
+        (ap): ap is LakehouseAccessPoint =>
+          ap instanceof LakehouseAccessPoint && ap.id === accessPointId,
+      );
+    if (!lakehouseResult) {
+      throw new Error(
+        `Can't resolve lakehouse access point '${accessPointId}' in data product '${dataProductPath}'`,
+      );
+    }
+
+    const result = new DataProductAnalysis();
+    result.path = dataProductPath;
+    result.title = artifact.dataProduct.title;
+    result.description = artifact.dataProduct.description;
+
+    return new DataProductAnalysisQueryResult(
+      undefined,
+      result,
+      lakehouseResult,
+    );
+  }
+
+  /**
+   * Shared core logic for building data product analysis after the access type
+   * specific resolution has been performed.
+   */
+  private async buildDataProductAnalysisCore(
+    artifact: V1_DataProductArtifact,
+    dataProductPath: string,
+    pureGraph: PureModel,
+    mappingPath: string,
+    accessGroup:
+      | V1_ModelAccessPointGroupInfo
+      | V1_NativeModelExecutionContextInfo,
+    resolvedRuntimePath: string | undefined,
+    projectInfo: ProjectGAVCoordinates,
+    graphReport?: GraphManagerOperationReport,
+  ): Promise<DataProductAnalysisQueryResult> {
+    const modelAccessPointGroups = artifact.accessPointGroups.filter(
+      (group): group is V1_ModelAccessPointGroupInfo =>
+        group instanceof V1_ModelAccessPointGroupInfo,
+    );
+
+    // Collect mapping generation infos from all sources
     const includedGenInfos = new Map<string, V1_MappingGenerationInfo>();
 
     if (artifact.nativeModelAccess?.mappingGenerations) {
@@ -3834,10 +4012,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     resolvedMappingStub.name = extractElementNameFromPath(mappingPath);
 
     // Only add a runtime stub for the resolved native context (if applicable)
-    const resolvedRuntimePath =
-      dataProductAccessType === DataProductAccessType.NATIVE
-        ? nativeRuntimePaths.get(accessPointId)
-        : undefined;
     let resolvedRuntimeStub: V1_PackageableRuntime | undefined;
     if (resolvedRuntimePath) {
       resolvedRuntimeStub = new V1_PackageableRuntime();
@@ -3848,8 +4022,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       resolvedRuntimeStub.runtimeValue = new V1_EngineRuntime();
     }
 
-    // Create a dummy data product element
-
     // Create a dummy data product element
     const dummyDataProduct = new V1_DataProduct();
     dummyDataProduct.package =
@@ -4499,6 +4671,21 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  async checkServiceRegisteredByPattern(
+    serviceServerUrl: string,
+    servicePattern: string,
+  ): Promise<boolean> {
+    try {
+      await this.engine.getServiceMetadataByPattern(
+        serviceServerUrl,
+        servicePattern,
+      );
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   async runServicePostValidations(
     service: Service,
     graph: PureModel,

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

@@ -229,6 +229,7 @@ export const V1_buildExecutionContext = (
     const exec = new QueryDataProductLakehouseExecutionContext();
     exec.dataProductPath = protocolExecContext.dataProductPath;
     exec.accessPointId = protocolExecContext.accessPointId;
+    exec.accessGroupId = protocolExecContext.accessGroupId;
     return exec;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
@@ -279,6 +280,7 @@ export const V1_buildExecutionContextInfo = (
     const exec = new QueryDataProductLakehouseExecutionContextInfo();
     exec.dataProductPath = v1_execContext.dataProductPath;
     exec.accessPointId = v1_execContext.accessPointId;
+    exec.accessGroupId = v1_execContext.accessGroupId;
     return exec;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');
@@ -403,6 +405,7 @@ export const V1_transformQueryExecutionContext = (
     const protocol = new V1_DataProductLakehouseExecutionContext();
     protocol.dataProductPath = execContext.dataProductPath;
     protocol.accessPointId = execContext.accessPointId;
+    protocol.accessGroupId = execContext.accessGroupId;
     return protocol;
   }
   throw new UnsupportedOperationError('Unsupported query execution context');

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

@@ -121,6 +121,7 @@ enum CORE_ENGINE_ACTIVITY_TRACE {
   REGISTER_SERVICE = 'register service',
   GET_SERVICE_VERSION = 'get service version',
   ACTIVATE_SERVICE_GENERATION_ID = 'activate service generation id',
+  GET_SERVICE_METADATA = 'get service metadata',
   VALIDATE_SERVICE_ASSERTION_ID = 'validate service assertion id',
   RUN_SERVICE_TESTS = 'run service tests',
   GENERATE_TEST_DATA_WITH_DEFAULT_SEED = 'generate test data with default seed',
@@ -1240,6 +1241,17 @@ export class V1_EngineServerClient extends AbstractServerClient {
       request,
     );
 
+  getServiceMetadataByPattern = (
+    serviceServerUrl: string,
+    servicePattern: string,
+  ): Promise<PlainObject> =>
+    this.getWithTracing(
+      this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.GET_SERVICE_METADATA),
+      `${this._service(
+        this.baseUrlForServiceRegistration ?? serviceServerUrl,
+      )}/serviceMetadata/${encodeURIComponent(servicePattern)}`,
+    );
+
   // ------------------------------------------- Legend Services List -------------------------------------------
 
   private readonly getServicesDetailsFromCache = (): Promise<PlainObject[]> =>

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

@@ -328,6 +328,11 @@ export interface V1_GraphManagerEngine {
     generationId: string,
   ) => Promise<void>;
 
+  getServiceMetadataByPattern: (
+    serviceServerUrl: string,
+    servicePattern: string,
+  ) => Promise<PlainObject>;
+
   runServicePostVal: (
     servicePath: string,
     input: V1_PureModelContext,

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

@@ -1142,6 +1142,16 @@ export class V1_RemoteEngine implements V1_GraphManagerEngine {
     );
   }
 
+  async getServiceMetadataByPattern(
+    serviceServerUrl: string,
+    servicePattern: string,
+  ): Promise<PlainObject> {
+    return this.engineServerClient.getServiceMetadataByPattern(
+      serviceServerUrl,
+      servicePattern,
+    );
+  }
+
   async runServicePostVal(
     servicePath: string,
     input: V1_PureModelContext,

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

@@ -67,7 +67,7 @@ export enum V1_QueryExecutionContextType {
   QUERY_DATASAPCE_EXECUTION_CONTEXT = 'dataSpaceExecutionContext',
   QUERY_DATAPRODUCT_NATIVE_EXECUTION_CONTEXT = 'dataProductNativeExecutionContext',
   QUERY_DATAPRODUCT_MODEL_ACCESS_EXECUTION_CONTEXT = 'dataProductModelAccessExecutionContext',
-  QUERY_DATAPRODUCT_LAKEHOUSE_EXECUTION_CONTEXT = 'dataProductLakehouseExecutionContext',
+  QUERY_DATAPRODUCT_LAKEHOUSE_EXECUTION_CONTEXT = 'dataProductLakehouseAccessExecutionContext',
 }
 
 export class V1_QueryExplicitExecutionContext extends V1_QueryExecutionContext {
@@ -146,6 +146,7 @@ export class V1_DataProductModelAccessExecutionContext extends V1_QueryDataProdu
 
 export class V1_DataProductLakehouseExecutionContext extends V1_QueryDataProductExecutionContext {
   accessPointId!: string;
+  accessGroupId!: string;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_DataProductLakehouseExecutionContext, {
@@ -154,6 +155,7 @@ export class V1_DataProductLakehouseExecutionContext extends V1_QueryDataProduct
       ),
       dataProductPath: primitive(),
       accessPointId: primitive(),
+      accessGroupId: primitive(),
     }),
     {
       deserializeNullAsUndefined: true,

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

@@ -14,8 +14,16 @@
  * limitations under the License.
  */
 
-import type { PlainObject } from '@finos/legend-shared';
+import {
+  hashArray,
+  type Hashable,
+  type PlainObject,
+} from '@finos/legend-shared';
 import type { V1_StereotypePtr } from '../../model/packageableElements/domain/V1_StereotypePtr.js';
+import { AppDirLevel } from '../../../../../../graph/metamodel/pure/packageableElements/ingest/IngestDefinition.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../../graph/Core_HashUtils.js';
+
+export { AppDirLevel as V1_AppDirLevel };
 
 // ---------------------------------------- Users & App Directory --------------------------------------
 
@@ -29,17 +37,17 @@ export enum V1_UserType {
   SYSTEM_ACCOUNT = 'SYSTEM_ACCOUNT',
 }
 
-export class V1_AppDirNode {
+export class V1_AppDirNode implements Hashable {
   appDirId!: number;
-  level!: V1_AppDirLevel;
-}
-
-export enum V1_AppDirLevel {
-  BUSINESS_UNIT = 'BUSINESS_UNIT',
-  SUB_BUSINESS_UNIT = 'SUB_BUSINESS_UNIT',
-  FAMILY = 'FAMILY',
-  APPLICATION = 'APPLICATION',
-  DEPLOYMENT = 'DEPLOYMENT',
+  level!: AppDirLevel;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.APP_DIR_NODE,
+      this.appDirId.toString(),
+      this.level,
+    ]);
+  }
 }
 
 // -------------------------------------------- Pagination ---------------------------------------------

package/src/graph-manager/protocol/pure/v1/model/packageableElements/dataProduct/V1_DataProduct.ts

@@ -33,6 +33,7 @@ import {
 import type { V1_StereotypePtr } from '../domain/V1_StereotypePtr.js';
 import type { V1_TaggedValue } from '../domain/V1_TaggedValue.js';
 import type { V1_EmbeddedData } from '../../data/V1_EmbeddedData.js';
+import type { V1_AppDirNode } from '../../../lakehouse/entitlements/V1_CoreEntitlements.js';
 
 export const V1_DATA_PRODUCT_ELEMENT_PROTOCOL_TYPE = 'dataProduct';
 
@@ -369,12 +370,9 @@ export abstract class V1_DataProductType implements Hashable {
   }
 }
 
-export class V1_InternalDataProductType extends V1_DataProductType {
-  _type = V1_DataProductTypeValue.INTERNAL;
-}
+export class V1_InternalDataProductType extends V1_DataProductType {}
 
 export class V1_ExternalDataProductType extends V1_DataProductType {
-  _type = V1_DataProductTypeValue.EXTERNAL;
   link!: V1_DataProductLink;
 
   override get hashCode(): string {
@@ -409,6 +407,27 @@ export class V1_DataProductOperationalMetadata implements Hashable {
   }
 }
 
+export enum V1_DataProductOwnerType {
+  APP_DIR = 'appDir',
+}
+
+export abstract class V1_DataProductOwner implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_AppDirOwner extends V1_DataProductOwner implements Hashable {
+  production: V1_AppDirNode | undefined;
+  prodParallel: V1_AppDirNode | undefined;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_OWNER,
+      this.production?.hashCode ?? '',
+      this.prodParallel?.hashCode ?? '',
+    ]);
+  }
+}
+
 export class V1_DataProduct extends V1_PackageableElement implements Hashable {
   title: string | undefined;
   description: string | undefined;
@@ -421,6 +440,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
   taggedValues: V1_TaggedValue[] = [];
   sampleValues: V1_EmbeddedData[] | undefined;
   operationalMetadata: V1_DataProductOperationalMetadata | undefined;
+  owner: V1_DataProductOwner | undefined;
 
   override get hashCode(): string {
     return hashArray([
@@ -436,6 +456,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
       hashArray(this.taggedValues),
       hashArray(this.sampleValues ?? []),
       this.operationalMetadata ?? '',
+      this.owner ?? '',
     ]);
   }
 

package/src/graph-manager/protocol/pure/v1/transformation/pureGraph/from/V1_DataProductTransformer.ts

@@ -30,6 +30,7 @@ import {
   FunctionAccessPoint,
   PackageableElementSampleQuery,
   InLineSampleQuery,
+  AppDirOwner,
 } from '../../../../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
 import {
   type V1_AccessPoint,
@@ -57,6 +58,7 @@ import {
   V1_PackageableElementSampleQuery,
   V1_InLineSampleQuery,
   V1_NativeModelExecutionContext,
+  V1_AppDirOwner,
 } from '../../../model/packageableElements/dataProduct/V1_DataProduct.js';
 import { V1_initPackageableElement } from './V1_CoreTransformerHelper.js';
 import { V1_transformRawLambda } from './V1_RawValueSpecificationTransformer.js';
@@ -69,6 +71,7 @@ import { V1_PackageableElementPointer } from '../../../model/packageableElements
 import { V1_transformEmbeddedData } from './V1_DataElementTransformer.js';
 import { ConcreteFunctionDefinition } from '../../../../../../../graph/metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
 import { generateFunctionPrettyName } from '../../../../../../../graph/helpers/PureLanguageHelper.js';
+import { V1_AppDirNode } from '../../../lakehouse/entitlements/V1_CoreEntitlements.js';
 
 const transformAccessPoint = (
   ap: AccessPoint,
@@ -343,5 +346,26 @@ export const V1_transformDataProduct = (
     V1_transformTaggedValue(taggedValue),
   );
 
+  if (element.owner instanceof AppDirOwner) {
+    const v1Owner = new V1_AppDirOwner();
+    if (element.owner.production) {
+      const v1Node = new V1_AppDirNode();
+      v1Node.appDirId = element.owner.production.appDirId;
+      v1Node.level = element.owner.production.level;
+      v1Owner.production = v1Node;
+    }
+    if (element.owner.prodParallel) {
+      const v1Node = new V1_AppDirNode();
+      v1Node.appDirId = element.owner.prodParallel.appDirId;
+      v1Node.level = element.owner.prodParallel.level;
+      v1Owner.prodParallel = v1Node;
+    }
+    product.owner = v1Owner;
+  } else if (element.owner !== undefined) {
+    throw new UnsupportedOperationError(
+      `Unable to transform data product owner`,
+    );
+  }
+
   return product;
 };