@finos/legend-application-studio 22.6.0 → 23.0.1

package/src/stores/editor-state/element-editor-state/mapping/MappingEditorState.ts

@@ -1,1514 +0,0 @@
-/**
- * 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 {
-  observable,
-  action,
-  computed,
-  flow,
-  makeObservable,
-  flowResult,
-} from 'mobx';
-import type { EditorStore } from '../../../EditorStore.js';
-import {
-  InstanceSetImplementationState,
-  MappingElementState,
-} from './MappingElementState.js';
-import { PureInstanceSetImplementationState } from './PureInstanceSetImplementationState.js';
-import { ElementEditorState } from '../../../editor-state/element-editor-state/ElementEditorState.js';
-import {
-  MAPPING_TEST_EDITOR_TAB_TYPE,
-  MappingTestState,
-  TEST_RESULT,
-} from './MappingTestState.js';
-import { createMockDataForMappingElementSource } from '../../../shared/MockDataUtils.js';
-import {
-  type GeneratorFn,
-  assertErrorThrown,
-  LogEvent,
-  deleteEntry,
-  generateEnumerableNameFromToken,
-  IllegalStateError,
-  isNonNullable,
-  assertNonNullable,
-  guaranteeNonNullable,
-  guaranteeType,
-  UnsupportedOperationError,
-  assertTrue,
-  addUniqueEntry,
-  filterByType,
-} from '@finos/legend-shared';
-import { MappingExecutionState } from './MappingExecutionState.js';
-import { RootFlatDataInstanceSetImplementationState } from './FlatDataInstanceSetImplementationState.js';
-import type { TreeNodeData, TreeData } from '@finos/legend-art';
-import { UnsupportedInstanceSetImplementationState } from './UnsupportedInstanceSetImplementationState.js';
-import { RootRelationalInstanceSetImplementationState } from './relational/RelationalInstanceSetImplementationState.js';
-import {
-  type CompilationError,
-  type PackageableElement,
-  type InputData,
-  type Type,
-  type EmbeddedSetImplementation,
-  getAllClassMappings,
-  GRAPH_MANAGER_EVENT,
-  fromElementPathToMappingElementId,
-  extractSourceInformationCoordinates,
-  getAllEnumerationMappings,
-  Class,
-  Enumeration,
-  Mapping,
-  EnumerationMapping,
-  SetImplementation,
-  PureInstanceSetImplementation,
-  ExpectedOutputMappingTestAssert,
-  ObjectInputData,
-  ObjectInputType,
-  FlatDataInstanceSetImplementation,
-  InstanceSetImplementation,
-  EmbeddedFlatDataPropertyMapping,
-  FlatDataInputData,
-  RootFlatDataRecordType,
-  PackageableElementExplicitReference,
-  RootFlatDataRecordTypeExplicitReference,
-  RootRelationalInstanceSetImplementation,
-  EmbeddedRelationalInstanceSetImplementation,
-  AggregationAwareSetImplementation,
-  TableAlias,
-  RelationalInputData,
-  RelationalInputType,
-  OperationSetImplementation,
-  OperationType,
-  AssociationImplementation,
-  InferableMappingElementIdExplicitValue,
-  InferableMappingElementRootExplicitValue,
-  stub_Class,
-  findPropertyMapping,
-  DEPRECATED__MappingTest,
-  PrimitiveType,
-} from '@finos/legend-graph';
-import type {
-  DSL_Mapping_LegendStudioApplicationPlugin_Extension,
-  MappingElementLabel,
-} from '../../../DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
-import type { LegendStudioApplicationPlugin } from '../../../LegendStudioApplicationPlugin.js';
-import { flatData_setSourceRootRecordType } from '../../../shared/modifier/STO_FlatData_GraphModifierHelper.js';
-import {
-  pureInstanceSetImpl_setSrcClass,
-  mapping_addClassMapping,
-  mapping_addEnumerationMapping,
-  mapping_addTest,
-  mapping_deleteAssociationMapping,
-  mapping_deleteClassMapping,
-  mapping_deleteEnumerationMapping,
-  mapping_deleteTest,
-  setImpl_updateRootOnCreate,
-  setImpl_updateRootOnDelete,
-} from '../../../shared/modifier/DSL_Mapping_GraphModifierHelper.js';
-import { BASIC_SET_IMPLEMENTATION_TYPE } from '../../../shared/ModelClassifierUtils.js';
-import { rootRelationalSetImp_setMainTableAlias } from '../../../shared/modifier/STO_Relational_GraphModifierHelper.js';
-import { LambdaEditorState } from '@finos/legend-query-builder';
-import type { MappingEditorTabState } from './MappingTabManagerState.js';
-
-export interface MappingExplorerTreeNodeData extends TreeNodeData {
-  mappingElement: MappingElement;
-}
-
-export const generateMappingTestName = (mapping: Mapping): string => {
-  const generatedName = generateEnumerableNameFromToken(
-    mapping.test.map((t) => t.name),
-    'test',
-  );
-  assertTrue(
-    !mapping.test.find((t) => t.name === generatedName),
-    `Can't auto-generate test name for value '${generatedName}'`,
-  );
-  return generatedName;
-};
-
-export enum MAPPING_ELEMENT_SOURCE_ID_LABEL {
-  ENUMERATION_MAPPING = 'enumerationMapping',
-  OPERATION_CLASS_MAPPING = 'operationClassMapping',
-  PURE_INSTANCE_CLASS_MAPPING = 'pureInstanceClassMapping',
-  FLAT_DATA_CLASS_MAPPING = 'flatDataClassMapping',
-  RELATIONAL_CLASS_MAPPING = 'relationalClassMapping',
-  AGGREGATION_AWARE_CLASS_MAPPING = 'aggregationAwareClassMapping',
-}
-
-export enum MAPPING_ELEMENT_TYPE {
-  CLASS = 'CLASS',
-  ENUMERATION = 'ENUMERATION',
-  ASSOCIATION = 'ASSOCIATION',
-}
-
-export type MappingElement =
-  | EnumerationMapping
-  | SetImplementation
-  | AssociationImplementation;
-
-/**
- * Mapping element source could be just about anything, even `undefined`
- * We cannot really extend this type since it hinders modularity
- */
-export type MappingElementSource = unknown;
-
-export const getMappingElementTarget = (
-  mappingElement: MappingElement,
-): PackageableElement => {
-  if (mappingElement instanceof EnumerationMapping) {
-    return mappingElement.enumeration.value;
-  } else if (mappingElement instanceof AssociationImplementation) {
-    return mappingElement.association.value;
-  } else if (mappingElement instanceof EmbeddedFlatDataPropertyMapping) {
-    return mappingElement.class.value;
-  } else if (
-    mappingElement instanceof EmbeddedRelationalInstanceSetImplementation
-  ) {
-    return mappingElement.class.value;
-  } else if (mappingElement instanceof SetImplementation) {
-    return mappingElement.class.value;
-  }
-  throw new UnsupportedOperationError(
-    `Can't derive target of mapping element`,
-    mappingElement,
-  );
-};
-
-export const getMappingElementLabel = (
-  mappingElement: MappingElement,
-  editorStore: EditorStore,
-): MappingElementLabel => {
-  if (mappingElement instanceof EnumerationMapping) {
-    return {
-      value: `${
-        fromElementPathToMappingElementId(
-          mappingElement.enumeration.value.path,
-        ) === mappingElement.id.value
-          ? mappingElement.enumeration.value.name
-          : `${mappingElement.enumeration.value.name} [${mappingElement.id.value}]`
-      }`,
-      root: false,
-      tooltip: mappingElement.enumeration.value.path,
-    };
-  } else if (mappingElement instanceof AssociationImplementation) {
-    return {
-      value: `${
-        fromElementPathToMappingElementId(
-          mappingElement.association.value.path,
-        ) === mappingElement.id.value
-          ? mappingElement.association.value.name
-          : `${mappingElement.association.value.name} [${mappingElement.id.value}]`
-      }`,
-      root: false,
-      tooltip: mappingElement.association.value.path,
-    };
-  } else if (mappingElement instanceof SetImplementation) {
-    if (mappingElement instanceof EmbeddedFlatDataPropertyMapping) {
-      return {
-        value: `${mappingElement.class.value.name} [${mappingElement.property.value.name}]`,
-        root: mappingElement.root.value,
-        tooltip: mappingElement.class.value.path,
-      };
-    }
-    const extraSetImplementationMappingElementLabelInfoBuilders =
-      editorStore.pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
-            ).getExtraSetImplementationMappingElementLabelInfoBuilders?.() ??
-            [],
-        );
-    for (const labelInfoBuilder of extraSetImplementationMappingElementLabelInfoBuilders) {
-      const labelInfo = labelInfoBuilder(mappingElement);
-      if (labelInfo) {
-        return labelInfo;
-      }
-    }
-    return {
-      value: `${
-        fromElementPathToMappingElementId(mappingElement.class.value.path) ===
-        mappingElement.id.value
-          ? mappingElement.root.value
-            ? mappingElement.class.value.name
-            : `${mappingElement.class.value.name} [default]`
-          : `${mappingElement.class.value.name} [${mappingElement.id.value}]`
-      }`,
-      root: mappingElement.root.value,
-      tooltip: mappingElement.class.value.path,
-    };
-  }
-  throw new UnsupportedOperationError(
-    `Can't build label info for mapping element`,
-    mappingElement,
-  );
-};
-
-export const getMappingElementSource = (
-  mappingElement: MappingElement,
-  plugins: LegendStudioApplicationPlugin[],
-): MappingElementSource | undefined => {
-  if (mappingElement instanceof OperationSetImplementation) {
-    // NOTE: we don't need to resolve operation union because at the end of the day, it uses other class mappings
-    // in the mapping, so if we use this method on all class mappings of a mapping, we don't miss anything
-    return undefined;
-  } else if (mappingElement instanceof EnumerationMapping) {
-    return mappingElement.sourceType?.value;
-  } else if (mappingElement instanceof AssociationImplementation) {
-    throw new UnsupportedOperationError();
-  } else if (mappingElement instanceof PureInstanceSetImplementation) {
-    return mappingElement.srcClass?.value;
-  } else if (mappingElement instanceof FlatDataInstanceSetImplementation) {
-    return mappingElement.sourceRootRecordType.value;
-  } else if (mappingElement instanceof EmbeddedFlatDataPropertyMapping) {
-    return getMappingElementSource(
-      guaranteeType(
-        mappingElement.rootInstanceSetImplementation,
-        FlatDataInstanceSetImplementation,
-      ),
-      plugins,
-    );
-  } else if (
-    mappingElement instanceof RootRelationalInstanceSetImplementation
-  ) {
-    return mappingElement.mainTableAlias;
-  } else if (
-    mappingElement instanceof EmbeddedRelationalInstanceSetImplementation
-  ) {
-    return mappingElement.rootInstanceSetImplementation.mainTableAlias;
-  } else if (mappingElement instanceof AggregationAwareSetImplementation) {
-    return getMappingElementSource(
-      mappingElement.mainSetImplementation,
-      plugins,
-    );
-  }
-  const extraMappingElementSourceExtractors = plugins.flatMap(
-    (plugin) =>
-      (
-        plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
-      ).getExtraMappingElementSourceExtractors?.() ?? [],
-  );
-  for (const extractor of extraMappingElementSourceExtractors) {
-    const mappingElementSource = extractor(mappingElement);
-    if (mappingElementSource) {
-      return mappingElementSource;
-    }
-  }
-  throw new UnsupportedOperationError(
-    `Can't extract source of mapping element: no compatible extractor available from plugins`,
-    mappingElement,
-  );
-};
-
-export const getMappingElementType = (
-  mappingElement: MappingElement,
-): MAPPING_ELEMENT_TYPE => {
-  if (mappingElement instanceof EnumerationMapping) {
-    return MAPPING_ELEMENT_TYPE.ENUMERATION;
-  } else if (mappingElement instanceof AssociationImplementation) {
-    return MAPPING_ELEMENT_TYPE.ASSOCIATION;
-  } else if (mappingElement instanceof EmbeddedFlatDataPropertyMapping) {
-    return MAPPING_ELEMENT_TYPE.CLASS;
-  } else if (mappingElement instanceof SetImplementation) {
-    return MAPPING_ELEMENT_TYPE.CLASS;
-  }
-  throw new UnsupportedOperationError(
-    `Can't classify mapping element`,
-    mappingElement,
-  );
-};
-
-export const createClassMapping = (
-  mapping: Mapping,
-  id: string,
-  _class: Class,
-  setImpType: BASIC_SET_IMPLEMENTATION_TYPE,
-  editorStore: EditorStore,
-): SetImplementation | undefined => {
-  let setImp: SetImplementation;
-  // NOTE: by default when we create a new instance set implementation, we will create PURE instance set implementation
-  // we don't let users choose the various instance set implementation type as that require proper source
-  // e.g. flat data class mapping requires stubbing the source
-  switch (setImpType) {
-    case BASIC_SET_IMPLEMENTATION_TYPE.OPERATION:
-      setImp = new OperationSetImplementation(
-        InferableMappingElementIdExplicitValue.create(id, _class.path),
-        mapping,
-        PackageableElementExplicitReference.create(_class),
-        InferableMappingElementRootExplicitValue.create(false),
-        OperationType.STORE_UNION,
-      );
-      break;
-    case BASIC_SET_IMPLEMENTATION_TYPE.INSTANCE:
-      setImp = new PureInstanceSetImplementation(
-        InferableMappingElementIdExplicitValue.create(id, _class.path),
-        mapping,
-        PackageableElementExplicitReference.create(_class),
-        InferableMappingElementRootExplicitValue.create(false),
-        undefined,
-      );
-      break;
-    default:
-      return undefined;
-  }
-  setImpl_updateRootOnCreate(setImp);
-  mapping_addClassMapping(
-    mapping,
-    setImp,
-    editorStore.changeDetectionState.observerContext,
-  );
-  return setImp;
-};
-
-export const createEnumerationMapping = (
-  mapping: Mapping,
-  id: string,
-  enumeration: Enumeration,
-  sourceType: Type,
-): EnumerationMapping => {
-  const enumMapping = new EnumerationMapping(
-    InferableMappingElementIdExplicitValue.create(id, enumeration.path),
-    PackageableElementExplicitReference.create(enumeration),
-    mapping,
-    PackageableElementExplicitReference.create(sourceType),
-  );
-  mapping_addEnumerationMapping(mapping, enumMapping);
-  return enumMapping;
-};
-
-export const getEmbeddedSetImplementations = (
-  setImpl: InstanceSetImplementation,
-): InstanceSetImplementation[] => {
-  const embeddedPropertyMappings = setImpl.propertyMappings.filter(
-    // NOTE: we use this convenient flag to check if something is embedded mapping or not
-    // however, in reality, we can check for presence of `propertyMappings`, or more overkill
-    // do an extension mechanism to figure this out, for example, do an extension mechanism
-    // to check if an instance set implementation is embedded or not
-    (pm) => pm._isEmbedded,
-  ) as EmbeddedSetImplementation[];
-  return embeddedPropertyMappings
-    .flatMap(getEmbeddedSetImplementations)
-    .concat(embeddedPropertyMappings);
-};
-
-// We only care to get `own` class mapping as embedded set implementations can only be within the
-// current class mapping i.e current mapping.
-const getMappingEmbeddedSetImplementations = (
-  mapping: Mapping,
-): InstanceSetImplementation[] =>
-  mapping.classMappings
-    .filter(filterByType(InstanceSetImplementation))
-    .map(getEmbeddedSetImplementations)
-    .flat();
-
-const getMappingElementByTypeAndId = (
-  mapping: Mapping,
-  mappingElementType: string,
-  mappingElementId: string,
-): MappingElement | undefined => {
-  // NOTE: ID must be unique across all mapping elements of the same type
-  switch (mappingElementType) {
-    case MAPPING_ELEMENT_TYPE.CLASS:
-      return (
-        getAllClassMappings(mapping).find(
-          (classMapping) => classMapping.id.value === mappingElementId,
-        ) ??
-        getMappingEmbeddedSetImplementations(mapping)
-          .filter(filterByType(EmbeddedFlatDataPropertyMapping))
-          .find((me) => me.id.value === mappingElementId)
-      );
-    case MAPPING_ELEMENT_TYPE.ASSOCIATION:
-      return mapping.associationMappings.find(
-        (associationMapping) =>
-          associationMapping.id.value === mappingElementId,
-      );
-    case MAPPING_ELEMENT_TYPE.ENUMERATION:
-      return getAllEnumerationMappings(mapping).find(
-        (enumerationMapping) =>
-          enumerationMapping.id.value === mappingElementId,
-      );
-    default:
-      return undefined;
-  }
-};
-
-// TODO?: We need to consider whther to keep this method or not, because in the future we might
-// need to treat class mappings, enumeration mappings, and association mappings fairly differently
-// TODO: account for mapping includes?
-export const getAllMappingElements = (mapping: Mapping): MappingElement[] => [
-  ...mapping.classMappings,
-  ...mapping.associationMappings,
-  ...mapping.enumerationMappings,
-];
-
-const constructMappingElementNodeData = (
-  mappingElement: MappingElement,
-  editorStore: EditorStore,
-): MappingExplorerTreeNodeData => ({
-  id: `${mappingElement.id.value}`,
-  mappingElement: mappingElement,
-  label: getMappingElementLabel(mappingElement, editorStore).value,
-});
-
-const getMappingElementTreeNodeData = (
-  mappingElement: MappingElement,
-  editorStore: EditorStore,
-): MappingExplorerTreeNodeData => {
-  const nodeData: MappingExplorerTreeNodeData = constructMappingElementNodeData(
-    mappingElement,
-    editorStore,
-  );
-  if (
-    mappingElement instanceof FlatDataInstanceSetImplementation ||
-    mappingElement instanceof EmbeddedFlatDataPropertyMapping
-  ) {
-    const embedded = mappingElement.propertyMappings.filter(
-      filterByType(EmbeddedFlatDataPropertyMapping),
-    );
-    nodeData.childrenIds = embedded.map(
-      (e) => `${nodeData.id}.${e.property.value.name}`,
-    );
-  }
-  return nodeData;
-};
-
-const getMappingIdentitySortString = (
-  me: MappingElement,
-  type: PackageableElement,
-): string => `${type.name}-${type.path}-${me.id.value}`;
-
-const getMappingElementTreeData = (
-  mapping: Mapping,
-  editorStore: EditorStore,
-): TreeData<MappingExplorerTreeNodeData> => {
-  const rootIds: string[] = [];
-  const nodes = new Map<string, MappingExplorerTreeNodeData>();
-  const rootMappingElements = getAllMappingElements(mapping).sort((a, b) =>
-    getMappingIdentitySortString(a, getMappingElementTarget(a)).localeCompare(
-      getMappingIdentitySortString(b, getMappingElementTarget(b)),
-    ),
-  );
-  rootMappingElements.forEach((mappingElement) => {
-    const mappingElementTreeNodeData = getMappingElementTreeNodeData(
-      mappingElement,
-      editorStore,
-    );
-    addUniqueEntry(rootIds, mappingElementTreeNodeData.id);
-    nodes.set(mappingElementTreeNodeData.id, mappingElementTreeNodeData);
-  });
-  return { rootIds, nodes };
-};
-
-const reprocessMappingElement = (
-  mappingElement: MappingElement,
-  treeNodes: Map<string, MappingExplorerTreeNodeData>,
-  openNodes: string[],
-  editorStore: EditorStore,
-): MappingExplorerTreeNodeData => {
-  const nodeData: MappingExplorerTreeNodeData = constructMappingElementNodeData(
-    mappingElement,
-    editorStore,
-  );
-  if (
-    mappingElement instanceof FlatDataInstanceSetImplementation ||
-    mappingElement instanceof EmbeddedFlatDataPropertyMapping
-  ) {
-    const embedded = mappingElement.propertyMappings.filter(
-      filterByType(EmbeddedFlatDataPropertyMapping),
-    );
-    nodeData.childrenIds = embedded.map(
-      (e) => `${nodeData.id}.${e.property.value.name}`,
-    );
-    if (openNodes.includes(mappingElement.id.value)) {
-      nodeData.isOpen = true;
-      embedded.forEach((e) =>
-        reprocessMappingElement(e, treeNodes, openNodes, editorStore),
-      );
-    }
-  }
-  treeNodes.set(nodeData.id, nodeData);
-  return nodeData;
-};
-
-const reprocessMappingElementNodes = (
-  mapping: Mapping,
-  openNodes: string[],
-  editorStore: EditorStore,
-): TreeData<MappingExplorerTreeNodeData> => {
-  const rootIds: string[] = [];
-  const nodes = new Map<string, MappingExplorerTreeNodeData>();
-  const rootMappingElements = getAllMappingElements(mapping).sort((a, b) =>
-    getMappingIdentitySortString(a, getMappingElementTarget(a)).localeCompare(
-      getMappingIdentitySortString(b, getMappingElementTarget(b)),
-    ),
-  );
-  rootMappingElements.forEach((mappingElement) => {
-    const mappingElementTreeNodeData = reprocessMappingElement(
-      mappingElement,
-      nodes,
-      openNodes,
-      editorStore,
-    );
-    addUniqueEntry(rootIds, mappingElementTreeNodeData.id);
-  });
-  return { rootIds, nodes };
-};
-
-export interface MappingElementSpec {
-  showTarget: boolean;
-  // whether or not to open the new mapping element tab as an adjacent tab, this behavior is similar to Chrome
-  openInAdjacentTab: boolean;
-  target?: PackageableElement | undefined;
-  postSubmitAction?: (newMappingElement: MappingElement | undefined) => void;
-}
-
-export class MappingEditorState extends ElementEditorState {
-  currentTabState?: MappingEditorTabState | undefined;
-  openedTabStates: MappingEditorTabState[] = [];
-
-  mappingExplorerTreeData: TreeData<MappingExplorerTreeNodeData>;
-  newMappingElementSpec?: MappingElementSpec | undefined;
-
-  mappingTestStates: MappingTestState[] = [];
-  isRunningAllTests = false;
-  allTestRunTime = 0;
-
-  constructor(editorStore: EditorStore, element: PackageableElement) {
-    super(editorStore, element);
-
-    makeObservable<MappingEditorState, 'closeMappingElementTabState'>(this, {
-      currentTabState: observable,
-      openedTabStates: observable,
-      mappingTestStates: observable,
-      newMappingElementSpec: observable,
-      isRunningAllTests: observable,
-      allTestRunTime: observable,
-      mappingExplorerTreeData: observable.ref,
-      mapping: computed,
-      testSuiteResult: computed,
-      setNewMappingElementSpec: action,
-      setMappingExplorerTreeNodeData: action,
-      openMappingElement: action,
-      closeAllTabs: action,
-      createMappingElement: action,
-      reprocessMappingExplorerTree: action,
-      mappingElementsWithSimilarTarget: computed,
-      reprocess: action,
-      openTab: flow,
-      closeTab: flow,
-      closeAllOtherTabs: flow,
-      openTest: flow,
-      buildExecution: flow,
-      addTest: flow,
-      deleteTest: flow,
-      createNewTest: flow,
-      runTests: flow,
-      changeClassMappingSourceDriver: flow,
-      closeMappingElementTabState: flow,
-      deleteMappingElement: flow,
-    });
-
-    this.mappingTestStates = this.mapping.test.map(
-      (t) => new MappingTestState(editorStore, t, this),
-    );
-    this.mappingExplorerTreeData = getMappingElementTreeData(
-      this.mapping,
-      editorStore,
-    );
-  }
-
-  get mapping(): Mapping {
-    return guaranteeType(
-      this.element,
-      Mapping,
-      'Element inside mapping editor state must be a mapping',
-    );
-  }
-
-  /**
-   * This method is used to check if a target is being mapped multiple times, so we can make
-   * decision on things like whether we enforce the user to provide an ID for those mapping elements.
-   */
-  get mappingElementsWithSimilarTarget(): MappingElement[] {
-    if (this.currentTabState instanceof MappingElementState) {
-      const mappingElement = this.currentTabState.mappingElement;
-      switch (getMappingElementType(mappingElement)) {
-        case MAPPING_ELEMENT_TYPE.CLASS:
-          return this.mapping.classMappings.filter(
-            (cm) =>
-              cm.class.value ===
-              (mappingElement as SetImplementation).class.value,
-          );
-        case MAPPING_ELEMENT_TYPE.ENUMERATION:
-          return this.mapping.enumerationMappings.filter(
-            (em) =>
-              em.enumeration.value ===
-              (mappingElement as EnumerationMapping).enumeration.value,
-          );
-        case MAPPING_ELEMENT_TYPE.ASSOCIATION: // NOTE: we might not even support Association Mapping
-        default:
-          return [];
-      }
-    }
-    return [];
-  }
-
-  setNewMappingElementSpec(spec: MappingElementSpec | undefined): void {
-    this.newMappingElementSpec = spec;
-  }
-
-  // -------------------------------------- Tabs ---------------------------------------
-
-  *openTab(tabState: MappingEditorTabState): GeneratorFn<void> {
-    if (tabState !== this.currentTabState) {
-      if (tabState instanceof MappingTestState) {
-        yield flowResult(this.openTest(tabState.test));
-      } else if (tabState instanceof MappingElementState) {
-        this.openMappingElement(tabState.mappingElement, false);
-      } else if (tabState instanceof MappingExecutionState) {
-        this.currentTabState = tabState;
-      }
-    }
-  }
-
-  *closeTab(tabState: MappingEditorTabState): GeneratorFn<void> {
-    const tabIndex = this.openedTabStates.findIndex((ts) => ts === tabState);
-    assertTrue(
-      tabIndex !== -1,
-      `Mapping editor tab should be currently opened`,
-    );
-    this.openedTabStates.splice(tabIndex, 1);
-    // if current tab is closed, we need further processing
-    if (this.currentTabState === tabState) {
-      if (this.openedTabStates.length) {
-        const openIndex = tabIndex - 1;
-        const tabStateToOpen =
-          openIndex >= 0
-            ? this.openedTabStates[openIndex]
-            : this.openedTabStates.length
-            ? this.openedTabStates[0]
-            : undefined;
-        if (tabStateToOpen) {
-          yield flowResult(this.openTab(tabStateToOpen));
-        } else {
-          this.currentTabState = undefined;
-        }
-      } else {
-        this.currentTabState = undefined;
-      }
-    }
-  }
-
-  *closeAllOtherTabs(tabState: MappingEditorTabState): GeneratorFn<void> {
-    assertNonNullable(
-      this.openedTabStates.find((ts) => ts === tabState),
-      `Mapping editor tab should be currently opened`,
-    );
-    this.openedTabStates = [tabState];
-    yield flowResult(this.openTab(tabState));
-  }
-
-  closeAllTabs(): void {
-    this.currentTabState = undefined;
-    this.openedTabStates = [];
-  }
-
-  // -------------------------------------- Explorer Tree ---------------------------------------
-
-  setMappingExplorerTreeNodeData(
-    data: TreeData<MappingExplorerTreeNodeData>,
-  ): void {
-    this.mappingExplorerTreeData = data;
-  }
-
-  onMappingExplorerTreeNodeExpand = (
-    node: MappingExplorerTreeNodeData,
-  ): void => {
-    const mappingElement = node.mappingElement;
-    const treeData = this.mappingExplorerTreeData;
-    if (node.childrenIds?.length) {
-      node.isOpen = !node.isOpen;
-      if (
-        mappingElement instanceof FlatDataInstanceSetImplementation ||
-        mappingElement instanceof EmbeddedFlatDataPropertyMapping
-      ) {
-        mappingElement.propertyMappings
-          .filter(filterByType(EmbeddedFlatDataPropertyMapping))
-          .forEach((embeddedPM) => {
-            const embeddedPropertyNode = getMappingElementTreeNodeData(
-              embeddedPM,
-              this.editorStore,
-            );
-            treeData.nodes.set(embeddedPropertyNode.id, embeddedPropertyNode);
-          });
-      }
-    }
-    this.setMappingExplorerTreeNodeData({ ...treeData });
-  };
-
-  onMappingExplorerTreeNodeSelect = (
-    node: MappingExplorerTreeNodeData,
-  ): void => {
-    this.onMappingExplorerTreeNodeExpand(node);
-    this.openMappingElement(node.mappingElement, false);
-  };
-
-  getMappingExplorerTreeChildNodes = (
-    node: MappingExplorerTreeNodeData,
-  ): MappingExplorerTreeNodeData[] => {
-    if (!node.childrenIds) {
-      return [];
-    }
-    const childrenNodes = node.childrenIds
-      .map((id) => this.mappingExplorerTreeData.nodes.get(id))
-      .filter(isNonNullable)
-      .sort((a, b) => a.label.localeCompare(b.label));
-    return childrenNodes;
-  };
-
-  reprocessMappingExplorerTree(openNodeFoCurrentTab = false): void {
-    const openedTreeNodeIds = Array.from(
-      this.mappingExplorerTreeData.nodes.values(),
-    )
-      .filter((node) => node.isOpen)
-      .map((node) => node.id);
-    this.setMappingExplorerTreeNodeData(
-      reprocessMappingElementNodes(
-        this.mapping,
-        openedTreeNodeIds,
-        this.editorStore,
-      ),
-    );
-    if (openNodeFoCurrentTab) {
-      // TODO: we should follow the example of project explorer where we maintain the currentlySelectedNode
-      // instead of adaptively show the `selectedNode` based on current tab state. This is bad
-      // this.setMappingElementTreeNodeData(openNode(openElement, this.mappingElementsTreeData));
-      // const openNode = (element: EmbeddedFlatDataPropertyMapping, treeData: TreeData<MappingElementTreeNodeData>): MappingElementTreeNodeData => {
-      // if (element instanceof EmbeddedFlatDataPropertyMapping) {
-      //   let currentElement: InstanceSetImplementation | undefined = element;
-      //   while (currentElement instanceof EmbeddedFlatDataPropertyMapping) {
-      //     const node: MappingElementTreeNodeData = treeData.nodes.get(currentElement.id) ?? addNode(currentElement, treeData);
-      //     node.isOpen = true;
-      //     currentElement = currentElement.owner as InstanceSetImplementation;
-      //   }
-      //   // create children if not created
-      //   element.propertyMappings.filter((me: AbstractFlatDataPropertyMapping): me is EmbeddedFlatDataPropertyMapping => me instanceof EmbeddedFlatDataPropertyMapping)
-      //     .forEach(el => treeData.nodes.get(el.id) ?? addNode(el, treeData));
-      // }
-      // return treeData;
-      // const addNode = (element: EmbeddedFlatDataPropertyMapping, treeData: TreeData<MappingElementTreeNodeData>): MappingElementTreeNodeData => {
-      //   const newNode = getMappingElementTreeNodeData(element);
-      //   treeData.nodes.set(newNode.id, newNode);
-      //   if (element.owner instanceof FlatDataInstanceSetImplementation || element.owner instanceof EmbeddedFlatDataPropertyMapping) {
-      //     const baseNode = treeData.nodes.get(element.owner.id);
-      //     if (baseNode) {
-      //       baseNode.isOpen = true;
-      //     }
-      //   } else {
-      //     const parentNode = treeData.nodes.get(element.owner.id);
-      //     if (parentNode) {
-      //       parentNode.childrenIds = parentNode.childrenIds ? Array.from((new Set(parentNode.childrenIds)).add(newNode.id)) : [newNode.id];
-      //     }
-      //   }
-      //   return newNode;
-      // };
-    }
-  }
-
-  // -------------------------------------- Mapping Element ---------------------------------------
-
-  openMappingElement(
-    mappingElement: MappingElement,
-    openInAdjacentTab: boolean,
-  ): void {
-    if (mappingElement instanceof AssociationImplementation) {
-      this.editorStore.applicationStore.notificationService.notifyUnsupportedFeature(
-        'Association mapping editor',
-      );
-      return;
-    }
-    // Open mapping element from included mapping in another mapping editor tab
-    if (mappingElement._PARENT !== this.element) {
-      this.editorStore.tabManagerState.openElementEditor(
-        mappingElement._PARENT,
-      );
-    }
-    const currentMappingEditorState =
-      this.editorStore.tabManagerState.getCurrentEditorState(
-        MappingEditorState,
-      );
-    // If the next mapping element to be opened is not opened yet, we will find the right place to put it in the tab bar
-    if (
-      !currentMappingEditorState.openedTabStates.find(
-        (tabState) =>
-          tabState instanceof MappingElementState &&
-          tabState.mappingElement === mappingElement,
-      )
-    ) {
-      const newMappingElementState = guaranteeNonNullable(
-        currentMappingEditorState.createMappingElementState(mappingElement),
-      );
-      if (openInAdjacentTab) {
-        const currentMappingElementIndex = this.openedTabStates.findIndex(
-          (tabState) => tabState === this.currentTabState,
-        );
-        if (currentMappingElementIndex !== -1) {
-          currentMappingEditorState.openedTabStates.splice(
-            currentMappingElementIndex + 1,
-            0,
-            newMappingElementState,
-          );
-        } else {
-          throw new IllegalStateError(`Can't find current mapping editor tab`);
-        }
-      } else {
-        currentMappingEditorState.openedTabStates.push(newMappingElementState);
-      }
-    }
-    // Set current mapping element, i.e. switch to new tab
-    currentMappingEditorState.currentTabState =
-      currentMappingEditorState.openedTabStates.find(
-        (tabState) =>
-          tabState instanceof MappingElementState &&
-          tabState.mappingElement === mappingElement,
-      );
-    currentMappingEditorState.reprocessMappingExplorerTree(true);
-  }
-
-  *changeClassMappingSourceDriver(
-    setImplementation: InstanceSetImplementation,
-    newSource: MappingElementSource | undefined,
-  ): GeneratorFn<void> {
-    const currentSource = getMappingElementSource(
-      setImplementation,
-      this.editorStore.pluginManager.getApplicationPlugins(),
-    );
-    if (currentSource !== newSource) {
-      // first, we check if the current class mapping is compatible with the new source
-      // if it is, we don't need to create a new class mapping,
-      // if it is not, we would need to create a new class mapping that is compatible with the new source
-      // and as a result, we will reset all the property mappings
-      //
-      // TODO?: we might need to think of how we would handle embedded class mapping
-      let sourceUpdated = false;
-      if (setImplementation instanceof PureInstanceSetImplementation) {
-        if (newSource instanceof Class || newSource === undefined) {
-          pureInstanceSetImpl_setSrcClass(
-            setImplementation,
-            newSource
-              ? PackageableElementExplicitReference.create(newSource)
-              : undefined,
-          );
-          sourceUpdated = true;
-        }
-      } else if (
-        setImplementation instanceof FlatDataInstanceSetImplementation
-      ) {
-        if (
-          newSource instanceof RootFlatDataRecordType &&
-          !getEmbeddedSetImplementations(setImplementation).length
-        ) {
-          flatData_setSourceRootRecordType(setImplementation, newSource);
-          sourceUpdated = true;
-        }
-      } else if (
-        setImplementation instanceof RootRelationalInstanceSetImplementation
-      ) {
-        if (
-          newSource instanceof TableAlias &&
-          !getEmbeddedSetImplementations(setImplementation).length
-        ) {
-          rootRelationalSetImp_setMainTableAlias(setImplementation, newSource);
-          sourceUpdated = true;
-        }
-      } else {
-        const extraInstanceSetImplementationSourceUpdaters =
-          this.editorStore.pluginManager
-            .getApplicationPlugins()
-            .flatMap(
-              (plugin) =>
-                (
-                  plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
-                ).getExtraInstanceSetImplementationSourceUpdaters?.() ?? [],
-            );
-        for (const updater of extraInstanceSetImplementationSourceUpdaters) {
-          sourceUpdated = updater(setImplementation, newSource);
-          if (sourceUpdated) {
-            break;
-          }
-        }
-      }
-
-      // here we require a change of set implementation as the source type does not match the what the current class mapping supports
-      if (!sourceUpdated) {
-        let newSetImp: InstanceSetImplementation;
-        if (newSource instanceof Class || newSource === undefined) {
-          newSetImp = new PureInstanceSetImplementation(
-            setImplementation.id,
-            this.mapping,
-            setImplementation.class,
-            setImplementation.root,
-            newSource
-              ? PackageableElementExplicitReference.create(newSource)
-              : undefined,
-          );
-        } else if (newSource instanceof RootFlatDataRecordType) {
-          newSetImp = new FlatDataInstanceSetImplementation(
-            setImplementation.id,
-            this.mapping,
-            PackageableElementExplicitReference.create(
-              setImplementation.class.value,
-            ),
-            setImplementation.root,
-            RootFlatDataRecordTypeExplicitReference.create(newSource),
-          );
-        } else if (newSource instanceof TableAlias) {
-          const newRootRelationalInstanceSetImplementation =
-            new RootRelationalInstanceSetImplementation(
-              setImplementation.id,
-              this.mapping,
-              setImplementation.class,
-              setImplementation.root,
-            );
-          newRootRelationalInstanceSetImplementation.mainTableAlias = newSource;
-          newSetImp = newRootRelationalInstanceSetImplementation;
-        } else {
-          throw new UnsupportedOperationError(
-            `Can't use the specified class mapping source`,
-            newSource,
-          );
-        }
-
-        // replace the instance set implementation in mapping
-        const idx = guaranteeNonNullable(
-          this.mapping.classMappings.findIndex(
-            (classMapping) => classMapping === setImplementation,
-          ),
-          `Can't find class mapping with ID '${setImplementation.id.value}' in mapping '${this.mapping.path}'`,
-        );
-        this.mapping.classMappings[idx] = newSetImp;
-
-        // replace the instance set implementation in opened tab state
-        const setImplStateIdx = guaranteeNonNullable(
-          this.openedTabStates.findIndex(
-            (tabState) =>
-              tabState instanceof MappingElementState &&
-              tabState.mappingElement === setImplementation,
-          ),
-          `Can't find any mapping state for class mapping with ID '${setImplementation.id.value}'`,
-        );
-        const newMappingElementState = guaranteeNonNullable(
-          this.createMappingElementState(newSetImp),
-        );
-        this.openedTabStates[setImplStateIdx] = newMappingElementState;
-        this.currentTabState = newMappingElementState;
-
-        // close all children
-        yield flowResult(this.closeMappingElementTabState(setImplementation));
-        this.reprocessMappingExplorerTree(true);
-      }
-    }
-  }
-
-  private *closeMappingElementTabState(
-    mappingElement: MappingElement,
-  ): GeneratorFn<void> {
-    let mappingElementsToClose = [mappingElement];
-    if (
-      this.editorStore.graphManagerState.isInstanceSetImplementation(
-        mappingElement,
-      )
-    ) {
-      const embeddedChildren = getEmbeddedSetImplementations(mappingElement);
-      mappingElementsToClose = mappingElementsToClose.concat(embeddedChildren);
-    }
-    const matchMappingElementState = (
-      tabState: MappingEditorTabState | undefined,
-    ): boolean =>
-      tabState instanceof MappingElementState &&
-      mappingElementsToClose.includes(tabState.mappingElement);
-    if (
-      this.currentTabState &&
-      matchMappingElementState(this.currentTabState)
-    ) {
-      yield flowResult(this.closeTab(this.currentTabState));
-    }
-    this.openedTabStates = this.openedTabStates.filter(
-      (tabState) => !matchMappingElementState(tabState),
-    );
-  }
-
-  *deleteMappingElement(mappingElement: MappingElement): GeneratorFn<void> {
-    if (mappingElement instanceof EnumerationMapping) {
-      mapping_deleteEnumerationMapping(this.mapping, mappingElement);
-    } else if (mappingElement instanceof AssociationImplementation) {
-      mapping_deleteAssociationMapping(this.mapping, mappingElement);
-    } else if (mappingElement instanceof EmbeddedFlatDataPropertyMapping) {
-      deleteEntry(mappingElement._OWNER.propertyMappings, mappingElement);
-    } else if (
-      mappingElement instanceof EmbeddedRelationalInstanceSetImplementation
-    ) {
-      deleteEntry(mappingElement._OWNER.propertyMappings, mappingElement);
-    } else if (mappingElement instanceof SetImplementation) {
-      mapping_deleteClassMapping(this.mapping, mappingElement);
-    }
-    if (mappingElement instanceof SetImplementation) {
-      setImpl_updateRootOnDelete(mappingElement);
-    }
-    yield flowResult(this.closeMappingElementTabState(mappingElement));
-    this.reprocessMappingExplorerTree();
-  }
-
-  /**
-   * This will determine if we need to show the new mapping element modal or not
-   */
-  createMappingElement(spec: MappingElementSpec): void {
-    if (spec.target) {
-      const suggestedId = fromElementPathToMappingElementId(spec.target.path);
-      const mappingIds = getAllMappingElements(this.mapping).map(
-        (mElement) => mElement.id.value,
-      );
-      const showId = mappingIds.includes(suggestedId);
-      const showClasMappingType = spec.target instanceof Class;
-      const showNewMappingModal = [
-        showId,
-        spec.showTarget,
-        showClasMappingType,
-      ].some(Boolean);
-      if (showNewMappingModal) {
-        this.setNewMappingElementSpec(spec);
-      } else {
-        let newMappingElement: MappingElement | undefined = undefined;
-        if (spec.target instanceof Enumeration) {
-          // We default to a source type of String when creating a new enumeration mapping
-          newMappingElement = createEnumerationMapping(
-            this.mapping,
-            suggestedId,
-            spec.target,
-            PrimitiveType.STRING,
-          );
-        }
-        // NOTE: we don't support association now, nor do we support this for class
-        // since class requires a step to choose the class mapping type
-        if (newMappingElement) {
-          this.openMappingElement(newMappingElement, true);
-        }
-        if (spec.postSubmitAction) {
-          spec.postSubmitAction(newMappingElement);
-        }
-      }
-    } else {
-      this.setNewMappingElementSpec(spec);
-    }
-  }
-
-  private createMappingElementState(
-    mappingElement: MappingElement | undefined,
-  ): MappingElementState | undefined {
-    if (!mappingElement) {
-      return undefined;
-    }
-    if (mappingElement instanceof PureInstanceSetImplementation) {
-      return new PureInstanceSetImplementationState(
-        this.editorStore,
-        mappingElement,
-      );
-    } else if (mappingElement instanceof FlatDataInstanceSetImplementation) {
-      return new RootFlatDataInstanceSetImplementationState(
-        this.editorStore,
-        mappingElement,
-      );
-    } else if (mappingElement instanceof EmbeddedFlatDataPropertyMapping) {
-      throw new UnsupportedOperationError(
-        `Can't create mapping element state for emebdded property mapping`,
-      );
-    } else if (
-      mappingElement instanceof RootRelationalInstanceSetImplementation
-    ) {
-      return new RootRelationalInstanceSetImplementationState(
-        this.editorStore,
-        mappingElement,
-      );
-    } else if (
-      mappingElement instanceof EmbeddedRelationalInstanceSetImplementation ||
-      mappingElement instanceof AggregationAwareSetImplementation
-    ) {
-      return new UnsupportedInstanceSetImplementationState(
-        this.editorStore,
-        mappingElement,
-      );
-    }
-    const extraMappingElementStateCreators = this.editorStore.pluginManager
-      .getApplicationPlugins()
-      .flatMap(
-        (plugin) =>
-          (
-            plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
-          ).getExtraMappingElementStateCreators?.() ?? [],
-      );
-    for (const elementStateCreator of extraMappingElementStateCreators) {
-      const mappingElementState = elementStateCreator(
-        mappingElement,
-        this.editorStore,
-      );
-      if (mappingElementState) {
-        return mappingElementState;
-      }
-    }
-    return new MappingElementState(this.editorStore, mappingElement);
-  }
-
-  // -------------------------------------- Compilation ---------------------------------------
-
-  reprocess(newElement: Mapping, editorStore: EditorStore): MappingEditorState {
-    const mappingEditorState = new MappingEditorState(editorStore, newElement);
-
-    // process tabs
-    mappingEditorState.openedTabStates = this.openedTabStates
-      .map((tabState) => {
-        if (tabState instanceof MappingElementState) {
-          const mappingElement = getMappingElementByTypeAndId(
-            mappingEditorState.mapping,
-            getMappingElementType(tabState.mappingElement),
-            tabState.mappingElement.id.value,
-          );
-          return this.createMappingElementState(mappingElement);
-        } else if (tabState instanceof MappingTestState) {
-          return mappingEditorState.mappingTestStates.find(
-            (testState) => testState.test.name === tabState.test.name,
-          );
-        } else if (tabState instanceof MappingExecutionState) {
-          // TODO?: re-consider if we would want to reprocess mapping execution tabs or not
-          return undefined;
-        }
-        // TODO?: re-consider if we would want to reprocess mapping execution tabs or not
-        return undefined;
-      })
-      .filter(isNonNullable);
-
-    // process currently opened tab
-    if (this.currentTabState instanceof MappingElementState) {
-      const currentlyOpenedMappingElement = getMappingElementByTypeAndId(
-        mappingEditorState.mapping,
-        getMappingElementType(this.currentTabState.mappingElement),
-        this.currentTabState.mappingElement.id.value,
-      );
-      mappingEditorState.currentTabState = this.openedTabStates.find(
-        (tabState) =>
-          tabState instanceof MappingElementState &&
-          tabState.mappingElement === currentlyOpenedMappingElement,
-      );
-    } else if (this.currentTabState instanceof MappingTestState) {
-      const currentlyOpenedMappingTest =
-        mappingEditorState.mappingTestStates.find(
-          (testState) =>
-            this.currentTabState instanceof MappingTestState &&
-            testState.test.name === this.currentTabState.test.name,
-        )?.test;
-      mappingEditorState.currentTabState = this.openedTabStates.find(
-        (tabState) =>
-          tabState instanceof MappingTestState &&
-          tabState.test === currentlyOpenedMappingTest,
-      );
-    } else {
-      // TODO?: re-consider if we would want to reprocess mapping execution tab or not
-      mappingEditorState.currentTabState = undefined;
-    }
-
-    return mappingEditorState;
-  }
-
-  override revealCompilationError(compilationError: CompilationError): boolean {
-    let revealed = false;
-    try {
-      if (compilationError.sourceInformation) {
-        const errorCoordinates = extractSourceInformationCoordinates(
-          compilationError.sourceInformation,
-        );
-        if (errorCoordinates) {
-          const sourceId = compilationError.sourceInformation.sourceId;
-          assertTrue(errorCoordinates.length >= 5);
-          const [
-            ,
-            mappingElementType,
-            mappingElementId,
-            propertyName,
-            targetPropertyId,
-          ] = errorCoordinates;
-          const newMappingElement = getMappingElementByTypeAndId(
-            this.mapping,
-            guaranteeNonNullable(
-              mappingElementType,
-              `Can't reveal compilation error: mapping type is missing`,
-            ),
-            guaranteeNonNullable(
-              mappingElementId,
-              `Can't reveal compilation error: mapping ID is missing`,
-            ),
-          );
-          // TODO: take care of operation mapping using systematic coordinates
-          // See https://github.com/finos/legend-studio/issues/1168
-          if (newMappingElement instanceof InstanceSetImplementation) {
-            const propertyMapping = findPropertyMapping(
-              newMappingElement,
-              guaranteeNonNullable(
-                propertyName,
-                `Can't reveal compilation error: mapping property name is missing`,
-              ),
-              targetPropertyId,
-            );
-            if (propertyMapping) {
-              if (
-                !(this.currentTabState instanceof MappingElementState) ||
-                newMappingElement !== this.currentTabState.mappingElement
-              ) {
-                this.openMappingElement(newMappingElement, false);
-              }
-              if (
-                // TODO: take care of operation mapping using systematic coordinates
-                // See https://github.com/finos/legend-studio/issues/1168
-                this.currentTabState instanceof InstanceSetImplementationState
-              ) {
-                const propertyMappingState: LambdaEditorState | undefined = (
-                  this.currentTabState.propertyMappingStates as unknown[]
-                )
-                  .filter(filterByType(LambdaEditorState))
-                  .find((state) => state.lambdaId === sourceId);
-                if (propertyMappingState) {
-                  propertyMappingState.setCompilationError(compilationError);
-                  revealed = true;
-                }
-              }
-            }
-          }
-        }
-      }
-    } catch (error) {
-      assertErrorThrown(error);
-      this.editorStore.applicationStore.logService.warn(
-        LogEvent.create(GRAPH_MANAGER_EVENT.COMPILATION_FAILURE),
-        `Can't locate error, redirecting to text mode`,
-        error,
-      );
-    }
-    return revealed;
-  }
-
-  override clearCompilationError(): void {
-    this.openedTabStates
-      .filter(filterByType(InstanceSetImplementationState))
-      .forEach((tabState) => {
-        tabState.propertyMappingStates.forEach((pmState) =>
-          pmState.setCompilationError(undefined),
-        );
-      });
-  }
-
-  // -------------------------------------- Execution ---------------------------------------
-
-  *buildExecution(setImpl: SetImplementation): GeneratorFn<void> {
-    const executionTabStates = this.openedTabStates.filter(
-      filterByType(MappingExecutionState),
-    );
-    const executionStateName = generateEnumerableNameFromToken(
-      executionTabStates.map((tabState) => tabState.name),
-      'execution',
-    );
-    assertTrue(
-      !executionTabStates.find(
-        (tabState) => tabState.name === executionStateName,
-      ),
-      `Can't auto-generate execution name for value '${executionStateName}'`,
-    );
-    const executionState = new MappingExecutionState(
-      this.editorStore,
-      this,
-      executionStateName,
-    );
-    yield flowResult(executionState.buildQueryWithClassMapping(setImpl));
-    addUniqueEntry(this.openedTabStates, executionState);
-    this.currentTabState = executionState;
-  }
-
-  // -------------------------------------- Test ---------------------------------------
-
-  *openTest(
-    test: DEPRECATED__MappingTest,
-    openTab?: MAPPING_TEST_EDITOR_TAB_TYPE,
-  ): GeneratorFn<void> {
-    const isOpened = Boolean(
-      this.openedTabStates.find(
-        (tabState) =>
-          tabState instanceof MappingTestState && tabState.test === test,
-      ),
-    );
-    const testState = this.mappingTestStates.find(
-      (mappingTestState) => mappingTestState.test === test,
-    );
-    assertNonNullable(
-      testState,
-      `Mapping test state must already been created for test '${test.name}'`,
-    );
-    if (
-      !this.openedTabStates.find(
-        (tabState) =>
-          tabState instanceof MappingTestState && tabState.test === test,
-      )
-    ) {
-      addUniqueEntry(this.openedTabStates, testState);
-    }
-    this.currentTabState = this.openedTabStates.find(
-      (tabState) =>
-        tabState instanceof MappingTestState && tabState.test === test,
-    );
-    yield flowResult(
-      testState.onTestStateOpen(
-        openTab ??
-          // This is for user's convenience.
-          // If the test is already opened, respect is currently opened tab
-          // otherwise, if the test has a result, switch to show the result tab
-          (!isOpened && testState.result !== TEST_RESULT.NONE
-            ? MAPPING_TEST_EDITOR_TAB_TYPE.RESULT
-            : undefined),
-      ),
-    );
-  }
-
-  get testSuiteResult(): TEST_RESULT {
-    const numberOfTestPassed = this.mappingTestStates.filter(
-      (testState) => testState.result === TEST_RESULT.PASSED,
-    ).length;
-    const numberOfTestFailed = this.mappingTestStates.filter(
-      (testState) =>
-        testState.result === TEST_RESULT.FAILED ||
-        testState.result === TEST_RESULT.ERROR,
-    ).length;
-    return numberOfTestFailed
-      ? TEST_RESULT.FAILED
-      : numberOfTestPassed
-      ? TEST_RESULT.PASSED
-      : TEST_RESULT.NONE;
-  }
-
-  *runTests(): GeneratorFn<void> {
-    const startTime = Date.now();
-    this.isRunningAllTests = true;
-    this.mappingTestStates.forEach((testState) =>
-      testState.resetTestRunStatus(),
-    );
-    yield Promise.all(
-      this.mappingTestStates.map((testState: MappingTestState) => {
-        // run non-skip tests, and reset all skipped tests
-        if (!testState.isSkipped) {
-          return testState.runTest();
-        }
-        testState.resetTestRunStatus();
-        return undefined;
-      }),
-    );
-    this.isRunningAllTests = false;
-    this.allTestRunTime = Date.now() - startTime;
-  }
-
-  *addTest(test: DEPRECATED__MappingTest): GeneratorFn<void> {
-    this.mappingTestStates.push(
-      new MappingTestState(this.editorStore, test, this),
-    );
-    mapping_addTest(
-      this.mapping,
-      test,
-      this.editorStore.changeDetectionState.observerContext,
-    );
-    yield flowResult(this.openTest(test));
-  }
-
-  *deleteTest(test: DEPRECATED__MappingTest): GeneratorFn<void> {
-    const matchMappingTestState = (
-      tabState: MappingEditorTabState | undefined,
-    ): boolean =>
-      tabState instanceof MappingTestState && tabState.test === test;
-    mapping_deleteTest(this.mapping, test);
-    if (this.currentTabState && matchMappingTestState(this.currentTabState)) {
-      yield flowResult(this.closeTab(this.currentTabState));
-    }
-    this.openedTabStates = this.openedTabStates.filter(
-      (tabState) => !matchMappingTestState(tabState),
-    );
-    this.mappingTestStates = this.mappingTestStates.filter(
-      (tabState) => !matchMappingTestState(tabState),
-    );
-  }
-
-  *createNewTest(setImplementation: SetImplementation): GeneratorFn<void> {
-    const query =
-      this.editorStore.graphManagerState.graphManager.createGetAllRawLambda(
-        setImplementation.class.value,
-      );
-    const source = getMappingElementSource(
-      setImplementation,
-      this.editorStore.pluginManager.getApplicationPlugins(),
-    );
-    if (setImplementation instanceof OperationSetImplementation) {
-      this.editorStore.applicationStore.notificationService.notifyWarning(
-        `Can't auto-generate input data for operation class mapping. Please pick a concrete class mapping instead`,
-      );
-    }
-    let inputData: InputData;
-    if (source === undefined || source instanceof Class) {
-      inputData = new ObjectInputData(
-        PackageableElementExplicitReference.create(source ?? stub_Class()),
-        ObjectInputType.JSON,
-        source
-          ? createMockDataForMappingElementSource(source, this.editorStore)
-          : '{}',
-      );
-    } else if (source instanceof RootFlatDataRecordType) {
-      inputData = new FlatDataInputData(
-        PackageableElementExplicitReference.create(source._OWNER._OWNER),
-        createMockDataForMappingElementSource(source, this.editorStore),
-      );
-    } else if (source instanceof TableAlias) {
-      inputData = new RelationalInputData(
-        PackageableElementExplicitReference.create(
-          source.relation.ownerReference.value,
-        ),
-        createMockDataForMappingElementSource(source, this.editorStore),
-        RelationalInputType.SQL,
-      );
-    } else {
-      throw new UnsupportedOperationError(
-        `Can't create new mapping test input data with the specified source`,
-        source,
-      );
-    }
-    const newTest = new DEPRECATED__MappingTest(
-      generateMappingTestName(this.mapping),
-      query,
-      [inputData],
-      new ExpectedOutputMappingTestAssert('{}'),
-    );
-    mapping_addTest(
-      this.mapping,
-      newTest,
-      this.editorStore.changeDetectionState.observerContext,
-    );
-    // open the test
-    this.mappingTestStates.push(
-      new MappingTestState(this.editorStore, newTest, this),
-    );
-    yield flowResult(this.openTest(newTest));
-  }
-}