generator-jhipster 8.7.0 → 8.7.2

package/dist/lib/jdl/converters/exporters/jdl-exporter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 JDLObject from '../../core/models/jdl-object.js';
+/**
+ * Writes down the given JDL to a file.
+ * @param jdl the JDL to write.
+ * @param path the path where the file will be written.
+ * @returns file contents
+ */
+export default function exportToJDL(jdl: JDLObject, path?: string): string;

package/dist/lib/jdl/converters/exporters/jhipster-deployment-exporter.d.ts

@@ -0,0 +1,26 @@
+/**
+ * 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 JDLDeployment from '../../core/models/jdl-deployment.js';
+import type { JHipsterYoRcContent } from '../../core/types/json-config.js';
+/**
+ * Exports JDL deployments to .yo-rc.json files in separate folders (based on deployment type).
+ * @param deployments the deployments to exporters (key: deployment type, value: JDLDeployment- deployment config).
+ * @return object[] exported deployments in their final form.
+ */
+export default function exportDeployments(deployments: Record<string, JDLDeployment>): Partial<JHipsterYoRcContent>[];

package/dist/lib/jdl/converters/exporters/jhipster-deployment-exporter.js

@@ -0,0 +1,67 @@
+/**
+ * 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 { createFolderIfItDoesNotExist, doesFileExist } from '../../core/utils/file-utils.js';
+import DeploymentValidator from '../validators/deployment-validator.js';
+import { GENERATOR_NAME, writeConfigFile } from './export-utils.js';
+/**
+ * Exports JDL deployments to .yo-rc.json files in separate folders (based on deployment type).
+ * @param deployments the deployments to exporters (key: deployment type, value: JDLDeployment- deployment config).
+ * @return object[] exported deployments in their final form.
+ */
+export default function exportDeployments(deployments) {
+    if (!deployments) {
+        throw new Error('Deployments have to be passed to be exported.');
+    }
+    return Object.values(deployments).map(deployment => {
+        checkForErrors(deployment);
+        const yoRcDeployment = setUpDeploymentStructure(deployment);
+        writeDeploymentConfigs(yoRcDeployment);
+        return yoRcDeployment;
+    });
+}
+function checkForErrors(deployment) {
+    const validator = new DeploymentValidator();
+    validator.validate(deployment);
+}
+function setUpDeploymentStructure(deployment) {
+    let deploymentToExport = {};
+    deploymentToExport[GENERATOR_NAME] = JSON.parse(JSON.stringify(deployment, null, 2).concat('\n'));
+    deploymentToExport[GENERATOR_NAME].appsFolders = deployment.appsFolders;
+    deploymentToExport[GENERATOR_NAME].clusteredDbApps = deployment.clusteredDbApps;
+    deploymentToExport = setUpArrayOptions(deploymentToExport);
+    return deploymentToExport;
+}
+function setUpArrayOptions(deployment) {
+    deployment[GENERATOR_NAME].appsFolders = Array.from(deployment[GENERATOR_NAME]?.appsFolders || []);
+    deployment[GENERATOR_NAME].clusteredDbApps = Array.from(deployment[GENERATOR_NAME]?.clusteredDbApps || []);
+    return deployment;
+}
+/**
+ * This function writes a Yeoman config file in a folder.
+ * @param deployment the deployment.
+ */
+function writeDeploymentConfigs(deployment) {
+    const folderName = deployment[GENERATOR_NAME].deploymentType;
+    if (doesFileExist(folderName)) {
+        throw new Error(`A file named '${folderName}' already exists, so a folder of the same name can't be created for the application.`);
+    }
+    createFolderIfItDoesNotExist(folderName);
+    writeConfigFile(deployment, path.join(folderName, '.yo-rc.json'));
+}

package/dist/lib/jdl/converters/exporters/jhipster-entity-exporter.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 type { JSONEntity } from '../../core/types/json-config.js';
+import type { JhipsterJSONJDLExporterWrapper } from '../../core/types/exporter.js';
+/**
+ * Exports the passed entities to JSON.
+ * @param {Object} passedConfiguration - the object having the keys:
+ * @param {Array<JSONEntity>} passedConfiguration.entities - the entity objects to export.
+ * @param {Object} passedConfiguration.application - the application where the entities should be exported.
+ * @param {Boolean} passedConfiguration.application.forSeveralApplications - whether to create the .jhipster folder
+ *          inside a specific application's folder.
+ * @param {String} passedConfiguration.application.name - the application's name, where the entities should be exported.
+ * @param {String} passedConfiguration.application.type - the application's type.
+ * @returns {Array<JSONEntity>} the exported entities.
+ */
+export default function exportEntities(passedConfiguration: JhipsterJSONJDLExporterWrapper): JSONEntity[];

package/dist/lib/jdl/converters/exporters/jhipster-entity-exporter.js

