@finos/legend-application-studio 15.1.0 → 15.2.0

package/src/index.ts

@@ -68,9 +68,13 @@ export {
 export * from './components/LegendStudioTestID.js';
 export * from './stores/EditorStoreTestUtils.js';
 
+export { PostProcessorEditorState } from './stores/editor-state/element-editor-state/connection/PostProcessorEditorState.js';
 export { MappingExecutionState } from './stores/editor-state/element-editor-state/mapping/MappingExecutionState.js';
 export { MappingTestState } from './stores/editor-state/element-editor-state/mapping/MappingTestState.js';
-export { ConnectionValueState } from './stores/editor-state/element-editor-state/connection/ConnectionEditorState.js';
+export {
+  ConnectionValueState,
+  RelationalDatabaseConnectionValueState,
+} from './stores/editor-state/element-editor-state/connection/ConnectionEditorState.js';
 export * from './stores/editor-state/element-editor-state/mapping/MappingEditorState.js';
 export { MappingElementState } from './stores/editor-state/element-editor-state/mapping/MappingElementState.js';
 export { UnsupportedInstanceSetImplementationState } from './stores/editor-state/element-editor-state/mapping/UnsupportedInstanceSetImplementationState.js';
@@ -89,7 +93,7 @@ export { WorkspaceSetupStore } from './stores/workspace-setup/WorkspaceSetupStor
  */
 
 export {
-  ConnectionEditor_StringEditor,
+  ConnectionEditor_TextEditor,
   ConnectionEditor_BooleanEditor,
   ConnectionEditor_ArrayEditor,
 } from './components/editor/edit-panel/connection-editor/RelationalDatabaseConnectionEditor.js';

package/src/stores/EditorStore.ts

@@ -95,7 +95,6 @@ import {
 } from '@finos/legend-server-sdlc';
 import {
   type PackageableElement,
-  type Type,
   type Store,
   type GraphManagerState,
   GRAPH_MANAGER_EVENT,
@@ -114,7 +113,6 @@ import {
   PackageableConnection,
   FileGenerationSpecification,
   GenerationSpecification,
-  PRIMITIVE_TYPE,
   Package,
   DataElement,
   isElementReadOnly,
@@ -1344,89 +1342,12 @@ export class EditorStore {
     }
   }
 
-  get enumerationOptions(): PackageableElementOption<Enumeration>[] {
-    return this.graphManagerState.graph.ownEnumerations
-      .concat(this.graphManagerState.graph.dependencyManager.enumerations)
-      .map(buildElementOption);
-  }
-
-  get classOptions(): PackageableElementOption<Class>[] {
-    return this.graphManagerState.graph.ownClasses
-      .concat(
-        this.graphManagerState.collectExposedSystemElements(
-          this.graphManagerState.graph.systemModel.ownClasses,
-        ),
-      )
-      .concat(this.graphManagerState.graph.dependencyManager.classes)
-      .map(buildElementOption);
-  }
-
-  get associationOptions(): PackageableElementOption<Association>[] {
-    return this.graphManagerState.graph.ownAssociations
-      .concat(
-        this.graphManagerState.collectExposedSystemElements(
-          this.graphManagerState.graph.systemModel.ownAssociations,
-        ),
-      )
-      .concat(this.graphManagerState.graph.dependencyManager.associations)
-      .map(buildElementOption);
-  }
-
-  get profileOptions(): PackageableElementOption<Profile>[] {
-    return this.graphManagerState.graph.ownProfiles
-      .concat(
-        this.graphManagerState.collectExposedSystemElements(
-          this.graphManagerState.graph.systemModel.ownProfiles,
-        ),
-      )
-      .concat(this.graphManagerState.graph.dependencyManager.profiles)
-      .map(buildElementOption);
-  }
-
-  get classPropertyGenericTypeOptions(): PackageableElementOption<Type>[] {
-    return this.graphManagerState.graph.primitiveTypes
-      .filter((p) => p.path !== PRIMITIVE_TYPE.LATESTDATE)
-      .map(buildElementOption)
-      .concat(
-        this.graphManagerState.graph.ownTypes
-          .concat(
-            this.graphManagerState.collectExposedSystemElements(
-              this.graphManagerState.graph.systemModel.ownTypes,
-            ),
-          )
-          .concat(this.graphManagerState.graph.dependencyManager.types)
-          .map(buildElementOption),
-      );
-  }
-
-  get mappingOptions(): PackageableElementOption<Mapping>[] {
-    return this.graphManagerState.graph.ownMappings
-      .concat(this.graphManagerState.graph.dependencyManager.mappings)
-      .map(buildElementOption);
-  }
-
-  get runtimeOptions(): PackageableElementOption<PackageableRuntime>[] {
-    return this.graphManagerState.graph.ownRuntimes
-      .concat(this.graphManagerState.graph.dependencyManager.runtimes)
-      .map(buildElementOption);
-  }
-
-  get serviceOptions(): PackageableElementOption<Service>[] {
-    return this.graphManagerState.graph.ownServices
-      .concat(this.graphManagerState.graph.dependencyManager.services)
-      .map(buildElementOption);
-  }
-
   get storeOptions(): PackageableElementOption<Store>[] {
-    return this.graphManagerState.graph.ownStores
-      .concat(this.graphManagerState.graph.dependencyManager.stores)
-      .map(buildElementOption);
+    return this.graphManagerState.usableStores.map(buildElementOption);
   }
 
   get dataOptions(): PackageableElementOption<DataElement>[] {
-    return this.graphManagerState.graph.ownDataElements
-      .concat(this.graphManagerState.graph.dependencyManager.dataElements)
-      .map(buildElementOption);
+    return this.graphManagerState.usableDataElements.map(buildElementOption);
   }
 
   getSupportedElementTypes(): string[] {

package/src/stores/StoreRelational_LegendStudioApplicationPlugin_Extension.ts

@@ -18,7 +18,11 @@ import type { DSL_LegendStudioApplicationPlugin_Extension } from './LegendStudio
 import type {
   DatasourceSpecification,
   AuthenticationStrategy,
+  PostProcessor,
+  ObserverContext,
 } from '@finos/legend-graph';
+import type { RelationalDatabaseConnectionValueState } from './editor-state/element-editor-state/connection/ConnectionEditorState.js';
+import type { PostProcessorEditorState } from './editor-state/element-editor-state/connection/PostProcessorEditorState.js';
 
 // connection datasource specification
 
@@ -50,6 +54,29 @@ export type AuthenticationStrategyEditorRenderer = (
   isReadOnly: boolean,
 ) => React.ReactNode | undefined;
 
+// connection post-processor
+
+export type PostProcessorTypeGetter = (
+  metamodel: PostProcessor,
+) => string | undefined;
+
+export type PostProcessorCreator = (
+  type: string,
+  connectionValueState: RelationalDatabaseConnectionValueState,
+  observerContext: ObserverContext,
+) => PostProcessor | undefined;
+
+export type PostProcessorEditorRenderer = (
+  metamodel: PostProcessor,
+  connectionValueState: RelationalDatabaseConnectionValueState,
+  isReadOnly: boolean,
+) => React.ReactNode | undefined;
+
+export type PostProcessorStateCreator = (
+  metamodel: PostProcessor,
+  connectionValueState: RelationalDatabaseConnectionValueState,
+) => PostProcessorEditorState | undefined;
+
 export interface StoreRelational_LegendStudioApplicationPlugin_Extension
   extends DSL_LegendStudioApplicationPlugin_Extension {
   // --------------------- relational database connection datasource specification ------------------
@@ -97,4 +124,32 @@ export interface StoreRelational_LegendStudioApplicationPlugin_Extension
    * Get the list of renderers for the editor for a relational database authentication strategy.
    */
   getExtraAuthenticationStrategyEditorRenderers?(): AuthenticationStrategyEditorRenderer[];
+
+  // --------------------- relational database connection post-processor ------------------
+
+  /**
+   * Get the list of the supported type for post-processors.
+   *
+   */
+  getExtraPostProcessorClassifiers?(): string[];
+
+  /**
+   * Get the list of classifiers for a post-processor.
+   */
+  getExtraPostProcessorClassifierGetters?(): PostProcessorTypeGetter[];
+
+  /**
+   * Get the list of creators for post-processor given the type specifier.
+   */
+  getExtraPostProcessorCreators?(): PostProcessorCreator[];
+
+  /**
+   * Get the list of state creators for a post-processor.
+   */
+  getExtraPostProcessorStateCreators?(): PostProcessorStateCreator[];
+
+  /**
+   * Get the list of renderers for the editor for a post-processor.
+   */
+  getExtraPostProcessorEditorRenderers?(): PostProcessorEditorRenderer[];
 }

package/src/stores/editor/NewElementState.ts

@@ -92,7 +92,10 @@ import {
 import type { EmbeddedDataTypeOption } from '../editor-state/element-editor-state/data/DataEditorState.js';
 import { dataElement_setEmbeddedData } from '../graphModifier/DSLData_GraphModifierHelper.js';
 import { PACKAGEABLE_ELEMENT_TYPE } from '../shared/ModelUtil.js';
-import type { PackageableElementOption } from '@finos/legend-application';
+import {
+  buildElementOption,
+  type PackageableElementOption,
+} from '@finos/legend-application';
 import { EmbeddedDataType } from '../editor-state/ExternalFormatState.js';
 import { createEmbeddedData } from '../editor-state/element-editor-state/data/EmbeddedDataState.js';
 
@@ -302,7 +305,7 @@ export class NewRelationalDatabaseConnectionDriver extends NewConnectionValueDri
     if (store instanceof Database) {
       selectedStore = store;
     } else {
-      const dbs = this.editorStore.graphManagerState.graph.databases;
+      const dbs = this.editorStore.graphManagerState.usableDatabases;
       selectedStore = dbs.length ? (dbs[0] as Database) : stub_Database();
     }
     return new RelationalDatabaseConnection(
@@ -431,7 +434,8 @@ export class NewServiceDriver extends NewElementDriver<Service> {
       isValid: computed,
       createElement: action,
     });
-    this.mappingOption = editorStore.mappingOptions[0];
+    this.mappingOption =
+      editorStore.graphManagerState.usableMappings.map(buildElementOption)[0];
   }
 
   setMappingOption(val: PackageableElementOption<Mapping> | undefined): void {
@@ -447,10 +451,7 @@ export class NewServiceDriver extends NewElementDriver<Service> {
     const _mapping = mappingOption.value;
     const mapping = PackageableElementExplicitReference.create(_mapping);
     const service = new Service(name);
-    const runtimes =
-      this.editorStore.graphManagerState.graph.ownRuntimes.concat(
-        this.editorStore.graphManagerState.graph.dependencyManager.runtimes,
-      );
+    const runtimes = this.editorStore.graphManagerState.usableRuntimes;
     const compatibleRuntimes = runtimes.filter((runtime) =>
       runtime.runtimeValue.mappings.map((m) => m.value).includes(_mapping),
     );

package/src/stores/editor-state/ModelImporterState.ts

@@ -499,16 +499,20 @@ export class ModelImporterState extends EditorState {
   setModelImporterExtension(
     extension: ModelImporterExtensionConfiguration,
   ): ExtensionModelImporterEditorState {
-    const externalEditorState =
-      this.modelImportEditorState instanceof ExtensionModelImporterEditorState
-        ? this.modelImportEditorState
-        : new ExtensionModelImporterEditorState(
-            extension,
-            extension.getExtensionModelImportRendererStateCreator(this),
-            this,
-          );
-    externalEditorState.setExtension(extension);
-    this.setImportEditorState(externalEditorState);
-    return externalEditorState;
+    if (
+      this.modelImportEditorState instanceof
+        ExtensionModelImporterEditorState &&
+      this.modelImportEditorState.config === extension
+    ) {
+      return this.modelImportEditorState;
+    } else {
+      const modelImporterEditorState = new ExtensionModelImporterEditorState(
+        extension,
+        extension.getExtensionModelImportRendererStateCreator(this),
+        this,
+      );
+      this.setImportEditorState(modelImporterEditorState);
+      return modelImporterEditorState;
+    }
   }
 }

package/src/stores/editor-state/element-editor-state/connection/ConnectionEditorState.ts

@@ -52,12 +52,18 @@ import {
   RedshiftDatasourceSpecification,
   createValidationError,
   isStubbed_PackageableElement,
+  type PostProcessor,
+  MapperPostProcessor,
 } from '@finos/legend-graph';
 import type { DSLMapping_LegendStudioApplicationPlugin_Extension } from '../../../DSLMapping_LegendStudioApplicationPlugin_Extension.js';
 import {
   relationDbConnection_setNewAuthenticationStrategy,
   relationDbConnection_setDatasourceSpecification,
 } from '../../../graphModifier/StoreRelational_GraphModifierHelper.js';
+import {
+  MapperPostProcessorEditorState,
+  type PostProcessorEditorState,
+} from './PostProcessorEditorState.js';
 
 export abstract class ConnectionValueState {
   editorStore: EditorStore;
@@ -74,6 +80,7 @@ export abstract class ConnectionValueState {
 export enum RELATIONAL_DATABASE_TAB_TYPE {
   GENERAL = 'GENERAL',
   STORE = 'STORE',
+  POST_PROCESSORS = 'POST-PROCESSORS',
 }
 
 export enum CORE_DATASOURCE_SPEC_TYPE {
@@ -86,6 +93,10 @@ export enum CORE_DATASOURCE_SPEC_TYPE {
   BIGQUERY = 'BIGQUERY',
 }
 
+export enum POST_PROCESSOR_TYPE {
+  MAPPER = 'MAPPER',
+}
+
 export enum CORE_AUTHENTICATION_STRATEGY_TYPE {
   DELEGATED_KERBEROS = 'DELEGATED_KERBEROS',
   H2_DEFAULT = 'H2_DEFAULT',
@@ -102,6 +113,7 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
   override connection: RelationalDatabaseConnection;
   selectedTab = RELATIONAL_DATABASE_TAB_TYPE.GENERAL;
   databaseBuilderState: DatabaseBuilderState;
+  postProcessorState: PostProcessorEditorState | undefined;
 
   constructor(
     editorStore: EditorStore,
@@ -109,17 +121,50 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
   ) {
     super(editorStore, connection);
     makeObservable(this, {
-      setSelectedTab: action,
       databaseBuilderState: observable,
       selectedTab: observable,
+      postProcessorState: observable,
+      setSelectedTab: action,
+      selectPostProcessor: action,
     });
+
     this.connection = connection;
+
     this.databaseBuilderState = new DatabaseBuilderState(
       editorStore,
       connection,
     );
   }
 
+  selectPostProcessor = (postProcessor: PostProcessor | undefined): void => {
+    if (!this.postProcessorState && postProcessor) {
+      if (postProcessor instanceof MapperPostProcessor) {
+        this.postProcessorState = new MapperPostProcessorEditorState(
+          postProcessor,
+          this,
+        );
+      } else {
+        const extraPostProcessorStateCreators = this.editorStore.pluginManager
+          .getApplicationPlugins()
+          .flatMap(
+            (plugin) =>
+              (
+                plugin as StoreRelational_LegendStudioApplicationPlugin_Extension
+              ).getExtraPostProcessorStateCreators?.() ?? [],
+          );
+        for (const creator of extraPostProcessorStateCreators) {
+          const postProcessorState = creator(postProcessor, this);
+          if (postProcessorState) {
+            this.postProcessorState = postProcessorState;
+          }
+        }
+      }
+    }
+    if (this.postProcessorState) {
+      this.postProcessorState.setPostProcessorState(postProcessor);
+    }
+  };
+
   get storeValidationResult(): ValidationIssue | undefined {
     return isStubbed_PackageableElement(this.connection.store.value)
       ? createValidationError(['Connection database cannot be empty'])
@@ -480,6 +525,7 @@ export class PackageableConnectionEditorState extends ElementEditorState {
       editorStore,
       newElement,
     );
+
     return editorState;
   }
 }

package/src/stores/editor-state/element-editor-state/connection/PostProcessorEditorState.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 {
+  PostProcessor,
+  Mapper,
+  MapperPostProcessor,
+} from '@finos/legend-graph';
+import { makeObservable, observable, action } from 'mobx';
+import type { RelationalDatabaseConnectionValueState } from './ConnectionEditorState.js';
+
+export abstract class PostProcessorEditorState {
+  postProcessor: PostProcessor | undefined;
+  connectionValueState: RelationalDatabaseConnectionValueState;
+
+  constructor(
+    postProcessor: PostProcessor | undefined,
+    connectionValueState: RelationalDatabaseConnectionValueState,
+  ) {
+    makeObservable(this, {
+      postProcessor: observable,
+      connectionValueState: observable,
+    });
+
+    this.postProcessor = postProcessor;
+    this.connectionValueState = connectionValueState;
+  }
+
+  abstract setPostProcessorState(val: PostProcessor | undefined): void;
+}
+
+export class MapperPostProcessorEditorState extends PostProcessorEditorState {
+  selectedMapper: Mapper | undefined;
+
+  constructor(
+    postProcessor: MapperPostProcessor | undefined,
+    connectionValueState: RelationalDatabaseConnectionValueState,
+  ) {
+    super(postProcessor, connectionValueState);
+
+    makeObservable(this, {
+      selectedMapper: observable,
+      setSelectedMapper: action,
+      setPostProcessorState: action,
+    });
+
+    this.postProcessor = postProcessor;
+    this.connectionValueState = connectionValueState;
+  }
+
+  setPostProcessorState = (val: PostProcessor | undefined): void => {
+    this.postProcessor = val;
+
+    this.setSelectedMapper(undefined);
+  };
+
+  setSelectedMapper = (val: Mapper | undefined): void => {
+    this.selectedMapper = val;
+  };
+}

package/src/stores/editor-state/element-editor-state/service/ServiceExecutionState.ts

@@ -904,7 +904,7 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
 
   addExecutionParameter(value: string): void {
     const _mapping =
-      this.editorStore.mappingOptions[0]?.value ?? stub_Mapping();
+      this.editorStore.graphManagerState.usableMappings[0] ?? stub_Mapping();
     const _key = new KeyedExecutionParameter(
       value,
       PackageableElementExplicitReference.create(_mapping),

package/src/stores/editor-state/element-editor-state/service/testable/ServiceTestDataState.ts

@@ -206,13 +206,17 @@ export class ConnectionTestDataState {
 }
 
 export class NewConnectionDataState {
+  readonly editorStore: EditorStore;
   readonly testSuiteState: ServiceTestDataState;
   showModal = false;
   connection: IdentifiedConnection | undefined;
   embeddedDataType: EmbeddedDataTypeOption | undefined;
   dataElement: DataElement | undefined;
 
-  constructor(suite: ServiceTestDataState) {
+  constructor(
+    editorStore: EditorStore,
+    serviceTestDataState: ServiceTestDataState,
+  ) {
     makeObservable(this, {
       showModal: observable,
       connection: observable,
@@ -224,8 +228,10 @@ export class NewConnectionDataState {
       handleConnectionChange: action,
       setDataElement: action,
     });
-    this.testSuiteState = suite;
-    this.dataElement = this.testSuiteState.editorStore.dataOptions[0]?.value;
+
+    this.editorStore = editorStore;
+    this.testSuiteState = serviceTestDataState;
+    this.dataElement = editorStore.graphManagerState.usableDataElements[0];
   }
 
   setModal(val: boolean): void {
@@ -303,6 +309,7 @@ export class ServiceTestDataState {
       newConnectionDataState: observable,
       selectedDataState: observable,
     });
+
     this.testData = testData;
     this.testSuiteState = testSuiteState;
     this.editorStore = testSuiteState.editorStore;
@@ -315,7 +322,10 @@ export class ServiceTestDataState {
         connectionData,
       );
     }
-    this.newConnectionDataState = new NewConnectionDataState(this);
+    this.newConnectionDataState = new NewConnectionDataState(
+      this.editorStore,
+      this,
+    );
   }
 
   createConnectionTestData(): void {

package/src/stores/graphModifier/StoreRelational_GraphModifierHelper.ts

@@ -42,6 +42,8 @@ import {
   type ObserverContext,
   type EnumerationMappingReference,
   type TableAlias,
+  type Mapper,
+  type PostProcessor,
   getRelationalInputType,
   observe_DatasourceSpecification,
   observe_AuthenticationStrategy,
@@ -49,8 +51,14 @@ import {
   observe_PropertyMapping,
   observe_EnumerationMappingReference,
   observe_TableAlias,
+  type SchemaNameMapper,
+  type MapperPostProcessor,
+  observe_PostProcessor,
+  observe_Mapper,
 } from '@finos/legend-graph';
+import { addUniqueEntry, deleteEntry } from '@finos/legend-shared';
 import { action } from 'mobx';
+import type { RelationalDatabaseConnectionValueState } from '../editor-state/element-editor-state/connection/ConnectionEditorState.js';
 
 // --------------------------------------------- DB Connection -------------------------------------
 
@@ -421,3 +429,59 @@ export const rootRelationalSetImp_setPropertyMappings = action(
     );
   },
 );
+
+// --------------------------------------------- Post-Processor -------------------------------------
+
+export const relationalDatabaseConnection_addPostProcessor = action(
+  (
+    connectionValueState: RelationalDatabaseConnectionValueState,
+    postProcessor: PostProcessor,
+    observerContext: ObserverContext,
+  ): void => {
+    addUniqueEntry(
+      connectionValueState.connection.postProcessors,
+      observe_PostProcessor(postProcessor, observerContext),
+    );
+  },
+);
+
+export const relationalDatabaseConnection_deletePostProcessor = action(
+  (
+    connectionValueState: RelationalDatabaseConnectionValueState,
+    postProcessor: PostProcessor,
+  ): void => {
+    deleteEntry(connectionValueState.connection.postProcessors, postProcessor);
+  },
+);
+
+export const mapperPostProcessor_addMapper = action(
+  (mapperPostProcessor: MapperPostProcessor, mapper: Mapper): void => {
+    addUniqueEntry(mapperPostProcessor.mappers, observe_Mapper(mapper));
+  },
+);
+
+export const mapper_setFrom = action((mapper: Mapper, val: string): void => {
+  mapper.from = val;
+});
+
+export const mapper_setTo = action((mapper: Mapper, val: string): void => {
+  mapper.to = val;
+});
+
+export const schemaNameMapper_setTo = action(
+  (schemaNameMapper: SchemaNameMapper, val: string): void => {
+    schemaNameMapper.to = val;
+  },
+);
+
+export const schemaNameMapper_setFrom = action(
+  (schemaNameMapper: SchemaNameMapper, val: string): void => {
+    schemaNameMapper.from = val;
+  },
+);
+
+export const mapperPostProcessor_deleteMapper = action(
+  (mapperPostProcessor: MapperPostProcessor, val: Mapper): void => {
+    deleteEntry(mapperPostProcessor.mappers, val);
+  },
+);

package/src/stores/sidebar-state/testable/GlobalTestRunnerState.ts

@@ -46,7 +46,6 @@ import {
   filterByType,
 } from '@finos/legend-shared';
 import { action, flow, makeObservable, observable } from 'mobx';
-import { getElementTypeIcon } from '../../../components/shared/ElementIconUtils.js';
 import type { EditorSDLCState } from '../../EditorSDLCState.js';
 import type { EditorStore } from '../../EditorStore.js';
 import type {
@@ -56,10 +55,9 @@ import type {
 
 // Testable Metadata
 export interface TestableMetadata {
-  testable: Testable;
   id: string;
   name: string;
-  icon: React.ReactNode;
+  testable: Testable;
 }
 
 export const getTestableMetadata = (
@@ -69,7 +67,7 @@ export const getTestableMetadata = (
 ): TestableMetadata => {
   if (testable instanceof PackageableElement) {
     return {
-      testable: testable,
+      testable,
       id:
         getNullableIDFromTestable(
           testable,
@@ -77,10 +75,6 @@ export const getTestableMetadata = (
           editorStore.graphManagerState.pluginManager.getPureGraphManagerPlugins(),
         ) ?? uuid(),
       name: testable.name,
-      icon: getElementTypeIcon(
-        editorStore,
-        editorStore.graphState.getPackageableElementType(testable),
-      ),
     };
   }
   const extraTestables = extraTestableMetadataGetters
@@ -91,7 +85,6 @@ export const getTestableMetadata = (
       testable,
       id: uuid(),
       name: '(unknown)',
-      icon: null,
     }
   );
 };