generator-jhipster 7.1.0 → 7.4.0

package/generators/server/generator.spec.mjs

@@ -0,0 +1,52 @@
+/**
+ * Copyright 2013-2021 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 expect from 'expect';
+import lodash from 'lodash';
+import { basename, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+import testSupport from '../../test/support/index.cjs';
+import Generator from './index.js';
+
+const { snakeCase } = lodash;
+const { testBlueprintSupport } = testSupport;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const generator = basename(__dirname);
+
+describe(`JHipster ${generator} generator`, () => {
+  it('generator-list constant matches folder name', async () => {
+    await expect((await import('../generator-list.js')).default[`GENERATOR_${snakeCase(generator).toUpperCase()}`]).toBe(generator);
+  });
+  it('should be exported at package.json', async () => {
+    await expect((await import(`generator-jhipster/esm/generators/${generator}`)).default).toBe(Generator);
+  });
+  it('should support features parameter', () => {
+    const instance = new Generator([], { help: true }, { bar: true });
+    expect(instance.features.bar).toBe(true);
+  });
+  describe('blueprint support', () => testBlueprintSupport(generator));
+  describe('exported files', () => {
+    it('should match snapshot', async () => {
+      expect((await import('./files.js')).serverFiles).toMatchSnapshot();
+    });
+  });
+});

package/generators/server/index.js

@@ -18,23 +18,45 @@
  */
 /* eslint-disable consistent-return */
 const chalk = require('chalk');
-const _ = require('lodash');
 const os = require('os');
 const prompts = require('./prompts');
+const { GENERATOR_COMMON, GENERATOR_LANGUAGES, GENERATOR_SERVER } = require('../generator-list');
+const databaseTypes = require('../../jdl/jhipster/database-types');
 const BaseBlueprintGenerator = require('../generator-base-blueprint');
-const writeFiles = require('./files').writeFiles;
+const { writeFiles } = require('./files');
 const packagejs = require('../../package.json');
 const constants = require('../generator-constants');
 const statistics = require('../statistics');
-const { getBase64Secret, getRandomHex } = require('../utils');
 const { defaultConfig } = require('../generator-defaults');
-const { GRADLE } = require('../../jdl/jhipster/build-tool-types');
+const { JWT, OAUTH2, SESSION } = require('../../jdl/jhipster/authentication-types');
+const {
+  CASSANDRA,
+  COUCHBASE,
+  MARIADB,
+  MSSQL,
+  MYSQL,
+  ORACLE,
+  POSTGRESQL,
+  SQL,
+  MONGODB,
+  NEO4J,
+} = require('../../jdl/jhipster/database-types');
+const { CAFFEINE, EHCACHE, HAZELCAST, INFINISPAN, MEMCACHED, REDIS } = require('../../jdl/jhipster/cache-types');
+const { GRADLE, MAVEN } = require('../../jdl/jhipster/build-tool-types');
+const { ELASTICSEARCH } = require('../../jdl/jhipster/search-engine-types');
+const { EUREKA } = require('../../jdl/jhipster/service-discovery-types');
+const { MICROSERVICE, GATEWAY } = require('../../jdl/jhipster/application-types');
+const { getBase64Secret, getRandomHex } = require('../utils');
+const cacheTypes = require('../../jdl/jhipster/cache-types');
+const websocketTypes = require('../../jdl/jhipster/websocket-types');
 
-let useBlueprints;
+const NO_CACHE = cacheTypes.NO;
+const NO_DATABASE = databaseTypes.NO;
+const NO_WEBSOCKET = websocketTypes.FALSE;
 
 module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
