@finos/legend-graph 31.4.0 → 31.4.2

package/src/graph/metamodel/pure/functionActivator/SnowflakeAppDeploymentConfiguration.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { hashArray } from '@finos/legend-shared';
+import type { ConnectionPointer } from '../packageableElements/connection/Connection.js';
+import { DeploymentConfiguration } from './DeploymentConfiguration.js';
+
+export class SnowflakeAppDeploymentConfiguration extends DeploymentConfiguration {
+  activationConnection: ConnectionPointer | undefined;
+
+  override get hashCode(): string {
+    return hashArray([this.activationConnection ?? '']);
+  }
+}

package/src/graph/metamodel/pure/functionActivator/SnowflakeAppType.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+
+export enum SnowflakeAppType {
+  FULL = 'FULL',
+  STAGE = 'STAGE',
+}

package/src/graph/metamodel/pure/packageableElements/PackageableElement.ts

@@ -45,6 +45,7 @@ import type { ExecutionEnvironmentInstance } from './service/ExecutionEnvironmen
 import type { INTERNAL__UnknownPackageableElement } from './INTERNAL__UnknownPackageableElement.js';
 import type { INTERNAL__UnknownFunctionActivator } from './function/INTERNAL__UnknownFunctionActivator.js';
 import type { INTERNAL__UnknownStore } from './store/INTERNAL__UnknownStore.js';
+import type { SnowflakeApp } from './function/SnowflakeApp.js';
 
 export interface PackageableElementVisitor<T> {
   visit_PackageableElement(element: PackageableElement): T;
@@ -76,6 +77,7 @@ export interface PackageableElementVisitor<T> {
   visit_GenerationSpecification(element: GenerationSpecification): T;
   visit_DataElement(element: DataElement): T;
   visit_ExecutionEnvironmentInstance(element: ExecutionEnvironmentInstance): T;
+  visit_SnowflakeApp(element: SnowflakeApp): T;
 }
 
 class ModelElement extends AnnotatedElement {

package/src/graph/metamodel/pure/packageableElements/function/FunctionActivator.ts

@@ -18,6 +18,7 @@ import type { Hashable } from '@finos/legend-shared';
 import { PackageableElement } from '../PackageableElement.js';
 import type { PackageableElementReference } from '../PackageableElementReference.js';
 import type { ConcreteFunctionDefinition } from './ConcreteFunctionDefinition.js';
+import type { DeploymentConfiguration } from '../../functionActivator/DeploymentConfiguration.js';
 
 export abstract class FunctionActivator
   extends PackageableElement
@@ -30,4 +31,5 @@ export abstract class FunctionActivator
    * @discrepancy model
    */
   function!: PackageableElementReference<ConcreteFunctionDefinition>;
+  activationConfiguration!: DeploymentConfiguration;
 }

package/src/graph/metamodel/pure/packageableElements/function/SnowflakeApp.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 { hashArray } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../Core_HashUtils.js';
+import type { PackageableElementVisitor } from '../PackageableElement.js';
+import { FunctionActivator } from './FunctionActivator.js';
+import type { SnowflakeAppDeploymentConfiguration } from '../../functionActivator/SnowflakeAppDeploymentConfiguration.js';
+import type { SnowflakeAppType } from '../../functionActivator/SnowflakeAppType.js';
+
+export class SnowflakeApp extends FunctionActivator {
+  applicationName!: string;
+  description: string | undefined;
+  owner: string | undefined;
+  declare activationConfiguration: SnowflakeAppDeploymentConfiguration;
+  type: SnowflakeAppType | undefined;
+
+  accept_PackageableElementVisitor<T>(
+    visitor: PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_SnowflakeApp(this);
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SNOWFLAKE_APP,
+      this.applicationName,
+      this.description ?? '',
+      this.owner ?? '',
+      this.activationConfiguration,
+      this.type ?? '',
+    ]);
+  }
+}

package/src/graph/metamodel/pure/packageableElements/runtime/Runtime.ts

@@ -19,7 +19,10 @@ import {
   CORE_HASH_STRUCTURE,
   hashElementPointer,
 } from '../../../../../graph/Core_HashUtils.js';
-import type { Connection } from '../connection/Connection.js';
+import type {
+  Connection,
+  ConnectionPointer,
+} from '../connection/Connection.js';
 import type { PackageableRuntime } from './PackageableRuntime.js';
 import type { Mapping } from '../mapping/Mapping.js';
 import type { Store } from '../store/Store.js';
@@ -66,12 +69,37 @@ export class StoreConnections implements Hashable {
   }
 }
 
