generator-jhipster 8.6.0 → 8.7.0

package/dist/generators/spring-data-cassandra/generator.js

@@ -17,10 +17,10 @@
  * limitations under the License.
  */
 import BaseApplicationGenerator from '../base-application/index.js';
+import { PaginationTypes } from '../../jdl/jhipster/entity-options.js';
 import writeCassandraFilesTask from './files.js';
 import cleanupCassandraFilesTask from './cleanup.js';
 import writeCassandraEntityFilesTask, { cleanupCassandraEntityFilesTask } from './entity-files.js';
-import { PaginationTypes } from '../../jdl/jhipster/entity-options.js';
 const { NO: NO_PAGINATION } = PaginationTypes;
 export default class CassandraGenerator extends BaseApplicationGenerator {
     async beforeQueue() {

package/dist/generators/spring-data-cassandra/templates/src/test/java/_package_/config/CassandraTestContainer.java.ejs

@@ -42,7 +42,7 @@ public class CassandraTestContainer implements InitializingBean, DisposableBean
 
     public static final String DEFAULT_KEYSPACE_NAME = "cassandratestkeyspace";
 
-    private static final Logger log = LoggerFactory.getLogger(CassandraTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(CassandraTestContainer.class);
     private static final Integer DATABASE_REQUEST_TIMEOUT = 20;
     private static final Integer CONTAINER_STARTUP_TIMEOUT_MINUTES = 10;
 
@@ -60,7 +60,7 @@ public class CassandraTestContainer implements InitializingBean, DisposableBean
         if (null == cassandraContainer) {
             cassandraContainer = new CassandraContainer<>("<%- dockerContainers.cassandra %>")
                     .withStartupTimeout(Duration.of(CONTAINER_STARTUP_TIMEOUT_MINUTES, ChronoUnit.MINUTES))
-                    .withLogConsumer(new Slf4jLogConsumer(log))
+                    .withLogConsumer(new Slf4jLogConsumer(LOG))
                     .withReuse(true);
         }
         if (!cassandraContainer.isRunning()) {

package/dist/generators/spring-data-couchbase/files.js

@@ -16,7 +16,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { SERVER_MAIN_SRC_DIR, SERVER_MAIN_RES_DIR, SERVER_TEST_SRC_DIR } from '../generator-constants.js';
+import { SERVER_MAIN_RES_DIR, SERVER_MAIN_SRC_DIR, SERVER_TEST_SRC_DIR } from '../generator-constants.js';
 import { moveToJavaPackageSrcDir, moveToJavaPackageTestDir } from '../server/support/index.js';
 export const couchbaseFiles = {
     serverJavaConfig: [

package/dist/generators/spring-data-couchbase/templates/src/main/java/_package_/config/DatabaseConfiguration.java.ejs

@@ -82,7 +82,7 @@ public class DatabaseConfiguration extends AbstractCouchbaseConfiguration {
     private static final String CHANGELOG_COLLECTION = "changelog";
     private static final String TYPE_KEY = "type";
 
-    private static final Logger log = LoggerFactory.getLogger(DatabaseConfiguration.class);
+    private static final Logger LOG = LoggerFactory.getLogger(DatabaseConfiguration.class);
 
     private final JHipsterProperties jHipsterProperties;
     private final CouchbaseProperties couchbaseProperties;
@@ -167,7 +167,7 @@ public class DatabaseConfiguration extends AbstractCouchbaseConfiguration {
 
     @Bean
     public Couchmove couchmove(Cluster cluster) {
-        log.debug("Configuring Couchmove");
+        LOG.debug("Configuring Couchmove");
         Bucket bucket = cluster.bucket(getBucketName());
         Collection collection = bucket.scope(getScopeName()).collection(CHANGELOG_COLLECTION);
         Couchmove couchmove = new Couchmove(collection, cluster, "config/couchmove/changelog");

package/dist/generators/spring-data-couchbase/templates/src/test/java/_package_/config/CouchbaseTestContainer.java.ejs

@@ -31,7 +31,7 @@ import java.time.Duration;
 public class CouchbaseTestContainer implements InitializingBean, DisposableBean {
 
     private CouchbaseContainer couchbaseContainer;
-    private static final Logger log = LoggerFactory.getLogger(CouchbaseTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(CouchbaseTestContainer.class);
 
     @Override
     public void destroy() {
@@ -52,7 +52,7 @@ public class CouchbaseTestContainer implements InitializingBean, DisposableBean
                 .withBucket(new BucketDefinition(getBucketName()))
                 .withCredentials("user", "password")
                 .withServiceQuota(CouchbaseService.SEARCH, 1024)
-                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withLogConsumer(new Slf4jLogConsumer(LOG))
                 .withStartupTimeout(Duration.ofMinutes(15))
                 .withReuse(true);
         }

package/dist/generators/spring-data-elasticsearch/generator.js

@@ -17,10 +17,10 @@
  * limitations under the License.
  */
 import BaseApplicationGenerator from '../base-application/index.js';
+import { mutateData } from '../base/support/index.js';
 import writeElasticsearchFilesTask from './files.js';
 import cleanupElasticsearchFilesTask from './cleanup.js';
 import writeElasticsearchEntityFilesTask, { cleanupElasticsearchEntityFilesTask } from './entity-files.js';
-import { mutateData } from '../base/support/index.js';
 export default class ElasticsearchGenerator extends BaseApplicationGenerator {
     async beforeQueue() {
         if (!this.fromBlueprint) {

package/dist/generators/spring-data-elasticsearch/templates/src/test/java/_package_/config/ElasticsearchTestContainer.java.ejs

@@ -34,7 +34,7 @@ import java.time.temporal.ChronoUnit;
  */
 public class ElasticsearchTestContainer implements InitializingBean, DisposableBean {
 
-    private static final Logger log = LoggerFactory.getLogger(ElasticsearchTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(ElasticsearchTestContainer.class);
     private static final Integer CONTAINER_STARTUP_TIMEOUT_MINUTES = 10;
     private ElasticsearchContainer elasticsearchContainer;
 
@@ -54,7 +54,7 @@ public class ElasticsearchTestContainer implements InitializingBean, DisposableB
                     .withSharedMemorySize(256000000L)
                     .withEnv("ES_JAVA_OPTS", "-Xms256m -Xmx256m")
                     .withEnv("xpack.security.enabled", "false")
-                    .withLogConsumer(new Slf4jLogConsumer(log))
+                    .withLogConsumer(new Slf4jLogConsumer(LOG))
                     .withReuse(true);
         }
         if (!elasticsearchContainer.isRunning()) {

package/dist/generators/spring-data-mongodb/templates/src/main/java/_package_/_entityPackage_/repository/_entityClass_Repository.java.ejs

@@ -41,9 +41,6 @@ import java.util.UUID;
 /**
  * <%= springDataDescription %> repository for the <%= persistClass %> entity.
  */
-<%_ if (!implementsEagerLoadApis) { _%>
-@SuppressWarnings("unused")
-<%_ } _%>
 @Repository
 public interface <%= entityClass %>Repository extends MongoRepository<<%= persistClass %>, <%= primaryKey.type %>> {
 <%_ if (implementsEagerLoadApis) { _%>

package/dist/generators/spring-data-mongodb/templates/src/test/java/_package_/config/MongoDbTestContainer.java.ejs

@@ -31,7 +31,7 @@ public class MongoDbTestContainer implements InitializingBean, DisposableBean {
     /* private final long memoryInBytes = Math.round(1024 * 1024 * 1024 * 0.6);
     private final long memorySwapInBytes = Math.round(1024 * 1024 * 1024 * 0.8);
     private final long nanoCpu = Math.round(1_000_000_000L * 0.1); */
-    private static final Logger log = LoggerFactory.getLogger(MongoDbTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(MongoDbTestContainer.class);
 
     private MongoDBContainer mongodbContainer;
 
@@ -53,7 +53,7 @@ public class MongoDbTestContainer implements InitializingBean, DisposableBean {
                 .withCreateContainerCmdModifier(cmd ->
                     cmd.getHostConfig().withMemory(memoryInBytes).withMemorySwap(memorySwapInBytes).withNanoCPUs(nanoCpu)
                 ) */
-                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withLogConsumer(new Slf4jLogConsumer(LOG))
                 .withReuse(true);
         }
         if (!mongodbContainer.isRunning()) {

package/dist/generators/spring-data-neo4j/entity-files.js

@@ -1,3 +1,21 @@
+/**
+ * Copyright 2013-2024 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 { javaMainPackageTemplatesBlock } from '../server/support/index.js';
 const domainFiles = [
     {

package/dist/generators/spring-data-neo4j/files.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 import { moveToJavaPackageSrcDir, moveToJavaPackageTestDir } from '../server/support/index.js';
-import { SERVER_MAIN_SRC_DIR, SERVER_MAIN_RES_DIR, SERVER_TEST_SRC_DIR } from '../generator-constants.js';
+import { SERVER_MAIN_RES_DIR, SERVER_MAIN_SRC_DIR, SERVER_TEST_SRC_DIR } from '../generator-constants.js';
 export const neo4jFiles = {
     serverResource: [
         {

package/dist/generators/spring-data-neo4j/generator.js

@@ -17,7 +17,7 @@
  * limitations under the License.
  */
 import BaseApplicationGenerator from '../base-application/index.js';
-import { GENERATOR_JAVA, GENERATOR_LIQUIBASE } from '../generator-list.js';
+import { GENERATOR_LIQUIBASE } from '../generator-list.js';
 import writeTask from './files.js';
 import cleanupTask from './cleanup.js';
 import writeEntitiesTask, { cleanupEntitiesTask } from './entity-files.js';
@@ -28,8 +28,7 @@ export default class Neo4jGenerator extends BaseApplicationGenerator {
         }
         if (!this.delegateToBlueprint) {
             await this.dependsOnBootstrapApplication();
-            const javaGenerator = await this.dependsOnJHipster(GENERATOR_JAVA);
-            javaGenerator.useJacksonIdentityInfo = true;
+            (await this.dependsOnJHipster('jhipster:java:domain')).useJacksonIdentityInfo = true;
         }
     }
     get composing() {
@@ -126,21 +125,23 @@ export default class Neo4jGenerator extends BaseApplicationGenerator {
                 });
             },
             addDependencies({ application, source }) {
-                source.addJavaDependencies?.([
-                    { groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-data-neo4j' },
-                    { scope: 'test', groupId: 'org.testcontainers', artifactId: 'junit-jupiter' },
-                    { scope: 'test', groupId: 'org.testcontainers', artifactId: 'testcontainers' },
-                    { scope: 'test', groupId: 'org.testcontainers', artifactId: 'neo4j' },
-                ]);
-                if (!application.databaseMigrationLiquibase) {
-                    source.addJavaDependencies?.([
+                source.addJavaDefinitions?.({
+                    dependencies: [
+                        { groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-data-neo4j' },
+                        { scope: 'test', groupId: 'org.testcontainers', artifactId: 'junit-jupiter' },
+                        { scope: 'test', groupId: 'org.testcontainers', artifactId: 'testcontainers' },
+                        { scope: 'test', groupId: 'org.testcontainers', artifactId: 'neo4j' },
+                    ],
+                }, {
+                    condition: !application.databaseMigrationLiquibase,
+                    dependencies: [
                         {
                             groupId: 'eu.michael-simons.neo4j',
                             artifactId: 'neo4j-migrations-spring-boot-starter',
                             version: application.javaDependencies['neo4j-migrations-spring-boot-starter'],
                         },
-                    ]);
-                }
+                    ],
+                });
             },
         });
     }

package/dist/generators/spring-data-neo4j/templates/src/test/java/_package_/config/Neo4jTestContainer.java.ejs

@@ -34,7 +34,7 @@ import java.time.temporal.ChronoUnit;
  */
 public class Neo4jTestContainer implements InitializingBean, DisposableBean {
 
-    private static final Logger log = LoggerFactory.getLogger(Neo4jTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(Neo4jTestContainer.class);
     private static final Integer CONTAINER_STARTUP_TIMEOUT_MINUTES = 10;
     private Neo4jContainer neo4jContainer;
 
@@ -52,7 +52,7 @@ public class Neo4jTestContainer implements InitializingBean, DisposableBean {
                 (Neo4jContainer) new Neo4jContainer(DockerImageName.parse("<%- dockerContainers.neo4j %>"))
                     .withoutAuthentication()
                     .withStartupTimeout(Duration.of(CONTAINER_STARTUP_TIMEOUT_MINUTES, ChronoUnit.MINUTES))
-                    .withLogConsumer(new Slf4jLogConsumer(log))
+                    .withLogConsumer(new Slf4jLogConsumer(LOG))
                     .withReuse(true);
         }
         if (!neo4jContainer.isRunning()) {

package/dist/generators/spring-data-relational/files.js

@@ -16,8 +16,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { mergeSections, addSectionsCondition } from '../base/support/index.js';
-import { javaMainPackageTemplatesBlock, javaTestPackageTemplatesBlock, javaTestResourceTemplatesBlock, javaMainResourceTemplatesBlock, } from '../java/support/index.js';
+import { addSectionsCondition, mergeSections } from '../base/support/index.js';
+import { javaMainPackageTemplatesBlock, javaMainResourceTemplatesBlock, javaTestPackageTemplatesBlock, javaTestResourceTemplatesBlock, } from '../java/support/index.js';
 export const sqlFiles = {
     serverFiles: [
         {

package/dist/generators/spring-data-relational/generator.js

@@ -18,11 +18,11 @@
  */
 import BaseApplicationGenerator from '../base-application/index.js';
 import { GENERATOR_LIQUIBASE } from '../generator-list.js';
+import { isReservedTableName } from '../../jdl/jhipster/reserved-keywords.js';
+import { databaseTypes } from '../../jdl/jhipster/index.js';
 import writeTask from './files.js';
 import cleanupTask from './cleanup.js';
 import writeEntitiesTask, { cleanupEntitiesTask } from './entity-files.js';
-import { isReservedTableName } from '../../jdl/jhipster/reserved-keywords.js';
-import { databaseTypes } from '../../jdl/jhipster/index.js';
 import { getDBCExtraOption, getJdbcUrl, getR2dbcUrl } from './support/index.js';
 import { getDatabaseDriverForDatabase, getDatabaseTypeMavenDefinition, getH2MavenDefinition } from './internal/dependencies.js';
 const { SQL } = databaseTypes;
@@ -35,16 +35,6 @@ export default class SqlGenerator extends BaseApplicationGenerator {
             await this.dependsOnJHipster('jhipster:java:domain');
         }
     }
-    get initializing() {
-        return this.asInitializingTaskGroup({
-            async parseCommand() {
-                await this.parseCurrentJHipsterCommand();
-            },
-        });
-    }
-    get [BaseApplicationGenerator.INITIALIZING]() {
-        return this.delegateTasksToBlueprint(() => this.initializing);
-    }
     get composing() {
         return this.asComposingTaskGroup({
             async composing() {
@@ -130,54 +120,48 @@ export default class SqlGenerator extends BaseApplicationGenerator {
             },
             addDependencies({ application, source }) {
                 const { reactive, javaDependencies, packageFolder } = application;
-                if (reactive) {
-                    source.addJavaDependencies?.([
+                const { prodDatabaseType, devDatabaseTypeH2Any } = application;
+                const dbDefinitions = getDatabaseTypeMavenDefinition(prodDatabaseType, {
+                    inProfile: devDatabaseTypeH2Any ? 'prod' : undefined,
+                    javaDependencies,
+                });
+                const h2Definitions = devDatabaseTypeH2Any ? getH2MavenDefinition({ prodDatabaseType, packageFolder }) : undefined;
+                source.addJavaDefinitions?.({
+                    condition: reactive,
+                    dependencies: [
                         { groupId: 'commons-beanutils', artifactId: 'commons-beanutils', version: javaDependencies['commons-beanutils'] },
                         { groupId: 'jakarta.persistence', artifactId: 'jakarta.persistence-api' },
                         { groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-data-r2dbc' },
-                    ]);
-                }
-                else {
-                    source.addJavaDependencies?.([
+                    ],
+                    mavenDefinition: dbDefinitions.r2dbc,
+                }, {
+                    condition: !reactive,
+                    dependencies: [
                         { groupId: 'com.fasterxml.jackson.datatype', artifactId: 'jackson-datatype-hibernate6' },
                         { groupId: 'org.hibernate.orm', artifactId: 'hibernate-core' },
                         { groupId: 'org.hibernate.validator', artifactId: 'hibernate-validator' },
                         { groupId: 'org.springframework.boot', artifactId: 'spring-boot-starter-data-jpa' },
                         { groupId: 'org.springframework.security', artifactId: 'spring-security-data' },
                         { scope: 'annotationProcessor', groupId: 'org.hibernate.orm', artifactId: 'hibernate-jpamodelgen' },
-                    ]);
-                }
-                source.addJavaDependencies?.([
-                    { groupId: 'com.fasterxml.jackson.module', artifactId: 'jackson-module-jaxb-annotations' },
-                    { groupId: 'com.zaxxer', artifactId: 'HikariCP' },
-                    { scope: 'annotationProcessor', groupId: 'org.glassfish.jaxb', artifactId: 'jaxb-runtime' },
-                ]);
-                source.addJavaDependencies?.([
-                    { scope: 'test', groupId: 'org.testcontainers', artifactId: 'jdbc' },
-                    { scope: 'test', groupId: 'org.testcontainers', artifactId: 'junit-jupiter' },
-                    { scope: 'test', groupId: 'org.testcontainers', artifactId: 'testcontainers' },
-                ]);
-                if (application.buildToolMaven) {
-                    const { prodDatabaseType, devDatabaseTypeH2Any } = application;
-                    const inProfile = devDatabaseTypeH2Any ? 'prod' : undefined;
-                    if (!reactive) {
-                        source.addMavenDefinition?.({
-                            dependencies: [{ inProfile: 'IDE', groupId: 'org.hibernate.orm', artifactId: 'hibernate-jpamodelgen' }],
-                        });
-                    }
-                    if (devDatabaseTypeH2Any) {
-                        const h2Definitions = getH2MavenDefinition({ prodDatabaseType, packageFolder });
-                        source.addMavenDefinition?.(h2Definitions.jdbc);
-                        if (reactive) {
-                            source.addMavenDefinition?.(h2Definitions.r2dbc);
-                        }
-                    }
-                    const dbDefinitions = getDatabaseTypeMavenDefinition(prodDatabaseType, { inProfile, javaDependencies });
-                    source.addMavenDefinition?.(dbDefinitions.jdbc);
-                    if (reactive) {
-                        source.addMavenDefinition?.(dbDefinitions.r2dbc);
-                    }
-                }
+                    ],
+                    mavenDefinition: { dependencies: [{ inProfile: 'IDE', groupId: 'org.hibernate.orm', artifactId: 'hibernate-jpamodelgen' }] },
+                }, {
+                    dependencies: [
+                        { groupId: 'com.fasterxml.jackson.module', artifactId: 'jackson-module-jaxb-annotations' },
+                        { groupId: 'com.zaxxer', artifactId: 'HikariCP' },
+                        { scope: 'annotationProcessor', groupId: 'org.glassfish.jaxb', artifactId: 'jaxb-runtime' },
+                        { scope: 'test', groupId: 'org.testcontainers', artifactId: 'jdbc' },
+                        { scope: 'test', groupId: 'org.testcontainers', artifactId: 'junit-jupiter' },
+                        { scope: 'test', groupId: 'org.testcontainers', artifactId: 'testcontainers' },
+                    ],
+                    mavenDefinition: dbDefinitions.jdbc,
+                }, {
+                    condition: devDatabaseTypeH2Any,
+                    mavenDefinition: h2Definitions?.jdbc,
+                }, {
+                    condition: devDatabaseTypeH2Any && reactive,
+                    mavenDefinition: h2Definitions?.r2dbc,
+                });
             },
         });
     }

package/dist/generators/spring-data-relational/internal/dependencies.js

@@ -71,7 +71,6 @@ export const getH2MavenDefinition = ({ prodDatabaseType, packageFolder, }) => {
         },
     };
 };
-// eslint-disable-next-line import/prefer-default-export
 export const getDatabaseTypeMavenDefinition = (databaseType, { inProfile }) => {
     const dependenciesForType = {
         mariadb: {

package/dist/generators/spring-data-relational/support/application-properties.js

@@ -16,9 +16,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { databaseTypes } from '../../../jdl/jhipster/index.js';
 import { getDatabaseData } from './database-data.js';
 import { getJdbcUrl, getR2dbcUrl } from './database-url.js';
-import { databaseTypes } from '../../../jdl/jhipster/index.js';
 const { ORACLE, MYSQL, POSTGRESQL, MARIADB, MSSQL, H2_MEMORY, H2_DISK } = databaseTypes;
 export default function prepareSqlApplicationProperties({ application }) {
     application.prodDatabaseTypeMariadb = application.prodDatabaseType === MARIADB;

package/dist/generators/spring-data-relational/support/database-data.js

@@ -41,7 +41,7 @@ const h2GetProdDatabaseData = (databaseType, { extraOptions = '' }, { prodDataba
     if (itests && H2_MEMORY === databaseType) {
         data.port = ':12344';
     }
-    const h2ProdDatabaseMode = prodDatabaseType ? H2_PROD_DATABASE_MODE[prodDatabaseType] ?? '' : '';
+    const h2ProdDatabaseMode = prodDatabaseType ? (H2_PROD_DATABASE_MODE[prodDatabaseType] ?? '') : '';
     return {
         ...data,
         localDirectory,

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/config/DatabaseConfiguration.java.ejs

@@ -97,7 +97,7 @@ import java.util.UUID;
 public class DatabaseConfiguration {
 
 <%_ if (devDatabaseTypeH2Any) { _%>
-    private static final Logger log = LoggerFactory.getLogger(DatabaseConfiguration.class);
+    private static final Logger LOG = LoggerFactory.getLogger(DatabaseConfiguration.class);
 
     private final Environment env;
 
@@ -115,7 +115,7 @@ public class DatabaseConfiguration {
     @Profile(JHipsterConstants.SPRING_PROFILE_DEVELOPMENT)
     public Object h2TCPServer() throws SQLException {
         String port = getValidPortForH2();
-        log.debug("H2 database is available on port {}", port);
+        LOG.debug("H2 database is available on port {}", port);
         return H2ConfigurationHelper.createServer(port);
     }
 

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/repository/EntityManager_reactive.java.ejs

@@ -42,7 +42,6 @@ import org.springframework.data.relational.core.sql.render.SqlRenderer;
 import org.springframework.r2dbc.core.Parameter;
 import org.springframework.stereotype.Component;
 import org.springframework.util.Assert;
-
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
@@ -52,10 +51,12 @@ import reactor.core.publisher.Mono;
  */
 @Component
 public class EntityManager {
-    public final static String ENTITY_ALIAS = "e";
-    public final static String ALIAS_PREFIX = "e_";
+
+    public static final String ENTITY_ALIAS = "e";
+    public static final String ALIAS_PREFIX = "e_";
 
     public static class LinkTable {
+
         final String tableName;
         final String idColumn;
         final String referenceColumn;
@@ -125,9 +126,17 @@ public class EntityManager {
     public String createSelect(SelectFromAndJoinCondition selectFrom, Class<?> entityType, Pageable pageable, Condition where) {
         if (pageable != null) {
             if (where != null) {
-                return createSelectImpl(selectFrom.limitOffset(pageable.getPageSize(), pageable.getOffset()).where(where), entityType, pageable.getSort());
+                return createSelectImpl(
+                    selectFrom.limitOffset(pageable.getPageSize(), pageable.getOffset()).where(where),
+                    entityType,
+                    pageable.getSort()
+                );
             } else {
-                return createSelectImpl(selectFrom.limitOffset(pageable.getPageSize(), pageable.getOffset()), entityType, pageable.getSort());
+                return createSelectImpl(
+                    selectFrom.limitOffset(pageable.getPageSize(), pageable.getOffset()),
+                    entityType,
+                    pageable.getSort()
+                );
             }
         } else {
             if (where != null) {
@@ -184,30 +193,28 @@ public class EntityManager {
      * @return the number of inserted rows.
      */
     public Mono<Long> updateLinkTable(LinkTable table, Object entityId, Stream<?> referencedIds) {
-        return deleteFromLinkTable(table, entityId)
-                .then(
-                    Flux.fromStream(referencedIds)
-                        .flatMap((Object referenceId) -> {
-                            StatementMapper.InsertSpec insert = r2dbcEntityTemplate
-                                .getDataAccessStrategy()
-                                .getStatementMapper()
-                                .createInsert(table.tableName)
-                                .withColumn(table.idColumn, Parameter.from(entityId))
-                                .withColumn(table.referenceColumn, Parameter.from(referenceId));
-
-                            return r2dbcEntityTemplate
-                                .getDatabaseClient()
-                                .sql(statementMapper.getMappedObject(insert))
-                                .fetch()
-                                .rowsUpdated();
-                            })
-                        .collectList()
-                        .map((List<Long> updates) -> updates.stream().reduce(Long::sum).orElse(0l)));
+        return deleteFromLinkTable(table, entityId).then(
+            Flux.fromStream(referencedIds)
+                .flatMap((Object referenceId) -> {
+                    StatementMapper.InsertSpec insert = r2dbcEntityTemplate
+                        .getDataAccessStrategy()
+                        .getStatementMapper()
+                        .createInsert(table.tableName)
+                        .withColumn(table.idColumn, Parameter.from(entityId))
+                        .withColumn(table.referenceColumn, Parameter.from(referenceId));
+
+                    return r2dbcEntityTemplate.getDatabaseClient().sql(statementMapper.getMappedObject(insert)).fetch().rowsUpdated();
+                })
+                .collectList()
+                .map((List<Long> updates) -> updates.stream().reduce(Long::sum).orElse(0l))
+        );
     }
 
     public Mono<Void> deleteFromLinkTable(LinkTable table, Object entityId) {
         Assert.notNull(entityId, "entityId is null");
-        StatementMapper.DeleteSpec deleteSpec = r2dbcEntityTemplate.getDataAccessStrategy().getStatementMapper()
+        StatementMapper.DeleteSpec deleteSpec = r2dbcEntityTemplate
+            .getDataAccessStrategy()
+            .getStatementMapper()
             .createDelete(table.tableName)
             .withCriteria(Criteria.from(Criteria.where(table.idColumn).is(entityId)));
         return r2dbcEntityTemplate.getDatabaseClient().sql(statementMapper.getMappedObject(deleteSpec)).then();
@@ -218,7 +225,9 @@ public class EntityManager {
             RelationalPersistentEntity<?> entity = getPersistentEntity(entityType);
             if (entity != null) {
                 Sort sort = updateMapper.getMappedObject(sortParameter, entity);
-                selectFrom = selectFrom.orderBy(createOrderByFields(Table.create(entity.getTableName()).as(EntityManager.ENTITY_ALIAS), sort));
+                selectFrom = selectFrom.orderBy(
+                    createOrderByFields(Table.create(entity.getTableName()).as(EntityManager.ENTITY_ALIAS), sort)
+                );
             }
         }
         return createSelect(selectFrom.build());
@@ -229,11 +238,9 @@ public class EntityManager {
     }
 
     private static Collection<? extends OrderByField> createOrderByFields(Table table, Sort sortToUse) {
-
         List<OrderByField> fields = new ArrayList<>();
 
         for (Sort.Order order : sortToUse) {
-
             String propertyName = order.getProperty();
             OrderByField orderByField = !propertyName.contains(".")
                 ? OrderByField.from(table.column(propertyName).as(EntityManager.ALIAS_PREFIX + propertyName))

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/repository/UserSqlHelper_reactive.java.ejs

@@ -25,6 +25,7 @@ import org.springframework.data.relational.core.sql.Expression;
 import org.springframework.data.relational.core.sql.Table;
 
 public class UserSqlHelper {
+
     public static List<Expression> getColumns(Table table, String columnPrefix) {
         List<Expression> columns = new ArrayList<>();
         columns.add(Column.aliased("id", table, columnPrefix + "_id"));

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/repository/rowmapper/ColumnConverter_reactive.java.ejs

@@ -52,7 +52,6 @@ public class ColumnConverter implements ColumnConverterReactive {
     @Override
     @SuppressWarnings("unchecked")
     public <T> T convert(@Nullable Object value, @Nullable Class<T> target) {
-
         if (value == null || target == null || ClassUtils.isAssignableValue(target, value)) {
             return (T) value;
         }
@@ -85,5 +84,4 @@ public class ColumnConverter implements ColumnConverterReactive {
             return convert(obj, target);
         }
     }
-
 }

package/dist/generators/spring-data-relational/templates/src/main/resources/.h2.server.properties.ejs

@@ -1,6 +1,6 @@
 #H2 Server Properties
 <%_ if (devDatabaseTypeH2Memory) { _%>
-0=JHipster H2 (Memory)|org.h2.Driver|jdbc\:h2\:mem\:<%= lowercaseBaseName %>|<%= baseName %>
+0=JHipster H2 (Memory)|org.h2.Driver|jdbc\:h2\:mem\:<%= baseName %>|<%= baseName %>
 <%_ } _%>
 <%_ if (devDatabaseTypeH2Disk) { _%>
 0=JHipster H2 (Disk)|org.h2.Driver|jdbc\:h2\:file\:./<%= temporaryDir %>h2db/db/<%= lowercaseBaseName %>|<%= baseName %>

package/dist/generators/spring-data-relational/templates/src/test/java/_package_/config/MariadbTestContainer.java.ejs

@@ -28,7 +28,7 @@ import java.util.Collections;
 
 public class MariadbTestContainer implements SqlTestContainer {
 
-    private static final Logger log = LoggerFactory.getLogger(MariadbTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(MariadbTestContainer.class);
 
     private MariaDBContainer<?> mariaDBContainer;
 
@@ -45,7 +45,7 @@ public class MariadbTestContainer implements SqlTestContainer {
             mariaDBContainer = new MariaDBContainer<>("<%- dockerContainers.mariadb %>")
                 .withDatabaseName("<%= baseName %>")
                 .withTmpFs(Collections.singletonMap("/testtmpfs", "rw"))
-                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withLogConsumer(new Slf4jLogConsumer(LOG))
                 .withReuse(true);
         }
         if (!mariaDBContainer.isRunning()) {

package/dist/generators/spring-data-relational/templates/src/test/java/_package_/config/MsSqlTestContainer.java.ejs

@@ -28,7 +28,7 @@ import java.util.Collections;
 
 public class MsSqlTestContainer implements SqlTestContainer {
 
-    private static final Logger log = LoggerFactory.getLogger(MsSqlTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(MsSqlTestContainer.class);
 
     private MSSQLServerContainer<?> mSSQLServerContainer;
 
@@ -46,7 +46,7 @@ public class MsSqlTestContainer implements SqlTestContainer {
                 // Refer to https://java.testcontainers.org/modules/databases/mssqlserver/
                 //.acceptLicense()
                 .withTmpFs(Collections.singletonMap("/testtmpfs", "rw"))
-                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withLogConsumer(new Slf4jLogConsumer(LOG))
                 .withReuse(true);
         }
         if (!mSSQLServerContainer.isRunning()) {

package/dist/generators/spring-data-relational/templates/src/test/java/_package_/config/MysqlTestContainer.java.ejs

@@ -28,7 +28,7 @@ import java.util.Collections;
 
 public class MysqlTestContainer implements SqlTestContainer {
 
-    private static final Logger log = LoggerFactory.getLogger(MysqlTestContainer.class);
+    private static final Logger LOG = LoggerFactory.getLogger(MysqlTestContainer.class);
 
     private MySQLContainer<?> mysqlContainer;
 
@@ -44,7 +44,7 @@ public class MysqlTestContainer implements SqlTestContainer {
             mysqlContainer = new MySQLContainer<>("<%- dockerContainers.mysql %>")
                 .withDatabaseName("<%= baseName %>")
                 .withTmpFs(Collections.singletonMap("/testtmpfs", "rw"))
-                .withLogConsumer(new Slf4jLogConsumer(log))
+                .withLogConsumer(new Slf4jLogConsumer(LOG))
                 .withReuse(true);
         }
         if (!mysqlContainer.isRunning()) {