generator-jhipster 8.7.0 → 8.7.2

package/dist/jdl/readers/jdl-reader.js

@@ -1,111 +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 * as parser from '../parsing/api.js';
-import performJDLPostParsingTasks from '../parsing/jdl-post-parsing-tasks.js';
-import { readFile, readFiles } from './file-reader.js';
-/**
- * Parses the given files and returns the resulting intermediate object.
- * If one file is passed, the file will be read and its parsed content returned.
- * If more than one are passed, they will be assembled and only parsed once.
- * @param files the files to parse.
- * @returns {Object} the intermediate object.
- */
-export function parseFromFiles(files) {
-    checkFiles(files);
-    checkAllTheFilesAreJDLFiles(files);
-    return parse(getFilesContent(files));
-}
-/**
- * Parses the given content and returns the resulting intermediate object.
- * @param content the JDL content to parse.
- * @returns {Object} the intermediate object.
- */
-export function parseFromContent(content) {
-    if (!content) {
-        throw new Error('A valid JDL content must be passed so as to be parsed.');
-    }
-    return parse(content);
-}
-export function getCstFromContent(content) {
-    return getCst(content);
-}
-function checkFiles(files) {
-    if (!files || files.length === 0) {
-        throw new Error('The files must be passed to be parsed.');
-    }
-}
-function getFilesContent(files) {
-    return files.length === 1 ? readFile(files[0]) : aggregateFiles(files);
-}
-function checkAllTheFilesAreJDLFiles(files) {
-    for (let i = 0; i < files.length; i++) {
-        checkFileIsJDLFile(files[i]);
-    }
-}
-/**
- * Parsed the stringified JDL content and returns an intermediate object from the Chevrotain parsers.
- * @param content the JDL content.
- * @returns the intermediate object.
- */
-function parse(content) {
-    const parsedContent = callApiMethod('parse', content);
-    return performJDLPostParsingTasks(parsedContent);
-}
-function getCst(content) {
-    return callApiMethod('getCst', content);
-}
-function callApiMethod(methodName, content) {
-    if (!content) {
-        throw new Error('File content must be passed, it is currently empty.');
-    }
-    try {
-        const processedInput = filterJDLDirectives(removeInternalJDLComments(content));
-        return parser[methodName](processedInput);
-    }
-    catch (error) {
-        if (error instanceof SyntaxError) {
-            logger.error(`Syntax error message:\n\t${error.message}`);
-        }
-        throw error;
-    }
-}
-function removeInternalJDLComments(content) {
-    // Removing an internal Comment will not affect line/column location info
-    // as no lines are removed and the comments consumes the rest of the line.
-    return content.replace(/\/\/[^\n\r]*/gm, '');
-}
-function filterJDLDirectives(content) {
-    // We are only removing the directive not the whole line to avoid modifying line/column
-    // location information in parsers errors.
-    return content.replace(/^\u0023.*/gm, '');
-}
-/**
- * Checks whether the given file is a JDL file, only from the extension.
- * Doesn't return anything, but fails if the extension doesn't match.
- * @param file the file to check.
- */
-export function checkFileIsJDLFile(file) {
-    if (!file.endsWith('.jh') && !file.endsWith('.jdl')) {
-        throw new Error(`The passed file '${file}' must end with '.jh' or '.jdl' to be valid.`);
-    }
-}
-function aggregateFiles(files) {
-    return readFiles(files).join('\n');
-}

package/dist/jdl/readers/json-file-reader.js

@@ -1,40 +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 { upperFirst } from '../utils/string-utils.js';
-import { readFile } from './file-reader.js';
-/**
- * Reads a JSON file.
- * @param filePath the JSON file's path
- * @return its content
- */
-export function readJSONFile(filePath) {
-    return JSON.parse(readFile(filePath));
-}
-/**
- * From an entity's name, gives the expected file path.
- * @param entityName the entity's name.
- * @returns the file's path.
- */
-export function toFilePath(entityName) {
-    if (!entityName) {
-        throw new Error('The passed entity name must not be nil to be converted to file path.');
-    }
-    return path.join('.jhipster', `${upperFirst(entityName)}.json`);
-}

package/dist/jdl/readers/json-reader.js

