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

package/lib/package.json

@@ -0,0 +1,87 @@
+{
+    "name": "@finos/legend-extension-dsl-data-quality",
+    "version": "1.0.0",
+    "description": "Legend extension for Data Quality",
+    "keywords": [
+        "legend",
+        "legend-extension",
+        "dsl",
+        "dsl-data-quality"
+    ],
+    "homepage": "https://github.com/finos/legend-studio/tree/master/packages/legend-extension-dsl-data-quality",
+    "bugs": {
+        "url": "https://github.com/finos/legend-studio/issues"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/finos/legend-studio.git",
+        "directory": "packages/legend-extension-dsl-data-quality"
+    },
+    "license": "Apache-2.0",
+    "sideEffects": false,
+    "type": "module",
+    "exports": {
+        "./graph": "./lib/graph-manager/index.js",
+        "./application-studio": "./lib/components/index.js",
+        "./lib/index.css": "./lib/index.css"
+    },
+    "scripts": {
+        "build": "yarn clean && yarn build:sass && yarn build:ts",
+        "build:sass": "cross-env INIT_CWD=$INIT_CWD node ../../scripts/workflow/buildSass.js",
+        "build:ts": "tsc --project ./tsconfig.build.json",
+        "clean": "npm-run-all clean:cache clean:lib",
+        "clean:cache": "rimraf \"build\"",
+        "clean:lib": "rimraf \"lib\"",
+        "dev": "npm-run-all --parallel dev:sass dev:ts",
+        "dev:sass": "sass style:lib --watch --load-path=../../node_modules/@finos/legend-art/scss",
+        "dev:ts": "tsc --watch --preserveWatchOutput",
+        "lint:js": "cross-env NODE_ENV=production eslint --cache --cache-location ./build/.eslintcache --report-unused-disable-directives --parser-options=project:\"./tsconfig.json\" \"./src/**/*.{js,ts,tsx}\"",
+        "publish:prepare": "node ../../scripts/release/preparePublishContent.js",
+        "publish:snapshot": "node ../../scripts/release/publishDevSnapshot.js",
+        "test": "jest",
+        "test:watch": "jest --watch"
+    },
+    "dependencies": {
+        "@finos/legend-application": "workspace:*",
+        "@finos/legend-application-studio": "workspace:*",
+        "@finos/legend-art": "workspace:*",
+        "@finos/legend-extension-dsl-data-space": "workspace:*",
+        "@finos/legend-graph": "workspace:*",
+        "@finos/legend-lego": "workspace:*",
+        "@finos/legend-query-builder": "workspace:*",
+        "@finos/legend-shared": "workspace:*",
+        "@finos/legend-storage": "workspace:*",
+        "@types/react": "18.3.3",
+        "@types/react-dom": "18.3.0",
+        "mobx": "6.12.3",
+        "mobx-react-lite": "4.0.7",
+        "react": "18.3.1",
+        "react-dnd": "16.0.1",
+        "react-dom": "18.3.1",
+        "serializr": "3.0.2"
+    },
+    "devDependencies": {
+        "@finos/legend-dev-utils": "workspace:*",
+        "@jest/globals": "29.7.0",
+        "cross-env": "7.0.3",
+        "eslint": "8.57.0",
+        "jest": "29.7.0",
+        "npm-run-all": "4.1.5",
+        "rimraf": "5.0.7",
+        "sass": "1.77.4",
+        "typescript": "5.4.5"
+    },
+    "peerDependencies": {
+        "react": "^18.0.0"
+    },
+    "publishConfig": {
+        "directory": "build/publishContent"
+    },
+    "extensions": {
+        "graphManagerPreset": "@finos/legend-graph-manager-preset-dsl-data-quality",
+        "applicationStudioPlugin": "@finos/legend-application-plugin-data-quality",
+        "pureGraphPlugin": "@finos/legend-pure-graph-plugin-dsl-data-quality",
+        "pureGraphManagerPlugin": "@finos/legend-pure-graph-manager-plugin-dsl-data-quality",
+        "pureProtocolProcessorPlugin": "@finos/legend-pure-protocol-processor-plugin-dsl-data-quality"
+    }
+}

