generator-jhipster 8.0.0-beta.2 → 8.0.0-rc.1

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

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

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

@@ -18,19 +18,34 @@
  */
 import { getDatabaseData } from './database-data.mjs';
 import { getJdbcUrl, getR2dbcUrl } from './database-url.mjs';
-export default function prepareSqlApplicationProperties(application) {
-    const devDatabaseData = getDatabaseData(application.devDatabaseType);
+import { databaseTypes } from '../../../jdl/jhipster/index.mjs';
+const { ORACLE, MYSQL, POSTGRESQL, MARIADB, MSSQL, H2_MEMORY, H2_DISK } = databaseTypes;
+export default function prepareSqlApplicationProperties({ application }) {
+    application.prodDatabaseTypeMariadb = application.prodDatabaseType === MARIADB;
+    application.prodDatabaseTypeMssql = application.prodDatabaseType === MSSQL;
+    application.prodDatabaseTypeMysql = application.prodDatabaseType === MYSQL;
+    application.prodDatabaseTypeOracle = application.prodDatabaseType === ORACLE;
+    application.prodDatabaseTypePostgresql = application.prodDatabaseType === POSTGRESQL;
+    application.devDatabaseTypeH2Disk = application.devDatabaseType === H2_DISK;
+    application.devDatabaseTypeH2Memory = application.devDatabaseType === H2_MEMORY;
+    application.devDatabaseTypeH2Any = application.devDatabaseTypeH2Disk || application.devDatabaseTypeH2Memory;
+    application.devDatabaseTypeMariadb = application.prodDatabaseTypeMariadb && !application.devDatabaseTypeH2Any;
+    application.devDatabaseTypeMssql = application.prodDatabaseTypeMssql && !application.devDatabaseTypeH2Any;
+    application.devDatabaseTypeMysql = application.prodDatabaseTypeMysql && !application.devDatabaseTypeH2Any;
+    application.devDatabaseTypeOracle = application.prodDatabaseTypeOracle && !application.devDatabaseTypeH2Any;
+    application.devDatabaseTypePostgresql = application.prodDatabaseTypePostgresql && !application.devDatabaseTypeH2Any;
+    application.devDatabaseTypePostgres = application.devDatabaseTypePostgresql; // Deprecated
+    if (!application.databaseTypeSql) {
+        return;
+    }
     const prodDatabaseData = getDatabaseData(application.prodDatabaseType);
-    application.devHibernateDialect = devDatabaseData.hibernateDialect;
     application.prodHibernateDialect = prodDatabaseData.hibernateDialect;
-    application.devJdbcDriver = devDatabaseData.jdbcDriver;
     application.prodJdbcDriver = prodDatabaseData.jdbcDriver;
-    application.devDatabaseUsername = devDatabaseData.defaultUsername ?? application.baseName;
-    application.devDatabasePassword = devDatabaseData.defaultPassword ?? '';
     application.prodDatabaseUsername = prodDatabaseData.defaultUsername ?? application.baseName;
     application.prodDatabasePassword = prodDatabaseData.defaultPassword ?? '';
+    application.prodDatabaseName = prodDatabaseData.defaultDatabaseName ?? application.baseName;
     const prodDatabaseOptions = {
-        databaseName: prodDatabaseData.defaultDatabaseName ?? application.baseName,
+        databaseName: application.prodDatabaseName,
         hostname: 'localhost',
     };
     application.prodJdbcUrl = getJdbcUrl(application.prodDatabaseType, prodDatabaseOptions);
@@ -42,43 +57,66 @@ export default function prepareSqlApplicationProperties(application) {
         application.prodR2dbcUrl = getR2dbcUrl(application.prodDatabaseType, prodDatabaseOptions);
     }
     if (application.devDatabaseTypeH2Any) {
-        const devDatabaseOptions = {
-            databaseName: devDatabaseData.defaultDatabaseName ?? application.lowercaseBaseName,
-        };
-        application.devJdbcUrl = getJdbcUrl(application.devDatabaseType, {
-            ...devDatabaseOptions,
-            buildDirectory: `./${application.temporaryDir}`,
-            prodDatabaseType: application.prodDatabaseType,
-        });
-        let devLiquibaseOptions;
-        if (application.devDatabaseTypeH2Memory) {
-            devLiquibaseOptions = {
-                protocolSuffix: 'h2:tcp://',
-                localDirectory: 'localhost:18080/mem:',
-            };
-        }
-        else {
-            devLiquibaseOptions = {
-                // eslint-disable-next-line no-template-curly-in-string
-                buildDirectory: application.buildToolGradle ? `./${application.temporaryDir}` : '${project.build.directory}/',
+        try {
+            const devDatabaseData = getDatabaseData(application.devDatabaseType);
+            application.devHibernateDialect = devDatabaseData.hibernateDialect;
+            application.devJdbcDriver = devDatabaseData.jdbcDriver;
+            application.devDatabaseUsername = devDatabaseData.defaultUsername ?? application.baseName;
+            application.devDatabasePassword = devDatabaseData.defaultPassword ?? '';
+            application.devDatabaseName = devDatabaseData.defaultDatabaseName ?? application.baseName;
+            const devDatabaseOptions = {
+                databaseName: application.devDatabaseName,
             };
-        }
-        application.devLiquibaseUrl = getJdbcUrl(application.devDatabaseType, {
-            ...devDatabaseOptions,
-            skipExtraOptions: true,
-            ...devLiquibaseOptions,
-        });
-        if (application.reactive) {
-            application.devR2dbcUrl = getR2dbcUrl(application.devDatabaseType, {
+            application.devJdbcUrl = getJdbcUrl(application.devDatabaseType, {
                 ...devDatabaseOptions,
                 buildDirectory: `./${application.temporaryDir}`,
                 prodDatabaseType: application.prodDatabaseType,
             });
+            let devLiquibaseOptions;
+            if (application.devDatabaseTypeH2Memory) {
+                devLiquibaseOptions = {
+                    protocolSuffix: 'h2:tcp://',
+                    localDirectory: 'localhost:18080/mem:',
+                };
+            }
+            else {
+                devLiquibaseOptions = {
+                    // eslint-disable-next-line no-template-curly-in-string
+                    buildDirectory: application.buildToolGradle ? `./${application.temporaryDir}` : '${project.build.directory}/',
+                };
+            }
+            application.devLiquibaseUrl = getJdbcUrl(application.devDatabaseType, {
+                ...devDatabaseOptions,
+                skipExtraOptions: true,
+                ...devLiquibaseOptions,
+            });
+            if (application.reactive) {
+                application.devR2dbcUrl = getR2dbcUrl(application.devDatabaseType, {
+                    ...devDatabaseOptions,
+                    buildDirectory: `./${application.temporaryDir}`,
+                    prodDatabaseType: application.prodDatabaseType,
+                });
+            }
+        }
+        catch (error) {
+            if (application.backendTypeSpringBoot) {
+                throw error;
+            }
         }
     }
     else {
         application.devJdbcUrl = application.prodJdbcUrl;
         application.devLiquibaseUrl = application.prodLiquibaseUrl;
         application.devR2dbcUrl = application.prodR2dbcUrl;
+        application.devHibernateDialect = application.prodHibernateDialect;
+        application.devJdbcDriver = application.prodJdbcDriver;
+        application.devDatabaseUsername = application.prodDatabaseUsername;
+        application.devDatabasePassword = application.prodDatabasePassword;
+        application.devDatabaseName = application.prodDatabaseName;
+        application.devJdbcUrl = application.prodJdbcUrl;
+        application.devLiquibaseUrl = application.prodLiquibaseUrl;
+        if (application.reactive) {
+            application.devR2dbcUrl = application.prodR2dbcUrl;
+        }
     }
 }

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

@@ -71,7 +71,7 @@ const databaseData = {
         jdbcDriver: 'org.mariadb.jdbc.Driver',
         hibernateDialect: 'org.hibernate.dialect.MariaDB103Dialect',
         port: ':3306/',
-        extraOptions: '?useLegacyDatetimeCode=false&serverTimezone=UTC',
+        extraOptions: '?useLegacyDatetimeCode=false',
         defaultUsername: 'root',
         constraintNameMaxLength: 64,
         tableNameMaxLength: 64,
@@ -84,7 +84,7 @@ const databaseData = {
         tableNameMaxLength: 64,
         constraintNameMaxLength: 64,
         port: ':3306/',
-        extraOptions: '?useUnicode=true&characterEncoding=utf8&useSSL=false&useLegacyDatetimeCode=false&serverTimezone=UTC&createDatabaseIfNotExist=true',
+        extraOptions: '?useUnicode=true&characterEncoding=utf8&useSSL=false&useLegacyDatetimeCode=false&createDatabaseIfNotExist=true',
         defaultUsername: 'root',
     },
     [ORACLE]: {

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/_entityPackage_/domain/_persistClass_.java.jhi.jakarta_persistence.ejs

@@ -0,0 +1,128 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+<%#
+ This is a fragment file, it will be merged into to root template if available.
+ EJS fragments will process % delimiter tags in template and & delimiter tags in the merge process.
+-%>
+<&_ if (fragment.importSection) { -&>
+import jakarta.persistence.*;
+<%_ if ((prodDatabaseTypePostgresql && anyFieldHasTextContentType) || (anyFieldIsUUID && (prodDatabaseTypeMysql || prodDatabaseTypeMariadb))) { _%>
+import org.hibernate.annotations.JdbcTypeCode;
+import org.hibernate.type.SqlTypes;
+<%_ } _%>
+<&_ } -&>
+
+<&_ if (fragment.annotationSection) { -&>
+@Entity
+@Table(name = "<%= entityTableName %>")
+<&_ } -&>
+
+<%_ for (const field of fields) { -%>
+<&_ if (fragment.field<%- field.fieldNameCapitalized %>AnnotationSection) { -&>
+  <%_ if (field.id) { _%>
+    @Id
+    <%_ if (field.jpaGeneratedValue === 'identity') { _%>
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    <%_ } else if (field.jpaGeneratedValue === 'sequence') { _%>
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "sequenceGenerator")
+    @SequenceGenerator(name = "sequenceGenerator"<% if (field.liquibaseCustomSequenceGenerator) { %>, sequenceName = "<%- field.jpaSequenceGeneratorName %>"<% } %>)
+    <%_ } else if (field.jpaGeneratedValue) { _%>
+    @GeneratedValue
+    <%_ } _%>
+  <%_ } _%>
+  <%_ if (field.fieldIsEnum) { _%>
+    @Enumerated(EnumType.STRING)
+  <%_ } _%>
+  <%_ if (field.fieldTypeBytes) { _%>
+    @Lob
+  <%_ } _%>
+  <%_ if (field.fieldTypeTemporal || field.fieldTypeDuration) { _%>
+    @Column(name = "<%- field.fieldNameAsDatabaseColumn %>"<% if (field.fieldValidationRequired) { %>, nullable = false<% } %><% if (field.fieldValidationUnique) { %>, unique = true<% } %>)
+  <%_ } else if (field.fieldTypeBigDecimal) { _%>
+    @Column(name = "<%- field.fieldNameAsDatabaseColumn %>", precision = 21, scale = 2<% if (field.fieldValidationRequired) { %>, nullable = false<% } %><% if (field.fieldValidationUnique) { %>, unique = true<% } %>)
+  <%_ } else if (field.fieldTypeUUID && (prodDatabaseTypeMysql || prodDatabaseTypeMariadb)) { _%>
+    @JdbcTypeCode(SqlTypes.VARCHAR)
+    @Column(name = "<%- field.fieldNameAsDatabaseColumn %>", length = 36<% if (field.fieldValidationRequired) { %>, nullable = false<% } %><% if (field.fieldValidationUnique) { %>, unique = true<% } %>)
+  <%_ } else { _%>
+    @Column(name = "<%- field.fieldNameAsDatabaseColumn %>"<% if (field.fieldValidate === true) { %><% if (field.fieldValidationMaxLength) { %>, length = <%= field.fieldValidateRulesMaxlength %><% } %><% if (field.fieldValidationRequired) { %>, nullable = false<% } %><% if (field.fieldValidationUnique) { %>, unique = true<% } %><% } %>)
+  <%_ } _%>
+<&_ } -&>
+<%_ } -%>
+
+<%_ for (const field of fields.filter(field => field.fieldWithContentType)) { -%>
+<&_ if (fragment.field<%- field.fieldNameCapitalized %>ContentTypeAnnotationSection) { -&>
+    @Column(
+        name = "<%- field.fieldNameAsDatabaseColumn %>_content_type"
+        <%_ if (field.fieldValidationRequired) { %>, nullable = false<% } _%>
+    )
+<&_ } -&>
+<%_ } -%>
+
+<%_ for (const relationship of relationships) { -%>
+<&_ if (fragment.relationship<%- relationship.relationshipNameCapitalized %>AnnotationSection) { -&>
+  <%_ if (relationship.relationshipOneToMany) { -%>
+    @OneToMany(fetch = FetchType.LAZY, mappedBy = "<%= relationship.otherEntityRelationshipName %>")
+  <%_ } else if (relationship.relationshipManyToOne) { -%>
+    @ManyToOne(<% if (relationship.relationshipRequired) { %>optional = false<% } else { %>fetch = FetchType.LAZY<% } %>)
+      <%_ if (relationship.relationshipValidate && relationship.relationshipRequired) { _%>
+    @NotNull
+      <%_ } _%>
+  <%_ } else if (relationship.relationshipManyToMany) { -%>
+    @ManyToMany(fetch = FetchType.LAZY<% if (!relationship.ownerSide) { %>, mappedBy = "<%= relationship.otherEntityRelationshipNamePlural %>"<% } %>)
+      <%_ if (relationship.ownerSide) { _%>
+        <%_ if (relationship.relationshipValidate && relationship.relationshipRequired) { _%>
+    @NotNull
+        <%_ } _%>
+    @JoinTable(name = "<%= relationship.joinTable.name %>",
+               joinColumns = <%= primaryKey.fields.length > 1 ? '{' : '' %>
+                   <%_ primaryKey.fields.forEach((field, idx) => { _%>
+                   <%= idx === 0 ? '' : ',' %>@JoinColumn(name = "<%= `${entityTableName}_${field.columnName}` %>")
+                   <%_ }); _%>
+               <%= primaryKey.fields.length > 1 ? '}' : '' %>,
+               inverseJoinColumns = <%= relationship.otherEntity.primaryKey.fields.length > 1 ? '{' : '' %>
+                   <%_ relationship.otherEntity.primaryKey.fields.forEach((field, idx) => { _%>
+                   <%= idx === 0 ? '' : ',' %>@JoinColumn(name = "<%= `${relationship.columnName}_${field.columnName}` %>"))
+                   <%_ }); _%>
+               <%= relationship.otherEntity.primaryKey.fields.length > 1 ? '}' : '' %>
+      <%_ } _%>
+  <%_ } else { -%>
+      <%_ if (relationship.ignoreOtherSideProperty) { -%>
+    @JsonIgnoreProperties(value = {
+        <%_ relationship.otherEntity.relationships.forEach(otherRelationship => { _%>
+        "<%= otherRelationship.relationshipReferenceField %>",
+        <%_ }); _%>
+    }, allowSetters = true)
+      <%_ } _%>
+      <%_ if (relationship.ownerSide) { -%>
+    @OneToOne(fetch = FetchType.LAZY<% if (relationship.relationshipRequired) { %>, optional = false<% } %>)
+        <%_ if (relationship.relationshipValidate && relationship.relationshipRequired) { _%>
+    @NotNull
+        <%_ } _%>
+        <%_ if (relationship.id) { %>
+    @MapsId
+    @JoinColumn(name = "<%= relationship.otherEntity.primaryKey.fields[0].columnName %>")
+        <%_ } else { _%>
+    @JoinColumn(unique = true)
+        <%_ } _%>
+      <%_ } else { _%>
+    @OneToOne(fetch = FetchType.LAZY, mappedBy = "<%= relationship.otherEntityRelationshipName %>")
+      <%_ } -%>
+  <%_ } -%>
+<&_ } -&>
+<%_ } -%>

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

@@ -0,0 +1,280 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+package <%= entityAbsolutePackage %>.repository;
+
+import java.util.function.BiFunction;
+<%_ if (anyFieldIsBigDecimal) { _%>
+import java.math.BigDecimal;
+<%_} if (anyFieldIsInstant) { _%>
+import java.time.Instant;
+<%_ } if (anyFieldIsLocalDate) { _%>
+import java.time.LocalDate;
+<%_ } if (anyFieldIsZonedDateTime) { _%>
+import java.time.ZonedDateTime;
+<%_ } if (anyFieldIsDuration) { _%>
+import java.time.Duration;
+<%_ } if (anyFieldIsUUID) { _%>
+import java.util.UUID;
+<%_ } _%>
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Optional;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.data.domain.Pageable;
+import io.r2dbc.spi.Row;
+import io.r2dbc.spi.RowMetadata;
+import static org.springframework.data.relational.core.query.Criteria.where;
+<%_ if (containsBagRelationships) { _%>
+import static org.springframework.data.relational.core.query.Query.query;
+<%_ } _%>
+import org.springframework.data.r2dbc.convert.R2dbcConverter;
+import org.springframework.data.r2dbc.core.R2dbcEntityOperations;
+import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
+import org.springframework.data.r2dbc.repository.support.SimpleR2dbcRepository;
+import org.springframework.data.relational.core.query.Criteria;
+import org.springframework.data.relational.core.sql.Column;
+import org.springframework.data.relational.core.sql.Comparison;
+import org.springframework.data.relational.core.sql.Condition;
+import org.springframework.data.relational.core.sql.Conditions;
+import org.springframework.data.relational.core.sql.Expression;
+import org.springframework.data.relational.core.sql.Select;
+import org.springframework.data.relational.core.sql.SelectBuilder.SelectFromAndJoin<% if (reactiveEagerRelations.length > 0) { %>Condition<% } %>;
+import org.springframework.data.relational.core.sql.Table;
+import org.springframework.data.relational.repository.support.MappingRelationalEntityInformation;
+import org.springframework.r2dbc.core.DatabaseClient;
+import org.springframework.r2dbc.core.RowsFetchSpec;
+
+import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
+<%_ if (jpaMetamodelFiltering && reactive) {  _%>
+import <%= entityAbsolutePackage %>.domain.criteria.<%= entityClass %>Criteria;
+import <%= entityAbsolutePackage %>.repository.rowmapper.ColumnConverter;
+import tech.jhipster.service.ConditionBuilder;
+<%_ }  _%>
+<% relationships.forEach(rel => {
+  if (rel.relationshipManyToMany && rel.ownerSide) { _%>
+import <%= rel.otherEntity.entityAbsolutePackage %>.domain.<%= rel.otherEntity.persistClass %>;
+  <%_ } _%>
+<%_ }); _%>
+<%_ Object.keys(uniqueEnums).forEach(element => { _%>
+
+import <%= entityAbsolutePackage %>.domain.enumeration.<%= element %>;
+<%_ }); _%>
+
+<%_ [...reactiveOtherEntities, locals].forEach(otherEntity => { _%>
+import <%= otherEntity.entityAbsolutePackage %>.repository.rowmapper.<%= otherEntity.entityClass %>RowMapper;
+  <%_ if (otherEntity.entityPackage !== entityPackage) { _%>
+import <%= otherEntity.entityAbsolutePackage %>.repository.<%= otherEntity.entityClass %>SqlHelper;
+  <%_ } _%>
+<%_ }); _%>
+<%_ if (packageName !== entityAbsolutePackage) { _%>
+import <%= packageName %>.repository.EntityManager;
+<%_ } _%>
+
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+/**
+ * <%= springDataDescription %> custom repository implementation for the <%= persistClass %> entity.
+ */
+@SuppressWarnings("unused")
+class <%= entityClass %>RepositoryInternalImpl extends SimpleR2dbcRepository<<%= persistClass %>, <%= primaryKey.type %>> implements <%= entityClass %>RepositoryInternal {
+    private final DatabaseClient db;
+    private final R2dbcEntityTemplate r2dbcEntityTemplate;
+    private final EntityManager entityManager;
+
+<%_ reactiveUniqueEntityTypes.forEach(element => { _%>
+    private final <%= element %>RowMapper <%= element.toLowerCase() %>Mapper;
+<%_ }); _%>
+<%_ if (jpaMetamodelFiltering && reactive) {  _%>
+    private final ColumnConverter columnConverter;
+<%_ } _%>
+
+    private final static Table entityTable = Table.aliased("<%= entityTableName %>", EntityManager.ENTITY_ALIAS);
+<%_ reactiveEagerRelations.forEach(rel => { _%>
+    private final static Table <%= rel.relationshipName %>Table = Table.aliased("<%= rel.otherEntityTableName %>", "<%= rel.relationshipSqlSafeName %>");
+<%_ }); _%>
+
+<%_ relationships.forEach(rel => {
+  if (rel.shouldWriteJoinTable) {
+_%>
+    private final static EntityManager.LinkTable <%= rel.relationshipName %>Link = new EntityManager.LinkTable("<%= rel.joinTable.name %>", "<%= entityTableName %>_<%= primaryKey.hibernateSnakeCaseName %>", "<%= rel.joinColumnNames[0] %>");
+<%_ }
+}); _%>
+
+    public <%= entityClass %>RepositoryInternalImpl(R2dbcEntityTemplate template, EntityManager entityManager<%_
+            reactiveUniqueEntityTypes.forEach(element => { _%>, <%= element %>RowMapper <%= element.toLowerCase() %>Mapper<%_ }); _%>, R2dbcEntityOperations entityOperations,
+        R2dbcConverter converter<% if (jpaMetamodelFiltering && reactive) {  %>,
+        ColumnConverter columnConverter<% } %>) {
+        super(new MappingRelationalEntityInformation(converter.getMappingContext().getRequiredPersistentEntity(<%= persistClass %>.class)), entityOperations, converter);
+        this.db = template.getDatabaseClient();
+        this.r2dbcEntityTemplate = template;
+        this.entityManager = entityManager;
+<%_ reactiveUniqueEntityTypes.forEach(element => { _%>
+        this.<%= element.toLowerCase() %>Mapper = <%= element.toLowerCase() %>Mapper;
+<%_ }); _%>
+<%_ if (jpaMetamodelFiltering && reactive) {  _%>
+        this.columnConverter = columnConverter;
+<%_ } _%>
+    }
+
+    @Override
+    public Flux<<%= persistClass %>> findAllBy(Pageable pageable) {
+        return createQuery(pageable, null).all();
+    }
+
+    RowsFetchSpec<<%= persistClass %>> createQuery(Pageable pageable, Condition whereClause) {
+        List<Expression> columns = <%= entityClass %>SqlHelper.getColumns(entityTable, EntityManager.ENTITY_ALIAS);
+<%_ reactiveEagerRelations.forEach(rel => { _%>
+        columns.addAll(<%= rel.otherEntityNameCapitalized %>SqlHelper.getColumns(<%= rel.relationshipName %>Table, "<%= rel.relationshipName %>"));
+<%_ }); _%>
+        SelectFromAndJoin<% if (reactiveEagerRelations.length > 0) { %>Condition<% } %> selectFrom = Select.builder().select(columns).from(entityTable)
+<%_ reactiveEagerRelations.forEach(rel => { _%>
+            .leftOuterJoin(<%= rel.relationshipName %>Table).on(Column.create("<%= rel.joinColumnNames[0] %>", entityTable)).equals(Column.create("<%= rel.otherEntity.primaryKey.fields[0].columnName %>", <%= rel.relationshipName %>Table ))
+<%_ }); _%>;
+        // we do not support Criteria here for now as of https://github.com/jhipster/generator-jhipster/issues/18269
+        String select = entityManager.createSelect(selectFrom, <%= persistClass %>.class, pageable, whereClause);
+        return db.sql(select).map(this::process);
+    }
+
+    @Override
+    public Flux<<%= persistClass %>> findAll() {
+        return findAllBy(null);
+    }
+
+    @Override
+    public Mono<<%= persistClass %>> findById(<%= primaryKey.type %> id) {
+<%_ if (primaryKey.type != 'Long') {  _%>
+        Comparison whereClause = Conditions.isEqual(entityTable.column("<%= primaryKey.fields[0].columnName %>"), Conditions.just(StringUtils.wrap(id.toString(), "'")));
+<%_ } else { _%>
+        Comparison whereClause = Conditions.isEqual(entityTable.column("<%= primaryKey.fields[0].columnName %>"), Conditions.just(id.toString()));
+<%_ }_%>
+        return createQuery(null, whereClause).one();
+    }
+
+<%_ if (implementsEagerLoadApis) { _%>
+
+    @Override
+    public Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id) {
+        return findById(id);
+    }
+
+    @Override
+    public Flux<<%= persistClass %>> findAllWithEagerRelationships() {
+        return findAll();
+    }
+
+    @Override
+    public Flux<<%= persistClass %>> findAllWithEagerRelationships(Pageable page) {
+        return findAllBy(page);
+    }
+
+<%_ } _%>
+    private <%= persistClass %> process(Row row, RowMetadata metadata) {
+        <%= persistClass %> entity = <%= entityClass.toLowerCase() %>Mapper.apply(row, "e");
+<%_ reactiveEagerRelations.forEach(rel => { _%>
+        entity.set<%= rel.relationshipNameCapitalized %>(<%= rel.otherEntityNameCapitalized.toLowerCase() %>Mapper.apply(row, "<%= rel.relationshipName %>"));
+<%_ }); _%>
+        return entity;
+    }
+
+    @Override
+    public <S extends <%= persistClass %>> Mono<S> save(S entity) {
+<%_ if (isUsingMapsId) { _%>
+        if (entity.get<%= primaryKey.nameCapitalized %>() == null && entity.get<%= mapsIdAssoc.relationshipNameCapitalized %>() != null) {
+            entity.set<%= primaryKey.nameCapitalized %>(entity.get<%= mapsIdAssoc.relationshipNameCapitalized %>().get<%= mapsIdAssoc.otherEntity.primaryKey.nameCapitalized %>());
+            return entityManager.insert(entity);
+        }
+<%_ } _%>
+        return super.save(entity)<% if (containsBagRelationships) { %>.flatMap((S e) -> updateRelations(e))<% } %>;
+    }
+
+<%_ if (containsBagRelationships) { _%>
+    protected <S extends <%= persistClass %>> Mono<S> updateRelations(S entity) {
+  <%_ relationships.filter(rel => {
+    return (rel.relationshipManyToMany && rel.ownerSide);
+   }).forEach(function(rel, idx) { _%>
+    <%_ if (idx === 0) { _%>
+        Mono<Void> result = entityManager.updateLinkTable(<%= rel.relationshipName %>Link, entity.get<%= primaryKey.nameCapitalized %>(), entity.get<%= rel.relationshipNameCapitalizedPlural %>().stream().map(<%= rel.otherEntity.persistClass %>::get<%= rel.otherEntity.primaryKey.nameCapitalized %>)).then();
+    <%_ } else { _%>
+        result = result.and(entityManager.updateLinkTable(<%= rel.relationshipName %>Link, entity.get<%= primaryKey.nameCapitalized %>(), entity.get<%= rel.relationshipNameCapitalizedPlural %>().stream().map(<%= rel.otherEntity.persistClass %>::get<%= rel.otherEntity.primaryKey.nameCapitalized %>)));
+    <%_ } _%>
+  <%_ }); _%>
+        return result.thenReturn(entity);
+    }
+
+    @Override
+    public Mono<Void> deleteById(<%= primaryKey.type %> entityId) {
+        return deleteRelations(entityId)
+            .then(super.deleteById(entityId));
+    }
+
+    protected Mono<Void> deleteRelations(<%= primaryKey.type %> entityId) {
+  <%_ relationships.filter(rel => {
+      return (rel.relationshipManyToMany && rel.ownerSide);
+    }).forEach(function(rel, idx) { _%>
+    <%_ if (idx === 0) { _%>
+        return entityManager.deleteFromLinkTable(<%= rel.relationshipName %>Link, entityId)
+    <%_} else { _%>
+            .and(entityManager.deleteFromLinkTable(<%= rel.relationshipName %>Link, entityId))
+    <%_ } _%>
+  <%_ }); %>;
+        }
+<%_ } _%>
+<%_ if (jpaMetamodelFiltering && reactive) {  _%>
+    @Override
+    public Flux<<%= persistClass %>> findByCriteria(<%= entityClass %>Criteria <%= entityInstance %>Criteria, Pageable page) {
+        return createQuery(page, buildConditions(<%= entityInstance %>Criteria)).all();
+    }
+
+    @Override
+    public Mono<Long> countByCriteria(<%= entityClass %>Criteria criteria) {
+        return findByCriteria(criteria, null)
+                    .collectList()
+                        .map(collectedList -> collectedList != null ? (long) collectedList.size() : (long) 0);
+    }
+
+    private Condition buildConditions(<%= entityClass %>Criteria criteria) {
+        ConditionBuilder builder = new ConditionBuilder(this.columnConverter);
+        List<Condition> allConditions = new ArrayList<Condition>();
+        if (criteria != null) {
+            if (criteria.get<%= primaryKey.nameCapitalized %>() != null) {
+                builder.buildFilterConditionForField(criteria.get<%= primaryKey.nameCapitalized %>(), entityTable.column("<%= primaryKey.name %>"));
+            }
+<%_
+fields.forEach((field) => {
+  if (field.id || field.transient) return;
+  if (field.filterableField) { _%>
+            if (criteria.get<%= field.fieldInJavaBeanMethod %>() != null) {
+                builder.buildFilterConditionForField(criteria.get<%= field.fieldInJavaBeanMethod %>(), entityTable.column("<%= field.columnName %>"));
+            }
+<%_ } _%>
+<%_ }); _%>
+<%_ reactiveEagerRelations.forEach((relationship) => {
+  const metamodelFieldName = (relationship.relationshipManyToMany || relationship.relationshipOneToMany) ? relationship.relationshipFieldNamePlural : relationship.relationshipFieldName; _%>
+            if (criteria.get<%= relationship.relationshipNameCapitalized %>Id() != null) {
+                builder.buildFilterConditionForField(criteria.get<%= relationship.relationshipNameCapitalized %>Id(), <%= relationship.relationshipName %>Table.column("<%= relationship.otherEntity.primaryKey.ownFields[0].columnName %>"));
+            }
+<%_ }); _%>
+        }
+        return builder.buildConditions();
+    }
+<%_ } _%>
+}

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

@@ -18,7 +18,7 @@
 -%>
 
 <%_
-    let uuidConversionNeeded = (reactive && !prodDatabaseTypePostgres);
+    let uuidConversionNeeded = (reactive && !prodDatabaseTypePostgresql);
 _%>
 package <%= packageName %>.config;
 

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/domain/_PersistClass_.java.jhi.hibernate_cache.ejs

@@ -0,0 +1,41 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+<%#
+ This is a fragment file, it will be merged into to root template if available.
+ EJS fragments will process % delimiter tags in template and & delimiter tags in the merge process.
+-%>
+<&_ if (fragment.importSection) { -&>
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+<&_ } -&>
+
+<&_ if (fragment.annotationSection) { -&>
+@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+<&_ } -&>
+
+<%_ for (const relationship of relationships) { _%>
+<&_ if (fragment.relationship<%- relationship.relationshipNameCapitalized %>AnnotationSection) { -&>
+  <%_ if (relationship.relationshipOneToMany) { _%>
+    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+  <%_ } _%>
+  <%_ if (relationship.relationshipManyToMany) { _%>
+    @Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
+  <%_ } _%>
+<&_ } -&>
+<%_ } -%>

package/dist/generators/spring-data-relational/templates/src/main/java/_package_/domain/_PersistClass_.java.jhi.jakarta_lifecycle_events.ejs

@@ -0,0 +1,31 @@
+<%#
+ Copyright 2013-2023 the original author or authors from the JHipster project.
+
+ This file is part of the JHipster project, see https://www.jhipster.tech/
+ for more information.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+      https://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-%>
+<%#
+ This is a fragment file, it will be merged into to root template if available.
+ EJS fragments will process % delimiter tags in template and & delimiter tags in the merge process.
+-%>
+<&_ if (fragment.classAdditionalFieldsMethodsSection) { -&>
+
+    @PostLoad
+    @PostPersist
+    public void updateEntityState() {
+        this.setIsPersisted();
+    }
+
+ <&_ } -&>