generator-jhipster 8.7.0 → 8.7.2

package/dist/lib/jdl/converters/json-to-jdl-entity-converter.js

@@ -0,0 +1,281 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 JDLObject from '../core/models/jdl-object.js';
+import { JDLEntity, JDLEnum } from '../core/models/index.js';
+import JDLField from '../core/models/jdl-field.js';
+import JDLValidation from '../core/models/jdl-validation.js';
+import JDLRelationship from '../core/models/jdl-relationship.js';
+import JDLUnaryOption from '../core/models/jdl-unary-option.js';
+import JDLBinaryOption from '../core/models/jdl-binary-option.js';
+import { lowerFirst, upperFirst } from '../core/utils/string-utils.js';
+import { binaryOptions, relationshipOptions, unaryOptions } from '../core/built-in-options/index.js';
+import { asJdlRelationshipType } from '../core/basic-types/relationship-types.js';
+const { BUILT_IN_ENTITY } = relationshipOptions;
+const { FILTER, NO_FLUENT_METHOD, READ_ONLY, EMBEDDED } = unaryOptions;
+const { ANGULAR_SUFFIX, CLIENT_ROOT_FOLDER, DTO, MICROSERVICE, PAGINATION, SEARCH, SERVICE } = binaryOptions.Options;
+export default {
+    convertEntitiesToJDL,
+};
+let entities;
+let jdlObject;
+/**
+ * Convert the passed entities (parsed from JSON files) to a JDL object.
+ * @param params - an object containing the entities and relevant options.
+ * @param params.entities - a Map having for keys the entity names and values the JSON entity files.
+ * @return the parsed entities in the JDL form.
+ */
+export function convertEntitiesToJDL(entities) {
+    if (!entities) {
+        throw new Error('Entities have to be passed to be converted.');
+    }
+    init(entities);
+    addEntities();
+    addRelationshipsToJDL();
+    return jdlObject;
+}
+function init(ents) {
+    entities = ents;
+    jdlObject = new JDLObject();
+}
+function addEntities() {
+    entities.forEach((entity, entityName) => {
+        addEntity(entity, entityName);
+    });
+}
+function addEntity(entity, entityName) {
+    jdlObject.addEntity(convertJSONToJDLEntity(entity, entityName));
+    addEnumsToJDL(entity);
+    addEntityOptionsToJDL(entity, entityName);
+}
+function convertJSONToJDLEntity(entity, entityName) {
+    const jdlEntity = new JDLEntity({
+        name: entityName,
+        tableName: entity.entityTableName,
+        comment: entity.documentation,
+        annotations: entity.annotations,
+    });
+    addFields(jdlEntity, entity);
+    return jdlEntity;
+}
+function addFields(jdlEntity, entity) {
+    entity?.fields?.forEach(field => {
+        jdlEntity.addField(convertJSONToJDLField(field));
+    });
+}
+function convertJSONToJDLField(field) {
+    const jdlField = new JDLField({
+        name: lowerFirst(field.fieldName),
+        type: field.fieldType,
+        comment: field.documentation,
+    });
+    addValidations(jdlField, field);
+    return jdlField;
+}
+function addValidations(jdlField, field) {
+    if (field.fieldValidateRules) {
+        field.fieldValidateRules.forEach((rule) => {
+            jdlField.addValidation(convertJSONToJDLValidation(rule, field));
+        });
+    }
+}
+function convertJSONToJDLValidation(rule, field) {
+    return new JDLValidation({
+        name: rule,
+        value: field[`fieldValidateRules${upperFirst(rule)}`],
+    });
+}
+function addEnumsToJDL(entity) {
+    entity?.fields?.forEach((field) => {
+        if (field.fieldValues !== undefined) {
+            jdlObject.addEnum(new JDLEnum({
+                name: field.fieldType,
+                values: getEnumValuesFromString(field.fieldValues),
+                comment: field.fieldTypeDocumentation,
+            }));
+        }
+    });
+}
+function getEnumValuesFromString(valuesAsString) {
+    return valuesAsString.split(',').map(fieldValue => {
+        // if fieldValue looks like ENUM_VALUE (something)
+        if (fieldValue.includes('(')) {
+            const [key, value] = fieldValue
+                .replace(/^(\w+)\s\((\w+)\)$/, (match, matchedKey, matchedValue) => `${matchedKey},${matchedValue}`)
+                .split(',');
+            return {
+                key,
+                value,
+            };
+        }
+        return { key: fieldValue };
+    });
+}
+/*
+ * Adds relationships for entities to JDL.
+ * The jdl passed must contain the jdl entities concerned by the relationships
+ */
+function addRelationshipsToJDL() {
+    entities.forEach((entity, entityName) => {
+        dealWithRelationships(entity.relationships, entityName);
+    });
+}
+function dealWithRelationships(relationships, entityName) {
+    if (!relationships) {
+        return;
+    }
+    relationships.forEach(relationship => {
+        if (relationship.relationshipSide === 'right') {
+            // Right side will be merged into the left side.
+            return;
+        }
+        const jdlRelationship = getRelationship(relationship, entityName);
+        if (jdlRelationship) {
+            jdlObject.addRelationship(jdlRelationship);
+        }
+    });
+}
+function getRelationship(relationship, entityName) {
+    const type = asJdlRelationshipType(relationship.relationshipType);
+    const options = getRelationshipOptions(relationship);
+    const sourceEntitySideAttributes = getSourceEntitySideAttributes(entityName, relationship);
+    const destinationEntityName = upperFirst(relationship.otherEntityName);
+    const destinationJDLEntity = jdlObject.getEntity(destinationEntityName);
+    const destinationEntity = entities.get(destinationEntityName);
+    let relationshipConfiguration = {
+        side: relationship.relationshipSide,
+        from: entityName,
+        to: destinationJDLEntity?.name ?? destinationEntityName,
+        type,
+        options,
+        injectedFieldInFrom: sourceEntitySideAttributes.injectedFieldInSourceEntity,
+        isInjectedFieldInFromRequired: sourceEntitySideAttributes.injectedFieldInSourceIsRequired,
+        commentInFrom: sourceEntitySideAttributes.commentForSourceEntity,
+        isInjectedFieldInToRequired: false,
+        injectedFieldInTo: null,
+        commentInTo: null,
+    };
+    relationshipConfiguration = {
+        ...relationshipConfiguration,
+        ...sourceEntitySideAttributes,
+    };
+    if (!destinationJDLEntity || !destinationEntity) {
+        if (relationshipConfiguration.options.global[BUILT_IN_ENTITY]) {
+            return new JDLRelationship(relationshipConfiguration);
+        }
+        return undefined;
+    }
+    const isEntityTheDestinationSideEntity = (otherEntityName, otherEntityRelationshipName) => otherEntityName === entityName && otherEntityRelationshipName === relationship.relationshipName;
+    const destinationSideAttributes = getDestinationEntitySideAttributes(isEntityTheDestinationSideEntity, destinationEntity.relationships);
+    relationshipConfiguration = {
+        ...relationshipConfiguration,
+        injectedFieldInTo: destinationSideAttributes.injectedFieldInDestinationEntity,
+        isInjectedFieldInToRequired: destinationSideAttributes.injectedFieldInDestinationIsRequired ?? false,
+        commentInTo: destinationSideAttributes.commentForDestinationEntity,
+    };
+    return new JDLRelationship(relationshipConfiguration);
+}
+function getSourceEntitySideAttributes(entityName, relationship) {
+    return {
+        sourceEntity: entityName,
+        injectedFieldInSourceEntity: getInjectedFieldInSourceEntity(relationship),
+        injectedFieldInSourceIsRequired: relationship.relationshipValidateRules,
+        commentForSourceEntity: relationship.documentation,
+    };
+}
+function getDestinationEntitySideAttributes(isEntityTheDestinationSideEntity, destinationEntityRelationships) {
+    const foundDestinationSideEntity = destinationEntityRelationships?.find(destinationEntityFromRelationship => {
+        return isEntityTheDestinationSideEntity(upperFirst(destinationEntityFromRelationship.otherEntityName), destinationEntityFromRelationship.otherEntityRelationshipName);
+    });
+    if (!foundDestinationSideEntity) {
+        return {};
+    }
+    // Bidirectional relationship
+    let injectedFieldInDestinationEntity = foundDestinationSideEntity.relationshipName;
+    if (!!foundDestinationSideEntity.otherEntityField && foundDestinationSideEntity.otherEntityField !== 'id') {
+        injectedFieldInDestinationEntity += `(${foundDestinationSideEntity.otherEntityField})`;
+    }
+    const injectedFieldInDestinationIsRequired = !!foundDestinationSideEntity.relationshipValidateRules;
+    const commentForDestinationEntity = foundDestinationSideEntity.documentation;
+    return {
+        injectedFieldInDestinationEntity,
+        injectedFieldInDestinationIsRequired,
+        commentForDestinationEntity,
+    };
+}
+function getRelationshipOptions(relationship) {
+    const options = {
+        global: {},
+        source: relationship.options ?? {},
+        destination: {},
+    };
+    if (relationship.relationshipWithBuiltInEntity) {
+        options.global[BUILT_IN_ENTITY] = true;
+    }
+    return options;
+}
+function getInjectedFieldInSourceEntity(relationship) {
+    return (relationship.relationshipName +
+        (relationship.otherEntityField && relationship.otherEntityField !== 'id' ? `(${relationship.otherEntityField})` : ''));
+}
+function addEntityOptionsToJDL(entity, entityName) {
+    if (entity.fluentMethods === false) {
+        addUnaryOptionToJDL(NO_FLUENT_METHOD, entityName);
+    }
+    [DTO, PAGINATION, SERVICE].forEach(option => {
+        if (entity[option] && entity[option] !== 'no') {
+            addBinaryOptionToJDL(option, entity[option], entityName);
+        }
+    });
+    if (entity.searchEngine) {
+        addBinaryOptionToJDL(SEARCH, entity.searchEngine, entityName);
+    }
+    // angularSuffix in BinaryOptions, angularJSSuffix in Json
+    if (entity.angularJSSuffix) {
+        addBinaryOptionToJDL(ANGULAR_SUFFIX, entity.angularJSSuffix, entityName);
+    }
+    // microservice in BinaryOptions, microserviceName in Json
+    if (entity.microserviceName !== undefined) {
+        addBinaryOptionToJDL(MICROSERVICE, entity.microserviceName, entityName);
+    }
+    if (entity.jpaMetamodelFiltering === true) {
+        addUnaryOptionToJDL(FILTER, entityName);
+    }
+    if (entity.readOnly === true) {
+        addUnaryOptionToJDL(READ_ONLY, entityName);
+    }
+    if (entity.embedded === true) {
+        addUnaryOptionToJDL(EMBEDDED, entityName);
+    }
+    if (entity.clientRootFolder) {
+        addBinaryOptionToJDL(CLIENT_ROOT_FOLDER, entity.clientRootFolder, entityName);
+    }
+}
+function addUnaryOptionToJDL(unaryOption, entityName) {
+    jdlObject.addOption(new JDLUnaryOption({
+        name: unaryOption,
+        entityNames: new Set([entityName]),
+    }));
+}
+function addBinaryOptionToJDL(binaryOption, value, entityName) {
+    jdlObject.addOption(new JDLBinaryOption({
+        name: binaryOption,
+        value,
+        entityNames: new Set([entityName]),
+    }));
+}

