@finos/legend-graph 1.2.1 → 1.3.0

package/src/models/protocols/pure/DSLExternalFormat_PureProtocolProcessorPlugin.ts

@@ -0,0 +1,417 @@
+/**
+ * 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 packageJson from '../../../../package.json';
+import {
+  type PlainObject,
+  assertType,
+  guaranteeNonEmptyString,
+  assertNonNullable,
+  guaranteeNonNullable,
+} from '@finos/legend-shared';
+import { deserialize, serialize } from 'serializr';
+import type { PureModel } from '../../../graph/PureModel';
+import {
+  getBinding,
+  getSchemaSet,
+} from '../../../graphManager/DSLExternalFormat_GraphManagerHelper';
+import type { Connection } from '../../metamodels/pure/packageableElements/connection/Connection';
+import type { Mapping } from '../../metamodels/pure/packageableElements/mapping/Mapping';
+import type { PackageableElement } from '../../metamodels/pure/packageableElements/PackageableElement';
+import {
+  PackageableElementReference,
+  toOptionalPackageableElementReference,
+} from '../../metamodels/pure/packageableElements/PackageableElementReference';
+import type { Runtime } from '../../metamodels/pure/packageableElements/runtime/Runtime';
+import { ExternalFormatConnection } from '../../metamodels/pure/packageableElements/externalFormat/connection/DSLExternalFormat_ExternalFormatConnection';
+import { UrlStream } from '../../metamodels/pure/packageableElements/externalFormat/connection/DSLExternalFormat_UrlStream';
+import { Schema } from '../../metamodels/pure/packageableElements/externalFormat/schemaSet/DSLExternalFormat_Schema';
+import { SchemaSet } from '../../metamodels/pure/packageableElements/externalFormat/schemaSet/DSLExternalFormat_SchemaSet';
+import { Binding } from '../../metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_Binding';
+import { ModelUnit } from '../../metamodels/pure/packageableElements/externalFormat/store/DSLExternalFormat_ModelUnit';
+import type { Store } from '../../metamodels/pure/packageableElements/store/Store';
+import type {
+  DSLMapping_PureProtocolProcessorPlugin_Extension,
+  V1_ConnectionBuilder,
+  V1_ConnectionProtocolDeserializer,
+  V1_ConnectionProtocolSerializer,
+  V1_ConnectionTransformer,
+} from './DSLMapping_PureProtocolProcessorPlugin_Extension';
+import {
+  type V1_ElementProtocolClassifierPathGetter,
+  type V1_ElementProtocolDeserializer,
+  type V1_ElementProtocolSerializer,
+  type V1_ElementTransformer,
+  type V1_ExecutionInputGetter,
+  PureProtocolProcessorPlugin,
+} from './PureProtocolProcessorPlugin';
+import type { V1_PureModelContextData } from './v1/model/context/V1_PureModelContextData';
+import type { V1_Connection } from './v1/model/packageableElements/connection/V1_Connection';
+import { V1_ExternalFormatConnection } from './v1/model/packageableElements/externalFormat/connection/V1_DSLExternalFormat_ExternalFormatConnection';
+import { V1_UrlStream } from './v1/model/packageableElements/externalFormat/connection/V1_DSLExternalFormat_UrlStream';
+import { V1_Schema } from './v1/model/packageableElements/externalFormat/schemaSet/V1_DSLExternalFormat_Schema';
+import { V1_SchemaSet } from './v1/model/packageableElements/externalFormat/schemaSet/V1_DSLExternalFormat_SchemaSet';
+import { V1_Binding } from './v1/model/packageableElements/externalFormat/store/V1_DSLExternalFormat_Binding';
+import { V1_ModelUnit } from './v1/model/packageableElements/externalFormat/store/V1_DSLExternalFormat_ModelUnit';
+import type { V1_PackageableElement } from './v1/model/packageableElements/V1_PackageableElement';
+import {
+  V1_initPackageableElement,
+  V1_transformElementReference,
+} from './v1/transformation/pureGraph/from/V1_CoreTransformerHelper';
+import type { V1_GraphTransformerContext } from './v1/transformation/pureGraph/from/V1_GraphTransformerContext';
+import {
+  V1_resolveBinding,
+  V1_resolveSchemaSet,
+} from './v1/transformation/pureGraph/to/V1_DSLExternalFormat_GraphBuilderHelper';
+import { V1_ElementBuilder } from './v1/transformation/pureGraph/to/V1_ElementBuilder';
+import type { V1_GraphBuilderContext } from './v1/transformation/pureGraph/to/V1_GraphBuilderContext';
+import {
+  V1_bindingModelSchema,
+  V1_BINDING_ELEMENT_PROTOCOL_TYPE,
+  V1_externalFormatConnectionModelSchema,
+  V1_EXTERNAL_FORMAT_CONNECTION_ELEMENT_PROTOCOL_TYPE,
+  V1_schemaSetModelSchema,
+  V1_SCHEMA_SET_ELEMENT_PROTOCOL_TYPE,
+} from './v1/transformation/pureProtocol/serializationHelpers/V1_DSLExternalFormat_ProtocolHelper';
+
+const BINDING_ELEMENT_CLASSIFIER_PATH =
+  'meta::external::shared::format::binding::Binding';
+const SCHEMA_SET_ELEMENT_CLASSIFIER_PATH =
+  'meta::external::shared::format::metamodel::SchemaSet';
+
+export class DSLExternalFormat_PureProtocolProcessorPlugin
+  extends PureProtocolProcessorPlugin
+  implements DSLMapping_PureProtocolProcessorPlugin_Extension
+{
+  constructor() {
+    super(
+      packageJson.extensions.dsl_external_format_pureProtocolProcessorPlugin,
+      packageJson.version,
+    );
+  }
+
+  override V1_getExtraElementBuilders(): V1_ElementBuilder<V1_PackageableElement>[] {
+    return [
+      new V1_ElementBuilder<V1_Binding>({
+        elementClassName: Binding.name,
+        _class: V1_Binding,
+        firstPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): PackageableElement => {
+          assertType(elementProtocol, V1_Binding);
+          const element = new Binding(elementProtocol.name);
+          const path = context.currentSubGraph.buildPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          context.currentSubGraph
+            .getOrCreatePackage(elementProtocol.package)
+            .addElement(element);
+          context.currentSubGraph.setOwnStore(path, element);
+          return element;
+        },
+        secondPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): void => {
+          assertType(elementProtocol, V1_Binding);
+          const path = context.graph.buildPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          const element = getBinding(path, context.graph);
+          const schemaSet = elementProtocol.schemaSet
+            ? V1_resolveSchemaSet(elementProtocol.schemaSet, context)
+            : undefined;
+          element.schemaId = elementProtocol.schemaId;
+          element.schemaSet = toOptionalPackageableElementReference(schemaSet);
+
+          element.contentType = guaranteeNonEmptyString(
+            elementProtocol.contentType,
+            `Binding 'contentType' '${elementProtocol.contentType}' is not supported`,
+          );
+          assertNonNullable(
+            elementProtocol.modelUnit,
+            `Binding 'modelUnit' field is missing`,
+          );
+          const modelUnit = new ModelUnit();
+          modelUnit.packageableElementIncludes =
+            elementProtocol.modelUnit.packageableElementIncludes.map((e) =>
+              context.resolveElement(e, true),
+            );
+          modelUnit.packageableElementExcludes =
+            elementProtocol.modelUnit.packageableElementExcludes.map((e) =>
+              context.resolveElement(e, true),
+            );
+          element.modelUnit = modelUnit;
+        },
+      }),
+      new V1_ElementBuilder<V1_SchemaSet>({
+        elementClassName: SchemaSet.name,
+        _class: V1_SchemaSet,
+        firstPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): PackageableElement => {
+          assertType(elementProtocol, V1_SchemaSet);
+          const element = new SchemaSet(elementProtocol.name);
+          const path = context.currentSubGraph.buildPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          context.currentSubGraph.setOwnElementInExtension(
+            path,
+            element,
+            SchemaSet,
+          );
+          return element;
+        },
+        secondPass: (
+          elementProtocol: V1_PackageableElement,
+          context: V1_GraphBuilderContext,
+        ): void => {
+          assertType(elementProtocol, V1_SchemaSet);
+          const path = context.graph.buildPath(
+            elementProtocol.package,
+            elementProtocol.name,
+          );
+          const element = getSchemaSet(path, context.graph);
+          element.format = guaranteeNonEmptyString(elementProtocol.format);
+          element.schemas = elementProtocol.schemas.map((schema) => {
+            const schemaElement = new Schema();
+            schemaElement.setContent(
+              guaranteeNonEmptyString(
+                schema.content,
+                `Schema 'content' field is missing or empty`,
+              ),
+            );
+            schemaElement.id = schema.id;
+            schemaElement.location = schema.location;
+            return schemaElement;
+          });
+        },
+      }),
+    ];
+  }
+
+  override V1_getExtraElementClassifierPathGetters(): V1_ElementProtocolClassifierPathGetter[] {
+    return [
+      (elementProtocol: V1_PackageableElement): string | undefined => {
+        if (elementProtocol instanceof V1_Binding) {
+          return BINDING_ELEMENT_CLASSIFIER_PATH;
+        } else if (elementProtocol instanceof V1_SchemaSet) {
+          return SCHEMA_SET_ELEMENT_CLASSIFIER_PATH;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolSerializers(): V1_ElementProtocolSerializer[] {
+    return [
+      (
+        elementProtocol: V1_PackageableElement,
+        plugins: PureProtocolProcessorPlugin[],
+      ): PlainObject<V1_PackageableElement> | undefined => {
+        if (elementProtocol instanceof V1_Binding) {
+          return serialize(V1_bindingModelSchema, elementProtocol);
+        } else if (elementProtocol instanceof V1_SchemaSet) {
+          return serialize(V1_schemaSetModelSchema, elementProtocol);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementProtocolDeserializers(): V1_ElementProtocolDeserializer[] {
+    return [
+      (
+        json: PlainObject<V1_PackageableElement>,
+        plugins: PureProtocolProcessorPlugin[],
+      ): V1_PackageableElement | undefined => {
+        if (json._type === V1_BINDING_ELEMENT_PROTOCOL_TYPE) {
+          return deserialize(V1_bindingModelSchema, json);
+        } else if (json._type === V1_SCHEMA_SET_ELEMENT_PROTOCOL_TYPE) {
+          return deserialize(V1_schemaSetModelSchema, json);
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraElementTransformers(): V1_ElementTransformer[] {
+    return [
+      (
+        metamodel: PackageableElement,
+        context: V1_GraphTransformerContext,
+      ): V1_PackageableElement | undefined => {
+        if (metamodel instanceof Binding) {
+          const protocol = new V1_Binding();
+          V1_initPackageableElement(protocol, metamodel);
+          protocol.name = metamodel.name;
+          protocol.package = metamodel.package?.fullPath ?? '';
+          protocol.schemaId = metamodel.schemaId;
+          protocol.schemaSet = metamodel.schemaSet.valueForSerialization;
+          protocol.contentType = metamodel.contentType;
+          const modelUnit = new V1_ModelUnit();
+          modelUnit.packageableElementExcludes =
+            metamodel.modelUnit.packageableElementExcludes.map((path) =>
+              path instanceof PackageableElementReference
+                ? path.valueForSerialization ?? ''
+                : path,
+            );
+          modelUnit.packageableElementIncludes =
+            metamodel.modelUnit.packageableElementIncludes.map((path) =>
+              path instanceof PackageableElementReference
+                ? path.valueForSerialization ?? ''
+                : path,
+            );
+          protocol.modelUnit = modelUnit;
+          protocol.includedStores = [];
+          return protocol;
+        } else if (metamodel instanceof SchemaSet) {
+          const protocol = new V1_SchemaSet();
+          V1_initPackageableElement(protocol, metamodel);
+          protocol.name = metamodel.name;
+          protocol.package = metamodel.package?.fullPath ?? '';
+          protocol.format = metamodel.format;
+          protocol.schemas = metamodel.schemas.map((schema) => {
+            const schemaProtocol = new V1_Schema();
+            schemaProtocol.content = schema.content;
+            schemaProtocol.id = schema.id;
+            schemaProtocol.location = schema.location;
+            return schemaProtocol;
+          });
+          return protocol;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  override V1_getExtraExecutionInputGetters(): V1_ExecutionInputGetter[] {
+    return [
+      (
+        graph: PureModel,
+        mapping: Mapping,
+        runtime: Runtime,
+        protocolGraph: V1_PureModelContextData,
+      ): V1_PackageableElement[] =>
+        protocolGraph.elements.filter(
+          (element) => element instanceof V1_SchemaSet,
+        ),
+    ];
+  }
+
+  override V1_getExtraSourceInformationKeys(): string[] {
+    return ['contentSourceInformation'];
+  }
+
+  V1_getExtraConnectionBuilders(): V1_ConnectionBuilder[] {
+    return [
+      (
+        connection: V1_Connection,
+        context: V1_GraphBuilderContext,
+        store?: PackageableElementReference<Store> | undefined,
+      ): Connection | undefined => {
+        if (connection instanceof V1_ExternalFormatConnection) {
+          const Store = !store
+            ? V1_resolveBinding(
+                guaranteeNonNullable(
+                  connection.store,
+                  `External format connection 'store' field is missing`,
+                ),
+                context,
+              )
+            : connection.store
+            ? V1_resolveBinding(connection.store, context)
+            : ((): PackageableElementReference<Binding> => {
+                assertType(
+                  store.value,
+                  Binding,
+                  `External format connection store must be a Binding`,
+                );
+                return store as PackageableElementReference<Binding>;
+              })();
+          const externalFormatConnection = new ExternalFormatConnection(Store);
+          assertNonNullable(
+            connection.externalSource,
+            `External format connection 'externalSource' field is missing`,
+          );
+          const urlStream = new UrlStream();
+          urlStream.setUrl(
+            guaranteeNonEmptyString(
+              connection.externalSource.url,
+              `URL stream 'url' field is missing or empty`,
+            ),
+          );
+          externalFormatConnection.externalSource = urlStream;
+          return externalFormatConnection;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  V1_getExtraConnectionTransformers(): V1_ConnectionTransformer[] {
+    return [
+      (
+        metamodel: Connection,
+        context: V1_GraphTransformerContext,
+      ): V1_Connection | undefined => {
+        if (metamodel instanceof ExternalFormatConnection) {
+          const connection = new V1_ExternalFormatConnection();
+          connection.store = V1_transformElementReference(metamodel.store);
+          const urlStream = new V1_UrlStream();
+          urlStream.url = metamodel.externalSource.url;
+          connection.externalSource = urlStream;
+          return connection;
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  V1_getExtraConnectionProtocolSerializers(): V1_ConnectionProtocolSerializer[] {
+    return [
+      (
+        connectionProtocol: V1_Connection,
+      ): PlainObject<V1_Connection> | undefined => {
+        if (connectionProtocol instanceof V1_ExternalFormatConnection) {
+          return serialize(
+            V1_externalFormatConnectionModelSchema,
+            connectionProtocol,
+          );
+        }
+        return undefined;
+      },
+    ];
+  }
+
+  V1_getExtraConnectionProtocolDeserializers(): V1_ConnectionProtocolDeserializer[] {
+    return [
+      (json: PlainObject<V1_Connection>): V1_Connection | undefined => {
+        if (
+          json._type === V1_EXTERNAL_FORMAT_CONNECTION_ELEMENT_PROTOCOL_TYPE
+        ) {
+          return deserialize(V1_externalFormatConnectionModelSchema, json);
+        }
+        return undefined;
+      },
+    ];
+  }
+}

package/src/models/protocols/pure/v1/V1_PureGraphManager.ts

@@ -209,6 +209,9 @@ import {
 import { PackageableElementReference } from '../../../metamodels/pure/packageableElements/PackageableElementReference';
 import type { GraphPluginManager } from '../../../../GraphPluginManager';
 import type { QuerySearchSpecification } from '../../../../graphManager/action/query/QuerySearchSpecification';
+import type { ExternalFormatDescription } from '../../../../graphManager/action/externalFormat/ExternalFormatDescription';
+import type { ConfigurationProperty } from '../../../metamodels/pure/packageableElements/fileGeneration/ConfigurationProperty';
+import { V1_ExternalFormatModelGenerationInput } from './engine/externalFormat/V1_ExternalFormatModelGeneration';
 
 const V1_FUNCTION_SUFFIX_MULTIPLICITY_INFINITE = 'MANY';
 
@@ -480,7 +483,7 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           LogEvent.create(GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_SYSTEM_BUILT),
           Date.now() - startTime,
           'ms',
-          `[profile: ${systemModel.ownProfiles.length}, enumeration: ${systemModel.ownEnumerations.length}]`,
+          `[class: ${systemModel.ownClasses.length}, profile: ${systemModel.ownProfiles.length}, enumeration: ${systemModel.ownEnumerations.length}]`,
         );
       }
       systemModel.buildState.pass();
@@ -507,6 +510,18 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     options?: GraphBuilderOptions,
   ): GeneratorFn<void> {
     const startTime = Date.now();
+    if (!options?.quiet) {
+      this.log.info(
+        LogEvent.create(
+          GRAPH_MANAGER_LOG_EVENT.GRAPH_BUILDER_DEPENDENCIES_ENTITIES_FETCHED,
+        ),
+        Date.now() - startTime,
+        'ms',
+        `[projects: ${dependencyEntitiesMap.size}, entities: ${
+          Array.from(dependencyEntitiesMap.values()).flat().length
+        }]`,
+      );
+    }
     dependencyManager.buildState.reset();
     // Create a dummy graph for system processing. This is to ensure dependency models do not depend on the main graph
     const graph = new PureModel(
@@ -601,6 +616,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
           '[ERROR]',
           Date.now() - startTime,
           'ms',
+          `[elements: ${
+            Array.from(dependencyManager.projectDependencyModelsIndex.values())
+              .map((v) => v.allOwnElements)
+              .flat().length
+          }]`,
         );
       }
       dependencyManager.buildState.fail();
@@ -1724,6 +1744,26 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
     );
   }
 
+  // ------------------------------------------- External Format --------------------------------
+  getAvailableExternalFormatsDescriptions(): Promise<
+    ExternalFormatDescription[]
+  > {
+    return this.engine.getAvailableExternalFormatsDescriptions();
+  }
+
+  generateModelFromExternalFormat(
+    configurationProperties: ConfigurationProperty[],
+    graph: PureModel,
+  ): Promise<string> {
+    const config: Record<PropertyKey, unknown> = {};
+    configurationProperties.forEach((property) => {
+      config[property.name] = property.value as Record<PropertyKey, unknown>;
+    });
+    const model = this.getFullGraphModelData(graph);
+    const input = new V1_ExternalFormatModelGenerationInput(model, config);
+    return this.engine.generateModel(input);
+  }
+
   // ------------------------------------------- Import -------------------------------------------
 
   getAvailableImportConfigurationDescriptions(): Promise<
@@ -1942,8 +1982,11 @@ export class V1_PureGraphManager extends AbstractPureGraphManager {
   ): Promise<ServiceTestResult[]> {
     const protocolGraph = this.getFullGraphModelData(graph);
     const targetService = guaranteeNonNullable(
-      protocolGraph
-        .getElementsOfType(V1_Service)
+      protocolGraph.elements
+        .filter(
+          (element: V1_PackageableElement): element is V1_Service =>
+            element instanceof V1_Service,
+        )
         .find((element) => element.path === service.path),
       `Can't run service test: service '${service.path}' not found`,
     );

package/src/models/protocols/pure/v1/engine/V1_Engine.ts

@@ -70,6 +70,7 @@ import type { PureProtocolProcessorPlugin } from '../../PureProtocolProcessorPlu
 import {
   V1_buildCompilationError,
   V1_buildExecutionError,
+  V1_buildExternalFormatDescription,
   V1_buildGenerationConfigurationDescription,
   V1_buildImportConfigurationDescription,
   V1_buildParserError,
@@ -92,6 +93,9 @@ import { V1_ExecutionError } from './execution/V1_ExecutionError';
 import { V1_PureModelContextText } from '../model/context/V1_PureModelContextText';
 import { V1_QuerySearchSpecification } from './query/V1_QuerySearchSpecification';
 import type { ExecutionOptions } from '../../../../../graphManager/AbstractPureGraphManager';
+import type { ExternalFormatDescription } from '../../../../../graphManager/action/externalFormat/ExternalFormatDescription';
+import { V1_ExternalFormatDescription } from './externalFormat/V1_ExternalFormatDescription';
+import { V1_ExternalFormatModelGenerationInput } from './externalFormat/V1_ExternalFormatModelGeneration';
 
 class V1_EngineConfig extends TEMPORARY__AbstractEngineConfig {
   private engine: V1_Engine;
@@ -500,6 +504,34 @@ export class V1_Engine {
       )
     ).map((output) => V1_GenerationOutput.serialization.fromJson(output));
   }
+  // ------------------------------------------- External Format -----------------------------------------
+
+  async getAvailableExternalFormatsDescriptions(): Promise<
+    ExternalFormatDescription[]
+  > {
+    const externalFormatDescriptions =
+      await this.engineServerClient.getAvailableExternalFormatsDescriptions();
+    return externalFormatDescriptions.map((des) =>
+      V1_buildExternalFormatDescription(
+        V1_ExternalFormatDescription.serialization.fromJson(des),
+      ),
+    );
+  }
+
+  async generateModel(
+    input: V1_ExternalFormatModelGenerationInput,
+  ): Promise<string> {
+    const pmcd = (await this.engineServerClient.generateModel(
+      V1_ExternalFormatModelGenerationInput.serialization.toJson(input),
+    )) as unknown as PlainObject<V1_PureModelContextData>;
+    const pureCode =
+      ((
+        await this.engineServerClient.transformJSONToGrammar({
+          modelDataContext: pmcd,
+        })
+      ).code as string | undefined) ?? '';
+    return pureCode;
+  }
 
   // ------------------------------------------- Schema Import -------------------------------------------
 

package/src/models/protocols/pure/v1/engine/V1_EngineHelper.ts

@@ -15,6 +15,7 @@
  */
 
 import {
+  assertNonEmptyString,
   guaranteeNonEmptyString,
   guaranteeNonNullable,
 } from '@finos/legend-shared';
