@finos/legend-application-studio 22.2.1 → 22.3.1

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

@@ -379,69 +379,70 @@ export interface ServiceExecutionContext {
 }
 
 export abstract class ServiceExecutionContextState {
-  executionContext: ServiceExecutionContext;
   executionState: ServiceExecutionState;
 
-  constructor(
-    executionContext: ServiceExecutionContext,
-    executionState: ServiceExecutionState,
-  ) {
-    this.executionContext = executionContext;
+  constructor(executionState: ServiceExecutionState) {
     this.executionState = executionState;
   }
 
+  abstract get executionContext(): ServiceExecutionContext;
   abstract setMapping(value: Mapping): void;
   abstract setRuntime(value: Runtime): void;
 }
 
 export class SingleExecutionContextState extends ServiceExecutionContextState {
-  declare executionContext1: PureSingleExecution;
+  declare executionState: SingleServicePureExecutionState;
 
-  constructor(
-    executionContext: PureSingleExecution,
-    executionState: ServiceExecutionState,
-  ) {
-    super(
-      {
-        mapping:
-          executionContext.mapping as PackageableElementReference<Mapping>,
-        runtime: executionContext.runtime as Runtime,
-      },
-      executionState,
-    );
-    this.executionContext1 = executionContext;
+  constructor(executionState: SingleServicePureExecutionState) {
+    super(executionState);
     makeObservable(this, {
-      executionContext: observable,
       setMapping: action,
       setRuntime: action,
     });
+    this.executionState = executionState;
   }
 
   setMapping(value: Mapping): void {
-    this.executionContext.mapping =
-      PackageableElementExplicitReference.create(value);
     pureSingleExecution_setMapping(
-      this.executionContext1,
+      this.executionState.execution,
       value,
       this.executionState.editorStore.changeDetectionState.observerContext,
     );
   }
   setRuntime(value: Runtime): void {
-    this.executionContext.runtime = value;
     pureSingleExecution_setRuntime(
-      this.executionContext1,
+      this.executionState.execution,
       value,
       this.executionState.editorStore.changeDetectionState.observerContext,
     );
   }
+
+  get executionContext(): ServiceExecutionContext {
+    return {
+      mapping: guaranteeNonNullable(this.executionState.execution.mapping),
+      runtime: guaranteeNonNullable(this.executionState.execution.runtime),
+    };
+  }
 }
 
 export class KeyedExecutionContextState extends ServiceExecutionContextState {
-  declare executionContext: KeyedExecutionParameter;
+  keyedExecutionParameter: KeyedExecutionParameter;
+
+  constructor(
+    keyedExecutionParameter: KeyedExecutionParameter,
+    executionState: MultiServicePureExecutionState,
+  ) {
+    super(executionState);
+    makeObservable(this, {
+      setMapping: action,
+      setRuntime: action,
+    });
+    this.keyedExecutionParameter = keyedExecutionParameter;
+  }
 
   setMapping(value: Mapping): void {
     pureSingleExecution_setMapping(
-      this.executionContext,
+      this.keyedExecutionParameter,
       value,
       this.executionState.editorStore.changeDetectionState.observerContext,
     );
@@ -449,11 +450,15 @@ export class KeyedExecutionContextState extends ServiceExecutionContextState {
 
   setRuntime(value: Runtime): void {
     pureSingleExecution_setRuntime(
-      this.executionContext,
+      this.keyedExecutionParameter,
       value,
       this.executionState.editorStore.changeDetectionState.observerContext,
     );
   }
+
+  get executionContext(): ServiceExecutionContext {
+    return this.keyedExecutionParameter;
+  }
 }
 
 export abstract class ServicePureExecutionState extends ServiceExecutionState {
@@ -522,7 +527,7 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   };
 
   *generatePlan(debug: boolean): GeneratorFn<void> {
-    if (!this.selectedExecutionContextState || this.isGeneratingPlan) {
+    if (this.isGeneratingPlan) {
       return;
     }
     try {
@@ -533,8 +538,8 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
         const debugResult =
           (yield this.editorStore.graphManagerState.graphManager.debugExecutionPlanGeneration(
             query,
-            this.selectedExecutionContextState.executionContext.mapping.value,
-            this.selectedExecutionContextState.executionContext.runtime,
+            this.selectedExecutionContextState?.executionContext.mapping.value,
+            this.selectedExecutionContextState?.executionContext.runtime,
             this.editorStore.graphManagerState.graph,
           )) as { plan: RawExecutionPlan; debug: string };
         rawPlan = debugResult.plan;
@@ -543,8 +548,8 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
         rawPlan =
           (yield this.editorStore.graphManagerState.graphManager.generateExecutionPlan(
             query,
-            this.selectedExecutionContextState.executionContext.mapping.value,
-            this.selectedExecutionContextState.executionContext.runtime,
+            this.selectedExecutionContextState?.executionContext.mapping.value,
+            this.selectedExecutionContextState?.executionContext.runtime,
             this.editorStore.graphManagerState.graph,
           )) as object;
       }
@@ -571,8 +576,8 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
     }
   }
 
-  *handleExecute(): GeneratorFn<void> {
-    if (!this.selectedExecutionContextState || this.isRunningQuery) {
+  *handleRunQuery(): GeneratorFn<void> {
+    if (this.isRunningQuery) {
       return;
     }
     const query = this.queryState.query;
@@ -585,25 +590,24 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
   }
 
   *runQuery(): GeneratorFn<void> {
-    if (!this.selectedExecutionContextState || this.isRunningQuery) {
+    if (this.isRunningQuery) {
       return;
     }
     try {
       this.isRunningQuery = true;
-      const promise =
-        this.editorStore.graphManagerState.graphManager.executeMapping(
-          this.getExecutionQuery(),
-          this.selectedExecutionContextState.executionContext.mapping.value,
-          this.selectedExecutionContextState.executionContext.runtime,
-          this.editorStore.graphManagerState.graph,
-          {
-            useLosslessParse: true,
-            parameterValues: buildExecutionParameterValues(
-              this.parameterState.parameterStates,
-              this.editorStore.graphManagerState,
-            ),
-          },
-        );
+      const promise = this.editorStore.graphManagerState.graphManager.runQuery(
+        this.getExecutionQuery(),
+        this.selectedExecutionContextState?.executionContext.mapping.value,
+        this.selectedExecutionContextState?.executionContext.runtime,
+        this.editorStore.graphManagerState.graph,
+        {
+          useLosslessParse: true,
+          parameterValues: buildExecutionParameterValues(
+            this.parameterState.parameterStates,
+            this.editorStore.graphManagerState,
+          ),
+        },
+      );
       this.setQueryRunPromise(promise);
       const result = (yield promise) as ExecutionResult;
       if (this.queryRunPromise === promise) {
@@ -679,7 +683,7 @@ export abstract class ServicePureExecutionState extends ServiceExecutionState {
       ),
     );
     decorateRuntimeWithNewMapping(
-      executionState.executionContext.runtime,
+      customRuntime,
       executionState.executionContext.mapping.value,
       this.editorStore,
     );
@@ -734,7 +738,7 @@ export class InlineServicePureExecutionState extends ServicePureExecutionState {
       updateExecutionQuery: action,
       setOpeningQueryEditor: action,
       generatePlan: flow,
-      handleExecute: flow,
+      handleRunQuery: flow,
       runQuery: flow,
     });
     this.selectedExecutionContextState =
@@ -767,6 +771,7 @@ export class SingleServicePureExecutionState extends ServicePureExecutionState {
     makeObservable(this, {
       queryState: observable,
       getInitiallySelectedExecutionContextState: observable,
+      selectedExecutionContextState: observable,
       runtimeEditorState: observable,
       isRunningQuery: observable,
       isGeneratingPlan: observable,
@@ -789,7 +794,7 @@ export class SingleServicePureExecutionState extends ServicePureExecutionState {
       setShowChangeExecModal: action,
       setIsRunningQuery: action,
       generatePlan: flow,
-      handleExecute: flow,
+      handleRunQuery: flow,
       runQuery: flow,
     });
     this.selectedExecutionContextState =
@@ -801,7 +806,7 @@ export class SingleServicePureExecutionState extends ServicePureExecutionState {
   }
 
   getInitiallySelectedExecutionContextState(): ServiceExecutionContextState {
-    return new SingleExecutionContextState(this.execution, this);
+    return new SingleExecutionContextState(this);
   }
 
   setMultiExecutionKey(val: string): void {
@@ -877,7 +882,7 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
       setIsRunningQuery: action,
       changeExecution: action,
       generatePlan: flow,
-      handleExecute: flow,
+      handleRunQuery: flow,
       runQuery: flow,
     });
 

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

@@ -57,7 +57,7 @@ import {
   createMockPrimitiveProperty,
 } from '../../../../shared/MockDataUtils.js';
 import {
-  createRelationalDataFromCSV,
+  TEMPORARY_createRelationalDataFromCSV,
   EmbeddedDataConnectionTypeVisitor,
   getAllIdentifiedConnectionsFromRuntime,
   TEMPORARY_EmbeddedDataConnectionVisitor,
@@ -155,7 +155,7 @@ export class ConnectionTestDataState {
               anonymizeGeneratedData: this.anonymizeGeneratedData,
             },
           )) as string;
-        embeddedData = createRelationalDataFromCSV(value);
+        embeddedData = TEMPORARY_createRelationalDataFromCSV(value);
       } else {
         embeddedData = connection.accept_ConnectionVisitor(
           new TEMPORARY_EmbeddedDataConnectionVisitor(this.editorStore),

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

@@ -24,6 +24,7 @@ import {
   buildLambdaVariableExpressions,
   VariableExpression,
   PureMultiExecution,
+  PureExecution,
 } from '@finos/legend-graph';
 import { action, flow, makeObservable, observable } from 'mobx';
 import { TestableTestEditorState } from '../../testable/TestableEditorState.js';
@@ -183,8 +184,11 @@ export class ServiceTestSetupState {
   }
 
   get serviceQuery(): RawLambda | undefined {
-    return this.testState.suiteState.testableState.serviceEditorState
-      .executionState.serviceExecutionParameters?.query;
+    const execution = this.testState.testable.execution;
+    if (execution instanceof PureExecution) {
+      return execution.func;
+    }
+    return undefined;
   }
 
   get queryVariableExpressions(): VariableExpression[] {

package/src/stores/shared/{FileGenerationTreeUtils.ts → FileSystemTreeUtils.ts}

@@ -25,16 +25,16 @@ import {
   type GenerationOutput,
 } from '@finos/legend-graph';
 
-export interface GenerationOutputResult {
-  generationOutput: GenerationOutput;
+export const GENERATION_FILE_ROOT_NAME = 'GENERATION_FILE_ROOT';
+
+export interface FileResult {
+  value: GenerationOutput;
   parentId?: string | undefined;
 }
-export const GENERATION_FILE_ROOT_NAME = 'GENERATION_FILE_ROOT';
 
-// Generation Directory Model
-class GenerationFileNodeElement {
+class FileSystemElement {
   name: string;
-  directory?: GenerationDirectory | undefined;
+  directory?: FileSystem_Directory | undefined;
   parentId?: string | undefined;
 
   constructor(name: string, fileGenerationParent?: string) {
@@ -53,42 +53,42 @@ class GenerationFileNodeElement {
   }
 }
 
-export class GenerationDirectory extends GenerationFileNodeElement {
-  children: GenerationFileNodeElement[] = [];
+export class FileSystem_Directory extends FileSystemElement {
+  children: FileSystemElement[] = [];
 
-  setDirectory(val: GenerationDirectory): void {
+  setDirectory(val: FileSystem_Directory): void {
     this.directory = val;
   }
-  addChild(val: GenerationFileNodeElement): void {
+  addChild(val: FileSystemElement): void {
     addUniqueEntry(this.children, val);
   }
-  addElement(val: GenerationFileNodeElement): void {
+  addElement(val: FileSystemElement): void {
     this.addChild(val);
     val.directory = this;
   }
 
   static createDirectoryFromParent(
     name: string,
-    parent: GenerationDirectory,
-    fileGenerationParent?: string,
-  ): GenerationDirectory {
-    const newDirectory = new GenerationDirectory(name, fileGenerationParent);
+    parent: FileSystem_Directory,
+    genParent?: string,
+  ): FileSystem_Directory {
+    const newDirectory = new FileSystem_Directory(name, genParent);
     newDirectory.setDirectory(parent);
     return newDirectory;
   }
 
   static getOrCreateDirectory(
-    parent: GenerationDirectory,
+    parent: FileSystem_Directory,
     directoryName: string,
     insert: boolean,
-  ): GenerationDirectory {
+  ): FileSystem_Directory {
     const index = directoryName.indexOf(DIRECTORY_PATH_DELIMITER);
     const str =
       index === -1 ? directoryName : directoryName.substring(0, index);
-    let node: GenerationDirectory | undefined;
+    let node: FileSystem_Directory | undefined;
     node = parent.children.find(
-      (child: GenerationFileNodeElement): child is GenerationDirectory =>
-        child instanceof GenerationDirectory && child.name === str,
+      (child: FileSystemElement): child is FileSystem_Directory =>
+        child instanceof FileSystem_Directory && child.name === str,
     );
     if (!node) {
       if (!insert) {
@@ -97,11 +97,11 @@ export class GenerationDirectory extends GenerationFileNodeElement {
         );
       }
       // create the node if it is not in parent directory
-      node = GenerationDirectory.createDirectoryFromParent(str, parent);
+      node = FileSystem_Directory.createDirectoryFromParent(str, parent);
       parent.addChild(node);
     }
     if (index !== -1) {
-      return GenerationDirectory.getOrCreateDirectory(
+      return FileSystem_Directory.getOrCreateDirectory(
         node,
         directoryName.substring(index + DIRECTORY_PATH_DELIMITER.length),
         insert,
@@ -121,7 +121,7 @@ export class GenerationDirectory extends GenerationFileNodeElement {
   }
 }
 
-export class GenerationFile extends GenerationFileNodeElement {
+export class FileSystem_File extends FileSystemElement {
   content!: string;
   format?: string | undefined;
 
@@ -137,31 +137,31 @@ export class GenerationFile extends GenerationFileNodeElement {
   }
 }
 
-// Generation Tree Node
-export interface GenerationTreeNodeData extends TreeNodeData {
-  fileNode: GenerationFileNodeElement;
+// Tree Node
+export interface FileSystemTreeNodeData extends TreeNodeData {
+  fileNode: FileSystemElement;
 }
 
-export const getGenerationTreeNodeData = (
-  fileNode: GenerationFileNodeElement,
-): GenerationTreeNodeData => ({
+export const getFileSystemTreeNodeData = (
+  fileNode: FileSystemElement,
+): FileSystemTreeNodeData => ({
   id: fileNode.path,
   label: fileNode.name,
   childrenIds:
-    fileNode instanceof GenerationDirectory
+    fileNode instanceof FileSystem_Directory
       ? fileNode.children.map((child) => child.path)
       : undefined,
   fileNode: fileNode,
 });
 
 export const populateDirectoryTreeNodeChildren = (
-  node: GenerationTreeNodeData,
-  treeData: TreeData<GenerationTreeNodeData>,
+  node: FileSystemTreeNodeData,
+  treeData: TreeData<FileSystemTreeNodeData>,
 ): void => {
-  if (node.childrenIds && node.fileNode instanceof GenerationDirectory) {
+  if (node.childrenIds && node.fileNode instanceof FileSystem_Directory) {
     node.childrenIds = node.fileNode.children.map((child) => child.path);
     node.fileNode.children
-      .map((child) => getGenerationTreeNodeData(child))
+      .map((child) => getFileSystemTreeNodeData(child))
       .forEach((childNode) => {
         const currentNode = treeData.nodes.get(childNode.id);
         if (currentNode) {
@@ -174,14 +174,14 @@ export const populateDirectoryTreeNodeChildren = (
   }
 };
 
-export const getGenerationTreeData = (
-  dir: GenerationDirectory,
+export const getFileSystemTreeData = (
+  dir: FileSystem_Directory,
   rootWrapperName?: string,
-): TreeData<GenerationTreeNodeData> => {
+): TreeData<FileSystemTreeNodeData> => {
   const rootIds: string[] = [];
-  const nodes = new Map<string, GenerationTreeNodeData>();
+  const nodes = new Map<string, FileSystemTreeNodeData>();
   if (rootWrapperName) {
-    const rootNode = getGenerationTreeNodeData(dir);
+    const rootNode = getFileSystemTreeNodeData(dir);
     rootNode.label = rootWrapperName;
     addUniqueEntry(rootIds, rootNode.id);
     nodes.set(rootNode.id, rootNode);
@@ -191,11 +191,11 @@ export const getGenerationTreeData = (
       .sort((a, b) => a.name.localeCompare(b.name))
       .sort(
         (a, b) =>
-          (b instanceof GenerationDirectory ? 1 : 0) -
-          (a instanceof GenerationDirectory ? 1 : 0),
+          (b instanceof FileSystem_Directory ? 1 : 0) -
+          (a instanceof FileSystem_Directory ? 1 : 0),
       )
       .forEach((childDirectory) => {
-        const childTreeNodeData = getGenerationTreeNodeData(childDirectory);
+        const childTreeNodeData = getFileSystemTreeNodeData(childDirectory);
         addUniqueEntry(rootIds, childTreeNodeData.id);
         nodes.set(childTreeNodeData.id, childTreeNodeData);
       });
@@ -204,11 +204,11 @@ export const getGenerationTreeData = (
 };
 
 export const addNode = (
-  element: GenerationFileNodeElement,
-  treeData: TreeData<GenerationTreeNodeData>,
+  element: FileSystemElement,
+  treeData: TreeData<FileSystemTreeNodeData>,
   showRoot?: boolean,
-): GenerationTreeNodeData => {
-  const newNode = getGenerationTreeNodeData(element);
+): FileSystemTreeNodeData => {
+  const newNode = getFileSystemTreeNodeData(element);
   treeData.nodes.set(newNode.id, newNode);
   if (
     !element.directory ||
@@ -227,28 +227,28 @@ export const addNode = (
 };
 
 export const openNode = (
-  element: GenerationFileNodeElement,
-  treeData: TreeData<GenerationTreeNodeData>,
+  element: FileSystemElement,
+  treeData: TreeData<FileSystemTreeNodeData>,
   showRoot?: boolean,
-): GenerationTreeNodeData | undefined => {
+): FileSystemTreeNodeData | undefined => {
   let currentElement = element;
-  let openingNode: GenerationTreeNodeData | undefined;
+  let openingNode: FileSystemTreeNodeData | undefined;
   while (currentElement.directory) {
-    const node: GenerationTreeNodeData =
+    const node: FileSystemTreeNodeData =
       treeData.nodes.get(currentElement.path) ??
       addNode(currentElement, treeData, showRoot);
-    node.isOpen = currentElement instanceof GenerationDirectory;
+    node.isOpen = currentElement instanceof FileSystem_Directory;
     openingNode = !openingNode ? node : openingNode;
     currentElement = currentElement.directory;
   }
   return openingNode;
 };
 
-export const getFileGenerationChildNodes = (
-  node: GenerationTreeNodeData,
-  treeData: TreeData<GenerationTreeNodeData>,
-): GenerationTreeNodeData[] => {
-  if (node.childrenIds && node.fileNode instanceof GenerationDirectory) {
+export const getFileSystemChildNodes = (
+  node: FileSystemTreeNodeData,
+  treeData: TreeData<FileSystemTreeNodeData>,
+): FileSystemTreeNodeData[] => {
+  if (node.childrenIds && node.fileNode instanceof FileSystem_Directory) {
     populateDirectoryTreeNodeChildren(node, treeData);
     return node.childrenIds
       .map((id) => treeData.nodes.get(id))
@@ -256,21 +256,21 @@ export const getFileGenerationChildNodes = (
       .sort((a, b) => a.label.localeCompare(b.label))
       .sort(
         (a, b) =>
-          (b.fileNode instanceof GenerationDirectory ? 1 : 0) -
-          (a.fileNode instanceof GenerationDirectory ? 1 : 0),
+          (b.fileNode instanceof FileSystem_Directory ? 1 : 0) -
+          (a.fileNode instanceof FileSystem_Directory ? 1 : 0),
       );
   }
   return [];
 };
 
-export const buildGenerationDirectory = (
-  rootDirectory: GenerationDirectory,
-  generationResultIndex: Map<string, GenerationOutputResult>,
-  filesIndex: Map<string, GenerationFile>,
+export const buildFileSystemDirectory = (
+  rootDirectory: FileSystem_Directory,
+  filesResultIndex: Map<string, FileResult>,
+  filesIndex: Map<string, FileSystem_File>,
 ): void => {
-  Array.from(generationResultIndex.values()).forEach((generationFileInfo) => {
-    const generationOutput = generationFileInfo.generationOutput;
-    const filePath = generationOutput.fileName;
+  Array.from(filesResultIndex.values()).forEach((fileResult) => {
+    const resultValue = fileResult.value;
+    const filePath = resultValue.fileName;
     const index = filePath.lastIndexOf(DIRECTORY_PATH_DELIMITER);
     const fileName =
       index === -1
@@ -283,22 +283,23 @@ export const buildGenerationDirectory = (
       index === -1 ? undefined : filePath.substring(0, index);
     let directory = rootDirectory;
     if (directoryName) {
-      directory = GenerationDirectory.getOrCreateDirectory(
+      directory = FileSystem_Directory.getOrCreateDirectory(
         rootDirectory,
         directoryName,
         true,
       );
     }
-    const file = new GenerationFile(
+    const file = new FileSystem_File(
       fileName,
-      generationOutput.content,
-      generationFileInfo.generationOutput.format,
-      generationFileInfo.parentId,
+      resultValue.content,
+      fileResult.value.format,
+      fileResult.parentId,
     );
     directory.addElement(file);
     filesIndex.set(filePath, file);
   });
 };
+
 const openNodeById = (
   id: string,
   treeData: TreeData<TreeNodeData> | undefined,
@@ -312,19 +313,19 @@ const openNodeById = (
 };
 
 export const reprocessOpenNodes = (
-  treeData: TreeData<GenerationTreeNodeData>,
-  filesIndex: Map<string, GenerationFile>,
-  rootDirectory: GenerationDirectory,
+  treeData: TreeData<FileSystemTreeNodeData>,
+  filesIndex: Map<string, FileSystem_File>,
+  rootDirectory: FileSystem_Directory,
   openedNodeIds: string[],
   showRoot?: boolean,
 ): void => {
   const openNodeElement = (
     elementPath: string,
-  ): GenerationTreeNodeData | undefined => {
+  ): FileSystemTreeNodeData | undefined => {
     const element =
       filesIndex.get(elementPath) ??
       returnUndefOnError(() =>
-        GenerationDirectory.getOrCreateDirectory(
+        FileSystem_Directory.getOrCreateDirectory(
           rootDirectory,
           elementPath,
           false,