@finos/legend-graph 24.0.1 → 25.0.0

package/src/graphManager/protocol/pure/v1/engine/execution/V1_ExecutionHelper.ts

@@ -26,12 +26,13 @@ import {
   JsonExecutionResult,
   TDSExecutionResult,
   TDSBuilder,
-  TDSColumn,
+  INTERNAL__TDSColumn,
   RawExecutionResult,
 } from '../../../../../../graphManager/action/execution/ExecutionResult.js';
 import {
   type V1_ExecutionResult,
   type V1_TDSBuilder,
+  type V1_INTERNAL__TDSColumn,
   V1_ClassExecutionResult,
   V1_JsonExecutionResult,
   V1_INTERNAL__UnknownExecutionResult,
@@ -50,19 +51,23 @@ const buildJSONExecutionResult = (
   return metamodel;
 };
 
+const INTERNAL__buildTDSColumn = (
+  protocol: V1_INTERNAL__TDSColumn,
+): INTERNAL__TDSColumn => {
+  const metamodel = new INTERNAL__TDSColumn();
+  metamodel.name = guaranteeNonNullable(
+    protocol.name,
+    `TDS column 'name' field is missing`,
+  );
+  metamodel.type = protocol.type;
+  metamodel.doc = protocol.doc;
+  metamodel.relationalType = protocol.relationalType;
+  return metamodel;
+};
+
 const buildTDSBuilder = (protocol: V1_TDSBuilder): TDSBuilder => {
   const builder = new TDSBuilder();
-  builder.columns = protocol.columns.map((_column) => {
-    const column = new TDSColumn();
-    column.name = guaranteeNonNullable(
-      _column.name,
-      `TDS column 'name' field is missing`,
-    );
-    column.type = _column.type;
-    column.doc = _column.doc;
-    column.relationalType = _column.relationalType;
-    return column;
-  });
+  builder.columns = protocol.columns.map(INTERNAL__buildTDSColumn);
   return builder;
 };
 

package/src/graphManager/protocol/pure/v1/engine/execution/V1_ExecutionResult.ts

@@ -48,14 +48,20 @@ export class V1_JsonExecutionResult extends V1_ExecutionResult {
   );
 }
 