-  constructor(args, opts) {
-    super(args, opts, { unique: 'namespace' });
+  constructor(args, options, features) {
+    super(args, options, { unique: 'namespace', ...features });
 
     // This adds support for a `--experimental` flag which can be used to enable experimental features
     this.option('experimental', {
@@ -51,29 +73,36 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
 
     // preserve old jhipsterVersion value for cleanup which occurs after new config is written into disk
     this.jhipsterOldVersion = this.jhipsterConfig.jhipsterVersion;
+  }
 
-    useBlueprints = !this.fromBlueprint && this.instantiateBlueprints('server');
+  async _postConstruct() {
+    if (!this.fromBlueprint) {
+      await this.composeWithBlueprints(GENERATOR_SERVER);
+    }
 
     // Not using normal blueprints or this is a normal blueprint.
-    if (!useBlueprints || (this.fromBlueprint && this.sbsBlueprint)) {
+    if ((!this.fromBlueprint && !this.delegateToBlueprint) || (this.fromBlueprint && this.sbsBlueprint)) {
       this.setFeatures({
-        customInstallTask: function customInstallTask(preferredPm, defaultInstallTask) {
-          if ((preferredPm && preferredPm !== 'npm') || this.skipClient || this.jhipsterConfig.skipClient) {
+        customInstallTask: async function customInstallTask(preferredPm, defaultInstallTask) {
+          const buildTool = this.jhipsterConfig.buildTool;
+          if (
+            (preferredPm && preferredPm !== 'npm') ||
+            this.skipClient ||
+            this.jhipsterConfig.skipClient ||
+            (buildTool !== GRADLE && buildTool !== MAVEN)
+          ) {
             return defaultInstallTask();
           }
-          const gradle = this.jhipsterConfig.buildTool === GRADLE;
+          const gradle = buildTool === GRADLE;
           const command = gradle ? './gradlew' : './npmw';
           const args = gradle ? ['npmInstall'] : ['install'];
 
-          const failureCallback = error => {
+          try {
+            await this.spawnCommand(command, args, { preferLocal: true });
+          } catch (error) {
             this.log(chalk.red(`Error executing '${command} ${args.join(' ')}', execute it yourself. (${error.shortMessage})`));
-            return true;
-          };
-
-          return this.spawnCommand(command, args, { preferLocal: true }).then(
-            () => true,
-            error => failureCallback(error)
-          );
+          }
+          return true;
         }.bind(this),
       });
     }
@@ -92,6 +121,24 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
         }
       },
 
+      loadEnvironmentVariables() {
+        if (process.env.JHI_BOM_VERSION) {
+          this.jhiBomVersion = process.env.JHI_BOM_VERSION;
+          this.info(`Using JHipster BOM version ${process.env.JHI_BOM_VERSION}`);
+        }
+
+        this.defaultPackaging = process.env.JHI_WAR === '1' ? 'war' : 'jar';
+        if (this.defaultPackaging === 'war') {
+          this.info(`Using ${this.defaultPackaging} as default packaging`);
+        }
+
+        const JHI_PROFILE = process.env.JHI_PROFILE;
+        this.defaultEnvironment = (JHI_PROFILE || '').includes('dev') ? 'dev' : 'prod';
+        if (JHI_PROFILE) {
+          this.info(`Using ${this.defaultEnvironment} as default profile`);
+        }
+      },
+
       setupServerconsts() {
         // Make constants available in templates
         this.MAIN_DIR = constants.MAIN_DIR;
@@ -131,13 +178,14 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
         this.DOCKER_COMPOSE_FORMAT_VERSION = constants.DOCKER_COMPOSE_FORMAT_VERSION;
 
         this.JAVA_VERSION = constants.JAVA_VERSION;
+        this.JAVA_COMPATIBLE_VERSIONS = constants.JAVA_COMPATIBLE_VERSIONS;
 
         this.NODE_VERSION = constants.NODE_VERSION;
         this.NPM_VERSION = constants.NPM_VERSION;
         this.GRADLE_VERSION = constants.GRADLE_VERSION;
 
         this.JIB_VERSION = constants.JIB_VERSION;
-        this.JHIPSTER_DEPENDENCIES_VERSION = constants.JHIPSTER_DEPENDENCIES_VERSION;
+        this.JHIPSTER_DEPENDENCIES_VERSION = this.jhiBomVersion || constants.JHIPSTER_DEPENDENCIES_VERSION;
         this.SPRING_BOOT_VERSION = constants.SPRING_BOOT_VERSION;
         this.LIQUIBASE_VERSION = constants.LIQUIBASE_VERSION;
         this.LIQUIBASE_DTD_VERSION = constants.LIQUIBASE_DTD_VERSION;
@@ -149,6 +197,8 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
         this.JACKSON_DATABIND_NULLABLE_VERSION = constants.JACKSON_DATABIND_NULLABLE_VERSION;
 
         this.ANGULAR = constants.SUPPORTED_CLIENT_FRAMEWORKS.ANGULAR;
+        this.VUE = constants.SUPPORTED_CLIENT_FRAMEWORKS.VUE;
+        this.REACT = constants.SUPPORTED_CLIENT_FRAMEWORKS.REACT;
 
         this.packagejs = packagejs;
       },
@@ -183,7 +233,7 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
   }
 
   get initializing() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._initializing();
   }
 
@@ -203,7 +253,7 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
   }
 
   get prompting() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._prompting();
   }
 
@@ -215,34 +265,34 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
           this.jhipsterConfig.serverPort = 8080 + this.jhipsterConfig.applicationIndex;
         }
       },
