generator-jhipster 7.6.0 → 7.8.1

package/generators/entity-server/templates/src/main/java/package/domain/Entity.java.jhi.javax_lifecycle_events.ejs

@@ -0,0 +1,31 @@
+<%#
+ Copyright 2013-2022 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();
+    }
+
+ <&_ } -&>

package/generators/entity-server/templates/src/main/java/package/domain/Entity.java.jhi.spring_data_persistable.ejs

@@ -0,0 +1,54 @@
+<%#
+ Copyright 2013-2022 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.springframework.data.domain.Persistable;
+<&_ } -&>
+
+<&_ if (fragment.additionalInterfacesSection) { -&>
+, Persistable<<%= primaryKey.type %>>
+<&_ } -&>
+
+<&_ if (fragment.classAdditionalFieldsSection) { -&>
+    @Transient
+    private boolean isPersisted;
+<&_ } -&>
+
+<&_ if (fragment.classAdditionalFieldsMethodsSection) { -&>
+<%_ if (primaryKey.name !== 'id') { -%>
+    @Override
+    public <%= primaryKey.type %> getId() {
+        return this.<%= primaryKey.name %>;
+    }
+ <%_ } -%>
+
+    @Transient
+    @Override
+    public boolean isNew() {
+        return !this.isPersisted;
+    }
+
+    public <%= persistClass %> setIsPersisted() {
+        this.isPersisted = true;
+        return this;
+    }
+ <&_ } -&>

package/generators/entity-server/templates/src/main/java/package/domain/Entity.java.jhi.spring_data_reactive.ejs

