@finos/legend-application-studio 28.1.3 → 28.2.0

package/src/components/editor/editor-group/service-editor/ServiceExecutionQueryEditor.tsx

@@ -36,7 +36,6 @@ import { assertErrorThrown } from '@finos/legend-shared';
 import { flowResult } from 'mobx';
 import { useEditorStore } from '../../EditorStoreProvider.js';
 import {
-  isStubbed_PackageableElement,
   isStubbed_RawLambda,
   KeyedExecutionParameter,
 } from '@finos/legend-graph';
@@ -115,91 +114,78 @@ export const ServiceExecutionQueryEditor = observer(
       applicationStore.guardUnhandledError(async () => {
         const selectedExecutionState =
           executionState.selectedExecutionContextState;
-        if (selectedExecutionState?.executionContext.mapping === undefined) {
-          applicationStore.notificationService.notifyError(
-            'Editing query without runtime and mapping is unsupported via query builder, please leverage the text mode to edit query',
-          );
-          executionState.setOpeningQueryEditor(false);
-        } else {
-          const mapping = selectedExecutionState.executionContext.mapping.value;
-          if (!isStubbed_PackageableElement(mapping)) {
-            await flowResult(
-              embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration({
-                setupQueryBuilderState: (): QueryBuilderState => {
-                  const queryBuilderState = new ServiceQueryBuilderState(
-                    embeddedQueryBuilderState.editorStore.applicationStore,
-                    embeddedQueryBuilderState.editorStore.graphManagerState,
-                    service,
-                    undefined,
-                    selectedExecutionState.executionContext instanceof
-                    KeyedExecutionParameter
-                      ? selectedExecutionState.executionContext.key
-                      : undefined,
+
+        await flowResult(
+          embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration({
+            setupQueryBuilderState: (): QueryBuilderState => {
+              const queryBuilderState = new ServiceQueryBuilderState(
+                embeddedQueryBuilderState.editorStore.applicationStore,
+                embeddedQueryBuilderState.editorStore.graphManagerState,
+                service,
+                undefined,
+                selectedExecutionState?.executionContext instanceof
+                KeyedExecutionParameter
+                  ? selectedExecutionState.executionContext.key
+                  : undefined,
+              );
+              queryBuilderState.initializeWithQuery(
+                executionState.execution.func,
+              );
+              if (openInTextMode) {
+                queryBuilderState.textEditorState.openModal(
+                  QueryBuilderTextEditorMode.TEXT,
+                );
+              }
+              return queryBuilderState;
+            },
+            actionConfigs: [
+              {
+                key: 'save-query-btn',
+                renderer: (
+                  queryBuilderState: QueryBuilderState,
+                ): React.ReactNode => {
+                  const save = applicationStore.guardUnhandledError(
+                    async () => {
+                      try {
+                        const rawLambda = queryBuilderState.buildQuery();
+                        await flowResult(
+                          executionState.queryState.updateLamba(rawLambda),
+                        );
+                        applicationStore.notificationService.notifySuccess(
+                          `Service query is updated`,
+                        );
+                        embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration(
+                          undefined,
+                        );
+                      } catch (error) {
+                        assertErrorThrown(error);
+                        applicationStore.notificationService.notifyError(
+                          `Can't save query: ${error.message}`,
+                        );
+                      }
+                    },
                   );
-                  queryBuilderState.initializeWithQuery(
-                    executionState.execution.func,
+
+                  return (
+                    <button
+                      className="query-builder__dialog__header__custom-action"
+                      tabIndex={-1}
+                      disabled={isReadOnly}
+                      onClick={save}
+                    >
+                      Save Query
+                    </button>
                   );
-                  if (openInTextMode) {
-                    queryBuilderState.textEditorState.openModal(
-                      QueryBuilderTextEditorMode.TEXT,
-                    );
-                  }
-                  return queryBuilderState;
                 },
-                actionConfigs: [
-                  {
-                    key: 'save-query-btn',
-                    renderer: (
-                      queryBuilderState: QueryBuilderState,
-                    ): React.ReactNode => {
-                      const save = applicationStore.guardUnhandledError(
-                        async () => {
-                          try {
-                            const rawLambda = queryBuilderState.buildQuery();
-                            await flowResult(
-                              executionState.queryState.updateLamba(rawLambda),
-                            );
-                            applicationStore.notificationService.notifySuccess(
-                              `Service query is updated`,
-                            );
-                            embeddedQueryBuilderState.setEmbeddedQueryBuilderConfiguration(
-                              undefined,
-                            );
-                          } catch (error) {
-                            assertErrorThrown(error);
-                            applicationStore.notificationService.notifyError(
-                              `Can't save query: ${error.message}`,
-                            );
-                          }
-                        },
-                      );
-
-                      return (
-                        <button
-                          className="query-builder__dialog__header__custom-action"
-                          tabIndex={-1}
-                          disabled={isReadOnly}
-                          onClick={save}
-                        >
-                          Save Query
-                        </button>
-                      );
-                    },
-                  },
-                ],
-                disableCompile: isStubbed_RawLambda(
-                  executionState.queryState.query,
-                ),
-              }),
-            );
-            executionState.setOpeningQueryEditor(false);
-            return;
-          }
-          applicationStore.notificationService.notifyWarning(
-            'Please specify a mapping and a runtime for the execution context to edit with query builder',
-          );
-          executionState.setOpeningQueryEditor(false);
-        }
+              },
+            ],
+            disableCompile: isStubbed_RawLambda(
+              executionState.queryState.query,
+            ),
+          }),
+        );
+        executionState.setOpeningQueryEditor(false);
+        return;
       });
 
     const importQuery = (): void =>

package/src/components/editor/editor-group/uml-editor/ClassQueryBuilder.tsx

@@ -68,11 +68,11 @@ const promoteQueryToService = async (
   const applicationStore = editorStore.applicationStore;
   try {
     const mapping = guaranteeNonNullable(
-      queryBuilderState.mapping,
+      queryBuilderState.executionContextState.mapping,
       'Mapping is required to create service execution',
     );
     const runtime = guaranteeNonNullable(
-      queryBuilderState.runtimeValue,
+      queryBuilderState.executionContextState.runtimeValue,
       'Runtime is required to create service execution',
     );
     const query = queryBuilderState.buildQuery();
@@ -269,15 +269,15 @@ const PromoteToServiceQueryBuilderAction = observer(
       setPromoteQueryType(type);
     const closeNewServiceModal = (): void => setPromoteQueryType(undefined);
     const allowPromotion = Boolean(
-      queryBuilderState.mapping &&
-        queryBuilderState.runtimeValue &&
+      queryBuilderState.executionContextState.mapping &&
+        queryBuilderState.executionContextState.runtimeValue &&
         !queryBuilderState.allValidationIssues.length,
     );
 
     const renderSaveAsModal = (): React.ReactNode => {
       if (
         promoteQueryModal === PROMOTE_QUERY_TYPE.SERVICE &&
-        queryBuilderState.mapping
+        queryBuilderState.executionContextState.mapping
       ) {
         const promoteToService = async (
           packagePath: string,
@@ -295,7 +295,7 @@ const PromoteToServiceQueryBuilderAction = observer(
 
         return (
           <NewServiceModal
-            mapping={queryBuilderState.mapping}
+            mapping={queryBuilderState.executionContextState.mapping}
             close={closeNewServiceModal}
             showModal={true}
             promoteToService={promoteToService}

package/src/components/editor/side-bar/Explorer.tsx

@@ -698,7 +698,7 @@ const ExplorerContextMenu = observer(
         editorStore.projectConfigurationEditorState.projectConfiguration?.projectDependencies.find(
           (dep) => dep.projectId === node?.packageableElement.name,
         );
-      if (projectDependency && !projectDependency.isLegacyDependency) {
+      if (projectDependency) {
         applicationStore.navigationService.navigator.visitAddress(
           applicationStore.navigationService.navigator.generateAddress(
             generateViewProjectByGAVRoute(

package/src/stores/editor/EditorGraphState.ts

@@ -42,11 +42,7 @@ import { ElementEditorState } from './editor-state/element-editor-state/ElementE
 import { GraphGenerationState } from './editor-state/GraphGenerationState.js';
 import { MODEL_IMPORT_NATIVE_INPUT_TYPE } from './editor-state/ModelImporterState.js';
 import type { DSL_LegendStudioApplicationPlugin_Extension } from '../LegendStudioApplicationPlugin.js';
-import {
-  type Entity,
-  EntitiesWithOrigin,
-  generateGAVCoordinates,
-} from '@finos/legend-storage';
+import { type Entity, EntitiesWithOrigin } from '@finos/legend-storage';
 import {
   type EntityChange,
   type ProjectDependency,
@@ -59,7 +55,6 @@ import {
   ProjectDependencyCoordinates,
   RawProjectDependencyReport,
   buildDependencyReport,
-  StoreProjectData,
 } from '@finos/legend-server-depot';
 import {
   GRAPH_MANAGER_EVENT,
@@ -752,53 +747,15 @@ export class EditorGraphState {
     projectDependencies: ProjectDependency[],
   ): Promise<ProjectDependencyCoordinates[]> {
     return Promise.all(
-      projectDependencies.map(async (dep) => {
-        /**
-         * We expect current dependency ids to be in the format of {groupId}:{artifactId}.
-         * For the legacy dependency we must fetch the corresponding coordinates (group, artifact ids) from the depot server
-         *
-         * @backwardCompatibility
-         */
-        if (dep.isLegacyDependency) {
-          return this.editorStore.depotServerClient
-            .getProjectById(dep.projectId)
-            .then((projects) => {
-              const projectsData = projects.map((p) =>
-                StoreProjectData.serialization.fromJson(p),
-              );
-              if (projectsData.length !== 1) {
-                throw new Error(
-                  `Expected 1 project for project ID '${dep.projectId}'. Got ${
-                    projectsData.length
-                  } projects with coordinates ${projectsData
-                    .map(
-                      (i) =>
-                        `'${generateGAVCoordinates(
-                          i.groupId,
-                          i.artifactId,
-                          undefined,
-                        )}'`,
-                    )
-                    .join(', ')}.`,
-                );
-              }
-              const project = projectsData[0] as StoreProjectData;
-              return new ProjectDependencyCoordinates(
-                project.groupId,
-                project.artifactId,
-                dep.versionId,
-              );
-            });
-        } else {
-          return Promise.resolve(
-            new ProjectDependencyCoordinates(
-              guaranteeNonNullable(dep.groupId),
-              guaranteeNonNullable(dep.artifactId),
-              dep.versionId,
-            ),
-          );
-        }
-      }),
+      projectDependencies.map(async (dep) =>
+        Promise.resolve(
+          new ProjectDependencyCoordinates(
+            guaranteeNonNullable(dep.groupId),
+            guaranteeNonNullable(dep.artifactId),
+            dep.versionId,
+          ),
+        ),
+      ),
     );
   }
 

package/src/stores/editor/editor-state/element-editor-state/FunctionEditorState.ts

@@ -32,6 +32,7 @@ import {
   assertType,
   StopWatch,
   filterByType,
+  assertTrue,
 } from '@finos/legend-shared';
 import { ElementEditorState } from './ElementEditorState.js';
 import {
@@ -51,6 +52,7 @@ import {
   VariableExpression,
   observe_ValueSpecification,
   generateFunctionPrettyName,
+  RawVariableExpression,
 } from '@finos/legend-graph';
 import {
   ExecutionPlanState,
@@ -271,6 +273,7 @@ export class FunctionEditorState extends ElementEditorState {
       generatePlan: flow,
       handleRunFunc: flow,
       cancelFuncRun: flow,
+      updateFunctionWithQuery: flow,
     });
 
     assertType(
@@ -335,6 +338,32 @@ export class FunctionEditorState extends ElementEditorState {
     this.functionDefinitionEditorState.setCompilationError(undefined);
   }
 
+  *updateFunctionWithQuery(val: RawLambda): GeneratorFn<void> {
+    const lambdaParam = val.parameters ? (val.parameters as object[]) : [];
+    const parameters = lambdaParam
+      .map((param) =>
+        this.editorStore.graphManagerState.graphManager.buildRawValueSpecification(
+          param,
+          this.editorStore.graphManagerState.graph,
+        ),
+      )
+      .map((rawValueSpec) =>
+        guaranteeType(rawValueSpec, RawVariableExpression),
+      );
+    assertTrue(
+      Array.isArray(val.body),
+      `Query body expected to be a list of expressions`,
+    );
+    this.functionElement.expressionSequence = val.body as object[];
+    this.functionElement.parameters = parameters;
+    yield flowResult(
+      this.functionDefinitionEditorState.convertLambdaObjectToGrammarString({
+        pretty: true,
+        firstLoad: true,
+      }),
+    );
+  }
+
   reprocess(
     newElement: ConcreteFunctionDefinition,
     editorStore: EditorStore,

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

@@ -622,12 +622,12 @@ export class MappingEditorState extends ElementEditorState {
   mappingExplorerTreeData: TreeData<MappingExplorerTreeNodeData>;
   newMappingElementSpec?: MappingElementSpec | undefined;
 
+  mappingTestableState: MappingTestableState;
+
   // DEPREACTED legacy tests: TO REMOVE once mapping testable dev work is complete
-  mappingTestStates: DEPRECATED__MappingTestState[] = [];
+  DEPRECATED_mappingTestStates: DEPRECATED__MappingTestState[] = [];
   isRunningAllTests = false;
   allTestRunTime = 0;
-  //
-  mappingTestableState: MappingTestableState;
 
   constructor(editorStore: EditorStore, element: PackageableElement) {
     super(editorStore, element);
@@ -635,7 +635,7 @@ export class MappingEditorState extends ElementEditorState {
     makeObservable<MappingEditorState, 'closeMappingElementTabState'>(this, {
       currentTabState: observable,
       openedTabStates: observable,
-      mappingTestStates: observable,
+      DEPRECATED_mappingTestStates: observable,
       newMappingElementSpec: observable,
       isRunningAllTests: observable,
       allTestRunTime: observable,
@@ -666,7 +666,7 @@ export class MappingEditorState extends ElementEditorState {
       deleteMappingElement: flow,
     });
 
-    this.mappingTestStates = this.mapping.test.map(
+    this.DEPRECATED_mappingTestStates = this.mapping.test.map(
       (t) => new DEPRECATED__MappingTestState(editorStore, t, this),
     );
     this.mappingExplorerTreeData = getMappingElementTreeData(
@@ -1238,7 +1238,7 @@ export class MappingEditorState extends ElementEditorState {
           );
           return this.createMappingElementState(mappingElement);
         } else if (tabState instanceof DEPRECATED__MappingTestState) {
-          return mappingEditorState.mappingTestStates.find(
+          return mappingEditorState.DEPRECATED_mappingTestStates.find(
             (testState) => testState.test.name === tabState.test.name,
           );
         } else if (tabState instanceof MappingExecutionState) {
@@ -1264,7 +1264,7 @@ export class MappingEditorState extends ElementEditorState {
       );
     } else if (this.currentTabState instanceof DEPRECATED__MappingTestState) {
       const currentlyOpenedMappingTest =
-        mappingEditorState.mappingTestStates.find(
+        mappingEditorState.DEPRECATED_mappingTestStates.find(
           (testState) =>
             this.currentTabState instanceof DEPRECATED__MappingTestState &&
             testState.test.name === this.currentTabState.test.name,
@@ -1407,7 +1407,7 @@ export class MappingEditorState extends ElementEditorState {
           tabState.test === test,
       ),
     );
-    const testState = this.mappingTestStates.find(
+    const testState = this.DEPRECATED_mappingTestStates.find(
       (mappingTestState) => mappingTestState.test === test,
     );
     assertNonNullable(
@@ -1442,10 +1442,10 @@ export class MappingEditorState extends ElementEditorState {
   }
 
   get testSuiteResult(): TEST_RESULT {
-    const numberOfTestPassed = this.mappingTestStates.filter(
+    const numberOfTestPassed = this.DEPRECATED_mappingTestStates.filter(
       (testState) => testState.result === TEST_RESULT.PASSED,
     ).length;
-    const numberOfTestFailed = this.mappingTestStates.filter(
+    const numberOfTestFailed = this.DEPRECATED_mappingTestStates.filter(
       (testState) =>
         testState.result === TEST_RESULT.FAILED ||
         testState.result === TEST_RESULT.ERROR,
@@ -1461,11 +1461,11 @@ export class MappingEditorState extends ElementEditorState {
     try {
       const startTime = Date.now();
       this.isRunningAllTests = true;
-      this.mappingTestStates.forEach((testState) =>
+      this.DEPRECATED_mappingTestStates.forEach((testState) =>
         testState.resetTestRunStatus(),
       );
-      const input = this.mappingTestStates
-        .map((testState: DEPRECATED__MappingTestState) => {
+      const input = this.DEPRECATED_mappingTestStates.map(
+        (testState: DEPRECATED__MappingTestState) => {
           // run non-skip tests, and reset all skipped tests
           if (!testState.isSkipped) {
             testState.setIsRunningTest(true);
@@ -1480,8 +1480,8 @@ export class MappingEditorState extends ElementEditorState {
           }
           testState.resetTestRunStatus();
           return undefined;
-        })
-        .filter(isNonNullable);
+        },
+      ).filter(isNonNullable);
       yield this.editorStore.graphManagerState.graphManager.DEPRECATED__runLegacyMappingTests(
         input,
         this.mapping,
@@ -1505,7 +1505,7 @@ export class MappingEditorState extends ElementEditorState {
   }
 
   *addTest(test: DEPRECATED__MappingTest): GeneratorFn<void> {
-    this.mappingTestStates.push(
+    this.DEPRECATED_mappingTestStates.push(
       new DEPRECATED__MappingTestState(this.editorStore, test, this),
     );
     mapping_addDEPRECATEDTest(
@@ -1529,9 +1529,10 @@ export class MappingEditorState extends ElementEditorState {
     this.openedTabStates = this.openedTabStates.filter(
       (tabState) => !matchMappingTestState(tabState),
     );
-    this.mappingTestStates = this.mappingTestStates.filter(
-      (tabState) => !matchMappingTestState(tabState),
-    );
+    this.DEPRECATED_mappingTestStates =
+      this.DEPRECATED_mappingTestStates.filter(
+        (tabState) => !matchMappingTestState(tabState),
+      );
   }
 
   *createNewTest(setImplementation: SetImplementation): GeneratorFn<void> {
@@ -1588,7 +1589,7 @@ export class MappingEditorState extends ElementEditorState {
       this.editorStore.changeDetectionState.observerContext,
     );
     // open the test
-    this.mappingTestStates.push(
+    this.DEPRECATED_mappingTestStates.push(
       new DEPRECATED__MappingTestState(this.editorStore, newTest, this),
     );
     yield flowResult(this.openTest(newTest));

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

@@ -31,9 +31,8 @@ export class MappingExecutionQueryBuilderState extends QueryBuilderState {
     mapping: Mapping,
   ) {
     super(applicationStore, graphManagerState);
-
     this.executionMapping = mapping;
-    this.mapping = mapping;
+    this.executionContextState.mapping = mapping;
   }
 
   override get isMappingReadOnly(): boolean {

package/src/stores/editor/editor-state/element-editor-state/mapping/testable/MappingTestableState.ts

@@ -646,10 +646,12 @@ export class MappingTestableState {
   }
 
   init(): void {
-    const suite = this.mapping.tests[0];
-    this.selectedTestSuite = suite
-      ? this.buildTestSuiteState(suite)
-      : undefined;
+    if (!this.selectedTestSuite) {
+      const suite = this.mapping.tests[0];
+      this.selectedTestSuite = suite
+        ? this.buildTestSuiteState(suite)
+        : undefined;
+    }
   }
 
   openCreateModal(): void {

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

@@ -42,6 +42,7 @@ import {
   getValueSpecificationReturnType,
   type Type,
   resolveServiceQueryRawLambda,
+  PureExecution,
 } from '@finos/legend-graph';
 import { ServiceTestableState } from './testable/ServiceTestableState.js';
 import { User } from '@finos/legend-server-sdlc';
@@ -132,10 +133,13 @@ export class ServiceEditorState extends ElementEditorState {
         editorStore.sdlcServerClient.features.canCreateVersion,
     );
     this.testableState = new ServiceTestableState(editorStore, this);
-    const query = this.executionState.serviceExecutionParameters?.query;
+    const executionQuery =
+      this.service.execution instanceof PureExecution
+        ? this.service.execution.func
+        : undefined;
     // default to execution tab if query is defined
     this.selectedTab =
-      query && !isStubbed_RawLambda(query)
+      executionQuery && !isStubbed_RawLambda(executionQuery)
         ? SERVICE_TAB.EXECUTION
         : SERVICE_TAB.GENERAL;
     this.postValidationState = new ServicePostValidationsState(this);

package/src/stores/editor/editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.ts

@@ -200,22 +200,6 @@ export class ProjectConfigurationEditorState extends EditorState {
         .map((v) => StoreProjectData.serialization.fromJson(v))
         .forEach((project) => this.projects.set(project.coordinates, project));
 
-      // Update the legacy dependency to newer format (using group ID and artifact ID instead of just project ID)
-      this.projectConfiguration?.projectDependencies.forEach(
-        (dependency): void => {
-          if (!dependency.isLegacyDependency) {
-            return;
-          }
-          const project = Array.from(this.projects.values()).find(
-            (e) => e.projectId === dependency.projectId,
-          );
-          // re-write to new format
-          if (project) {
-            dependency.setProjectId(project.coordinates);
-          }
-        },
-      );
-
       // fetch the versions for the dependency projects
       for (const dep of this.projectConfiguration?.projectDependencies ?? []) {
         const project = this.projects.get(dep.projectId);