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

package/src/components/DataQualityValidationParametersEditor.tsx

@@ -0,0 +1,355 @@
+/**
+ * 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 { observer } from 'mobx-react-lite';
+import {
+  type Type,
+  type RawVariableExpression,
+  Class,
+  Enumeration,
+  MULTIPLICITY_INFINITE,
+  PrimitiveType,
+  Unit,
+} from '@finos/legend-graph';
+import type { DataQualityRelationValidationConfiguration } from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import { useCallback, useRef, useState } from 'react';
+import {
+  useEditorStore,
+  rawVariableExpression_setName,
+  rawVariableExpression_setType,
+  rawVariableExpression_setMultiplicity,
+  getElementIcon,
+  LEGEND_STUDIO_TEST_ID,
+} from '@finos/legend-application-studio';
+import { useApplicationStore } from '@finos/legend-application';
+import {
+  type PackageableElementOption,
+  buildElementOption,
+} from '@finos/legend-lego/graph-editor';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+import {
+  ArrowCircleRightIcon,
+  clsx,
+  createFilter,
+  CustomSelectorInput,
+  LockIcon,
+  PanelDnDEntry,
+  PanelEntryDragHandle,
+  TimesIcon,
+  useDragPreviewLayer,
+} from '@finos/legend-art';
+import { useDrag, useDrop } from 'react-dnd';
+import { dataQualityRelationValidation_swapParameters } from '../graph-manager/DSL_DataQuality_GraphModifierHelper.js';
+
+enum FUNCTION_PARAMETER_TYPE {
+  CLASS = 'CLASS',
+  ENUMERATION = 'ENUMERATION',
+  PRIMITIVE = 'PRIMITIVE',
+}
+const getFunctionParameterType = (type: Type): FUNCTION_PARAMETER_TYPE => {
+  if (type instanceof PrimitiveType) {
+    return FUNCTION_PARAMETER_TYPE.PRIMITIVE;
+  } else if (type instanceof Enumeration) {
+    return FUNCTION_PARAMETER_TYPE.ENUMERATION;
+  } else if (type instanceof Class) {
+    return FUNCTION_PARAMETER_TYPE.CLASS;
+  }
+  throw new UnsupportedOperationError(
+    `Can't classify function parameter`,
+    type,
+  );
+};
+
+export type FunctionParameterDragSource = {
+  parameter: RawVariableExpression;
+};
+
+export const FUNCTION_PARAMETER_DND_TYPE = 'FUNCTION_PARAMETER';
+
+export const DataQualityValidationParametersEditor = observer(
+  (props: {
+    parameter: RawVariableExpression;
+    _validationConfig: DataQualityRelationValidationConfiguration;
+    deleteParameter: () => void;
+    isReadOnly: boolean;
+  }) => {
+    const ref = useRef<HTMLDivElement>(null);
+    const handleRef = useRef<HTMLDivElement>(null);
+
+    const { parameter, _validationConfig, deleteParameter, isReadOnly } = props;
+    const editorStore = useEditorStore();
+    const applicationStore = useApplicationStore();
+    // Name
+    const changeValue: React.ChangeEventHandler<HTMLInputElement> = (event) =>
+      rawVariableExpression_setName(parameter, event.target.value);
+    // Type
+    const [isEditingType, setIsEditingType] = useState(false);
+    const typeOptions =
+      editorStore.graphManagerState.usableClassPropertyTypes.map(
+        buildElementOption,
+      );
+    const paramType = parameter.type.value;
+    const typeName = getFunctionParameterType(paramType);
+    const filterOption = createFilter({
+      ignoreCase: true,
+      ignoreAccents: false,
+      stringify: (option: { data: PackageableElementOption<Type> }): string =>
+        option.data.value.path,
+    });
+    const selectedType = { value: paramType, label: paramType.name };
+    const changeType = (val: PackageableElementOption<Type>): void => {
+      if (val.value !== parameter.type.value) {
+        rawVariableExpression_setType(parameter, val.value);
+        // updateFunctionName(editorStore, applicationStore, _func);
+      }
+      setIsEditingType(false);
+    };
+    const openElement = (): void => {
+      if (!(paramType instanceof PrimitiveType)) {
+        editorStore.graphEditorMode.openElement(
+          paramType instanceof Unit ? paramType.measure : paramType,
+        );
+      }
+    };
+    // Multiplicity
+    const [lowerBound, setLowerBound] = useState<string | number>(
+      parameter.multiplicity.lowerBound,
+    );
+    const [upperBound, setUpperBound] = useState<string | number>(
+      parameter.multiplicity.upperBound ?? MULTIPLICITY_INFINITE,
+    );
+    const updateMultiplicity = (
+      lower: number | string,
+      upper: number | string,
+    ): void => {
+      const lBound = typeof lower === 'number' ? lower : parseInt(lower, 10);
+      const uBound =
+        upper === MULTIPLICITY_INFINITE
+          ? undefined
+          : typeof upper === 'number'
+            ? upper
+            : parseInt(upper, 10);
+      if (!isNaN(lBound) && (uBound === undefined || !isNaN(uBound))) {
+        rawVariableExpression_setMultiplicity(
+          parameter,
+          editorStore.graphManagerState.graph.getMultiplicity(lBound, uBound),
+        );
+      }
+    };
+    const changeLowerBound: React.ChangeEventHandler<HTMLInputElement> = (
+      event,
+    ) => {
+      setLowerBound(event.target.value);
+      updateMultiplicity(event.target.value, upperBound);
+    };
+    const changeUpperBound: React.ChangeEventHandler<HTMLInputElement> = (
+      event,
+    ) => {
+      setUpperBound(event.target.value);
+      updateMultiplicity(lowerBound, event.target.value);
+    };
+
+    // Drag and Drop
+    const handleHover = useCallback(
+      (item: FunctionParameterDragSource): void => {
+        const draggingParameter = item.parameter;
+        const hoveredParameter = parameter;
+        dataQualityRelationValidation_swapParameters(
+          _validationConfig.query.parameters,
+          draggingParameter,
+          hoveredParameter,
+        );
+      },
+      [_validationConfig.query.parameters, parameter],
+    );
+
+    const [{ isBeingDraggedParameter }, dropConnector] = useDrop<
+      FunctionParameterDragSource,
+      void,
+      { isBeingDraggedParameter: RawVariableExpression | undefined }
+    >(
+      () => ({
+        accept: [FUNCTION_PARAMETER_DND_TYPE],
+        hover: (item) => handleHover(item),
+        collect: (
+          monitor,
+        ): {
+          isBeingDraggedParameter: RawVariableExpression | undefined;
+        } => ({
+          isBeingDraggedParameter:
+            monitor.getItem<FunctionParameterDragSource | null>()?.parameter,
+        }),
+      }),
+      [handleHover],
+    );
+    const isBeingDragged = parameter === isBeingDraggedParameter;
+
+    const [, dragConnector, dragPreviewConnector] =
+      useDrag<FunctionParameterDragSource>(
+        () => ({
+          type: FUNCTION_PARAMETER_DND_TYPE,
+          item: () => ({
+            parameter: parameter,
+          }),
+        }),
+        [parameter],
+      );
+    dragConnector(handleRef);
+    dropConnector(ref);
+    useDragPreviewLayer(dragPreviewConnector);
+
+    return (
+      <PanelDnDEntry
+        ref={ref}
+        placeholder={<div className="dnd__placeholder--light"></div>}
+        className="property-basic-editor__container"
+        showPlaceholder={isBeingDragged}
+      >
+        <PanelEntryDragHandle
+          dragSourceConnector={handleRef}
+          isDragging={isBeingDragged}
+        />
+        <div className="property-basic-editor">
+          {isReadOnly && (
+            <div className="property-basic-editor__lock">
+              <LockIcon />
+            </div>
+          )}
+          <input
+            className="property-basic-editor__name input--dark"
+            disabled={isReadOnly}
+            value={parameter.name}
+            spellCheck={false}
+            onChange={changeValue}
+            placeholder="Parameter name"
+          />
+          {!isReadOnly && isEditingType && (
+            <CustomSelectorInput
+              className="property-basic-editor__type"
+              options={typeOptions}
+              onChange={changeType}
+              value={selectedType}
+              placeholder="Choose a type..."
+              filterOption={filterOption}
+              darkMode={
+                !applicationStore.layoutService
+                  .TEMPORARY__isLightColorThemeEnabled
+              }
+            />
+          )}
+          {!isReadOnly && !isEditingType && (
+            <div
+              className={clsx(
+                'property-basic-editor__type',
+                'property-basic-editor__type--show-click-hint',
+                `background--${typeName.toLowerCase()}`,
+                {
+                  'property-basic-editor__type--has-visit-btn':
+                    typeName !== FUNCTION_PARAMETER_TYPE.PRIMITIVE,
+                },
+              )}
+            >
+              {typeName !== FUNCTION_PARAMETER_TYPE.PRIMITIVE && (
+                <div className="property-basic-editor__type__abbr">
+                  {getElementIcon(paramType, editorStore)}
+                </div>
+              )}
+              <div className="property-basic-editor__type__label">
+                {paramType.name}
+              </div>
+              <div
+                className="property-basic-editor__type__label property-basic-editor__type__label--hover"
+                onClick={(): void => setIsEditingType(true)}
+              >
+                Click to edit
+              </div>
+              {typeName !== FUNCTION_PARAMETER_TYPE.PRIMITIVE && (
+                <button
+                  data-testid={LEGEND_STUDIO_TEST_ID.TYPE_VISIT}
+                  className="property-basic-editor__type__visit-btn"
+                  onClick={openElement}
+                  tabIndex={-1}
+                  title="Visit element"
+                >
+                  <ArrowCircleRightIcon />
+                </button>
+              )}
+            </div>
+          )}
+          {isReadOnly && (
+            <div
+              className={clsx(
+                'property-basic-editor__type',
+                `background--${typeName.toLowerCase()}`,
+                {
+                  'property-basic-editor__type--has-visit-btn':
+                    typeName !== FUNCTION_PARAMETER_TYPE.PRIMITIVE,
+                },
+              )}
+            >
+              {typeName !== FUNCTION_PARAMETER_TYPE.PRIMITIVE && (
+                <div className="property-basic-editor__type__abbr">
+                  {getElementIcon(paramType, editorStore)}
+                </div>
+              )}
+              <div className="property-basic-editor__type__label">
+                {paramType.name}
+              </div>
+              {typeName !== FUNCTION_PARAMETER_TYPE.PRIMITIVE && (
+                <button
+                  data-testid={LEGEND_STUDIO_TEST_ID.TYPE_VISIT}
+                  className="property-basic-editor__type__visit-btn"
+                  onClick={openElement}
+                  tabIndex={-1}
+                  title="Visit element"
+                >
+                  <ArrowCircleRightIcon />
+                </button>
+              )}
+            </div>
+          )}
+          <div className="property-basic-editor__multiplicity">
+            <input
+              className="property-basic-editor__multiplicity-bound"
+              disabled={isReadOnly}
+              spellCheck={false}
+              value={lowerBound}
+              onChange={changeLowerBound}
+            />
+            <div className="property-basic-editor__multiplicity__range">..</div>
+            <input
+              className="property-basic-editor__multiplicity-bound"
+              disabled={isReadOnly}
+              spellCheck={false}
+              value={upperBound}
+              onChange={changeUpperBound}
+            />
+          </div>
+          {!isReadOnly && (
+            <button
+              className="uml-element-editor__remove-btn btn--dark btn--caution"
+              disabled={isReadOnly}
+              onClick={deleteParameter}
+              tabIndex={-1}
+              title="Remove"
+            >
+              <TimesIcon />
+            </button>
+          )}
+        </div>
+      </PanelDnDEntry>
+    );
+  },
+);

package/src/components/states/ConstraintState.ts

@@ -23,6 +23,8 @@ import { action, makeObservable, observable } from 'mobx';
 import { uuid } from '@finos/legend-shared';
 
 export const CONSTRAINT_SOURCE_ID_LABEL = 'constraint';
+export const VALIDATION_SOURCE_ID_LABEL = 'validation';
+export const VALIDATION_ROW_MAP_ID_LABEL = 'validation_row_map';
 
 export class ConstraintState {
   readonly uuid = uuid();

package/src/components/states/DataQualityClassValidationState.ts

@@ -40,7 +40,7 @@ import {
   DataSpace,
   resolveUsableDataSpaceClasses,
 } from '@finos/legend-extension-dsl-data-space/graph';
-import { ELEMENT_CREATION_BASIS } from '../DSL_DataQuality_ClassElementDriver.js';
+import { CLASS_ELEMENT_CREATION_BASIS } from '../DSL_DataQuality_ElementDriver.js';
 import {
   type GeneratorFn,
   assertType,
@@ -62,8 +62,8 @@ import { DataQualityResultState } from './DataQualityResultState.js';
 export class DataQualityClassValidationState extends DataQualityState {
   dataSpace?: DataSpace | undefined;
   dataSpaces: DataSpaceInfo[] = [];
-  validationElementCreationBasis: ELEMENT_CREATION_BASIS =
-    ELEMENT_CREATION_BASIS.MAPPING_RUNTIME_BASED;
+  validationElementCreationBasis: CLASS_ELEMENT_CREATION_BASIS =
+    CLASS_ELEMENT_CREATION_BASIS.MAPPING_RUNTIME_BASED;
 
   constructor(
     editorStore: EditorStore,
@@ -112,7 +112,7 @@ export class DataQualityClassValidationState extends DataQualityState {
       MappingAndRuntimeDataQualityExecutionContext
     ) {
       this.validationElementCreationBasis =
-        ELEMENT_CREATION_BASIS.MAPPING_RUNTIME_BASED;
+        CLASS_ELEMENT_CREATION_BASIS.MAPPING_RUNTIME_BASED;
       this.dataQualityQueryBuilderState.executionContextState.setMapping(
         this.constraintsConfigurationElement.context.mapping.value,
       );
@@ -130,7 +130,7 @@ export class DataQualityClassValidationState extends DataQualityState {
       DataSpaceDataQualityExecutionContext
     ) {
       this.validationElementCreationBasis =
-        ELEMENT_CREATION_BASIS.DATASPACE_BASED;
+        CLASS_ELEMENT_CREATION_BASIS.DATASPACE_BASED;
       this.dataSpace =
         this.constraintsConfigurationElement.context.dataSpace.value;
       this.executionContext = this.dataSpace.defaultExecutionContext;

package/src/components/states/DataQualityRelationResultState.ts

@@ -0,0 +1,274 @@
+/**
+ * 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 {
+  buildExecutionParameterValues,
+  ExecutionPlanState,
+  QUERY_BUILDER_EVENT,
+  QueryBuilderTelemetryHelper,
+} from '@finos/legend-query-builder';
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import {
+  type GeneratorFn,
+  assertErrorThrown,
+  LogEvent,
+  StopWatch,
+} from '@finos/legend-shared';
+import {
+  type ExecutionResult,
+  type RawExecutionPlan,
+  GRAPH_MANAGER_EVENT,
+} from '@finos/legend-graph';
+import { getDataQualityPureGraphManagerExtension } from '../../graph-manager/protocol/pure/DSL_DataQuality_PureGraphManagerExtension.js';
+import type { DataQualityRelationValidationConfigurationState } from './DataQualityRelationValidationConfigurationState.js';
+import type { DataQualityRelationValidation } from '../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+
+export const DEFAULT_LIMIT = 1000;
+export class DataQualityRelationResultState {
+  readonly dataQualityRelationValidationConfigurationState: DataQualityRelationValidationConfigurationState;
+  readonly executionPlanState: ExecutionPlanState;
+
+  previewLimit = DEFAULT_LIMIT;
+  isRunningValidation = false;
+  isGeneratingPlan = false;
+  executionResult?: ExecutionResult | undefined;
+  executionDuration?: number | undefined;
+  latestRunHashCode?: string | undefined;
+  validationRunPromise: Promise<ExecutionResult> | undefined = undefined;
+  validationToRun: DataQualityRelationValidation | undefined;
+
+  constructor(
+    dataQualityRelationValidationState: DataQualityRelationValidationConfigurationState,
+  ) {
+    makeObservable(this, {
+      executionResult: observable,
+      previewLimit: observable,
+      executionDuration: observable,
+      latestRunHashCode: observable,
+      validationRunPromise: observable,
+      isGeneratingPlan: observable,
+      isRunningValidation: observable,
+      validationToRun: observable,
+      setIsRunningValidation: action,
+      setExecutionResult: action,
+      setExecutionDuration: action,
+      setPreviewLimit: action,
+      setValidationRunPromise: action,
+      setValidationToRun: action,
+      handleRunValidation: action,
+      runValidation: flow,
+      cancelValidation: flow,
+      generatePlan: flow,
+    });
+
+    this.dataQualityRelationValidationConfigurationState =
+      dataQualityRelationValidationState;
+    this.executionPlanState = new ExecutionPlanState(
+      this.dataQualityRelationValidationConfigurationState.editorStore.applicationStore,
+      this.dataQualityRelationValidationConfigurationState.editorStore.graphManagerState,
+    );
+  }
+
+  setIsRunningValidation(val: boolean): void {
+    this.isRunningValidation = val;
+  }
+
+  setExecutionResult(val: ExecutionResult | undefined): void {
+    this.executionResult = val;
+  }
+
+  setExecutionDuration(val: number | undefined): void {
+    this.executionDuration = val;
+  }
+
+  setPreviewLimit(val: number): void {
+    this.previewLimit = Math.max(1, val);
+  }
+
+  setValidationRunPromise(promise: Promise<ExecutionResult> | undefined): void {
+    this.validationRunPromise = promise;
+  }
+
+  setValidationToRun(validation: DataQualityRelationValidation): void {
+    this.validationToRun = validation;
+  }
+
+  get checkForStaleResults(): boolean {
+    if (
+      this.latestRunHashCode !==
+      this.dataQualityRelationValidationConfigurationState.hashCode
+    ) {
+      return true;
+    }
+    return false;
+  }
+
+  handleRunValidation() {
+    if (this.isRunningValidation) {
+      return;
+    }
+    const queryLambda =
+      this.dataQualityRelationValidationConfigurationState
+        .bodyExpressionSequence;
+    const parameters = (queryLambda.parameters ?? []) as object[];
+    if (parameters.length) {
+      this.dataQualityRelationValidationConfigurationState.parametersState.openModal(
+        queryLambda,
+      );
+    } else {
+      flowResult(this.runValidation()).catch(
+        this.dataQualityRelationValidationConfigurationState.editorStore
+          .applicationStore.alertUnhandledError,
+      );
+    }
+  }
+
+  *runValidation(): GeneratorFn<void> {
+    let promise;
+    try {
+      this.setIsRunningValidation(true);
+      const currentHashCode =
+        this.dataQualityRelationValidationConfigurationState.hashCode;
+      const packagePath =
+        this.dataQualityRelationValidationConfigurationState.validationElement
+          .path;
+      const model =
+        this.dataQualityRelationValidationConfigurationState.editorStore
+          .graphManagerState.graph;
+
+      const stopWatch = new StopWatch();
+
+      promise = getDataQualityPureGraphManagerExtension(
+        this.dataQualityRelationValidationConfigurationState.editorStore
+          .graphManagerState.graphManager,
+      ).execute(model, packagePath, {
+        previewLimit: this.previewLimit,
+        validationName: this.validationToRun?.name,
+        lambdaParameterValues: buildExecutionParameterValues(
+          this.dataQualityRelationValidationConfigurationState.parametersState
+            .parameterStates,
+          this.dataQualityRelationValidationConfigurationState.editorStore
+            .graphManagerState,
+        ),
+      });
+
+      this.setValidationRunPromise(promise);
+      const result = (yield promise) as ExecutionResult;
+
+      if (this.validationRunPromise === promise) {
+        this.setExecutionResult(result);
+        this.latestRunHashCode = currentHashCode;
+        this.setExecutionDuration(stopWatch.elapsed);
+      }
+    } catch (error) {
+      if (this.validationRunPromise === promise) {
+        assertErrorThrown(error);
+        this.setExecutionResult(undefined);
+        this.dataQualityRelationValidationConfigurationState.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+          error,
+        );
+        this.dataQualityRelationValidationConfigurationState.editorStore.applicationStore.notificationService.notifyError(
+          error,
+        );
+      }
+    } finally {
+      this.setIsRunningValidation(false);
+    }
+  }
+
+  *cancelValidation(): GeneratorFn<void> {
+    this.setIsRunningValidation(false);
+    this.setValidationRunPromise(undefined);
+    try {
+      yield this.dataQualityRelationValidationConfigurationState.editorStore.graphManagerState.graphManager.cancelUserExecutions(
+        true,
+      );
+    } catch (error) {
+      // Don't notify users about success or failure
+      this.dataQualityRelationValidationConfigurationState.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+    }
+  }
+
+  *generatePlan(debug: boolean): GeneratorFn<void> {
+    const packagePath =
+      this.dataQualityRelationValidationConfigurationState.validationElement
+        .path;
+    const model =
+      this.dataQualityRelationValidationConfigurationState.editorStore
+        .graphManagerState.graph;
+    try {
+      this.isGeneratingPlan = true;
+      let rawPlan: RawExecutionPlan;
+
+      const stopWatch = new StopWatch();
+
+      if (debug) {
+        const debugResult = (yield getDataQualityPureGraphManagerExtension(
+          this.dataQualityRelationValidationConfigurationState.editorStore
+            .graphManagerState.graphManager,
+        ).debugExecutionPlanGeneration(model, packagePath, {
+          validationName: this.validationToRun?.name,
+        })) as {
+          plan: RawExecutionPlan;
+          debug: string;
+        };
+        rawPlan = debugResult.plan;
+        this.executionPlanState.setDebugText(debugResult.debug);
+      } else {
+        QueryBuilderTelemetryHelper.logEvent_ExecutionPlanGenerationLaunched(
+          this.dataQualityRelationValidationConfigurationState.editorStore
+            .applicationStore.telemetryService,
+        );
+        rawPlan = (yield getDataQualityPureGraphManagerExtension(
+          this.dataQualityRelationValidationConfigurationState.editorStore
+            .graphManagerState.graphManager,
+        ).generatePlan(model, packagePath, {
+          validationName: this.validationToRun?.name,
+        })) as RawExecutionPlan;
+      }
+
+      stopWatch.record();
+      try {
+        this.executionPlanState.setRawPlan(rawPlan);
+        const plan =
+          this.dataQualityRelationValidationConfigurationState.editorStore.graphManagerState.graphManager.buildExecutionPlan(
+            rawPlan,
+            this.dataQualityRelationValidationConfigurationState.editorStore
+              .graphManagerState.graph,
+          );
+        this.executionPlanState.initialize(plan);
+      } catch {
+        //do nothing
+      }
+      stopWatch.record(QUERY_BUILDER_EVENT.BUILD_EXECUTION_PLAN__SUCCESS);
+    } catch (error) {
+      assertErrorThrown(error);
+      this.dataQualityRelationValidationConfigurationState.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+      this.dataQualityRelationValidationConfigurationState.editorStore.applicationStore.notificationService.notifyError(
+        error,
+      );
+    } finally {
+      this.isGeneratingPlan = false;
+    }
+  }
+}