generator-jhipster 8.2.1 → 8.4.0

package/dist/generators/spring-boot/generator.js

@@ -18,18 +18,19 @@
  */
 import os from 'node:os';
 import chalk from 'chalk';
-import { kebabCase, sortedUniqBy } from 'lodash-es';
+import { sortedUniqBy } from 'lodash-es';
 import BaseApplicationGenerator from '../base-application/index.js';
-import { GENERATOR_SERVER, GENERATOR_SPRING_CACHE, GENERATOR_SPRING_CLOUD_STREAM, GENERATOR_SPRING_DATA_CASSANDRA, GENERATOR_SPRING_DATA_COUCHBASE, GENERATOR_SPRING_DATA_ELASTICSEARCH, GENERATOR_SPRING_DATA_MONGODB, GENERATOR_SPRING_DATA_NEO4J, GENERATOR_SPRING_DATA_RELATIONAL, GENERATOR_SPRING_WEBSOCKET, } from '../generator-list.js';
+import { GENERATOR_CUCUMBER, GENERATOR_DOCKER, GENERATOR_FEIGN_CLIENT, GENERATOR_GATLING, GENERATOR_LANGUAGES, GENERATOR_SERVER, GENERATOR_SPRING_CACHE, GENERATOR_SPRING_CLOUD_STREAM, GENERATOR_SPRING_DATA_CASSANDRA, GENERATOR_SPRING_DATA_COUCHBASE, GENERATOR_SPRING_DATA_ELASTICSEARCH, GENERATOR_SPRING_DATA_MONGODB, GENERATOR_SPRING_DATA_NEO4J, GENERATOR_SPRING_DATA_RELATIONAL, GENERATOR_SPRING_WEBSOCKET, } from '../generator-list.js';
 import { serverFiles } from './files.js';
 import cleanupTask from './cleanup.js';
 import { ADD_SPRING_MILESTONE_REPOSITORY } from '../generator-constants.js';
 import { addSpringFactory, getJavaValueGeneratorForType, getPrimaryKeyValue, getSpecificationBuildForType, insertContentIntoApplicationProperties, javaBeanCase, } from '../server/support/index.js';
 import { addJavaAnnotation, generateKeyStore } from '../java/support/index.js';
 import { createNeedleCallback, mutateData } from '../base/support/index.js';
-import { APPLICATION_TYPE_MICROSERVICE, applicationTypes, cacheTypes, databaseTypes, fieldTypes, messageBrokerTypes, searchEngineTypes, websocketTypes, } from '../../jdl/index.js';
+import { APPLICATION_TYPE_MICROSERVICE, applicationTypes, cacheTypes, databaseTypes, fieldTypes, messageBrokerTypes, searchEngineTypes, testFrameworkTypes, websocketTypes, } from '../../jdl/index.js';
 import { writeFiles as writeEntityFiles } from './entity-files.js';
-import { getPomVersionProperties } from '../maven/support/index.js';
+import { getPomVersionProperties, parseMavenPom } from '../maven/support/index.js';
+import { askForOptionalItems, askForServerSideOpts, askForServerTestOpts } from './prompts.js';
 const { CAFFEINE, EHCACHE, HAZELCAST, INFINISPAN, MEMCACHED, REDIS, NO: NO_CACHE } = cacheTypes;
 const { NO: NO_WEBSOCKET, SPRING_WEBSOCKET } = websocketTypes;
 const { CASSANDRA, COUCHBASE, MONGODB, NEO4J, SQL } = databaseTypes;
@@ -37,6 +38,7 @@ const { MICROSERVICE, GATEWAY } = applicationTypes;
 const { KAFKA, PULSAR } = messageBrokerTypes;
 const { ELASTICSEARCH } = searchEngineTypes;
 const { BYTES: TYPE_BYTES, BYTE_BUFFER: TYPE_BYTE_BUFFER } = fieldTypes.RelationalOnlyDBTypes;