-export class V1_TDSColumn {
+/**
+ * TODO?: maybe we converge to use V1_TDSColumn
+ *
+ * Since here, we're building out the result builder config, we don't need
+ * to fully resolve all the references, hence we have this simplified version of V1_TDSColumn
+ */
+export class V1_INTERNAL__TDSColumn {
   name!: string;
   doc?: string | undefined;
   type?: string | undefined;
   relationalType?: string | undefined;
 
   static readonly serialization = new SerializationFactory(
-    createModelSchema(V1_TDSColumn, {
+    createModelSchema(V1_INTERNAL__TDSColumn, {
       name: primitive(),
       doc: optional(primitive()),
       type: optional(primitive()),
@@ -65,12 +71,14 @@ export class V1_TDSColumn {
 }
 
 export class V1_TDSBuilder extends V1_ResultBuilder {
-  columns: V1_TDSColumn[] = [];
+  columns: V1_INTERNAL__TDSColumn[] = [];
 
   static readonly serialization = new SerializationFactory(
     createModelSchema(V1_TDSBuilder, {
       _type: primitive(),
-      columns: list(usingModelSchema(V1_TDSColumn.serialization.schema)),
+      columns: list(
+        usingModelSchema(V1_INTERNAL__TDSColumn.serialization.schema),
+      ),
     }),
   );
 }

package/src/graphManager/protocol/pure/v1/model/packageableElements/V1_PackageableElement.ts

@@ -33,6 +33,7 @@ import type { V1_Measure } from './domain/V1_Measure.js';
 import type { V1_SectionIndex } from './section/V1_SectionIndex.js';
 import type { V1_DataElement } from './data/V1_DataElement.js';
 import { ELEMENT_PATH_DELIMITER } from '../../../../../../graph/MetaModelConst.js';
+import type { V1_ExecutionEnvironmentInstance } from './service/V1_ExecutionEnvironmentInstance.js';
 
 export interface V1_PackageableElementVisitor<T> {
   visit_PackageableElement(element: V1_PackageableElement): T;
@@ -53,6 +54,9 @@ export interface V1_PackageableElementVisitor<T> {
   visit_GenerationSpecification(element: V1_GenerationSpecification): T;
   visit_FileGeneration(element: V1_FileGenerationSpecification): T;
   visit_DataElement(element: V1_DataElement): T;
+  visit_ExecutionEnvironmentInstance(
+    element: V1_ExecutionEnvironmentInstance,
+  ): T;
 }
 
 export abstract class V1_PackageableElement implements Hashable {
@@ -80,10 +84,10 @@ export abstract class V1_PackageableElement implements Hashable {
 }
 
 export class V1_PackageableElementPointer implements Hashable {
-  type!: string;
+  type?: string | undefined;
   path!: string;
 
-  constructor(type: string, path: string) {
+  constructor(type: string | undefined, path: string) {
     this.type = type;
     this.path = path;
   }
@@ -91,7 +95,7 @@ export class V1_PackageableElementPointer implements Hashable {
   get hashCode(): string {
     return hashArray([
       CORE_HASH_STRUCTURE.PACKAGEABLE_ELEMENT_POINTER,
-      this.type,
+      this.type ?? '',
       this.path,
     ]);
   }

package/src/graphManager/protocol/pure/v1/model/packageableElements/service/V1_ExecutionEnvironmentInstance.ts

@@ -0,0 +1,82 @@
+/**
+ * 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, hashArray } from '@finos/legend-shared';
+import { CORE_HASH_STRUCTURE } from '../../../../../../../graph/Core_HashUtils.js';
+import type { V1_Runtime } from '../runtime/V1_Runtime.js';
+import {
+  V1_PackageableElement,
+  type V1_PackageableElementVisitor,
+} from '../V1_PackageableElement.js';
+
+export class V1_ExecutionEnvironmentInstance
+  extends V1_PackageableElement
+  implements Hashable
+{
+  executionParameters: V1_ExecutionParameters[] = [];
+
+  override get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.EXECUTION_ENVIRONMENT_INSTANCE,
+      this.path,
+      hashArray(this.executionParameters),
+    ]);
+  }
+
+  accept_PackageableElementVisitor<T>(
+    visitor: V1_PackageableElementVisitor<T>,
+  ): T {
+    return visitor.visit_ExecutionEnvironmentInstance(this);
+  }
+}
+
+export abstract class V1_ExecutionParameters implements Hashable {
+  abstract get hashCode(): string;
+}
+
+export class V1_SingleExecutionParameters
+  extends V1_ExecutionParameters
+  implements Hashable
+{
+  key!: string;
+  mapping!: string;
+  runtime!: V1_Runtime;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.SINGLE_EXECUTION_PARAMETER,
+      this.key,
+      this.mapping,
+      this.runtime,
+    ]);
+  }
+}
+
+export class V1_MultiExecutionParameters
+  extends V1_ExecutionParameters
+  implements Hashable
+{
+  masterKey!: string;
+  singleExecutionParameters: V1_SingleExecutionParameters[] = [];
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.MULTI_EXECUTION_PARAMETER,
+      this.masterKey,
+      hashArray(this.singleExecutionParameters),
+    ]);
+  }
+}

package/src/graphManager/protocol/pure/v1/model/packageableElements/store/relational/connection/V1_AuthenticationStrategy.ts

@@ -149,3 +149,19 @@ export class V1_MiddleTierUsernamePasswordAuthenticationStrategy
     ]);
   }
 }
+
+export class V1_TrinoDelegatedKerberosAuthenticationStrategy
+  extends V1_AuthenticationStrategy
+  implements Hashable
+{
+  kerberosRemoteServiceName!: string;
+  kerberosUseCanonicalHostname!: boolean;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_DELEGATED_KERBEROS_AUTHENTICATION_STRATEGY,
+      this.kerberosRemoteServiceName,
+      this.kerberosUseCanonicalHostname.toString(),
+    ]);
+  }
+}

package/src/graphManager/protocol/pure/v1/model/packageableElements/store/relational/connection/V1_DatasourceSpecification.ts

@@ -194,3 +194,42 @@ export class V1_LocalH2DataSourceSpecification
     ]);
   }
 }
+
+export class V1_TrinoSslSpecification implements Hashable {
+  ssl!: boolean;
+  trustStorePathVaultReference?: string | undefined;
+  trustStorePasswordVaultReference?: string | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_SSL_SPECIFICATION,
+      this.ssl.toString(),
+      this.trustStorePathVaultReference ?? '',
+      this.trustStorePasswordVaultReference ?? '',
+    ]);
+  }
+}
+
+export class V1_TrinoDatasourceSpecification
+  extends V1_DatasourceSpecification
+  implements Hashable
+{
+  host!: string;
+  port!: number;
+  sslSpecification!: V1_TrinoSslSpecification;
+  catalog?: string | undefined;
+  schema?: string | undefined;
+  clientTags?: string | undefined;
+
+  get hashCode(): string {
+    return hashArray([
+      CORE_HASH_STRUCTURE.TRINO_DATASOURCE_SPECIFICATION,
+      this.host,
+      this.port.toString(),
+      this.sslSpecification,
+      this.catalog ?? '',
+      this.schema ?? '',
+      this.clientTags ?? '',
+    ]);
+  }
+}

package/src/graphManager/protocol/pure/v1/model/packageableElements/store/relational/connection/V1_RelationalDatabaseConnection.ts

@@ -47,6 +47,7 @@ export enum V1_DatabaseType {
   Presto = 'Presto',
   Redshift = 'Redshift',
   Spanner = 'Spanner',
+  Trino = 'Trino',
 }
 
 export abstract class V1_DatabaseConnection extends V1_Connection {

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/from/V1_ConnectionTransformer.ts

@@ -39,6 +39,7 @@ import {
   UsernamePasswordAuthenticationStrategy,
   GCPWorkloadIdentityFederationAuthenticationStrategy,
   MiddleTierUsernamePasswordAuthenticationStrategy,
+  TrinoDelegatedKerberosAuthenticationStrategy,
 } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/connection/AuthenticationStrategy.js';
 import {
   type DatasourceSpecification,
@@ -50,6 +51,7 @@ import {
   RedshiftDatasourceSpecification,
   BigQueryDatasourceSpecification,
   SpannerDatasourceSpecification,
+  TrinoDatasourceSpecification,
 } from '../../../../../../../graph/metamodel/pure/packageableElements/store/relational/connection/DatasourceSpecification.js';
 import type { ModelChainConnection } from '../../../../../../../graph/metamodel/pure/packageableElements/store/modelToModel/connection/ModelChainConnection.js';
 import { V1_initPackageableElement } from './V1_CoreTransformerHelper.js';
@@ -64,6 +66,8 @@ import {
   V1_StaticDatasourceSpecification,
   V1_RedshiftDatasourceSpecification,
   V1_SpannerDatasourceSpecification,
+  V1_TrinoDatasourceSpecification,
+  V1_TrinoSslSpecification,
 } from '../../../model/packageableElements/store/relational/connection/V1_DatasourceSpecification.js';
 import {
   type V1_AuthenticationStrategy,
@@ -76,6 +80,7 @@ import {
   V1_OAuthAuthenticationStrategy,
   V1_GCPWorkloadIdentityFederationAuthenticationStrategy,
   V1_MiddleTierUsernamePasswordAuthenticationStrategy,
+  V1_TrinoDelegatedKerberosAuthenticationStrategy,
 } from '../../../model/packageableElements/store/relational/connection/V1_AuthenticationStrategy.js';
 import type { V1_Connection } from '../../../model/packageableElements/connection/V1_Connection.js';
 import {
@@ -178,6 +183,25 @@ const transformSpannerDatasourceSpecification = (
   return source;
 };
 
+const transformTrinoDatasourceSpecification = (
+  metamodel: TrinoDatasourceSpecification,
+): V1_TrinoDatasourceSpecification => {
+  const source = new V1_TrinoDatasourceSpecification();
+  source.host = metamodel.host;
+  source.port = metamodel.port;
+  source.catalog = metamodel.catalog;
+  source.schema = metamodel.schema;
+  source.clientTags = metamodel.clientTags;
+  const sslSpecification = new V1_TrinoSslSpecification();
+  sslSpecification.ssl = metamodel.sslSpecification.ssl;
+  sslSpecification.trustStorePathVaultReference =
+    metamodel.sslSpecification.trustStorePathVaultReference;
+  sslSpecification.trustStorePasswordVaultReference =
+    metamodel.sslSpecification.trustStorePasswordVaultReference;
+  source.sslSpecification = sslSpecification;
+  return source;
+};
+
 const transformDatasourceSpecification = (
   metamodel: DatasourceSpecification,
   context: V1_GraphTransformerContext,
@@ -201,6 +225,8 @@ const transformDatasourceSpecification = (
     return protocol;
   } else if (metamodel instanceof RedshiftDatasourceSpecification) {
     return transformRedshiftDatasourceSpecification(metamodel);
+  } else if (metamodel instanceof TrinoDatasourceSpecification) {
+    return transformTrinoDatasourceSpecification(metamodel);
   }
   const extraConnectionDatasourceSpecificationTransformers =
     context.plugins.flatMap(
@@ -277,6 +303,13 @@ const transformAuthenticationStrategy = (
     const auth = new V1_MiddleTierUsernamePasswordAuthenticationStrategy();
     auth.vaultReference = metamodel.vaultReference;
     return auth;
+  } else if (
+    metamodel instanceof TrinoDelegatedKerberosAuthenticationStrategy
+  ) {
+    const auth = new V1_TrinoDelegatedKerberosAuthenticationStrategy();
+    auth.kerberosRemoteServiceName = metamodel.kerberosRemoteServiceName;
+    auth.kerberosUseCanonicalHostname = metamodel.kerberosUseCanonicalHostname;
+    return auth;
   }
   const extraConnectionAuthenticationStrategyTransformers =
     context.plugins.flatMap(

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/from/V1_ExecutionEnvironmentTransformer.ts

@@ -0,0 +1,72 @@
+/**
+ * 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 ExecutionEnvironmentInstance,
+  type ExecutionParameters,
+  SingleExecutionParameters,
+  MultiExecutionParameters,
+} from '../../../../../../../graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
+import { V1_initPackageableElement } from './V1_CoreTransformerHelper.js';
+import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext.js';
+import {
+  type V1_ExecutionParameters,
+  V1_ExecutionEnvironmentInstance,
+  V1_MultiExecutionParameters,
+  V1_SingleExecutionParameters,
+} from '../../../model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
+import { V1_transformRuntime } from './V1_RuntimeTransformer.js';
+import { UnsupportedOperationError } from '@finos/legend-shared';
+
+const V1_transformSingleExecutionParameters = (
+  element: SingleExecutionParameters,
+  context: V1_GraphTransformerContext,
+): V1_SingleExecutionParameters => {
+  const _val = new V1_SingleExecutionParameters();
+  _val.key = element.key;
+  _val.mapping = element.mapping.valueForSerialization ?? '';
+  _val.runtime = V1_transformRuntime(element.runtime, context);
+  return _val;
+};
+
+const V1_transformExecutionParameters = (
+  element: ExecutionParameters,
+  context: V1_GraphTransformerContext,
+): V1_ExecutionParameters => {
+  if (element instanceof SingleExecutionParameters) {
+    return V1_transformSingleExecutionParameters(element, context);
+  } else if (element instanceof MultiExecutionParameters) {
+    const val = new V1_MultiExecutionParameters();
+    val.masterKey = element.masterKey;
+    val.singleExecutionParameters = element.singleExecutionParameters.map((s) =>
+      V1_transformSingleExecutionParameters(s, context),
+    );
+    return val;
+  }
+  throw new UnsupportedOperationError('Unsupported execution parameter type');
+};
+
+export const V1_transformExecutionEnvirnoment = (
+  element: ExecutionEnvironmentInstance,
+  context: V1_GraphTransformerContext,
+): V1_ExecutionEnvironmentInstance => {
+  const execEnv = new V1_ExecutionEnvironmentInstance();
+  V1_initPackageableElement(execEnv, element);
+  execEnv.executionParameters = element.executionParameters.map((e) =>
+    V1_transformExecutionParameters(e, context),
+  );
+  return execEnv;
+};

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/from/V1_PackageableElementTransformer.ts

@@ -66,6 +66,8 @@ import type {
 import type { V1_GraphTransformerContext } from './V1_GraphTransformerContext.js';
 import type { DataElement } from '../../../../../../../graph/metamodel/pure/packageableElements/data/DataElement.js';
 import { V1_transformDataElement } from './V1_DataElementTransformer.js';
+import type { ExecutionEnvironmentInstance } from '../../../../../../../graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
+import { V1_transformExecutionEnvirnoment } from './V1_ExecutionEnvironmentTransformer.js';
 
 class V1_PackageableElementTransformer
   implements PackageableElementVisitor<V1_PackageableElement>
@@ -175,6 +177,12 @@ class V1_PackageableElementTransformer
   visit_DataElement(element: DataElement): V1_PackageableElement {
     return V1_transformDataElement(element, this.context);
   }
+
+  visit_ExecutionEnvironmentInstance(
+    element: ExecutionEnvironmentInstance,
+  ): V1_PackageableElement {
+    return V1_transformExecutionEnvirnoment(element, this.context);
+  }
 }
 
 export const V1_transformPackageableElement = (

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementFifthPassBuilder.ts

@@ -44,6 +44,7 @@ import type { V1_Measure } from '../../../model/packageableElements/domain/V1_Me
 import { V1_buildDatabaseSchemaViewsSecondPass } from './helpers/V1_DatabaseBuilderHelper.js';
 import type { V1_SectionIndex } from '../../../model/packageableElements/section/V1_SectionIndex.js';
 import type { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement.js';
+import type { V1_ExecutionEnvironmentInstance } from '../../../model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
 
 export class V1_ElementFifthPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -139,4 +140,10 @@ export class V1_ElementFifthPassBuilder
   visit_DataElement(element: V1_DataElement): void {
     throw new UnsupportedOperationError();
   }
+
+  visit_ExecutionEnvironmentInstance(
+    element: V1_ExecutionEnvironmentInstance,
+  ): void {
+    throw new UnsupportedOperationError();
+  }
 }

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementFirstPassBuilder.ts

@@ -66,6 +66,8 @@ import { DataElement } from '../../../../../../../graph/metamodel/pure/packageab
 import { V1_buildFunctionSignature } from '../../../helpers/V1_DomainHelper.js';
 import { Multiplicity } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/Multiplicity.js';
 import { PrimitiveType } from '../../../../../../../graph/metamodel/pure/packageableElements/domain/PrimitiveType.js';
+import type { V1_ExecutionEnvironmentInstance } from '../../../model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
+import { ExecutionEnvironmentInstance } from '../../../../../../../graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
 
 export class V1_ElementFirstPassBuilder
   implements V1_PackageableElementVisitor<PackageableElement>
@@ -488,4 +490,30 @@ export class V1_ElementFirstPassBuilder
     this.context.currentSubGraph.setOwnDataElement(path, dataElement);
     return dataElement;
   }
+
+  visit_ExecutionEnvironmentInstance(
+    element: V1_ExecutionEnvironmentInstance,
+  ): PackageableElement {
+    assertNonEmptyString(
+      element.package,
+      `Execution Environment 'package' field is missing or empty`,
+    );
+    assertNonEmptyString(
+      element.name,
+      `Execution Environment 'name' field is missing or empty`,
+    );
+    const exEnvir = new ExecutionEnvironmentInstance(element.name);
+    const path = V1_buildFullPath(element.package, element.name);
+    V1_checkDuplicatedElement(path, this.context, this.elementPathCache);
+    addElementToPackage(
+      getOrCreateGraphPackage(
+        this.context.currentSubGraph,
+        element.package,
+        this.packageCache,
+      ),
+      exEnvir,
+    );
+    this.context.currentSubGraph.setOwnExecutionEnvironment(path, exEnvir);
+    return exEnvir;
+  }
 }

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementFourthPassBuilder.ts

@@ -52,6 +52,7 @@ import { V1_buildMilestoningProperties } from './helpers/V1_MilestoneBuilderHelp
 import type { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement.js';
 import { V1_buildTestSuite } from './helpers/V1_TestBuilderHelper.js';
 import { MappingTestSuite } from '../../../../../../../graph/metamodel/pure/packageableElements/mapping/MappingTestSuite.js';
+import type { V1_ExecutionEnvironmentInstance } from '../../../model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
 
 export class V1_ElementFourthPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -124,6 +125,12 @@ export class V1_ElementFourthPassBuilder
     );
   }
 
+  visit_ExecutionEnvironmentInstance(
+    element: V1_ExecutionEnvironmentInstance,
+  ): void {
+    throw new UnsupportedOperationError();
+  }
+
   visit_Mapping(element: V1_Mapping): void {
     const path = V1_buildFullPath(element.package, element.name);
     const mapping = this.context.currentSubGraph.getOwnMapping(path);

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementSecondPassBuilder.ts

@@ -87,6 +87,8 @@ import { V1_buildFunctionSignature } from '../../../helpers/V1_DomainHelper.js';
 import { getFunctionName } from '../../../../../../../graph/helpers/DomainHelper.js';
 import { GraphBuilderError } from '../../../../../../GraphManagerUtils.js';
 import { PostValidation } from '../../../../../../../graph/metamodel/pure/packageableElements/service/PostValidation.js';
+import type { V1_ExecutionEnvironmentInstance } from '../../../model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
+import { V1_buildExecutionParameters } from './V1_ExecutionEnvironmentBuilderHelper.js';
 
 export class V1_ElementSecondPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -423,4 +425,15 @@ export class V1_ElementSecondPassBuilder
     }
     dataElement.data = V1_buildEmbeddedData(element.data, this.context);
   }
+
+  visit_ExecutionEnvironmentInstance(
+    element: V1_ExecutionEnvironmentInstance,
+  ): void {
+    const execEnv = this.context.currentSubGraph.getOwnExecutionEnvironment(
+      V1_buildFullPath(element.package, element.name),
+    );
+    execEnv.executionParameters = element.executionParameters.map((e) =>
+      V1_buildExecutionParameters(e, this.context),
+    );
+  }
 }

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/to/V1_ElementThirdPassBuilder.ts

@@ -59,6 +59,7 @@ import type { V1_SectionIndex } from '../../../model/packageableElements/section
 import { GraphBuilderError } from '../../../../../../../graphManager/GraphManagerUtils.js';
 import type { V1_DataElement } from '../../../model/packageableElements/data/V1_DataElement.js';
 import { V1_TEMPORARY__buildMilestoningClass } from './helpers/V1_MilestoneBuilderHelper.js';
+import type { V1_ExecutionEnvironmentInstance } from '../../../model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
 
 export class V1_ElementThirdPassBuilder
   implements V1_PackageableElementVisitor<void>
@@ -87,6 +88,12 @@ export class V1_ElementThirdPassBuilder
     throw new UnsupportedOperationError();
   }
 
+  visit_ExecutionEnvironmentInstance(
+    element: V1_ExecutionEnvironmentInstance,
+  ): void {
+    throw new UnsupportedOperationError();
+  }
+
   visit_Class(element: V1_Class): void {
     const _class = this.context.currentSubGraph.getOwnClass(
       V1_buildFullPath(element.package, element.name),

package/src/graphManager/protocol/pure/v1/transformation/pureGraph/to/V1_ExecutionEnvironmentBuilderHelper.ts

@@ -0,0 +1,88 @@
+/**
+ * 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 {
+  assertNonNullable,
+  UnsupportedOperationError,
+} from '@finos/legend-shared';
+import {
+  type Runtime,
+  RuntimePointer,
+} from '../../../../../../../graph/metamodel/pure/packageableElements/runtime/Runtime.js';
+import {
+  type ExecutionParameters,
+  MultiExecutionParameters,
+  SingleExecutionParameters,
+} from '../../../../../../../graph/metamodel/pure/packageableElements/service/ExecutionEnvironmentInstance.js';
+import {
+  type V1_Runtime,
+  V1_EngineRuntime,
+  V1_RuntimePointer,
+} from '../../../model/packageableElements/runtime/V1_Runtime.js';
+import {
+  type V1_ExecutionParameters,
+  V1_MultiExecutionParameters,
+  V1_SingleExecutionParameters,
+} from '../../../model/packageableElements/service/V1_ExecutionEnvironmentInstance.js';
+import { V1_buildEngineRuntime } from './helpers/V1_RuntimeBuilderHelper.js';
+import type { V1_GraphBuilderContext } from './V1_GraphBuilderContext.js';
+
+const buildExecutionRuntime = (
+  runtime: V1_Runtime,
+  context: V1_GraphBuilderContext,
+): Runtime => {
+  if (runtime instanceof V1_RuntimePointer) {
+    assertNonNullable(
+      runtime.runtime,
+      `Runtime pointer 'runtime' field is missing`,
+    );
+    return new RuntimePointer(context.resolveRuntime(runtime.runtime));
+  } else if (runtime instanceof V1_EngineRuntime) {
+    return V1_buildEngineRuntime(runtime, context);
+  }
+  throw new UnsupportedOperationError();
+};
+
+export const V1_buildSingleExecutionParameters = (
+  protocol: V1_SingleExecutionParameters,
+  context: V1_GraphBuilderContext,
+): SingleExecutionParameters => {
+  const element = new SingleExecutionParameters();
+  element.key = protocol.key;
+  element.mapping = context.resolveMapping(protocol.mapping);
+  element.runtime = buildExecutionRuntime(protocol.runtime, context);
+
+  return element;
+};
+
+export const V1_buildExecutionParameters = (
+  protocol: V1_ExecutionParameters,
+  context: V1_GraphBuilderContext,
+): ExecutionParameters => {
+  if (protocol instanceof V1_SingleExecutionParameters) {
+    return V1_buildSingleExecutionParameters(protocol, context);
+  } else if (protocol instanceof V1_MultiExecutionParameters) {
+    const element = new MultiExecutionParameters();
+    element.masterKey = protocol.masterKey;
+    element.singleExecutionParameters = protocol.singleExecutionParameters.map(
+      (e) => V1_buildSingleExecutionParameters(e, context),
+    );
+    return element;
+  }
+  throw new UnsupportedOperationError(
+    'Unsupported execution environment parameter type',
+  );
+};