generator-jhipster 8.0.0-rc.1 → 8.1.0

package/dist/jdl/jhipster/json-entity.js

@@ -22,6 +22,7 @@ import { upperFirst } from '../utils/string-utils.js';
  * The JSONEntity class represents a read-to-be exported to JSON entity.
  */
 class JSONEntity {
+    annotations;
     /**
      * Creates a new JSONEntity instance.
      * @param args the entity configuration, keys:
@@ -46,6 +47,7 @@ class JSONEntity {
         const merged = merge(getDefaults(args.entityName), args);
         this.name = merged.name;
         this.fields = merged.fields;
+        this.annotations = merged.annotations;
         this.relationships = merged.relationships;
         this.documentation = merged.documentation;
         this.entityTableName = merged.entityTableName;
@@ -100,6 +102,9 @@ class JSONEntity {
             this[optionName] = options[optionName];
         });
     }
+    setAnnotations(annotations = {}) {
+        Object.assign(this.annotations, annotations);
+    }
 }
 export default JSONEntity;
 function getDefaults(entityName) {
@@ -108,5 +113,6 @@ function getDefaults(entityName) {
         fields: [],
         relationships: [],
         applications: [],
+        annotations: {},
     };
 }

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

@@ -32,12 +32,44 @@ export default function createApplicationConfigurationFromObject(configurationOb
             logger.debug(`Unrecognized application option name and value: '${optionName}' and '${optionValue}'.`);
             return;
         }
-        configuration.setOption(createJDLConfigurationOption(optionName, optionValue));
+        configuration.setOption(createApplicationJDLConfigurationOption(optionName, optionValue));
     });
     return configuration;
 }
-function createJDLConfigurationOption(name, value) {
+export function createApplicationNamespaceConfigurationFromObject(parsedNamespaceConfigs = {}) {
+    return Object.entries(parsedNamespaceConfigs).map(([namespace, parsedConfig]) => {
+        const configuration = new JDLApplicationConfiguration(namespace);
+        for (const [optionName, optionValue] of Object.entries(parsedConfig)) {
+            configuration.setOption(createUnknownJDLConfigurationOption(optionName, optionValue));
+        }
+        return configuration;
+    });
+}
+function createUnknownJDLConfigurationOption(name, value) {
+    let type;
+    if (typeof value === 'boolean') {
+        type = 'boolean';
+    }
+    else if (/^\d+$/.test(value)) {
+        value = parseInt(value, 10);
+        type = 'integer';
+    }
+    else if (Array.isArray(value)) {
+        type = 'list';
+    }
+    else if (typeof value === 'string') {
+        type = 'string';
+    }
+    else {
+        throw new Error(`Unknown value type for option ${name}`);
+    }
+    return createJDLConfigurationOption(type, name, value);
+}
+function createApplicationJDLConfigurationOption(name, value) {
     const type = applicationDefinition.getTypeForOption(name);
+    return createJDLConfigurationOption(type, name, value);
+}
+function createJDLConfigurationOption(type, name, value) {
     switch (type) {
         case 'string':
             return new StringJDLApplicationConfigurationOption(name, value, applicationDefinition.shouldTheValueBeQuoted(name));

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-entity.js

@@ -16,6 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { upperFirst } from 'lodash-es';
 import { merge } from '../utils/object-utils.js';
 import getTableNameFromEntityName from '../jhipster/entity-table-name-creator.js';
 export default class JDLEntity {
@@ -23,6 +24,7 @@ export default class JDLEntity {
     tableName;
     fields;
     comment;
+    annotations;
     constructor(args) {
         const merged = merge(defaults(), args);
         if (!merged.name) {
@@ -32,6 +34,7 @@ export default class JDLEntity {
         this.tableName = merged.tableName || merged.name;
         this.fields = merged.fields;
         this.comment = merged.comment;
+        this.annotations = merged.annotations ?? {};
     }
     /**
      * Adds the fields to the entity.
@@ -60,6 +63,18 @@ export default class JDLEntity {
                 .map(line => ` * ${line}\n`)
                 .join('')} */\n`;
         }
+        Object.entries(this.annotations).forEach(([key, value]) => {
+            key = upperFirst(key);
+            if (value === true) {
+                stringifiedEntity += `@${key}\n`;
+            }
+            else if (typeof value === 'string') {
+                stringifiedEntity += `@${key}("${value}")\n`;
+            }
+            else {
+                stringifiedEntity += `@${key}(${value})\n`;
+            }
+        });
         stringifiedEntity += `entity ${this.name}`;
         if (this.tableName && getTableNameFromEntityName(this.name) !== getTableNameFromEntityName(this.tableName)) {
             stringifiedEntity += ` (${this.tableName})`;
@@ -73,7 +88,7 @@ export default class JDLEntity {
 function defaults() {
     return {
         fields: {},
-        options: [],
+        annotations: {},
     };
 }
 function formatFieldObjects(jdlFieldObjects) {

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

@@ -16,6 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { upperFirst } from 'lodash-es';
 import { merge } from '../utils/object-utils.js';
 export default class JDLField {
     name;
@@ -66,6 +67,18 @@ export default class JDLField {
                 .map(line => ` * ${line}\n`)
                 .join('')} */\n`;
         }
