generator-jhipster 8.7.0 → 8.7.2

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)));
-}

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

@@ -1,293 +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 { JDLEntity, JDLEnum } from '../models/index.js';
-import JDLField from '../models/jdl-field.js';
-import JDLValidation from '../models/jdl-validation.js';
-import JDLRelationship from '../models/jdl-relationship.js';
-import JDLUnaryOption from '../models/jdl-unary-option.js';
-import JDLBinaryOption from '../models/jdl-binary-option.js';
-import { lowerFirst, upperFirst } from '../utils/string-utils.js';
-import { binaryOptions, fieldTypes, relationshipOptions, unaryOptions } from '../jhipster/index.js';
-import { asJdlRelationshipType } from '../jhipster/relationship-types.js';
-const { BlobTypes, CommonDBTypes, RelationalOnlyDBTypes } = fieldTypes;
-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;
-const { ANY, IMAGE, TEXT } = BlobTypes;
-const { BYTES } = RelationalOnlyDBTypes;
-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,
-    });
-    if (jdlField.type === BYTES) {
-        jdlField.type = getTypeForBlob(field.fieldTypeBlobContent);
-    }
-    addValidations(jdlField, field);
-    return jdlField;
-}
-function getTypeForBlob(blobContentType) {
-    if ([ANY, IMAGE, TEXT].includes(blobContentType)) {
-        return CommonDBTypes[`${blobContentType.toUpperCase()}_BLOB`];
-    }
-    throw new Error(`Unrecognised blob type: '${blobContentType}'`);
-}
-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/jdl/converters/json-to-jdl-option-converter.js

@@ -1,43 +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 { unaryOptions } from '../jhipster/index.js';
-import JDLUnaryOption from '../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/jdl/converters/parsed-jdl-to-jdl-object/application-converter.js

@@ -1,61 +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 createJDLApplication from '../../models/jdl-application-factory.js';
-import ApplicationOptions from '../../jhipster/application-options.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) {
-    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);
-        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/jdl/converters/parsed-jdl-to-jdl-object/deployment-converter.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.
- */
-import JDLDeployment from '../../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/jdl/converters/parsed-jdl-to-jdl-object/entity-converter.js

@@ -1,47 +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 { lowerFirst } from 'lodash-es';
-import { JDLEntity } from '../../models/index.js';
-import { formatComment } from '../../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/jdl/converters/parsed-jdl-to-jdl-object/enum-converter.js

@@ -1,44 +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 { JDLEnum } from '../../models/index.js';
-import { formatComment } from '../../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),
-    });
-}