package/dist/lib/jdl/converters/json-to-jdl-option-converter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 JDLObject from '../core/models/jdl-object.js';
+declare const _default: {
+    convertServerOptionsToJDL: typeof convertServerOptionsToJDL;
+};
+export default _default;
+/**
+ * Parses the jhipster configuration into JDL.
+ * @param config the jhipster config ('generator-jhipster' in .yo-rc.json)
+ * @param jdl to which the parsed options are added. If undefined a new JDLObject is created.
+ * @returns the JDLObject
+ */
+export declare function convertServerOptionsToJDL(config: any, jdl: JDLObject): JDLObject;

package/dist/lib/jdl/converters/json-to-jdl-option-converter.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 JDLObject from '../core/models/jdl-object.js';
+import { unaryOptions } from '../core/built-in-options/index.js';
+import JDLUnaryOption from '../core/models/jdl-unary-option.js';
+const { SKIP_CLIENT, SKIP_SERVER } = unaryOptions;
+export default {
+    convertServerOptionsToJDL,
+};
+/**
+ * Parses the jhipster configuration into JDL.
+ * @param config the jhipster config ('generator-jhipster' in .yo-rc.json)
+ * @param jdl to which the parsed options are added. If undefined a new JDLObject is created.
+ * @returns the JDLObject
+ */
+export function convertServerOptionsToJDL(config, jdl) {
+    const jdlObject = jdl || new JDLObject();
+    const jhipsterConfig = config || {};
+    [SKIP_CLIENT, SKIP_SERVER].forEach(option => {
+        if (jhipsterConfig[option] === true) {
+            jdlObject.addOption(new JDLUnaryOption({
+                name: option,
+            }));
+        }
+    });
+    return jdlObject;
+}

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/application-converter.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 JDLApplication from '../../core/models/jdl-application.js';
+import type { JDLRuntime } from '../../core/types/runtime.js';
+import type { ParsedJDLApplication } from '../../core/types/parsed.js';
+declare const _default: {
+    convertApplications: typeof convertApplications;
+};
+export default _default;
+/**
+ * Converts parsed applications to JDL applications.
+ * @param {Array<Object>} parsedApplications - the parsed applications.
+ * @return {Array} the converted JDL applications.
+ */
+export declare function convertApplications(parsedApplications: ParsedJDLApplication[], runtime: JDLRuntime): JDLApplication[];

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/application-converter.js

