generator-jhipster 8.7.0 → 8.7.1

package/dist/generators/server/options/message-broker.js

@@ -1,31 +0,0 @@
-/**
- * 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.
- */
-export const MESSAGE_BROKER = 'messageBroker';
-export const MESSAGE_BROKER_KAFKA = 'kafka';
-export const MESSAGE_BROKER_PULSAR = 'pulsar';
-export const MESSAGE_BROKER_NO = 'no';
-const ALPHANUMERIC_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
-const optionDefinition = {
-    name: MESSAGE_BROKER,
-    type: 'string',
-    tokenType: 'NAME',
-    tokenValuePattern: ALPHANUMERIC_PATTERN,
-    knownChoices: [MESSAGE_BROKER_NO, MESSAGE_BROKER_KAFKA, MESSAGE_BROKER_PULSAR],
-};
-export default optionDefinition;

package/dist/generators/server/options/sync-user-with-idp.js

@@ -1,24 +0,0 @@
-/**
- * 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.
- */
-export const SYNC_USER_WITH_IDP = 'syncUserWithIdp';
-export const syncUserWithIdpDefinition = {
-    name: SYNC_USER_WITH_IDP,
-    type: 'boolean',
-    tokenType: 'BOOLEAN',
-};

package/dist/generators/spring-cloud/generators/gateway/jdl/jdl-routes-option.js

@@ -1,6 +0,0 @@
-export const jdlRoutesOptions = {
-    name: 'routes',
-    tokenType: 'quotedList',
-    type: 'quotedList',
-    tokenValuePattern: /^"[A-Za-z][A-Za-z0-9_]*(?::[A-Za-z][A-Za-z0-9_]+(?::[0-9]+)?)?"$/,
-};

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

@@ -1,48 +0,0 @@
-/**
- * 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 JSONEntity from '../../jhipster/json-entity.js';
-import { formatComment } from '../../utils/format-utils.js';
-import { getTableNameFromEntityNameFallback } from '../../jhipster/entity-table-name-creator.js';
-export default {
-    convert,
-};
-/**
- * Converts JDL entities to JSONEntity objects with basic information.
- * @param jdlEntities - the JDL entities to convert.
- * @return a map having for keys entity names and for values the corresponding JSON entities.
- */
-export function convert(jdlEntities) {
-    if (!jdlEntities) {
-        throw new Error('JDL entities must be passed to get the basic entity information.');
-    }
-    return createJSONEntities(jdlEntities);
-}
-function createJSONEntities(jdlEntities) {
-    const convertedEntities = new Map();
-    jdlEntities.forEach((jdlEntity) => {
-        const entityName = jdlEntity.name;
-        convertedEntities.set(entityName, new JSONEntity({
-            entityName,
-            entityTableName: jdlEntity.tableName ?? getTableNameFromEntityNameFallback(entityName),
-            documentation: formatComment(jdlEntity.comment),
-            annotations: jdlEntity.annotations,
-        }));
-    });
-    return convertedEntities;
-}

package/dist/jdl/converters/jdl-to-json/jdl-to-json-field-converter.js