-      validateConfig() {
-        this._validateServerConfiguration();
+      configure() {
+        this._configureServer();
       },
     };
   }
 
   get configuring() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._configuring();
   }
 
   // Public API method used by the getter and also by Blueprints
   _composing() {
     return {
-      composeCommon() {
-        this.composeWithJHipster('common', true);
+      async composeCommon() {
+        await this.composeWithJHipster(GENERATOR_COMMON, true);
       },
 
-      composeLanguages() {
+      async composeLanguages() {
         // We don't expose client/server to cli, composing with languages is used for test purposes.
         if (this.jhipsterConfig.enableTranslation === false) return;
-        this.composeWithJHipster('languages', true);
+        await this.composeWithJHipster(GENERATOR_LANGUAGES, true);
       },
     };
   }
 
   get composing() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._composing();
   }
 
@@ -251,15 +301,18 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
     return {
       loadSharedConfig() {
         this.loadAppConfig();
+        this.loadDerivedAppConfig();
         this.loadClientConfig();
+        this.loadDerivedClientConfig();
         this.loadServerConfig();
+        this.loadPlatformConfig();
         this.loadTranslationConfig();
       },
     };
   }
 
   get loading() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._loading();
   }
 
@@ -269,35 +322,29 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
       prepareForTemplates() {
         // Application name modified, using each technology's conventions
         this.frontendAppName = this.getFrontendAppName();
-        this.camelizedBaseName = _.camelCase(this.baseName);
-        this.dasherizedBaseName = _.kebabCase(this.baseName);
-        this.lowercaseBaseName = this.baseName.toLowerCase();
-        this.humanizedBaseName = _.startCase(this.baseName);
         this.mainClass = this.getMainClassName();
-        this.cacheManagerIsAvailable = ['ehcache', 'caffeine', 'hazelcast', 'infinispan', 'memcached', 'redis'].includes(
-          this.cacheProvider
-        );
-        this.testsNeedCsrf = ['oauth2', 'session'].includes(this.authenticationType);
+        this.cacheManagerIsAvailable = [EHCACHE, CAFFEINE, HAZELCAST, INFINISPAN, MEMCACHED, REDIS].includes(this.cacheProvider);
+        this.testsNeedCsrf = [OAUTH2, SESSION].includes(this.authenticationType);
 
         this.jhiTablePrefix = this.getTableName(this.jhiPrefix);
 
-        if (this.jhipsterConfig.databaseType === 'sql') {
+        if (this.jhipsterConfig.databaseType === SQL) {
           // sql
           let dbContainer;
           switch (this.jhipsterConfig.prodDatabaseType) {
-            case 'mysql':
+            case MYSQL:
               dbContainer = this.DOCKER_MYSQL;
               break;
-            case 'mariadb':
+            case MARIADB:
               dbContainer = this.DOCKER_MARIADB;
               break;
-            case 'postgresql':
+            case POSTGRESQL:
               dbContainer = this.DOCKER_POSTGRESQL;
               break;
-            case 'mssql':
+            case MSSQL:
               dbContainer = this.DOCKER_MSSQL;
               break;
-            case 'oracle':
+            case ORACLE:
             default:
               dbContainer = null;
           }
@@ -312,7 +359,7 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
   }
 
   get preparing() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._preparing();
   }
 
@@ -322,13 +369,33 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
       ...super._missingPreDefault(),
 
       loadUserManagementEntities() {
+        // TODO v8 move to preparingEntities priority.
         if (!this.configOptions.sharedEntities) return;
         // Make user entity available to templates.
-        this.user = this.configOptions.sharedEntities.User;
+        const user = (this.user = this.configOptions.sharedEntities.User);
+        if (!user) return;
+
+        const { packageName, packageFolder } = this;
+        const { persistClass } = user;
+        user.entityAbsolutePackage = packageName;
+        user.entityAbsoluteFolder = packageFolder;
+        user.entityAbsoluteClass = `${packageName}.domain.${persistClass}`;
+      },
+
+      loadDomains() {
+        if (!this.configOptions.sharedEntities) return;
+        this.domains = [
+          ...new Set([
+            this.packageName,
+            ...Object.values(this.configOptions.sharedEntities)
+              .map(entity => entity.entityAbsolutePackage)
+              .filter(packageName => packageName),
+          ]),
+        ];
       },
 
       insight() {
-        statistics.sendSubGenEvent('generator', 'server', {
+        statistics.sendSubGenEvent('generator', GENERATOR_SERVER, {
           app: {
             authenticationType: this.authenticationType,
             cacheProvider: this.cacheProvider,
@@ -342,6 +409,7 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
             serviceDiscoveryType: this.serviceDiscoveryType,
             buildTool: this.buildTool,
             enableSwaggerCodegen: this.enableSwaggerCodegen,
+            enableGradleEnterprise: this.enableGradleEnterprise,
           },
         });
       },
@@ -349,17 +417,20 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
   }
 
   get default() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._default();
   }
 
   // Public API method used by the getter and also by Blueprints
   _writing() {
-    return { ...writeFiles(), ...super._missingPostWriting() };
+    return {
+      ...writeFiles(),
+      ...super._missingPostWriting(),
+    };
   }
 
   get writing() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._writing();
   }
 