@@ -0,0 +1,61 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 { createJDLApplication } from '../../core/models/jdl-application-factory.js';
+import { applicationOptions as ApplicationOptions } from '../../../jhipster/index.js';
+import { convertOptions } from './option-converter.js';
+const { OptionNames: { BASE_NAME }, } = ApplicationOptions;
+export default { convertApplications };
+/**
+ * Converts parsed applications to JDL applications.
+ * @param {Array<Object>} parsedApplications - the parsed applications.
+ * @return {Array} the converted JDL applications.
+ */
+export function convertApplications(parsedApplications, runtime) {
+    if (!parsedApplications) {
+        throw new Error('Applications have to be passed so as to be converted.');
+    }
+    return parsedApplications.map(parsedApplication => {
+        const jdlApplication = createJDLApplication(parsedApplication.config, parsedApplication.namespaceConfigs, runtime);
+        jdlApplication.addEntityNames(parsedApplication.entities);
+        const entityOptions = getEntityOptionsInApplication(parsedApplication);
+        checkEntityNamesInOptions(jdlApplication.getConfigurationOptionValue(BASE_NAME), entityOptions, parsedApplication.entities);
+        entityOptions.forEach(option => jdlApplication.addOption(option));
+        return jdlApplication;
+    });
+}
+function getEntityOptionsInApplication(parsedApplication) {
+    return convertOptions(parsedApplication.options, parsedApplication.useOptions || []);
+}
+/**
+ * Checks whether the entity names used in the options are present in the entity names declared for the application.
+ * @param applicationName - the application's name
+ * @param entityOptions - the options declared in the application
+ * @param entityNamesInApplication - the entity names declared in the application
+ */
+function checkEntityNamesInOptions(applicationName, entityOptions, entityNamesInApplication) {
+    const entityNamesInApplicationSet = new Set(entityNamesInApplication);
+    entityOptions.forEach(option => {
+        const entityNamesForTheOption = option.resolveEntityNames(entityNamesInApplication);
+        entityNamesForTheOption.forEach(entityNameForTheOption => {
+            if (!entityNamesInApplicationSet.has(entityNameForTheOption)) {
+                throw new Error(`The entity ${entityNameForTheOption} in the ${option.name} option isn't declared in ${applicationName}'s entity list.`);
+            }
+        });
+    });
+}

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/deployment-converter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 JDLDeployment from '../../core/models/jdl-deployment.js';
+import type { ParsedJDLDeployment } from '../../core/types/parsed.js';
+declare const _default: {
+    convertDeployments: typeof convertDeployments;
+};
+export default _default;
+/**
+ * Converts a parsed JDL content corresponding to deployments to an array of JDLDeployment objects.
+ * @param {Array} parsedDeployments - parsed JDL deployments.
+ * @return the converted JDLDeployment objects.
+ */
+export declare function convertDeployments(parsedDeployments: ParsedJDLDeployment[]): JDLDeployment[];

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/deployment-converter.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 JDLDeployment from '../../core/models/jdl-deployment.js';
+export default { convertDeployments };
+/**
+ * Converts a parsed JDL content corresponding to deployments to an array of JDLDeployment objects.
+ * @param {Array} parsedDeployments - parsed JDL deployments.
+ * @return the converted JDLDeployment objects.
+ */
+export function convertDeployments(parsedDeployments) {
+    if (!parsedDeployments) {
+        throw new Error('Deployments have to be passed so as to be converted.');
+    }
+    return parsedDeployments.map(parsedDeployment => new JDLDeployment(parsedDeployment));
+}

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/entity-converter.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 { JDLEntity } from '../../core/models/index.js';
+import type JDLField from '../../core/models/jdl-field.js';
+import type { ParsedJDLEntity } from '../../core/types/parsed.js';
+declare const _default: {
+    convertEntities: typeof convertEntities;
+};
+export default _default;
+/**
+ * Converts parsed entities to JDLEntity Objects.
+ * @param {Array<Object>} parsedEntities - parsed entities from JDL content.
+ * @param {Function} jdlFieldGetterFunction - the function called to retrieve JDL fields for an entity.
+ * @returns converted JDLEntity objects.
+ */
+export declare function convertEntities(parsedEntities: ParsedJDLEntity[], jdlFieldGetterFunction: (entity: ParsedJDLEntity) => JDLField[]): JDLEntity[];

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/entity-converter.js

