@finos/legend-application-studio 25.0.7 → 26.0.0

package/src/stores/editor/ExplorerTreeState.ts

@@ -48,8 +48,10 @@ import {
   getElementRootPackage,
   isDependencyElement,
   type Class,
+  type RelationalDatabaseConnection,
 } from '@finos/legend-graph';
 import { APPLICATION_EVENT } from '@finos/legend-application';
+import { DatabaseBuilderState } from './editor-state/element-editor-state/connection/DatabaseBuilderState.js';
 
 export enum ExplorerTreeRootPackageLabel {
   FILE_GENERATION = 'generated-files',
@@ -73,6 +75,7 @@ export class ExplorerTreeState {
 
   elementToRename?: PackageableElement | undefined;
   classToGenerateSampleData?: Class | undefined;
+  databaseBuilderState: DatabaseBuilderState | undefined;
 
   constructor(editorStore: EditorStore) {
     makeObservable(this, {
@@ -85,6 +88,7 @@ export class ExplorerTreeState {
       selectedNode: observable.ref,
       elementToRename: observable,
       classToGenerateSampleData: observable,
+      databaseBuilderState: observable,
       setTreeData: action,
       setGenerationTreeData: action,
       setSystemTreeData: action,
@@ -99,6 +103,8 @@ export class ExplorerTreeState {
       buildTreeInTextMode: action,
       openExplorerTreeNodes: action,
       reprocess: action,
+      buildDbBuilderState: action,
+      setDatabaseBuilderState: action,
       onTreeNodeSelect: action,
       openNode: action,
     });
@@ -170,6 +176,22 @@ export class ExplorerTreeState {
     this.classToGenerateSampleData = val;
   }
 
+  setDatabaseBuilderState(val: DatabaseBuilderState | undefined): void {
+    this.databaseBuilderState = val;
+  }
+  buildDbBuilderState(
+    val: RelationalDatabaseConnection,
+    isReadOnly: boolean,
+  ): void {
+    const dbBuilderState = new DatabaseBuilderState(
+      this.editorStore,
+      val,
+      isReadOnly,
+    );
+    dbBuilderState.setShowModal(true);
+    this.setDatabaseBuilderState(dbBuilderState);
+  }
+
   setSelectedNode(node: PackageTreeNodeData | undefined): void {
     if (this.selectedNode) {
       this.selectedNode.isSelected = false;

package/src/stores/editor/GraphEditGrammarModeState.ts

@@ -26,6 +26,7 @@ import {
   GraphBuilderError,
   type GraphManagerOperationReport,
   reportGraphAnalytics,
+  type SourceInformation,
 } from '@finos/legend-graph';
 import {
   type GeneratorFn,
@@ -55,19 +56,11 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     super(editorStore);
     makeObservable(this, {
       grammarTextEditorState: observable,
-      setGraphGrammar: flow,
-      setGraphGrammarFromEntites: flow,
       compileText: flow,
     });
     this.grammarTextEditorState = new GrammarTextEditorState(this.editorStore);
   }
 
-  async computeEntitiesFromCurrentGrammar(): Promise<Entity[]> {
-    return this.editorStore.graphManagerState.graphManager.pureCodeToEntities(
-      this.grammarTextEditorState.graphGrammarText,
-    );
-  }
-
   *initialize(isFallback?: boolean): GeneratorFn<void> {
     this.editorStore.localChangesState = new TextLocalChangesState(
       this.editorStore,
@@ -76,9 +69,21 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     this.editorStore.graphState.clearProblems();
     this.editorStore.changeDetectionState.stop();
     try {
+      const sourceInformationIndex = new Map<string, SourceInformation>();
+      const entities =
+        (yield this.editorStore.graphManagerState.graphManager.pureCodeToEntities(
+          this.grammarTextEditorState.graphGrammarText,
+          {
+            sourceInformationIndex,
+          },
+        )) as Entity[];
+      this.grammarTextEditorState.setSourceInformationIndex(
+        sourceInformationIndex,
+      );
+
       yield flowResult(
         this.editorStore.changeDetectionState.computeLocalChangesInTextMode(
-          (yield this.computeEntitiesFromCurrentGrammar()) as Entity[],
+          entities,
         ),
       );
     } catch (error) {
@@ -100,32 +105,19 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     if (
       this.editorStore.tabManagerState.currentTab instanceof ElementEditorState
     ) {
-      this.grammarTextEditorState.setCurrentElementLabelRegexString(
-        this.editorStore.tabManagerState.currentTab.element,
-      );
+      const sourceInformation =
+        this.grammarTextEditorState.sourceInformationIndex.get(
+          this.editorStore.tabManagerState.currentTab.element.path,
+        );
+      if (sourceInformation) {
+        this.grammarTextEditorState.setForcedCursorPosition({
+          lineNumber: sourceInformation.startLine,
+          column: 0,
+        });
+      }
     }
   }
 
-  *setGraphGrammarFromEntites(entities: Entity[]): GeneratorFn<void> {
-    const editorGrammar =
-      (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
-        entities,
-      )) as string;
-    yield flowResult(
-      this.grammarTextEditorState.setGraphGrammarText(editorGrammar),
-    );
-  }
-
-  *setGraphGrammar(): GeneratorFn<void> {
-    const graphGrammar =
-      (yield this.editorStore.graphManagerState.graphManager.graphToPureCode(
-        this.editorStore.graphManagerState.graph,
-      )) as string;
-    yield flowResult(
-      this.grammarTextEditorState.setGraphGrammarText(graphGrammar),
-    );
-  }
-
   *compileText(
     options?: {
       onError?: () => void;
@@ -324,6 +316,9 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
           }
         }
       }
+      this.grammarTextEditorState.setSourceInformationIndex(
+        compilationResult.sourceInformationIndex,
+      );
 
       yield flowResult(this.updateGraphAndApplication(entities));
 
@@ -492,21 +487,36 @@ export class GraphEditGrammarModeState extends GraphEditorMode {
     isGraphBuildFailure?: boolean;
   }): GeneratorFn<void> {
     if (fallbackOptions?.isGraphBuildFailure) {
-      yield flowResult(
-        this.setGraphGrammarFromEntites(
+      const editorGrammar =
+        (yield this.editorStore.graphManagerState.graphManager.entitiesToPureCode(
           this.editorStore.changeDetectionState
             .workspaceLocalLatestRevisionState.entities,
-        ),
+          { pretty: true },
+        )) as string;
+      yield flowResult(
+        this.grammarTextEditorState.setGraphGrammarText(editorGrammar),
       );
     } else {
-      yield flowResult(this.setGraphGrammar());
+      const graphGrammar =
+        (yield this.editorStore.graphManagerState.graphManager.graphToPureCode(
+          this.editorStore.graphManagerState.graph,
+          { pretty: true },
+        )) as string;
+      yield flowResult(
+        this.grammarTextEditorState.setGraphGrammarText(graphGrammar),
+      );
     }
     this.editorStore.applicationStore.alertService.setBlockingAlert(undefined);
   }
 
   openElement(element: PackageableElement): void {
-    // in text mode, we want to select the block of code that corresponds to the element if possible
-    // the cheap way to do this is to search by element label text, e.g. `Mapping some::package::someMapping`
-    this.grammarTextEditorState.setCurrentElementLabelRegexString(element);
+    const sourceInformation =
+      this.grammarTextEditorState.sourceInformationIndex.get(element.path);
+    if (sourceInformation) {
+      this.grammarTextEditorState.setForcedCursorPosition({
+        lineNumber: sourceInformation.startLine,
+        column: 0,
+      });
+    }
   }
 }

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

@@ -16,75 +16,28 @@
 
 import type { EditorStore } from '../EditorStore.js';
 import { action, makeObservable, observable } from 'mobx';
-import { hashValue, UnsupportedOperationError } from '@finos/legend-shared';
-import {
-  type PackageableElement,
-  Profile,
-  Enumeration,
-  Class,
-  Association,
-  Mapping,
-  ConcreteFunctionDefinition,
-  Service,
-  FlatData,
-  PackageableConnection,
-  PackageableRuntime,
-  JsonModelConnection,
-  XmlModelConnection,
-  FlatDataConnection,
-  FileGenerationSpecification,
-  GenerationSpecification,
-  Measure,
-  Database,
-  RelationalDatabaseConnection,
-  DataElement,
-  ModelChainConnection,
-  PURE_ELEMENT_NAME,
-  PURE_CONNECTION_NAME,
-  ExecutionEnvironmentInstance,
-} from '@finos/legend-graph';
-import { generatePackageableElementTreeNodeDataLabel } from '../utils/PackageTreeUtils.js';
+import { hashValue } from '@finos/legend-shared';
+import { type SourceInformation } from '@finos/legend-graph';
 import { LEGEND_STUDIO_SETTING_KEY } from '../../../__lib__/LegendStudioSetting.js';
 import type { CodeEditorPosition } from '@finos/legend-lego/code-editor';
-import type { DSL_Mapping_LegendStudioApplicationPlugin_Extension } from '../../extensions/DSL_Mapping_LegendStudioApplicationPlugin_Extension.js';
-import type { DSL_LegendStudioApplicationPlugin_Extension } from '../../LegendStudioApplicationPlugin.js';
 
-const getGrammarElementTypeLabelRegexString = (
-  typeLabel: string,
-  elementPath: string,
-): string =>
-  (
-    `^([^\\S\\n])*${typeLabel}` + // start with type label (accounted for spaces, but not newline)
-    `(\\s+<<.*>>)?` + // account for stereotype
-    `(\\s+\\{.*\\})?` + // account for tagged value
-    `\\s+${elementPath
-      .replaceAll('*', '\\*')
-      .replaceAll('(', '\\(')
-      .replaceAll(')', '\\)')
-      .replaceAll('[', '\\[')
-      .replaceAll(']', '\\]')}` + // element path (might contain [],(),*)
-    `[\\s\\n]`
-  ) // account for termination after element path
-    .replace(/\$/g, '\\$'); // replace special character $ by \\$
 export class GrammarTextEditorState {
   readonly editorStore: EditorStore;
 
+  sourceInformationIndex = new Map<string, SourceInformation>();
   graphGrammarText = '';
-  currentElementLabelRegexString?: string | undefined;
   wrapText: boolean;
+
   forcedCursorPosition?: CodeEditorPosition | undefined;
 
   constructor(editorStore: EditorStore) {
     makeObservable(this, {
       graphGrammarText: observable,
-      currentElementLabelRegexString: observable,
       wrapText: observable,
       forcedCursorPosition: observable,
       setGraphGrammarText: action,
       setWrapText: action,
       setForcedCursorPosition: action,
-      resetCurrentElementLabelRegexString: action,
-      setCurrentElementLabelRegexString: action,
     });
 
     this.editorStore = editorStore;
@@ -110,99 +63,7 @@ export class GrammarTextEditorState {
     this.forcedCursorPosition = position;
   }
 
-  resetCurrentElementLabelRegexString(): void {
-    this.currentElementLabelRegexString = undefined;
-  }
-
-  setCurrentElementLabelRegexString(element: PackageableElement): void {
-    let typeLabel: string | undefined;
-    if (element instanceof Class) {
-      typeLabel = PURE_ELEMENT_NAME.CLASS;
-    } else if (element instanceof Association) {
-      typeLabel = PURE_ELEMENT_NAME.ASSOCIATION;
-    } else if (element instanceof Enumeration) {
-      typeLabel = PURE_ELEMENT_NAME.ENUMERATION;
-    } else if (element instanceof Measure) {
-      typeLabel = PURE_ELEMENT_NAME.MEASURE;
-    } else if (element instanceof Profile) {
-      typeLabel = PURE_ELEMENT_NAME.PROFILE;
-    } else if (element instanceof ConcreteFunctionDefinition) {
-      typeLabel = PURE_ELEMENT_NAME.FUNCTION;
-    } else if (element instanceof FlatData) {
-      typeLabel = PURE_ELEMENT_NAME.FLAT_DATA;
-    } else if (element instanceof Database) {
-      typeLabel = PURE_ELEMENT_NAME.DATABASE;
-    } else if (element instanceof Mapping) {
-      typeLabel = PURE_ELEMENT_NAME.MAPPING;
-    } else if (element instanceof Service) {
-      typeLabel = PURE_ELEMENT_NAME.SERVICE;
-    } else if (element instanceof FileGenerationSpecification) {
-      typeLabel = PURE_ELEMENT_NAME.FILE_GENERATION;
-    } else if (element instanceof GenerationSpecification) {
-      typeLabel = PURE_ELEMENT_NAME.GENERATION_SPECIFICATION;
-    } else if (element instanceof PackageableConnection) {
-      if (element.connectionValue instanceof JsonModelConnection) {
-        typeLabel = PURE_CONNECTION_NAME.JSON_MODEL_CONNECTION;
-      } else if (element.connectionValue instanceof XmlModelConnection) {
-        typeLabel = PURE_CONNECTION_NAME.XML_MODEL_CONNECTION;
-      } else if (element.connectionValue instanceof FlatDataConnection) {
-        typeLabel = PURE_CONNECTION_NAME.FLAT_DATA_CONNECTION;
-      } else if (element.connectionValue instanceof ModelChainConnection) {
-        typeLabel = PURE_CONNECTION_NAME.MODEL_CHAIN_CONNECTION;
-      } else if (
-        element.connectionValue instanceof RelationalDatabaseConnection
-      ) {
-        typeLabel = PURE_CONNECTION_NAME.RELATIONAL_DATABASE_CONNECTION;
-      }
-      const extraPureGrammarConnectionLabelers = this.editorStore.pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_Mapping_LegendStudioApplicationPlugin_Extension
-            ).getExtraPureGrammarConnectionLabelers?.() ?? [],
-        );
-      for (const labeler of extraPureGrammarConnectionLabelers) {
-        const _typeLabel = labeler(element.connectionValue);
-        if (_typeLabel) {
-          typeLabel = _typeLabel;
-          break;
-        }
-      }
-    } else if (element instanceof PackageableRuntime) {
-      typeLabel = PURE_ELEMENT_NAME.RUNTIME;
-    } else if (element instanceof DataElement) {
-      typeLabel = PURE_ELEMENT_NAME.DATA_ELEMENT;
-    } else if (element instanceof ExecutionEnvironmentInstance) {
-      typeLabel = PURE_ELEMENT_NAME.EXECUTION_ENVIRONMENT;
-    } else {
-      const extraPureGrammarElementLabelers = this.editorStore.pluginManager
-        .getApplicationPlugins()
-        .flatMap(
-          (plugin) =>
-            (
-              plugin as DSL_LegendStudioApplicationPlugin_Extension
-            ).getExtraPureGrammarElementLabelers?.() ?? [],
-        );
-      for (const labeler of extraPureGrammarElementLabelers) {
-        const _typeLabel = labeler(element);
-        if (_typeLabel) {
-          typeLabel = _typeLabel;
-          break;
-        }
-      }
-    }
-    if (!typeLabel) {
-      throw new UnsupportedOperationError(
-        `Can't construct label for element type in Pure grammar: no compatible labeler available from plugins`,
-        element,
-      );
-    }
-    this.currentElementLabelRegexString = getGrammarElementTypeLabelRegexString(
-      typeLabel,
-      `${element.package?.path}::${generatePackageableElementTreeNodeDataLabel(
-        element,
-      )}`,
-    );
+  setSourceInformationIndex(val: Map<string, SourceInformation>): void {
+    this.sourceInformationIndex = val;
   }
 }

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

@@ -23,7 +23,6 @@ import {
 } from '@finos/legend-shared';
 import { ElementEditorState } from './../ElementEditorState.js';
 import type { STO_Relational_LegendStudioApplicationPlugin_Extension } from '../../../../extensions/STO_Relational_LegendStudioApplicationPlugin_Extension.js';
-import { DatabaseBuilderState } from './DatabaseBuilderState.js';
 import {
   type PackageableElement,
   type Connection,
@@ -119,7 +118,6 @@ export enum CORE_AUTHENTICATION_STRATEGY_TYPE {
 export class RelationalDatabaseConnectionValueState extends ConnectionValueState {
   override connection: RelationalDatabaseConnection;
   selectedTab = RELATIONAL_DATABASE_TAB_TYPE.GENERAL;
-  databaseBuilderState: DatabaseBuilderState;
   postProcessorState: PostProcessorEditorState | undefined;
 
   constructor(
@@ -128,19 +126,15 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
   ) {
     super(editorStore, connection);
     makeObservable(this, {
-      databaseBuilderState: observable,
       selectedTab: observable,
       postProcessorState: observable,
+      selectedDatasourceSpecificationType: computed,
+      selectedAuthenticationStrategyType: computed,
       setSelectedTab: action,
       selectPostProcessor: action,
     });
 
     this.connection = connection;
-
-    this.databaseBuilderState = new DatabaseBuilderState(
-      editorStore,
-      connection,
-    );
   }
 
   selectPostProcessor = (postProcessor: PostProcessor | undefined): void => {
@@ -186,7 +180,7 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
     return `${this.connection.type} connection`;
   }
 
-  get selectedDatasourceSpec(): string {
+  get selectedDatasourceSpecificationType(): string | undefined {
     const spec = this.connection.datasourceSpecification;
     if (spec instanceof StaticDatasourceSpecification) {
       return CORE_DATASOURCE_SPEC_TYPE.STATIC;
@@ -222,10 +216,7 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
         return type;
       }
     }
-    throw new UnsupportedOperationError(
-      `Can't classify datasource specification: no compatible classifer available from plugins`,
-      spec,
-    );
+    return undefined;
   }
 
   changeDatasourceSpec(type: string): void {
@@ -310,7 +301,8 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
       observerContext,
     );
   }
-  get selectedAuth(): string {
+
+  get selectedAuthenticationStrategyType(): string | undefined {
     const auth = this.connection.authenticationStrategy;
     if (auth instanceof DelegatedKerberosAuthenticationStrategy) {
       return CORE_AUTHENTICATION_STRATEGY_TYPE.DELEGATED_KERBEROS;
@@ -355,10 +347,8 @@ export class RelationalDatabaseConnectionValueState extends ConnectionValueState
         return type;
       }
     }
-    throw new UnsupportedOperationError(
-      `Can't classify authentication strategy: no compatible classifier available from plugins`,
-      auth,
-    );
+
+    return undefined;
   }
 
   changeAuthenticationStrategy(type: string): void {

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

@@ -28,14 +28,16 @@ import {
   isNonNullable,
   filterByType,
   ActionState,
+  guaranteeType,
 } from '@finos/legend-shared';
 import { observable, action, makeObservable, flow, flowResult } from 'mobx';
 import { LEGEND_STUDIO_APP_EVENT } from '../../../../../__lib__/LegendStudioEvent.js';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
-  type RelationalDatabaseConnection,
   type Schema,
+  type PackageableElement,
   type Table,
+  RelationalDatabaseConnection,
   DatabaseBuilderInput,
   DatabasePattern,
   TargetDatabase,
@@ -48,10 +50,19 @@ import {
   getSchema,
   getNullableSchema,
   getNullableTable,
+  PackageableConnection,
 } from '@finos/legend-graph';
 import { connection_setStore } from '../../../../graph-modifier/DSL_Mapping_GraphModifierHelper.js';
 import { GraphEditFormModeState } from '../../../GraphEditFormModeState.js';
 
+export const guaranteeRelationalDatabaseConnection = (
+  val: PackageableElement | undefined,
+): RelationalDatabaseConnection =>
+  guaranteeType(
+    guaranteeType(val, PackageableConnection).connectionValue,
+    RelationalDatabaseConnection,
+  );
+
 export abstract class DatabaseBuilderTreeNodeData implements TreeNodeData {
   isOpen?: boolean | undefined;
   id: string;
@@ -108,10 +119,12 @@ export class DatabaseBuilderState {
   isSavingDatabase = false;
   targetDatabasePath: string;
   treeData?: DatabaseBuilderTreeData | undefined;
+  isReadOnly: boolean;
 
   constructor(
     editorStore: EditorStore,
     connection: RelationalDatabaseConnection,
+    isReadOnly: boolean,
   ) {
     makeObservable<
       DatabaseBuilderState,
@@ -140,6 +153,7 @@ export class DatabaseBuilderState {
     this.connection = connection;
     this.editorStore = editorStore;
     this.targetDatabasePath = this.currentDatabase?.path ?? 'store::MyDatabase';
+    this.isReadOnly = isReadOnly;
   }
 
   setShowModal(val: boolean): void {
@@ -578,9 +592,7 @@ export class DatabaseBuilderState {
         const schemas = this.getSchemasFromTreeNode(this.treeData);
         this.updateDatabase(currentDatabase, database, schemas);
         this.editorStore.applicationStore.notificationService.notifySuccess(
-          `Database successfully '${isUpdating ? 'updated' : 'created'}. ${
-            !isUpdating ? 'Recompiling...' : ''
-          }`,
+          `Database successfully '${isUpdating ? 'updated' : 'created'}.`,
         );
         this.fetchSchemaDefinitions();
         if (isUpdating) {
@@ -593,6 +605,7 @@ export class DatabaseBuilderState {
           );
         }
       }
+      this.setShowModal(false);
     } catch (error) {
       assertErrorThrown(error);
       this.editorStore.applicationStore.logService.error(

package/src/stores/editor/editor-state/element-editor-state/data/DataEditorState.ts

@@ -40,13 +40,10 @@ export type EmbeddedDataTypeOption = {
 };
 
 export class EmbeddedDataEditorState {
-  /**
-   * NOTE: used to force component remount on state change
-   */
   readonly uuid = uuid();
-  editorStore: EditorStore;
-  embeddedData: EmbeddedData;
-  embeddedDataState: EmbeddedDataState;
+  readonly editorStore: EditorStore;
+  readonly embeddedData: EmbeddedData;
+  readonly embeddedDataState: EmbeddedDataState;
 
   constructor(editorStore: EditorStore, embeddedData: EmbeddedData) {
     this.editorStore = editorStore;
@@ -59,7 +56,8 @@ export class EmbeddedDataEditorState {
 }
 
 export class PackageableDataEditorState extends ElementEditorState {
-  embeddedDataState: EmbeddedDataEditorState;
+  readonly embeddedDataState: EmbeddedDataEditorState;
+
   selectedTab = DATA_TAB_TYPE.GENERAL;
 
   constructor(editorStore: EditorStore, element: PackageableElement) {

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

@@ -457,6 +457,7 @@ export class DEPRECATED__MappingTestState extends MappingEditorTabState {
       generatePlan: flow,
       regenerateExpectedResult: flow,
       runTest: flow,
+      cancelTest: flow,
       onTestStateOpen: flow,
     });
 
@@ -734,8 +735,13 @@ export class DEPRECATED__MappingTestState extends MappingEditorTabState {
         this.handleResult(result);
       }
     } catch (error) {
-      assertErrorThrown(error);
-      this.handleError(error, promise);
+      // When user cancels the query by calling the cancelQuery api, it will throw an exeuction failure error.
+      // For now, we don't want to notify users about this failure. Therefore we check to ensure the promise is still the same one.
+      // When cancelled the query, we set the queryRunPromise as undefined.
+      if (this.testRunPromise === promise) {
+        assertErrorThrown(error);
+        this.handleError(error, promise);
+      }
     } finally {
       this.isRunningTest = false;
       this.runTime = Date.now() - startTime;
@@ -750,6 +756,22 @@ export class DEPRECATED__MappingTestState extends MappingEditorTabState {
     }
   }
 
+  *cancelTest(): GeneratorFn<void> {
+    this.setIsRunningTest(false);
+    this.setTestRunPromise(undefined);
+    try {
+      yield this.editorStore.graphManagerState.graphManager.cancelUserExecutions(
+        true,
+      );
+    } catch (error) {
+      // don't notify users about success or failure
+      this.editorStore.applicationStore.logService.error(
+        LogEvent.create(GRAPH_MANAGER_EVENT.EXECUTION_FAILURE),
+        error,
+      );
+    }
+  }
+
   handleResult(result: ExecutionResult): void {
     this.testExecutionResultText = stringifyLosslessJSON(
       extractExecutionResultValues(result),

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

@@ -320,7 +320,7 @@ export class EmbeddedFlatDataInstanceSetImplementationState
     });
   }
 
-  // dummy lambda editor states needed because embedded flat-data should be seen as `PropertMappingState`
+  // dummy lambda editor states needed because embedded flat-data should be seen as `PropertyMappingState`
   lambdaPrefix = '';
   lambdaString = '';
   parserError?: ParserError | undefined;

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

@@ -101,6 +101,7 @@ import {
   PrimitiveType,
   type Store,
   ModelStore,
+  INTERNAL__UnknownSetImplementation,
 } from '@finos/legend-graph';
 import type {
   DSL_Mapping_LegendStudioApplicationPlugin_Extension,
@@ -270,7 +271,9 @@ export const getMappingElementSource = (
   mappingElement: MappingElement,
   plugins: LegendStudioApplicationPlugin[],
 ): MappingElementSource | undefined => {
-  if (mappingElement instanceof OperationSetImplementation) {
+  if (mappingElement instanceof INTERNAL__UnknownSetImplementation) {
+    return undefined;
+  } else 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;

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

@@ -64,6 +64,7 @@ import {
   getRawGenericType,
   EnumerationMappingExplicitReference,
   SetImplementationExplicitReference,
+  type INTERNAL__UnknownSetImplementation,
 } from '@finos/legend-graph';
 import type { EditorStore } from '../../../EditorStore.js';
 import {
@@ -141,6 +142,12 @@ export class MappingElementDecorator implements SetImplementationVisitor<void> {
     this.editorStore = editorStore;
   }
 
+  visit_INTERNAL__UnknownSetImplementation(
+    setImplementation: INTERNAL__UnknownSetImplementation,
+  ): void {
+    return;
+  }
+
   visitEnumerationMapping(enumerationMapping: EnumerationMapping): void {
     const enumValueMappingsToAdd: EnumValueMapping[] = [];
     enumerationMapping.enumeration.value.values.forEach((enumValue) => {
@@ -664,6 +671,12 @@ export class MappingElementDecorationCleaner
     this.editorStore = editorStore;
   }
 
+  visit_INTERNAL__UnknownSetImplementation(
+    setImplementation: INTERNAL__UnknownSetImplementation,
+  ): void {
+    return;
+  }
+
   visitEnumerationMapping(enumerationMapping: EnumerationMapping): void {
     // Remove the enum value mapping if all of its source values are empty
     const nonEmptyEnumValueMappings =