generator-jhipster 8.0.0-rc.1 → 8.0.0

package/dist/jdl/exporters/config.js

@@ -0,0 +1,11 @@
+import { GENERATOR_NAME } from './export-utils.js';
+export const mergeYoRcContent = (oldConfig, newConfig) => {
+    const merged = { [GENERATOR_NAME]: {} };
+    for (const ns of new Set([...Object.keys(oldConfig), ...Object.keys(newConfig)])) {
+        merged[ns] = { ...oldConfig[ns], ...newConfig[ns] };
+    }
+    if (oldConfig[GENERATOR_NAME]?.creationTimestamp) {
+        merged[GENERATOR_NAME].creationTimestamp = oldConfig[GENERATOR_NAME].creationTimestamp;
+    }
+    return merged;
+};

package/dist/jdl/exporters/export-utils.js

@@ -18,6 +18,7 @@
  */
 import fs from 'fs';
 import { doesFileExist } from '../utils/file-utils.js';
+import { mergeYoRcContent } from './config.js';
 export const GENERATOR_NAME = 'generator-jhipster';
 /**
  * This function writes a Yeoman config file in the current folder.
@@ -28,19 +29,7 @@ export function writeConfigFile(config, yoRcPath = '.yo-rc.json') {
     let newYoRc = { ...config };
     if (doesFileExist(yoRcPath)) {
         const yoRc = JSON.parse(fs.readFileSync(yoRcPath, { encoding: 'utf-8' }));
-        let creationTimestamp = config[GENERATOR_NAME].creationTimestamp;
-        if (yoRc[GENERATOR_NAME] && yoRc[GENERATOR_NAME].creationTimestamp) {
-            creationTimestamp = yoRc[GENERATOR_NAME].creationTimestamp;
-        }
-        newYoRc = {
-            ...yoRc,
-            ...config,
-            [GENERATOR_NAME]: {
-                ...yoRc[GENERATOR_NAME],
-                ...config[GENERATOR_NAME],
-                creationTimestamp,
-            },
-        };
+        newYoRc = mergeYoRcContent(yoRc, config);
     }
     fs.writeFileSync(yoRcPath, JSON.stringify(newYoRc, null, 2).concat('\n'));
 }

package/dist/jdl/index.js

@@ -1,3 +1,4 @@
 export * from './jdl-importer.js';
 export * from './parsing/api.js';
 export * from './jhipster/index.mjs';
+export * from './exporters/config.js';

package/dist/jdl/jdl-importer.js

@@ -204,8 +204,10 @@ function importOneApplicationAndEntities(jdlObject, configuration) {
         jdlObject,
     });
     const jsonEntities = entitiesPerApplicationMap.get(applicationName);
+    const { 'generator-jhipster': config, ...remaining } = formattedApplication;
     importState.exportedApplicationsWithEntities[applicationName] = {
-        config: formattedApplication['generator-jhipster'],
+        config,
+        ...remaining,
         entities: [],
     };
     if (jsonEntities.length !== 0) {
@@ -239,8 +241,10 @@ function importApplicationsAndEntities(jdlObject, configuration) {
             forSeveralApplications: true,
         });
         const exportedConfig = importState.exportedApplications.find(config => applicationName === config['generator-jhipster'].baseName);
+        const { 'generator-jhipster': config, ...remaining } = exportedConfig;
         importState.exportedApplicationsWithEntities[applicationName] = {
-            config: exportedConfig['generator-jhipster'],
+            config,
+            ...remaining,
             entities: exportedJSONEntities,
         };
         importState.exportedEntities = uniqBy([...importState.exportedEntities, ...exportedJSONEntities], 'name');

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/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 },

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

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

@@ -18,15 +18,15 @@
  */
 import EntityValidator from './entity-validator.js';
 import FieldValidator from './field-validator.js';
-import { fieldTypes, applicationTypes, databaseTypes, binaryOptions, reservedKeywords, relationshipOptions } from '../jhipster/index.mjs';
+import { fieldTypes, applicationTypes, databaseTypes, binaryOptions, relationshipOptions } from '../jhipster/index.mjs';
 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';
+import { isReservedFieldName, isReservedPaginationWords, isReservedTableName } from '../jhipster/reserved-keywords.js';
 const { BUILT_IN_ENTITY } = relationshipOptions;