package/package.json

@@ -0,0 +1,87 @@
+{
+  "name": "@finos/legend-extension-dsl-data-quality",
+  "version": "1.0.0",
+  "description": "Legend extension for Data Quality",
+  "keywords": [
+    "legend",
+    "legend-extension",
+    "dsl",
+    "dsl-data-quality"
+  ],
+  "homepage": "https://github.com/finos/legend-studio/tree/master/packages/legend-extension-dsl-data-quality",
+  "bugs": {
+    "url": "https://github.com/finos/legend-studio/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/finos/legend-studio.git",
+    "directory": "packages/legend-extension-dsl-data-quality"
+  },
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "./graph": "./lib/graph-manager/index.js",
+    "./application-studio": "./lib/components/index.js",
+    "./lib/index.css": "./lib/index.css"
+  },
+  "scripts": {
+    "build": "yarn clean && yarn build:sass && yarn build:ts",
+    "build:sass": "cross-env INIT_CWD=$INIT_CWD node ../../scripts/workflow/buildSass.js",
+    "build:ts": "tsc --project ./tsconfig.build.json",
+    "clean": "npm-run-all clean:cache clean:lib",
+    "clean:cache": "rimraf \"build\"",
+    "clean:lib": "rimraf \"lib\"",
+    "dev": "npm-run-all --parallel dev:sass dev:ts",
+    "dev:sass": "sass style:lib --watch --load-path=../../node_modules/@finos/legend-art/scss",
+    "dev:ts": "tsc --watch --preserveWatchOutput",
+    "lint:js": "cross-env NODE_ENV=production eslint --cache --cache-location ./build/.eslintcache --report-unused-disable-directives --parser-options=project:\"./tsconfig.json\" \"./src/**/*.{js,ts,tsx}\"",
+    "publish:prepare": "node ../../scripts/release/preparePublishContent.js",
+    "publish:snapshot": "node ../../scripts/release/publishDevSnapshot.js",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "dependencies": {
+    "@finos/legend-application": "15.1.13",
+    "@finos/legend-application-studio": "28.17.17",
+    "@finos/legend-art": "7.1.41",
+    "@finos/legend-extension-dsl-data-space": "10.3.34",
+    "@finos/legend-graph": "31.10.8",
+    "@finos/legend-lego": "1.2.44",
+    "@finos/legend-query-builder": "4.14.56",
+    "@finos/legend-shared": "10.0.43",
+    "@finos/legend-storage": "3.0.93",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "mobx": "6.12.3",
+    "mobx-react-lite": "4.0.7",
+    "react": "18.3.1",
+    "react-dnd": "16.0.1",
+    "react-dom": "18.3.1",
+    "serializr": "3.0.2"
+  },
+  "devDependencies": {
+    "@finos/legend-dev-utils": "2.1.11",
+    "@jest/globals": "29.7.0",
+    "cross-env": "7.0.3",
+    "eslint": "8.57.0",
+    "jest": "29.7.0",
+    "npm-run-all": "4.1.5",
+    "rimraf": "5.0.7",
+    "sass": "1.77.4",
+    "typescript": "5.4.5"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0"
+  },
+  "publishConfig": {
+    "directory": "build/publishContent"
+  },
+  "extensions": {
+    "graphManagerPreset": "@finos/legend-graph-manager-preset-dsl-data-quality",
+    "applicationStudioPlugin": "@finos/legend-application-plugin-data-quality",
+    "pureGraphPlugin": "@finos/legend-pure-graph-plugin-dsl-data-quality",
+    "pureGraphManagerPlugin": "@finos/legend-pure-graph-manager-plugin-dsl-data-quality",
+    "pureProtocolProcessorPlugin": "@finos/legend-pure-protocol-processor-plugin-dsl-data-quality"
+  }
+}

