@finos/legend-extension-dsl-data-quality 1.0.61 → 2.0.0

package/src/components/states/DataQualityRelationValidationState.ts

@@ -0,0 +1,180 @@
+/**
+ * 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 DataQualityRelationValidation,
+  RelationValidationType,
+} from '../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import { type EditorStore } from '@finos/legend-application-studio';
+import { action, makeObservable, observable } from 'mobx';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  hashArray,
+  LogEvent,
+} from '@finos/legend-shared';
+import {
+  type RawLambda,
+  buildSourceInformationSourceId,
+  GRAPH_MANAGER_EVENT,
+  isStubbed_RawLambda,
+  ParserError,
+  stub_RawLambda,
+} from '@finos/legend-graph';
+import { LambdaEditorState } from '@finos/legend-query-builder';
+import { VALIDATION_SOURCE_ID_LABEL } from './ConstraintState.js';
+import {
+  dataQualityRelationValidation_setAssertion,
+  dataQualityRelationValidation_setType,
+} from '../../graph-manager/DSL_DataQuality_GraphModifierHelper.js';
+import { DATA_QUALITY_HASH_STRUCTURE } from '../../graph/metamodel/DSL_DataQuality_HashUtils.js';
+import { DataQualityRelationValidationLambdaEditorState } from './DataQualityRelationValidationLambdaEditorState.js';
+import type { SelectOption } from '@finos/legend-art';
+
+export class DataQualityRelationValidationState extends LambdaEditorState {
+  relationValidation: DataQualityRelationValidation;
+  editorStore: EditorStore;
+  isValidationDialogOpen = false;
+  rowMapFunctionLambdaEditorState:
+    | DataQualityRelationValidationLambdaEditorState
+    | undefined;
+  constructor(
+    relationValidation: DataQualityRelationValidation,
+    editorStore: EditorStore,
+  ) {
+    super('true', '');
+
+    makeObservable(this, {
+      relationValidation: observable,
+      editorStore: observable,
+      isValidationDialogOpen: observable,
+      setIsValidationDialogOpen: action,
+      onValidationTypeChange: action,
+    });
+
+    this.relationValidation = relationValidation;
+    this.editorStore = editorStore;
+    this.rowMapFunctionLambdaEditorState =
+      relationValidation.type === RelationValidationType.AGGREGATE
+        ? new DataQualityRelationValidationLambdaEditorState(
+            relationValidation,
+            editorStore,
+          )
+        : undefined;
+  }
+
+  get lambdaId(): string {
+    return buildSourceInformationSourceId([
+      VALIDATION_SOURCE_ID_LABEL,
+      this.relationValidation.name,
+      this.uuid, // in case of duplications
+    ]);
+  }
+
+  setIsValidationDialogOpen(isValidationDialogOpen: boolean): void {
+    this.isValidationDialogOpen = isValidationDialogOpen;
+  }
+
+  onValidationTypeChange(val: SelectOption): void {
+    dataQualityRelationValidation_setType(
+      this.relationValidation,
+      val.value as RelationValidationType,
+    );
+    if (val.value === RelationValidationType.AGGREGATE) {
+      this.rowMapFunctionLambdaEditorState =
+        new DataQualityRelationValidationLambdaEditorState(
+          this.relationValidation,
+          this.editorStore,
+        );
+    } else {
+      this.rowMapFunctionLambdaEditorState = undefined;
+    }
+  }
+
+  *convertLambdaGrammarStringToObject(): GeneratorFn<void> {
+    const emptyFunctionDefinition = stub_RawLambda();
+    if (this.lambdaString) {
+      try {
+        const lambda =
+          (yield this.editorStore.graphManagerState.graphManager.pureCodeToLambda(
+            this.fullLambdaString,
+            this.lambdaId,
+          )) as RawLambda;
+        this.setParserError(undefined);
+        dataQualityRelationValidation_setAssertion(
+          this.relationValidation,
+          lambda,
+        );
+      } catch (error) {
+        assertErrorThrown(error);
+        if (error instanceof ParserError) {
+          this.setParserError(error);
+        }
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      dataQualityRelationValidation_setAssertion(
+        this.relationValidation,
+        emptyFunctionDefinition,
+      );
+    }
+  }
+
+  *convertLambdaObjectToGrammarString(options?: {
+    pretty?: boolean | undefined;
+    preserveCompilationError?: boolean | undefined;
+  }): GeneratorFn<void> {
+    if (!isStubbed_RawLambda(this.relationValidation.assertion)) {
+      try {
+        const lambdas = new Map<string, RawLambda>();
+        lambdas.set(this.lambdaId, this.relationValidation.assertion);
+        const isolatedLambdas =
+          (yield this.editorStore.graphManagerState.graphManager.lambdasToPureCode(
+            lambdas,
+            options?.pretty,
+          )) as Map<string, string>;
+        const grammarText = isolatedLambdas.get(this.lambdaId);
+        this.setLambdaString(
+          grammarText !== undefined
+            ? this.extractLambdaString(grammarText)
+            : '',
+        );
+        this.clearErrors({
+          preserveCompilationError: options?.preserveCompilationError,
+        });
+      } catch (error) {
+        assertErrorThrown(error);
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.PARSING_FAILURE),
+          error,
+        );
+      }
+    } else {
+      this.clearErrors();
+      this.setLambdaString('');
+    }
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_RELATION_VALIDATION,
+      this.lambdaString,
+    ]);
+  }
+}

package/src/components/states/DataQualityResultState.ts

@@ -116,12 +116,10 @@ export class DataQualityResultState {
 
       promise = getDataQualityPureGraphManagerExtension(
         this.dataQualityState.graphManagerState.graphManager,
-      ).execute(
-        model,
-        this.dataQualityState.lambdaParameterValues,
-        packagePath,
-        this.previewLimit,
-      );
+      ).execute(model, packagePath, {
+        lambdaParameterValues: this.dataQualityState.lambdaParameterValues,
+        previewLimit: this.previewLimit,
+      });
 
       this.setQueryRunPromise(promise);
       const result = (yield promise) as ExecutionResult;
@@ -179,7 +177,7 @@ export class DataQualityResultState {
       if (debug) {
         const debugResult = (yield getDataQualityPureGraphManagerExtension(
           this.dataQualityState.graphManagerState.graphManager,
-        ).debugExecutionPlanGeneration(model, packagePath)) as {
+        ).debugExecutionPlanGeneration(model, packagePath, {})) as {
           plan: RawExecutionPlan;
           debug: string;
         };
@@ -191,7 +189,7 @@ export class DataQualityResultState {
         );
         rawPlan = (yield getDataQualityPureGraphManagerExtension(
           this.dataQualityState.graphManagerState.graphManager,
-        ).generatePlan(model, packagePath)) as RawExecutionPlan;
+        ).generatePlan(model, packagePath, {})) as RawExecutionPlan;
       }
 
       stopWatch.record();

package/src/components/states/DataQualityState.ts

@@ -271,7 +271,7 @@ export abstract class DataQualityState extends ElementEditorState {
     const model = this.graphManagerState.graph;
     const rootGraphFetchTree = (yield getDataQualityPureGraphManagerExtension(
       this.graphManagerState.graphManager,
-    ).fetchStructuralValidations(model, packagePath)) as RootGraphFetchTree;
+    ).fetchStructuralValidations(model, packagePath, {})) as RootGraphFetchTree;
     this.initializeStructuralValidationsGraphFetchTreeState(
       rootGraphFetchTree as DataQualityRootGraphFetchTree,
     );

package/src/graph/metamodel/DSL_DataQuality_HashUtils.ts

@@ -17,6 +17,7 @@
 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_QUALITY_RELATION_VALIDATION_CONFIGURATION = 'DATA_QUALITY_RELATION_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',
@@ -26,4 +27,7 @@ export enum DATA_QUALITY_HASH_STRUCTURE {
   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',
+  DATA_QUALITY_RELATION_VALIDATION = 'DATA_QUALITY_RELATION_VALIDATION',
+  DATA_QUALITY_RELATION_FUNCTION_DEFINITION = 'DATA_QUALITY_RELATION_FUNCTION_DEFINITION',
+  DATA_QUALITY_RELATION_VALIDATION_QUERY = 'DATA_QUALITY_RELATION_VALIDATION_QUERY',
 }

package/src/graph/metamodel/DSL_DataQuality_PureGraphPlugin.ts

@@ -20,6 +20,7 @@ import packageJson from '../../../package.json';
 import {
   DataQualityClassValidationsConfiguration,
   DataQualityServiceValidationConfiguration,
+  DataQualityRelationValidationConfiguration,
 } from './pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
 
 export class DSL_DataQuality_PureGraphPlugin extends PureGraphPlugin {
@@ -31,6 +32,7 @@ export class DSL_DataQuality_PureGraphPlugin extends PureGraphPlugin {
     return [
       DataQualityClassValidationsConfiguration,
       DataQualityServiceValidationConfiguration,
+      DataQualityRelationValidationConfiguration,
     ];
   }
 }

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

@@ -21,13 +21,27 @@ import {
   type PackageableElementReference,
   type PackageableRuntime,
   type RawLambda,
+  type ParameterValue,
+  type RawVariableExpression,
   PackageableElement,
+  hashRawLambda,
 } from '@finos/legend-graph';
-import { type Hashable, hashArray } from '@finos/legend-shared';
+import { type Hashable, hashArray, uuid } 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 enum RelationValidationType {
+  ROW_LEVEL = 'ROW_LEVEL',
+  AGGREGATE = 'AGGREGATE',
+}
+export interface DQExecuteInputOptions {
+  lambdaParameterValues?: ParameterValue[];
+  clientVersion?: string | undefined;
+  validationName?: string | undefined;
+  previewLimit?: number | undefined;
+}
+
 export abstract class DataQualityExecutionContext implements Hashable {
   abstract get hashCode(): string;
 }
@@ -58,8 +72,10 @@ export class MappingAndRuntimeDataQualityExecutionContext extends DataQualityExe
   }
 }
 
+export abstract class DataQualityValidationConfiguration extends PackageableElement {}
+
 export class DataQualityClassValidationsConfiguration
-  extends PackageableElement
+  extends DataQualityValidationConfiguration
   implements Hashable
 {
   context!: DataQualityExecutionContext;
@@ -83,7 +99,7 @@ export class DataQualityClassValidationsConfiguration
 }
 
 export class DataQualityServiceValidationConfiguration
-  extends PackageableElement
+  extends DataQualityValidationConfiguration
   implements Hashable
 {
   serviceName: string | undefined;
@@ -105,3 +121,63 @@ export class DataQualityServiceValidationConfiguration
     return visitor.visit_PackageableElement(this);
   }
 }
+
+export class DataQualityRelationQueryLambda implements Hashable {
+  body?: object | undefined;
+  parameters: RawVariableExpression[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_RELATION_VALIDATION_QUERY,
+      hashArray(this.parameters),
+      hashRawLambda(undefined, this.body),
+    ]);
+  }
+}
+
+export class DataQualityRelationValidation implements Hashable {
+  readonly _UUID = uuid();
+  name: string;
+  description: string | undefined;
+  assertion: RawLambda;
+  type: RelationValidationType = RelationValidationType.ROW_LEVEL;
+  rowMapFunction: RawLambda | undefined;
+
+  constructor(name: string, assertion: RawLambda) {
+    this.name = name;
+    this.assertion = assertion;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_RELATION_VALIDATION,
+      this.name,
+      this.type,
+      this.description ?? '',
+      this.assertion,
+      this.rowMapFunction ?? '',
+    ]);
+  }
+}
+
+export class DataQualityRelationValidationConfiguration
+  extends DataQualityValidationConfiguration
+  implements Hashable
+{
+  query!: DataQualityRelationQueryLambda;
+  validations: DataQualityRelationValidation[] = [];
+
+  protected override get _elementHashCode(): string {
+    return hashArray([
+      DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_RELATION_VALIDATION_CONFIGURATION,
+      this.query,
+      hashArray(this.validations),
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_PackageableElement(this);
+  }
+}

package/src/graph-manager/DSL_DataQuality_GraphManagerHelper.ts

@@ -19,6 +19,7 @@ import { guaranteeNonNullable } from '@finos/legend-shared';
 import {
   DataQualityClassValidationsConfiguration,
   DataQualityServiceValidationConfiguration,
+  DataQualityRelationValidationConfiguration,
 } from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
 
 export const getOwnDataQualityClassValidationsConfiguration = (
@@ -44,3 +45,15 @@ export const getOwnDataQualityServiceValidationsConfiguration = (
     ),
     `Can't find data quality service validation element on '${path}'`,
   );
+
+export const getOwnDataQualityRelationValidationsConfiguration = (
+  path: string,
+  graph: BasicModel,
+): DataQualityRelationValidationConfiguration =>
+  guaranteeNonNullable(
+    graph.getOwnNullableExtensionElement(
+      path,
+      DataQualityRelationValidationConfiguration,
+    ),
+    `Can't find data quality tds validation element on '${path}'`,
+  );

package/src/graph-manager/DSL_DataQuality_GraphModifierHelper.ts

@@ -18,6 +18,9 @@ import { action } from 'mobx';
 import {
   type DataQualityClassValidationsConfiguration,
   type DataQualityExecutionContext,
+  type DataQualityRelationValidation,
+  type DataQualityRelationValidationConfiguration,
+  type RelationValidationType,
   DataSpaceDataQualityExecutionContext,
   MappingAndRuntimeDataQualityExecutionContext,
 } from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
@@ -28,15 +31,19 @@ import {
   type PackageableRuntime,
   type RawLambda,
   type ObserverContext,
+  type RawVariableExpression,
   observe_PackageableRuntime,
   observe_RawLambda,
   PackageableElementExplicitReference,
+  observe_RawVariableExpression,
 } from '@finos/legend-graph';
 import {
   observe_DataQualityRootGraphFetchTree,
+  observe_DataQualityRelationValidation,
   observe_DataSpaceDataQualityExecutionContext,
   observe_MappingAndRuntimeDataQualityExecutionContext,
 } from './action/changeDetection/DSL_DataQuality_ObserverHelper.js';
+import { addUniqueEntry, deleteEntry, swapEntry } from '@finos/legend-shared';
 
 export const dataQualityClassValidation_setDataQualityGraphFetchTree = action(
   (
@@ -111,3 +118,103 @@ export const dataQualityGraphFetchTree_removeConstraints = action(
     }
   },
 );
+
+export const dataQualityRelationValidation_setAssertion = action(
+  (_constraint: DataQualityRelationValidation, assertion: RawLambda): void => {
+    _constraint.assertion = observe_RawLambda(assertion);
+  },
+);
+
+export const dataQualityRelationValidation_setName = action(
+  (_constraint: DataQualityRelationValidation, name: string): void => {
+    _constraint.name = name;
+  },
+);
+
+export const dataQualityRelationValidation_setDescription = action(
+  (_constraint: DataQualityRelationValidation, description: string): void => {
+    _constraint.description = description;
+  },
+);
+
+export const dataQualityRelationValidation_setType = action(
+  (
+    _constraint: DataQualityRelationValidation,
+    type: RelationValidationType,
+  ): void => {
+    _constraint.type = type;
+  },
+);
+
+export const dataQualityRelationValidation_setRowMapFunction = action(
+  (
+    _constraint: DataQualityRelationValidation,
+    rowMapFunction: RawLambda,
+  ): void => {
+    _constraint.rowMapFunction = observe_RawLambda(rowMapFunction);
+  },
+);
+
+export const dataQualityRelationValidation_addValidation = action(
+  (
+    _relationValidation: DataQualityRelationValidationConfiguration,
+    val: DataQualityRelationValidation,
+  ): void => {
+    addUniqueEntry(
+      _relationValidation.validations,
+      observe_DataQualityRelationValidation(val),
+    );
+  },
+);
+
+export const dataQualityRelationValidation_deleteValidation = action(
+  (
+    _relationValidation: DataQualityRelationValidationConfiguration,
+    val: DataQualityRelationValidation,
+  ): void => {
+    deleteEntry(
+      _relationValidation.validations,
+      observe_DataQualityRelationValidation(val),
+    );
+  },
+);
+
+export const dataQualityRelationValidation_swapValidations = action(
+  (
+    _relationValidation: DataQualityRelationValidationConfiguration,
+    sourceValidation: DataQualityRelationValidation,
+    targetValidation: DataQualityRelationValidation,
+  ): void => {
+    swapEntry(
+      _relationValidation.validations,
+      sourceValidation,
+      targetValidation,
+    );
+  },
+);
+
+export const dataQualityRelationValidation_addParameter = action(
+  (_parameters: RawVariableExpression[], val: RawVariableExpression): void => {
+    addUniqueEntry(_parameters, observe_RawVariableExpression(val));
+  },
+);
+
+export const dataQualityRelationValidation_deleteParameter = action(
+  (_parameters: RawVariableExpression[], val: RawVariableExpression): void => {
+    deleteEntry(_parameters, val);
+  },
+);
+
+export const dataQualityRelationValidation_swapParameters = action(
+  (
+    _parameters: RawVariableExpression[],
+    sourceParameter: RawVariableExpression,
+    targetParameter: RawVariableExpression,
+  ): void => {
+    swapEntry(
+      _parameters,
+      observe_RawVariableExpression(sourceParameter),
+      observe_RawVariableExpression(targetParameter),
+    );
+  },
+);

package/src/graph-manager/DSL_DataQuality_PureGraphManagerPlugin.ts

@@ -24,10 +24,12 @@ import {
 import {
   DataQualityClassValidationsConfiguration,
   DataQualityServiceValidationConfiguration,
+  DataQualityRelationValidationConfiguration,
 } from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
 import {
   observe_DataQualityConstraintsConfiguration,
   observe_DataQualityServiceValidationConfiguration,
+  observe_DataQualityRelationValidationConfiguration,
 } from './action/changeDetection/DSL_DataQuality_ObserverHelper.js';
 import { DSL_DataQuality_buildGraphManagerExtension } from './protocol/pure/DSL_DataQuality_buildGraphManagerExtension.js';
 
@@ -48,6 +50,12 @@ export class DSL_DataQuality_PureGraphManagerPlugin extends PureGraphManagerPlug
         if (element instanceof DataQualityServiceValidationConfiguration) {
           return observe_DataQualityServiceValidationConfiguration(element);
         }
+        if (element instanceof DataQualityRelationValidationConfiguration) {
+          return observe_DataQualityRelationValidationConfiguration(
+            element,
+            context,
+          );
+        }
         return undefined;
       },
     ];

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

@@ -15,17 +15,22 @@
  */
 
 import {
+  type ObserverContext,
   observe_Abstract_PackageableElement,
   observe_Class,
   observe_PackageableElementReference,
   observe_PropertyReference,
   observe_RawLambda,
   skipObserved,
+  skipObservedWithContext,
 } from '@finos/legend-graph';