+        Object.entries(this.options ?? {}).forEach(([key, value]) => {
+            key = upperFirst(key);
+            if (value === true) {
+                string += `@${key}\n`;
+            }
+            else if (typeof value === 'string') {
+                string += `@${key}("${value}")\n`;
+            }
+            else {
+                string += `@${key}(${value})\n`;
+            }
+        });
         string += `${this.name} ${this.type}`;
         Object.keys(this.validations).forEach(validationName => {
             string += ` ${this.validations[validationName].toString()}`;

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

@@ -229,10 +229,10 @@ export default class JDLObject {
             string += `${this.enums.toString()}\n`;
         }
         if (this.getRelationshipQuantity() !== 0) {
-            string += `${relationshipsToString(this.relationships)}\n`;
+            string += `${relationshipsToString(this.relationships)}`;
         }
         if (this.getOptionQuantity() !== 0) {
-            string += `${optionsToString(this.options)}`;
+            string += `\n${optionsToString(this.options)}`;
         }
         return string;
     }
@@ -263,7 +263,7 @@ function relationshipsToString(relationships) {
     if (string === '') {
         return '';
     }
-    return `${relationships.toString()}\n`;
+    return `${string}\n`;
 }
 function optionsToString(options) {
     const string = options.toString();

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

@@ -1,3 +1,22 @@
+/**
+ * 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 { upperFirst } from 'lodash-es';
 import { Validations } from '../jhipster/index.mjs';
 import { relationshipTypeExists } from '../jhipster/relationship-types.js';
 const { REQUIRED } = Validations;
@@ -72,9 +91,9 @@ export default class JDLRelationship {
         if (Object.keys(sourceOptions).length !== 0) {
             Object.keys(sourceOptions).forEach(name => {
                 const value = sourceOptions[name];
-                string += `  @${name}${value != null && sourceOptions[name] !== true ? `(${value})` : ''}\n`;
+                name = upperFirst(name);
+                string += `@${name}${value != null && value !== true ? `(${value}) ` : ' '}`;
             });
-            string += '  ';
         }
         string += `${this.from}`;
         if (this.injectedFieldInFrom) {
@@ -92,12 +111,11 @@ export default class JDLRelationship {
         }
         const destinationOptions = this.options.destination;
         if (Object.keys(destinationOptions).length !== 0) {
-            string += '\n';
             Object.keys(destinationOptions).forEach(name => {
                 const value = destinationOptions[name];
-                string += `  @${name}${value != null && destinationOptions[name] !== true ? `(${value})` : ''}\n`;
+                name = upperFirst(name);
+                string += `@${name}${value != null && value !== true ? `(${value}) ` : ' '}`;
             });
-            string += '  ';
         }
         string += `${this.to}`;
         if (this.injectedFieldInTo) {

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

@@ -135,14 +135,29 @@ export default class JDLAstBuilderVisitor extends BaseJDLCSTVisitor {
         };
     }
     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;
@@ -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 },
@@ -55,7 +55,7 @@ const applicationConfigTokens = [
     { name: 'CLIENT_THEME', pattern: CLIENT_THEME },
     { name: 'WITH_ADMIN_UI', pattern: WITH_ADMIN_UI },
     { name: 'NATIVE_LANGUAGE', pattern: NATIVE_LANGUAGE },
-    { name: 'FRONT_END_BUILDER', pattern: 'frontendBuilder' },
+    { name: 'FRONT_END_BUILDER', pattern: 'frontendBuilder' }, // TODO always valid?
     { name: 'SKIP_USER_MANAGEMENT', pattern: SKIP_USER_MANAGEMENT },
     { name: 'ENABLE_SWAGGER_CODEGEN', pattern: ENABLE_SWAGGER_CODEGEN },
     { name: 'REACTIVE', pattern: REACTIVE },

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() {