@@ -0,0 +1,47 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 { lowerFirst } from 'lodash-es';
+import { JDLEntity } from '../../core/models/index.js';
+import { formatComment } from '../../core/utils/format-utils.js';
+export default { convertEntities };
+/**
+ * Converts parsed entities to JDLEntity Objects.
+ * @param {Array<Object>} parsedEntities - parsed entities from JDL content.
+ * @param {Function} jdlFieldGetterFunction - the function called to retrieve JDL fields for an entity.
+ * @returns converted JDLEntity objects.
+ */
+export function convertEntities(parsedEntities, jdlFieldGetterFunction) {
+    if (!parsedEntities) {
+        throw new Error('Entities have to be passed so as to be converted.');
+    }
+    return parsedEntities.map(parsedEntity => {
+        const jdlEntity = new JDLEntity({
+            name: parsedEntity.name,
+            tableName: parsedEntity.tableName,
+            comment: formatComment(parsedEntity.documentation),
+            annotations: Object.fromEntries(parsedEntity.annotations?.map(annotation => [
+                lowerFirst(annotation.optionName),
+                annotation.type === 'UNARY' ? true : annotation.optionValue,
+            ]) ?? []),
+        });
+        const jdlFields = jdlFieldGetterFunction.call(undefined, parsedEntity);
+        jdlEntity.addFields(jdlFields);
+        return jdlEntity;
+    });
+}

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/enum-converter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 { JDLEnum } from '../../core/models/index.js';
+import type { ParsedJDLEnum } from '../../core/types/parsed.js';
+declare const _default: {
+    convertEnums: typeof convertEnums;
+};
+export default _default;
+/**
+ * Converts a parsed JDL content corresponding to enumerations to an array of JDLEnum objects.
+ * @param {Array} enumerations - parsed JDL enumerations.
+ * @return the converted JDLEnums.
+ */
+export declare function convertEnums(enumerations: ParsedJDLEnum[]): JDLEnum[];