-import { makeObservable, observable, override } from 'mobx';
+import { computed, makeObservable, observable, override } from 'mobx';
 import {
   type DataQualityClassValidationsConfiguration,
   type DataQualityServiceValidationConfiguration,
+  type DataQualityRelationValidation,
+  type DataQualityRelationValidationConfiguration,
+  type DataQualityRelationQueryLambda,
   DataSpaceDataQualityExecutionContext,
   MappingAndRuntimeDataQualityExecutionContext,
 } from '../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
@@ -151,3 +156,51 @@ export const observe_DataQualityServiceValidationConfiguration = skipObserved(
     return metamodel;
   },
 );
+
+export const observe_DataQualityRelationValidation = skipObserved(
+  (metamodel: DataQualityRelationValidation): DataQualityRelationValidation => {
+    makeObservable(metamodel, {
+      name: observable,
+      assertion: observable,
+      description: observable,
+      type: observable,
+      rowMapFunction: observable,
+    });
+
+    observe_RawLambda(metamodel.assertion);
+    return metamodel;
+  },
+);
+
+export const observe_DataQualityRelationQueryLambda = skipObserved(
+  (metamodel: DataQualityRelationQueryLambda): DataQualityRelationQueryLambda =>
+    makeObservable(metamodel, {
+      body: observable.ref, // only observe the reference, the object itself is not observed
+      parameters: observable,
+      hashCode: computed,
+    }),
+);
+
+export const observe_DataQualityRelationValidationConfiguration =
+  skipObservedWithContext(
+    (
+      metamodel: DataQualityRelationValidationConfiguration,
+      context: ObserverContext,
+    ): DataQualityRelationValidationConfiguration => {
+      observe_Abstract_PackageableElement(metamodel);
+
+      makeObservable<
+        DataQualityRelationValidationConfiguration,
+        '_elementHashCode'
+      >(metamodel, {
+        _elementHashCode: override,
+        query: observable,
+        validations: observable,
+      });
+      metamodel.validations.forEach((value) =>
+        observe_DataQualityRelationValidation(value),
+      );
+      observe_DataQualityRelationQueryLambda(metamodel.query);
+      return metamodel;
+    },
+  );

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