+const { CUCUMBER, GATLING } = testFrameworkTypes;
 export default class SpringBootGenerator extends BaseApplicationGenerator {
     fakeKeytool;
     async beforeQueue() {
@@ -45,6 +47,8 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
         }
         if (!this.delegateToBlueprint) {
             await this.dependsOnJHipster(GENERATOR_SERVER);
+            await this.dependsOnJHipster('jhipster:java:domain');
+            await this.dependsOnJHipster('jhipster:java:build-tool');
         }
     }
     get initializing() {
@@ -57,30 +61,29 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
     get [BaseApplicationGenerator.INITIALIZING]() {
         return this.delegateTasksToBlueprint(() => this.initializing);
     }
+    get prompting() {
+        return this.asPromptingTaskGroup({
+            async promptCommand({ control }) {
+                if (control.existingProject && this.options.askAnswered !== true)
+                    return;
+                await this.promptCurrentJHipsterCommand();
+            },
+            askForServerTestOpts,
+            askForServerSideOpts,
+            askForOptionalItems,
+        });
+    }
+    get [BaseApplicationGenerator.PROMPTING]() {
+        return this.delegateTasksToBlueprint(() => this.prompting);
+    }
     get configuring() {
         return this.asConfiguringTaskGroup({
-            forceReactiveGateway() {
-                if (this.jhipsterConfig.applicationType === GATEWAY) {
-                    if (this.jhipsterConfig.reactive !== undefined && !this.jhipsterConfig.reactive) {
-                        this.log.warn('Non reactive gateway is not supported. Switching to reactive.');
-                    }
-                    this.jhipsterConfig.reactive = true;
-                }
-            },
             checks() {
                 const config = this.jhipsterConfigWithDefaults;
                 if (config.enableHibernateCache && [NO_CACHE, MEMCACHED].includes(config.cacheProvider)) {
                     this.log.verboseInfo(`Disabling hibernate cache for cache provider ${config.cacheProvider}`);
                     this.jhipsterConfig.enableHibernateCache = false;
                 }
-                if (config.websocket && config.websocket !== NO_WEBSOCKET) {
-                    if (config.reactive) {
-                        throw new Error('Spring Websocket is not supported with reactive applications.');
-                    }
-                    if (config.applicationType === MICROSERVICE) {
-                        throw new Error('Spring Websocket is not supported with microservice applications.');
-                    }
-                }
             },
             feignMigration() {
                 const { reactive, applicationType, feignClient } = this.jhipsterConfigWithDefaults;
@@ -107,7 +110,28 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
     get composing() {
         return this.asComposingTaskGroup({
             async composing() {
-                const { databaseType, messageBroker, searchEngine, websocket, cacheProvider } = this.jhipsterConfigWithDefaults;
+                const { applicationType, databaseType, messageBroker, searchEngine, websocket, cacheProvider, skipClient, clientFramework, enableTranslation, testFrameworks, feignClient, } = this.jhipsterConfigWithDefaults;
+                await this.composeWithJHipster(GENERATOR_DOCKER);
+                await this.composeWithJHipster('jhipster:java:jib');
+                await this.composeWithJHipster('jhipster:java:code-quality');
+                if (!skipClient && clientFramework !== 'no') {
+                    await this.composeWithJHipster('jhipster:java:node');
+                }
+                if (applicationType === GATEWAY) {
+                    await this.composeWithJHipster('jhipster:spring-cloud:gateway');
+                }
+                if (enableTranslation) {
+                    await this.composeWithJHipster(GENERATOR_LANGUAGES);
+                }
+                if (testFrameworks?.includes(CUCUMBER)) {
+                    await this.composeWithJHipster(GENERATOR_CUCUMBER);
+                }
+                if (testFrameworks?.includes(GATLING)) {
+                    await this.composeWithJHipster(GENERATOR_GATLING);
+                }
+                if (feignClient) {
+                    await this.composeWithJHipster(GENERATOR_FEIGN_CLIENT);
+                }
                 if (databaseType === SQL) {
                     await this.composeWithJHipster(GENERATOR_SPRING_DATA_RELATIONAL);
                 }
@@ -143,19 +167,36 @@ export default class SpringBootGenerator extends BaseApplicationGenerator {
     }
     get preparing() {
         return this.asPreparingTaskGroup({
+            async loadCommand({ application }) {
+                await this.loadCurrentJHipsterCommandConfig(application);
+            },
+            checksWebsocket({ application }) {
+                const { websocket } = application;
+                if (websocket && websocket !== NO_WEBSOCKET) {
+                    if (application.reactive) {
+                        throw new Error('Spring Websocket is not supported with reactive applications.');
+                    }
+                    if (application.applicationType === MICROSERVICE) {
+                        throw new Error('Spring Websocket is not supported with microservice applications.');
+                    }
+                }
+            },
             loadSpringBootBom({ application }) {
-                const pomFile = this.readTemplate(this.jhipsterTemplatePath('../resources/spring-boot-dependencies.pom'))?.toString();
                 if (this.useVersionPlaceholders) {
-                    application.javaDependencies['spring-boot'] = "'SPRING-BOOT-VERSION'";
-                    application.springBootDependencies = {};
+                    application.springBootDependencies = {
+                        'spring-boot-dependencies': "'SPRING-BOOT-VERSION'",
+                    };
                 }
                 else {
-                    application.springBootDependencies = this.prepareDependencies(getPomVersionProperties(pomFile), value => `'${kebabCase(value).toUpperCase()}-VERSION'`);
+                    const pomFile = this.readTemplate(this.jhipsterTemplatePath('../resources/spring-boot-dependencies.pom')).toString();
+                    const pom = parseMavenPom(pomFile);
+                    application.springBootDependencies = this.prepareDependencies(getPomVersionProperties(pom), 'java');
                     application.javaDependencies['spring-boot'] = application.springBootDependencies['spring-boot-dependencies'];
+                    Object.assign(application.javaManagedProperties, pom.project.properties);
                 }
             },
             prepareForTemplates({ application }) {
-                const SPRING_BOOT_VERSION = application.javaDependencies['spring-boot'];
+                const SPRING_BOOT_VERSION = application.springBootDependencies['spring-boot-dependencies'];
                 application.addSpringMilestoneRepository =
                     (application.backendType ?? 'Java') === 'Java' &&
                         (ADD_SPRING_MILESTONE_REPOSITORY || SPRING_BOOT_VERSION.includes('M') || SPRING_BOOT_VERSION.includes('RC'));
@@ -250,6 +291,16 @@ public void set${javaBeanCase(propertyName)}(${propertyType} ${propertyName}) {
     }
     get preparingEachEntityRelationship() {
         return this.asPreparingEachEntityRelationshipTaskGroup({
+            checkUserRelationships({ entity, entityName, relationship }) {
+                if (!entity.dtoMapstruct && relationship.otherEntity.builtInUser) {
+                    this.log.warn(`Entity ${entityName} doesn't use DTO. You should check for User data leakage through ${relationship.relationshipName} relationship.`);
+                }
+            },
+            checkDtoRelationships({ entity, entityName, relationship }) {
+                if (entity.dto !== relationship.otherEntity.dto) {
+                    this.log.warn(`Relationship between entities with different DTO configurations can cause unexpected results. Check ${relationship.relationshipName} in the ${entityName} entity.`);
+                }
+            },
             prepareEntity({ relationship }) {
                 if (relationship.otherEntity.embedded)
                     return;
@@ -300,7 +351,7 @@ public void set${javaBeanCase(propertyName)}(${propertyType} ${propertyName}) {
             async writeFiles({ application }) {
                 return this.writeFiles({
                     sections: serverFiles,
-                    rootTemplatesPath: ['', '../../server/templates/', '../../java/templates/'],
+                    rootTemplatesPath: ['', '../../server/templates/', '../../java/generators/domain/templates/'],
                     context: application,
                 });
             },
@@ -329,20 +380,47 @@ public void set${javaBeanCase(propertyName)}(${propertyType} ${propertyName}) {
     get postWriting() {
         return this.asPostWritingTaskGroup({
             addJHipsterBomDependencies({ application, source }) {
+                const { applicationTypeGateway, applicationTypeMicroservice, javaDependencies, jhipsterDependenciesVersion, messageBrokerAny } = application;
+                const { serviceDiscoveryAny } = application;
+                if (application.buildToolMaven) {
+                    source.addMavenProperty?.({
+                        property: 'spring-boot.version',
+                        // eslint-disable-next-line no-template-curly-in-string
+                        value: '${project.parent.version}',
+                    });
+                }
                 source.addJavaDependencies?.([
-                    {
-                        groupId: 'tech.jhipster',
-                        artifactId: 'jhipster-dependencies',
-                        version: application.jhipsterDependenciesVersion,
-                        type: 'pom',
-                        scope: 'import',
-                    },
-                    { groupId: 'tech.jhipster', artifactId: 'jhipster-framework' },
+                    { groupId: 'tech.jhipster', artifactId: 'jhipster-framework', version: jhipsterDependenciesVersion },
                 ]);
+                if (applicationTypeGateway || applicationTypeMicroservice || serviceDiscoveryAny || messageBrokerAny) {
+                    source.addJavaDependencies?.([
+                        {
+                            groupId: 'org.springframework.cloud',
+                            artifactId: 'spring-cloud-dependencies',
+                            type: 'pom',
+                            scope: 'import',
+                            version: javaDependencies['spring-cloud-dependencies'],
+                        },
+                    ]);
+                }
             },
             addSpringdoc({ application, source }) {
                 const springdocDependency = `springdoc-openapi-starter-${application.reactive ? 'webflux' : 'webmvc'}-api`;
-                source.addJavaDependencies?.([{ groupId: 'org.springdoc', artifactId: springdocDependency }]);
+                source.addJavaDependencies?.([
+                    { groupId: 'org.springdoc', artifactId: springdocDependency, version: application.javaDependencies.springdoc },
+                ]);
+            },
+            addFeignReactor({ application, source }) {
+                const { applicationTypeGateway, applicationTypeMicroservice, javaDependencies, reactive } = application;
+                if ((applicationTypeMicroservice || applicationTypeGateway) && reactive) {
+                    const groupId = 'com.playtika.reactivefeign';
+                    source.addJavaDependencies?.([
+                        { groupId, artifactId: 'feign-reactor-bom', type: 'pom', scope: 'import', version: javaDependencies['feign-reactor-bom'] },
+                        { groupId, artifactId: 'feign-reactor-cloud' },
+                        { groupId, artifactId: 'feign-reactor-spring-configuration' },
+                        { groupId, artifactId: 'feign-reactor-webclient' },
+                    ]);
+                }
             },
             addSpringSnapshotRepository({ application, source }) {
                 if (application.buildToolMaven) {
@@ -403,7 +481,7 @@ public void set${javaBeanCase(propertyName)}(${propertyType} ${propertyName}) {
         });
     }
     get [BaseApplicationGenerator.END]() {
-        return this.asEndTaskGroup(this.delegateTasksToBlueprint(() => this.end));
+        return this.delegateTasksToBlueprint(() => this.end);
     }
     /**
      * @private

package/dist/generators/{server → spring-boot}/prompts.js

@@ -17,23 +17,21 @@
  * limitations under the License.
  */
 import chalk from 'chalk';
-import * as _ from 'lodash-es';
-import { applicationOptions, applicationTypes, authenticationTypes, buildToolTypes, databaseTypes, cacheTypes, serviceDiscoveryTypes, testFrameworkTypes, } from '../../jdl/jhipster/index.js';
-import { MESSAGE_BROKER } from './options/index.js';
-import { R2DBC_DB_OPTIONS, SQL_DB_OPTIONS } from './support/database.js';
+import { includes, intersection } from 'lodash-es';
+import { applicationOptions, applicationTypes, authenticationTypes, databaseTypes, cacheTypes, serviceDiscoveryTypes, testFrameworkTypes, } from '../../jdl/jhipster/index.js';
+import { MESSAGE_BROKER } from '../server/options/index.js';
+import { R2DBC_DB_OPTIONS, SQL_DB_OPTIONS } from '../server/support/database.js';
 const { OptionNames } = applicationOptions;
 const { GATEWAY, MICROSERVICE, MONOLITH } = applicationTypes;
 const { CAFFEINE, EHCACHE, HAZELCAST, INFINISPAN, MEMCACHED, REDIS } = cacheTypes;
 const { JWT, OAUTH2, SESSION } = authenticationTypes;
-const { GRADLE, MAVEN } = buildToolTypes;
 const { CASSANDRA, H2_DISK, H2_MEMORY, MONGODB, NEO4J, SQL, COUCHBASE } = databaseTypes;
 const { CONSUL, EUREKA } = serviceDiscoveryTypes;
-const { AUTHENTICATION_TYPE, BUILD_TOOL, CACHE_PROVIDER, DATABASE_TYPE, PACKAGE_NAME, DEV_DATABASE_TYPE, PROD_DATABASE_TYPE, REACTIVE, SERVER_PORT, SERVICE_DISCOVERY_TYPE, WEBSOCKET, SEARCH_ENGINE, ENABLE_SWAGGER_CODEGEN, } = OptionNames;
+const { AUTHENTICATION_TYPE, CACHE_PROVIDER, DATABASE_TYPE, DEV_DATABASE_TYPE, PROD_DATABASE_TYPE, REACTIVE, SERVER_PORT, SERVICE_DISCOVERY_TYPE, WEBSOCKET, SEARCH_ENGINE, ENABLE_SWAGGER_CODEGEN, } = OptionNames;
 const NO_SERVICE_DISCOVERY = serviceDiscoveryTypes.NO;
 const NO_DATABASE = databaseTypes.NO;
 const NO_CACHE_PROVIDER = cacheTypes.NO;
 const { GATLING, CUCUMBER } = testFrameworkTypes;
-const { intersection } = _;
 /**
  * Get Option From Array
  *
@@ -44,7 +42,7 @@ const { intersection } = _;
 const getOptionFromArray = (array, option) => {
     let optionValue = false;
     array.forEach(value => {
-        if (_.includes(value, option)) {
+        if (includes(value, option)) {
             optionValue = value.split(':')[1];
         }
     });
@@ -71,16 +69,6 @@ export async function askForServerSideOpts({ control }) {
             message: 'As you are running in a microservice architecture, on which port would like your server to run? It should be unique to avoid port conflicts.',
             default: defaultServerPort,
         },
-        {
-            type: 'input',
-            name: PACKAGE_NAME,
-            validate: input => /^([a-z_]{1}[a-z0-9_]*(\.[a-z_]{1}[a-z0-9_]*)*)$/.test(input)
-                ? true
-                : 'The package name you have provided is not a valid Java package name.',
-            message: 'What is your default Java package name?',
-            default: this.jhipsterConfigWithDefaults.packageName,
-            store: true,
-        },
         {
             when: () => applicationType === 'gateway' || applicationType === 'microservice',
             type: 'list',
@@ -243,36 +231,6 @@ export async function askForServerSideOpts({ control }) {
             message: 'Do you want to use Hibernate 2nd level cache?',
             default: this.jhipsterConfigWithDefaults.enableHibernateCache,
         },
-        {
-            type: 'list',
-            name: BUILD_TOOL,
-            message: 'Would you like to use Maven or Gradle for building the backend?',
-            choices: [
-                {
-                    value: MAVEN,
-                    name: 'Maven',
-                },
-                {
-                    value: GRADLE,
-                    name: 'Gradle',
-                },
-            ],
-            default: this.jhipsterConfigWithDefaults.buildTool,
-        },
-        {
-            when: answers => answers.buildTool === GRADLE && this.experimental,
-            type: 'confirm',
-            name: 'enableGradleEnterprise',
-            message: 'Do you want to enable Gradle Enterprise integration?',
-            default: this.jhipsterConfigWithDefaults.enableGradleEnterprise,
-        },
-        {
-            when: answers => answers.enableGradleEnterprise,
-            type: 'input',
-            name: 'gradleEnterpriseHost',
-            message: 'Enter your Gradle Enterprise host',
-            validate: input => (input.length === 0 ? 'Please enter your Gradle Enterprise host' : true),
-        },
     ];
     await this.prompt(prompts, this.config);
 }