generator-jhipster 8.0.0-beta.3 → 8.0.0

package/dist/jdl/models/jdl-application-configuration.js

@@ -20,8 +20,10 @@ import ApplicationOptions from '../jhipster/application-options.js';
 const { OptionNames } = ApplicationOptions;
 export default class JDLApplicationConfiguration {
     options;
-    constructor() {
+    namespace;
+    constructor(namespace) {
         this.options = {};
+        this.namespace = namespace;
     }
     hasOption(optionName) {
         if (!optionName) {
@@ -54,12 +56,13 @@ export default class JDLApplicationConfiguration {
     }
     toString(indent = 0) {
         const spaceBeforeConfigKeyword = ' '.repeat(indent);
+        const namespace = this.namespace ? `:${this.namespace}` : '';
         if (Object.keys(this.options).length === 0) {
-            return `${spaceBeforeConfigKeyword}config {}`;
+            return `${spaceBeforeConfigKeyword}config${namespace} {}`;
         }
         const spaceBeforeOption = ' '.repeat(2 * indent);
         const config = getFormattedConfigOptionsString(this.options, spaceBeforeOption);
-        return `${spaceBeforeConfigKeyword}config {
+        return `${spaceBeforeConfigKeyword}config${namespace} {
 ${config}
 ${spaceBeforeConfigKeyword}}`;
     }

package/dist/jdl/models/jdl-application-factory.js

@@ -22,6 +22,6 @@ import JDLApplication from './jdl-application.js';
  * @param {Object} config - the application configuration.
  * @returns {JDLApplication} the created JDL application.
  */
-export default function createJDLApplication(config = {}) {
-    return new JDLApplication({ config: { baseName: 'jhipster', ...config } });
+export default function createJDLApplication(config, namespaceConfigs) {
+    return new JDLApplication({ config: { baseName: 'jhipster', ...config }, namespaceConfigs });
 }

package/dist/jdl/models/jdl-application.js

@@ -16,15 +16,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import createApplicationConfigurationFromObject from './jdl-application-configuration-factory.js';
+import createApplicationConfigurationFromObject, { createApplicationNamespaceConfigurationFromObject, } from './jdl-application-configuration-factory.js';
 import JDLApplicationEntities from './jdl-application-entities.js';
 import JDLOptions from './jdl-options.js';
 export default class JDLApplication {
     config;
+    namespaceConfigs;
     entityNames;
     options;
-    constructor({ config = {}, entityNames = [] } = {}) {
+    constructor({ config = {}, entityNames = [], namespaceConfigs = {} } = {}) {
         this.config = createApplicationConfigurationFromObject(config);
+        this.namespaceConfigs = createApplicationNamespaceConfigurationFromObject(namespaceConfigs);
         this.entityNames = new JDLApplicationEntities(entityNames);
         this.options = new JDLOptions();
     }
@@ -50,6 +52,11 @@ export default class JDLApplication {
     forEachConfigurationOption(passedFunction) {
         this.config.forEachOption(passedFunction);
     }
+    forEachNamespaceConfiguration(passedFunction) {
+        for (const namespaceConfig of this.namespaceConfigs) {
+            passedFunction(namespaceConfig);
+        }
+    }
     addEntityName(entityName) {
         if (!entityName) {
             throw new Error('An entity name has to be passed so as to be added to the application.');
@@ -87,7 +94,9 @@ export default class JDLApplication {
         return this.options.size();
     }
     toString() {
-        let stringifiedApplication = `application {\n${this.config.toString(2)}\n`;
+        let stringifiedApplication = `application {
+${this.config.toString(2)}
+${this.namespaceConfigs.map(config => `${config.toString(2)}\n`).join()}`;
         if (this.entityNames.size() !== 0) {
             stringifiedApplication += `\n${this.entityNames.toString(2)}\n`;
         }

package/dist/jdl/models/jdl-deployment.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import { deploymentOptions, applicationOptions, serviceDiscoveryTypes } from '../jhipster/index.mjs';
 import { merge } from '../utils/object-utils.js';
 import { join } from '../utils/set-utils.js';

package/dist/jdl/models/jdl-enum.js

@@ -37,13 +37,13 @@ export default class JDLEnum {
         return stringifyValues(this.values).join(',');
     }
     getValueJavadocs() {
-        const javadocs = {};
+        const documentations = {};
         this.values.forEach(jdlEnumValue => {
             if (jdlEnumValue.comment) {
-                javadocs[jdlEnumValue.name] = jdlEnumValue.comment;
+                documentations[jdlEnumValue.name] = jdlEnumValue.comment;
             }
         });
-        return javadocs;
+        return documentations;
     }
     toString() {
         let comment = '';

package/dist/jdl/models/jdl-relationship.js

@@ -1,28 +1,6 @@
-/**
- * Copyright 2013-2023 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 { validations } from '../jhipster/index.mjs';
+import { Validations } from '../jhipster/index.mjs';
 import { relationshipTypeExists } from '../jhipster/relationship-types.js';
-const { Validations: { REQUIRED }, } = validations;
-export const JDL_RELATIONSHIP_ONE_TO_ONE = 'OneToOne';
-export const JDL_RELATIONSHIP_ONE_TO_MANY = 'OneToMany';
-export const JDL_RELATIONSHIP_MANY_TO_ONE = 'ManyToOne';
-export const JDL_RELATIONSHIP_MANY_TO_MANY = 'ManyToMany';
+const { REQUIRED } = Validations;
 export default class JDLRelationship {
     side;
     from;

package/dist/jdl/parsing/api.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import { EOF } from 'chevrotain';
 import JDLAstBuilderVisitor from './jdl-ast-builder-visitor.js';
 import { JDLLexer, tokens } from './lexer/lexer.js';

package/dist/jdl/parsing/jdl-ast-builder-visitor.js

@@ -113,9 +113,9 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
                 annotations.push(this.visit(contextObject));
             });
         }
-        let javadoc = null;
+        let documentation = null;
         if (context.JAVADOC) {
-            javadoc = trimComment(context.JAVADOC[0].image);
+            documentation = trimComment(context.JAVADOC[0].image);
         }
         const name = context.NAME[0].image;
         let tableName = name;
@@ -131,18 +131,33 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
             name,
             tableName,
             body,
-            javadoc,
+            documentation,
         };
     }
     annotationDeclaration(context) {
+        const optionName = context.option[0].image;
         if (!context.value) {
-            return { optionName: context.option[0].image, type: 'UNARY' };
-        }
-        return {
-            optionName: context.option[0].image,
-            optionValue: context.value[0].image.replace(/"/g, ''),
-            type: 'BINARY',
-        };
+            return { optionName, type: 'UNARY' };
+        }
+        let { image: optionValue } = context.value[0];
+        const { tokenType } = context.value[0];
+        switch (tokenType.name) {
+            case 'INTEGER':
+                optionValue = parseInt(optionValue, 10);
+                break;
+            case 'DECIMAL':
+                optionValue = parseFloat(optionValue);
+                break;
+            case 'TRUE':
+                optionValue = true;
+                break;
+            case 'FALSE':
+                optionValue = false;
+                break;
+            default:
+                optionValue = optionValue.replace(/"/g, '');
+        }
+        return { optionName, optionValue, type: 'BINARY' };
     }
     entityTableNameDeclaration(context) {
         return context.NAME[0].image;
@@ -173,7 +188,7 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
             // this.visit(context.type) is equivalent to this.visit(context.type[0])
             type: this.visit(context.type),
             validations,
-            javadoc: comment,
+            documentation: comment,
             annotations,
         };
     }
@@ -252,7 +267,7 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
         };
     }
     relationshipSide(context) {
-        const javadoc = this.visit(context.comment);
+        const documentation = this.visit(context.comment);
         const name = context.NAME[0].image;
         const required = !!context.REQUIRED;
         let injectedField = null;
@@ -265,7 +280,7 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
         const ast = {
             name,
             injectedField,
-            javadoc,
+            documentation,
             required,
         };
         if (!injectedField) {
@@ -286,11 +301,11 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
     enumDeclaration(context) {
         const name = context.NAME[0].image;
         const values = this.visit(context.enumPropList);
-        let javadoc = null;
+        let documentation = null;
         if (context.JAVADOC) {
-            javadoc = trimComment(context.JAVADOC[0].image);
+            documentation = trimComment(context.JAVADOC[0].image);
         }
-        return { name, values, javadoc };
+        return { name, values, documentation };
     }
     enumPropList(context) {
         return context.enumProp.map(this.visit, this);
@@ -380,6 +395,7 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
     applicationSubDeclaration(context) {
         const applicationSubDeclaration = {
             config: {},
+            namespaceConfigs: {},
             entities: { entityList: [], excluded: [] },
             options: {},
             useOptions: [],
@@ -388,6 +404,10 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
             // Apparently the pegjs grammar only returned the last config
             applicationSubDeclaration.config = this.visit(context.applicationSubConfig[context.applicationSubConfig.length - 1]);
         }
+        if (context.applicationSubNamespaceConfig) {
+            const { namespace, config } = this.visit(context.applicationSubNamespaceConfig[context.applicationSubNamespaceConfig.length - 1]);
+            applicationSubDeclaration.namespaceConfigs[namespace] = config;
+        }
         if (context.applicationSubEntities) {
             // Apparently the pegjs grammar only returned the last entities
             applicationSubDeclaration.entities = this.visit(context.applicationSubEntities[context.applicationSubEntities.length - 1]);
@@ -429,6 +449,42 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
         }
         return applicationSubDeclaration;
     }
+    applicationSubNamespaceConfig(context) {
+        const config = {};
+        const namespace = context.namespace[0].image;
+        if (context.applicationNamespaceConfigDeclaration) {
+            const configProps = context.applicationNamespaceConfigDeclaration.map(this.visit, this);
+            configProps.forEach(configProp => {
+                config[configProp.key] = configProp.value;
+            });
+        }
+        return { namespace, config };
+    }
+    applicationNamespaceConfigDeclaration(context) {
+        const key = context.NAME[0].image;
+        const value = this.visit(context.namespaceConfigValue);
+        return { key, value };
+    }
+    namespaceConfigValue(context) {
+        if (context.qualifiedName) {
+            return this.visit(context.qualifiedName);
+        }
+        if (context.list) {
+            return this.visit(context.list);
+        }
+        if (context.INTEGER) {
+            return context.INTEGER[0].image;
+        }
+        if (context.STRING) {
+            const stringImage = context.STRING[0].image;
+            return stringImage.substring(1, stringImage.length - 1);
+        }
+        if (context.BOOLEAN) {
+            return context.BOOLEAN[0].image === 'true';
+        }
+        /* istanbul ignore next */
+        throw new Error('No valid config value was found, expected a qualified name, a list, an integer, a string or a boolean.');
+    }
     applicationSubConfig(context) {
         const config = {};
         if (context.applicationConfigDeclaration) {

package/dist/jdl/parsing/jdl-parser.js

@@ -18,6 +18,7 @@
  */
 import { CstParser } from 'chevrotain';
 import { tokens as LexerTokens } from './lexer/lexer.js';
+import { NAME } from './lexer/shared-tokens.js';
 let instance;
 export default class JDLParser extends CstParser {
     constructor() {
@@ -64,9 +65,12 @@ export default class JDLParser extends CstParser {
         this.applicationDeclaration();
         this.applicationSubDeclaration();
         this.applicationSubConfig();
+        this.applicationSubNamespaceConfig();
         this.applicationSubEntities();
         this.applicationConfigDeclaration();
         this.configValue();
+        this.applicationNamespaceConfigDeclaration();
+        this.namespaceConfigValue();
         this.qualifiedName();
         this.list();
         // very important to call this after all the rules have been defined.
@@ -133,12 +137,17 @@ export default class JDLParser extends CstParser {
             this.CONSUME(LexerTokens.NAME, { LABEL: 'option' });
             this.OPTION(() => {
                 this.CONSUME(LexerTokens.LPAREN);
-                this.OR([
-                    { ALT: () => this.CONSUME2(LexerTokens.STRING, { LABEL: 'value' }) },
-                    { ALT: () => this.CONSUME2(LexerTokens.NAME, { LABEL: 'value' }) },
-                    { ALT: () => this.CONSUME3(LexerTokens.INTEGER, { LABEL: 'value' }) },
-                    { ALT: () => this.CONSUME3(LexerTokens.DECIMAL, { LABEL: 'value' }) },
-                ]);
+                this.OR({
+                    IGNORE_AMBIGUITIES: true,
+                    DEF: [
+                        { ALT: () => this.CONSUME(LexerTokens.STRING, { LABEL: 'value' }) },
+                        { ALT: () => this.CONSUME(LexerTokens.INTEGER, { LABEL: 'value' }) },
+                        { ALT: () => this.CONSUME(LexerTokens.DECIMAL, { LABEL: 'value' }) },
+                        { ALT: () => this.CONSUME(LexerTokens.TRUE, { LABEL: 'value' }) },
+                        { ALT: () => this.CONSUME(LexerTokens.FALSE, { LABEL: 'value' }) },
+                        { ALT: () => this.CONSUME2(LexerTokens.NAME, { LABEL: 'value' }) },
+                    ],
+                });
                 this.CONSUME(LexerTokens.RPAREN);
             });
         });
@@ -455,6 +464,7 @@ export default class JDLParser extends CstParser {
         this.RULE('applicationSubDeclaration', () => {
             this.MANY(() => {
                 this.OR([
+                    { ALT: () => this.SUBRULE(this.applicationSubNamespaceConfig) },
                     { ALT: () => this.SUBRULE(this.applicationSubConfig) },
                     { ALT: () => this.SUBRULE(this.applicationSubEntities) },
                     { ALT: () => this.SUBRULE(this.unaryOptionDeclaration) },
@@ -464,6 +474,42 @@ export default class JDLParser extends CstParser {
             });
         });
     }
+    applicationSubNamespaceConfig() {
+        this.RULE('applicationSubNamespaceConfig', () => {
+            this.CONSUME(LexerTokens.CONFIG);
+            this.CONSUME(LexerTokens.LPAREN);
+            this.CONSUME(LexerTokens.NAME, { LABEL: 'namespace' });
+            this.CONSUME(LexerTokens.RPAREN);
+            this.CONSUME(LexerTokens.LCURLY);
+            this.MANY(() => {
+                this.OR([
+                    { ALT: () => this.CONSUME(LexerTokens.JAVADOC) },
+                    { ALT: () => this.SUBRULE(this.applicationNamespaceConfigDeclaration) },
+                ]);
+            });
+            this.CONSUME(LexerTokens.RCURLY);
+        });
+    }
+    applicationNamespaceConfigDeclaration() {
+        this.RULE('applicationNamespaceConfigDeclaration', () => {
+            this.CONSUME(NAME);
+            this.SUBRULE(this.namespaceConfigValue);
+            this.OPTION(() => {
+                this.CONSUME(LexerTokens.COMMA);
+            });
+        });
+    }
+    namespaceConfigValue() {
+        this.RULE('namespaceConfigValue', () => {
+            this.OR([
+                { ALT: () => this.CONSUME(LexerTokens.BOOLEAN) },
+                { ALT: () => this.SUBRULE(this.qualifiedName) },
+                { ALT: () => this.SUBRULE(this.list) },
+                { ALT: () => this.CONSUME(LexerTokens.INTEGER) },
+                { ALT: () => this.CONSUME(LexerTokens.STRING) },
+            ]);
+        });
+    }
     applicationSubConfig() {
         this.RULE('applicationSubConfig', () => {
             this.CONSUME(LexerTokens.CONFIG);

package/dist/jdl/parsing/lexer/application-tokens.js

@@ -23,7 +23,7 @@ import { applicationOptions } from '../../jhipster/index.mjs';
 import jhipsterDefinition from '../../../generators/app/jdl/index.mjs';
 const { OptionNames } = applicationOptions;
 const { APPLICATION_TYPE, AUTHENTICATION_TYPE, BASE_NAME, BLUEPRINT, BLUEPRINTS, BUILD_TOOL, CACHE_PROVIDER, CLIENT_FRAMEWORK, CLIENT_PACKAGE_MANAGER, CLIENT_THEME, CLIENT_THEME_VARIANT, CREATION_TIMESTAMP, DATABASE_TYPE, DEV_DATABASE_TYPE, DTO_SUFFIX, EMBEDDABLE_LAUNCH_SCRIPT, ENABLE_HIBERNATE_CACHE, ENABLE_SWAGGER_CODEGEN, ENABLE_TRANSLATION, ENTITY_SUFFIX, GATEWAY_SERVER_PORT, JHIPSTER_VERSION, JHI_PREFIX, JWT_SECRET_KEY, LANGUAGES, MICROFRONTEND, MICROFRONTENDS, NATIVE_LANGUAGE, PACKAGE_NAME, PROD_DATABASE_TYPE, REACTIVE, REMEMBER_ME_KEY, SEARCH_ENGINE, SERVER_PORT, SKIP_CLIENT, SKIP_SERVER, SKIP_USER_MANAGEMENT, TEST_FRAMEWORKS, WEBSOCKET, WITH_ADMIN_UI, ENABLE_GRADLE_ENTERPRISE, GRADLE_ENTERPRISE_HOST, } = OptionNames;
-const applicationConfigCategoryToken = createTokenFromConfig({ name: 'CONFIG_KEY', pattern: Lexer.NA });
+export const applicationConfigCategoryToken = createTokenFromConfig({ name: 'CONFIG_KEY', pattern: Lexer.NA });
 const applicationConfigTokens = [
     { name: 'BASE_NAME', pattern: BASE_NAME },
     { name: 'BLUEPRINTS', pattern: BLUEPRINTS },

package/dist/jdl/parsing/lexer/relationship-type-tokens.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 import { Lexer } from 'chevrotain';
-import { JDL_RELATIONSHIP_MANY_TO_MANY, JDL_RELATIONSHIP_MANY_TO_ONE, JDL_RELATIONSHIP_ONE_TO_MANY, JDL_RELATIONSHIP_ONE_TO_ONE, } from '../../models/jdl-relationship.js';
+import { JDL_RELATIONSHIP_MANY_TO_MANY, JDL_RELATIONSHIP_MANY_TO_ONE, JDL_RELATIONSHIP_ONE_TO_MANY, JDL_RELATIONSHIP_ONE_TO_ONE, } from '../../basic-types/relationships.js';
 import createTokenFromConfig from './token-creator.js';
 const relationshipTypeCategoryToken = createTokenFromConfig({ name: 'RELATIONSHIP_TYPE', pattern: Lexer.NA });
 const relationshipTypeTokens = [

package/dist/jdl/parsing/lexer/token-creator.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import { createToken } from 'chevrotain';
 import { NAME, KEYWORD, namePattern } from './shared-tokens.js';
 const { isString } = _;

package/dist/jdl/parsing/self-checks/parsing-system-checker.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import { Lexer } from 'chevrotain';
 import TokenCollectorVisitor from './token-collector-visitor.js';
 export function checkTokens(allDefinedTokens, rules) {

package/dist/jdl/parsing/validator.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 /* eslint-disable no-useless-escape */
-import _ from 'lodash';
+import * as _ from 'lodash-es';
 import { tokenMatcher as matchesToken } from 'chevrotain';
 import JDLParser from './jdl-parser.js';
 import { tokens as LexerTokens } from './lexer/lexer.js';

package/dist/jdl/utils/object-utils.js

@@ -50,7 +50,7 @@ export function areEntitiesEqual(firstEntity, secondEntity) {
     removeEntriesWithUndefinedValue(secondEntity);
     if (firstEntity.fields.length !== secondEntity.fields.length ||
         firstEntity.relationships.length !== secondEntity.relationships.length ||
-        firstEntity.javadoc !== secondEntity.javadoc ||
+        firstEntity.documentation !== secondEntity.documentation ||
         firstEntity.entityTableName !== secondEntity.entityTableName ||
         Object.keys(firstEntity).length !== Object.keys(secondEntity).length) {
         return false;

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

@@ -23,9 +23,11 @@ export default class EntityValidator extends Validator {
     constructor() {
         super('entity', ['name', 'tableName']);
     }
-    validate(jdlEntity) {
+    validate(jdlEntity, options = {}) {
         super.validate(jdlEntity);
-        checkForReservedClassName(jdlEntity);
+        if (options.checkReservedKeywords) {
+            checkForReservedClassName(jdlEntity);
+        }
     }
 }
 function checkForReservedClassName(jdlEntity) {

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

@@ -23,9 +23,11 @@ export default class EnumValidator extends Validator {
     constructor() {
         super('enum', ['name']);
     }
-    validate(jdlEnum) {
+    validate(jdlEnum, options = {}) {
         super.validate(jdlEnum);
-        checkForReservedClassName(jdlEnum);
+        if (options.checkReservedKeywords) {
+            checkForReservedClassName(jdlEnum);
+        }
     }
 }
 function checkForReservedClassName(jdlEnum) {

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

@@ -42,20 +42,30 @@ export default function createValidator(jdlObject, logger = console) {
         checkForErrors: () => {
             jdlObject.forEachApplication(jdlApplication => {
                 const blueprints = jdlApplication.getConfigurationOptionValue(BLUEPRINTS);
-                if (blueprints && blueprints.length > 0) {
+                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;
                 }
-                checkForEntityErrors(jdlApplication);
-                checkForRelationshipErrors();
-                checkForEnumErrors();
                 checkDeploymentsErrors();
                 checkForOptionErrors();
             });
             checkForRelationshipsBetweenApplications();
         },
     };
-    function checkForEntityErrors(jdlApplication) {
+    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;
         }
@@ -64,7 +74,7 @@ export default function createValidator(jdlObject, logger = console) {
             if (!jdlApplication.hasEntityName(jdlEntity.name)) {
                 return;
             }
-            validator.validate(jdlEntity);
+            validator.validate(jdlEntity, options);
             checkForFieldErrors(jdlEntity.name, jdlEntity.fields, jdlApplication);
         });
     }
@@ -100,13 +110,13 @@ export default function createValidator(jdlObject, logger = console) {
             });
         });
     }
-    function checkForEnumErrors() {
+    function checkForEnumErrors(options) {
         if (jdlObject.getEnumQuantity() === 0) {
             return;
         }
         const validator = new EnumValidator();
         jdlObject.forEachEnum(jdlEnum => {
-            validator.validate(jdlEnum);
+            validator.validate(jdlEnum, options);
         });
     }
     function checkDeploymentsErrors() {