@@ -45,7 +46,10 @@ import {
   GenerationPropertyItem,
   getGenerationPropertyItemType,
 } from '../../../../../graphManager/action/generation/GenerationConfigurationDescription';
-import type { V1_GenerationConfigurationDescription } from './generation/V1_GenerationConfigurationDescription';
+import type {
+  V1_GenerationConfigurationDescription,
+  V1_GenerationProperty,
+} from './generation/V1_GenerationConfigurationDescription';
 import type { V1_CompilationError } from './compilation/V1_CompilationError';
 import type { V1_ParserError } from './grammar/V1_ParserError';
 import {
@@ -64,6 +68,8 @@ import {
 import { V1_TaggedValue } from '../model/packageableElements/domain/V1_TaggedValue';
 import { V1_TagPtr } from '../model/packageableElements/domain/V1_TagPtr';
 import { V1_StereotypePtr } from '../model/packageableElements/domain/V1_StereotypePtr';
+import type { V1_ExternalFormatDescription } from './externalFormat/V1_ExternalFormatDescription';
+import { ExternalFormatDescription } from '../../../../../graphManager/action/externalFormat/ExternalFormatDescription';
 
 export const V1_buildLightQuery = (
   protocol: V1_LightQuery,
@@ -299,6 +305,57 @@ export const V1_buildImportConfigurationDescription = (
   return metamodel;
 };
 
+export const V1_buildGenerationProperty = (
+  protocol: V1_GenerationProperty,
+): GenerationProperty => {
+  const metamodel = new GenerationProperty();
+  metamodel.name = guaranteeNonNullable(
+    protocol.name,
+    `Generation property 'name' field is missing`,
+  );
+  metamodel.description = guaranteeNonNullable(
+    protocol.description,
+    `Generation property 'description' field is missing`,
+  );
+  metamodel.type = getGenerationPropertyItemType(
+    guaranteeNonNullable(
+      protocol.type,
+      `Generation property 'type' field is missing`,
+    ),
+  );
+  if (protocol.items) {
+    const generationPropertyItem = new GenerationPropertyItem();
+    generationPropertyItem.types = protocol.items.types.map(
+      getGenerationPropertyItemType,
+    );
+    generationPropertyItem.enums = protocol.items.enums;
+    metamodel.items = generationPropertyItem;
+  }
+  metamodel.defaultValue = protocol.defaultValue;
+  metamodel.required = protocol.required;
+  return metamodel;
+};
+export const V1_buildExternalFormatDescription = (
+  protocol: V1_ExternalFormatDescription,
+): ExternalFormatDescription => {
+  assertNonEmptyString(
+    protocol.name,
+    `External configuration description 'name' field is missing`,
+  );
+  const metamodel = new ExternalFormatDescription(protocol.name);
+  metamodel.contentTypes = protocol.contentTypes;
+  // model generation
+  metamodel.supportsModelGeneration = protocol.supportsModelGeneration;
+  metamodel.modelGenerationProperties = protocol.modelGenerationProperties.map(
+    V1_buildGenerationProperty,
+  );
+  // schema generation
+  metamodel.supportsSchemaGeneration = protocol.supportsSchemaGeneration;
+  metamodel.schemaGenerationProperties =
+    protocol.schemaGenerationProperties.map(V1_buildGenerationProperty);
+  return metamodel;
+};
+
 export const V1_buildGenerationOutput = (
   protocol: V1_GenerationOutput,
 ): GenerationOutput => {
@@ -327,34 +384,7 @@ export const V1_buildGenerationConfigurationDescription = (
     protocol.label,
     `Generation configuration description 'label' field is missing`,
   );
-  metamodel.properties = protocol.properties.map((_property) => {
-    const property = new GenerationProperty();
-    property.name = guaranteeNonNullable(
-      _property.name,
-      `Generation property 'name' field is missing`,
-    );
-    property.description = guaranteeNonNullable(
-      _property.description,
-      `Generation property 'description' field is missing`,
-    );
-    property.type = getGenerationPropertyItemType(
-      guaranteeNonNullable(
-        _property.type,
-        `Generation property 'type' field is missing`,
-      ),
-    );
-    if (_property.items) {
-      const generationPropertyItem = new GenerationPropertyItem();
-      generationPropertyItem.types = _property.items.types.map(
-        getGenerationPropertyItemType,
-      );
-      generationPropertyItem.enums = _property.items.enums;
-      property.items = generationPropertyItem;
-    }
-    property.defaultValue = _property.defaultValue;
-    property.required = _property.required;
-    return property;
-  });
+  metamodel.properties = protocol.properties.map(V1_buildGenerationProperty);
   metamodel.generationMode = guaranteeNonNullable(
     Object.values(GenerationMode).find(
       (mode) => mode === protocol.generationMode,