package/dist/lib/jdl/converters/parsed-jdl-to-jdl-object/enum-converter.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright 2013-2024 the original author or authors from the JHipster project.
+ *
+ * This file is part of the JHipster project, see https://www.jhipster.tech/
+ * for more information.
+ *
+ * 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
+ *
+ *      https://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 { JDLEnum } from '../../core/models/index.js';
+import { formatComment } from '../../core/utils/format-utils.js';
+export default { convertEnums };
+/**
+ * Converts a parsed JDL content corresponding to enumerations to an array of JDLEnum objects.
+ * @param {Array} enumerations - parsed JDL enumerations.
+ * @return the converted JDLEnums.
+ */
+export function convertEnums(enumerations) {
+    if (!enumerations) {
+        throw new Error('Enumerations have to be passed so as to be converted.');
+    }
+    return enumerations.map(enumeration => convertEnum(enumeration));
+}
+/**
+ * Converts a parsed JDL content corresponding to an enumeration to a JDLEnum object.
+ * @param {Object} enumeration - a parsed JDL enumeration.
+ * @return the converted JDLEnum.
+ */
+function convertEnum(enumeration) {
+    return new JDLEnum({
+        name: enumeration.name,
+        values: enumeration.values,
+        comment: formatComment(enumeration.documentation),
+    });
+}