@@ -1,134 +0,0 @@
-/**
- * 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 { capitalize } from 'lodash-es';
-import { validations } from '../../jhipster/index.js';
-import { formatComment } from '../../utils/format-utils.js';
-import { camelCase } from '../../utils/string-utils.js';
-import fieldTypes from '../../jhipster/field-types.js';
-const { Validations: { UNIQUE, REQUIRED }, } = validations;
-const { isBlobType } = fieldTypes;
-const { ANY_BLOB, BLOB, IMAGE_BLOB, TEXT_BLOB } = fieldTypes.CommonDBTypes;
-const { ANY, IMAGE, TEXT } = fieldTypes.BlobTypes;
-const { BYTES } = fieldTypes.RelationalOnlyDBTypes;
-export default { convert };
-/**
- * Converts entity fields to JSON content.
- * @param jdlObject - the JDL object containing entities, fields and enums.
- * @return a map having for keys an entity's name and for values its JSON fields.
- */
-export function convert(jdlObject) {
-    if (!jdlObject) {
-        throw new Error('A JDL Object must be passed to convert JDL fields to JSON.');
-    }
-    const convertedFields = new Map();
-    jdlObject.forEachEntity(jdlEntity => {
-        const convertedEntityFields = getConvertedFieldsForEntity(jdlEntity, jdlObject);
-        convertedFields.set(jdlEntity.name, convertedEntityFields);
-    });
-    return convertedFields;
-}
-function getConvertedFieldsForEntity(jdlEntity, jdlObject) {
-    const convertedEntityFields = [];
-    jdlEntity.forEachField((jdlField) => {
-        let fieldData = {
-            fieldName: camelCase(jdlField.name),
-            fieldType: jdlField.type,
-        };
-        const comment = formatComment(jdlField.comment);
-        if (comment) {
-            fieldData.documentation = comment;
-        }
-        if (jdlObject.hasEnum(jdlField.type)) {
-            fieldData.fieldValues = jdlObject.getEnum(fieldData.fieldType)?.getValuesAsString();
-            const fieldTypeComment = jdlObject.getEnum(fieldData.fieldType)?.comment;
-            if (fieldTypeComment) {
-                fieldData.fieldTypeDocumentation = fieldTypeComment;
-            }
-            const fieldValuesJavadocs = jdlObject.getEnum(fieldData.fieldType)?.getValueJavadocs();
-            if (fieldValuesJavadocs && Object.keys(fieldValuesJavadocs).length > 0) {
-                fieldData.fieldValuesJavadocs = fieldValuesJavadocs;
-            }
-        }
-        if (fieldData.fieldType && isBlobType(fieldData.fieldType)) {
-            const blobFieldData = getBlobFieldData(fieldData.fieldType);
-            fieldData = {
-                ...fieldData,
-                ...blobFieldData,
-            };
-        }
-        if (jdlField.validationQuantity() !== 0) {
-            const fieldValidations = getFieldValidations(jdlField);
-            fieldData = {
-                ...fieldData,
-                ...fieldValidations,
-            };
-        }
-        if (jdlField.optionQuantity() !== 0) {
-            const fieldOptions = getOptionsForField(jdlField);
-            fieldData = {
-                ...fieldData,
-                ...fieldOptions,
-            };
-        }
-        convertedEntityFields.push(fieldData);
-    });
-    return convertedEntityFields;
-}
-function getBlobFieldData(fieldType) {
-    const blobFieldData = {
-        fieldType: BYTES,
-    };
-    switch (fieldType) {
-        case IMAGE_BLOB:
-            blobFieldData.fieldTypeBlobContent = IMAGE;
-            break;
-        case BLOB:
-        case ANY_BLOB:
-            blobFieldData.fieldTypeBlobContent = ANY;
-            break;
-        case TEXT_BLOB:
-            blobFieldData.fieldTypeBlobContent = TEXT;
-            break;
-        default:
-            throw new Error(`Unrecognised Blob type: ${fieldType}.`);
-    }
-    return blobFieldData;
-}
-function getFieldValidations(jdlField) {
-    const fieldValidations = {
-        fieldValidateRules: [],
-    };
-    jdlField.forEachValidation(validation => {
-        fieldValidations.fieldValidateRules.push(validation.name);
-        if (validation.name !== REQUIRED && validation.name !== UNIQUE) {
-            fieldValidations[`fieldValidateRules${capitalize(validation.name)}`] = validation.value;
-        }
-    });
-    return fieldValidations;
-}
-function getOptionsForField(jdlField) {
-    const fieldOptions = {
-        options: {},
-    };
-    fieldOptions.options = {};
-    jdlField.forEachOption(([key, value]) => {
-        fieldOptions.options[key] = value;
-    });
-    return fieldOptions;
-}

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