@@ -368,18 +439,16 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
       packageJsonScripts() {
         const packageJsonConfigStorage = this.packageJson.createStorage('config').createProxy();
         packageJsonConfigStorage.backend_port = this.serverPort;
-        packageJsonConfigStorage.packaging = process.env.JHI_WAR === '1' ? 'war' : 'jar';
-        if (process.env.JHI_PROFILE) {
-          packageJsonConfigStorage.default_environment = process.env.JHI_PROFILE.includes('dev') ? 'dev' : 'prod';
-        }
+        packageJsonConfigStorage.packaging = this.defaultPackaging;
+        packageJsonConfigStorage.default_environment = this.defaultEnvironment;
       },
       packageJsonDockerScripts() {
         const scriptsStorage = this.packageJson.createStorage('scripts');
         const databaseType = this.jhipsterConfig.databaseType;
         const dockerAwaitScripts = [];
-        if (databaseType === 'sql') {
+        if (databaseType === SQL) {
           const prodDatabaseType = this.jhipsterConfig.prodDatabaseType;
-          if (prodDatabaseType === 'no' || prodDatabaseType === 'oracle') {
+          if (prodDatabaseType === NO_DATABASE || prodDatabaseType === ORACLE) {
             scriptsStorage.set('docker:db:up', `echo "Docker for db ${prodDatabaseType} not configured for application ${this.baseName}"`);
           } else {
             scriptsStorage.set({
@@ -389,12 +458,18 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
           }
         } else {
           const dockerFile = `src/main/docker/${databaseType}.yml`;
-          if (databaseType === 'cassandra') {
+          if (databaseType === CASSANDRA) {
             scriptsStorage.set({
               'docker:db:await': 'wait-on tcp:9042 && sleep 20',
             });
           }
-          if (databaseType === 'couchbase' || databaseType === 'cassandra') {
+          if (databaseType === COUCHBASE) {
+            scriptsStorage.set({
+              'docker:db:await':
+                'echo "Waiting for Couchbase to start" && wait-on http-get://localhost:8091/ui/index.html && sleep 30 && echo "Couchbase started"',
+            });
+          }
+          if (databaseType === COUCHBASE || databaseType === CASSANDRA) {
             scriptsStorage.set({
               'docker:db:build': `docker-compose -f ${dockerFile} build`,
               'docker:db:up': `docker-compose -f ${dockerFile} up -d`,
@@ -409,6 +484,11 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
             scriptsStorage.set('docker:db:up', `echo "Docker for db ${databaseType} not configured for application ${this.baseName}"`);
           }
         }
+        if (this.jhipsterConfig.searchEngine === ELASTICSEARCH) {
+          dockerAwaitScripts.push(
+            'echo "Waiting for Elasticsearch to start" && wait-on "http-get://localhost:9200/_cluster/health?wait_for_status=green&timeout=60s" && echo "Elasticsearch started"'
+          );
+        }
 
         const dockerOthersUp = [];
         const dockerOthersDown = [];
@@ -423,6 +503,10 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
               dockerAwaitScripts.push(
                 'echo "Waiting for jhipster-registry to start" && wait-on http-get://localhost:8761/management/health && echo "jhipster-registry started"'
               );
+            } else if (dockerConfig === 'keycloak') {
+              dockerAwaitScripts.push(
+                'echo "Waiting for keycloak to start" && wait-on http-get://localhost:9080/auth/realms/jhipster -t 30000 && echo "keycloak started" || echo "keycloak not running, make sure oauth2 server is running"'
+              );
             }
 
             scriptsStorage.set(`docker:${dockerConfig}:up`, `docker-compose -f ${dockerFile} up -d`);
@@ -432,6 +516,7 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
           }
         });
         scriptsStorage.set({
+          'docker:app:up': `docker-compose -f ${this.DOCKER_DIR}app.yml up -d`,
           'docker:others:await': dockerAwaitScripts.join(' && '),
           'predocker:others:up': dockerBuild.join(' && '),
           'docker:others:up': dockerOthersUp.join(' && '),
@@ -450,8 +535,9 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
 
         const buildTool = this.jhipsterConfig.buildTool;
         let e2ePackage = 'target/e2e';
-        if (buildTool === 'maven') {
+        if (buildTool === MAVEN) {
           scriptsStorage.set({
+            'app:start': './mvnw',
             'backend:info': './mvnw -ntp enforcer:display-info --batch-mode',
             'backend:doc:test': './mvnw -ntp javadoc:javadoc --batch-mode',
             'backend:nohttp:test': './mvnw -ntp checkstyle:check --batch-mode',
@@ -459,13 +545,16 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
             'java:jar': './mvnw -ntp verify -DskipTests --batch-mode',
             'java:war': './mvnw -ntp verify -DskipTests --batch-mode -Pwar',
             'java:docker': './mvnw -ntp verify -DskipTests jib:dockerBuild',
+            'java:docker:arm64': 'npm run java:docker -- -Djib-maven-plugin.architecture=arm64',
             'backend:unit:test': `./mvnw -ntp -P-webapp verify --batch-mode ${javaCommonLog} ${javaTestLog}`,
             'backend:build-cache': './mvnw dependency:go-offline',
+            'backend:debug': './mvnw -Dspring-boot.run.jvmArguments="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=*:8000"',
           });
-        } else if (buildTool === 'gradle') {
+        } else if (buildTool === GRADLE) {
           const excludeWebapp = this.jhipsterConfig.skipClient ? '' : '-x webapp';
           e2ePackage = 'e2e';
           scriptsStorage.set({
+            'app:start': './gradlew',
             'backend:info': './gradlew -v',
             'backend:doc:test': `./gradlew javadoc ${excludeWebapp}`,
             'backend:nohttp:test': `./gradlew checkstyleNohttp ${excludeWebapp}`,
@@ -496,7 +585,7 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
       },
       packageJsonE2eScripts() {
         const scriptsStorage = this.packageJson.createStorage('scripts');
-        const buildCmd = this.jhipsterConfig.buildTool === 'gradle' ? 'gradlew' : 'mvnw';
+        const buildCmd = this.jhipsterConfig.buildTool === GRADLE ? 'gradlew' : 'mvnw';
         if (scriptsStorage.get('e2e')) {
           scriptsStorage.set({
             'ci:server:await':
@@ -504,6 +593,20 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
             'pree2e:headless': 'npm run ci:server:await',
             'ci:e2e:run': 'concurrently -k -s first "npm run ci:e2e:server:start" "npm run e2e:headless"',
             'e2e:dev': `concurrently -k -s first "./${buildCmd}" "npm run e2e"`,
+            'e2e:devserver':
+              'concurrently -k -s first "npm run backend:start" "npm start" "wait-on http-get://localhost:9000 && npm run e2e:headless -- -c baseUrl=http://localhost:9000"',
+          });
+        }
+        // Vue eagerly loads remotes, wait for it.
+        if (this.microfrontend && this.applicationTypeGateway && this.clientFrameworkVue) {
+          const remotesScript = this.remotes
+            .map(
+              app =>
+                `echo "Waiting for microfrontend ${app.baseName} to start" && wait-on http-get://localhost:$npm_package_config_backend_port/${app.endpointPrefix}/remoteEntry.js && echo "Microfrontend ${app.baseName} started"`
+            )
+            .join(' && ');
+          scriptsStorage.set({
+            'ci:server:await': `${scriptsStorage.get('ci:server:await')} && ${remotesScript}`,
           });
         }
       },
@@ -511,18 +614,26 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
   }
 
   get postWriting() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._postWriting();
   }
 
   // Public API method used by the getter and also by Blueprints
   _end() {
     return {
+      checkLocaleValue() {
+        if (this.languages && this.languages.includes('in')) {
+          this.warning(
+            "For jdk 17 compatibility 'in' locale value should set 'java.locale.useOldISOCodes=true' environment variable. Refer to https://bugs.openjdk.java.net/browse/JDK-8267069"
+          );
+        }
+      },
+
       end() {
         this.log(chalk.green.bold('\nServer application generated successfully.\n'));
 
         let executable = 'mvnw';
-        if (this.buildTool === 'gradle') {
+        if (this.buildTool === GRADLE) {
           executable = 'gradlew';
         }
         let logMsgComment = '';
@@ -535,53 +646,38 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
   }
 
   get end() {
-    if (useBlueprints) return;
+    if (this.delegateToBlueprint) return {};
     return this._end();
   }
 
-  _validateServerConfiguration(config = this.jhipsterConfig) {
-    if (!config.packageFolder) {
-      config.packageFolder = config.packageName.replace(/\./g, '/');
-    }
-
+  _configureServer(config = this.jhipsterConfig) {
     // JWT authentication is mandatory with Eureka, so the JHipster Registry
     // can control the applications
-    if (config.serviceDiscoveryType === 'eureka' && config.authenticationType !== 'oauth2') {
-      config.authenticationType = 'jwt';
+    if (config.serviceDiscoveryType === EUREKA && config.authenticationType !== OAUTH2) {
+      config.authenticationType = JWT;
     }
 
     // Generate JWT secret key if key does not already exist in config
-    if ((config.authenticationType === 'jwt' || config.applicationType === 'microservice') && config.jwtSecretKey === undefined) {
+    if (
+      (config.authenticationType === JWT || config.applicationType === MICROSERVICE || config.applicationType === GATEWAY) &&
+      config.jwtSecretKey === undefined
+    ) {
       config.jwtSecretKey = getBase64Secret.call(this, null, 64);
     }
     // Generate remember me key if key does not already exist in config
-    if (config.authenticationType === 'session' && !config.rememberMeKey) {
+    if (config.authenticationType === SESSION && !config.rememberMeKey) {
       config.rememberMeKey = getRandomHex();
     }
 
-    if (config.authenticationType === 'oauth2') {
+    if (config.authenticationType === OAUTH2) {
       config.skipUserManagement = true;
     }
 
-    if (config.enableHibernateCache && ['no', 'memcached'].includes(config.cacheProvider)) {
+    if (config.enableHibernateCache && [NO_CACHE, MEMCACHED].includes(config.cacheProvider)) {
       this.info(`Disabling hibernate cache for cache provider ${config.cacheProvider}`);
       config.enableHibernateCache = false;
     }
 
-    // Convert to false for templates.
-    if (config.serviceDiscoveryType === 'no' || !config.serviceDiscoveryType) {
-      config.serviceDiscoveryType = false;
-    }
-    if (config.websocket === 'no' || !config.websocket) {
-      config.websocket = false;
-    }
-    if (config.searchEngine === 'no' || !config.searchEngine) {
-      config.searchEngine = false;
-    }
-    if (config.messageBroker === 'no' || !config.messageBroker) {
-      config.messageBroker = false;
-    }
-
     if (!config.databaseType && config.prodDatabaseType) {
       config.databaseType = this.getDBTypeFromDBValue(config.prodDatabaseType);
     }
@@ -590,17 +686,17 @@ module.exports = class JHipsterServerGenerator extends BaseBlueprintGenerator {
     }
 
     // force variables unused by microservice applications
-    if (config.applicationType === 'microservice') {
-      config.websocket = false;
+    if (config.applicationType === MICROSERVICE) {
+      config.websocket = NO_WEBSOCKET;
     }
 
     const databaseType = config.databaseType;
-    if (databaseType === 'no') {
-      config.devDatabaseType = 'no';
-      config.prodDatabaseType = 'no';
+    if (databaseType === NO_DATABASE) {
+      config.devDatabaseType = NO_DATABASE;
+      config.prodDatabaseType = NO_DATABASE;
       config.enableHibernateCache = false;
       config.skipUserManagement = true;
-    } else if (['mongodb', 'neo4j', 'couchbase', 'cassandra'].includes(databaseType)) {
+    } else if ([MONGODB, NEO4J, COUCHBASE, CASSANDRA].includes(databaseType)) {
       config.devDatabaseType = databaseType;
       config.prodDatabaseType = databaseType;
       config.enableHibernateCache = false;