@@ -0,0 +1,81 @@
+/**
+ * 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 applicationTypes from '../../../jhipster/application-types.js';
+import { readEntityFile } from '../../../utils/yo-rc.js';
+let configuration = {};
+/**
+ * Exports the passed entities to JSON.
+ * @param {Object} passedConfiguration - the object having the keys:
+ * @param {Array<JSONEntity>} passedConfiguration.entities - the entity objects to export.
+ * @param {Object} passedConfiguration.application - the application where the entities should be exported.
+ * @param {Boolean} passedConfiguration.application.forSeveralApplications - whether to create the .jhipster folder
+ *          inside a specific application's folder.
+ * @param {String} passedConfiguration.application.name - the application's name, where the entities should be exported.
+ * @param {String} passedConfiguration.application.type - the application's type.
+ * @returns {Array<JSONEntity>} the exported entities.
+ */
+export default function exportEntities(passedConfiguration) {
+    init(passedConfiguration);
+    if (configuration.entities.length === 0) {
+        return configuration.entities;
+    }
+    const subFolder = passedConfiguration.application.forSeveralApplications ? configuration.application.name : '';
+    configuration.entities = updateEntities(subFolder);
+    if (shouldFilterOutEntitiesBasedOnMicroservice()) {
+        configuration.entities = filterOutEntitiesByMicroservice();
+    }
+    return configuration.entities;
+}
+function init(passedConfiguration) {
+    if (!passedConfiguration?.entities) {
+        throw new Error('Entities have to be passed to be exported.');
+    }
+    configuration = passedConfiguration;
+}
+/**
+ * Writes entities in a sub folder.
+ * @param subFolder the folder (to create) in which the JHipster entity folder will be.
+ */
+function updateEntities(applicationPath) {
+    return configuration.entities.map((entity) => {
+        return updateEntityToGenerateWithExistingOne(applicationPath, entity);
+    });
+}
+function updateEntityToGenerateWithExistingOne(applicationPath, entity) {
+    try {
+        const fileOnDisk = readEntityFile(applicationPath, entity.name);
+        if (!entity.annotations?.changelogDate && fileOnDisk?.annotations?.changelogDate) {
+            entity.annotations = entity.annotations || {};
+            entity.annotations.changelogDate = fileOnDisk.annotations.changelogDate;
+            return { ...fileOnDisk, ...entity };
+        }
+    }
+    catch {
+        // New entity
+    }
+    return entity;
+}
+function shouldFilterOutEntitiesBasedOnMicroservice() {
+    return (configuration.application.type && configuration.application.type === applicationTypes.MICROSERVICE && configuration.application.name);
+}
+function filterOutEntitiesByMicroservice() {
+    return configuration.entities.filter(entity => {
+        return !(entity.microserviceName && entity.microserviceName.toLowerCase() !== configuration.application.name.toLowerCase());
+    });
+}

package/dist/lib/jdl/converters/jdl-to-json/jdl-to-json-basic-entity-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 JSONEntity from '../../core/basic-types/json-entity.js';
+import type { JDLEntity } from '../../core/models/index.js';
+declare const _default: {
+    convert: typeof convert;
+};
+export default _default;
+/**
+ * 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 declare function convert(jdlEntities: JDLEntity[]): Map<string, JSONEntity>;

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

@@ -0,0 +1,48 @@
+/**
+ * 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 '../../core/basic-types/json-entity.js';
+import { formatComment } from '../../core/utils/format-utils.js';
+import { getTableNameFromEntityNameFallback } from '../../core/utils/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/lib/jdl/converters/jdl-to-json/jdl-to-json-field-converter.d.ts

@@ -0,0 +1,12 @@
+import type JDLObject from '../../core/models/jdl-object.js';
+import type { JSONField } from '../../core/types/json-config.js';
+declare const _default: {
+    convert: typeof convert;
+};
+export default _default;
+/**
+ * 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 declare function convert(jdlObject: JDLObject): Map<string, JSONField[]>;

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

@@ -0,0 +1,102 @@
+/**
+ * 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 '../../core/built-in-options/index.js';
+import { formatComment } from '../../core/utils/format-utils.js';
+import { camelCase } from '../../core/utils/string-utils.js';
+const { Validations: { UNIQUE, REQUIRED }, } = validations;
+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 (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 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/lib/jdl/converters/jdl-to-json/jdl-to-json-option-converter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * 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 JDLObject from '../../core/models/jdl-object.js';
+import type JDLApplication from '../../core/models/jdl-application.js';
+declare const _default: {
+    convert: typeof convert;
+};
+export default _default;
+type JDLOptionHolder = JDLObject | JDLApplication;
+/**
+ * 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 declare function convert(jdlOptionHolder: JDLOptionHolder): Map<string, any>;

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

@@ -0,0 +1,104 @@
+/**
+ * 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 '../../core/utils/objects/logger.js';
+import { binaryOptions, unaryOptions } from '../../core/built-in-options/index.js';
+const { FILTER, NO_FLUENT_METHOD, READ_ONLY, EMBEDDED, SKIP_CLIENT, SKIP_SERVER } = unaryOptions;
+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') && [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' }, entityName);
+    });
+}
+function setOptionToEntityName(option, entityName) {
+    const { optionName, optionValue } = option;
+    const optionContentForEntity = convertedOptionContent.get(entityName) ?? {};
+    optionContentForEntity[optionName] = optionValue;
+    convertedOptionContent.set(entityName, optionContentForEntity);
+}

package/dist/lib/jdl/converters/jdl-to-json/jdl-to-json-relationship-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 JDLRelationship from '../../core/models/jdl-relationship.js';
+declare const _default: {
+    convert: typeof convert;
+};
+export default _default;
+/**
+ * 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 declare function convert(jdlRelationships?: JDLRelationship[], entityNames?: string[]): any;
+export declare const otherRelationshipType: (relationshipType: any) => any;