@finos/legend-graph 32.3.5 → 32.3.7

package/src/graph/metamodel/pure/dataProduct/MappingIncludeDataProduct.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2025-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 { hashArray } from '@finos/legend-shared';
+import { type Mapping } from '../packageableElements/mapping/Mapping.js';
+import { MappingInclude } from '../packageableElements/mapping/MappingInclude.js';
+import { type PackageableElementReference } from '../packageableElements/PackageableElementReference.js';
+import type { DataProduct } from './DataProduct.js';
+import { CORE_HASH_STRUCTURE } from '../../../Core_HashUtils.js';
+
+export class MappingIncludeDataProduct extends MappingInclude {
+  includedDataProduct: PackageableElementReference<DataProduct>;
+
+  constructor(
+    _OWNER: Mapping,
+    included: PackageableElementReference<Mapping>,
+    includedDataProduct: PackageableElementReference<DataProduct>,
+  ) {
+    super(_OWNER, included);
+    this.includedDataProduct = includedDataProduct;
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MAPPING_INCLUDE_DATAPRODUCT,
+      this.includedDataProduct.valueForSerialization ?? '',
+    ]);
+  }
+}

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

@@ -18,11 +18,14 @@ import { computed, makeObservable, observable, override } from 'mobx';
 import {
   type EmbeddedData,
   type ModelData,
+  type RelationElement,
+  type RelationRowTestData,
   ModelEmbeddedData,
   ModelInstanceData,
   ExternalFormatData,
   DataElementReference,
   ModelStoreData,
+  RelationElementsData,
 } from '../../../graph/metamodel/pure/data/EmbeddedData.js';
 import {
   type RelationalCSVDataTable,
@@ -141,6 +144,38 @@ const observe_RelationalCSVData = skipObserved(
   },
 );
 