@@ -20,32 +20,34 @@ import {
   type ExecutionResult,
   type PureModel,
   type RootGraphFetchTree,
-  type ParameterValue,
   AbstractPureGraphManagerExtension,
 } from '@finos/legend-graph';
 import { guaranteeNonNullable } from '@finos/legend-shared';
+import type { DQExecuteInputOptions } from '../../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
 
 export abstract class DSL_DataQuality_PureGraphManagerExtension extends AbstractPureGraphManagerExtension {
   abstract generatePlan(
     graph: PureModel,
     packagePath: string,
+    options: DQExecuteInputOptions,
   ): Promise<RawExecutionPlan>;
 
   abstract execute(
     graph: PureModel,
-    lambdaParameterValues: ParameterValue[],
     packagePath: string,
-    previewLimit: number,
+    options: DQExecuteInputOptions,
   ): Promise<ExecutionResult>;
 
   abstract debugExecutionPlanGeneration(
     graph: PureModel,
     packagePath: string,
+    options: DQExecuteInputOptions,
   ): Promise<{ plan: RawExecutionPlan; debug: string }>;
 
   abstract fetchStructuralValidations(
     graph: PureModel,
     packagePath: string,
+    options: DQExecuteInputOptions,
   ): Promise<RootGraphFetchTree>;
 }