@finos/legend-extension-dsl-data-quality 1.0.0

package/src/graph-manager/protocol/pure/DSL_DataQuality_PureProtocolProcessorPlugin.ts

@@ -0,0 +1,283 @@
+/**
+ * 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 packageJson from '../../../../package.json';
+import { type PlainObject, assertType } from '@finos/legend-shared';
+import {
+  V1_DataQualityClassValidationsConfiguration,
+  V1_DataQualityServiceValidationsConfiguration,
+} from './v1/V1_DataQualityConstraintsConfiguration.js';
+import {
+  DataQualityClassValidationsConfiguration,
+  DataQualityServiceValidationConfiguration,
+} from '../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import {
+  getOwnDataQualityClassValidationsConfiguration,
+  getOwnDataQualityServiceValidationsConfiguration,
+} from '../../DSL_DataQuality_GraphManagerHelper.js';
+import {
+  V1_DATA_QUALITY_PROTOCOL_TYPE,
+  V1_DATA_QUALITY_SERVICE_PROTOCOL_TYPE,
+  V1_deserializeDataQualityClassValidation,
+  V1_deserializeDataQualityServiceValidation,
+  V1_serializeDataQualityClassValidation,
+  V1_serializeDataQualityServiceValidation,
+} from './v1/transformation/pureProtocol/V1_DSL_DataQuality_ProtocolHelper.js';
+import {
+  V1_transformDataQualityExecutionContext,
+  V1_transformDataQualityGraphFetchTree,
+} from './v1/transformation/V1_ValueSpecificationTransformer.js';
+import {
+  V1_buildDataQualityExecutionContext,
+  V1_buildDataQualityGraphFetchTree,
+} from './v1/transformation/V1_ValueSpecificationBuilderHelper.js';
+import type { V1_DataQualityRootGraphFetchTree } from './v1/model/graphFetch/V1_DataQualityRootGraphFetchTree.js';
+import {
+  type V1_ElementProtocolClassifierPathGetter,
+  type V1_ElementProtocolDeserializer,
+  type V1_ElementProtocolSerializer,
+  type V1_ElementTransformer,
+  type V1_GraphBuilderContext,
+  type V1_GraphTransformerContext,
+  type V1_PackageableElement,
+  type PackageableElement,
+  V1_buildFullPath,
+  V1_buildRawLambdaWithResolvedPaths,
+  V1_initPackageableElement,
+  V1_transformRawLambda,
+  V1_ElementBuilder,
+  V1_ProcessingContext,
+  PureProtocolProcessorPlugin,
+} from '@finos/legend-graph';
+import type { DataQualityRootGraphFetchTree } from '../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';
+
+const DATA_QUALITY_CLASSIFIER_PATH =
+  'meta::pure::metamodel::dataquality::DataQuality';
+
+export class DSL_DataQuality_PureProtocolProcessorPlugin extends PureProtocolProcessorPlugin {
+  constructor() {
+    super(
+      packageJson.extensions.pureProtocolProcessorPlugin,
+      packageJson.version,
+    );
+  }
+
+  override V1_getExtraElementBuilders(): V1_ElementBuilder<V1_PackageableElement>[] {
+    return [
+      new V1_ElementBuilder<V1_DataQualityClassValidationsConfiguration>({
+        elementClassName: V1_DATA_QUALITY_PROTOCOL_TYPE,
+        _class: V1_DataQualityClassValidationsConfiguration,
+        firstPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): PackageableElement => {
+          assertType(
+            elementProtocol,
+            V1_DataQualityClassValidationsConfiguration,
+          );
+          const element = new DataQualityClassValidationsConfiguration(
+            elementProtocol.name,
+          );
+          const path = V1_buildFullPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          context.currentSubGraph.setOwnElementInExtension(
+            path,
+            element,
+            DataQualityClassValidationsConfiguration,
+          );
+          return element;
+        },
+        secondPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): void => {
+          assertType(
+            elementProtocol,
+            V1_DataQualityClassValidationsConfiguration,
+          );
+          const path = V1_buildFullPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          const element = getOwnDataQualityClassValidationsConfiguration(
+            path,
+            context.currentSubGraph,
+          );
+          element.context = V1_buildDataQualityExecutionContext(
+            elementProtocol.context,
+            context,
+          );
+          element.dataQualityRootGraphFetchTree =
+            elementProtocol.dataQualityRootGraphFetchTree
+              ? (V1_buildDataQualityGraphFetchTree(
+                  elementProtocol.dataQualityRootGraphFetchTree,
+                  context,
+                  undefined,
+                  [],
+                  new V1_ProcessingContext(''),
+                  true,
+                ) as DataQualityRootGraphFetchTree)
+              : undefined;
+          element.filter = elementProtocol.filter
+            ? V1_buildRawLambdaWithResolvedPaths(
+                elementProtocol.filter.parameters,
+                elementProtocol.filter.body,
+                context,
+              )
+            : undefined;
+        },
+      }),
+      //TODO handle service validations
+      new V1_ElementBuilder<V1_DataQualityServiceValidationsConfiguration>({
+        elementClassName: 'dataQualityServiceValidations',
+        _class: V1_DataQualityServiceValidationsConfiguration,
+        firstPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): PackageableElement => {
+          assertType(
+            elementProtocol,
+            V1_DataQualityServiceValidationsConfiguration,
+          );
+          const element = new DataQualityServiceValidationConfiguration(
+            elementProtocol.name,
+          );
+          const path = V1_buildFullPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          context.currentSubGraph.setOwnElementInExtension(
+            path,
+            element,
+            DataQualityServiceValidationConfiguration,
+          );
+          return element;
+        },
+        secondPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): void => {
+          assertType(
+            elementProtocol,
+            V1_DataQualityServiceValidationsConfiguration,
+          );
+          const path = V1_buildFullPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          const element = getOwnDataQualityServiceValidationsConfiguration(
+            path,
+            context.currentSubGraph,
+          );
+          element.contextName = elementProtocol.contextName;
+          element.serviceName = elementProtocol.serviceName;
+          element.dataQualityRootGraphFetchTree =
+            elementProtocol.dataQualityRootGraphFetchTree
+              ? (V1_buildDataQualityGraphFetchTree(
+                  elementProtocol.dataQualityRootGraphFetchTree,
+                  context,
+                  undefined,
+                  [],
+                  new V1_ProcessingContext(''),
+                  true,
+                ) as DataQualityRootGraphFetchTree)
+              : undefined;
+        },
+      }),
+    ];
+  }
+
+  override V1_getExtraElementClassifierPathGetters(): V1_ElementProtocolClassifierPathGetter[] {
+    return [
+      (protocol: V1_PackageableElement): string | undefined => {
+        if (protocol instanceof V1_DataQualityClassValidationsConfiguration) {
+          return DATA_QUALITY_CLASSIFIER_PATH;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolSerializers(): V1_ElementProtocolSerializer[] {
+    return [
+      (
+        protocol: V1_PackageableElement,
+        plugins: PureProtocolProcessorPlugin[],
+      ): PlainObject<V1_PackageableElement> | undefined => {
+        if (protocol instanceof V1_DataQualityClassValidationsConfiguration) {
+          return V1_serializeDataQualityClassValidation(protocol);
+        }
+        if (protocol instanceof V1_DataQualityServiceValidationsConfiguration) {
+          return V1_serializeDataQualityServiceValidation(protocol);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolDeserializers(): V1_ElementProtocolDeserializer[] {
+    return [
+      (
+        json: PlainObject<V1_PackageableElement>,
+        plugins: PureProtocolProcessorPlugin[],
+      ): V1_PackageableElement | undefined => {
+        if (json._type === V1_DATA_QUALITY_PROTOCOL_TYPE) {
+          return V1_deserializeDataQualityClassValidation(json);
+        }
+        if (json._type === V1_DATA_QUALITY_SERVICE_PROTOCOL_TYPE) {
+          return V1_deserializeDataQualityServiceValidation(json);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementTransformers(): V1_ElementTransformer[] {
+    return [
+      (
+        metamodel: PackageableElement,
+        context: V1_GraphTransformerContext,
+      ): V1_PackageableElement | undefined => {
+        if (metamodel instanceof DataQualityClassValidationsConfiguration) {
+          const protocol = new V1_DataQualityClassValidationsConfiguration();
+          V1_initPackageableElement(protocol, metamodel);
+          protocol.name = metamodel.name;
+          protocol.package = metamodel.package?.path ?? '';
+          protocol.dataQualityRootGraphFetchTree =
+            metamodel.dataQualityRootGraphFetchTree
+              ? (V1_transformDataQualityGraphFetchTree(
+                  metamodel.dataQualityRootGraphFetchTree,
+                  [],
+                  new Map<string, unknown[]>(),
+                  false,
+                  false,
+                ) as V1_DataQualityRootGraphFetchTree)
+              : undefined;
+          protocol.context = V1_transformDataQualityExecutionContext(
+            metamodel.context,
+          );
+          protocol.filter = metamodel.filter
+            ? V1_transformRawLambda(metamodel.filter, context)
+            : undefined;
+          return protocol;
+        }
+        return undefined;
+      },
+    ];
+  }
+}

package/src/graph-manager/protocol/pure/DSL_DataQuality_buildGraphManagerExtension.ts

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type {
+  AbstractPureGraphManager,
+  AbstractPureGraphManagerExtension,
+} from '@finos/legend-graph';
+import { V1_DSL_Data_Quality_PureGraphManagerExtension } from './v1/V1_DSL_Data_Quality_PureGraphManagerExtension.js';
+
+export const DSL_DataQuality_buildGraphManagerExtension = (
+  graphManager: AbstractPureGraphManager,
+): AbstractPureGraphManagerExtension =>
+  // NOTE: until we support more client versions, we always default to return V1
+  new V1_DSL_Data_Quality_PureGraphManagerExtension(graphManager);

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

@@ -0,0 +1,246 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type AbstractPureGraphManager,
+  type RawExecutionPlan,
+  type ExecutionResult,
+  type PureModel,
+  type RootGraphFetchTree,
+  type GraphDataOrigin,
+  type V1_RootGraphFetchTree,
+  type V1_PureModelContext,
+  LegendSDLC,
+  PureClientVersion,
+  V1_GraphBuilderContextBuilder,
+  V1_LegendSDLC,
+  V1_ProcessingContext,
+  V1_Protocol,
+  V1_PureGraphManager,
+  V1_PureModelContextPointer,
+  V1_pureModelContextPropSchema,
+} from '@finos/legend-graph';
+import { createModelSchema, optional, primitive } from 'serializr';
+import {
+  guaranteeType,
+  SerializationFactory,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { DSL_DataQuality_PureGraphManagerExtension } from '../DSL_DataQuality_PureGraphManagerExtension.js';
+import {
+  V1_transformRootGraphFetchTreeToDataQualityRootGraphFetchTree,
+  V1_buildDataQualityGraphFetchTree,
+} from './transformation/V1_ValueSpecificationBuilderHelper.js';
+import type { DataQualityRootGraphFetchTree } from '../../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';
+
+const DQ_GENERATE_EXECUTION_PLAN = 'generate execution plan';
+const DQ_EXECUTE_PLAN = 'execute plan';
+const DQ_DEBUG_EXECUTION_PLAN = 'debug execution plan';
+const DQ_FETCH_PROPERTY_PATH_TREE = 'dq fetch property path tree';
+
+export class V1_DQExecuteInput {
+  clientVersion: string | undefined;
+  model!: V1_PureModelContext;
+  packagePath!: string;
+  queryLimit: number | undefined;
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DQExecuteInput, {
+      clientVersion: optional(primitive()),
+      model: V1_pureModelContextPropSchema,
+      packagePath: primitive(),
+      queryLimit: optional(primitive()),
+    }),
+  );
+}
+
+export class V1_DSL_Data_Quality_PureGraphManagerExtension extends DSL_DataQuality_PureGraphManagerExtension {
+  declare graphManager: V1_PureGraphManager;
+  static readonly DEV_PROTOCOL_VERSION = PureClientVersion.VX_X_X;
+
+  constructor(graphManager: AbstractPureGraphManager) {
+    super(graphManager);
+    this.graphManager = guaranteeType(graphManager, V1_PureGraphManager);
+  }
+
+  getSupportedProtocolVersion(): string {
+    return PureClientVersion.V1_0_0;
+  }
+
+  private buildPureModelSDLCPointer(
+    origin: GraphDataOrigin,
+    clientVersion: string | undefined,
+  ): V1_PureModelContextPointer {
+    if (origin instanceof LegendSDLC) {
+      return new V1_PureModelContextPointer(
+        clientVersion
+          ? new V1_Protocol(
+              V1_PureGraphManager.PURE_PROTOCOL_NAME,
+              clientVersion,
+            )
+          : undefined,
+        new V1_LegendSDLC(origin.groupId, origin.artifactId, origin.versionId),
+      );
+    }
+    throw new UnsupportedOperationError('Unsupported graph origin');
+  }
+
+  createExecutionInput(
+    graph: PureModel,
+    packagePath: string,
+    clientVersion: string | undefined,
+    previewLimit: number | undefined,
+    dqExecuteInput: V1_DQExecuteInput,
+  ): V1_DQExecuteInput {
+    dqExecuteInput.clientVersion = clientVersion;
+    dqExecuteInput.model = graph.origin
+      ? this.buildPureModelSDLCPointer(graph.origin, undefined)
+      : this.graphManager.getFullGraphModelData(graph);
+    dqExecuteInput.packagePath = packagePath;
+    dqExecuteInput.queryLimit = previewLimit;
+    return dqExecuteInput;
+  }
+
+  generatePlan = async (
+    graph: PureModel,
+    packagePath: string,
+  ): Promise<RawExecutionPlan> => {
+    const input = this.createExecutionInput(
+      graph,
+      packagePath,
+      V1_DSL_Data_Quality_PureGraphManagerExtension.DEV_PROTOCOL_VERSION,
+      undefined,
+      new V1_DQExecuteInput(),
+    );
+
+    const serializedInput = V1_DQExecuteInput.serialization.toJson(input);
+
+    const engineServerClient = this.graphManager.engine.getEngineServerClient();
+
+    return engineServerClient.postWithTracing(
+      engineServerClient.getTraceData(DQ_GENERATE_EXECUTION_PLAN),
+      `${engineServerClient._pure()}/dataquality/generatePlan`,
+      serializedInput,
+      {},
+      undefined,
+      undefined,
+      { enableCompression: true },
+    );
+  };
+
+  execute = async (
+    graph: PureModel,
+    packagePath: string,
+    previewLimit: number,
+  ): Promise<ExecutionResult> => {
+    const input = this.createExecutionInput(
+      graph,
+      packagePath,
+      V1_DSL_Data_Quality_PureGraphManagerExtension.DEV_PROTOCOL_VERSION,
+      previewLimit,
+      new V1_DQExecuteInput(),
+    );
+
+    const serializedInput = V1_DQExecuteInput.serialization.toJson(input);
+    const engineServerClient = this.graphManager.engine.getEngineServerClient();
+
+    return engineServerClient.postWithTracing(
+      engineServerClient.getTraceData(DQ_EXECUTE_PLAN),
+      `${engineServerClient._pure()}/dataquality/execute`,
+      serializedInput,
+      {},
+      undefined,
+      undefined,
+      { enableCompression: true },
+    );
+  };
+
+  debugExecutionPlanGeneration = async (
+    graph: PureModel,
+    packagePath: string,
+  ): Promise<{ plan: RawExecutionPlan; debug: string }> => {
+    const input = this.createExecutionInput(
+      graph,
+      packagePath,
+      V1_DSL_Data_Quality_PureGraphManagerExtension.DEV_PROTOCOL_VERSION,
+      undefined,
+      new V1_DQExecuteInput(),
+    );
+
+    const serializedInput = V1_DQExecuteInput.serialization.toJson(input);
+    const engineServerClient = this.graphManager.engine.getEngineServerClient();
+
+    const result: { plan: RawExecutionPlan; debug: string[] } =
+      await engineServerClient.postWithTracing(
+        engineServerClient.getTraceData(DQ_DEBUG_EXECUTION_PLAN),
+        `${engineServerClient._pure()}/dataquality/debugPlan`,
+        serializedInput,
+        {},
+        undefined,
+        undefined,
+        { enableCompression: true },
+      );
+    return {
+      plan: result.plan,
+      debug: result.debug.join('\n'),
+    };
+  };
+
+  fetchStructuralValidations = async (
+    graph: PureModel,
+    packagePath: string,
+  ): Promise<RootGraphFetchTree> => {
+    const engineServerClient = this.graphManager.engine.getEngineServerClient();
+    const input = this.createExecutionInput(
+      graph,
+      packagePath,
+      V1_DSL_Data_Quality_PureGraphManagerExtension.DEV_PROTOCOL_VERSION,
+      undefined,
+      new V1_DQExecuteInput(),
+    );
+
+    const serializedInput = V1_DQExecuteInput.serialization.toJson(input);
+    const V1_rootGraphFetchTree: V1_RootGraphFetchTree =
+      await engineServerClient.postWithTracing(
+        engineServerClient.getTraceData(DQ_FETCH_PROPERTY_PATH_TREE),
+        `${engineServerClient._pure()}/dataquality/propertyPathTree`,
+        serializedInput,
+        {},
+        undefined,
+        undefined,
+        { enableCompression: true },
+      );
+
+    const V1_dataQualityRootGraphFetchTree =
+      V1_transformRootGraphFetchTreeToDataQualityRootGraphFetchTree(
+        V1_rootGraphFetchTree,
+      );
+    const context = new V1_GraphBuilderContextBuilder(
+      graph,
+      graph,
+      this.graphManager.graphBuilderExtensions,
+      this.graphManager.logService,
+    ).build();
+    return V1_buildDataQualityGraphFetchTree(
+      V1_dataQualityRootGraphFetchTree,
+      context,
+      undefined,
+      [],
+      new V1_ProcessingContext(''),
+      true,
+    ) as DataQualityRootGraphFetchTree;
+  };
+}

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

@@ -0,0 +1,103 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  type V1_PackageableElementVisitor,
+  type V1_PackageableElementPointer,
+  type V1_RawLambda,
+  V1_PackageableElement,
+} from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { DATA_QUALITY_HASH_STRUCTURE } from '../../../../graph/metamodel/DSL_DataQuality_HashUtils.js';
+import { type V1_DataQualityRootGraphFetchTree } from './model/graphFetch/V1_DataQualityRootGraphFetchTree.js';
+
+export abstract class V1_DataQualityExecutionContext implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_DataSpaceDataQualityExecutionContext extends V1_DataQualityExecutionContext {
+  context!: string;
+  dataSpace!: V1_PackageableElementPointer;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALTIY_DATASPACE_EXECUTION_CONTEXT,
+      this.context,
+      this.dataSpace.path,
+    ]);
+  }
+}
+
+export class V1_MappingAndRuntimeDataQualityExecutionContext extends V1_DataQualityExecutionContext {
+  mapping!: V1_PackageableElementPointer;
+  runtime!: V1_PackageableElementPointer;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_MAPPING_AND_RUNTIME_EXECUTION_CONTEXT,
+      this.mapping.path,
+      this.runtime.path,
+    ]);
+  }
+}
+
+export class V1_DataQualityClassValidationsConfiguration
+  extends V1_PackageableElement
+  implements Hashable
+{
+  context!: V1_DataQualityExecutionContext;
+  dataQualityRootGraphFetchTree: V1_DataQualityRootGraphFetchTree | undefined;
+  filter?: V1_RawLambda | undefined;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_CONSTRAINTS_CONFIGURATION,
+      this.context,
+      this.filter ?? '',
+      this.dataQualityRootGraphFetchTree ?? '',
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}
+
+export class V1_DataQualityServiceValidationsConfiguration
+  extends V1_PackageableElement
+  implements Hashable
+{
+  contextName?: string | undefined;
+  serviceName?: string | undefined;
+  dataQualityRootGraphFetchTree?: V1_DataQualityRootGraphFetchTree | undefined;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_SERVICE_VALIDATION_CONFIGURATION,
+      this.contextName ?? '',
+      this.serviceName ?? '',
+      this.dataQualityRootGraphFetchTree ?? '',
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/graphFetch/V1_DataQualityPropertyGraphFetchTree.ts

@@ -0,0 +1,37 @@
+/**
+ * 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 { V1_PropertyGraphFetchTree } from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { DATA_QUALITY_HASH_STRUCTURE } from '../../../../../../graph/metamodel/DSL_DataQuality_HashUtils.js';
+
+export class V1_DataQualityPropertyGraphFetchTree
+  extends V1_PropertyGraphFetchTree
+  implements Hashable
+{
+  constraints: string[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_PROPERTY_GRAPH_FETCH_TREE,
+      hashArray(this.subTrees),
+      this.property,
+      this.alias ?? '',
+      this.subType ?? '',
+      hashArray(this.constraints),
+    ]);
+  }
+}