@finos/legend-application-studio 28.12.1 → 28.13.0

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

@@ -366,14 +366,13 @@ export const ChangeExecutionModal = observer(
           />
         );
       } else if (executionState instanceof MultiServicePureExecutionState) {
-        const multiExec = executionState.execution;
         const currentOption = executionState.singleExecutionKey
           ? {
               value: executionState.singleExecutionKey,
               label: executionState.singleExecutionKey.key,
             }
           : undefined;
-        const multiOptions = multiExec.executionParameters.map(
+        const multiOptions = executionState.keyedExecutionParameters.map(
           (keyExecutionParameter) => ({
             value: keyExecutionParameter,
             label: keyExecutionParameter.key,
@@ -554,7 +553,7 @@ export const NewExecutionParameterModal = observer(
     const validationMessage =
       keyValue === ''
         ? `Execution context key can't be empty`
-        : executionState.execution.executionParameters.find(
+        : executionState.execution.executionParameters?.find(
             (e) => e.key === keyValue,
           )
         ? 'Execution context key already exists'
@@ -702,15 +701,19 @@ const MultiPureExecutionEditor = observer(
                 </PanelHeaderActions>
               </PanelHeader>
 
-              {multiExecution.executionParameters.map((executionParameter) => (
-                <KeyExecutionItem
-                  key={executionParameter.key}
-                  multiExecutionState={multiExecutionState}
-                  keyExecutionParameter={executionParameter}
-                  isReadOnly={multiExecutionState.serviceEditorState.isReadOnly}
-                />
-              ))}
-              {!multiExecution.executionParameters.length && (
+              {multiExecutionState.keyedExecutionParameters.map(
+                (executionParameter) => (
+                  <KeyExecutionItem
+                    key={executionParameter.key}
+                    multiExecutionState={multiExecutionState}
+                    keyExecutionParameter={executionParameter}
+                    isReadOnly={
+                      multiExecutionState.serviceEditorState.isReadOnly
+                    }
+                  />
+                ),
+              )}
+              {!multiExecutionState.keyedExecutionParameters.length && (
                 <BlankPanelPlaceholder
                   text="Add an execution context"
                   onClick={addExecutionKey}
@@ -780,7 +783,7 @@ const ServicePureExecutionEditor = observer(
     const showChangeExecutionModal = (): void => {
       if (servicePureExecutionState instanceof MultiServicePureExecutionState) {
         servicePureExecutionState.setSingleExecutionKey(
-          servicePureExecutionState.execution.executionParameters[0],
+          servicePureExecutionState.keyedExecutionParameters[0],
         );
       }
       servicePureExecutionState.setShowChangeExecModal(true);
@@ -905,7 +908,7 @@ export const ServiceExecutionEditor = observer(() => {
   }
   return (
     <UnsupportedEditorPanel
-      text="Can't display thie service execution in form-mode"
+      text="Can't display this service execution in form-mode"
       isReadOnly={serviceState.isReadOnly}
     />
   );

package/src/components/editor/panel-group/SQLPlaygroundPanel.tsx

@@ -54,7 +54,6 @@ import {
 import {
   PackageableConnection,
   RelationalDatabaseConnection,
-  guaranteeRelationalDatabaseConnection,
 } from '@finos/legend-graph';
 import { LEGEND_STUDIO_APPLICATION_NAVIGATION_CONTEXT_KEY } from '../../../__lib__/LegendStudioApplicationNavigationContext.js';
 import { type SQLPlaygroundPanelState } from '../../../stores/editor/panel-group/SQLPlaygroundPanelState.js';
@@ -81,6 +80,10 @@ import {
   type DatabaseSchemaExplorerTreeNodeContainerProps,
 } from '../editor-group/connection-editor/DatabaseSchemaExplorer.js';
 import { DatabaseSchemaExplorerTreeTableNodeData } from '../../../stores/editor/editor-state/element-editor-state/connection/DatabaseBuilderState.js';
+import {
+  buildRelationalDatabaseConnectionOption,
+  type RelationalDatabaseConnectionOption,
+} from '../editor-group/connection-editor/RelationalDatabaseConnectionEditor.js';
 
 const DATABASE_NODE_DND_TYPE = 'DATABASE_NODE_DND_TYPE';
 type DatabaseNodeDragType = { text: string };
@@ -108,32 +111,6 @@ const SQLPlaygroundDatabaseSchemaExplorerTreeNodeContainer = observer(
   },
 );
 
-type RelationalDatabaseConnectionOption = {
-  label: React.ReactNode;
-  value: PackageableConnection;
-};
-const buildRelationalDatabaseConnectionOption = (
-  connection: PackageableConnection,
-): RelationalDatabaseConnectionOption => {
-  const connectionValue = guaranteeRelationalDatabaseConnection(connection);
-  return {
-    value: connection,
-    label: (
-      <div className="sql-playground__config__connection-selector__option">
-        <div className="sql-playground__config__connection-selector__option__label">
-          {connection.name}
-        </div>
-        <div className="sql-playground__config__connection-selector__option__type">
-          {connectionValue.type}
-        </div>
-        <div className="sql-playground__config__connection-selector__option__path">
-          {connection.path}
-        </div>
-      </div>
-    ),
-  };
-};
-
 // List of most popular SQL keywords
 // See https://www.w3schools.com/sql/sql_ref_keywords.asp
 const SQL_KEYWORDS = [

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

@@ -90,6 +90,8 @@ import {
 import { flowResult } from 'mobx';
 import { useEditorStore } from '../EditorStoreProvider.js';
 import {
+  type PackageableElement,
+  type FunctionActivatorConfiguration,
   ELEMENT_PATH_DELIMITER,
   ROOT_PACKAGE_NAME,
   Package,
@@ -105,15 +107,13 @@ import {
   getFunctionSignature,
   getFunctionNameWithPath,
   getElementRootPackage,
-  type PackageableElement,
   PackageableConnection,
-  RelationalDatabaseConnection,
   guaranteeRelationalDatabaseConnection,
   extractDependencyGACoordinateFromRootPackageName,
-  type FunctionActivatorConfiguration,
   Database,
   DEPENDENCY_ROOT_PACKAGE_PREFIX,
   Service,
+  isRelationalDatabaseConnection,
 } from '@finos/legend-graph';
 import {
   ActionAlertActionType,
@@ -459,12 +459,6 @@ const SampleDataGenerator = observer(() => {
   );
 });
 
-const isRelationalDatabaseConnection = (
-  val: PackageableElement | undefined,
-): boolean =>
-  val instanceof PackageableConnection &&
-  val.connectionValue instanceof RelationalDatabaseConnection;
-
 const isRelationalDatabase = (
   val: PackageableElement | undefined,
 ): Database | undefined => (val instanceof Database ? val : undefined);

package/src/index.ts

@@ -113,3 +113,6 @@ export {
   EmbeddedDataState,
 } from './stores/editor/editor-state/element-editor-state/data/EmbeddedDataState.js';
 export type { EmbeddedDataTypeOption } from './stores/editor/editor-state/element-editor-state/data/DataEditorState.js';
+
+export { SnowflakeAppFunctionActivatorEdtiorState } from './stores/editor/editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.js';
+export { SnowflakeAppFunctionActivatorEditor } from './components/editor/editor-group/function-activator/SnowflakeAppFunctionActivatorEditor.js';

package/src/stores/editor/EditorGraphState.ts

@@ -57,8 +57,13 @@ import {
   buildDependencyReport,
 } from '@finos/legend-server-depot';
 import {
-  GRAPH_MANAGER_EVENT,
   type EngineError,
+  type PackageableElement,
+  type CompilationWarning,
+  type PureModel,
+  type FunctionActivatorConfiguration,
+  type RelationalDatabaseTypeConfiguration,
+  GRAPH_MANAGER_EVENT,
   Package,
   Profile,
   PrimitiveType,
@@ -80,13 +85,9 @@ import {
   DependencyGraphBuilderError,
   GraphDataDeserializationError,
   DataElement,
-  type PackageableElement,
-  type CompilationWarning,
-  type PureModel,
   createGraphBuilderReport,
   ExecutionEnvironmentInstance,
-  type FunctionActivatorConfiguration,
-  type RelationalDatabaseTypeConfiguration,
+  SnowflakeApp,
 } from '@finos/legend-graph';
 import { CONFIGURATION_EDITOR_TAB } from './editor-state/project-configuration-editor-state/ProjectConfigurationEditorState.js';
 import { PACKAGEABLE_ELEMENT_TYPE } from './utils/ModelClassifierUtils.js';
@@ -832,6 +833,8 @@ export class EditorGraphState {
       return PACKAGEABLE_ELEMENT_TYPE.DATA;
     } else if (element instanceof ExecutionEnvironmentInstance) {
       return PACKAGEABLE_ELEMENT_TYPE.EXECUTION_ENVIRONMENT;
+    } else if (element instanceof SnowflakeApp) {
+      return PACKAGEABLE_ELEMENT_TYPE.SNOWFLAKE_APP;
     }
     const extraElementTypeLabelGetters = this.editorStore.pluginManager
       .getApplicationPlugins()

package/src/stores/editor/EditorTabManagerState.ts

@@ -15,6 +15,7 @@
  */
 
 import {
+  type PackageableElement,
   Association,
   Class,
   ConcreteFunctionDefinition,
@@ -31,8 +32,8 @@ import {
   PrimitiveType,
   Profile,
   Service,
-  type PackageableElement,
   INTERNAL__UnknownFunctionActivator,
+  SnowflakeApp,
 } from '@finos/legend-graph';
 import {
   type Clazz,
@@ -58,7 +59,8 @@ import { UnsupportedElementEditorState } from './editor-state/UnsupportedElement
 import type { EditorStore } from './EditorStore.js';
 import type { DSL_LegendStudioApplicationPlugin_Extension } from '../LegendStudioApplicationPlugin.js';
 import { TabManagerState } from '@finos/legend-lego/application';
-import { INTERNAL__UnknownFunctionActivatorEdtiorState } from './editor-state/element-editor-state/INTERNAL__UnknownFunctionActivatorEditorState.js';
+import { INTERNAL__UnknownFunctionActivatorEdtiorState } from './editor-state/element-editor-state/function-activator/INTERNAL__UnknownFunctionActivatorEditorState.js';
+import { SnowflakeAppFunctionActivatorEdtiorState } from './editor-state/element-editor-state/function-activator/SnowflakeAppFunctionActivatorEditorState.js';
 
 export class EditorTabManagerState extends TabManagerState {
   readonly editorStore: EditorStore;
@@ -126,6 +128,11 @@ export class EditorTabManagerState extends TabManagerState {
       return new FileGenerationEditorState(this.editorStore, element);
     } else if (element instanceof DataElement) {
       return new PackageableDataEditorState(this.editorStore, element);
+    } else if (element instanceof SnowflakeApp) {
+      return new SnowflakeAppFunctionActivatorEdtiorState(
+        this.editorStore,
+        element,
+      );
     } else if (element instanceof INTERNAL__UnknownFunctionActivator) {
       return new INTERNAL__UnknownFunctionActivatorEdtiorState(
         this.editorStore,

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

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { action, flow, flowResult, makeObservable, observable } from 'mobx';
+import type { FunctionEditorState } from './FunctionEditorState.js';
+import {
+  type ConcreteFunctionDefinition,
+  type FunctionActivator,
+  PackageableElementExplicitReference,
+  SnowflakeApp,
+  extractElementNameFromPath,
+  extractPackagePathFromPath,
+  SnowflakeAppDeploymentConfiguration,
+} from '@finos/legend-graph';
+import { type GeneratorFn } from '@finos/legend-shared';
+import { FUNCTION_PROMOTE_TYPE } from '../../../../components/editor/editor-group/function-activator/FunctionEditor.js';
+
+const BASE_ACTIVATOR_NAME = 'NewActivator';
+
+export class FunctionActivatorPromoteState {
+  readonly functionEditorState: FunctionEditorState;
+
+  activatorPath: string;
+  isPromotingFunction = false;
+  isFunctionActivatorEditorOpen = false;
+  promoteType: string | undefined;
+
+  constructor(functionEditorState: FunctionEditorState) {
+    makeObservable(this, {
+      activatorPath: observable,
+      isPromotingFunction: observable,
+      isFunctionActivatorEditorOpen: observable,
+      promoteType: observable,
+      setPromoteType: action,
+      updateActivatorPath: action,
+      setIsPromotingFunction: action,
+      setIsFunctionActivatorEditorOpen: action,
+      promote: flow,
+    });
+
+    this.functionEditorState = functionEditorState;
+    this.activatorPath = `${this.functionEditorState.functionElement.package?.path}::${BASE_ACTIVATOR_NAME}`;
+  }
+
+  setIsPromotingFunction(val: boolean): void {
+    this.isPromotingFunction = val;
+  }
+
+  setIsFunctionActivatorEditorOpen(val: boolean): void {
+    this.isFunctionActivatorEditorOpen = val;
+  }
+
+  setPromoteType(val: string | undefined): void {
+    this.promoteType = val;
+  }
+
+  showFunctionPromoteModal(): void {
+    this.setIsPromotingFunction(true);
+  }
+
+  closeFunctionPromoteModal(): void {
+    this.setIsPromotingFunction(false);
+  }
+
+  updateActivatorPath(val: string): void {
+    this.activatorPath = val;
+  }
+
+  createFunctionActivator(
+    functionElement: ConcreteFunctionDefinition,
+  ): FunctionActivator | undefined {
+    const type = this.promoteType;
+    switch (type) {
+      case FUNCTION_PROMOTE_TYPE.SNOWFLAKE_NATIVE_APP: {
+        const activatorName = this.activatorPath.includes('::')
+          ? extractElementNameFromPath(this.activatorPath)
+          : this.activatorPath;
+        const snowflakeApp = new SnowflakeApp(activatorName);
+        snowflakeApp.applicationName = '';
+        snowflakeApp.description = '';
+        snowflakeApp.owner = undefined;
+        snowflakeApp.function =
+          PackageableElementExplicitReference.create(functionElement);
+        snowflakeApp.activationConfiguration =
+          new SnowflakeAppDeploymentConfiguration();
+        return snowflakeApp;
+      }
+      default:
+        return undefined;
+    }
+  }
+
+  *promote(functionElement: ConcreteFunctionDefinition): GeneratorFn<void> {
+    const functionActivator = this.createFunctionActivator(functionElement);
+    if (!functionActivator) {
+      return;
+    }
+    try {
+      yield flowResult(
+        this.functionEditorState.editorStore.graphEditorMode.addElement(
+          functionActivator,
+          extractPackagePathFromPath(this.activatorPath) ?? this.activatorPath,
+          true,
+        ),
+      );
+    } catch {
+      this.functionEditorState.editorStore.applicationStore.notificationService.notifyError(
+        `Can't promote function`,
+      );
+    } finally {
+      this.setPromoteType(undefined);
+    }
+  }
+}

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

@@ -66,6 +66,7 @@ import {
   getExecutionQueryFromRawLambda,
 } from '@finos/legend-query-builder';
 import { FunctionActivatorBuilderState } from './FunctionActivatorBuilderState.js';
+import { FunctionActivatorPromoteState } from './FunctionActivatorPromoteState.js';
 
 export enum FUNCTION_EDITOR_TAB {
   DEFINITION = 'DEFINITION',
@@ -243,7 +244,8 @@ export class FunctionParametersState extends LambdaParametersState {
 
 export class FunctionEditorState extends ElementEditorState {
   readonly functionDefinitionEditorState: FunctionDefinitionEditorState;
-  readonly activatorBuilderState: FunctionActivatorBuilderState;
+  readonly activatorBuilderState: FunctionActivatorBuilderState; // to be removed
+  readonly activatorPromoteState: FunctionActivatorPromoteState;
 
   selectedTab: FUNCTION_EDITOR_TAB;
 
@@ -287,6 +289,7 @@ export class FunctionEditorState extends ElementEditorState {
       this.editorStore,
     );
     this.activatorBuilderState = new FunctionActivatorBuilderState(this);
+    this.activatorPromoteState = new FunctionActivatorPromoteState(this);
     this.executionPlanState = new ExecutionPlanState(
       this.editorStore.applicationStore,
       this.editorStore.graphManagerState,

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

@@ -19,8 +19,8 @@ import {
   InMemoryGraphData,
   type INTERNAL__UnknownFunctionActivator,
 } from '@finos/legend-graph';
-import type { EditorStore } from '../../EditorStore.js';
-import { ElementEditorState } from './ElementEditorState.js';
+import type { EditorStore } from '../../../EditorStore.js';
+import { ElementEditorState } from '../ElementEditorState.js';
 import { action, flow, makeObservable } from 'mobx';
 import {
   ActionState,
@@ -28,9 +28,9 @@ import {
   type GeneratorFn,
   type PlainObject,
 } 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 { ProtocolValueBuilderState } from '../ProtocolValueBuilderState.js';
+import { INTERNAL__UnknownFunctionActivator_setContent } from '../../../../graph-modifier/DomainGraphModifierHelper.js';
+import { FUNCTION_ACTIVATOR_EXCLUDED_PATHS } from '../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

@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2020-present, Goldman Sachs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  SnowflakeApp,
+  type PackageableConnection,
+  ConnectionPointer,
+  InMemoryGraphData,
+  PackageableElementExplicitReference,
+  observe_SnowflakeAppDeploymentConfiguration,
+  observe_SnowflakeApp,
+} from '@finos/legend-graph';
+import {
+  ActionState,
+  assertErrorThrown,
+  guaranteeType,
+  type GeneratorFn,
+} from '@finos/legend-shared';
+import { makeObservable, action, flow, computed } from 'mobx';
+import type { EditorStore } from '../../../EditorStore.js';
+import { ElementEditorState } from '../ElementEditorState.js';
+
+export class SnowflakeAppFunctionActivatorEdtiorState extends ElementEditorState {
+  readonly validateState = ActionState.create();
+  readonly deployState = ActionState.create();
+
+  constructor(editorStore: EditorStore, element: SnowflakeApp) {
+    super(editorStore, element);
+
+    makeObservable(this, {
+      activator: computed,
+      reprocess: action,
+      updateOwner: action,
+      updateAppDescription: action,
+      updateApplicationName: action,
+      updateConnection: action,
+      validate: flow,
+      deploy: flow,
+    });
+  }
+
+  get activator(): SnowflakeApp {
+    return observe_SnowflakeApp(
+      guaranteeType(
+        this.element,
+        SnowflakeApp,
+        'Element inside snowflake app function editor state must be a SnowflakeApp',
+      ),
+    );
+  }
+
+  updateConnection(val: PackageableConnection): void {
+    this.activator.activationConfiguration.activationConnection =
+      new ConnectionPointer(PackageableElementExplicitReference.create(val));
+    observe_SnowflakeAppDeploymentConfiguration(
+      this.activator.activationConfiguration,
+    );
+  }
+
+  updateOwner(val: string): void {
+    this.activator.owner = val;
+  }
+
+  updateApplicationName(val: string): void {
+    this.activator.applicationName = val;
+  }
+
+  updateAppDescription(val: string): void {
+    this.activator.description = val;
+  }
+
+  *validate(): GeneratorFn<void> {
+    this.validateState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.validateFunctionActivator(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+      this.editorStore.applicationStore.notificationService.notifySuccess(
+        `Function activator is valid`,
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.validateState.complete();
+    }
+  }
+
+  *deploy(): GeneratorFn<void> {
+    this.deployState.inProgress();
+    try {
+      yield this.editorStore.graphManagerState.graphManager.publishFunctionActivatorToSandbox(
+        this.activator,
+        new InMemoryGraphData(this.editorStore.graphManagerState.graph),
+      );
+    } catch (error) {
+      assertErrorThrown(error);
+      this.editorStore.applicationStore.notificationService.notifyError(error);
+    } finally {
+      this.deployState.complete();
+    }
+  }
+
+  reprocess(
+    newElement: SnowflakeApp,
+    editorStore: EditorStore,
+  ): SnowflakeAppFunctionActivatorEdtiorState {
+    return new SnowflakeAppFunctionActivatorEdtiorState(
+      editorStore,
+      newElement,
+    );
+  }
+}

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

@@ -249,7 +249,10 @@ export class ServiceEditorState extends ElementEditorState {
         this,
         execution,
       );
-    } else if (execution instanceof PureMultiExecution) {
+    } else if (
+      execution instanceof PureMultiExecution &&
+      execution.executionParameters
+    ) {
       return new MultiServicePureExecutionState(
         this.editorStore,
         this,

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

@@ -927,7 +927,6 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
       handleRunQuery: flow,
       runQuery: flow,
     });
-
     this.execution = execution;
     this.selectedExecutionContextState =
       this.getInitiallySelectedExecutionContextState();
@@ -941,6 +940,10 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
     );
   }
 
+  get keyedExecutionParameters(): KeyedExecutionParameter[] {
+    return this.execution.executionParameters ?? [];
+  }
+
   setSingleExecutionKey(val: KeyedExecutionParameter | undefined): void {
     this.singleExecutionKey = val;
   }
@@ -980,7 +983,7 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
   getInitiallySelectedExecutionContextState():
     | ServiceExecutionContextState
     | undefined {
-    const parameter = this.execution.executionParameters[0];
+    const parameter = this.keyedExecutionParameters[0];
     return parameter
       ? new KeyedExecutionContextState(parameter, this)
       : undefined;
@@ -994,7 +997,10 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
   }
 
   deleteKeyExecutionParameter(value: KeyedExecutionParameter): void {
-    pureMultiExecution_deleteExecutionParameter(this.execution, value);
+    pureMultiExecution_deleteExecutionParameter(
+      this.keyedExecutionParameters,
+      value,
+    );
     if (value === this.selectedExecutionContextState?.executionContext) {
       this.selectedExecutionContextState =
         this.getInitiallySelectedExecutionContextState();
@@ -1010,7 +1016,7 @@ export class MultiServicePureExecutionState extends ServicePureExecutionState {
       stub_PackageableRuntime(),
     );
     pureMultiExecution_addExecutionParameter(
-      this.execution,
+      this.keyedExecutionParameters,
       _key,
       this.editorStore.changeDetectionState.observerContext,
     );

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

@@ -788,7 +788,7 @@ export class ConnectionTestDataState {
     if (execution instanceof PureSingleExecution && execution.runtime) {
       runtimes = [execution.runtime];
     } else if (execution instanceof PureMultiExecution) {
-      runtimes = execution.executionParameters.map((t) => t.runtime);
+      runtimes = execution.executionParameters?.map((t) => t.runtime) ?? [];
     }
     return runtimes.flatMap(getAllIdentifiedConnectionsFromRuntime);
   }

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

@@ -226,7 +226,7 @@ export class ServiceTestSetupState {
   get keyOptions(): KeyOption[] {
     const keys =
       this.testState.testable.execution instanceof PureMultiExecution
-        ? this.testState.testable.execution.executionParameters.map(
+        ? (this.testState.testable.execution.executionParameters ?? []).map(
             (p) => p.key,
           )
         : [];

package/src/stores/editor/utils/ModelClassifierUtils.ts

@@ -69,6 +69,7 @@ export enum PACKAGEABLE_ELEMENT_TYPE {
   GENERATION_SPECIFICATION = 'GENERATION_SPECIFICATION',
   SECTION_INDEX = 'SECTION_INDEX',
   DATA = 'DATA',
+  SNOWFLAKE_APP = 'SNOWFLAKE_APP',
 
   TEMPORARY__LOCAL_CONNECTION = 'LOCAL_CONNECTION',
   INTERNAL__UNKNOWN = 'UNKNOWN',

package/src/stores/graph-modifier/DSL_Service_GraphModifierHelper.ts

@@ -287,19 +287,22 @@ export const pureMultiExecution_setExecutionKey = action(
 );
 export const pureMultiExecution_addExecutionParameter = action(
   (
-    pe: PureMultiExecution,
+    executionParameters: KeyedExecutionParameter[],
     value: KeyedExecutionParameter,
     context: ObserverContext,
   ): void => {
     addUniqueEntry(
-      pe.executionParameters,
+      executionParameters,
       observe_KeyedExecutionParameter(value, context),
     );
   },
 );
 export const pureMultiExecution_deleteExecutionParameter = action(
-  (pe: PureMultiExecution, value: KeyedExecutionParameter): void => {
-    deleteEntry(pe.executionParameters, value);
+  (
+    executionParameters: KeyedExecutionParameter[],
+    value: KeyedExecutionParameter,
+  ): void => {
+    deleteEntry(executionParameters, value);
   },
 );