@finos/legend-application-studio 28.13.12 → 28.13.14

package/src/stores/editor/EditorGraphState.ts

@@ -491,6 +491,31 @@ export class EditorGraphState {
     }
   }
 
+  *buildGraphForLazyText(): GeneratorFn<void> {
+    this.isInitializingGraph = true;
+    const stopWatch = new StopWatch();
+    // reset
+    this.editorStore.graphManagerState.resetGraph();
+    // fetch and build dependencies
+    stopWatch.record();
+    const dependencyManager =
+      this.editorStore.graphManagerState.graphManager.createDependencyManager();
+    this.editorStore.graphManagerState.graph.dependencyManager =
+      dependencyManager;
+    this.editorStore.graphManagerState.dependenciesBuildState.setMessage(
+      `Fetching dependencies...`,
+    );
+    const dependencyEntitiesIndex = (yield flowResult(
+      this.getIndexedDependencyEntities(),
+    )) as Map<string, EntitiesWithOrigin>;
+    stopWatch.record(GRAPH_MANAGER_EVENT.FETCH_GRAPH_DEPENDENCIES__SUCCESS);
+    dependencyManager.initialize(dependencyEntitiesIndex);
+    this.isInitializingGraph = false;
+    this.editorStore.graphManagerState.dependenciesBuildState.sync(
+      ActionState.create().pass(),
+    );
+  }
+
   private redirectToModelImporterForDebugging(error: Error): void {
     if (this.editorStore.isInConflictResolutionMode) {
       this.editorStore.applicationStore.alertService.setBlockingAlert({

package/src/stores/editor/EditorStore.ts

@@ -110,6 +110,10 @@ import { SQLPlaygroundPanelState } from './panel-group/SQLPlaygroundPanelState.j
 import type { QuickInputState } from './QuickInputState.js';
 import { GlobalEndToEndWorkflowState } from './sidebar-state/end-to-end-workflow/GlobalEndToEndFlowState.js';
 import { openShowcaseManager } from '../ShowcaseManagerState.js';
+import {
+  GraphEditLazyGrammarModeState,
+  LazyTextEditorStore,
+} from '../lazy-text-editor/LazyTextEditorStore.js';
 
 export abstract class EditorExtensionState {
   /**
@@ -195,6 +199,8 @@ export class EditorStore implements CommandRegistrar {
   readonly tabManagerState = new EditorTabManagerState(this);
   supportedElementTypesWithCategory: Map<string, string[]>;
 
+  lazyTextEditorStore = new LazyTextEditorStore(this);
+
   constructor(
     applicationStore: LegendStudioApplicationStore,
     sdlcServerClient: SDLCServerClient,
@@ -211,6 +217,7 @@ export class EditorStore implements CommandRegistrar {
       graphEditorMode: observable,
       showSearchElementCommand: observable,
       quickInputState: observable,
+      lazyTextEditorStore: observable,
 
       isInViewerMode: computed,
       disableGraphEditing: computed,
@@ -230,6 +237,7 @@ export class EditorStore implements CommandRegistrar {
       initialize: flow,
       initMode: flow,
       initStandardMode: flow,
+      initializeLazyTextMode: flow,
       initConflictResolutionMode: flow,
       buildGraph: flow,
       toggleTextMode: flow,
@@ -715,6 +723,7 @@ export class EditorStore implements CommandRegistrar {
       ),
     ]);
     yield this.graphManagerState.initializeSystem();
+
     yield flowResult(this.initMode());
 
     onLeave(true);
@@ -728,6 +737,9 @@ export class EditorStore implements CommandRegistrar {
       case EDITOR_MODE.CONFLICT_RESOLUTION:
         yield flowResult(this.initConflictResolutionMode());
         return;
+      case EDITOR_MODE.LAZY_TEXT_EDITOR:
+        yield flowResult(this.initializeLazyTextMode());
+        return;
       default:
         throw new UnsupportedOperationError(
           `Can't initialize editor for unsupported mode '${this.mode}'`,
@@ -766,6 +778,92 @@ export class EditorStore implements CommandRegistrar {
     ]);
   }
 
+  *initializeLazyTextMode(): GeneratorFn<void> {
+    // set up
+    const projectId = this.sdlcState.activeProject.projectId;
+    const activeWorkspace = this.sdlcState.activeWorkspace;
+    const projectConfiguration = (yield this.sdlcServerClient.getConfiguration(
+      projectId,
+      activeWorkspace,
+    )) as PlainObject<ProjectConfiguration>;
+    this.projectConfigurationEditorState.setProjectConfiguration(
+      ProjectConfiguration.serialization.fromJson(projectConfiguration),
+    );
+    // make sure we set the original project configuration to a different object
+    this.projectConfigurationEditorState.setOriginalProjectConfiguration(
+      ProjectConfiguration.serialization.fromJson(projectConfiguration),
+    );
+
+    const startTime = Date.now();
+    let entities: Entity[];
+
+    this.initState.setMessage(`Fetching entities...`);
+    try {
+      entities = (yield this.sdlcServerClient.getEntities(
+        projectId,
+        activeWorkspace,
+      )) as Entity[];
+      this.changeDetectionState.workspaceLocalLatestRevisionState.setEntities(
+        entities,
+      );
+      this.applicationStore.logService.info(
+        LogEvent.create(GRAPH_MANAGER_EVENT.FETCH_GRAPH_ENTITIES__SUCCESS),
+        Date.now() - startTime,
+        'ms',
+      );
+    } catch {
+      return;
+    } finally {
+      this.initState.setMessage(undefined);
+    }
+    this.initState.setMessage('Building entities hash...');
+    yield flowResult(
+      this.changeDetectionState.workspaceLocalLatestRevisionState.buildEntityHashesIndex(
+        entities,
+        LogEvent.create(
+          LEGEND_STUDIO_APP_EVENT.CHANGE_DETECTION_BUILD_LOCAL_HASHES_INDEX__SUCCESS,
+        ),
+      ),
+    );
+
+    this.initState.setMessage('Building strict lazy graph...');
+    (yield flowResult(
+      this.graphState.buildGraphForLazyText(),
+    )) as GraphBuilderResult;
+    this.graphManagerState.graphBuildState.sync(ActionState.create().pass());
+    this.graphManagerState.generationsBuildState.sync(
+      ActionState.create().pass(),
+    );
+    this.initState.setMessage(undefined);
+    // switch to text mode
+    const graphEditorMode = new GraphEditLazyGrammarModeState(this);
+    try {
+      const editorGrammar =
+        (yield this.graphManagerState.graphManager.entitiesToPureCode(
+          this.changeDetectionState.workspaceLocalLatestRevisionState.entities,
+          { pretty: true },
+        )) as string;
+      yield flowResult(
+        graphEditorMode.grammarTextEditorState.setGraphGrammarText(
+          editorGrammar,
+        ),
+      );
+      this.graphEditorMode = graphEditorMode;
+      yield flowResult(
+        this.graphEditorMode.initialize({
+          useStoredEntities: true,
+        }),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.applicationStore.notificationService.notifyWarning(
+        `Can't initialize strict text mode. Issue converting entities to grammar: ${error.message}`,
+      );
+      this.applicationStore.alertService.setBlockingAlert(undefined);
+      return;
+    }
+  }
+
   private *initConflictResolutionMode(): GeneratorFn<void> {
     yield flowResult(
       this.conflictResolutionState.initProjectConfigurationInConflictResolutionMode(),
@@ -946,11 +1044,15 @@ export class EditorStore implements CommandRegistrar {
     if (this.graphState.checkIfApplicationUpdateOperationIsRunning()) {
       return;
     }
-    this.applicationStore.alertService.setBlockingAlert({
-      message: 'Switching to text mode...',
-      showLoading: true,
-    });
+    if (this.graphEditorMode.disableLeaveMode) {
+      this.graphEditorMode.onLeave();
+      return;
+    }
     if (this.graphEditorMode instanceof GraphEditFormModeState) {
+      this.applicationStore.alertService.setBlockingAlert({
+        message: 'Switching to text mode...',
+        showLoading: true,
+      });
       yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.GRAMMAR_TEXT));
     } else if (this.graphEditorMode instanceof GraphEditGrammarModeState) {
       yield flowResult(this.switchModes(GRAPH_EDITOR_MODE.FORM));
@@ -1136,6 +1238,7 @@ export class EditorStore implements CommandRegistrar {
     fallbackOptions?: {
       isCompilationFailure?: boolean;
       isGraphBuildFailure?: boolean;
+      useStoredEntities?: boolean;
     },
   ): GeneratorFn<void> {
     switch (to) {
@@ -1147,9 +1250,7 @@ export class EditorStore implements CommandRegistrar {
             graphEditorMode.cleanupBeforeEntering(fallbackOptions),
           );
           this.graphEditorMode = graphEditorMode;
-          yield flowResult(
-            this.graphEditorMode.initialize(Boolean(fallbackOptions)),
-          );
+          yield flowResult(this.graphEditorMode.initialize(fallbackOptions));
         } catch (error) {
           assertErrorThrown(error);
           this.applicationStore.notificationService.notifyWarning(

package/src/stores/editor/GraphEditGrammarModeState.ts

@@ -61,7 +61,15 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     this.grammarTextEditorState = new GrammarTextEditorState(this.editorStore);
   }
 
-  *initialize(isFallback?: boolean): GeneratorFn<void> {
+  get headerLabel(): string {
+    return 'Text Mode';
+  }
+
+  *initialize(isFallback?: {
+    isCompilationFailure?: boolean;
+    isGraphBuildFailure?: boolean;
+    useStoredEntities?: boolean;
+  }): GeneratorFn<void> {
     this.editorStore.localChangesState = new TextLocalChangesState(
       this.editorStore,
       this.editorStore.sdlcState,
@@ -93,7 +101,11 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
         error,
       );
     }
-    if (isFallback) {
+    if (
+      isFallback?.isCompilationFailure ||
+      isFallback?.isGraphBuildFailure ||
+      isFallback?.useStoredEntities
+    ) {
       yield flowResult(
         this.globalCompile({
           ignoreBlocking: true,

package/src/stores/editor/GraphEditorMode.ts

@@ -42,7 +42,15 @@ export abstract class GraphEditorMode {
     this.editorStore = editorStore;
   }
 
-  abstract initialize(isFallback?: boolean): GeneratorFn<void>;
+  get disableLeaveMode(): boolean {
+    return false;
+  }
+
+  abstract initialize(options?: {
+    isCompilationFailure?: boolean;
+    isGraphBuildFailure?: boolean;
+    useStoredEntities?: boolean;
+  }): GeneratorFn<void>;
   abstract addElement(
     element: PackageableElement,
     packagePath: string | undefined,

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

@@ -33,7 +33,7 @@ import {
   MAPPING_TEST_EDITOR_TAB_TYPE,
   DEPRECATED__MappingTestState,
   TEST_RESULT,
-} from './DEPRECATED__MappingTestState.js';
+} from './legacy/DEPRECATED__MappingTestState.js';
 import { createMockDataForMappingElementSource } from '../../../utils/MockDataUtils.js';
 import {
   type GeneratorFn,
@@ -59,7 +59,7 @@ import { RootRelationalInstanceSetImplementationState } from './relational/Relat
 import {
   type CompilationError,
   type PackageableElement,
-  type InputData,
+  type DEPRECATED__InputData,
   Type,
   type EmbeddedSetImplementation,
   type ExecutionResult,
@@ -74,8 +74,8 @@ import {
   EnumerationMapping,
   SetImplementation,
   PureInstanceSetImplementation,
-  ExpectedOutputMappingTestAssert,
-  ObjectInputData,
+  DEPRECATED__ExpectedOutputMappingTestAssert,
+  DEPRECATED__ObjectInputData,
   ObjectInputType,
   FlatDataInstanceSetImplementation,
   InstanceSetImplementation,
@@ -125,6 +125,7 @@ import { rootRelationalSetImp_setMainTableAlias } from '../../../../graph-modifi
 import { LambdaEditorState } from '@finos/legend-query-builder';
 import type { MappingEditorTabState } from './MappingTabManagerState.js';
 import { MappingTestableState } from './testable/MappingTestableState.js';
+import { MappingTestMigrationState } from './legacy/MappingTestMigrationState.js';
 
 export interface MappingExplorerTreeNodeData extends TreeNodeData {
   mappingElement: MappingElement;
@@ -626,6 +627,7 @@ export class MappingEditorState extends ElementEditorState {
 
   // DEPREACTED legacy tests: TO REMOVE once mapping testable dev work is complete
   DEPRECATED_mappingTestStates: DEPRECATED__MappingTestState[] = [];
+  migrationState: MappingTestMigrationState | undefined;
   isRunningAllTests = false;
   allTestRunTime = 0;
 
@@ -640,11 +642,15 @@ export class MappingEditorState extends ElementEditorState {
       isRunningAllTests: observable,
       allTestRunTime: observable,
       selectedTab: observable,
+      migrationState: observable,
       mappingExplorerTreeData: observable.ref,
       mapping: computed,
       testSuiteResult: computed,
       setNewMappingElementSpec: action,
+      openMigrationTool: action,
+      closeMigrationTool: action,
       setMappingExplorerTreeNodeData: action,
+      buildLegacyTestsStates: action,
       openMappingElement: action,
       closeAllTabs: action,
       createMappingElement: action,
@@ -666,9 +672,7 @@ export class MappingEditorState extends ElementEditorState {
       deleteMappingElement: flow,
     });
 
-    this.DEPRECATED_mappingTestStates = this.mapping.test.map(
-      (t) => new DEPRECATED__MappingTestState(editorStore, t, this),
-    );
+    this.DEPRECATED_mappingTestStates = this.buildLegacyTestsStates();
     this.mappingExplorerTreeData = getMappingElementTreeData(
       this.mapping,
       editorStore,
@@ -684,6 +688,12 @@ export class MappingEditorState extends ElementEditorState {
     );
   }
 
+  buildLegacyTestsStates(): DEPRECATED__MappingTestState[] {
+    return this.mapping.test.map(
+      (t) => new DEPRECATED__MappingTestState(this.editorStore, t, this),
+    );
+  }
+
   /**
    * 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.
@@ -1393,6 +1403,23 @@ export class MappingEditorState extends ElementEditorState {
 
   // -------------------------------------- Test ---------------------------------------
 
+  openMigrationTool(): void {
+    if (!this.mapping.test.length) {
+      this.editorStore.applicationStore.notificationService.notifyError(
+        'No legacy tests to migrate',
+      );
+      return;
+    }
+    this.migrationState = MappingTestMigrationState.build(
+      this.editorStore,
+      this,
+    );
+  }
+
+  closeMigrationTool(): void {
+    this.migrationState = undefined;
+  }
+
   *openTest(
     test: DEPRECATED__MappingTest,
     openTab?: MAPPING_TEST_EDITOR_TAB_TYPE,
@@ -1546,9 +1573,9 @@ export class MappingEditorState extends ElementEditorState {
         `Can't auto-generate input data for operation class mapping. Please pick a concrete class mapping instead`,
       );
     }
-    let inputData: InputData;
+    let inputData: DEPRECATED__InputData;
     if (source === undefined || source instanceof Class) {
-      inputData = new ObjectInputData(
+      inputData = new DEPRECATED__ObjectInputData(
         PackageableElementExplicitReference.create(source ?? stub_Class()),
         ObjectInputType.JSON,
         source
@@ -1578,7 +1605,7 @@ export class MappingEditorState extends ElementEditorState {
       generateMappingTestName(this.mapping),
       query,
       [inputData],
-      new ExpectedOutputMappingTestAssert('{}'),
+      new DEPRECATED__ExpectedOutputMappingTestAssert('{}'),
     );
     mapping_addDEPRECATEDTest(
       this.mapping,

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

@@ -51,7 +51,7 @@ import {
 } from '@finos/legend-shared';
 import { createMockDataForMappingElementSource } from '../../../utils/MockDataUtils.js';
 import {
-  type InputData,
+  type DEPRECATED__InputData,
   type Mapping,
   type Connection,
   type ExecutionResult,
@@ -69,9 +69,9 @@ import {
   LAMBDA_PIPE,
   GRAPH_MANAGER_EVENT,
   Class,
-  ObjectInputData,
+  DEPRECATED__ObjectInputData,
   ObjectInputType,
-  ExpectedOutputMappingTestAssert,
+  DEPRECATED__ExpectedOutputMappingTestAssert,
   IdentifiedConnection,
   EngineRuntime,
   JsonModelConnection,
@@ -209,12 +209,12 @@ abstract class MappingExecutionInputDataState {
   readonly uuid = uuid();
   editorStore: EditorStore;
   mapping: Mapping;
-  inputData?: InputData | undefined;
+  inputData?: DEPRECATED__InputData | undefined;
 
   constructor(
     editorStore: EditorStore,
     mapping: Mapping,
-    inputData: InputData | undefined,
+    inputData: DEPRECATED__InputData | undefined,
   ) {
     this.editorStore = editorStore;
     this.mapping = mapping;
@@ -232,7 +232,7 @@ abstract class MappingExecutionInputDataState {
     return undefined;
   }
 
-  abstract buildInputDataForTest(): InputData;
+  abstract buildInputDataForTest(): DEPRECATED__InputData;
 }
 
 export const createRuntimeForExecution = (
@@ -267,7 +267,7 @@ export class MappingExecutionEmptyInputDataState extends MappingExecutionInputDa
     );
   }
 
-  buildInputDataForTest(): InputData {
+  buildInputDataForTest(): DEPRECATED__InputData {
     throw new IllegalStateError(
       'Mapping execution runtime information is not specified',
     );
@@ -276,13 +276,13 @@ export class MappingExecutionEmptyInputDataState extends MappingExecutionInputDa
 
 // TODO?: handle XML
 export class MappingExecutionObjectInputDataState extends MappingExecutionInputDataState {
-  declare inputData: ObjectInputData;
+  declare inputData: DEPRECATED__ObjectInputData;
 
   constructor(editorStore: EditorStore, mapping: Mapping, _class: Class) {
     super(
       editorStore,
       mapping,
-      new ObjectInputData(
+      new DEPRECATED__ObjectInputData(
         PackageableElementExplicitReference.create(
           guaranteeNonNullable(_class),
         ),
@@ -344,8 +344,8 @@ export class MappingExecutionObjectInputDataState extends MappingExecutionInputD
     return jsonAssertion;
   }
 
-  buildInputDataForTest(): InputData {
-    return new ObjectInputData(
+  buildInputDataForTest(): DEPRECATED__InputData {
+    return new DEPRECATED__ObjectInputData(
       PackageableElementExplicitReference.create(
         guaranteeNonNullable(this.inputData.sourceClass.value),
       ),
@@ -402,7 +402,7 @@ export class MappingExecutionFlatDataInputDataState extends MappingExecutionInpu
     );
   }
 
-  buildInputDataForTest(): InputData {
+  buildInputDataForTest(): DEPRECATED__InputData {
     return new FlatDataInputData(
       PackageableElementExplicitReference.create(
         guaranteeNonNullable(this.inputData.sourceFlatData.value),
@@ -474,7 +474,7 @@ export class MappingExecutionRelationalInputDataState extends MappingExecutionIn
     );
   }
 
-  buildInputDataForTest(): InputData {
+  buildInputDataForTest(): DEPRECATED__InputData {
     return new RelationalInputData(
       PackageableElementExplicitReference.create(
         guaranteeNonNullable(this.inputData.database.value),
@@ -664,7 +664,7 @@ export class MappingExecutionState extends MappingEditorTabState {
         this.executionResultText
       ) {
         const inputData = this.inputDataState.buildInputDataForTest();
-        const assert = new ExpectedOutputMappingTestAssert(
+        const assert = new DEPRECATED__ExpectedOutputMappingTestAssert(
           toGrammarString(this.executionResultText),
         );
         const mappingTest = new DEPRECATED__MappingTest(

package/src/stores/editor/editor-state/element-editor-state/mapping/{DEPRECATED__MappingTestState.ts → legacy/DEPRECATED__MappingTestState.ts}

@@ -17,7 +17,7 @@
 import type {
   MappingEditorState,
   MappingElementSource,
-} from './MappingEditorState.js';
+} from '../MappingEditorState.js';
 import {
   type GeneratorFn,
   LogEvent,
@@ -39,22 +39,22 @@ import {
   ContentType,
   StopWatch,
 } from '@finos/legend-shared';
-import type { EditorStore } from '../../../EditorStore.js';
+import type { EditorStore } from '../../../../EditorStore.js';
 import { observable, flow, action, makeObservable, flowResult } from 'mobx';
-import { createMockDataForMappingElementSource } from '../../../utils/MockDataUtils.js';
+import { createMockDataForMappingElementSource } from '../../../../utils/MockDataUtils.js';
 import {
   type RawLambda,
   type Runtime,
-  type InputData,
-  type MappingTestAssert,
+  type DEPRECATED__InputData,
+  type DEPRECATED__MappingTestAssert,
   type Mapping,
   type ExecutionResult,
   extractExecutionResultValues,
   GRAPH_MANAGER_EVENT,
   LAMBDA_PIPE,
   Class,
-  ExpectedOutputMappingTestAssert,
-  ObjectInputData,
+  DEPRECATED__ExpectedOutputMappingTestAssert,
+  DEPRECATED__ObjectInputData,
   ObjectInputType,
   IdentifiedConnection,
   EngineRuntime,
@@ -81,7 +81,7 @@ import {
   reportGraphAnalytics,
 } from '@finos/legend-graph';
 import { DEFAULT_TAB_SIZE } from '@finos/legend-application';
-import { flatData_setData } from '../../../../graph-modifier/STO_FlatData_GraphModifierHelper.js';
+import { flatData_setData } from '../../../../../graph-modifier/STO_FlatData_GraphModifierHelper.js';
 import {
   expectedOutputMappingTestAssert_setExpectedOutput,
   mappingTest_setAssert,
@@ -89,19 +89,19 @@ import {
   objectInputData_setData,
   runtime_addIdentifiedConnection,
   runtime_addMapping,
-} from '../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
+} from '../../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
 import {
   localH2DatasourceSpecification_setTestDataSetupCsv,
   localH2DatasourceSpecification_setTestDataSetupSqls,
   relationalInputData_setData,
-} from '../../../../graph-modifier/STO_Relational_GraphModifierHelper.js';
+} from '../../../../../graph-modifier/STO_Relational_GraphModifierHelper.js';
 import {
   LambdaEditorState,
   QueryBuilderTelemetryHelper,
   QUERY_BUILDER_EVENT,
   ExecutionPlanState,
 } from '@finos/legend-query-builder';
-import { MappingEditorTabState } from './MappingTabManagerState.js';
+import { MappingEditorTabState } from '../MappingTabManagerState.js';
 
 export enum TEST_RESULT {
   NONE = 'NONE', // test has not run yet
@@ -194,12 +194,12 @@ abstract class MappingTestInputDataState {
   readonly uuid = uuid();
   editorStore: EditorStore;
   mapping: Mapping;
-  inputData: InputData;
+  inputData: DEPRECATED__InputData;
 
   constructor(
     editorStore: EditorStore,
     mapping: Mapping,
-    inputData: InputData,
+    inputData: DEPRECATED__InputData,
   ) {
     this.editorStore = editorStore;
     this.mapping = mapping;
@@ -210,7 +210,7 @@ abstract class MappingTestInputDataState {
 }
 
 export class MappingTestObjectInputDataState extends MappingTestInputDataState {
-  declare inputData: ObjectInputData;
+  declare inputData: DEPRECATED__ObjectInputData;
   /**
    * @workaround https://github.com/finos/legend-studio/issues/68
    */
@@ -219,7 +219,7 @@ export class MappingTestObjectInputDataState extends MappingTestInputDataState {
   constructor(
     editorStore: EditorStore,
     mapping: Mapping,
-    inputData: ObjectInputData,
+    inputData: DEPRECATED__ObjectInputData,
   ) {
     super(editorStore, mapping, inputData);
 
@@ -353,21 +353,21 @@ export class MappingTestRelationalInputDataState extends MappingTestInputDataSta
 
 abstract class MappingTestAssertionState {
   readonly uuid = uuid();
-  assert: MappingTestAssert;
+  assert: DEPRECATED__MappingTestAssert;
 
-  constructor(assert: MappingTestAssert) {
+  constructor(assert: DEPRECATED__MappingTestAssert) {
     this.assert = assert;
   }
 }
 
 export class MappingTestExpectedOutputAssertionState extends MappingTestAssertionState {
-  declare assert: ExpectedOutputMappingTestAssert;
+  declare assert: DEPRECATED__ExpectedOutputMappingTestAssert;
   /**
    * @workaround https://github.com/finos/legend-studio/issues/68
    */
   expectedResult: string;
 
-  constructor(assert: ExpectedOutputMappingTestAssert) {
+  constructor(assert: DEPRECATED__ExpectedOutputMappingTestAssert) {
     super(assert);
 
     makeObservable(this, {
@@ -399,6 +399,7 @@ export enum MAPPING_TEST_EDITOR_TAB_TYPE {
   SETUP = 'Test Setup',
   RESULT = 'Test Result',
 }
+
 /**
  * TODO: Remove once migration from `MappingTest_Legacy` to `MappingTest` is complete
  * @deprecated
@@ -513,7 +514,7 @@ export class DEPRECATED__MappingTestState extends MappingEditorTabState {
       'Mapping test input data must contain at least one item',
     );
     const inputData = this.test.inputData[0];
-    if (inputData instanceof ObjectInputData) {
+    if (inputData instanceof DEPRECATED__ObjectInputData) {
       return new MappingTestObjectInputDataState(
         this.editorStore,
         this.mappingEditorState.mapping,
@@ -540,7 +541,7 @@ export class DEPRECATED__MappingTestState extends MappingEditorTabState {
 
   buildAssertionState(): MappingTestAssertionState {
     const testAssertion = this.test.assert;
-    if (testAssertion instanceof ExpectedOutputMappingTestAssert) {
+    if (testAssertion instanceof DEPRECATED__ExpectedOutputMappingTestAssert) {
       return new MappingTestExpectedOutputAssertionState(testAssertion);
     }
     throw new UnsupportedOperationError(
@@ -584,7 +585,7 @@ export class DEPRECATED__MappingTestState extends MappingEditorTabState {
       const newInputDataState = new MappingTestObjectInputDataState(
         this.editorStore,
         this.mappingEditorState.mapping,
-        new ObjectInputData(
+        new DEPRECATED__ObjectInputData(
           PackageableElementExplicitReference.create(source ?? stub_Class()),
           ObjectInputType.JSON,
           tryToMinifyJSONString('{}'),