@@ -1,55 +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 fs from 'fs';
-import { convertEntitiesToJDL } from '../converters/json-to-jdl-entity-converter.js';
-import { convertServerOptionsToJDL } from '../converters/json-to-jdl-option-converter.js';
-import mergeJDLObjects from '../models/jdl-object-merger.js';
-import { doesDirectoryExist } from '../utils/file-utils.js';
-import { readJSONFile } from './json-file-reader.js';
-/* Parse the given jhipster app dir and return a JDLObject */
-export default function parseFromDir(dir) {
-    if (!dir) {
-        throw new Error('The app directory must be passed to read JSON files.');
-    }
-    if (!doesDirectoryExist(dir)) {
-        throw new Error(`The passed directory '${dir}' must exist and must be a directory to read JSON files.`);
-    }
-    const entityDir = `${dir}/.jhipster`;
-    if (!doesDirectoryExist(entityDir)) {
-        throw new Error(`'${entityDir}' must exist as a directory.`);
-    }
-    const entities = new Map();
-    const files = fs.readdirSync(entityDir);
-    files.forEach(file => {
-        if (file.endsWith('.json')) {
-            const entityName = file.slice(0, file.length - 5);
-            try {
-                entities.set(entityName, readJSONFile(`${entityDir}/${file}`));
-            }
-            catch {
-                // Not an entity file, not adding
-            }
-        }
-    });
-    const applicationOptions = readJSONFile(`${dir}/.yo-rc.json`)['generator-jhipster'];
-    // @ts-expect-error TODO
-    const jdlObject = convertServerOptionsToJDL(applicationOptions);
-    const convertedJDLObject = convertEntitiesToJDL(entities);
-    return mergeJDLObjects(jdlObject, convertedJDLObject);
-}

package/dist/jdl/utils/format-utils.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.
- */
-export { formatComment };
-/**
- * formats a comment
- * @param comment string.
- * @returns formatted comment string
- */
-export default function formatComment(comment) {
-    if (!comment) {
-        return undefined;
-    }
-    const parts = comment.trim().split('\n');
-    if (parts.length === 1 && parts[0].indexOf('*') !== 0) {
-        return parts[0];
-    }
-    return parts.reduce((previousValue, currentValue) => {
-        // newlines in the middle of the comment should stay to achieve:
-        // multiline comments entered by user drive unchanged from JDL
-        // studio to generated domain class
-        let delimiter = '';
-        if (previousValue !== '') {
-            delimiter = '\\n';
-        }
-        return previousValue.concat(delimiter, currentValue.trim().replace(/[*]*\s*/, ''));
-    }, '');
-}

package/dist/jdl/utils/objects/logger.js

@@ -1,26 +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 { createJHipsterLogger } from '../../../generators/base/support/logger.js';
-const logger = createJHipsterLogger({ namespace: 'jhipster:jdl' });
-export default {
-    info: (message) => logger.verboseInfo(message),
-    error: (message) => logger.error(message),
-    warn: (message) => logger.warn(message),
-    debug: (message) => logger.debug(message),
-};

package/dist/jdl/validators/binary-option-validator.js

@@ -1,34 +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 BinaryOptions from '../jhipster/binary-options.js';
-import OptionValidator from './option-validator.js';
-export default class BinaryOptionValidator extends OptionValidator {
-    constructor() {
-        super('binary', 'value');
-    }
-    validate(jdlOption) {
-        super.validate(jdlOption);
-        checkForInvalidValue(jdlOption);
-    }
-}
-function checkForInvalidValue(jdlOption) {
-    if (!!jdlOption.value && !BinaryOptions.exists(jdlOption.name, jdlOption.value)) {
-        throw new Error(`The '${jdlOption.name}' option is not valid for value '${jdlOption.value}'.`);
-    }
-}

package/dist/jdl/validators/deployment-validator.js