@@ -1,107 +0,0 @@
-/**
- * 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 logger from '../../utils/objects/logger.js';
-import { binaryOptions, entityOptions, searchEngineTypes, unaryOptions } from '../../jhipster/index.js';
-const { FILTER, NO_FLUENT_METHOD, READ_ONLY, EMBEDDED, SKIP_CLIENT, SKIP_SERVER } = unaryOptions;
-const { ServiceTypes } = entityOptions;
-const { NO: NO_SEARCH_ENGINE } = searchEngineTypes;
-const NO_SERVICE = ServiceTypes.NO;
-const { Options: { ANGULAR_SUFFIX, MICROSERVICE, SEARCH, DTO }, } = binaryOptions;
-const serviceClassOptionValue = binaryOptions.Values.service.SERVICE_CLASS;
-let convertedOptionContent;
-export default { convert };
-/**
- * Converts JDL options to JSON content to be set in JSON entities.
- * This function takes a single parameter: a JDL option holder. This holder is a class or an object responding to these
- * calls:
- *   - forEachOption, to loop over JDL options
- *   - getEntityNames, to get the declared entity names
- * @param jdlOptionHolder - a JDL object (a JDLObject or a JDLApplication) containing the options.
- * @return {Map<String, Object>} a map having for keys entity names and for values the JSON option contents.
- */
-export function convert(jdlOptionHolder) {
-    if (!jdlOptionHolder) {
-        throw new Error('A JDL object or application must be passed to convert JDL options to JSON.');
-    }
-    convertedOptionContent = new Map();
-    resolveEntityNamesForEachOption(jdlOptionHolder);
-    setConvertedOptionContents(jdlOptionHolder);
-    return convertedOptionContent;
-}
-function resolveEntityNamesForEachOption(jdlOptionHolder) {
-    jdlOptionHolder.forEachOption(jdlOption => {
-        if (jdlOption.entityNames.has('*')) {
-            jdlOption.setEntityNames(jdlOptionHolder.getEntityNames().filter(entityName => !jdlOption.excludedNames.has(entityName)));
-        }
-    });
-}
-function setConvertedOptionContents(jdlOptionHolder) {
-    jdlOptionHolder.forEachOption(jdlOption => {
-        setOptionsToEachEntityName(jdlOption);
-    });
-}
-function setOptionsToEachEntityName(jdlOption) {
-    const { key, value } = getJSONOptionKeyAndValue(jdlOption);
-    jdlOption.entityNames.forEach(entityName => {
-        setOptionToEntityName({ optionName: key, optionValue: value }, entityName);
-    });
-    jdlOption.entityNames.forEach(entityName => {
-        const serviceOptionValue = convertedOptionContent.get(entityName).service;
-        if ((!serviceOptionValue || serviceOptionValue === NO_SERVICE) && [DTO, FILTER].includes(jdlOption.name)) {
-            logger.info(`The ${jdlOption.name} option is set for ${entityName}, the '${serviceClassOptionValue}' value for the ` +
-                "'service' is gonna be set for this entity if no other value has been set.");
-            setOptionToEntityName({ optionName: 'service', optionValue: serviceClassOptionValue }, entityName);
-        }
-    });
-    if (jdlOption.name === SEARCH) {
-        preventEntitiesFromBeingSearched(jdlOption.excludedNames);
-    }
-}
-function getJSONOptionKeyAndValue(jdlOption) {
-    switch (jdlOption.name) {
-        case SKIP_CLIENT:
-        case SKIP_SERVER:
-        case READ_ONLY:
-        case EMBEDDED:
-            return { key: jdlOption.name, value: true };
-        case MICROSERVICE:
-            return { key: 'microserviceName', value: jdlOption.value };
-        case NO_FLUENT_METHOD:
-            return { key: 'fluentMethods', value: false };
-        case ANGULAR_SUFFIX:
-            return { key: 'angularJSSuffix', value: jdlOption.value };
-        case SEARCH:
-            return { key: 'searchEngine', value: jdlOption.value };
-        case FILTER:
-            return { key: 'jpaMetamodelFiltering', value: true };
-        default:
-            return { key: jdlOption.name, value: jdlOption.getType() === 'UNARY' ? true : jdlOption.value };
-    }
-}
-function preventEntitiesFromBeingSearched(entityNames) {
-    entityNames.forEach(entityName => {
-        setOptionToEntityName({ optionName: 'searchEngine', optionValue: NO_SEARCH_ENGINE }, entityName);
-    });
-}
-function setOptionToEntityName(option, entityName) {
-    const { optionName, optionValue } = option;
-    const optionContentForEntity = convertedOptionContent.get(entityName) ?? {};
-    optionContentForEntity[optionName] = optionValue;
-    convertedOptionContent.set(entityName, optionContentForEntity);
-}

package/dist/jdl/converters/jdl-to-json/jdl-to-json-relationship-converter.js