+export class ConnectionStores implements Hashable {
+  connectionPointer: ConnectionPointer;
+  storePointers: PackageableElementReference<Store>[] = [];
+
+  constructor(connectionPointer: ConnectionPointer) {
+    this.connectionPointer = connectionPointer;
+  }
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.STORE_CONNECTIONS,
+      this.connectionPointer,
+      hashArray(
+        this.storePointers.map((s) =>
+          hashElementPointer(
+            PackageableElementPointerType.STORE,
+            s.valueForSerialization ?? '',
+          ),
+        ),
+      ),
+    ]);
+  }
+}
+
 export abstract class Runtime implements Hashable {
   abstract get hashCode(): string;
 }
 
 export class EngineRuntime extends Runtime implements Hashable {
   mappings: PackageableElementReference<Mapping>[] = [];
+  connectionStores: ConnectionStores[] = [];
   connections: StoreConnections[] = [];
 
   get hashCode(): string {
@@ -85,6 +113,7 @@ export class EngineRuntime extends Runtime implements Hashable {
           ),
         ),
       ),
+      hashArray(this.connectionStores),
       hashArray(
         this.connections.filter(
           // TODO: use `isStubbed_StoreConnections` when we refactor hashing

package/src/graph/metamodel/pure/packageableElements/service/ServiceExecution.ts

@@ -100,10 +100,14 @@ export class KeyedExecutionParameter implements Hashable {
 }
 
 export class PureMultiExecution extends PureExecution implements Hashable {
-  executionKey: string;
-  executionParameters: KeyedExecutionParameter[] = [];
+  executionKey: string | undefined;
+  executionParameters: KeyedExecutionParameter[] | undefined;
 
-  constructor(executionKey: string, func: RawLambda, parentService: Service) {
+  constructor(
+    executionKey: string | undefined,
+    func: RawLambda,
+    parentService: Service,
+  ) {
     super(func, parentService);
     this.executionKey = executionKey;
   }
@@ -113,7 +117,7 @@ export class PureMultiExecution extends PureExecution implements Hashable {
       CORE_HASH_STRUCTURE.SERVICE_PURE_MULTI_EXECUTION,
       super.hashCode,
       this.executionKey,
-      hashArray(this.executionParameters),
+      hashArray(this.executionParameters ?? []),
     ]);
   }
 }

package/src/graph-manager/action/changeDetection/DSL_FunctionActivatorObserverHelper.ts

@@ -0,0 +1,36 @@
+/**
+ * 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 { makeObservable, observable } from 'mobx';
+import type { SnowflakeAppDeploymentConfiguration } from '../../../graph/metamodel/pure/functionActivator/SnowflakeAppDeploymentConfiguration.js';
+import { skipObserved } from './CoreObserverHelper.js';
+import { observe_ConnectionPointer } from './DSL_Mapping_ObserverHelper.js';
+
+export const observe_SnowflakeAppDeploymentConfiguration = skipObserved(
+  (
+    metamodel: SnowflakeAppDeploymentConfiguration,
+  ): SnowflakeAppDeploymentConfiguration => {
+    makeObservable(metamodel, {
+      activationConnection: observable,
+    });
+
+    if (metamodel.activationConnection) {
+      observe_ConnectionPointer(metamodel.activationConnection);
+    }
+
+    return metamodel;
+  },
+);

package/src/graph-manager/action/changeDetection/DSL_Service_ObserverHelper.ts

@@ -323,7 +323,7 @@ export const observe_PureMultiExecution = skipObservedWithContext(
       hashCode: computed,
     });
 
-    metamodel.executionParameters.forEach((parameter) =>
+    metamodel.executionParameters?.forEach((parameter) =>
       observe_KeyedExecutionParameter(parameter, context),
     );
 

package/src/graph-manager/action/changeDetection/DomainObserverHelper.ts

@@ -66,6 +66,8 @@ import {
   observe_RawVariableExpression,
 } from './RawValueSpecificationObserver.js';
 import type { INTERNAL__UnknownFunctionActivator } from '../../../graph/metamodel/pure/packageableElements/function/INTERNAL__UnknownFunctionActivator.js';
+import type { SnowflakeApp } from '../../../graph/metamodel/pure/packageableElements/function/SnowflakeApp.js';
+import { observe_SnowflakeAppDeploymentConfiguration } from './DSL_FunctionActivatorObserverHelper.js';
 
 const _observe_Abstract_Package = (metamodel: Package): void => {
   observe_Abstract_PackageableElement(metamodel);
@@ -488,6 +490,26 @@ export const observe_INTERNAL__UnknownFunctionActivator = skipObserved(
   },
 );
 
+export const observe_SnowflakeApp = skipObserved(
+  (metamodel: SnowflakeApp): SnowflakeApp => {
+    observe_Abstract_PackageableElement(metamodel);
+
+    makeObservable<SnowflakeApp, '_elementHashCode'>(metamodel, {
+      applicationName: observable,
+      description: observable,
+      owner: observable,
+      activationConfiguration: observable,
+      type: observable,
+      _elementHashCode: override,
+    });
+
+    observe_SnowflakeAppDeploymentConfiguration(
+      metamodel.activationConfiguration,
+    );
+    return metamodel;
+  },
+);
+
 // ------------------------------------- Type -------------------------------------
 
 export const observe_Type = skipObserved((metamodel: Type): Type => {

package/src/graph-manager/action/changeDetection/PackageableElementObserver.ts

@@ -45,6 +45,7 @@ import {
   observe_Package,
   observe_Profile,
   observe_SectionIndex,
+  observe_SnowflakeApp,
 } from './DomainObserverHelper.js';
 import {
   type ObserverContext,
@@ -71,6 +72,7 @@ import { observe_ExecutionEnvironmentInstance } from './DSL_ExecutionEnvironment
 import type { INTERNAL__UnknownPackageableElement } from '../../../graph/metamodel/pure/packageableElements/INTERNAL__UnknownPackageableElement.js';
 import type { INTERNAL__UnknownFunctionActivator } from '../../../graph/metamodel/pure/packageableElements/function/INTERNAL__UnknownFunctionActivator.js';
 import type { INTERNAL__UnknownStore } from '../../../graph/metamodel/pure/packageableElements/store/INTERNAL__UnknownStore.js';
+import type { SnowflakeApp } from '../../../graph/metamodel/pure/packageableElements/function/SnowflakeApp.js';
 
 class PackageableElementObserver implements PackageableElementVisitor<void> {
   observerContext: ObserverContext;
@@ -103,6 +105,10 @@ class PackageableElementObserver implements PackageableElementVisitor<void> {
     observe_INTERNAL__UnknownFunctionActivator(element);
   }
 
+  visit_SnowflakeApp(element: SnowflakeApp): void {
+    observe_SnowflakeApp(element);
+  }
+
   visit_INTERNAL__UnknownStore(element: INTERNAL__UnknownStore): void {
     observe_INTERNAL__UnknownStore(element);
   }

package/src/graph-manager/protocol/pure/v1/V1_PureGraphManager.ts

@@ -319,6 +319,7 @@ import {
 } from './engine/service/V1_TableRowIdentifiers.js';
 import { V1_transformTablePointer } from './transformation/pureGraph/from/V1_DatabaseTransformer.js';
 import { EngineError } from '../../../action/EngineError.js';
+import { V1_SnowflakeApp } from './model/packageableElements/function/V1_SnowflakeApp.js';
 
 class V1_PureModelContextDataIndex {
   elements: V1_PackageableElement[] = [];
@@ -3333,13 +3334,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           }
         } else if (execution instanceof PureMultiExecution) {
           sdlcInfo.packageableElementPointers =
-            execution.executionParameters.map(
+            execution.executionParameters?.map(
               (e) =>
                 new V1_PackageableElementPointer(
                   PackageableElementPointerType.MAPPING,
                   e.mapping.value.path,
                 ),
-            );
+            ) ?? [];
         } else {
           throw new UnsupportedOperationError(
             `Can't register service with the specified execution`,
@@ -3451,13 +3452,13 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
             }
           } else if (execution instanceof PureMultiExecution) {
             sdlcInfo.packageableElementPointers =
-              execution.executionParameters.map(
+              execution.executionParameters?.map(
                 (e) =>
                   new V1_PackageableElementPointer(
                     PackageableElementPointerType.MAPPING,
                     e.mapping.value.path,
                   ),
-              );
+              ) ?? [];
           } else {
             throw new UnsupportedOperationError(
               `Can't register service with the specified execution`,
@@ -3870,6 +3871,8 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
       return CORE_PURE_PATH.DATA_ELEMENT;
     } else if (protocol instanceof V1_GenerationSpecification) {
       return CORE_PURE_PATH.GENERATION_SPECIFICATION;
+    } else if (protocol instanceof V1_SnowflakeApp) {
+      return CORE_PURE_PATH.SNOWFLAKE_APP;
     }
     const extraElementProtocolClassifierPathGetters = this.pluginManager
       .getPureProtocolProcessorPlugins()

package/src/graph-manager/protocol/pure/v1/engine/V1_Engine.ts

@@ -143,6 +143,7 @@ import {
   V1_testDataGenerationResultModelSchema,
 } from './service/V1_TestDataGenerationResult.js';
 import { V1_RelationalConnectionBuilder } from './relational/V1_RelationalConnectionBuilder.js';
+import { V1_DeploymentResult } from './functionActivator/V1_DeploymentResult.js';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -1071,18 +1072,14 @@ export class V1_Engine {
   async publishFunctionActivatorToSandbox(
     input: V1_FunctionActivatorInput,
   ): Promise<void> {
-    const errors =
+    const error = V1_DeploymentResult.serialization.fromJson(
       await this.engineServerClient.publishFunctionActivatorToSandbox(
         V1_FunctionActivatorInput.serialization.toJson(input),
-      );
-    if (errors.length) {
+      ),
+    );
+    if (!error.successful) {
       throw new Error(
-        `Function activator validation failed:\n${errors
-          .map((error) =>
-            V1_FunctionActivatorError.serialization.fromJson(error),
-          )
-          .map((error) => `- ${error.message}`)
-          .join('\n')}`,
+        `Function activator validation failed: ${error.errors.join('\n')}`,
       );
     }
   }

package/src/graph-manager/protocol/pure/v1/engine/V1_EngineServerClient.ts

@@ -82,6 +82,7 @@ import type { V1_TestDataGenerationInput } from './service/V1_TestDataGeneration
 import type { V1_TestDataGenerationResult } from './service/V1_TestDataGenerationResult.js';
 import type { V1_RelationalConnectionBuilder } from './relational/V1_RelationalConnectionBuilder.js';
 import type { V1_LambdaPrefix } from './lambda/V1_LambdaPrefix.js';
+import type { V1_DeploymentResult } from './functionActivator/V1_DeploymentResult.js';
 
 enum CORE_ENGINE_ACTIVITY_TRACE {
   GRAMMAR_TO_JSON = 'transform Pure code to protocol',
@@ -835,7 +836,7 @@ export class V1_EngineServerClient extends AbstractServerClient {
 
   publishFunctionActivatorToSandbox(
     input: PlainObject<V1_FunctionActivatorInput>,
-  ): Promise<PlainObject<V1_FunctionActivatorError>[]> {
+  ): Promise<PlainObject<V1_DeploymentResult>> {
     return this.postWithTracing(
       this.getTraceData(
         CORE_ENGINE_ACTIVITY_TRACE.PUBLISH_FUNCTION_ACTIVATOR_TO_SANDBOX,

package/src/graph-manager/protocol/pure/v1/engine/functionActivator/V1_DeploymentConfiguration.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 type { Hashable } from '@finos/legend-shared';
+
+export abstract class V1_DeploymentConfiguration implements Hashable {
+  abstract get hashCode(): string;
+}

package/src/graph-manager/protocol/pure/v1/engine/functionActivator/V1_DeploymentResult.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { primitive, createModelSchema, list } from 'serializr';
+import { SerializationFactory } from '@finos/legend-shared';
+
+export class V1_DeploymentResult {
+  activatorIdentifier!: string;
+  successful!: boolean;
+  errors: string[] = [];
+
+  static readonly serialization = new SerializationFactory(
+    createModelSchema(V1_DeploymentResult, {
+      activatorIdentifier: primitive(),
+      successful: primitive(),
+      errors: list(primitive()),
+    }),
+  );
+}

package/src/graph-manager/protocol/pure/v1/engine/functionActivator/V1_SnowflakeAppDeploymentConfiguration.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { hashArray, type Hashable } from '@finos/legend-shared';
+import { V1_DeploymentConfiguration } from './V1_DeploymentConfiguration.js';
+import type { V1_ConnectionPointer } from '../../model/packageableElements/connection/V1_ConnectionPointer.js';
+
+export class V1_SnowflakeAppDeploymentConfiguration
+  extends V1_DeploymentConfiguration
+  implements Hashable
+{
+  activationConnection: V1_ConnectionPointer | undefined;
+
+  override get hashCode(): string {
+    return hashArray([this.activationConnection ?? '']);
+  }
+}

package/src/graph-manager/protocol/pure/v1/engine/functionActivator/V1_SnowflakeAppType.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ */
+
+export enum V1_SnowflakeAppType {
+  FULL = 'FULL',
+  STAGE = 'STAGE',
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/V1_PackageableElement.ts

@@ -37,6 +37,7 @@ import type { V1_ExecutionEnvironmentInstance } from './service/V1_ExecutionEnvi
 import type { V1_INTERNAL__UnknownPackageableElement } from './V1_INTERNAL__UnknownPackageableElement.js';
 import type { V1_INTERNAL__UnknownFunctionActivator } from './function/V1_INTERNAL__UnknownFunctionActivator.js';
 import type { V1_INTERNAL__UnknownStore } from './store/V1_INTERNAL__UnknownStore.js';
+import type { V1_SnowflakeApp } from './function/V1_SnowflakeApp.js';
 
 export interface V1_PackageableElementVisitor<T> {
   visit_PackageableElement(element: V1_PackageableElement): T;
@@ -68,6 +69,7 @@ export interface V1_PackageableElementVisitor<T> {
   visit_ExecutionEnvironmentInstance(
     element: V1_ExecutionEnvironmentInstance,
   ): T;
+  visit_SnowflakeApp(element: V1_SnowflakeApp): T;
 }
 
 export abstract class V1_PackageableElement implements Hashable {

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/V1_FunctionActivator.ts

@@ -16,10 +16,16 @@
 
 import type { Hashable } from '@finos/legend-shared';
 import { V1_PackageableElement } from '../../../model/packageableElements/V1_PackageableElement.js';
+import type { V1_TaggedValue } from '../domain/V1_TaggedValue.js';
+import type { V1_StereotypePtr } from '../domain/V1_StereotypePtr.js';
+import type { V1_DeploymentConfiguration } from '../../../engine/functionActivator/V1_DeploymentConfiguration.js';
 
 export abstract class V1_FunctionActivator
   extends V1_PackageableElement
   implements Hashable
 {
   function!: string;
+  activationConfiguration: V1_DeploymentConfiguration | undefined;
+  stereotypes: V1_StereotypePtr[] = [];
+  taggedValues: V1_TaggedValue[] = [];
 }

package/src/graph-manager/protocol/pure/v1/model/packageableElements/function/V1_SnowflakeApp.ts

@@ -0,0 +1,47 @@
+/**
+ * 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 { hashArray } from '@finos/legend-shared';
+import { V1_FunctionActivator } from './V1_FunctionActivator.js';
+import type { V1_PackageableElementVisitor } from '../V1_PackageableElement.js';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.js';
+import type { V1_SnowflakeAppDeploymentConfiguration } from '../../../engine/functionActivator/V1_SnowflakeAppDeploymentConfiguration.js';
+import type { V1_SnowflakeAppType } from '../../../engine/functionActivator/V1_SnowflakeAppType.js';
+
+export class V1_SnowflakeApp extends V1_FunctionActivator {
+  applicationName!: string;
+  description: string | undefined;
+  owner: string | undefined;
+  declare activationConfiguration: V1_SnowflakeAppDeploymentConfiguration;
+  type: V1_SnowflakeAppType | undefined;
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_SnowflakeApp(this);
+  }
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SNOWFLAKE_APP,
+      this.applicationName,
+      this.description ?? '',
+      this.owner ?? '',
+      this.activationConfiguration,
+      this.type ?? '',
+    ]);
+  }
+}

package/src/graph-manager/protocol/pure/v1/model/packageableElements/runtime/V1_Runtime.ts

@@ -18,6 +18,7 @@ import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.j
 import { type Hashable, hashArray } from '@finos/legend-shared';
 import type { V1_PackageableElementPointer } from '../../../model/packageableElements/V1_PackageableElement.js';
 import type { V1_Connection } from '../../../model/packageableElements/connection/V1_Connection.js';
+import type { V1_ConnectionPointer } from '../connection/V1_ConnectionPointer.js';
 
 export abstract class V1_Runtime implements Hashable {
   abstract get hashCode(): string;
@@ -49,14 +50,29 @@ export class V1_StoreConnections implements Hashable {
   }
 }
 
+export class V1_ConnectionStores implements Hashable {
+  connectionPointer!: V1_ConnectionPointer;
+  storePointers: V1_PackageableElementPointer[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.STORE_CONNECTIONS,
+      this.connectionPointer,
+      hashArray(this.storePointers),
+    ]);
+  }
+}
+
 export class V1_EngineRuntime extends V1_Runtime implements Hashable {
   mappings: V1_PackageableElementPointer[] = [];
+  connectionStores: V1_ConnectionStores[] = [];
   connections: V1_StoreConnections[] = [];
 
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.ENGINE_RUNTIME,
       hashArray(this.mappings),
+      hashArray(this.connectionStores),
       hashArray(this.connections),
     ]);
   }