@finos/legend-extension-dsl-data-quality 2.0.11 → 2.0.13

package/src/components/DataQualityRelationValidationsEditor.tsx

@@ -0,0 +1,101 @@
+/**
+ * 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 { DataQualityRelationValidationConfigurationState } from './states/DataQualityRelationValidationConfigurationState.js';
+import React from 'react';
+import { DragPreviewLayer, PlusIcon } from '@finos/legend-art';
+import { stub_RawLambda } from '@finos/legend-graph';
+import {
+  dataQualityRelationValidation_addValidation,
+  dataQualityRelationValidation_deleteValidation,
+} from '../graph-manager/DSL_DataQuality_GraphModifierHelper.js';
+import {
+  type RelationValidationDragSource,
+  DataQualityRelationValidationEditor,
+  RELATION_VALIDATION_DND_TYPE,
+} from './DataQualityRelationValidationEditor.js';
+import { DataQualityRelationValidation } from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+
+export const DataQualityRelationValidationsEditor = observer(
+  (props: {
+    dataQualityRelationValidationConfigurationState: DataQualityRelationValidationConfigurationState;
+  }) => {
+    const { dataQualityRelationValidationConfigurationState } = props;
+    const { validationElement, isReadOnly } =
+      dataQualityRelationValidationConfigurationState;
+
+    const addRelationValidation = (): void => {
+      const relationValidation = new DataQualityRelationValidation(
+        '',
+        stub_RawLambda(),
+      );
+      dataQualityRelationValidation_addValidation(
+        validationElement,
+        relationValidation,
+      );
+      dataQualityRelationValidationConfigurationState.addValidationState(
+        relationValidation,
+      );
+    };
+
+    const deleteRelationValidation =
+      (validation: DataQualityRelationValidation): (() => void) =>
+      (): void => {
+        dataQualityRelationValidation_deleteValidation(
+          validationElement,
+          validation,
+        );
+        dataQualityRelationValidationConfigurationState.deleteValidationState(
+          validation,
+        );
+      };
+
+    return (
+      <div className="relation-validation-config-editor__definition__item">
+        <div className="relation-validation-config-editor__definition__item__header-right">
+          <button
+            className="relation-validation-config-editor__definition__item__header__add-btn btn--dark"
+            disabled={isReadOnly}
+            onClick={addRelationValidation}
+            tabIndex={-1}
+            title="Add Relation Validation"
+          >
+            <PlusIcon />
+          </button>
+        </div>
+        <div className="relation-config-validations">
+          <DragPreviewLayer
+            labelGetter={(item: RelationValidationDragSource): string =>
+              item.validation.name === '' ? '(unknown)' : item.validation.name
+            }
+            types={[RELATION_VALIDATION_DND_TYPE]}
+          />
+          {validationElement.validations.map((relationValidation) => (
+            <DataQualityRelationValidationEditor
+              key={relationValidation._UUID}
+              validation={relationValidation}
+              relationValidationConfigurationState={
+                dataQualityRelationValidationConfigurationState
+              }
+              deleteValidation={deleteRelationValidation(relationValidation)}
+              isReadOnly={isReadOnly}
+            />
+          ))}
+        </div>
+      </div>
+    );
+  },
+);

package/src/components/DataQualityResultValues.tsx

@@ -19,14 +19,34 @@ import {
   type ExecutionResult,
   extractExecutionResultValues,
   RawExecutionResult,
+  TDSExecutionResult,
 } from '@finos/legend-graph';
 import { CODE_EDITOR_LANGUAGE } from '@finos/legend-code-editor';
 import { CodeEditor } from '@finos/legend-lego/code-editor';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
+import { DataQualityRelationGridResult } from './DataQualityRelationGridResult.js';
+import React from 'react';
+import type { DataQualityRelationValidationConfigurationState } from './states/DataQualityRelationValidationConfigurationState.js';
 
 export const DataQualityResultValues = observer(
-  (props: { executionResult: ExecutionResult }) => {
-    const { executionResult } = props;
+  (props: {
+    executionResult: ExecutionResult;
+    relationValidationConfigurationState?: DataQualityRelationValidationConfigurationState;
+  }) => {
+    const { executionResult, relationValidationConfigurationState } = props;
+    if (
+      relationValidationConfigurationState &&
+      executionResult instanceof TDSExecutionResult
+    ) {
+      return (
+        <DataQualityRelationGridResult
+          executionResult={executionResult}
+          relationValidationConfigurationState={
+            relationValidationConfigurationState
+          }
+        />
+      );
+    }
     if (executionResult instanceof RawExecutionResult) {
       const inputValue =
         executionResult.value === null

package/src/components/DataQualityValidationDetailPanel.tsx

@@ -39,7 +39,7 @@ export const DataQualityValidationDetailPanel = observer(
     relationValidationState: DataQualityRelationValidationState;
     changeName: React.ChangeEventHandler<HTMLInputElement>;
     changeDescription: React.ChangeEventHandler<HTMLInputElement>;
-    onLambdaEditorFocus: (() => void) | undefined;
+    onLambdaEditorFocus: (isAssertion: boolean) => void;
     onValidationTypeChange: (val: SelectOption) => void;
     selectedValidationType: {
       label: RelationValidationType;
@@ -123,35 +123,45 @@ export const DataQualityValidationDetailPanel = observer(
                   <div className="relation-validation-editor__label">
                     Row map function
                   </div>
-                  <InlineLambdaEditor
-                    disabled={
-                      dataQualityRelationValidationState.isConvertingValidationLambdaObjects ||
-                      isReadOnly
-                    }
-                    lambdaEditorState={rowMapFunctionLambdaEditorState}
-                    forceBackdrop={forceBackdrop}
-                    expectedType={PrimitiveType.BOOLEAN}
-                    onEditorFocus={onLambdaEditorFocus}
-                    disablePopUp={true}
-                  />
+                  <div className="data-quality-uml-element-editor__validation">
+                    <div className="data-quality-uml-element-editor__lambda__value">
+                      <InlineLambdaEditor
+                        disabled={
+                          dataQualityRelationValidationState.isConvertingValidationLambdaObjects ||
+                          isReadOnly
+                        }
+                        lambdaEditorState={rowMapFunctionLambdaEditorState}
+                        forceBackdrop={forceBackdrop}
+                        expectedType={PrimitiveType.BOOLEAN}
+                        onEditorFocus={() => onLambdaEditorFocus(false)}
+                        disablePopUp={true}
+                        className="relation-validation__lambda"
+                      />
+                    </div>
+                  </div>
                 </div>
               )}
               <div className="relation-validation-editor__content">
                 <div className="relation-validation-editor__label">
                   Validation Grammar
                 </div>
-                <InlineLambdaEditor
-                  disabled={
-                    dataQualityRelationValidationState.isConvertingValidationLambdaObjects ||
-                    isReadOnly
-                  }
-                  lambdaEditorState={relationValidationState}
-                  forceBackdrop={forceBackdrop}
-                  expectedType={PrimitiveType.BOOLEAN}
-                  onEditorFocus={onLambdaEditorFocus}
-                  disablePopUp={true}
-                  forceExpansion={true}
-                />
+                <div className="data-quality-uml-element-editor__validation">
+                  <div className="data-quality-uml-element-editor__lambda__value">
+                    <InlineLambdaEditor
+                      disabled={
+                        dataQualityRelationValidationState.isConvertingValidationLambdaObjects ||
+                        isReadOnly
+                      }
+                      lambdaEditorState={relationValidationState}
+                      forceBackdrop={forceBackdrop}
+                      expectedType={PrimitiveType.BOOLEAN}
+                      onEditorFocus={() => onLambdaEditorFocus(true)}
+                      disablePopUp={true}
+                      forceExpansion={true}
+                      className="relation-validation__lambda"
+                    />
+                  </div>
+                </div>
               </div>
               <div className="relation-validation-editor__content">
                 <div className="relation-validation-editor__label">

package/src/components/states/DataQualityRelationResultState.ts

@@ -36,6 +36,22 @@ import { getDataQualityPureGraphManagerExtension } from '../../graph-manager/pro
 import type { DataQualityRelationValidationConfigurationState } from './DataQualityRelationValidationConfigurationState.js';
 import type { DataQualityRelationValidation } from '../../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
 
+export type DataQualityRelationResultCellDataType =
+  | string
+  | number
+  | boolean
+  | null
+  | undefined;
+
+export interface DataQualityRelationRowDataType {
+  [key: string]: DataQualityRelationResultCellDataType;
+}
+
+export interface DataQualityRelationResultCellCoordinate {
+  rowIndex: number;
+  colIndex: number;
+}
+
 export const DEFAULT_LIMIT = 1000;
 export class DataQualityRelationResultState {
   readonly dataQualityRelationValidationConfigurationState: DataQualityRelationValidationConfigurationState;
@@ -117,9 +133,6 @@ export class DataQualityRelationResultState {
   }
 
   handleRunValidation() {
-    if (this.isRunningValidation) {
-      return;
-    }
     const queryLambda =
       this.dataQualityRelationValidationConfigurationState
         .bodyExpressionSequence;
@@ -127,6 +140,7 @@ export class DataQualityRelationResultState {
     if (parameters.length) {
       this.dataQualityRelationValidationConfigurationState.parametersState.openModal(
         queryLambda,
+        true,
       );
     } else {
       flowResult(this.runValidation()).catch(
@@ -225,6 +239,7 @@ export class DataQualityRelationResultState {
             .graphManagerState.graphManager,
         ).debugExecutionPlanGeneration(model, packagePath, {
           validationName: this.validationToRun?.name,
+          previewLimit: this.previewLimit,
         })) as {
           plan: RawExecutionPlan;
           debug: string;
@@ -241,6 +256,7 @@ export class DataQualityRelationResultState {
             .graphManagerState.graphManager,
         ).generatePlan(model, packagePath, {
           validationName: this.validationToRun?.name,
+          previewLimit: this.previewLimit,
         })) as RawExecutionPlan;
       }
 

package/src/components/states/DataQualityRelationValidationConfigurationState.ts

@@ -18,7 +18,6 @@ import {
   type EditorStore,
   ElementEditorState,
 } from '@finos/legend-application-studio';
-
 import {
   type DataQualityRelationValidation,
   DataQualityRelationValidationConfiguration,
@@ -36,7 +35,7 @@ import {
 } from '@finos/legend-shared';
 import {
   type ExecutionResult,
-  type ExecutionResultWithMetadata,
+  type RawExecutionPlan,
   buildSourceInformationSourceId,
   GRAPH_MANAGER_EVENT,
   isStubbed_PackageableElement,
@@ -56,6 +55,8 @@ import {
   observable,
 } from 'mobx';
 import {
+  buildExecutionParameterValues,
+  ExecutionPlanState,
   LambdaEditorState,
   LambdaParametersState,
   LambdaParameterState,
@@ -65,9 +66,11 @@ import { DataQualityRelationValidationState } from './DataQualityRelationValidat
 import { DataQualityRelationResultState } from './DataQualityRelationResultState.js';
 import { DATA_QUALITY_HASH_STRUCTURE } from '../../graph/metamodel/DSL_DataQuality_HashUtils.js';
 import type { SelectOption } from '@finos/legend-art';
+import { getDataQualityPureGraphManagerExtension } from '../../graph-manager/protocol/pure/DSL_DataQuality_PureGraphManagerExtension.js';
 
 export enum DATA_QUALITY_RELATION_VALIDATION_EDITOR_TAB {
   DEFINITION = 'Definition',
+  VALIDATIONS = 'Validations',
   TRIAL_RUN = 'Trial Run',
 }
 
@@ -203,21 +206,18 @@ export class RelationDefinitionParameterState extends LambdaParametersState {
       relationValidationConfigurationState;
   }
 
-  openModal(lambda: RawLambda): void {
+  openModal(lambda: RawLambda, runLambdaWithConstraints: boolean): void {
     this.parameterStates = this.build(lambda);
     this.parameterValuesEditorState.open(
       (): Promise<void> =>
         flowResult(
-          this.relationValidationConfigurationState.resultState.runValidation(),
-        )
-          .catch(
-            this.relationValidationConfigurationState.editorStore
-              .applicationStore.alertUnhandledError,
-          )
-          .catch(
-            this.relationValidationConfigurationState.editorStore
-              .applicationStore.alertUnhandledError,
-          ),
+          runLambdaWithConstraints
+            ? this.relationValidationConfigurationState.resultState.runValidation()
+            : this.relationValidationConfigurationState.runValidation(),
+        ).catch(
+          this.relationValidationConfigurationState.editorStore.applicationStore
+            .alertUnhandledError,
+        ),
       PARAMETER_SUBMIT_ACTION.RUN,
     );
   }
@@ -252,9 +252,11 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
   readonly relationFunctionDefinitionEditorState: RelationFunctionDefinitionEditorState;
   selectedTab: DATA_QUALITY_RELATION_VALIDATION_EDITOR_TAB;
 
-  isRunningFunc = false;
-  funcRunPromise: Promise<ExecutionResultWithMetadata> | undefined = undefined;
+  isRunningValidation = false;
+  isGeneratingPlan = false;
+  validationRunPromise: Promise<ExecutionResult> | undefined = undefined;
   executionResult?: ExecutionResult | undefined; // NOTE: stored as lossless JSON string
+  executionPlanState: ExecutionPlanState;
   validationStates: DataQualityRelationValidationState[] = [];
   parametersState: RelationDefinitionParameterState;
   isConvertingValidationLambdaObjects = false;
@@ -268,16 +270,22 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
 
     makeObservable(this, {
       selectedTab: observable,
-      isRunningFunc: observable,
-      funcRunPromise: observable,
+      isRunningValidation: observable,
+      validationRunPromise: observable,
       executionResult: observable,
+      resultState: observable,
       setSelectedTab: action,
-      setFuncRunPromise: action,
+      setValidationRunPromise: action,
       setExecutionResult: action,
       addValidationState: action,
+      resetResultState: action,
       validationElement: computed,
       relationValidationOptions: computed,
+      runValidation: flow,
+      handleRunValidation: flow,
       convertValidationLambdaObjects: flow,
+      cancelValidationRun: flow,
+      generatePlan: flow,
     });
     assertType(
       element,
@@ -292,6 +300,10 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
         new DataQualityRelationValidationState(validation, editorStore),
       );
     });
+    this.executionPlanState = new ExecutionPlanState(
+      this.editorStore.applicationStore,
+      this.editorStore.graphManagerState,
+    );
     this.parametersState = new RelationDefinitionParameterState(this);
     this.resultState = new DataQualityRelationResultState(this);
   }
@@ -314,6 +326,15 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
     );
   }
 
+  get validationOptions(): SelectOption[] {
+    return this.validationElement.validations.map((validation) => {
+      return {
+        label: validation.name,
+        value: validation,
+      };
+    });
+  }
+
   getNullableValidationState = (
     relationValidation: DataQualityRelationValidation,
   ): DataQualityRelationValidationState | undefined =>
@@ -336,6 +357,11 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
       value: type,
     }));
   }
+
+  resetResultState(): void {
+    this.resultState = new DataQualityRelationResultState(this);
+  }
+
   addValidationState(validation: DataQualityRelationValidation): void {
     if (
       !this.validationStates.find(
@@ -357,10 +383,10 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
     }
   }
 
-  setFuncRunPromise = (
-    promise: Promise<ExecutionResultWithMetadata> | undefined,
+  setValidationRunPromise = (
+    promise: Promise<ExecutionResult> | undefined,
   ): void => {
-    this.funcRunPromise = promise;
+    this.validationRunPromise = promise;
   };
 
   setSelectedTab(tab: DATA_QUALITY_RELATION_VALIDATION_EDITOR_TAB): void {
@@ -371,6 +397,21 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
     this.executionResult = executionResult;
   };
 
+  *handleRunValidation(): GeneratorFn<void> {
+    if (this.isRunningValidation) {
+      return;
+    }
+    const queryLambda = this.bodyExpressionSequence;
+    const parameters = (queryLambda.parameters ?? []) as object[];
+    if (parameters.length) {
+      this.parametersState.openModal(queryLambda, false);
+    } else {
+      flowResult(this.runValidation()).catch(
+        this.editorStore.applicationStore.alertUnhandledError,
+      );
+    }
+  }
+
   *convertValidationLambdaObjects(): GeneratorFn<void> {
     const lambdas = new Map<string, RawLambda>();
     const index = new Map<string, DataQualityRelationValidationState>();
@@ -419,6 +460,115 @@ export class DataQualityRelationValidationConfigurationState extends ElementEdit
     );
   }
 
+  setIsRunningValidation(val: boolean): void {
+    this.isRunningValidation = val;
+  }
+
+  *runValidation(): GeneratorFn<void> {
+    let promise;
+    try {
+      this.setIsRunningValidation(true);
+      const packagePath = this.validationElement.path;
+      const model = this.editorStore.graphManagerState.graph;
+
+      promise = getDataQualityPureGraphManagerExtension(
+        this.editorStore.graphManagerState.graphManager,
+      ).execute(model, packagePath, {
+        runQuery: true,
+        lambdaParameterValues: buildExecutionParameterValues(
+          this.parametersState.parameterStates,
+          this.editorStore.graphManagerState,
+        ),
+      });
+
+      this.setValidationRunPromise(promise);
+      const result = (yield promise) as ExecutionResult;
+
+      if (this.validationRunPromise === promise) {
+        this.setExecutionResult(result);
+      }
+    } catch (error) {
+      if (this.validationRunPromise === promise) {
+        assertErrorThrown(error);
+        this.setExecutionResult(undefined);
+        this.editorStore.applicationStore.logService.error(
+          LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+          error,
+        );
+        this.editorStore.applicationStore.notificationService.notifyError(
+          error,
+        );
+      }
+    } finally {
+      this.setIsRunningValidation(false);
+    }
+  }
+
+  *cancelValidationRun(): GeneratorFn<void> {
+    this.setIsRunningValidation(false);
+    this.setValidationRunPromise(undefined);
+    try {
+      yield this.editorStore.graphManagerState.graphManager.cancelUserExecutions(
+        true,
+      );
+    } catch (error) {
+      // Don't notify users about success or failure
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+    }
+  }
+
+  *generatePlan(debug: boolean): GeneratorFn<void> {
+    const packagePath = this.validationElement.path;
+    const model = this.editorStore.graphManagerState.graph;
+    try {
+      this.isGeneratingPlan = true;
+      let rawPlan: RawExecutionPlan;
+
+      if (debug) {
+        const debugResult = (yield getDataQualityPureGraphManagerExtension(
+          this.editorStore.graphManagerState.graphManager,
+        ).debugExecutionPlanGeneration(model, packagePath, {
+          runQuery: true,
+        })) as {
+          plan: RawExecutionPlan;
+          debug: string;
+        };
+        rawPlan = debugResult.plan;
+        this.executionPlanState.setDebugText(debugResult.debug);
+      } else {
+        rawPlan = (yield getDataQualityPureGraphManagerExtension(
+          this.editorStore.graphManagerState.graphManager,
+        ).generatePlan(model, packagePath, {
+          runQuery: true,
+        })) as RawExecutionPlan;
+      }
+
+      try {
+        this.executionPlanState.setRawPlan(rawPlan);
+        const plan =
+          this.editorStore.graphManagerState.graphManager.buildExecutionPlan(
+            rawPlan,
+            this.editorStore.graphManagerState.graph,
+          );
+        this.executionPlanState.initialize(plan);
+      } catch {
+        //do nothing
+      }
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.isGeneratingPlan = false;
+    }
+  }
+
   get hashCode(): string {
     return hashArray([
       DATA_QUALITY_HASH_STRUCTURE.DATA_QUALITY_RELATION_VALIDATION,

package/src/components/states/DataQualityRelationValidationLambdaEditorState.ts

@@ -42,7 +42,7 @@ export class DataQualityRelationValidationLambdaEditorState extends LambdaEditor
     relationValidation: DataQualityRelationValidation,
     editorStore: EditorStore,
   ) {
-    super('true', '|');
+    super('', '|');
 
     makeObservable(this, {
       relationValidation: observable,

package/src/components/states/DataQualityRelationValidationState.ts

@@ -37,6 +37,7 @@ import { LambdaEditorState } from '@finos/legend-query-builder';
 import { VALIDATION_SOURCE_ID_LABEL } from './ConstraintState.js';
 import {
   dataQualityRelationValidation_setAssertion,
+  dataQualityRelationValidation_setRowMapFunction,
   dataQualityRelationValidation_setType,
 } from '../../graph-manager/DSL_DataQuality_GraphModifierHelper.js';
 import { DATA_QUALITY_HASH_STRUCTURE } from '../../graph/metamodel/DSL_DataQuality_HashUtils.js';
@@ -60,6 +61,7 @@ export class DataQualityRelationValidationState extends LambdaEditorState {
       relationValidation: observable,
       editorStore: observable,
       isValidationDialogOpen: observable,
+      rowMapFunctionLambdaEditorState: observable,
       setIsValidationDialogOpen: action,
       onValidationTypeChange: action,
     });
@@ -92,15 +94,22 @@ export class DataQualityRelationValidationState extends LambdaEditorState {
       this.relationValidation,
       val.value as RelationValidationType,
     );
+    let defaultLambda;
     if (val.value === RelationValidationType.AGGREGATE) {
       this.rowMapFunctionLambdaEditorState =
         new DataQualityRelationValidationLambdaEditorState(
           this.relationValidation,
           this.editorStore,
         );
+      defaultLambda = stub_RawLambda();
     } else {
       this.rowMapFunctionLambdaEditorState = undefined;
+      defaultLambda = undefined;
     }
+    dataQualityRelationValidation_setRowMapFunction(
+      this.relationValidation,
+      defaultLambda,
+    );
   }
 
   *convertLambdaGrammarStringToObject(): GeneratorFn<void> {

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

@@ -40,6 +40,7 @@ export interface DQExecuteInputOptions {
   clientVersion?: string | undefined;
   validationName?: string | undefined;
   previewLimit?: number | undefined;
+  runQuery?: boolean | undefined;
 }
 
 export abstract class DataQualityExecutionContext implements Hashable {

package/src/graph-manager/DSL_DataQuality_GraphModifierHelper.ts

@@ -149,9 +149,11 @@ export const dataQualityRelationValidation_setType = action(
 export const dataQualityRelationValidation_setRowMapFunction = action(
   (
     _constraint: DataQualityRelationValidation,
-    rowMapFunction: RawLambda,
+    rowMapFunction: RawLambda | undefined,
   ): void => {
-    _constraint.rowMapFunction = observe_RawLambda(rowMapFunction);
+    _constraint.rowMapFunction = rowMapFunction
+      ? observe_RawLambda(rowMapFunction)
+      : rowMapFunction;
   },
 );
 

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

@@ -73,6 +73,7 @@ export class V1_DQExecuteInput {
   packagePath!: string;
   queryLimit: number | undefined;
   validationName: string | undefined;
+  runQuery: boolean | undefined;
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_DQExecuteInput, {
@@ -82,6 +83,7 @@ export class V1_DQExecuteInput {
       packagePath: primitive(),
       queryLimit: optional(primitive()),
       validationName: optional(primitive()),
+      runQuery: optional(primitive()),
     }),
   );
 }
@@ -174,6 +176,7 @@ export class V1_DSL_Data_Quality_PureGraphManagerExtension extends DSL_DataQuali
     dqExecuteInput.packagePath = packagePath;
     dqExecuteInput.queryLimit = options.previewLimit;
     dqExecuteInput.validationName = options.validationName;
+    dqExecuteInput.runQuery = options.runQuery;
     return dqExecuteInput;
   }
 

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

@@ -149,6 +149,8 @@ export class V1_DataQualityRelationValidationsConfiguration
 {
   query!: V1_DataQualityRelationQueryLambda;
   validations: V1_DataQualityRelationValidation[] = [];
+  taggedValues: V1_TaggedValue[] = [];
+  stereotypes: V1_StereotypePtr[] = [];
 
   override get hashCode(): string {
     return hashArray([