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

package/src/components/utils/DataQualityGraphFetchTreeUtil.ts

@@ -0,0 +1,592 @@
+/**
+ * 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 TreeData, type TreeNodeData } from '@finos/legend-art';
+import {
+  type Hashable,
+  addUniqueEntry,
+  assertErrorThrown,
+  assertType,
+  deleteEntry,
+  hashArray,
+  LogEvent,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import { action, computed, makeObservable, observable } from 'mobx';
+import {
+  type AbstractProperty,
+  type Type,
+  type Constraint,
+  type GraphFetchTree,
+  type RawLambda,
+  Class,
+  GRAPH_MANAGER_EVENT,
+  PackageableElementExplicitReference,
+  PropertyExplicitReference,
+  getAllClassConstraints,
+  isStubbed_RawLambda,
+  TYPE_CAST_TOKEN,
+} from '@finos/legend-graph';
+import {
+  type QueryBuilderExplorerTreeNodeData,
+  graphFetchTree_addSubTree,
+  graphFetchTree_removeSubTree,
+  type QueryBuilderExplorerTreeRootNodeData,
+  QueryBuilderExplorerTreePropertyNodeData,
+  QueryBuilderExplorerTreeSubTypeNodeData,
+} from '@finos/legend-query-builder';
+import type { DataQualityState } from '../states/DataQualityState.js';
+import {
+  DataQualityPropertyGraphFetchTree,
+  DataQualityRootGraphFetchTree,
+} from '../../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';
+import { ConstraintState } from '../states/ConstraintState.js';
+import type { EditorStore } from '@finos/legend-application-studio';
+import { DATA_QUALITY_HASH_STRUCTURE } from '../../graph/metamodel/DSL_DataQuality_HashUtils.js';
+import {
+  dataQualityGraphFetchTree_removeConstraints,
+  graphFetchTree_removeAllSubTrees,
+} from '../../graph-manager/DSL_DataQuality_GraphModifierHelper.js';
+
+export class DataQualityGraphFetchTreeNodeData
+  implements TreeNodeData, Hashable
+{
+  readonly id: string;
+  readonly label: string;
+  readonly tree:
+    | DataQualityPropertyGraphFetchTree
+    | DataQualityRootGraphFetchTree;
+  readonly parentId?: string | undefined;
+  readonly editorStore: EditorStore;
+  isOpen?: boolean | undefined;
+  isReadOnly?: boolean;
+  childrenIds: string[] = [];
+  constraints: ConstraintState[] = [];
+
+  constructor(
+    editorStore: EditorStore,
+    id: string,
+    label: string,
+    parentId: string | undefined,
+    graphFetchTreeNode:
+      | DataQualityPropertyGraphFetchTree
+      | DataQualityRootGraphFetchTree,
+  ) {
+    makeObservable(this, {
+      hashCode: computed,
+      constraints: observable,
+      isReadOnly: observable,
+      setConstraintsForClass: action,
+      setIsReadOnly: action,
+    });
+
+    this.id = id;
+    this.label = label;
+    this.parentId = parentId;
+    this.tree = graphFetchTreeNode;
+    // NOTE: in this tree, every node is open
+    this.isOpen = true;
+    this.editorStore = editorStore;
+  }
+
+  setIsReadOnly(isReadOnly: boolean) {
+    this.isReadOnly = isReadOnly;
+  }
+
+  setConstraintsForClass(_class: Class, constraintsToSelect: string[]) {
+    const constraints = getAllClassConstraints(_class).map(
+      (constraint) => new ConstraintState(constraint),
+    );
+    const lambdas = new Map<string, RawLambda>();
+    const index = new Map<string, ConstraintState>();
+    constraints.forEach((constraintState) => {
+      if (!isStubbed_RawLambda(constraintState.constraint.functionDefinition)) {
+        lambdas.set(
+          constraintState.lambdaId,
+          constraintState.constraint.functionDefinition,
+        );
+        index.set(constraintState.lambdaId, constraintState);
+        if (
+          constraintsToSelect.find(
+            (constraintName) =>
+              constraintState.constraint.name === constraintName,
+          )
+        ) {
+          constraintState.isSelected = true;
+        }
+      }
+    });
+    if (lambdas.size) {
+      this.editorStore.graphManagerState.graphManager
+        .lambdasToPureCode(lambdas)
+        .then((res: Map<string, string>) => {
+          res.forEach((grammarText: string, key: string) => {
+            const constraintState = index.get(key);
+            constraintState?.setLambdaString(
+              constraintState.extractLambdaString(grammarText),
+            );
+          });
+          this.constraints = constraints;
+        })
+        .catch((error) => {
+          assertErrorThrown(error);
+          this.editorStore.applicationStore.logService.error(
+            LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+            error,
+          );
+        });
+    }
+  }
+
+  get type(): Type {
+    if (this.tree instanceof DataQualityPropertyGraphFetchTree) {
+      return this.tree.property.value.genericType.value.rawType;
+    }
+    if (this.tree instanceof DataQualityRootGraphFetchTree) {
+      return this.tree.class.value;
+    }
+    throw new UnsupportedOperationError(
+      `Can't get type of Graph Fetch Tree`,
+      this.tree,
+    );
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_GRAPH_FETCH_TREE_NODE_DATA,
+      this.id,
+      this.label,
+      this.tree,
+      this.parentId ?? '',
+      hashArray(this.childrenIds),
+    ]);
+  }
+}
+
+export interface DataQualityGraphFetchTreeData
+  extends TreeData<DataQualityGraphFetchTreeNodeData> {
+  tree: DataQualityRootGraphFetchTree;
+}
+
+export const generateRootGraphFetchTreeNodeID = (
+  parentNodeId: string | undefined,
+  classValue: string | undefined,
+): string =>
+  `${parentNodeId ? `${parentNodeId}.` : ''}${
+    classValue ? `${TYPE_CAST_TOKEN}${classValue}` : ''
+  }`;
+
+const getPrunableNodes = (
+  treeData: DataQualityGraphFetchTreeData,
+): DataQualityGraphFetchTreeNodeData[] =>
+  Array.from(treeData.nodes.values()).filter(
+    (node) =>
+      (node.type instanceof Class &&
+        node.childrenIds.length === 0 &&
+        node.constraints.length === 0) ||
+      // orphan node
+      (node.tree instanceof DataQualityPropertyGraphFetchTree &&
+        node.parentId &&
+        !treeData.nodes.has(node.parentId)),
+  );
+
+const removeNode = (
+  treeData: DataQualityGraphFetchTreeData,
+  node: DataQualityGraphFetchTreeNodeData,
+): void => {
+  const parentNode = node.parentId
+    ? treeData.nodes.get(node.parentId)
+    : undefined;
+  if (parentNode) {
+    deleteEntry(parentNode.childrenIds, node.id);
+    graphFetchTree_removeSubTree(parentNode.tree, node.tree);
+  } else {
+    if (node.tree instanceof DataQualityRootGraphFetchTree) {
+      deleteEntry(treeData.rootIds, node.id);
+      dataQualityGraphFetchTree_removeConstraints(node.tree);
+      graphFetchTree_removeAllSubTrees(node.tree);
+    }
+    graphFetchTree_removeSubTree(treeData.tree, node.tree);
+  }
+  treeData.nodes.delete(node.id);
+};
+const pruneTreeData = (treeData: DataQualityGraphFetchTreeData): void => {
+  let prunableNodes = getPrunableNodes(treeData);
+  while (prunableNodes.length) {
+    prunableNodes.forEach((node) => {
+      removeNode(treeData, node);
+    });
+    prunableNodes = getPrunableNodes(treeData);
+  }
+};
+export const removeNodeRecursively = (
+  treeData: DataQualityGraphFetchTreeData,
+  node: DataQualityGraphFetchTreeNodeData,
+): void => {
+  removeNode(treeData, node);
+  pruneTreeData(treeData);
+};
+
+export const generateGraphFetchTreeNodeID = (
+  property: AbstractProperty,
+  parentNodeId: string | undefined,
+  subType: Type | undefined,
+): string =>
+  `${parentNodeId ? `${parentNodeId}.` : ''}${property.name}${
+    subType ? `${TYPE_CAST_TOKEN}${subType.path}` : ''
+  }`;
+
+const buildGraphFetchSubTree = (
+  editorStore: EditorStore,
+  tree: GraphFetchTree,
+  parentNode: DataQualityGraphFetchTreeNodeData | undefined,
+  nodes: Map<string, DataQualityGraphFetchTreeNodeData>,
+  fetchConstraints: boolean,
+  isReadOnly: boolean,
+): DataQualityGraphFetchTreeNodeData => {
+  assertType(
+    tree,
+    DataQualityPropertyGraphFetchTree,
+    'Graph fetch sub-tree must be a property graph fetch tree',
+  );
+  const property = tree.property.value;
+  const subType = tree.subType?.value;
+  const parentNodeId = parentNode?.id;
+  const node = new DataQualityGraphFetchTreeNodeData(
+    editorStore,
+    generateGraphFetchTreeNodeID(property, parentNodeId, subType),
+    property.name,
+    parentNodeId,
+    tree,
+  );
+  node.setIsReadOnly(isReadOnly);
+  if (
+    node.type instanceof Class &&
+    fetchConstraints &&
+    tree.constraints.length
+  ) {
+    node.setConstraintsForClass(node.type, tree.constraints);
+  }
+  tree.subTrees.forEach((subTree) => {
+    const subTreeNode = buildGraphFetchSubTree(
+      editorStore,
+      subTree,
+      node,
+      nodes,
+      fetchConstraints,
+      isReadOnly,
+    );
+    addUniqueEntry(node.childrenIds, subTreeNode.id);
+    nodes.set(subTreeNode.id, subTreeNode);
+  });
+  return node;
+};
+
+const buildRootGraphFetchSubTree = (
+  editorStore: EditorStore,
+  tree: DataQualityRootGraphFetchTree,
+  parentNode: DataQualityGraphFetchTreeNodeData | undefined,
+  nodes: Map<string, DataQualityGraphFetchTreeNodeData>,
+  fetchConstraints: boolean,
+  isReadonly: boolean,
+): DataQualityGraphFetchTreeNodeData => {
+  const parentNodeId = parentNode?.id;
+  const node = new DataQualityGraphFetchTreeNodeData(
+    editorStore,
+    generateRootGraphFetchTreeNodeID(
+      parentNodeId,
+      tree.class.valueForSerialization ?? '',
+    ),
+    tree.class.value.name,
+    parentNodeId,
+    tree,
+  );
+  node.setIsReadOnly(isReadonly);
+  if (
+    node.type instanceof Class &&
+    fetchConstraints &&
+    tree.constraints.length
+  ) {
+    node.setConstraintsForClass(node.type, tree.constraints);
+  }
+  tree.subTrees.forEach((subTree) => {
+    const subTreeNode = buildGraphFetchSubTree(
+      editorStore,
+      subTree,
+      node,
+      nodes,
+      fetchConstraints,
+      isReadonly,
+    );
+    addUniqueEntry(node.childrenIds, subTreeNode.id);
+    nodes.set(subTreeNode.id, subTreeNode);
+  });
+  return node;
+};
+
+export const buildGraphFetchTreeData = (
+  editorStore: EditorStore,
+  tree: DataQualityRootGraphFetchTree,
+  displayRoot: boolean = false,
+  fetchConstraints: boolean,
+  isReadOnly: boolean,
+): DataQualityGraphFetchTreeData => {
+  const rootIds: string[] = [];
+  const nodes = new Map<string, DataQualityGraphFetchTreeNodeData>();
+  if (displayRoot) {
+    const rootNode = buildRootGraphFetchSubTree(
+      editorStore,
+      tree,
+      undefined,
+      nodes,
+      fetchConstraints,
+      isReadOnly,
+    );
+    addUniqueEntry(rootIds, rootNode.id);
+    nodes.set(rootNode.id, rootNode);
+  } else {
+    tree.subTrees.forEach((subTree) => {
+      const subTreeNode = buildGraphFetchSubTree(
+        editorStore,
+        subTree,
+        undefined,
+        nodes,
+        fetchConstraints,
+        isReadOnly,
+      );
+      addUniqueEntry(rootIds, subTreeNode.id);
+      nodes.set(subTreeNode.id, subTreeNode);
+    });
+  }
+
+  return { rootIds, nodes, tree };
+};
+
+export const isGraphFetchTreeDataEmpty = (
+  treeData: DataQualityGraphFetchTreeData,
+): boolean => treeData.tree.subTrees.length === 0;
+
+export const isConstraintsClassesTreeEmpty = (
+  treeData: DataQualityGraphFetchTreeData,
+): boolean => treeData.rootIds.length === 0;
+
+export const updateNodeConstraints = (
+  treeData: DataQualityGraphFetchTreeData,
+  node: DataQualityGraphFetchTreeNodeData,
+  constraint: Constraint,
+  addConstraint: boolean,
+): void => {
+  //update the node of graph fetch tree present
+  const updatedTreeNode = node.tree;
+  if (addConstraint) {
+    updatedTreeNode.constraints.push(constraint.name);
+  } else {
+    updatedTreeNode.constraints = updatedTreeNode.constraints.filter(
+      (constraintName) => constraintName !== constraint.name,
+    );
+  }
+};
+
+export const addQueryBuilderPropertyNode = (
+  treeData: DataQualityGraphFetchTreeData,
+  explorerTreeData: TreeData<QueryBuilderExplorerTreeNodeData>,
+  node:
+    | QueryBuilderExplorerTreePropertyNodeData
+    | QueryBuilderExplorerTreeRootNodeData,
+  dataQualityState: DataQualityState,
+): void => {
+  const editorStore = dataQualityState.editorStore;
+  const rootNodeId = generateRootGraphFetchTreeNodeID(
+    undefined,
+    treeData.tree.class.valueForSerialization ?? '',
+  );
+  //root node and property node handled differently
+  //handling property node
+  if (node instanceof QueryBuilderExplorerTreePropertyNodeData) {
+    // traverse the property node all the way to the root and resolve the
+    // chain of property that leads to this property node
+    const propertyGraphFetchTrees: DataQualityPropertyGraphFetchTree[] = [
+      new DataQualityPropertyGraphFetchTree(
+        PropertyExplicitReference.create(node.property),
+        undefined,
+      ),
+    ];
+    let parentExplorerTreeNode = explorerTreeData.nodes.get(node.parentId);
+    while (
+      parentExplorerTreeNode instanceof
+        QueryBuilderExplorerTreePropertyNodeData ||
+      parentExplorerTreeNode instanceof QueryBuilderExplorerTreeSubTypeNodeData
+    ) {
+      let subType = undefined;
+      let subtypeAssigned = false;
+      while (
+        parentExplorerTreeNode instanceof
+        QueryBuilderExplorerTreeSubTypeNodeData
+      ) {
+        if (!subtypeAssigned) {
+          subType = PackageableElementExplicitReference.create(
+            parentExplorerTreeNode.subclass,
+          );
+          subtypeAssigned = true;
+        }
+        parentExplorerTreeNode = explorerTreeData.nodes.get(
+          parentExplorerTreeNode.parentId,
+        );
+      }
+      if (
+        parentExplorerTreeNode instanceof
+          QueryBuilderExplorerTreePropertyNodeData &&
+        parentExplorerTreeNode.mappingData.entityMappedProperty?.subType &&
+        parentExplorerTreeNode.type instanceof Class
+      ) {
+        subType = PackageableElementExplicitReference.create(
+          parentExplorerTreeNode.type,
+        );
+      }
+      if (
+        parentExplorerTreeNode instanceof
+        QueryBuilderExplorerTreePropertyNodeData
+      ) {
+        const propertyGraphFetchTree = new DataQualityPropertyGraphFetchTree(
+          PropertyExplicitReference.create(parentExplorerTreeNode.property),
+          subType,
+        );
+        propertyGraphFetchTree.subTrees.push(
+          propertyGraphFetchTrees[0] as DataQualityPropertyGraphFetchTree,
+        );
+        propertyGraphFetchTrees.unshift(propertyGraphFetchTree);
+        parentExplorerTreeNode = explorerTreeData.nodes.get(
+          parentExplorerTreeNode.parentId,
+        );
+      } else {
+        dataQualityState.applicationStore.notificationService.notifyError(
+          `Can't cast the root class of graph fetch structure to its subtype`,
+        );
+        return;
+      }
+    }
+
+    // traverse the chain of property from the root class to find a node in the
+    // current graph fetch tree that matches any of this property, consider
+    // this the starting point
+    //
+    // If we found a match, use that as the starting point, otherwise, use the root
+    // of the graph fetch tree as the starting point
+    //
+    // NOTE: here we assume that we don't allow specifying duplicated nodes.
+    // perhaps we need to allow that behavior in the future so people can customize the
+    // shape of the object (e.g. same field but under different aliases)
+
+    //current node id will be pointing root node id
+    let currentNodeId: string | undefined = rootNodeId;
+    let parentNode: DataQualityGraphFetchTreeNodeData | undefined =
+      treeData.nodes.get(rootNodeId);
+    let newSubTree: DataQualityPropertyGraphFetchTree | undefined;
+    for (const propertyGraphFetchTree of propertyGraphFetchTrees) {
+      currentNodeId = generateGraphFetchTreeNodeID(
+        propertyGraphFetchTree.property.value,
+        currentNodeId,
+        propertyGraphFetchTree.subType?.value,
+      );
+      const existingGraphFetchNode = treeData.nodes.get(currentNodeId);
+      if (existingGraphFetchNode) {
+        parentNode = existingGraphFetchNode;
+      } else {
+        newSubTree = propertyGraphFetchTree;
+        break;
+      }
+    }
+
+    // construct the query builder graph fetch subtree from the starting point
+    if (newSubTree) {
+      const childNode = buildGraphFetchSubTree(
+        editorStore,
+        newSubTree,
+        parentNode,
+        treeData.nodes,
+        false,
+        false,
+      );
+      treeData.nodes.set(childNode.id, childNode);
+      if (parentNode) {
+        addUniqueEntry(parentNode.childrenIds, childNode.id);
+        graphFetchTree_addSubTree(
+          parentNode.tree,
+          childNode.tree,
+          dataQualityState.dataQualityQueryBuilderState.observerContext,
+        );
+      } else {
+        //this case arises when we reach upto rootNode
+        let rootNode = treeData.nodes.get(rootNodeId);
+        //check if root node exists in actual tree made
+        if (!rootNode) {
+          rootNode = buildRootGraphFetchSubTree(
+            editorStore,
+            treeData.tree,
+            undefined,
+            treeData.nodes,
+            false,
+            false,
+          );
+          addUniqueEntry(treeData.rootIds, rootNode.id);
+          treeData.nodes.set(rootNode.id, rootNode);
+        }
+        addUniqueEntry(rootNode.childrenIds, childNode.id);
+        graphFetchTree_addSubTree(
+          treeData.tree,
+          childNode.tree,
+          dataQualityState.dataQualityQueryBuilderState.observerContext,
+        );
+      }
+    }
+
+    const nodeToShowConstraintsFor = treeData.nodes.get(
+      `${rootNodeId}.${node.id}`,
+    );
+    //fetching constraints for class node and making sure constraints is populated for the first time
+    if (
+      nodeToShowConstraintsFor &&
+      node.type instanceof Class &&
+      nodeToShowConstraintsFor.constraints.length === 0
+    ) {
+      nodeToShowConstraintsFor.setConstraintsForClass(node.type, []);
+      treeData.nodes.set(nodeToShowConstraintsFor.id, nodeToShowConstraintsFor);
+    }
+  } else {
+    //this case arises when root node is dragged
+    let rootNodeFromTree = treeData.nodes.get(rootNodeId);
+    //check if root node already exists in data quality root graph fetch tree
+    if (!rootNodeFromTree) {
+      rootNodeFromTree = buildRootGraphFetchSubTree(
+        editorStore,
+        treeData.tree,
+        undefined,
+        treeData.nodes,
+        false,
+        false,
+      );
+      addUniqueEntry(treeData.rootIds, rootNodeFromTree.id);
+    }
+    //making sure root node is class type and constraints is fetch for first time
+    if (
+      node.type instanceof Class &&
+      rootNodeFromTree.constraints.length === 0
+    ) {
+      rootNodeFromTree.setConstraintsForClass(node.type, []);
+    }
+    treeData.nodes.set(rootNodeFromTree.id, rootNodeFromTree);
+  }
+};

package/src/graph/metamodel/DSL_DataQuality_HashUtils.ts

@@ -0,0 +1,29 @@
+/**
+ * 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.
+ */
+
+export enum DATA_QUALITY_HASH_STRUCTURE {
+  DATA_QUALITY_CONSTRAINTS_CONFIGURATION = 'DATA_QUALITY_CONSTRAINTS_CONFIGURATION',
+  DATA_QUALITY_SERVICE_VALIDATION_CONFIGURATION = 'DATA_QUALITY_SERVICE_VALIDATION_CONFIGURATION',
+  DATA_QUALTIY_DATASPACE_EXECUTION_CONTEXT = 'DATA_QUALITY_DATASPACE_EXECUTION_CONTEXT',
+  DATA_QUALITY_MAPPING_AND_RUNTIME_EXECUTION_CONTEXT = 'DATA_QUALITY_MAPPING_AND_RUNTIME_EXECUTION_CONTEXT',
+  DATA_QUALITY_GRAPH_FETCH_STATE = 'DATA_QUALITY_GRAPH_FETCH_STATE',
+  DATA_QUALITY_GRAPH_FETCH_TREE = 'DATA_QUALITY_GRAPH_FETCH_TREE',
+  DATA_QUALITY_ROOT_GRAPH_FETCH_TREE = 'DATA_QUALITY_ROOT_GRAPH_FETCH_TREE',
+  DATA_QUALITY_PROPERTY_GRAPH_FETCH_TREE = 'DATA_QUALITY_PROPERTY_GRAPH_FETCH_TREE',
+  DATA_QUALITY_SUBTYPE_GRAPH_FETCH_TREE = 'DATA_QUALITY_SUBTYPE_GRAPH_FETCH_TREE',
+  DATA_QUALITY_GRAPH_FETCH_TREE_NODE_DATA = 'DATA_QUALITY_GRAPH_FETCH_TREE_NODE_DATA',
+  DATA_QUALITY_STATE = 'DATA_QUALITY_STATE',
+}

package/src/graph/metamodel/DSL_DataQuality_PureGraphPlugin.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 Clazz } from '@finos/legend-shared';
+import { type PackageableElement, PureGraphPlugin } from '@finos/legend-graph';
+import packageJson from '../../../package.json';
+import {
+  DataQualityClassValidationsConfiguration,
+  DataQualityServiceValidationConfiguration,
+} from './pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+
+export class DSL_DataQuality_PureGraphPlugin extends PureGraphPlugin {
+  constructor() {
+    super(packageJson.extensions.pureGraphPlugin, packageJson.version);
+  }
+
+  override getExtraPureGraphExtensionClasses(): Clazz<PackageableElement>[] {
+    return [
+      DataQualityClassValidationsConfiguration,
+      DataQualityServiceValidationConfiguration,
+    ];
+  }
+}