@@ -92,7 +92,7 @@ import org.springframework.data.relational.core.mapping.Table;
 <&_ if (fragment.classAdditionalRelationshipsSection) { -&>
     <%_ for (const relationship of relationships) { _%>
       <%_ if (relationship.ownerSide && !relationship.collection && !relationship.id) { _%>
-    @Column("<%= relationship.columnName %>_id")
+    @Column("<%= relationship.joinColumnNames[0] %>")
     private <%= relationship.otherEntity.primaryKey.type %> <%= relationship.relationshipFieldName %>Id;
       <%_ } _%>
     <%_ } _%>

package/generators/entity-server/templates/src/main/java/package/domain/EntityCallback.java.ejs

@@ -0,0 +1,43 @@
+<%#
+ Copyright 2013-2022 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 %>.domain;
+
+import org.reactivestreams.Publisher;
+import org.springframework.data.r2dbc.mapping.OutboundRow;
+import org.springframework.data.r2dbc.mapping.event.AfterConvertCallback;
+import org.springframework.data.r2dbc.mapping.event.AfterSaveCallback;
+import org.springframework.data.relational.core.sql.SqlIdentifier;
+import org.springframework.stereotype.Component;
+
+import reactor.core.publisher.Mono;
+
+@Component
+public class <%= persistClass %>Callback implements AfterSaveCallback<<%= persistClass %>>, AfterConvertCallback<<%= persistClass %>> {
+
+    @Override
+    public Publisher<<%= persistClass %>> onAfterConvert(<%= persistClass %> entity, SqlIdentifier table) {
+        return Mono.just(entity.setIsPersisted());
+    }
+
+    @Override
+    public Publisher<<%= persistClass %>> onAfterSave(<%= persistClass %> entity, OutboundRow outboundRow,
+            SqlIdentifier table) {
+        return Mono.just(entity.setIsPersisted());
+    }
+}

package/generators/entity-server/templates/src/main/java/package/repository/EntityRepository.java.ejs

@@ -20,13 +20,13 @@ package <%= entityAbsolutePackage %>.repository;
 
 import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
 
-<%_ if (relationshipsContainEagerLoad) { _%>
+<%_ if (implementsEagerLoadApis) { _%>
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.Pageable;
 <%_ } _%>
 <%_ if (databaseTypeSql) { _%>
 import org.springframework.data.jpa.repository.*;
-  <%_ if (relationshipsContainEagerLoad) { _%>
+  <%_ if (implementsEagerLoadApis) { _%>
 import org.springframework.data.repository.query.Param;
   <%_ } _%>
 <%_ } _%>
@@ -41,19 +41,11 @@ import org.springframework.data.neo4j.repository.Neo4jRepository;
 import org.springframework.data.cassandra.repository.CassandraRepository;
 <%_ } _%>
 import org.springframework.stereotype.Repository;
-<%_
-if (databaseTypeSql || databaseTypeMongodb) {
-  let importList = fieldsContainOwnerManyToMany;
-  for (r of relationships) {
-    if (r.relationshipManyToOne && r.otherEntityUser) {
-      importList = true;
-    }
-  }
-_%>
-  <%_ if (importList) { _%>
+<%_ if (databaseTypeSql || databaseTypeMongodb) { _%>
+  <%_ if (implementsEagerLoadApis || relationships.some(r => r.relationshipManyToOne && r.otherEntityUser)) { _%>
 import java.util.List;
   <%_ } _%>
-  <%_ if (relationshipsContainEagerLoad) { _%>
+  <%_ if (implementsEagerLoadApis) { _%>
 import java.util.Optional;
   <%_ } _%>
 <%_ } _%>
@@ -65,11 +57,11 @@ import java.util.UUID;
 /**
  * Spring Data <%= officialDatabaseType %> repository for the <%= persistClass %> entity.
  */
-<%_ if (!relationshipsContainEagerLoad) { _%>
+<%_ if (!implementsEagerLoadApis) { _%>
 @SuppressWarnings("unused")
 <%_ } _%>
 @Repository
-public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) { %>JpaRepository<% } %><% if (databaseTypeMongodb) { %>MongoRepository<% } %><% if (databaseTypeNeo4j) { %>Neo4jRepository<% } %><% if (databaseTypeCassandra) { %>CassandraRepository<% } %><<%= persistClass %>, <%= primaryKey.type %>><% if (jpaMetamodelFiltering) { %>, JpaSpecificationExecutor<<%= persistClass %>><% } %> {
+public interface <%= entityClass %>Repository extends <% if (containsBagRelationships && databaseTypeSql) { %><%= entityClass %>RepositoryWithBagRelationships, <% } %><% if (databaseTypeSql) { %>JpaRepository<% } %><% if (databaseTypeMongodb) { %>MongoRepository<% } %><% if (databaseTypeNeo4j) { %>Neo4jRepository<% } %><% if (databaseTypeCassandra) { %>CassandraRepository<% } %><<%= persistClass %>, <%= primaryKey.type %>><% if (jpaMetamodelFiltering) { %>, JpaSpecificationExecutor<<%= persistClass %>><% } %> {
 <%_ for (const relationship of relationships) { _%>
   <%_ if (relationship.relationshipManyToOne && relationship.otherEntityUser && databaseTypeSql) { _%>
 
@@ -77,28 +69,49 @@ public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) {
     List<<%= persistClass %>> findBy<%= relationship.relationshipNameCapitalized %>IsCurrentUser();
   <%_ } _%>
 <%_ } _%>
-<%_ if (relationshipsContainEagerLoad) { _%>
+<%_ if (implementsEagerLoadApis) { _%>
   <%_ if (databaseTypeSql) { _%>
 
+    <%_ const containsToOneEagerRelationship = relationships.some(relationship => relationship.relationshipEagerLoad && !relationship.bagRelationship); _%>
+    default Optional<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> <%= primaryKey.name %>) {
+        return <% if (containsBagRelationships) { %>this.fetchBagRelationships(<% } %>
+            this.<% if (containsToOneEagerRelationship) { %>findOneWithToOneRelationships<% } else { %>findById<% } %>(<%= primaryKey.name %>)
+    <%  if (containsBagRelationships) { %>)<% } %>;
+    }
+
+    default List<<%= persistClass %>> findAllWithEagerRelationships() {
+        return <% if (containsBagRelationships) { %>this.fetchBagRelationships(<% } %>
+            this.<% if (containsToOneEagerRelationship) { %>findAllWithToOneRelationships<% } else { %>findAll<% } %>()
+    <%  if (containsBagRelationships) { %>)<% } %>;
+    }
+
+    default Page<<%= persistClass %>> findAllWithEagerRelationships(Pageable pageable) {
+        return <% if (containsBagRelationships) { %>this.fetchBagRelationships(<% } %>
+            this.<% if (containsToOneEagerRelationship) { %>findAllWithToOneRelationships<% } else { %>findAll<% } %>(pageable)
+    <%  if (containsBagRelationships) { %>)<% } %>;
+    }
+    <%_ if (containsToOneEagerRelationship) { _%>
+
     @Query(value = "select distinct <%= entityInstanceDbSafe %> from <%= persistClass %> <%= entityInstanceDbSafe %><%
       for (const relationship of relationships) {
-        if (relationship.relationshipEagerLoad) { %> left join fetch <%= entityInstanceDbSafe %>.<%= relationship.reference.name %><% }
+        if (relationship.relationshipEagerLoad && !relationship.bagRelationship) { %> left join fetch <%= entityInstanceDbSafe %>.<%= relationship.reference.name %><% }
       } %>",
         countQuery = "select count(distinct <%= entityInstanceDbSafe %>) from <%= persistClass %> <%= entityInstanceDbSafe %>")
-    Page<<%= persistClass %>> findAllWithEagerRelationships(Pageable pageable);
+    Page<<%= persistClass %>> findAllWithToOneRelationships(Pageable pageable);
 
     @Query("select distinct <%= entityInstanceDbSafe %> from <%= persistClass %> <%= entityInstanceDbSafe %><%
       for (const relationship of relationships) {
-        if (relationship.relationshipEagerLoad) { %> left join fetch <%= entityInstanceDbSafe %>.<%= relationship.reference.name %><% }
+        if (relationship.relationshipEagerLoad && !relationship.bagRelationship) { %> left join fetch <%= entityInstanceDbSafe %>.<%= relationship.reference.name %><% }
       } %>")
-    List<<%= persistClass %>> findAllWithEagerRelationships();
+    List<<%= persistClass %>> findAllWithToOneRelationships();
 
     @Query("select <%= entityInstanceDbSafe %> from <%= persistClass %> <%= entityInstanceDbSafe %><%
       for (const relationship of relationships) {
-        if (relationship.relationshipEagerLoad) { %> left join fetch <%= entityInstanceDbSafe %>.<%= relationship.reference.name %><% }
+        if (relationship.relationshipEagerLoad && !relationship.bagRelationship) { %> left join fetch <%= entityInstanceDbSafe %>.<%= relationship.reference.name %><% }
       } %> where <%= entityInstanceDbSafe %>.id =:id")
-    Optional<<%= persistClass %>> findOneWithEagerRelationships(@Param("id") <%= primaryKey.type %> id);
-    <%_ } else if (databaseTypeMongodb)  { _%>
+    Optional<<%= persistClass %>> findOneWithToOneRelationships(@Param("id") <%= primaryKey.type %> id);
+    <%_ } _%>
+  <%_ } else if (databaseTypeMongodb) { _%>
 
     @Query("{}")
     Page<<%= persistClass %>> findAllWithEagerRelationships(Pageable pageable);

package/generators/entity-server/templates/src/main/java/package/repository/EntityRepositoryInternalImpl_reactive.java.ejs

@@ -38,19 +38,21 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Optional;
 import org.springframework.data.domain.Pageable;
-<%_ if (databaseTypeSql) { _%>
 import io.r2dbc.spi.Row;
 import io.r2dbc.spi.RowMetadata;
 import static org.springframework.data.relational.core.query.Criteria.where;
-  <%_ if (fieldsContainOwnerManyToMany) { _%>
+<%_ 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<% } %>;
@@ -58,7 +60,6 @@ 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 %>;
 <% relationships.forEach(function(rel) {
@@ -105,14 +106,14 @@ class <%= entityClass %>RepositoryInternalImpl extends SimpleR2dbcRepository<<%=
 <%_ relationships.forEach(function(rel) {
   if (rel.shouldWriteJoinTable) {
 _%>
-    private final static EntityManager.LinkTable <%= rel.relationshipName %>Link = new EntityManager.LinkTable("<%= rel.joinTable.name %>", "<%= getColumnName(name) %>_id", "<%= getColumnName(rel.relationshipName) %>_id");
+    private final static EntityManager.LinkTable <%= rel.relationshipName %>Link = new EntityManager.LinkTable("<%= rel.joinTable.name %>", "<%= entity.entityTableName %>_<%= getColumnName(entity.primaryKey.name) %>", "<%= rel.joinColumnNames[0] %>");
 <%_ }
 }); _%>
 
     public <%= entityClass %>RepositoryInternalImpl(R2dbcEntityTemplate template, EntityManager entityManager<%_
             reactiveUniqueEntityTypes.forEach(function(element) { _%>, <%= element %>RowMapper <%= element.toLowerCase() %>Mapper<%_ }); _%>, R2dbcEntityOperations entityOperations,
         R2dbcConverter converter) {
-        super(new MappingRelationalEntityInformation(converter.getMappingContext().getRequiredPersistentEntity(<%= entityClass %>.class)), entityOperations, converter);
+        super(new MappingRelationalEntityInformation(converter.getMappingContext().getRequiredPersistentEntity(<%= persistClass %>.class)), entityOperations, converter);
         this.db = template.getDatabaseClient();
         this.r2dbcEntityTemplate = template;
         this.entityManager = entityManager;
@@ -123,40 +124,35 @@ _%>
 
     @Override
     public Flux<<%= persistClass %>> findAllBy(Pageable pageable) {
-        return findAllBy(pageable, null);
-    }
-
-    @Override
-    public Flux<<%= persistClass %>> findAllBy(Pageable pageable, Criteria criteria) {
-        return createQuery(pageable, criteria).all();
+        return createQuery(pageable, null).all();
     }
 
-    RowsFetchSpec<<%= persistClass %>> createQuery(Pageable pageable, Criteria criteria) {
-        List<Expression> columns = <%= persistClass %>SqlHelper.getColumns(entityTable, EntityManager.ENTITY_ALIAS);
+    RowsFetchSpec<<%= persistClass %>> createQuery(Pageable pageable, Condition whereClause) {
+        List<Expression> columns = <%= entityClass %>SqlHelper.getColumns(entityTable, EntityManager.ENTITY_ALIAS);
 <%_ reactiveEagerRelations.forEach(function(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(function(rel) {
-            const colName = _getJoinColumnName(rel); _%>
-            .leftOuterJoin(<%= rel.relationshipName %>Table).on(Column.create("<%= colName %>", entityTable)).equals(Column.create("id", <%= rel.relationshipName %>Table ))
+<%_ reactiveEagerRelations.forEach(function(rel) { _%>
+            .leftOuterJoin(<%= rel.relationshipName %>Table).on(Column.create("<%= rel.joinColumnNames[0] %>", entityTable)).equals(Column.create("<%= rel.otherEntity.primaryKey.fields[0].columnName %>", <%= rel.relationshipName %>Table ))
 <%_ }); _%>;
-
-        String select = entityManager.createSelect(selectFrom, <%= persistClass %>.class, pageable, criteria);
+        // 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, null);
+        return findAllBy(null);
     }
 
     @Override
     public Mono<<%= persistClass %>> findById(<%= primaryKey.type %> id) {
-        return createQuery(null, where(EntityManager.ENTITY_ALIAS + ".<%= primaryKey.name %>").is(id)).one();
+        Comparison whereClause = Conditions.isEqual(entityTable.column("<%= primaryKey.fields[0].columnName %>"), Conditions.just(id.toString()));
+        return createQuery(null, whereClause).one();
     }
 
-<%_ if (fieldsContainOwnerManyToMany) { _%>
+<%_ if (implementsEagerLoadApis) { _%>
 
     @Override
     public Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id) {
@@ -190,30 +186,30 @@ _%>
             return entityManager.insert(entity);
         }
 <%_ } _%>
-        return super.save(entity)<% if (fieldsContainOwnerManyToMany) { %>.flatMap((S e) -> updateRelations(e))<% } %>;
+        return super.save(entity)<% if (containsBagRelationships) { %>.flatMap((S e) -> updateRelations(e))<% } %>;
     }
 
-<%_ if (fieldsContainOwnerManyToMany) { _%>
+<%_ if (containsBagRelationships) { _%>
     protected <S extends <%= persistClass %>> Mono<S> updateRelations(S entity) {
   <%_ relationships.filter(function(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(<%= asEntity(rel.otherEntityNameCapitalized) %>::getId)).then();
+        Mono<Void> result = entityManager.updateLinkTable(<%= rel.relationshipName %>Link, entity.get<%= primaryKey.nameCapitalized %>(), entity.get<%= rel.relationshipNameCapitalizedPlural %>().stream().map(<%= asEntity(rel.otherEntityNameCapitalized) %>::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(<%= asEntity(rel.otherEntityNameCapitalized) %>::getId)));
+        result = result.and(entityManager.updateLinkTable(<%= rel.relationshipName %>Link, entity.get<%= primaryKey.nameCapitalized %>(), entity.get<%= rel.relationshipNameCapitalizedPlural %>().stream().map(<%= asEntity(rel.otherEntityNameCapitalized) %>::get<%= rel.otherEntity.primaryKey.nameCapitalized %>)));
     <%_ } _%>
   <%_ }); _%>
         return result.thenReturn(entity);
     }
 
     @Override
-    public Mono<Void> deleteById(Long entityId) {
+    public Mono<Void> deleteById(<%= primaryKey.type %> entityId) {
         return deleteRelations(entityId)
             .then(super.deleteById(entityId));
     }
 
-    protected Mono<Void> deleteRelations(Long entityId) {
+    protected Mono<Void> deleteRelations(<%= primaryKey.type %> entityId) {
   <%_ relationships.filter(function(rel) {
       return (rel.relationshipManyToMany && rel.ownerSide);
     }).forEach(function(rel, idx) { _%>

package/generators/entity-server/templates/src/main/java/package/repository/EntityRepositoryWithBagRelationships.java.ejs

@@ -0,0 +1,37 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.repository;
+
+import java.util.List;
+import java.util.Optional;
+<%_ if (fieldsContainUUID) { _%>
+import java.util.UUID;
+<%_ } _%>
+
+import org.springframework.data.domain.Page;
+
+import <%= packageName %>.domain.<%= persistClass %>;
+
+public interface <%= entityClass %>RepositoryWithBagRelationships {
+    Optional<<%= persistClass %>> fetchBagRelationships(Optional<<%= persistClass %>> <%= entityInstance %>);
+
+    List<<%= persistClass %>> fetchBagRelationships(List<<%= persistClass %>> <%= entityInstancePlural %>);
+
+    Page<<%= persistClass %>> fetchBagRelationships(Page<<%= persistClass %>> <%= entityInstancePlural %>);
+}

package/generators/entity-server/templates/src/main/java/package/repository/EntityRepositoryWithBagRelationshipsImpl.java.ejs

@@ -0,0 +1,91 @@
+<%#
+ 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.
+-%>
+package <%= packageName %>.repository;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+<%_ if (fieldsContainUUID) { _%>
+import java.util.UUID;
+<%_ } _%>
+
+import javax.persistence.EntityManager;
+import javax.persistence.PersistenceContext;
+
+import org.hibernate.annotations.QueryHints;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+import <%= packageName %>.domain.<%= persistClass %>;
+
+/**
+ * Utility repository to load bag relationships based on https://vladmihalcea.com/hibernate-multiplebagfetchexception/
+ */
+public class <%= entityClass %>RepositoryWithBagRelationshipsImpl implements <%= entityClass %>RepositoryWithBagRelationships {
+    @PersistenceContext
+    private EntityManager entityManager;
+ 
+    @Override
+    public Optional<<%= persistClass %>> fetchBagRelationships(Optional<<%= persistClass %>> <%= entityInstance %>) {
+        return <%= entityInstance %>
+<%_ for (const relationship of relationships.filter(relationship => relationship.bagRelationship)) { _%>
+            .map(this::fetch<%= relationship.relationshipNameCapitalizedPlural %>)
+<%_ } _%>
+        ;
+    }
+ 
+    @Override
+    public Page<<%= persistClass %>> fetchBagRelationships(Page<<%= persistClass %>> <%= entityInstancePlural %>) {
+        return new PageImpl<>(fetchBagRelationships(<%= entityInstancePlural %>.getContent()), <%= entityInstancePlural %>.getPageable(), <%= entityInstancePlural %>.getTotalElements());
+    }
+ 
+    @Override
+    public List<<%= persistClass %>> fetchBagRelationships(List<<%= persistClass %>> <%= entityInstancePlural %>) {
+        return Optional
+            .of(<%= entityInstancePlural %>)
+<%_ for (const relationship of relationships.filter(relationship => relationship.bagRelationship)) { _%>
+            .map(this::fetch<%= relationship.relationshipNameCapitalizedPlural %>)
+<%_ } _%>
+            .orElse(Collections.emptyList());
+    }
+<%_ for (const relationship of relationships.filter(relationship => relationship.bagRelationship)) { _%>
+
+    <%= persistClass %> fetch<%= relationship.relationshipNameCapitalizedPlural %>(<%= persistClass %> result) {
+        return entityManager
+            .createQuery(
+                "select <%= entityInstance %> from <%= persistClass %> <%= entityInstance %> left join fetch <%= entityInstance %>.<%= relationship.relationshipFieldNamePlural %> where <%= entityInstance %> is :<%= entityInstance %>",
+                <%= persistClass %>.class
+            )
+            .setParameter("<%= entityInstance %>", result)
+            .setHint(QueryHints.PASS_DISTINCT_THROUGH, false)
+            .getSingleResult();
+    }
+
+    List<<%= persistClass %>> fetch<%= relationship.relationshipNameCapitalizedPlural %>(List<<%= persistClass %>> <%= entityInstancePlural %>) {
+        return entityManager
+            .createQuery(
+                "select distinct <%= entityInstance %> from <%= persistClass %> <%= entityInstance %> left join fetch <%= entityInstance %>.<%= relationship.relationshipFieldNamePlural %> where <%= entityInstance %> in :<%= entityInstancePlural %>",
+                <%= persistClass %>.class
+            )
+            .setParameter("<%= entityInstancePlural %>", <%= entityInstancePlural %>)
+            .setHint(QueryHints.PASS_DISTINCT_THROUGH, false)
+            .getResultList();
+    }
+<%_ } _%>
+}

package/generators/entity-server/templates/src/main/java/package/repository/EntityRepository_reactive.java.ejs

@@ -22,15 +22,11 @@ import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
 <%_ if (databaseTypeCassandra) { _%>
 import org.springframework.data.cassandra.repository.ReactiveCassandraRepository;
 <%_ } _%>
-<%_ if (databaseTypeCouchbase) { _%>
-import org.springframework.data.couchbase.core.query.Query;
-import org.springframework.data.couchbase.repository.ReactiveCouchbaseSortingRepository;
-<%_ } _%>
 <%_ if (databaseTypeNeo4j) { _%>
 import org.springframework.data.neo4j.repository.ReactiveNeo4jRepository;
 import org.springframework.data.neo4j.repository.query.Query;
 <%_ } _%>
-<%_ if (!paginationNo || relationshipsContainEagerLoad || databaseTypeSql) { _%>
+<%_ if (!paginationNo || implementsEagerLoadApis || databaseTypeSql) { _%>
 import org.springframework.data.domain.Pageable;
 <%_ } _%>
 <%_ if (databaseTypeSql) { _%>
@@ -39,16 +35,16 @@ import org.springframework.data.repository.reactive.ReactiveCrudRepository;
 import org.springframework.data.relational.core.query.Criteria;
 <%_ } _%>
 <%_ if (databaseTypeMongodb) { _%>
-  <%_ if (relationshipsContainEagerLoad) { _%>
+  <%_ if (implementsEagerLoadApis) { _%>
 import org.springframework.data.mongodb.repository.Query;
   <%_ } _%>
 import org.springframework.data.mongodb.repository.ReactiveMongoRepository;
 <%_ } _%>
 import org.springframework.stereotype.Repository;
-<%_ if (databaseTypeCouchbase || databaseTypeSql || !paginationNo || relationshipsContainEagerLoad) { _%>
+<%_ if (databaseTypeSql || !paginationNo || implementsEagerLoadApis) { _%>
 import reactor.core.publisher.Flux;
 <%_ } _%>
-<%_ if (relationshipsContainEagerLoad || databaseTypeSql) { _%>
+<%_ if (implementsEagerLoadApis || databaseTypeSql) { _%>
 import reactor.core.publisher.Mono;
 <%_ } _%>
 <%_ if (primaryKey.typeUUID) { _%>
@@ -61,13 +57,13 @@ import java.util.UUID;
  */
 @SuppressWarnings("unused")
 @Repository
-public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) { %>ReactiveCrud<% } if (databaseTypeMongodb) { %>ReactiveMongo<% } if (databaseTypeCouchbase) { %>ReactiveN1qlCouchbase<% } if (databaseTypeNeo4j) { %>ReactiveNeo4j<% } if (databaseTypeCassandra) { %>ReactiveCassandra<% } %>Repository<<%= persistClass %>, <%= primaryKey.type %>><% if (databaseTypeSql) { %>, <%= entityClass %>RepositoryInternal<% } %> {
+public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) { %>ReactiveCrud<% } if (databaseTypeMongodb) { %>ReactiveMongo<% } if (databaseTypeNeo4j) { %>ReactiveNeo4j<% } if (databaseTypeCassandra) { %>ReactiveCassandra<% } %>Repository<<%= persistClass %>, <%= primaryKey.type %>><% if (databaseTypeSql) { %>, <%= entityClass %>RepositoryInternal<% } %> {
 
 <%_ if (!paginationNo) { _%>
     Flux<<%= persistClass %>> findAllBy(Pageable pageable);
 <%_ } _%>
-<%_ if (relationshipsContainEagerLoad) { _%>
-  <%_ if (databaseTypeCouchbase || databaseTypeMongodb) { _%>
+<%_ if (implementsEagerLoadApis) { _%>
+  <%_ if (databaseTypeMongodb) { _%>
 
     @Query("<%= (databaseTypeMongodb) ? '{}' : '#{#n1ql.selectEntity} WHERE #{#n1ql.filter}' %>")
     Flux<<%= persistClass %>> findAllWithEagerRelationships(Pageable pageable);
@@ -90,7 +86,7 @@ public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) {
   <%_ } _%>
 <%_ } _%>
 <%_ if (databaseTypeSql) { _%>
-  <%_ if (fieldsContainOwnerManyToMany) { _%>
+  <%_ if (implementsEagerLoadApis) { _%>
 
     @Override
     Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id);
@@ -108,21 +104,21 @@ public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) {
     let ownerSide = relationship.ownerSide; _%>
     <%_ if (relationship.relationshipManyToOne || (relationship.relationshipOneToOne && ownerSide)) { _%>
 
-    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= getColumnName(relationshipName) %>_id = :id")
+    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= relationship.joinColumnNames[0] %> = :id")
     Flux<<%= persistClass %>> findBy<%= relationship.relationshipNameCapitalized %>(<%= primaryKey.type %> id);
 
-    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= getColumnName(relationshipName) %>_id IS NULL")
+    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= relationship.joinColumnNames[0] %> IS NULL")
     Flux<<%= persistClass %>> findAllWhere<%= relationship.relationshipNameCapitalized %>IsNull();
     <%_ } else if (relationship.shouldWriteJoinTable) { _%>
 
-    @Query("SELECT entity.* FROM <%= entityTableName %> entity JOIN <%= relationship.joinTable.name %> joinTable ON entity.id = joinTable.<%= getColumnName(name) %>_id WHERE joinTable.<%= getColumnName(relationshipName) %>_id = :id")
+    @Query("SELECT entity.* FROM <%= entityTableName %> entity JOIN <%= relationship.joinTable.name %> joinTable ON entity.<%= primaryKey.fields[0].columnName %> = joinTable.<%= relationship.joinColumnNames[0] %> WHERE joinTable.<%= relationship.joinColumnNames[0] %> = :id")
     Flux<<%= persistClass %>> findBy<%= relationship.relationshipNameCapitalized %>(<%= primaryKey.type %> id);
     <%_ } else if (relationship.relationshipOneToOne && !ownerSide) {
         let otherEntityRelationshipName = relationship.otherEntityRelationshipName;
         let otherEntityTableName = relationship.otherEntityTableName;
       _%>
 
-    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.id not in (select <%= getColumnName(otherEntityRelationshipName) %>_id from <%= otherEntityTableName %>)")
+    @Query("SELECT * FROM <%= entityTableName %> entity WHERE entity.<%= primaryKey.fields[0].columnName  %> not in (select <%= relationship.joinColumnNames[0]%> from <%= otherEntityTableName %>)")
     Flux<<%= persistClass %>> findAllWhere<%= relationship.relationshipNameCapitalized %>IsNull();
     <%_ } _%>
   <%_ } _%>
@@ -138,10 +134,8 @@ public interface <%= entityClass %>Repository extends <% if (databaseTypeSql) {
 
     @Override
     Mono<Void> deleteById(<%= primaryKey.type %> id);
-<%_ } _%>
-
 }
-<%_ if (databaseTypeSql) { _%>
+
 interface <%= entityClass %>RepositoryInternal {
     <S extends <%= persistClass %>> Mono<S> save(S entity);
 
@@ -150,10 +144,10 @@ interface <%= entityClass %>RepositoryInternal {
     Flux<<%= persistClass %>> findAll();
 
     Mono<<%= persistClass %>> findById(<%= primaryKey.type %> id);
+    // this is not supported at the moment because of https://github.com/jhipster/generator-jhipster/issues/18269
+    // Flux<<%= persistClass %>> findAllBy(Pageable pageable, Criteria criteria);
 
-    Flux<<%= persistClass %>> findAllBy(Pageable pageable, Criteria criteria);
-
-  <%_ if (fieldsContainOwnerManyToMany) { _%>
+  <%_ if (implementsEagerLoadApis) { _%>
 
     Mono<<%= persistClass %>> findOneWithEagerRelationships(<%= primaryKey.type %> id);
 
@@ -162,8 +156,6 @@ interface <%= entityClass %>RepositoryInternal {
     Flux<<%= persistClass %>> findAllWithEagerRelationships(Pageable page);
 
     Mono<Void> deleteById(<%= primaryKey.type %> id);
-
   <%_ } _%>
-
-}
 <%_ } _%>
+}