@@ -1,168 +0,0 @@
-/**
- * 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 { kebabCase } from 'lodash-es';
-import { relationshipOptions, validations } from '../../jhipster/index.js';
-import { camelCase, lowerFirst } from '../../utils/string-utils.js';
-const { Validations: { REQUIRED }, } = validations;
-const { BUILT_IN_ENTITY } = relationshipOptions;
-let convertedRelationships;
-export default { convert };
-/**
- * Converts passed JDL relationships to JSON content.
- * @param jdlRelationships - the relationships to convert
- * @param entityNames - all the entities' names
- * @return {Map<String, Array<Object>>} a map having for keys entity names and for values arrays of JSON relationships.
- */
-export function convert(jdlRelationships = [], entityNames = []) {
-    if (jdlRelationships.length === 0 || entityNames.length === 0) {
-        return new Map();
-    }
-    convertedRelationships = new Map(entityNames.map(entityName => [entityName, []]));
-    const relatedRelationships = getRelatedRelationships(jdlRelationships, entityNames);
-    relatedRelationships.forEach((relatedRelationship, currentEntityName) => {
-        setRelationshipsFromEntity(relatedRelationship, currentEntityName);
-        setRelationshipsToEntity(relatedRelationship, currentEntityName);
-    });
-    return convertedRelationships;
-}
-function getRelatedRelationships(relationships, entityNames) {
-    const relatedRelationships = new Map();
-    entityNames.forEach(entityName => {
-        const relationshipsRelatedToEntity = {
-            from: [],
-            to: [],
-        };
-        relationships.forEach(jdlRelationship => {
-            if (jdlRelationship.from === entityName) {
-                relationshipsRelatedToEntity.from.push(jdlRelationship);
-            }
-            if (jdlRelationship.to === entityName &&
-                (jdlRelationship.injectedFieldInTo || Object.keys(jdlRelationship.options.source).length !== 0)) {
-                relationshipsRelatedToEntity.to.push(jdlRelationship);
-            }
-        });
-        relatedRelationships.set(entityName, relationshipsRelatedToEntity);
-    });
-    return relatedRelationships;
-}
-function setRelationshipsFromEntity(relatedRelationships, entityName) {
-    relatedRelationships.from.forEach(relationshipToConvert => {
-        const otherSplitField = extractField(relationshipToConvert.injectedFieldInTo);
-        const convertedRelationship = {
-            relationshipSide: 'left',
-            relationshipType: kebabCase(relationshipToConvert.type),
-            otherEntityName: camelCase(relationshipToConvert.to),
-        };
-        if (otherSplitField.relationshipName) {
-            convertedRelationship.otherEntityRelationshipName = lowerFirst(otherSplitField.relationshipName);
-        }
-        if (relationshipToConvert.isInjectedFieldInFromRequired) {
-            convertedRelationship.relationshipValidateRules = REQUIRED;
-        }
-        if (relationshipToConvert.commentInFrom) {
-            convertedRelationship.documentation = relationshipToConvert.commentInFrom;
-        }
-        const splitField = extractField(relationshipToConvert.injectedFieldInFrom);
-        convertedRelationship.relationshipName = camelCase(splitField.relationshipName || relationshipToConvert.to);
-        if (splitField.otherEntityField) {
-            convertedRelationship.otherEntityField = lowerFirst(splitField.otherEntityField);
-        }
-        setOptionsForRelationshipSourceSide(relationshipToConvert, convertedRelationship);
-        const convertedEntityRelationships = convertedRelationships.get(entityName);
-        convertedEntityRelationships.push(convertedRelationship);
-    });
-}
-export const otherRelationshipType = relationshipType => relationshipType.split('-').reverse().join('-');
-function setRelationshipsToEntity(relatedRelationships, entityName) {
-    relatedRelationships.to.forEach(relationshipToConvert => {
-        const otherSplitField = extractField(relationshipToConvert.injectedFieldInFrom);
-        const convertedRelationship = {
-            relationshipSide: 'right',
-            relationshipType: otherRelationshipType(kebabCase(relationshipToConvert.type)),
-            otherEntityName: camelCase(relationshipToConvert.from),
-        };
-        if (otherSplitField.relationshipName) {
-            convertedRelationship.otherEntityRelationshipName =
-                lowerFirst(otherSplitField.relationshipName) || camelCase(relationshipToConvert.to);
-        }
-        if (relationshipToConvert.isInjectedFieldInToRequired) {
-            convertedRelationship.relationshipValidateRules = REQUIRED;
-        }
-        if (relationshipToConvert.commentInTo) {
-            convertedRelationship.documentation = relationshipToConvert.commentInTo;
-        }
-        const splitField = extractField(relationshipToConvert.injectedFieldInTo);
-        convertedRelationship.relationshipName = camelCase(splitField.relationshipName || relationshipToConvert.from);
-        if (splitField.otherEntityField) {
-            convertedRelationship.otherEntityField = lowerFirst(splitField.otherEntityField);
-        }
-        relationshipToConvert.injectedFieldInTo = relationshipToConvert.injectedFieldInTo ?? lowerFirst(relationshipToConvert.from);
-        setOptionsForRelationshipDestinationSide(relationshipToConvert, convertedRelationship);
-        const convertedEntityRelationships = convertedRelationships.get(entityName);
-        convertedEntityRelationships.push(convertedRelationship);
-    });
-}
-function setOptionsForRelationshipSourceSide(relationshipToConvert, convertedRelationship) {
-    convertedRelationship.options = convertedRelationship.options || {};
-    relationshipToConvert.forEachGlobalOption((optionName, optionValue) => {
-        if (optionName === BUILT_IN_ENTITY) {
-            convertedRelationship.relationshipWithBuiltInEntity = optionValue;
-        }
-        else {
-            convertedRelationship.options[optionName] = optionValue;
-        }
-    });
-    relationshipToConvert.forEachDestinationOption((optionName, optionValue) => {
-        convertedRelationship.options[optionName] = optionValue;
-    });
-    if (Object.keys(convertedRelationship.options).length === 0) {
-        delete convertedRelationship.options;
-    }
-}
-function setOptionsForRelationshipDestinationSide(relationshipToConvert, convertedRelationship) {
-    convertedRelationship.options = convertedRelationship.options || {};
-    relationshipToConvert.forEachGlobalOption((optionName, optionValue) => {
-        convertedRelationship.options[optionName] = optionValue;
-    });
-    relationshipToConvert.forEachSourceOption((optionName, optionValue) => {
-        convertedRelationship.options[optionName] = optionValue;
-    });
-    if (Object.keys(convertedRelationship.options).length === 0) {
-        delete convertedRelationship.options;
-    }
-}
-/**
- * Parses the string "<relationshipName>(<otherEntityField>)"
- * @param{String} field
- * @return{Object} where 'relationshipName' is the relationship name and
- *                'otherEntityField' is the other entity field name
- */
-function extractField(field) {
-    const splitField = {
-        relationshipName: '',
-    };
-    if (field) {
-        const chunks = field.replace('(', '/').replace(')', '').split('/');
-        splitField.relationshipName = chunks[0];
-        if (chunks.length > 1) {
-            splitField.otherEntityField = chunks[1];
-        }
-    }
-    return splitField;
-}

