@finos/legend-application-studio 28.13.2 → 28.13.4

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

@@ -91,7 +91,6 @@ import { flowResult } from 'mobx';
 import { useEditorStore } from '../EditorStoreProvider.js';
 import {
   type PackageableElement,
-  type FunctionActivatorConfiguration,
   ELEMENT_PATH_DELIMITER,
   ROOT_PACKAGE_NAME,
   Package,
@@ -144,7 +143,6 @@ import {
   CodeEditor,
 } from '@finos/legend-lego/code-editor';
 import { DatabaseBuilderWizard } from '../editor-group/connection-editor/DatabaseBuilderWizard.js';
-import { FunctionEditorState } from '../../../stores/editor/editor-state/element-editor-state/FunctionEditorState.js';
 import { DatabaseModelBuilder } from '../editor-group/connection-editor/DatabaseModelBuilder.js';
 import { queryService } from '../editor-group/service-editor/ServiceExecutionQueryEditor.js';
 import { QueryDatabaseState } from '../../../stores/editor/editor-state/element-editor-state/database/QueryDatabaseState.js';
@@ -755,50 +753,6 @@ const ExplorerContextMenu = observer(
         ).catch(applicationStore.alertUnhandledError);
       }
     };
-    const activateFunction = (): void => {
-      if (node?.packageableElement instanceof ConcreteFunctionDefinition) {
-        editorStore.setQuickInputState({
-          title: 'Activate function',
-          placeholder: 'Select an activation...',
-          options: editorStore.graphState.functionActivatorConfigurations.map(
-            (config) => ({
-              value: config,
-              label: (
-                <div
-                  className="function-editor__activator__selector__option"
-                  title={config.description}
-                >
-                  <div className="function-editor__activator__selector__option__name">
-                    {config.name}
-                  </div>
-                  <div className="function-editor__activator__selector__option__description">
-                    {config.description}
-                  </div>
-                </div>
-              ),
-            }),
-          ),
-          getSearchValue: (option: {
-            value: FunctionActivatorConfiguration;
-            label: React.ReactNode;
-          }): string => option.value.name,
-          onSelect: (option: {
-            value: FunctionActivatorConfiguration;
-            label: React.ReactNode;
-          }) => {
-            editorStore.graphEditorMode.openElement(node.packageableElement);
-            editorStore.tabManagerState
-              .getCurrentEditorState(FunctionEditorState)
-              .activatorBuilderState.setCurrentActivatorConfiguration(
-                option.value,
-              );
-          },
-          customization: {
-            rowHeight: 70,
-          },
-        });
-      }
-    };
 
     if (isDependencyProjectRoot()) {
       return (
@@ -878,19 +832,6 @@ const ExplorerContextMenu = observer(
             <MenuContentDivider />
           </>
         )}
-        {node.packageableElement instanceof ConcreteFunctionDefinition && (
-          <>
-            {editorStore.applicationStore.config.options
-              .TEMPORARY__enableFunctionActivatorSupport && (
-              <>
-                <MenuContentItem onClick={activateFunction}>
-                  Activate...
-                </MenuContentItem>
-                <MenuContentDivider />
-              </>
-            )}
-          </>
-        )}
         {isRelationalDatabaseConnection(node.packageableElement) && (
           <>
             <MenuContentItem onClick={openSQLPlayground}>

package/src/stores/editor/editor-state/element-editor-state/{FunctionActivatorPromoteState.ts → FunctionActivatorState.ts}

@@ -27,54 +27,54 @@ import {
   SnowflakeAppType,
 } from '@finos/legend-graph';
 import { type GeneratorFn } from '@finos/legend-shared';
-import { FUNCTION_PROMOTE_TYPE } from '../../../../components/editor/editor-group/function-activator/FunctionEditor.js';
+import { FUNCTION_ACTIVATE_TYPE } from '../../../../components/editor/editor-group/function-activator/FunctionEditor.js';
 
 const BASE_ACTIVATOR_NAME = 'NewActivator';
 
-export class FunctionActivatorPromoteState {
+export class FunctionActivatorState {
   readonly functionEditorState: FunctionEditorState;
 
   activatorPath: string;
-  isPromotingFunction = false;
+  isActivatingFunction = false;
   isFunctionActivatorEditorOpen = false;
-  promoteType: string | undefined;
+  activateType: string | undefined;
 
   constructor(functionEditorState: FunctionEditorState) {
     makeObservable(this, {
       activatorPath: observable,
-      isPromotingFunction: observable,
+      isActivatingFunction: observable,
       isFunctionActivatorEditorOpen: observable,
-      promoteType: observable,
-      setPromoteType: action,
+      activateType: observable,
+      setAcitvateType: action,
       updateActivatorPath: action,
-      setIsPromotingFunction: action,
+      setIsActivatingFunction: action,
       setIsFunctionActivatorEditorOpen: action,
-      promote: flow,
+      activate: flow,
     });
 
     this.functionEditorState = functionEditorState;
-    this.promoteType = FUNCTION_PROMOTE_TYPE.SNOWFLAKE_NATIVE_APP;
+    this.activateType = FUNCTION_ACTIVATE_TYPE.SNOWFLAKE_NATIVE_APP;
     this.activatorPath = `${this.functionEditorState.functionElement.package?.path}::${BASE_ACTIVATOR_NAME}`;
   }
 
-  setIsPromotingFunction(val: boolean): void {
-    this.isPromotingFunction = val;
+  setIsActivatingFunction(val: boolean): void {
+    this.isActivatingFunction = val;
   }
 
   setIsFunctionActivatorEditorOpen(val: boolean): void {
     this.isFunctionActivatorEditorOpen = val;
   }
 
-  setPromoteType(val: string | undefined): void {
-    this.promoteType = val;
+  setAcitvateType(val: string | undefined): void {
+    this.activateType = val;
   }
 
-  showFunctionPromoteModal(): void {
-    this.setIsPromotingFunction(true);
+  showFunctionActivateModal(): void {
+    this.setIsActivatingFunction(true);
   }
 
-  closeFunctionPromoteModal(): void {
-    this.setIsPromotingFunction(false);
+  closeFunctionActivateModal(): void {
+    this.setIsActivatingFunction(false);
   }
 
   updateActivatorPath(val: string): void {
@@ -84,9 +84,9 @@ export class FunctionActivatorPromoteState {
   createFunctionActivator(
     functionElement: ConcreteFunctionDefinition,
   ): FunctionActivator | undefined {
-    const type = this.promoteType;
+    const type = this.activateType;
     switch (type) {
-      case FUNCTION_PROMOTE_TYPE.SNOWFLAKE_NATIVE_APP: {
+      case FUNCTION_ACTIVATE_TYPE.SNOWFLAKE_NATIVE_APP: {
         const activatorName = this.activatorPath.includes('::')
           ? extractElementNameFromPath(this.activatorPath)
           : this.activatorPath;
@@ -106,7 +106,7 @@ export class FunctionActivatorPromoteState {
     }
   }
 
-  *promote(functionElement: ConcreteFunctionDefinition): GeneratorFn<void> {
+  *activate(functionElement: ConcreteFunctionDefinition): GeneratorFn<void> {
     const functionActivator = this.createFunctionActivator(functionElement);
     if (!functionActivator) {
       return;
@@ -121,10 +121,10 @@ export class FunctionActivatorPromoteState {
       );
     } catch {
       this.functionEditorState.editorStore.applicationStore.notificationService.notifyError(
-        `Can't promote function`,
+        `Can't activate function`,
       );
     } finally {
-      this.setPromoteType(FUNCTION_PROMOTE_TYPE.SNOWFLAKE_NATIVE_APP);
+      this.setAcitvateType(FUNCTION_ACTIVATE_TYPE.SNOWFLAKE_NATIVE_APP);
     }
   }
 }

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

@@ -65,13 +65,14 @@ import {
   buildExecutionParameterValues,
   getExecutionQueryFromRawLambda,
 } from '@finos/legend-query-builder';
-import { FunctionActivatorBuilderState } from './FunctionActivatorBuilderState.js';
-import { FunctionActivatorPromoteState } from './FunctionActivatorPromoteState.js';
+import { FunctionActivatorState } from './FunctionActivatorState.js';
+import { FunctionTestableState } from './function-activator/testable/FunctionTestableState.js';
 
 export enum FUNCTION_EDITOR_TAB {
   DEFINITION = 'DEFINITION',
   TAGGED_VALUES = 'TAGGED_VALUES',
   STEREOTYPES = 'STEREOTYPES',
+  TEST_SUITES = 'TEST_SUITES',
 }
 
 export class FunctionDefinitionEditorState extends LambdaEditorState {
@@ -244,8 +245,8 @@ export class FunctionParametersState extends LambdaParametersState {
 
 export class FunctionEditorState extends ElementEditorState {
   readonly functionDefinitionEditorState: FunctionDefinitionEditorState;
-  readonly activatorBuilderState: FunctionActivatorBuilderState; // to be removed
-  readonly activatorPromoteState: FunctionActivatorPromoteState;
+  readonly activatorPromoteState: FunctionActivatorState;
+  readonly functionTestableEditorState: FunctionTestableState;
 
   selectedTab: FUNCTION_EDITOR_TAB;
 
@@ -288,13 +289,13 @@ export class FunctionEditorState extends ElementEditorState {
       element,
       this.editorStore,
     );
-    this.activatorBuilderState = new FunctionActivatorBuilderState(this);
-    this.activatorPromoteState = new FunctionActivatorPromoteState(this);
+    this.activatorPromoteState = new FunctionActivatorState(this);
     this.executionPlanState = new ExecutionPlanState(
       this.editorStore.applicationStore,
       this.editorStore.graphManagerState,
     );
     this.parametersState = new FunctionParametersState(this);
+    this.functionTestableEditorState = new FunctionTestableState(this);
   }
 
   override get label(): string {

package/src/stores/editor/editor-state/element-editor-state/function-activator/INTERNAL__UnknownFunctionActivatorEditorState.ts

@@ -30,7 +30,7 @@ import {
 } from '@finos/legend-shared';
 import { ProtocolValueBuilderState } from '../ProtocolValueBuilderState.js';
 import { INTERNAL__UnknownFunctionActivator_setContent } from '../../../../graph-modifier/DomainGraphModifierHelper.js';
-import { FUNCTION_ACTIVATOR_EXCLUDED_PATHS } from '../FunctionActivatorBuilderState.js';
+import { FUNCTION_ACTIVATOR_EXCLUDED_PATHS } from '../ToDelete_FunctionActivatorBuilderState.js';
 
 export class INTERNAL__UnknownFunctionActivatorEdtiorState extends ElementEditorState {
   readonly activator: INTERNAL__UnknownFunctionActivator;

package/src/stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.ts

@@ -50,7 +50,7 @@ export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState
       updateConnection: action,
       updateAppType: action,
       validate: flow,
-      deploy: flow,
+      deployToSandbox: flow,
     });
   }
 
@@ -106,7 +106,7 @@ export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState
     }
   }
 
-  *deploy(): GeneratorFn<void> {
+  *deployToSandbox(): GeneratorFn<void> {
     this.deployState.inProgress();
     try {
       yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(