@@ -1,76 +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 { applicationOptions, applicationTypes, databaseTypes, deploymentOptions, searchEngineTypes } from '../jhipster/index.js';
-import Validator from './validator.js';
-const { Options } = deploymentOptions;
-const { MICROSERVICE } = applicationTypes;
-const { NO } = databaseTypes;
-const { ELASTICSEARCH } = searchEngineTypes;
-const { OptionNames } = applicationOptions;
-const { PROD_DATABASE_TYPE } = OptionNames;
-export default class DeploymentValidator extends Validator {
-    constructor() {
-        super('deployment', ['deploymentType', 'appsFolders', 'directoryPath']);
-    }
-    validate(jdlDeployment, options = {}) {
-        super.validate(jdlDeployment);
-        switch (jdlDeployment.deploymentType) {
-            case Options.deploymentType.dockerCompose:
-                validateDockerComposeRelatedDeployment(jdlDeployment, options);
-                break;
-            case Options.deploymentType.kubernetes:
-                validateKubernetesRelatedDeployment(jdlDeployment);
-                break;
-            case Options.deploymentType.openshift:
-                validateOpenshiftRelatedDeployment(jdlDeployment, options);
-                break;
-            default:
-                throw new Error(`The deployment type ${jdlDeployment.deploymentType} isn't supported.`);
-        }
-    }
-}
-function validateDockerComposeRelatedDeployment(jdlDeployment, options = {}) {
-    if (jdlDeployment.gatewayType !== Options.gatewayType.springCloudGateway && options.applicationType === MICROSERVICE) {
-        throw new Error('A gateway type must be provided when dealing with microservices and the deployment type is docker-compose.');
-    }
-}
-function validateKubernetesRelatedDeployment(jdlDeployment) {
-    if (!jdlDeployment.kubernetesServiceType) {
-        throw new Error('A kubernetes service type must be provided when dealing with kubernetes-related deployments.');
-    }
-    if (jdlDeployment.istio && !jdlDeployment.ingressDomain) {
-        throw new Error('An ingress domain must be provided when dealing with kubernetes-related deployments, with istio and when the service type is ingress.');
-    }
-    if (jdlDeployment.kubernetesServiceType === Options.kubernetesServiceType.ingress && !jdlDeployment.ingressType) {
-        throw new Error('An ingress type is required when dealing with kubernetes-related deployments and when the service type is ingress.');
-    }
-}
-function validateOpenshiftRelatedDeployment(jdlDeployment, options) {
-    if (jdlDeployment.storageType) {
-        if (options.prodDatabaseType === NO) {
-            throw new Error(`Can't have the storageType option set when there is no ${PROD_DATABASE_TYPE}.`);
-        }
-        if (options.searchEngine === ELASTICSEARCH) {
-            throw new Error("Can't have the storageType option set when elasticsearch is the search engine.");
-        }
-        if (jdlDeployment.monitoring === Options.monitoring.prometheus) {
-            throw new Error("Can't have the storageType option set when the monitoring is done with prometheus.");
-        }
-    }
-}

package/dist/jdl/validators/entity-validator.js

@@ -1,37 +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 { reservedKeywords } from '../jhipster/index.js';
-import Validator from './validator.js';
-const { isReservedClassName } = reservedKeywords;
-export default class EntityValidator extends Validator {
-    constructor() {
-        super('entity', ['name']);
-    }
-    validate(jdlEntity, options = {}) {
-        super.validate(jdlEntity);
-        if (options.checkReservedKeywords) {
-            checkForReservedClassName(jdlEntity);
-        }
-    }
-}
-function checkForReservedClassName(jdlEntity) {
-    if (isReservedClassName(jdlEntity.name)) {
-        throw new Error(`The name '${jdlEntity.name}' is a reserved keyword and can not be used as an entity class name.`);
-    }
-}

package/dist/jdl/validators/enum-validator.js

@@ -1,37 +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 { reservedKeywords } from '../jhipster/index.js';
-import Validator from './validator.js';
-const { isReservedClassName } = reservedKeywords;
-export default class EnumValidator extends Validator {
-    constructor() {
-        super('enum', ['name']);
-    }
-    validate(jdlEnum, options = {}) {
-        super.validate(jdlEnum);
-        if (options.checkReservedKeywords) {
-            checkForReservedClassName(jdlEnum);
-        }
-    }
-}
-function checkForReservedClassName(jdlEnum) {
-    if (isReservedClassName(jdlEnum.name)) {
-        throw new Error(`The enum name '${jdlEnum.name}' is reserved keyword and can not be used as enum class name.`);
-    }
-}