+export const observe_RelationRowTestData = skipObserved(
+  (metamodel: RelationRowTestData): RelationRowTestData => {
+    makeObservable(metamodel, {
+      values: observable,
+    });
+    return metamodel;
+  },
+);
+
+export const observe_RelationElement = skipObserved(
+  (metamodel: RelationElement): RelationElement => {
+    makeObservable(metamodel, {
+      paths: observable,
+      columns: observable,
+      rows: observable,
+      hashCode: computed,
+    });
+    metamodel.rows.forEach(observe_RelationRowTestData);
+    return metamodel;
+  },
+);
+
+export const observe_RelationElementsData = skipObserved(
+  (metamodel: RelationElementsData): RelationElementsData => {
+    makeObservable(metamodel, {
+      hashCode: computed,
+    });
+    metamodel.relationElements.forEach(observe_RelationElement);
+    return metamodel;
+  },
+);
+
 export const observe_INTERNAL__UnknownEmbeddedData = skipObserved(
   (metamodel: INTERNAL__UnknownEmbeddedData): INTERNAL__UnknownEmbeddedData => {
     makeObservable(metamodel, {
@@ -165,6 +200,8 @@ export function observe_EmbeddedData(
     return observe_ModelStoreData(metamodel, context);
   } else if (metamodel instanceof RelationalCSVData) {
     return observe_RelationalCSVData(metamodel);
+  } else if (metamodel instanceof RelationElementsData) {
+    return observe_RelationElementsData(metamodel);
   }
   const extraEmbeddedDataObservers = context.plugins.flatMap(
     (plugin) =>

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

@@ -31,6 +31,7 @@ import {
   type DataProductRuntimeInfo,
   LakehouseAccessPoint,
   UnknownDataProductIcon,
+  type Expertise,
 } from '../../../graph/metamodel/pure/dataProduct/DataProduct.js';
 import {
   observe_Abstract_PackageableElement,
@@ -200,6 +201,16 @@ export const observe_DataProductIcon = skipObserved(
   },
 );
 
+export const observe_Expertise = skipObserved(
+  (metamodel: Expertise): Expertise => {
+    makeObservable(metamodel, {
+      description: observable,
+      expertIds: observable,
+    });
+    return metamodel;
+  },
+);
+
 export const observe_DataProduct = skipObserved(
   (metamodel: DataProduct): DataProduct => {
     observe_Abstract_PackageableElement(metamodel);
@@ -211,6 +222,7 @@ export const observe_DataProduct = skipObserved(
       description: observable,
       supportInfo: observable,
       icon: observable,
+      expertise: observable,
     });
 
     if (metamodel.supportInfo) {
@@ -219,6 +231,7 @@ export const observe_DataProduct = skipObserved(
     if (metamodel.icon) {
       observe_DataProductIcon(metamodel.icon);
     }
+    metamodel.expertise?.forEach(observe_Expertise);
     metamodel.accessPointGroups.forEach(observe_APG);
     return metamodel;
   },

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

@@ -1160,6 +1160,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     await this.buildStores(graph, inputs, options);
     stopWatch.record(GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_STORES__SUCCESS);
 
+    // build data products
+    graphBuilderState.setMessage(`Building data products...`);
+    await this.buildDataProducts(graph, inputs, options);
+    stopWatch.record(
+      GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_DATA_PRODUCTS__SUCCESS,
+    );
+
     // build mappings
     graphBuilderState.setMessage(`Building mappings...`);
     await this.buildMappings(graph, inputs, options);
@@ -1193,13 +1200,6 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_DATA_ELEMENTS__SUCCESS,
     );
 
-    // build data products
-    graphBuilderState.setMessage(`Building data products...`);
-    await this.buildDataProducts(graph, inputs, options);
-    stopWatch.record(
-      GRAPH_MANAGER_EVENT.GRAPH_BUILDER_BUILD_DATA_PRODUCTS__SUCCESS,
-    );
-
     // build other elements
     graphBuilderState.setMessage(`Building other elements...`);
     await this.buildFileGenerations(graph, inputs, options);

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

@@ -703,12 +703,17 @@ export class V1_EngineServerClient extends AbstractServerClient {
 
   lambdaRelationType = (
     input: PlainObject<V1_LambdaReturnTypeInput>,
+    options?: {
+      abortController?: AbortController | undefined;
+    },
   ): Promise<PlainObject<V1_RelationType>> =>
     this.postWithTracing(
       this.getTraceData(CORE_ENGINE_ACTIVITY_TRACE.GET_LAMBDA_RETURN_TYPE),
       `${this._pure()}/compilation/lambdaRelationType`,
       input,
-      {},
+      {
+        signal: options?.abortController?.signal ?? null,
+      },
       undefined,
       undefined,
       { enableCompression: true },

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

@@ -14,113 +14,214 @@
  * limitations under the License.
  */
 
-import { SerializationFactory, usingModelSchema } from '@finos/legend-shared';
-import { createModelSchema, list, optional, primitive } from 'serializr';
+import {
+  SerializationFactory,
+  UnsupportedOperationError,
+  usingConstantValueSchema,
+  usingModelSchema,
+  type PlainObject,
+} from '@finos/legend-shared';
+import {
+  createModelSchema,
+  custom,
+  list,
+  optional,
+  primitive,
+  serialize,
+} from 'serializr';
+import type { V1_GenericType } from '../../model/packageableElements/type/V1_GenericType.js';
+import {
+  V1_deserializeGenericType,
+  V1_genericTypeModelSchema,
+} from '../../transformation/pureProtocol/serializationHelpers/V1_TypeSerializationHelper.js';
 
-export class V1_DataProductArtifactDataProduct {
+export enum V1_DataProductTypeEnum {
+  INTERNAL = 'internalDataProductType',
+  EXTERNAL = 'externalDataProductType',
+}
+
+export enum V1_ResourceBuilderType {
+  DATABASE_DDL = 'databaseDDL',
+  FUNCTION_ACCESS_POINT = 'functionAccessPoint',
+}
+
+export enum V1_DatabaseDDLImplementationType {
+  VIEW = 'VIEW',
+  TABLE = 'TABLE',
+  PROCEDURE = 'PROCEDURE',
+}
+
+export abstract class V1_DataProductType {}
+
+export class V1_ExternalDataProductType extends V1_DataProductType {
+  link: string | undefined;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_ExternalDataProductType, {
+      _type: usingConstantValueSchema(V1_DataProductTypeEnum.EXTERNAL),
+      link: optional(primitive()),
+    }),
+  );
+}
+
+export class V1_InternalDataProductType extends V1_DataProductType {
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_InternalDataProductType, {
+      _type: usingConstantValueSchema(V1_DataProductTypeEnum.INTERNAL),
+    }),
+  );
+}
+
+export const V1_serializeDataProductType = (
+  DataProductType: V1_DataProductType,
+): PlainObject<V1_DataProductType> => {
+  if (DataProductType instanceof V1_ExternalDataProductType) {
+    return V1_ExternalDataProductType.serialization.toJson(DataProductType);
+  } else if (DataProductType instanceof V1_InternalDataProductType) {
+    return V1_InternalDataProductType.serialization.toJson(DataProductType);
+  }
+  throw new UnsupportedOperationError();
+};
+
+export const V1_deserializeDataProductType = (
+  json: PlainObject<V1_DataProductType>,
+): V1_DataProductType => {
+  switch (json._type) {
+    case V1_DataProductTypeEnum.EXTERNAL:
+      return V1_ExternalDataProductType.serialization.fromJson(json);
+    case V1_DataProductTypeEnum.INTERNAL:
+      return V1_InternalDataProductType.serialization.fromJson(json);
+    default:
+      throw new Error(`Unknown V1_DataProductType type: ${json._type}`);
+  }
+};
+
+export class V1_DataProductInfo {
   path!: string;
-  deploymentId!: string;
+  deploymentId: string | undefined;
   description: string | undefined;
   title: string | undefined;
+  dataProductType: V1_DataProductType | undefined;
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataProductArtifactDataProduct, {
+    createModelSchema(V1_DataProductInfo, {
       path: primitive(),
       deploymentId: primitive(),
       description: optional(primitive()),
       title: optional(primitive()),
+      dataProductType: custom(
+        (val) => (val ? V1_serializeDataProductType(val) : undefined),
+        (val) => (val ? V1_deserializeDataProductType(val) : undefined),
+      ),
     }),
   );
 }
 
-export class V1_DataProductArtifactResourceBuilder {
+export abstract class V1_ResourceBuilder {}
+
+export class V1_DatabaseDDL extends V1_ResourceBuilder {
   reproducible!: boolean;
   targetEnvironment!: string;
   script!: string;
+  classification: string | undefined;
+  resourceType!: V1_DatabaseDDLImplementationType;
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataProductArtifactResourceBuilder, {
+    createModelSchema(V1_DatabaseDDL, {
+      _type: usingConstantValueSchema(V1_ResourceBuilderType.DATABASE_DDL),
       reproducible: primitive(),
       targetEnvironment: primitive(),
       script: primitive(),
+      classification: optional(primitive()),
+      resourceType: primitive(),
     }),
   );
 }
 
-export class V1_DataProductArtifactAccessPointImplementation {
-  id!: string;
-  resourceBuilder!: V1_DataProductArtifactResourceBuilder;
+export class V1_FunctionAccessPoint extends V1_ResourceBuilder {
+  functionGrammar!: string;
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataProductArtifactAccessPointImplementation, {
-      id: primitive(),
-      resourceBuilder: usingModelSchema(
-        V1_DataProductArtifactResourceBuilder.serialization.schema,
+    createModelSchema(V1_FunctionAccessPoint, {
+      _type: usingConstantValueSchema(
+        V1_ResourceBuilderType.FUNCTION_ACCESS_POINT,
       ),
+      functionGrammar: primitive(),
     }),
   );
 }
 
-export class V1_DataProductArtifactAccessPointGroup {
+export const V1_serializeResourceBuilder = (
+  resourceBuilder: V1_ResourceBuilder,
+): PlainObject<V1_ResourceBuilder> => {
+  if (resourceBuilder instanceof V1_DatabaseDDL) {
+    return V1_DatabaseDDL.serialization.toJson(resourceBuilder);
+  } else if (resourceBuilder instanceof V1_FunctionAccessPoint) {
+    return V1_FunctionAccessPoint.serialization.toJson(resourceBuilder);
+  }
+  throw new UnsupportedOperationError();
+};
+
+export const V1_deserializeResourceBuilder = (
+  json: PlainObject<V1_ResourceBuilder>,
+): V1_ResourceBuilder => {
+  switch (json._type) {
+    case V1_ResourceBuilderType.DATABASE_DDL:
+      return V1_DatabaseDDL.serialization.fromJson(json);
+    case V1_ResourceBuilderType.FUNCTION_ACCESS_POINT:
+      return V1_FunctionAccessPoint.serialization.fromJson(json);
+    default:
+      throw new Error(`Unknown V1_ResourceBuilder type: ${json._type}`);
+  }
+};
+
+export class V1_AccessPointImplementation {
   id!: string;
   description: string | undefined;
-  accessPointImplementations: V1_DataProductArtifactAccessPointImplementation[] =
-    [];
+  resourceBuilder!: V1_ResourceBuilder;
+  lambdaGenericType: V1_GenericType | undefined;
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataProductArtifactAccessPointGroup, {
+    createModelSchema(V1_AccessPointImplementation, {
       id: primitive(),
       description: optional(primitive()),
-      accessPointImplementations: list(
-        usingModelSchema(
-          V1_DataProductArtifactAccessPointImplementation.serialization.schema,
-        ),
-      ),
-    }),
-  );
-}
-
-export class V1_DataProductArtifactGeneration {
-  dataProduct!: V1_DataProductArtifactDataProduct;
-  accessPointGroups: V1_DataProductArtifactAccessPointGroup[] = [];
-
-  static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataProductArtifactGeneration, {
-      dataProduct: usingModelSchema(
-        V1_DataProductArtifactDataProduct.serialization.schema,
+      resourceBuilder: custom(
+        V1_serializeResourceBuilder,
+        V1_deserializeResourceBuilder,
       ),
-      accessPointGroups: list(
-        usingModelSchema(
-          V1_DataProductArtifactAccessPointGroup.serialization.schema,
-        ),
+      lambdaGenericType: custom(
+        (val) => serialize(V1_genericTypeModelSchema, val),
+        (val) => V1_deserializeGenericType(val),
       ),
     }),
   );
 }
 
-export class V1_DataProductDefinitionAndArtifact {
-  definition!: string;
-  artifact!: V1_DataProductArtifactGeneration;
+export class V1_AccessPointGroupInfo {
+  id!: string;
+  description: string | undefined;
+  accessPointImplementations: V1_AccessPointImplementation[] = [];
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_DataProductDefinitionAndArtifact, {
-      definition: primitive(),
-      artifact: usingModelSchema(
-        V1_DataProductArtifactGeneration.serialization.schema,
+    createModelSchema(V1_AccessPointGroupInfo, {
+      id: primitive(),
+      description: optional(primitive()),
+      accessPointImplementations: list(
+        usingModelSchema(V1_AccessPointImplementation.serialization.schema),
       ),
     }),
   );
 }
 
-export class V1_SandboxDataProductDeploymentResponse {
-  deployedDataProducts: V1_DataProductDefinitionAndArtifact[] = [];
+export class V1_DataProductArtifact {
+  dataProduct!: V1_DataProductInfo;
+  accessPointGroups: V1_AccessPointGroupInfo[] = [];
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_SandboxDataProductDeploymentResponse, {
-      deployedDataProducts: list(
-        usingModelSchema(
-          V1_DataProductDefinitionAndArtifact.serialization.schema,
-        ),
+    createModelSchema(V1_DataProductArtifact, {
+      dataProduct: usingModelSchema(V1_DataProductInfo.serialization.schema),
+      accessPointGroups: list(
+        usingModelSchema(V1_AccessPointGroupInfo.serialization.schema),
       ),
     }),
   );

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

@@ -302,6 +302,19 @@ export class V1_ExternalDataProductType extends V1_DataProductType {
   }
 }
 
+export class V1_Expertise implements Hashable {
+  description: string | undefined;
+  expertIds: string[] | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.DATA_PRODUCT_EXPERTISE,
+      this.description ?? '',
+      hashArray(this.expertIds ?? []),
+    ]);
+  }
+}
+
 export class V1_DataProduct extends V1_PackageableElement implements Hashable {
   title: string | undefined;
   description: string | undefined;
@@ -313,6 +326,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
   type: V1_DataProductType | undefined;
   stereotypes: V1_StereotypePtr[] = [];
   taggedValues: V1_TaggedValue[] = [];
+  expertise: V1_Expertise[] | undefined;
 
   override get hashCode(): string {
     return hashArray([
@@ -327,6 +341,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
       this.type ?? '',
       hashArray(this.stereotypes),
       hashArray(this.taggedValues),
+      hashArray(this.expertise ?? []),
     ]);
   }
 

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

@@ -0,0 +1,30 @@
+/**
+ * Copyright (c) 2025-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 { hashArray } from '@finos/legend-shared';
+import { V1_MappingInclude } from '../mapping/V1_MappingInclude.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.js';
+
+export class V1_MappingIncludeDataProduct extends V1_MappingInclude {
+  includedDataProduct!: string;
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MAPPING_INCLUDE_DATAPRODUCT,
+      this.includedDataProduct,
+    ]);
+  }
+}

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

@@ -50,6 +50,7 @@ import {
   V1_InternalDataProductType,
   V1_ExternalDataProductType,
   V1_FunctionAccessPoint,
+  type V1_Expertise,
 } from '../../../model/packageableElements/dataProduct/V1_DataProduct.js';
 import { V1_initPackageableElement } from './V1_CoreTransformerHelper.js';
 import { V1_transformRawLambda } from './V1_RawValueSpecificationTransformer.js';
@@ -77,7 +78,7 @@ const transformAccessPoint = (
     const func = new V1_FunctionAccessPoint();
     func.id = ap.id;
     func.description = ap.description;
-    func.query = V1_transformRawLambda(ap.func, context);
+    func.query = V1_transformRawLambda(ap.query, context);
     return func;
   } else if (ap instanceof UnknownAccessPoint) {
     const un = new V1_UnknownAccessPoint();
@@ -126,6 +127,7 @@ export const V1_transformDataProduct = (
   product.coverageRegions = element.coverageRegions as
     | V1_DataProductRegion[]
     | undefined;
+  product.expertise = element.expertise as V1_Expertise[] | undefined;
   if (element.type instanceof InternalDataProductType) {
     product.type = new V1_InternalDataProductType();
   } else if (element.type instanceof ExternalDataProductType) {

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

@@ -51,6 +51,7 @@ import type { InlineEmbeddedRelationalInstanceSetImplementation } from '../../..
 import type { OtherwiseEmbeddedRelationalInstanceSetImplementation } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/mapping/OtherwiseEmbeddedRelationalInstanceSetImplementation.js';
 import type { InferableMappingElementIdValue } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/InferableMappingElementId.js';
 import { MappingIncludeMapping } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/MappingIncludeMapping.js';
+import { MappingIncludeDataProduct } from '../../../../../../../graph/metamodel/pure/dataProduct/MappingIncludeDataProduct.js';
 import { INTERNAL__UnknownMappingInclude } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/INTERNAL__UnknownMappingInclude.js';
 import type { MappingInclude } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/MappingInclude.js';
 import {
@@ -104,6 +105,7 @@ import {
   type V1_MappingInclude,
   V1_MappingIncludeMapping,
 } from '../../../model/packageableElements/mapping/V1_MappingInclude.js';
+import { V1_MappingIncludeDataProduct } from '../../../model/packageableElements/dataProduct/V1_MappingIncludeDataProduct.js';
 import { V1_INTERNAL__UnknownMappingInclude } from '../../../model/packageableElements/mapping/V1_INTERNAL__UnknownMappingInclude.js';
 import { V1_EnumerationMapping } from '../../../model/packageableElements/mapping/V1_EnumerationMapping.js';
 import { V1_FlatDataPropertyMapping } from '../../../model/packageableElements/store/flatData/mapping/V1_FlatDataPropertyMapping.js';
@@ -416,6 +418,11 @@ const transformMappingInclude = (
     const protocol = new V1_INTERNAL__UnknownMappingInclude();
     protocol.content = element.content;
     return protocol;
+  } else if (element instanceof MappingIncludeDataProduct) {
+    const mappingInclude = new V1_MappingIncludeDataProduct();
+    mappingInclude.includedDataProduct =
+      element.includedDataProduct.valueForSerialization ?? '';
+    return mappingInclude;
   } else if (element instanceof MappingIncludeMapping) {
     const mappingInclude = new V1_MappingIncludeMapping();
     mappingInclude.includedMapping =

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

@@ -108,6 +108,7 @@ import {
   type V1_MappingInclude,
   V1_MappingIncludeMapping,
 } from '../../../model/packageableElements/mapping/V1_MappingInclude.js';
+import { V1_MappingIncludeDataProduct } from '../../../model/packageableElements/dataProduct/V1_MappingIncludeDataProduct.js';
 import { V1_INTERNAL__UnknownMappingInclude } from '../../../model/packageableElements/mapping/V1_INTERNAL__UnknownMappingInclude.js';
 import type { V1_INTERNAL__UnknownStore } from '../../../model/packageableElements/store/V1_INTERNAL__UnknownStore.js';
 import type { V1_SnowflakeApp } from '../../../model/packageableElements/function/V1_SnowflakeApp.js';
@@ -135,10 +136,12 @@ import {
   Email,
   ExternalDataProductType,
   InternalDataProductType,
+  ModelAccessPointGroup,
   SupportInfo,
 } from '../../../../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
 import {
   V1_buildAccessPointGroup,
+  V1_buildDataProductExpertise,
   V1_buildDataProductIcon,
   V1_buildDataProductLink,
 } from './helpers/V1_DataProductBuilder.js';
@@ -543,6 +546,17 @@ export class V1_ElementSecondPassBuilder
     if (protocol instanceof V1_INTERNAL__UnknownMappingInclude) {
       return undefined;
     }
+    if (protocol instanceof V1_MappingIncludeDataProduct) {
+      const dataProduct = this.context.graph.getDataProduct(
+        protocol.includedDataProduct,
+      );
+      return guaranteeNonNullable(
+        dataProduct.accessPointGroups
+          .filter((apg) => apg instanceof ModelAccessPointGroup)
+          .at(0),
+        `include dataproduct requires Model AccessPoint Group. Can't find a Model AccessPoint Group for the dataproduct ${protocol.includedDataProduct}`,
+      ).mapping.value.path;
+    }
     if (protocol instanceof V1_MappingIncludeMapping) {
       return protocol.includedMapping;
     }
@@ -766,6 +780,11 @@ export class V1_ElementSecondPassBuilder
       dataProductType.link = element.type.link;
       dataProduct.type = dataProductType;
     }
+    if (element.expertise) {
+      dataProduct.expertise = element.expertise.map((expertise) =>
+        V1_buildDataProductExpertise(expertise),
+      );
+    }
     dataProduct.deliveryFrequency = element.deliveryFrequency as
       | DataProduct_DeliveryFrequency
       | undefined;

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

@@ -112,6 +112,7 @@ import {
   RelationColumn,
   RelationType,
 } from '../../../../../../../graph/metamodel/pure/packageableElements/relation/RelationType.js';
+import type { DataProduct } from '../../../../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
 import { V1_buildValueSpecification } from './helpers/V1_ValueSpecificationBuilderHelper.js';
 
 export const V1_buildFullPath = (
@@ -664,6 +665,13 @@ export class V1_GraphBuilderContext {
       path,
       this.graph.getDataElement,
     );
+  resolveDataProduct = (
+    path: string,
+  ): PackageableElementImplicitReference<DataProduct> =>
+    this.createImplicitPackageableElementReference(
+      path,
+      this.graph.getDataProduct,
+    );
 }
 
 export class V1_GraphBuilderContextBuilder {