@finos/legend-graph 32.6.1 → 32.6.3

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

@@ -42,6 +42,7 @@ import {
   guaranteeType,
   guaranteeNonEmptyString,
   uuid,
+  returnUndefOnError,
 } from '@finos/legend-shared';
 import type { TEMPORARY__AbstractEngineConfig } from '../../../../graph-manager/action/TEMPORARY__AbstractEngineConfig.js';
 import {
@@ -382,6 +383,7 @@ import {
 } from '../../../action/analytics/data-product/DataProductAnalysis.js';
 import {
   AccessPointGroup,
+  type DataProduct,
   DataProductAccessType,
   DataProductElementScope,
   LakehouseAccessPoint,
@@ -404,10 +406,24 @@ import {
   V1_MetadatProject,
 } from './engine/dev-metadata/V1_DevMetadataPushRequest.js';
 import type { MetadataRequestOptions } from '../../../action/dev-metadata/MetadataRequestOptions.js';
-import type { Accessor } from '../../../../graph/metamodel/pure/packageableElements/relation/Accessor.js';
+import type {
+  Accessor,
+  DataProductAccessor,
+} from '../../../../graph/metamodel/pure/packageableElements/relation/Accessor.js';
 import { IngestDefinition } from '../../../../graph/metamodel/pure/packageableElements/ingest/IngestDefinition.js';
 import { Database } from '../../../../graph/metamodel/pure/packageableElements/store/relational/model/Database.js';
-import { V1_createAccessorFromPackageableElement } from './helpers/V1_AccessorHelper.js';
+import {
+  V1_createAccessorFromPackageableElement,
+  V1_buildDataProductAccessor,
+  V1_resolveAccessorsFromRawLambda,
+  V1_buildRelationTypeFromAccessPointImplementation,
+} from './helpers/V1_AccessorHelper.js';
+import {
+  V1_DataProductAccessor,
+  V1_IngestDefinitionAccessor,
+  V1_RelationStoreAccessor,
+} from './model/valueSpecification/raw/classInstance/relation/V1_RelationStoreAccessor.js';
+import { V1_deserializeIngestDefinitionContent } from './transformation/pureProtocol/serializationHelpers/V1_IngestSerializationHelper.js';
 
 /**
  * Number of elements to process synchronously before yielding to the event loop.
@@ -2157,6 +2173,68 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return V1_createAccessorFromPackageableElement(element, context, options);
   }
 
+  override async buildDataProductAccessor(
+    element: DataProduct,
+    graph: PureModel,
+    options?: {
+      tableName?: string | undefined;
+    },
+  ): Promise<DataProductAccessor | undefined> {
+    const context = new V1_GraphBuilderContextBuilder(
+      graph,
+      graph,
+      this.graphBuilderExtensions,
+      this.logService,
+    ).build();
+    return V1_buildDataProductAccessor(element, context, this, options);
+  }
+
+  override async collectAccessorsInRawLambda(
+    rawLambda: RawLambda,
+    graph: PureModel,
+  ): Promise<Accessor[]> {
+    const v1Accessors = V1_resolveAccessorsFromRawLambda(
+      rawLambda,
+      this,
+      this.pluginManager.getPureProtocolProcessorPlugins(),
+      graph,
+    );
+    if (!v1Accessors) {
+      return [];
+    }
+    const results = await Promise.all(
+      v1Accessors.map(async (v1Accessor) => {
+        const elementPath = v1Accessor.path[0];
+        if (!elementPath) {
+          return undefined;
+        }
+        const element = graph.getNullableElement(elementPath);
+        if (!element) {
+          return undefined;
+        }
+        if (v1Accessor instanceof V1_DataProductAccessor) {
+          return this.buildDataProductAccessor(element as DataProduct, graph, {
+            tableName: v1Accessor.path[1],
+          });
+        }
+        if (v1Accessor instanceof V1_IngestDefinitionAccessor) {
+          return this.createAccessorFromPackageableElement(element, graph, {
+            schemaName: undefined,
+            tableName: v1Accessor.path[1],
+          });
+        }
+        if (v1Accessor instanceof V1_RelationStoreAccessor) {
+          return this.createAccessorFromPackageableElement(element, graph, {
+            schemaName: v1Accessor.path[1],
+            tableName: v1Accessor.path[2],
+          });
+        }
+        return undefined;
+      }),
+    );
+    return results.filter(isNonNullable);
+  }
+
   private buildLambdaReturnTypeInput(
     lambda: RawLambda,
     graph: PureModel,
@@ -3905,10 +3983,10 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       graphReport,
     );
 
-    const data = pureGraph.getDataProduct(dataProductPath);
+    const dataProduct = pureGraph.getDataProduct(dataProductPath);
 
     // Create access point groups with LakehouseAccessPoints from artifact data
-    data.accessPointGroups = artifact.accessPointGroups
+    dataProduct.accessPointGroups = artifact.accessPointGroups
       .filter(
         (groupInfo) => !(groupInfo instanceof V1_ModelAccessPointGroupInfo),
       )
@@ -3925,6 +4003,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
               apGroup,
             );
             lakehouseAP.description = apImpl.description;
+            // Cache the relation type derived from the artifact's lambda
+            // generic type so downstream consumers can avoid re-computing it.
+            lakehouseAP.__internal__RelationType =
+              V1_buildRelationTypeFromAccessPointImplementation(
+                apImpl,
+                pureGraph,
+              );
             return lakehouseAP;
           },
         );
@@ -3932,7 +4017,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       });
 
     // Find the lakehouse access point matching the requested id
-    const lakehouseResult = data.accessPointGroups
+    const lakehouseResult = dataProduct.accessPointGroups
       .flatMap((group) => group.accessPoints)
       .find(
         (ap): ap is LakehouseAccessPoint =>
@@ -4332,6 +4417,20 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     return result;
   }
 
+  // --------------------------------------------- Ingeset Defintion --------------------------------------
+
+  getIngestDefinitionDatasetNames(
+    ingestDefinition: IngestDefinition,
+  ): string[] {
+    const content = returnUndefOnError(() =>
+      V1_deserializeIngestDefinitionContent(ingestDefinition.content),
+    );
+    if (!content?.datasets) {
+      return [];
+    }
+    return content.datasets.map((ds) => ds.name);
+  }
+
   // --------------------------------------------- Relational ---------------------------------------------
 
   async generateModelsFromDatabaseSpecification(

package/src/graph-manager/protocol/pure/v1/helpers/V1_AccessorHelper.ts

@@ -19,6 +19,7 @@ import {
   IngestionAccessor,
   RelationalStoreAccessor,
   type AccessorOwner,
+  DataProductAccessor,
 } from '../../../../../graph/metamodel/pure/packageableElements/relation/Accessor.js';
 import {
   RelationType,
@@ -31,12 +32,50 @@ import { Database } from '../../../../../graph/metamodel/pure/packageableElement
 import { Column } from '../../../../../graph/metamodel/pure/packageableElements/store/relational/model/Column.js';
 import type { Table } from '../../../../../graph/metamodel/pure/packageableElements/store/relational/model/Table.js';
 import { mapRelationalDataTypeToPrimitiveType } from '../../../../../graph/helpers/STO_Relational_Helper.js';
-import type { V1_IngestDataset } from '../model/packageableElements/ingest/V1_IngestDefinition.js';
+import {
+  type V1_IngestDataset,
+  type V1_WriteMode,
+  V1_WriteModeType,
+} from '../model/packageableElements/ingest/V1_IngestDefinition.js';
 import type { V1_GraphBuilderContext } from '../transformation/pureGraph/to/V1_GraphBuilderContext.js';
 import { V1_GenericType as V1_GenericTypeProtocol } from '../model/packageableElements/type/V1_GenericType.js';
 import { V1_PackageableType } from '../model/packageableElements/type/V1_PackageableType.js';
-import { returnUndefOnError } from '@finos/legend-shared';
+import { returnUndefOnError, type PlainObject } from '@finos/legend-shared';
+import {
+  MILESTONE_INGEST_COLUMNS,
+  PRECISE_PRIMITIVE_TYPE,
+  PRIMITIVE_TYPE,
+} from '../../../../../graph/MetaModelConst.js';
+import type { RelationTypeMetadata } from '../../../../action/relation/RelationTypeMetadata.js';
 import { V1_deserializeIngestDefinitionContent } from '../transformation/pureProtocol/serializationHelpers/V1_IngestSerializationHelper.js';
+import {
+  RelationElement,
+  RelationElementsData,
+} from '../../../../../graph/metamodel/pure/data/EmbeddedData.js';
+import type { RawLambda } from '../../../../../graph/metamodel/pure/rawValueSpecification/RawLambda.js';
+import type { AbstractPureGraphManager } from '../../../../AbstractPureGraphManager.js';
+import type { PureModel } from '../../../../../graph/PureModel.js';
+import type { ConcreteFunctionDefinition } from '../../../../../graph/metamodel/pure/packageableElements/function/ConcreteFunctionDefinition.js';
+import { V1_deserializeValueSpecification } from '../transformation/pureProtocol/serializationHelpers/V1_ValueSpecificationSerializer.js';
+import type { PureProtocolProcessorPlugin } from '../../PureProtocolProcessorPlugin.js';
+import { V1_Lambda } from '../model/valueSpecification/raw/V1_Lambda.js';
+import { V1_AppliedFunction } from '../model/valueSpecification/application/V1_AppliedFunction.js';
+import { V1_ClassInstance } from '../model/valueSpecification/raw/V1_ClassInstance.js';
+import { V1_Collection } from '../model/valueSpecification/raw/V1_Collection.js';
+import {
+  type V1_Accessor,
+  V1_DataProductAccessor,
+  V1_IngestDefinitionAccessor,
+  V1_RelationStoreAccessor,
+} from '../model/valueSpecification/raw/classInstance/relation/V1_RelationStoreAccessor.js';
+import type { V1_ValueSpecification } from '../model/valueSpecification/V1_ValueSpecification.js';
+import {
+  type DataProduct,
+  LakehouseAccessPoint,
+} from '../../../../../graph/metamodel/pure/dataProduct/DataProduct.js';
+import type { V1_AccessPointImplementation } from '../lakehouse/deploy/V1_DataProductArtifact.js';
+import { V1_RelationType } from '../model/packageableElements/type/V1_RelationType.js';
+import { V1_getGenericTypeFullPath } from './V1_DomainHelper.js';
 
 const buildV1GenericType = (fullPath: string): V1_GenericTypeProtocol => {
   // Strip package prefix — primitive types are indexed by simple name
@@ -50,26 +89,85 @@ const buildV1GenericType = (fullPath: string): V1_GenericTypeProtocol => {
   return genericType;
 };
 
+const addMilestonedColumnsForWriteMode = (
+  relationType: RelationType,
+  writeMode: V1_WriteMode | undefined,
+  context: V1_GraphBuilderContext,
+): void => {
+  if (
+    writeMode?._type === V1_WriteModeType.BATCH_MILESTONED ||
+    writeMode?._type === V1_WriteModeType.BATCH_MILESTONED_BUSINESS_TEMPORAL
+  ) {
+    relationType.columns.push(
+      new RelationColumn(
+        MILESTONE_INGEST_COLUMNS.INGEST_LAKE_IN_ID,
+        context.resolveGenericTypeFromProtocolWithRelationType(
+          buildV1GenericType(PRIMITIVE_TYPE.INTEGER),
+        ),
+      ),
+    );
+    relationType.columns.push(
+      new RelationColumn(
+        MILESTONE_INGEST_COLUMNS.INGEST_LAKE_OUT_ID,
+        context.resolveGenericTypeFromProtocolWithRelationType(
+          buildV1GenericType(PRIMITIVE_TYPE.INTEGER),
+        ),
+      ),
+    );
+    relationType.columns.push(
+      new RelationColumn(
+        MILESTONE_INGEST_COLUMNS.INGEST_LAKE_DIGEST,
+        context.resolveGenericTypeFromProtocolWithRelationType(
+          buildV1GenericType(PRIMITIVE_TYPE.STRING),
+        ),
+      ),
+    );
+    if (
+      writeMode._type === V1_WriteModeType.BATCH_MILESTONED_BUSINESS_TEMPORAL
+    ) {
+      relationType.columns.push(
+        new RelationColumn(
+          MILESTONE_INGEST_COLUMNS.INGEST_LAKE_FROM,
+          context.resolveGenericTypeFromProtocolWithRelationType(
+            buildV1GenericType(PRECISE_PRIMITIVE_TYPE.TIMESTAMP),
+          ),
+        ),
+      );
+      relationType.columns.push(
+        new RelationColumn(
+          MILESTONE_INGEST_COLUMNS.INGEST_LAKE_THRU,
+          context.resolveGenericTypeFromProtocolWithRelationType(
+            buildV1GenericType(PRECISE_PRIMITIVE_TYPE.TIMESTAMP),
+          ),
+        ),
+      );
+    }
+  }
+};
+
 const buildRelationTypeFromIngestDataset = (
   dataset: V1_IngestDataset,
   context: V1_GraphBuilderContext,
+  effectiveWriteMode?: V1_WriteMode | undefined,
 ): RelationType => {
+  const writeMode = dataset.writeMode ?? effectiveWriteMode;
   const relationType = new RelationType('__ingest_dataset__');
   relationType.columns = dataset.source.schema.columns.map((col) => {
     const rawTypePath =
       col.genericType.rawType instanceof V1_PackageableType
         ? col.genericType.rawType.fullPath
-        : 'String';
+        : PRIMITIVE_TYPE.STRING;
     const v1GenericType = buildV1GenericType(rawTypePath);
     const resolvedGenericType =
       returnUndefOnError(() =>
         context.resolveGenericTypeFromProtocolWithRelationType(v1GenericType),
       ) ??
       context.resolveGenericTypeFromProtocolWithRelationType(
-        buildV1GenericType('String'),
+        buildV1GenericType(PRIMITIVE_TYPE.STRING),
       );
     return new RelationColumn(col.name, resolvedGenericType);
   });
+  addMilestonedColumnsForWriteMode(relationType, writeMode, context);
   return relationType;
 };
 
@@ -89,6 +187,42 @@ const buildRelationTypeFromTable = (table: Table): RelationType => {
   return relationType;
 };
 // TODO: move to pure graph
+/**
+ * Builds a metamodel `RelationType` from the cached `lambdaGenericType` on a
+ * `V1_AccessPointImplementation`. Returns `undefined` if the implementation
+ * does not carry a relation-typed generic type.
+ *
+ * Column types are resolved against the supplied `PureModel`.
+ */
+export const V1_buildRelationTypeFromAccessPointImplementation = (
+  apImpl: V1_AccessPointImplementation,
+  graph: PureModel,
+  relationTypeName?: string | undefined,
+): RelationType | undefined => {
+  const v1RelationType = apImpl.lambdaGenericType?.typeArguments
+    .map((typeArg) => typeArg.rawType)
+    .find(
+      (rawType): rawType is V1_RelationType =>
+        rawType instanceof V1_RelationType,
+    );
+  if (!v1RelationType) {
+    return undefined;
+  }
+  const relationType = new RelationType(relationTypeName ?? apImpl.id);
+  relationType.columns = v1RelationType.columns.map(
+    (col) =>
+      new RelationColumn(
+        col.name,
+        GenericTypeExplicitReference.create(
+          new GenericType(
+            graph.getType(V1_getGenericTypeFullPath(col.genericType)),
+          ),
+        ),
+      ),
+  );
+  return relationType;
+};
+
 /**
  * Creates an appropriate Accessor from a packageable element.
  *
@@ -118,7 +252,11 @@ export const V1_createAccessorFromPackageableElement = (
     if (!dataset) {
       return undefined;
     }
-    const relationType = buildRelationTypeFromIngestDataset(dataset, context);
+    const relationType = buildRelationTypeFromIngestDataset(
+      dataset,
+      context,
+      content.writeMode,
+    );
     return new IngestionAccessor(
       element.path,
       undefined,
@@ -154,3 +292,212 @@ export const V1_createAccessorFromPackageableElement = (
   }
   return undefined;
 };
+
+const buildRelationTypeFromMetadata = (
+  metadata: RelationTypeMetadata,
+  context: V1_GraphBuilderContext,
+): RelationType => {
+  const relationType = new RelationType('__data_product__');
+  relationType.columns = metadata.columns.map((col) => {
+    const v1GenericType = buildV1GenericType(col.type);
+    const resolvedGenericType =
+      returnUndefOnError(() =>
+        context.resolveGenericTypeFromProtocolWithRelationType(v1GenericType),
+      ) ??
+      context.resolveGenericTypeFromProtocolWithRelationType(
+        buildV1GenericType(PRIMITIVE_TYPE.STRING),
+      );
+    return new RelationColumn(col.name, resolvedGenericType);
+  });
+  return relationType;
+};
+
+export const V1_buildDataProductAccessor = async (
+  element: DataProduct,
+  context: V1_GraphBuilderContext,
+  graphManager: AbstractPureGraphManager,
+  options?: {
+    tableName?: string | undefined;
+  },
+): Promise<DataProductAccessor | undefined> => {
+  const accessPointId = options?.tableName;
+  const accessPoint = element.accessPointGroups
+    .flatMap((g) => g.accessPoints)
+    .filter(
+      (ap): ap is LakehouseAccessPoint => ap instanceof LakehouseAccessPoint,
+    )
+    .find((ap) => ap.id === accessPointId);
+  if (!accessPoint) {
+    return undefined;
+  }
+  const relationTypeMetadata = await graphManager.getLambdaRelationType(
+    accessPoint.func,
+    context.graph,
+  );
+  const relationType = buildRelationTypeFromMetadata(
+    relationTypeMetadata,
+    context,
+  );
+  return new DataProductAccessor(
+    element.path,
+    undefined,
+    accessPoint.id,
+    relationType,
+    element,
+  );
+};
+
+const collectV1AccessorsFromValueSpecification = (
+  valueSpec: V1_ValueSpecification,
+  accessors: V1_Accessor[],
+  visited: Set<V1_ValueSpecification>,
+  plugins: PureProtocolProcessorPlugin[],
+  graph: PureModel | undefined,
+  visitedFunctions: Set<ConcreteFunctionDefinition>,
+): void => {
+  if (visited.has(valueSpec)) {
+    return;
+  }
+  visited.add(valueSpec);
+
+  if (valueSpec instanceof V1_ClassInstance) {
+    const val = valueSpec.value;
+    if (
+      val instanceof V1_DataProductAccessor ||
+      val instanceof V1_IngestDefinitionAccessor ||
+      val instanceof V1_RelationStoreAccessor
+    ) {
+      if (!accessors.includes(val)) {
+        accessors.push(val);
+      }
+    }
+  } else if (valueSpec instanceof V1_AppliedFunction) {
+    // Walk parameters in case they contain inline accessors
+    for (const param of valueSpec.parameters) {
+      collectV1AccessorsFromValueSpecification(
+        param,
+        accessors,
+        visited,
+        plugins,
+        graph,
+        visitedFunctions,
+      );
+    }
+    // Also follow the function body if it's a user-defined function in the graph
+    if (graph) {
+      const funcPath = valueSpec.function;
+      // ConcreteFunctionDefinition paths include the signature suffix; strip it
+      // by matching functions whose path starts with the applied function name
+      const funcDef = returnUndefOnError(() =>
+        graph.functions.find(
+          (f) => f.path === funcPath || f.path.startsWith(`${funcPath}_`),
+        ),
+      );
+      if (funcDef && !visitedFunctions.has(funcDef)) {
+        visitedFunctions.add(funcDef);
+        // expressionSequence is stored as raw JSON on ConcreteFunctionDefinition
+        for (const rawExpr of funcDef.expressionSequence) {
+          try {
+            const exprSpec = V1_deserializeValueSpecification(
+              rawExpr as PlainObject<V1_ValueSpecification>,
+              plugins,
+            );
+            collectV1AccessorsFromValueSpecification(
+              exprSpec,
+              accessors,
+              visited,
+              plugins,
+              graph,
+              visitedFunctions,
+            );
+          } catch {
+            // ignore
+          }
+        }
+      }
+    }
+  } else if (valueSpec instanceof V1_Lambda) {
+    for (const expr of valueSpec.body) {
+      collectV1AccessorsFromValueSpecification(
+        expr,
+        accessors,
+        visited,
+        plugins,
+        graph,
+        visitedFunctions,
+      );
+    }
+  } else if (valueSpec instanceof V1_Collection) {
+    for (const val of valueSpec.values) {
+      collectV1AccessorsFromValueSpecification(
+        val,
+        accessors,
+        visited,
+        plugins,
+        graph,
+        visitedFunctions,
+      );
+    }
+  }
+};
+
+export const V1_buildRelationElementsDataFromAccessors = (
+  accessorsForParent: Accessor[],
+): RelationElementsData => {
+  const relationElementsData = new RelationElementsData();
+  relationElementsData.relationElements = accessorsForParent.map((accessor) => {
+    const relationElement = new RelationElement();
+    if (accessor instanceof RelationalStoreAccessor) {
+      const schema = accessor.schema;
+      relationElement.paths =
+        schema !== undefined ? [schema, accessor.accessor] : ['UNKNOWN'];
+    } else {
+      relationElement.paths = [accessor.accessor || 'UNKNOWN'];
+    }
+    relationElement.columns = accessor.relationType.columns.map(
+      (column) => column.name,
+    );
+    relationElement.rows = [];
+    return relationElement;
+  });
+  return relationElementsData;
+};
+
+export const V1_resolveAccessorsFromRawLambda = (
+  rawLambda: RawLambda,
+  graphManager: AbstractPureGraphManager,
+  plugins: PureProtocolProcessorPlugin[],
+  graph?: PureModel | undefined,
+): V1_Accessor[] | undefined => {
+  try {
+    const json = graphManager.serializeRawValueSpecification(rawLambda);
+    const v1ValueSpec = V1_deserializeValueSpecification(json, plugins);
+    const accessors: V1_Accessor[] = [];
+    const visited = new Set<V1_ValueSpecification>();
+    const visitedFunctions = new Set<ConcreteFunctionDefinition>();
+    if (v1ValueSpec instanceof V1_Lambda) {
+      for (const expr of v1ValueSpec.body) {
+        collectV1AccessorsFromValueSpecification(
+          expr,
+          accessors,
+          visited,
+          plugins,
+          graph,
+          visitedFunctions,
+        );
+      }
+    } else {
+      collectV1AccessorsFromValueSpecification(
+        v1ValueSpec,
+        accessors,
+        visited,
+        plugins,
+        graph,
+        visitedFunctions,
+      );
+    }
+    return accessors;
+  } catch {
+    return undefined;
+  }
+};

package/src/graph-manager/protocol/pure/v1/model/data/V1_DataResolver.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../../graph/Core_HashUtils.js';
+import type { V1_EmbeddedData } from './V1_EmbeddedData.js';
+import type { V1_PackageableElementPointer } from '../packageableElements/V1_PackageableElement.js';
+
+export abstract class V1_DataResolver implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_BaseDataResolver extends V1_DataResolver implements Hashable {
+  data!: V1_EmbeddedData;
+  elementPointer!: V1_PackageableElementPointer;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.BASE_DATA_RESOLVER,
+      this.data,
+      this.elementPointer.path,
+    ]);
+  }
+}
+
+export class V1_ReferenceDataResolver
+  extends V1_DataResolver
+  implements Hashable
+{
+  elementPointer!: V1_PackageableElementPointer;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.REFERENCE_DATA_RESOLVER,
+      this.elementPointer.path,
+    ]);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/data/V1_EmbeddedData.ts

@@ -139,15 +139,15 @@ export class V1_RelationRowTestData implements Hashable {
 }
 
 export class V1_RelationElement implements Hashable {
-  paths!: string[];
   columns!: string[];
+  paths!: string[];
   rows: V1_RelationRowTestData[] = [];
 
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.RELATION_ELEMENT,
-      hashArray(this.paths),
       hashArray(this.columns),
+      hashArray(this.paths),
       hashArray(this.rows),
     ]);
   }

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

@@ -34,6 +34,7 @@ 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';
+import type { V1_DataProductTestSuite } from './test/V1_DataProductTestSuite.js';
 
 export const V1_DATA_PRODUCT_ELEMENT_PROTOCOL_TYPE = 'dataProduct';
 
@@ -441,6 +442,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
   sampleValues: V1_EmbeddedData[] | undefined;
   operationalMetadata: V1_DataProductOperationalMetadata | undefined;
   owner: V1_DataProductOwner | undefined;
+  testSuites: V1_DataProductTestSuite[] | undefined;
 
   override get hashCode(): string {
     return hashArray([
@@ -457,6 +459,7 @@ export class V1_DataProduct extends V1_PackageableElement implements Hashable {
       hashArray(this.sampleValues ?? []),
       this.operationalMetadata ?? '',
       this.owner ?? '',
+      hashArray(this.testSuites ?? []),
     ]);
   }