package/dist/jdl/validators/jdl-with-application-validator.js

@@ -1,191 +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 { applicationOptions, fieldTypes, relationshipOptions } from '../jhipster/index.js';
-import EntityValidator from './entity-validator.js';
-import FieldValidator from './field-validator.js';
-import ValidationValidator from './validation-validator.js';
-import RelationshipValidator from './relationship-validator.js';
-import EnumValidator from './enum-validator.js';
-import DeploymentValidator from './deployment-validator.js';
-import UnaryOptionValidator from './unary-option-validator.js';
-import BinaryOptionValidator from './binary-option-validator.js';
-const { OptionNames } = applicationOptions;
-const { BUILT_IN_ENTITY } = relationshipOptions;
-const { BLUEPRINTS, BASE_NAME } = OptionNames;
-/**
- * Constructor taking the jdl object to check against application settings.
- * @param {JDLObject} jdlObject -  the jdl object to check.
- * @param {Object} logger - the logger to use, default to the console.
- * @param {Object} [options]
- */
-export default function createValidator(jdlObject, logger = console) {
-    if (!jdlObject) {
-        throw new Error('A JDL object must be passed to check for business errors.');
-    }
-    return {
-        checkForErrors: () => {
-            jdlObject.forEachApplication(jdlApplication => {
-                const blueprints = jdlApplication.getConfigurationOptionValue(BLUEPRINTS);
-                const checkReservedKeywords = (blueprints?.length ?? 0) === 0;
-                checkForNamespaceConfigErrors(jdlApplication);
-                checkForRelationshipErrors();
-                checkForEntityErrors(jdlApplication, { checkReservedKeywords });
-                checkForEnumErrors({ checkReservedKeywords });
-                if (!checkReservedKeywords) {
-                    logger.warn('Blueprints are being used, the JDL validation phase is skipped.');
-                    return;
-                }
-                checkDeploymentsErrors();
-                checkForOptionErrors();
-            });
-            checkForRelationshipsBetweenApplications();
-        },
-    };
-    function checkForNamespaceConfigErrors(jdlApplication) {
-        jdlApplication.forEachNamespaceConfiguration(config => {
-            const blueprints = jdlApplication.config.getOption('blueprints');
-            if (!blueprints || !blueprints.getValue().some(blueprint => blueprint === config.namespace)) {
-                throw new Error(`Blueprint namespace config ${config.namespace} requires the blueprint ${config.namespace}`);
-            }
-        });
-    }
-    function checkForEntityErrors(jdlApplication, options) {
-        if (jdlObject.getEntityQuantity() === 0) {
-            return;
-        }
-        const validator = new EntityValidator();
-        jdlObject.forEachEntity(jdlEntity => {
-            if (!jdlApplication.hasEntityName(jdlEntity.name)) {
-                return;
-            }
-            validator.validate(jdlEntity, options);
-            checkForFieldErrors(jdlEntity.name, jdlEntity.fields, jdlApplication);
-        });
-    }
-    function checkForFieldErrors(_entityName, jdlFields, _jdlApplication) {
-        const validator = new FieldValidator();
-        Object.keys(jdlFields).forEach(fieldName => {
-            const jdlField = jdlFields[fieldName];
-            validator.validate(jdlField);
-            const isAnEnum = jdlObject.hasEnum(jdlField.type);
-            checkForValidationErrors(jdlField, isAnEnum);
-        });
-    }
-    function checkForValidationErrors(jdlField, isAnEnum) {
-        const validator = new ValidationValidator();
-        Object.keys(jdlField.validations).forEach(validationName => {
-            const jdlValidation = jdlField.validations[validationName];
-            validator.validate(jdlValidation);
-            if (!fieldTypes.hasValidation(jdlField.type, jdlValidation.name, isAnEnum)) {
-                throw new Error(`The validation '${jdlValidation.name}' isn't supported for the type '${jdlField.type}'.`);
-            }
-        });
-    }
-    function checkForRelationshipErrors() {
-        if (jdlObject.getRelationshipQuantity() === 0) {
-            return;
-        }
-        const validator = new RelationshipValidator();
-        jdlObject.forEachRelationship(jdlRelationship => {
-            validator.validate(jdlRelationship);
-            checkForAbsentEntities({
-                jdlRelationship,
-                doesEntityExist: entityName => !!jdlObject.getEntity(entityName),
-            });
-        });
-    }
-    function checkForEnumErrors(options) {
-        if (jdlObject.getEnumQuantity() === 0) {
-            return;
-        }
-        const validator = new EnumValidator();
-        jdlObject.forEachEnum(jdlEnum => {
-            validator.validate(jdlEnum, options);
-        });
-    }
-    function checkDeploymentsErrors() {
-        if (jdlObject.getDeploymentQuantity() === 0) {
-            return;
-        }
-        const validator = new DeploymentValidator();
-        jdlObject.forEachDeployment(deployment => {
-            validator.validate(deployment);
-        });
-    }
-    function checkForOptionErrors() {
-        if (jdlObject.getOptionQuantity() === 0) {
-            return;
-        }
-        const unaryOptionValidator = new UnaryOptionValidator();
-        const binaryOptionValidator = new BinaryOptionValidator();
-        jdlObject.getOptions().forEach(option => {
-            if (option.getType() === 'UNARY') {
-                unaryOptionValidator.validate(option);
-            }
-            else {
-                binaryOptionValidator.validate(option);
-            }
-        });
-    }
-    function checkForRelationshipsBetweenApplications() {
-        const applicationsPerEntityNames = getApplicationsPerEntityNames(jdlObject);
-        jdlObject.forEachRelationship(jdlRelationship => {
-            checkIfRelationshipIsBetweenApplications({
-                jdlRelationship,
-                applicationsPerEntityName: applicationsPerEntityNames,
-            });
-        });
-    }
-}
-function checkForAbsentEntities({ jdlRelationship, doesEntityExist, }) {
-    const absentEntities = [];
-    if (!doesEntityExist(jdlRelationship.from)) {
-        absentEntities.push(jdlRelationship.from);
-    }
-    if (!doesEntityExist(jdlRelationship.to) && !jdlRelationship.options.global[BUILT_IN_ENTITY]) {
-        absentEntities.push(jdlRelationship.to);
-    }
-    if (absentEntities.length !== 0) {
-        throw new Error(`In the relationship between ${jdlRelationship.from} and ${jdlRelationship.to}, ` +
-            `${absentEntities.join(' and ')} ${absentEntities.length === 1 ? 'is' : 'are'} not declared. If '${jdlRelationship.to}' is a built-in entity declare like '${jdlRelationship.from} to ${jdlRelationship.to} with builtInEntity'.`);
-    }
-}
-function checkIfRelationshipIsBetweenApplications({ jdlRelationship, applicationsPerEntityName }) {
-    let applicationsForSourceEntity = applicationsPerEntityName[jdlRelationship.from];
-    let applicationsForDestinationEntity = applicationsPerEntityName[jdlRelationship.to];
-    if (!applicationsForDestinationEntity || !applicationsForSourceEntity) {
-        return;
-    }
-    applicationsForSourceEntity = applicationsForSourceEntity.map(jdlApplication => jdlApplication.getConfigurationOptionValue(BASE_NAME));
-    applicationsForDestinationEntity = applicationsForDestinationEntity.map(jdlApplication => jdlApplication.getConfigurationOptionValue(BASE_NAME));
-    const difference = applicationsForSourceEntity.filter(application => !applicationsForDestinationEntity.includes(application));
-    if (difference.length !== 0) {
-        throw new Error(`Entities for the ${jdlRelationship.type} relationship from '${jdlRelationship.from}' to '${jdlRelationship.to}' do not belong to the same application.`);
-    }
-}
-function getApplicationsPerEntityNames(jdlObject) {
-    const applicationsPerEntityName = {};
-    jdlObject.forEachApplication(jdlApplication => {
-        jdlApplication.forEachEntityName(entityName => {
-            applicationsPerEntityName[entityName] = applicationsPerEntityName[entityName] || [];
-            applicationsPerEntityName[entityName].push(jdlApplication);
-        });
-    });
-    return applicationsPerEntityName;
-}