package/dist/jdl/converters/json-to-jdl-application-converter.js

@@ -1,33 +0,0 @@
-/**
- * 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 '../models/jdl-object.js';
-import createJDLApplication from '../models/jdl-application-factory.js';
-const GENERATOR_NAME = 'generator-jhipster';
-export function convertApplicationsToJDL({ applications, jdl } = {}) {
-    const jsonApplications = applications || [];
-    const jdlObject = jdl || new JDLObject();
-    jsonApplications.forEach((application) => {
-        const convertedApplication = convertApplicationToJDL({ application });
-        jdlObject.addApplication(convertedApplication);
-    });
-    return jdlObject;
-}
-export function convertApplicationToJDL({ application } = {}) {
-    return createJDLApplication(application[GENERATOR_NAME]);
-}

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

@@ -1,122 +0,0 @@
-/**
- * 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 path from 'path';
-import fs from 'fs';
-import JDLObject from '../models/jdl-object.js';
-import mergeJDLObjects from '../models/jdl-object-merger.js';
-import { doesDirectoryExist, doesFileExist } from '../utils/file-utils.js';
-import { readJSONFile } from '../readers/json-file-reader.js';
-import exportJDLObject from '../exporters/jdl-exporter.js';
-import { removeFieldsWithNullishValues } from '../../generators/base/support/config.js';
-import { GENERATOR_JHIPSTER } from '../../generators/generator-constants.js';
-import { convertEntitiesToJDL } from './json-to-jdl-entity-converter.js';
-import { convertApplicationToJDL } from './json-to-jdl-application-converter.js';
-export default {
-    convertToJDL,
-    convertSingleContentToJDL,
-};
-/**
- * Exports to JDL every JHipster file found in the passed directory (down to one subfolder level).
- * @param directory the directory to find JHipster files.
- * @param output the file where the JDL will be written
- */
-export function convertToJDL(directory = '.', output = 'app.jdl') {
-    let jdlObject;
-    if (doesFileExist(path.join(directory, '.yo-rc.json'))) {
-        const yoRcFileContent = readJSONFile(path.join(directory, '.yo-rc.json'));
-        let entities;
-        if (doesDirectoryExist(path.join(directory, '.jhipster'))) {
-            entities = getJSONEntityFiles(directory);
-        }
-        jdlObject = getJDLObjectFromSingleApplication(yoRcFileContent, entities);
-    }
-    else {
-        try {
-            jdlObject = getJDLObjectFromMultipleApplications(directory);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (output) {
-        output = path.isAbsolute(output) ? output : path.join(directory, output);
-        exportJDLObject(jdlObject, output);
-    }
-    return jdlObject;
-}
-export function convertSingleContentToJDL(yoRcFileContent, entities) {
-    return getJDLObjectFromSingleApplication(yoRcFileContent, entities).toString();
-}
-function getJDLObjectFromMultipleApplications(directory) {
-    const subDirectories = getSubdirectories(directory);
-    if (subDirectories.length === 0) {
-        throw new Error('There are no subdirectories.');
-    }
-    let jdlObject = new JDLObject();
-    subDirectories.forEach(subDirectory => {
-        const applicationDirectory = path.join(directory, subDirectory);
-        const yoRcFileContent = readJSONFile(path.join(applicationDirectory, '.yo-rc.json'));
-        let entities = new Map();
-        if (doesDirectoryExist(path.join(applicationDirectory, '.jhipster'))) {
-            entities = getJSONEntityFiles(applicationDirectory);
-        }
-        jdlObject = getJDLObjectFromSingleApplication(yoRcFileContent, entities, jdlObject);
-    });
-    return jdlObject;
-}
-export function getJDLObjectFromSingleApplication(yoRcFileContent, entities, existingJDLObject = new JDLObject()) {
-    const cleanedYoRcFileContent = cleanYoRcFileContent(yoRcFileContent);
-    const jdlApplication = convertApplicationToJDL({ application: cleanedYoRcFileContent });
-    if (!entities) {
-        existingJDLObject.addApplication(jdlApplication);
-        return existingJDLObject;
-    }
-    const jdlObject = convertEntitiesToJDL(entities);
-    entities.forEach((entity, entityName) => jdlApplication.addEntityName(entityName));
-    jdlObject.addApplication(jdlApplication);
-    return mergeJDLObjects(existingJDLObject, jdlObject);
-}
-function cleanYoRcFileContent(yoRcFileContent) {
-    for (const key of Object.keys(yoRcFileContent)) {
-        yoRcFileContent[key] = removeFieldsWithNullishValues(yoRcFileContent[key]);
-    }
-    delete yoRcFileContent[GENERATOR_JHIPSTER].promptValues;
-    const result = structuredClone(yoRcFileContent);
-    if (yoRcFileContent[GENERATOR_JHIPSTER].blueprints) {
-        result[GENERATOR_JHIPSTER].blueprints = yoRcFileContent[GENERATOR_JHIPSTER].blueprints.map(blueprint => blueprint.name);
-    }
-    if (yoRcFileContent[GENERATOR_JHIPSTER].microfrontends) {
-        result[GENERATOR_JHIPSTER].microfrontends = yoRcFileContent[GENERATOR_JHIPSTER].microfrontends.map(({ baseName }) => baseName);
-    }
-    return result;
-}
-function getJSONEntityFiles(applicationDirectory) {
-    const entities = new Map();
-    fs.readdirSync(path.join(applicationDirectory, '.jhipster')).forEach(file => {
-        const entityName = file.slice(0, file.indexOf('.json'));
-        const jsonFilePath = path.join(applicationDirectory, '.jhipster', file);
-        if (fs.statSync(jsonFilePath).isFile() && file.endsWith('.json')) {
-            entities.set(entityName, readJSONFile(jsonFilePath));
-        }
-    });
-    return entities;
-}
-function getSubdirectories(rootDirectory) {
-    return fs.readdirSync(path.join(rootDirectory)).filter(file => doesDirectoryExist(path.join(rootDirectory, file)));
-}