-const { isReservedFieldName, isReservedTableName, isReservedPaginationWords } = reservedKeywords;
 const { SQL } = databaseTypes;
 /**
  * Constructor taking the jdl object to check against application settings.
@@ -43,49 +43,50 @@ export default function createValidator(jdlObject, applicationSettings = {}, log
     if (!jdlObject) {
         throw new Error('A JDL object must be passed to check for business errors.');
     }
-    if (applicationSettings.blueprints && applicationSettings.blueprints.length !== 0) {
-        return {
-            checkForErrors: () => {
-                logger.warn('Blueprints are being used, the JDL validation phase is skipped.');
-            },
-        };
-    }
+    const { blueprints, databaseType } = applicationSettings;
+    const checkReservedKeywords = Boolean((databaseType ?? 'no') !== 'no') && (blueprints?.length ?? 0) === 0;
     return {
         checkForErrors: () => {
-            checkForEntityErrors();
+            checkForEntityErrors({ checkReservedKeywords });
             checkForRelationshipErrors();
-            checkForEnumErrors();
-            checkDeploymentsErrors();
-            checkForOptionErrors();
+            checkForEnumErrors({ checkReservedKeywords });
+            if (checkReservedKeywords) {
+                checkDeploymentsErrors();
+                checkForOptionErrors();
+            }
+            else {
+                logger.warn('Blueprints are being used, the JDL validation phase is skipped.');
+            }
         },
     };
-    function checkForEntityErrors() {
+    function checkForEntityErrors(options) {
         if (jdlObject.getEntityQuantity() === 0) {
             return;
         }
-        if (!applicationSettings.databaseType) {
-            throw new Error('Database type is required to validate entities.');
-        }
         const validator = new EntityValidator();
         jdlObject.forEachEntity(jdlEntity => {
-            validator.validate(jdlEntity);
-            if (isReservedTableName(jdlEntity.tableName, applicationSettings.databaseType)) {
-                logger.warn(`The table name '${jdlEntity.tableName}' is a reserved keyword, so it will be prefixed with the value of 'jhiPrefix'.`);
+            validator.validate(jdlEntity, options);
+            if (options.checkReservedKeywords) {
+                if (isReservedTableName(jdlEntity.tableName, applicationSettings.databaseType)) {
+                    logger.warn(`The table name '${jdlEntity.tableName}' is a reserved keyword, so it will be prefixed with the value of 'jhiPrefix'.`);
+                }
             }
-            checkForFieldErrors(jdlEntity.name, jdlEntity.fields);
+            checkForFieldErrors(jdlEntity.name, jdlEntity.fields, options);
         });
     }
-    function checkForFieldErrors(entityName, jdlFields) {
+    function checkForFieldErrors(entityName, jdlFields, options) {
         const validator = new FieldValidator();
         const filtering = applicationSettings.databaseType === SQL;
         Object.keys(jdlFields).forEach(fieldName => {
             const jdlField = jdlFields[fieldName];
             validator.validate(jdlField);
-            if (isReservedFieldName(jdlField.name)) {
-                logger.warn(`The name '${jdlField.name}' is a reserved keyword, so it will be prefixed with the value of 'jhiPrefix'.`);
-            }
-            if (filtering && isReservedPaginationWords(jdlField.name)) {
-                throw new Error(`Field name '${fieldName}' found in ${entityName} is a reserved keyword, as it is used by Spring for pagination in the URL.`);
+            if (options.checkReservedKeywords) {
+                if (isReservedFieldName(jdlField.name)) {
+                    logger.warn(`The name '${jdlField.name}' is a reserved keyword, so it will be prefixed with the value of 'jhiPrefix'.`);
+                }
+                if (filtering && isReservedPaginationWords(jdlField.name)) {
+                    throw new Error(`Field name '${fieldName}' found in ${entityName} is a reserved keyword, as it is used by Spring for pagination in the URL.`);
+                }
             }
             const typeCheckingFunction = getTypeCheckingFunction(entityName, applicationSettings);
             if (!jdlObject.hasEnum(jdlField.type) && !typeCheckingFunction(jdlField.type)) {
@@ -117,13 +118,13 @@ export default function createValidator(jdlObject, applicationSettings = {}, log
             });
         });
     }
-    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() {

package/dist/jdl/validators/validator.js

@@ -23,7 +23,7 @@ export default class Validator {
         this.objectType = objectType;
         this.fieldsToCheck = fieldsToCheck;
     }
-    validate(object) {
+    validate(object, _options) {
         if (!object) {
             throw new Error(`No ${this.objectType}.`);
         }

package/dist/types/generators/base/support/config.d.mts

@@ -38,10 +38,10 @@ export declare const pickFields: (source: Record<string | number, any>, fields:
  *
  * @example
  * // application = { prop: 'foo-bar', prop2: 'foo2' }
- * mutateApplication(
- *   application,
+ * mutateData(
+ *   data,
  *   { prop: 'foo', prop2: ({ prop }) => prop + 2 },
  *   { prop: ({ prop }) => prop + '-bar', prop2: 'won\'t override' },
  * );
  */
-export declare const mutateApplication: (application: Record<string | number, any>, ...mutations: Record<string | number, any>[]) => void;
+export declare const mutateData: (context: Record<string | number, any>, ...mutations: Record<string | number, any>[]) => void;

package/dist/types/generators/base-application/support/prepare-entity.d.mts

@@ -1,5 +1,6 @@
 import type BaseGenerator from '../../base-core/index.mjs';
 import { Entity } from '../types/index.mjs';
+import type CoreGenerator from '../../base-core/generator.mjs';
 export declare const entityDefaultConfig: {
     pagination: string;
     anyPropertyHasValidation: boolean;
@@ -16,7 +17,11 @@ export declare const entityDefaultConfig: {
 };
 export default function prepareEntity(entityWithConfig: any, generator: any, application: any): any;
 export declare function derivedPrimaryKeyProperties(primaryKey: any): void;
-export declare function prepareEntityPrimaryKeyForTemplates(entityWithConfig: any, generator: any, enableCompositeId?: boolean): any;
+export declare function prepareEntityPrimaryKeyForTemplates(this: CoreGenerator | void, { entity: entityWithConfig, enableCompositeId, application }: {
+    entity: any;
+    enableCompositeId?: boolean;
+    application?: any;
+}): any;
 /**
  * Copy required application config into entity.
  * Some entity features are related to the backend instead of the current app.