package/src/components/DSL_DataQuality_ClassElementDriver.tsx

@@ -0,0 +1,175 @@
+/**
+ * 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 EditorStore,
+  NewElementDriver,
+} from '@finos/legend-application-studio';
+import {
+  DataQualityClassValidationsConfiguration,
+  DataSpaceDataQualityExecutionContext,
+  MappingAndRuntimeDataQualityExecutionContext,
+} from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import { action, computed, makeObservable, observable } from 'mobx';
+import {
+  filterByType,
+  getNullableFirstEntry,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import {
+  type Mapping,
+  type PackageableRuntime,
+  getMappingCompatibleRuntimes,
+  PackageableElementExplicitReference,
+} from '@finos/legend-graph';
+import {
+  type PackageableElementOption,
+  buildElementOption,
+} from '@finos/legend-lego/graph-editor';
+import { DataSpace } from '@finos/legend-extension-dsl-data-space/graph';
+
+export type RuntimeOption = {
+  label: string;
+  value: PackageableRuntime | undefined;
+};
+
+export enum ELEMENT_CREATION_BASIS {
+  MAPPING_RUNTIME_BASED = 'Mapping/Runtime',
+  DATASPACE_BASED = 'DataSpace',
+}
+
+export class DataQuality_ClassElementDriver extends NewElementDriver<DataQualityClassValidationsConfiguration> {
+  dqElementCreationBasis: ELEMENT_CREATION_BASIS;
+  dataSpaceSelected: PackageableElementOption<DataSpace> | undefined;
+  mappingSelected: PackageableElementOption<Mapping> | undefined;
+  runtimeSelected: RuntimeOption | undefined;
+
+  constructor(editorStore: EditorStore) {
+    super(editorStore);
+
+    makeObservable(this, {
+      dataSpaceSelected: observable,
+      mappingSelected: observable,
+      runtimeSelected: observable,
+      dqElementCreationBasis: observable,
+      setDataSpaceSelected: action,
+      setMappingSelected: action,
+      setRuntimeSelected: action,
+      setDqElementCreationBasis: action,
+      runtimeOptions: computed,
+    });
+    this.dqElementCreationBasis = ELEMENT_CREATION_BASIS.DATASPACE_BASED;
+    this.dataSpaceSelected = getNullableFirstEntry(this.dataSpaceOptions);
+    this.mappingSelected = getNullableFirstEntry(this.mappingOptions);
+    this.runtimeSelected = getNullableFirstEntry(this.runtimeOptions);
+  }
+
+  get dataSpaceOptions(): PackageableElementOption<DataSpace>[] {
+    return this.editorStore.graphManagerState.graph.allOwnElements
+      .filter(filterByType(DataSpace))
+      .map(buildElementOption);
+  }
+
+  get mappingOptions(): PackageableElementOption<Mapping>[] {
+    return this.editorStore.graphManagerState.usableMappings.map(
+      buildElementOption,
+    );
+  }
+
+  get compatibleMappingRuntimes(): PackageableRuntime[] {
+    return this.mappingSelected?.value
+      ? getMappingCompatibleRuntimes(
+          this.mappingSelected.value,
+          this.editorStore.graphManagerState.usableRuntimes,
+        )
+      : [];
+  }
+
+  get runtimeOptions(): RuntimeOption[] {
+    return this.compatibleMappingRuntimes.map((runtime) =>
+      buildElementOption(runtime),
+    );
+  }
+
+  setDataSpaceSelected(
+    dataSpace: PackageableElementOption<DataSpace> | undefined,
+  ): void {
+    this.dataSpaceSelected = dataSpace;
+  }
+
+  setMappingSelected(
+    mappingSelected: PackageableElementOption<Mapping> | undefined,
+  ): void {
+    this.mappingSelected = mappingSelected;
+  }
+
+  setRuntimeSelected(runtimeSelected: RuntimeOption | undefined): void {
+    this.runtimeSelected = runtimeSelected;
+  }
+
+  setDqElementCreationBasis(
+    dqElementCreationBasis: ELEMENT_CREATION_BASIS,
+  ): void {
+    this.dqElementCreationBasis = dqElementCreationBasis;
+  }
+
+  get isValid(): boolean {
+    if (
+      this.dqElementCreationBasis === ELEMENT_CREATION_BASIS.DATASPACE_BASED
+    ) {
+      return Boolean(this.dataSpaceSelected);
+    }
+    return Boolean(this.mappingSelected && this.runtimeSelected);
+  }
+
+  createElement(name: string): DataQualityClassValidationsConfiguration {
+    const dataQualityConstraintsConfiguration =
+      new DataQualityClassValidationsConfiguration(name);
+    if (
+      this.dqElementCreationBasis === ELEMENT_CREATION_BASIS.DATASPACE_BASED
+    ) {
+      const dataSpaceToSet = PackageableElementExplicitReference.create(
+        this.dataSpaceSelected!.value,
+      );
+      const dataSpaceExecutionContext =
+        new DataSpaceDataQualityExecutionContext();
+      dataSpaceExecutionContext.context =
+        dataSpaceToSet.value.defaultExecutionContext.name;
+      dataSpaceExecutionContext.dataSpace = dataSpaceToSet;
+      dataQualityConstraintsConfiguration.context = dataSpaceExecutionContext;
+      dataQualityConstraintsConfiguration.dataQualityRootGraphFetchTree =
+        undefined;
+    } else {
+      if (this.mappingSelected && this.runtimeSelected) {
+        const mappingOption = guaranteeNonNullable(this.mappingSelected);
+        const _mapping = mappingOption.value;
+        const mapping = PackageableElementExplicitReference.create(_mapping);
+        const runtimeOption = guaranteeNonNullable(this.runtimeSelected.value);
+        const runtimeValue =
+          PackageableElementExplicitReference.create(runtimeOption);
+        const mappingAndRuntimeExecutionContext =
+          new MappingAndRuntimeDataQualityExecutionContext();
+        mappingAndRuntimeExecutionContext.mapping = mapping;
+        mappingAndRuntimeExecutionContext.runtime = runtimeValue;
+        dataQualityConstraintsConfiguration.context =
+          mappingAndRuntimeExecutionContext;
+      }
+      dataQualityConstraintsConfiguration.dataQualityRootGraphFetchTree =
+        undefined;
+    }
+    return dataQualityConstraintsConfiguration;
+  }
+}

package/src/components/DSL_DataQuality_LegendStudioApplicationPlugin.tsx

@@ -0,0 +1,220 @@
+/**
+ * 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 DSL_LegendStudioApplicationPlugin_Extension,
+  type ElementClassifier,
+  type ElementEditorRenderer,
+  type ElementEditorStateCreator,
+  type ElementIconGetter,
+  type ElementTypeLabelGetter,
+  type NewElementDriverCreator,
+  type NewElementDriverEditorRenderer,
+  type NewElementFromStateCreator,
+  type ElementEditorState,
+  type NewElementDriver,
+  type EditorStore,
+  type NewElementState,
+  LegendStudioApplicationPlugin,
+  PACKAGEABLE_ELEMENT_GROUP_BY_CATEGORY,
+} from '@finos/legend-application-studio';
+import type { PackageableElement } from '@finos/legend-graph';
+import {
+  DataQualityClassValidationsConfiguration,
+  DataQualityServiceValidationConfiguration,
+} from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import { EyeIcon } from '@finos/legend-art';
+import { DataQualityClassValidationEditor } from './DataQualityClassValidationEditor.js';
+import { DataQuality_ClassElementDriver } from './DSL_DataQuality_ClassElementDriver.js';
+import { NewDataQualityServiceValidationElementEditor } from './DSL_NewDataQualityServiceValidationElement.js';
+import { DataQuality_ServiceElementDriver } from './DSL_DataQuality_ServiceElementDriver.js';
+import { DataQualityServiceValidationEditor } from './DataQualityServiceValidationEditor.js';
+import { DataQualityClassValidationState } from './states/DataQualityClassValidationState.js';
+import { NewDataQualityClassValidationElementEditor } from './DSL_NewDataQualityClassValidationElement.js';
+import { type ReactNode } from 'react';
+import { DataQualityServiceValidationState } from './states/DataQualityServiceValidationState.js';
+
+const DATA_QUALITY_ELEMENT_TYPE = 'DATAQUALITY';
+const DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE =
+  'DATAQUALITYSERVICEVALIDATION';
+
+const DATA_QUALITY_ELEMENT_TYPE_LABEL = 'Data Quality Class Validation';
+const DATA_QUALITY_SERVICE_VALIDATION_TYPE_LABEL =
+  'Data Quality Service Validation';
+
+export class DSL_DataQuality_LegendStudioApplicationPlugin
+  extends LegendStudioApplicationPlugin
+  implements DSL_LegendStudioApplicationPlugin_Extension
+{
+  constructor() {
+    super(packageJson.extensions.applicationStudioPlugin, packageJson.version);
+  }
+
+  getExtraSupportedElementTypes(): string[] {
+    return [
+      DATA_QUALITY_ELEMENT_TYPE,
+      DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE,
+    ];
+  }
+
+  getExtraSupportedElementTypesWithCategory(): Map<string, string[]> {
+    const elementTypeswithCategory = new Map<string, string[]>();
+    elementTypeswithCategory.set(PACKAGEABLE_ELEMENT_GROUP_BY_CATEGORY.OTHER, [
+      DATA_QUALITY_ELEMENT_TYPE,
+      // DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE,
+    ]);
+    return elementTypeswithCategory;
+  }
+
+  getExtraElementClassifiers(): ElementClassifier[] {
+    return [
+      (element: PackageableElement): string | undefined => {
+        if (element instanceof DataQualityClassValidationsConfiguration) {
+          return DATA_QUALITY_ELEMENT_TYPE;
+        }
+        if (element instanceof DataQualityServiceValidationConfiguration) {
+          return DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  getExtraElementIconGetters(): ElementIconGetter[] {
+    return [
+      (type: string): React.ReactNode | undefined => {
+        if (type === DATA_QUALITY_ELEMENT_TYPE) {
+          return (
+            <div className="icon icon--dataQuality">
+              <EyeIcon />
+            </div>
+          );
+        }
+        if (type === DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE) {
+          return (
+            <div className="icon icon--dataQuality">
+              <EyeIcon />
+            </div>
+          );
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  getExtraElementTypeLabelGetters(): ElementTypeLabelGetter[] {
+    return [
+      (type: string): string | undefined => {
+        if (type === DATA_QUALITY_ELEMENT_TYPE) {
+          return DATA_QUALITY_ELEMENT_TYPE_LABEL;
+        }
+        if (type === DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE) {
+          return DATA_QUALITY_SERVICE_VALIDATION_TYPE_LABEL;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  getExtraNewElementFromStateCreators(): NewElementFromStateCreator[] {
+    return [
+      (
+        type: string,
+        name: string,
+        state: NewElementState,
+      ): PackageableElement | undefined => {
+        if (type === DATA_QUALITY_ELEMENT_TYPE) {
+          return state
+            .getNewElementDriver(DataQuality_ClassElementDriver)
+            .createElement(name);
+        }
+        if (type === DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE) {
+          return state
+            .getNewElementDriver(DataQuality_ServiceElementDriver)
+            .createElement(name);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  getExtraElementEditorRenderers(): ElementEditorRenderer[] {
+    return [
+      (elementEditorState: ElementEditorState): React.ReactNode | undefined => {
+        if (elementEditorState instanceof DataQualityServiceValidationState) {
+          return (
+            <DataQualityServiceValidationEditor key={elementEditorState.uuid} />
+          );
+        }
+        if (elementEditorState instanceof DataQualityClassValidationState) {
+          return (
+            <DataQualityClassValidationEditor key={elementEditorState.uuid} />
+          );
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  getExtraElementEditorStateCreators(): ElementEditorStateCreator[] {
+    return [
+      (
+        editorStore: EditorStore,
+        element: PackageableElement,
+      ): ElementEditorState | undefined => {
+        if (element instanceof DataQualityClassValidationsConfiguration) {
+          return new DataQualityClassValidationState(editorStore, element);
+        }
+        if (element instanceof DataQualityServiceValidationConfiguration) {
+          return new DataQualityServiceValidationState(editorStore, element);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  getExtraNewElementDriverEditorRenderers(): NewElementDriverEditorRenderer[] {
+    return [
+      (type: string): ReactNode | undefined => {
+        if (type === DATA_QUALITY_ELEMENT_TYPE) {
+          return <NewDataQualityClassValidationElementEditor />;
+        }
+        if (type === DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE) {
+          return <NewDataQualityServiceValidationElementEditor />;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  getExtraNewElementDriverCreators(): NewElementDriverCreator[] {
+    return [
+      (
+        editorStore: EditorStore,
+        type: string,
+      ): NewElementDriver<PackageableElement> | undefined => {
+        if (type === DATA_QUALITY_ELEMENT_TYPE) {
+          return new DataQuality_ClassElementDriver(editorStore);
+        }
+        if (type === DATA_QUALITY_SERVICE_VALIDATION_ELEMENT_TYPE) {
+          return new DataQuality_ServiceElementDriver(editorStore);
+        }
+        return undefined;
+      },
+    ];
+  }
+}

package/src/components/DSL_DataQuality_LegendStudioPlugin_Extension.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { DataQualityState } from './states/DataQualityState.js';
+import type {
+  EditorExtensionState,
+  EditorStore,
+  ElementEditorState,
+  LegendStudioApplicationPlugin,
+} from '@finos/legend-application-studio';
+
+export type ExtensionStateBuilder = (
+  editorStore: EditorStore,
+  dataQualityState: DataQualityState,
+) => EditorExtensionState | undefined;
+
+export type ComponentRenderer = (
+  tabName: string,
+  elementEditorState: ElementEditorState,
+) => React.ReactNode | undefined;
+
+export interface DSL_DataQuality_LegendStudioPlugin_Extension
+  extends LegendStudioApplicationPlugin {
+  getExtensionStates?(): ExtensionStateBuilder[];
+  getComponentRenderers?(): ComponentRenderer[];
+  getAllTabs?(): (() => string[])[];
+}

package/src/components/DSL_DataQuality_ServiceElementDriver.tsx

@@ -0,0 +1,57 @@
+/**
+ * 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 EditorStore,
+  NewElementDriver,
+} from '@finos/legend-application-studio';
+import { DataQualityServiceValidationConfiguration } from '../graph/metamodel/pure/packageableElements/data-quality/DataQualityValidationConfiguration.js';
+import { action, makeObservable, observable } from 'mobx';
+import type { Service } from '@finos/legend-graph';
+import {
+  type PackageableElementOption,
+  buildElementOption,
+} from '@finos/legend-lego/graph-editor';
+
+export class DataQuality_ServiceElementDriver extends NewElementDriver<DataQualityServiceValidationConfiguration> {
+  serviceSelected: PackageableElementOption<Service> | undefined;
+
+  constructor(editorStore: EditorStore) {
+    super(editorStore);
+
+    makeObservable(this, {
+      serviceSelected: observable,
+      setServiceSelected: action,
+    });
+
+    this.serviceSelected =
+      editorStore.graphManagerState.usableServices.map(buildElementOption)[0];
+  }
+
+  setServiceSelected(
+    serviceSelected: PackageableElementOption<Service> | undefined,
+  ): void {
+    this.serviceSelected = serviceSelected;
+  }
+
+  get isValid(): boolean {
+    return Boolean(this.serviceSelected);
+  }
+
+  createElement(name: string): DataQualityServiceValidationConfiguration {
+    return new DataQualityServiceValidationConfiguration(name);
+  }
+}