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

package/src/graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.ts

@@ -0,0 +1,55 @@
+/**
+ * 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 Hashable, hashArray } from '@finos/legend-shared';
+import {
+  RootGraphFetchTree,
+  PropertyGraphFetchTree,
+} from '@finos/legend-graph';
+import { DATA_QUALITY_HASH_STRUCTURE } from '../../../DSL_DataQuality_HashUtils.js';
+
+export class DataQualityRootGraphFetchTree
+  extends RootGraphFetchTree
+  implements Hashable
+{
+  constraints: string[] = [];
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_ROOT_GRAPH_FETCH_TREE,
+      hashArray(this.subTrees),
+      hashArray(this.subTypeTrees),
+      hashArray(this.constraints),
+      this.class.valueForSerialization ?? '',
+    ]);
+  }
+}
+
+export class DataQualityPropertyGraphFetchTree
+  extends 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.value.name,
+      this.alias ?? '',
+      this.subType?.valueForSerialization ?? '',
+      hashArray(this.constraints),
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.ts

@@ -0,0 +1,107 @@
+/**
+ * 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 PackageableElementVisitor,
+  type GraphFetchTree,
+  type Mapping,
+  type PackageableElementReference,
+  type PackageableRuntime,
+  type RawLambda,
+  PackageableElement,
+} from '@finos/legend-graph';
+import { type Hashable, hashArray } from '@finos/legend-shared';
+import { DATA_QUALITY_HASH_STRUCTURE } from '../../../DSL_DataQuality_HashUtils.js';
+import type { DataSpace } from '@finos/legend-extension-dsl-data-space/graph';
+import type { DataQualityRootGraphFetchTree } from './DataQualityGraphFetchTree.js';
+
+export abstract class DataQualityExecutionContext implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class DataSpaceDataQualityExecutionContext extends DataQualityExecutionContext {
+  context!: string;
+  dataSpace!: PackageableElementReference<DataSpace>;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALTIY_DATASPACE_EXECUTION_CONTEXT,
+      this.context,
+      this.dataSpace.valueForSerialization ?? '',
+    ]);
+  }
+}
+
+export class MappingAndRuntimeDataQualityExecutionContext extends DataQualityExecutionContext {
+  mapping!: PackageableElementReference<Mapping>;
+  runtime!: PackageableElementReference<PackageableRuntime>;
+
+  override get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_MAPPING_AND_RUNTIME_EXECUTION_CONTEXT,
+      this.mapping.valueForSerialization ?? '',
+      this.runtime.valueForSerialization ?? '',
+    ]);
+  }
+}
+
+export class DataQualityClassValidationsConfiguration
+  extends PackageableElement
+  implements Hashable
+{
+  context!: DataQualityExecutionContext;
+  dataQualityRootGraphFetchTree: DataQualityRootGraphFetchTree | undefined;
+  filter?: RawLambda | undefined;
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_CONSTRAINTS_CONFIGURATION,
+      this.context,
+      this.filter ?? '',
+      this.dataQualityRootGraphFetchTree ?? '',
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}
+
+export class DataQualityServiceValidationConfiguration
+  extends PackageableElement
+  implements Hashable
+{
+  serviceName: string | undefined;
+  contextName: string | undefined;
+  dataQualityRootGraphFetchTree: GraphFetchTree | undefined;
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_SERVICE_VALIDATION_CONFIGURATION,
+      this.serviceName ?? '',
+      this.contextName ?? '',
+      this.dataQualityRootGraphFetchTree ?? '',
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}

package/src/graph-manager/DSL_DataQuality_GraphManagerHelper.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 { BasicModel } from '@finos/legend-graph';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+import {
+  DataQualityClassValidationsConfiguration,
+  DataQualityServiceValidationConfiguration,
+} from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+
+export const getOwnDataQualityClassValidationsConfiguration = (
+  path: string,
+  graph: BasicModel,
+): DataQualityClassValidationsConfiguration =>
+  guaranteeNonNullable(
+    graph.getOwnNullableExtensionElement(
+      path,
+      DataQualityClassValidationsConfiguration,
+    ),
+    `Can't find data quality class validation element on '${path}'`,
+  );
+
+export const getOwnDataQualityServiceValidationsConfiguration = (
+  path: string,
+  graph: BasicModel,
+): DataQualityServiceValidationConfiguration =>
+  guaranteeNonNullable(
+    graph.getOwnNullableExtensionElement(
+      path,
+      DataQualityServiceValidationConfiguration,
+    ),
+    `Can't find data quality service validation element on '${path}'`,
+  );

package/src/graph-manager/DSL_DataQuality_GraphManagerPreset.ts

@@ -0,0 +1,31 @@
+/**
+ * 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 { AbstractPreset } from '@finos/legend-shared';
+import packageJson from '../../package.json';
+import { DSL_DataQuality_PureGraphPlugin } from '../graph/metamodel/DSL_DataQuality_PureGraphPlugin.js';
+import { DSL_DataQuality_PureGraphManagerPlugin } from './DSL_DataQuality_PureGraphManagerPlugin.js';
+import { DSL_DataQuality_PureProtocolProcessorPlugin } from './protocol/pure/DSL_DataQuality_PureProtocolProcessorPlugin.js';
+
+export class DSL_DataQuality_GraphManagerPreset extends AbstractPreset {
+  constructor() {
+    super(packageJson.extensions.graphManagerPreset, packageJson.version, [
+      new DSL_DataQuality_PureGraphPlugin(),
+      new DSL_DataQuality_PureGraphManagerPlugin(),
+      new DSL_DataQuality_PureProtocolProcessorPlugin(),
+    ]);
+  }
+}

package/src/graph-manager/DSL_DataQuality_GraphModifierHelper.ts

@@ -0,0 +1,113 @@
+/**
+ * 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 { action } from 'mobx';
+import {
+  type DataQualityClassValidationsConfiguration,
+  type DataQualityExecutionContext,
+  DataSpaceDataQualityExecutionContext,
+  MappingAndRuntimeDataQualityExecutionContext,
+} from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import { DataQualityRootGraphFetchTree } from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';
+import {
+  type GraphFetchTree,
+  type PackageableElementReference,
+  type PackageableRuntime,
+  type RawLambda,
+  type ObserverContext,
+  observe_PackageableRuntime,
+  observe_RawLambda,
+  PackageableElementExplicitReference,
+} from '@finos/legend-graph';
+import {
+  observe_DataQualityRootGraphFetchTree,
+  observe_DataSpaceDataQualityExecutionContext,
+  observe_MappingAndRuntimeDataQualityExecutionContext,
+} from './action/changeDetection/DSL_DataQuality_ObserverHelper.js';
+
+export const dataQualityClassValidation_setDataQualityGraphFetchTree = action(
+  (
+    element: DataQualityClassValidationsConfiguration,
+    val: DataQualityRootGraphFetchTree | undefined,
+  ): void => {
+    element.dataQualityRootGraphFetchTree = val
+      ? observe_DataQualityRootGraphFetchTree(val)
+      : val;
+  },
+);
+
+export const dataQualityClassValidation_setDataQualityContext = action(
+  (
+    element: DataQualityClassValidationsConfiguration,
+    val: DataQualityExecutionContext,
+  ): void => {
+    if (val instanceof DataSpaceDataQualityExecutionContext) {
+      element.context = observe_DataSpaceDataQualityExecutionContext(val);
+    }
+    if (val instanceof MappingAndRuntimeDataQualityExecutionContext) {
+      element.context =
+        observe_MappingAndRuntimeDataQualityExecutionContext(val);
+    }
+  },
+);
+
+export const dataQualityClassValidation_setFilter = action(
+  (
+    element: DataQualityClassValidationsConfiguration,
+    val: RawLambda | undefined,
+  ): void => {
+    element.filter = val ? observe_RawLambda(val) : val;
+  },
+);
+
+export const dataQualityClassValidation_setContextDataQualityContext = action(
+  (element: DataQualityClassValidationsConfiguration, val: string): void => {
+    if (element.context instanceof DataSpaceDataQualityExecutionContext) {
+      element.context.context = val;
+      element.context = observe_DataSpaceDataQualityExecutionContext(
+        element.context,
+      );
+    }
+  },
+);
+
+export const dataQualityClassValidation_setRuntimeDataQualityContext = action(
+  (
+    element: DataQualityClassValidationsConfiguration,
+    val: PackageableElementReference<PackageableRuntime>,
+    observerContext: ObserverContext,
+  ): void => {
+    if (
+      element.context instanceof MappingAndRuntimeDataQualityExecutionContext
+    ) {
+      element.context.runtime = PackageableElementExplicitReference.create(
+        observe_PackageableRuntime(val.value, observerContext),
+      );
+    }
+  },
+);
+export const graphFetchTree_removeAllSubTrees = action(
+  (target: GraphFetchTree): void => {
+    target.subTrees = [];
+  },
+);
+export const dataQualityGraphFetchTree_removeConstraints = action(
+  (target: GraphFetchTree): void => {
+    if (target instanceof DataQualityRootGraphFetchTree) {
+      target.constraints = [];
+    }
+  },
+);

package/src/graph-manager/DSL_DataQuality_PureGraphManagerPlugin.ts

@@ -0,0 +1,59 @@
+/**
+ * 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 ElementObserver,
+  type PureGraphManagerExtensionBuilder,
+  type ObserverContext,
+  type PackageableElement,
+  PureGraphManagerPlugin,
+} from '@finos/legend-graph';
+import {
+  DataQualityClassValidationsConfiguration,
+  DataQualityServiceValidationConfiguration,
+} from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import {
+  observe_DataQualityConstraintsConfiguration,
+  observe_DataQualityServiceValidationConfiguration,
+} from './action/changeDetection/DSL_DataQuality_ObserverHelper.js';
+import { DSL_DataQuality_buildGraphManagerExtension } from './protocol/pure/DSL_DataQuality_buildGraphManagerExtension.js';
+
+export class DSL_DataQuality_PureGraphManagerPlugin extends PureGraphManagerPlugin {
+  constructor() {
+    super(packageJson.extensions.pureGraphManagerPlugin, packageJson.version);
+  }
+
+  override getExtraElementObservers(): ElementObserver[] {
+    return [
+      (
+        element: PackageableElement,
+        context: ObserverContext,
+      ): PackageableElement | undefined => {
+        if (element instanceof DataQualityClassValidationsConfiguration) {
+          return observe_DataQualityConstraintsConfiguration(element);
+        }
+        if (element instanceof DataQualityServiceValidationConfiguration) {
+          return observe_DataQualityServiceValidationConfiguration(element);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override getExtraPureGraphManagerExtensionBuilders(): PureGraphManagerExtensionBuilder[] {
+    return [DSL_DataQuality_buildGraphManagerExtension];
+  }
+}

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

@@ -0,0 +1,153 @@
+/**
+ * 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 {
+  observe_Abstract_PackageableElement,
+  observe_Class,
+  observe_PackageableElementReference,
+  observe_PropertyReference,
+  observe_RawLambda,
+  skipObserved,
+} from '@finos/legend-graph';
+import { makeObservable, observable, override } from 'mobx';
+import {
+  type DataQualityClassValidationsConfiguration,
+  type DataQualityServiceValidationConfiguration,
+  DataSpaceDataQualityExecutionContext,
+  MappingAndRuntimeDataQualityExecutionContext,
+} from '../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import { observe_DataSpace } from '@finos/legend-extension-dsl-data-space/graph';
+import {
+  type DataQualityRootGraphFetchTree,
+  DataQualityPropertyGraphFetchTree,
+} from '../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';
+
+export const observe_DataSpaceDataQualityExecutionContext = skipObserved(
+  (
+    metamodel: DataSpaceDataQualityExecutionContext,
+  ): DataSpaceDataQualityExecutionContext => {
+    makeObservable<DataSpaceDataQualityExecutionContext>(metamodel, {
+      context: observable,
+      dataSpace: observable,
+    });
+    observe_DataSpace(metamodel.dataSpace.value);
+    return metamodel;
+  },
+);
+
+export const observe_MappingAndRuntimeDataQualityExecutionContext =
+  skipObserved(
+    (
+      metamodel: MappingAndRuntimeDataQualityExecutionContext,
+    ): MappingAndRuntimeDataQualityExecutionContext => {
+      makeObservable<MappingAndRuntimeDataQualityExecutionContext>(metamodel, {
+        mapping: observable,
+        runtime: observable,
+      });
+      observe_PackageableElementReference(metamodel.mapping);
+      observe_PackageableElementReference(metamodel.runtime);
+      return metamodel;
+    },
+  );
+
+export const observe_DataQualityPropertyGraphFetchTree = skipObserved(
+  (
+    metamodel: DataQualityPropertyGraphFetchTree,
+  ): DataQualityPropertyGraphFetchTree => {
+    makeObservable<DataQualityPropertyGraphFetchTree>(metamodel, {
+      constraints: observable,
+      property: observable,
+      subTrees: observable,
+    });
+    observe_PropertyReference(metamodel.property);
+    metamodel.subTrees.forEach((subTree) => {
+      if (subTree instanceof DataQualityPropertyGraphFetchTree) {
+        observe_DataQualityPropertyGraphFetchTree(subTree);
+      }
+    });
+    return metamodel;
+  },
+);
+
+export const observe_DataQualityRootGraphFetchTree = skipObserved(
+  (metamodel: DataQualityRootGraphFetchTree): DataQualityRootGraphFetchTree => {
+    makeObservable<DataQualityRootGraphFetchTree>(metamodel, {
+      class: observable,
+      subTrees: observable,
+      constraints: observable,
+    });
+    observe_Class(metamodel.class.value);
+    metamodel.subTrees.forEach((subTree) => {
+      if (subTree instanceof DataQualityPropertyGraphFetchTree) {
+        observe_DataQualityPropertyGraphFetchTree(subTree);
+      }
+    });
+    return metamodel;
+  },
+);
+export const observe_DataQualityConstraintsConfiguration = skipObserved(
+  (
+    metamodel: DataQualityClassValidationsConfiguration,
+  ): DataQualityClassValidationsConfiguration => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<
+      DataQualityClassValidationsConfiguration,
+      '_elementHashCode'
+    >(metamodel, {
+      _elementHashCode: override,
+      context: observable,
+      filter: observable,
+      dataQualityRootGraphFetchTree: observable,
+    });
+    if (metamodel.context instanceof DataSpaceDataQualityExecutionContext) {
+      observe_DataSpaceDataQualityExecutionContext(metamodel.context);
+    }
+    if (
+      metamodel.context instanceof MappingAndRuntimeDataQualityExecutionContext
+    ) {
+      observe_MappingAndRuntimeDataQualityExecutionContext(metamodel.context);
+    }
+    if (metamodel.filter) {
+      observe_RawLambda(metamodel.filter);
+    }
+    if (metamodel.dataQualityRootGraphFetchTree) {
+      observe_DataQualityRootGraphFetchTree(
+        metamodel.dataQualityRootGraphFetchTree,
+      );
+    }
+    return metamodel;
+  },
+);
+
+export const observe_DataQualityServiceValidationConfiguration = skipObserved(
+  (
+    metamodel: DataQualityServiceValidationConfiguration,
+  ): DataQualityServiceValidationConfiguration => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<
+      DataQualityServiceValidationConfiguration,
+      '_elementHashCode'
+    >(metamodel, {
+      _elementHashCode: override,
+      contextName: observable,
+      serviceName: observable,
+      dataQualityRootGraphFetchTree: observable,
+    });
+    return metamodel;
+  },
+);

package/src/graph-manager/index.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 * from './DSL_DataQuality_GraphManagerPreset.js';
+export * from './protocol/pure/v1/transformation/V1_ValueSpecificationBuilderHelper.js';
+export * from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityGraphFetchTree.js';

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

@@ -0,0 +1,59 @@
+/**
+ * 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,
+  AbstractPureGraphManagerExtension,
+} from '@finos/legend-graph';
+import { guaranteeNonNullable } from '@finos/legend-shared';
+
+export abstract class DSL_DataQuality_PureGraphManagerExtension extends AbstractPureGraphManagerExtension {
+  abstract generatePlan(
+    graph: PureModel,
+    packagePath: string,
+  ): Promise<RawExecutionPlan>;
+
+  abstract execute(
+    graph: PureModel,
+    packagePath: string,
+    previewLimit: number,
+  ): Promise<ExecutionResult>;
+
+  abstract debugExecutionPlanGeneration(
+    graph: PureModel,
+    packagePath: string,
+  ): Promise<{ plan: RawExecutionPlan; debug: string }>;
+
+  abstract fetchStructuralValidations(
+    graph: PureModel,
+    packagePath: string,
+  ): Promise<RootGraphFetchTree>;
+}
+
+export const getDataQualityPureGraphManagerExtension = (
+  graphManager: AbstractPureGraphManager,
+): DSL_DataQuality_PureGraphManagerExtension =>
+  guaranteeNonNullable(
+    graphManager.extensions.find(
+      (extension) =>
+        extension instanceof DSL_DataQuality_PureGraphManagerExtension,
+    ),
+    `Can't find Data Quality Pure graph manager extension`,
+  );