generator-jhipster 7.7.0 → 7.9.0

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) { _%>
@@ -57,17 +53,17 @@ import java.util.UUID;
 <%_ } _%>
 
 /**
- * Spring Data <%= officialDatabaseType %> reactive repository for the <%= persistClass %> entity.
+ * <%= springDataDescription %> repository for the <%= persistClass %> entity.
  */
 @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 (relationshipsContainEagerLoad) { _%>
+  <%_ 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 (relationshipsContainEagerLoad) { _%>
+  <%_ 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);
-
   <%_ } _%>
-
-}
 <%_ } _%>
+}

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

@@ -29,7 +29,7 @@ public class <%= entityClass %>SqlHelper {
 
     public static List<Expression> getColumns(Table table, String columnPrefix) {
         List<Expression> columns = new ArrayList<>();
-<%_ fields.forEach(function(field) {
+<%_ fields.filter(field => !field.transient).forEach(function(field) {
     let col = field.fieldNameAsDatabaseColumn;
     _%>
         columns.add(Column.aliased("<%= col %>", table, columnPrefix + "_<%= col %>"));
@@ -39,7 +39,7 @@ public class <%= entityClass %>SqlHelper {
 <%_ }); _%>
 
 <%_ reactiveRegularEagerRelations.forEach(function(rel) { _%>
-        columns.add(Column.aliased("<%= getColumnName(rel.relationshipName) %>_id", table, columnPrefix + "_<%= getColumnName(rel.relationshipName) %>_id"));
+        columns.add(Column.aliased("<%= rel.joinColumnNames[0] %>", table, columnPrefix + "_<%= rel.joinColumnNames[0] %>"));
 <%_ }); _%>
         return columns;
     }

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

@@ -62,7 +62,7 @@ public class <%= entityClass %>RowMapper implements BiFunction<Row, String, <%=
     @Override
     public <%= persistClass %> apply(Row row, String prefix) {
         <%= persistClass %> entity = new <%= persistClass %>();
-<%_ fields.forEach(function(field) {
+<%_ fields.filter(field => !field.transient).forEach(function(field) {
   let fieldType = field.fieldType;
   if (field.blobContentTypeText) {
     fieldType = 'String';
@@ -73,7 +73,7 @@ public class <%= entityClass %>RowMapper implements BiFunction<Row, String, <%=
         entity.set<%= field.fieldInJavaBeanMethod %>(converter.fromRow(row, prefix + "_<%= field.fieldNameAsDatabaseColumn %>", <%= fieldType %>.class));
 <%_ }); _%>
 <%_ reactiveRegularEagerRelations.forEach(function(rel) { _%>
-        entity.set<%= rel.relationshipNameCapitalized %>Id(converter.fromRow(row, prefix + "_<%= getColumnName(rel.relationshipName) %>_id", <%= rel.otherEntity.primaryKey.type %>.class));
+        entity.set<%= rel.relationshipNameCapitalized %>Id(converter.fromRow(row, prefix + "_<%= rel.joinColumnNames[0] %>", <%= rel.otherEntity.primaryKey.type %>.class));
 <%_ }); _%>
         return entity;
     }

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

@@ -19,6 +19,7 @@
 package <%= entityAbsolutePackage %>.repository.search;
 
 import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
+import <%= entityAbsolutePackage %>.repository.<%= persistClass %>Repository;
 
 <%_ if (!paginationNo) { _%>
   <%_ if (!reactive) { _%>
@@ -27,6 +28,7 @@ import java.util.stream.Collectors;
 
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
+import org.springframework.data.elasticsearch.core.SearchHits;
   <%_ } _%>
 import org.springframework.data.domain.Pageable;
 import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
@@ -34,7 +36,6 @@ import org.elasticsearch.search.sort.SortBuilder;
 import java.util.List;
 import org.springframework.data.domain.PageRequest;
 
-
 <%_ } _%>
 <%_ if (reactive) { _%>
 import org.springframework.data.elasticsearch.core.ReactiveElasticsearchTemplate;
@@ -42,9 +43,13 @@ import org.springframework.data.elasticsearch.core.ReactiveElasticsearchTemplate
 import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
 <%_ } _%>
 import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
+import org.springframework.data.elasticsearch.core.query.Query;
 import org.springframework.data.elasticsearch.core.SearchHit;
 import org.springframework.data.elasticsearch.repository.<% if (reactive) {%>Reactive<% } %>ElasticsearchRepository;
-
+import org.springframework.scheduling.annotation.Async;
+import org.springframework.transaction.annotation.Isolation;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
 <%_ if (reactive) { _%>
 import reactor.core.publisher.Flux;
 <%_ } else { _%>
@@ -65,7 +70,9 @@ public interface <%= entityClass %>SearchRepository extends <% if (reactive) {%>
 <%_ if (reactive) { _%>
 
 interface <%= entityClass %>SearchRepositoryInternal {
-    Flux<<%= entityClass %>> search(String query<% if (!paginationNo) { %>, Pageable pageable<% } %>);
+    Flux<<%= persistClass %>> search(String query<% if (!paginationNo) { %>, Pageable pageable<% } %>);
+
+    Flux<<%= persistClass %>> search(Query query);
 }
 
 class <%= entityClass %>SearchRepositoryInternalImpl implements <%= entityClass %>SearchRepositoryInternal {
@@ -77,21 +84,18 @@ class <%= entityClass %>SearchRepositoryInternalImpl implements <%= entityClass
     }
 
     @Override
-    public Flux<<%= entityClass %>> search(String query<% if (!paginationNo) { %>, Pageable pageable<% } %>) {
+    public Flux<<%= persistClass %>> search(String query<% if (!paginationNo) { %>, Pageable pageable<% } %>) {
+        NativeSearchQuery nativeSearchQuery = new NativeSearchQuery(queryStringQuery(query));
   <%_ if (!paginationNo) { _%>
-        List<SortBuilder<?>> builders = new SortToSortBuilderListConverter().convert(pageable.getSort());
-
-        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder().withQuery(queryStringQuery(query))
-            .withPageable(PageRequest.of(pageable.getPageNumber(), pageable.getPageSize()));
-
-        queryBuilder.withSorts(builders);            
+        nativeSearchQuery.setPageable(pageable);
+  <%_ }_%>
+        return search(nativeSearchQuery);
+    }
 
-        NativeSearchQuery nativeSearchQuery = queryBuilder.build();
-  <%_ } else { _%>
-        NativeSearchQuery nativeSearchQuery = new NativeSearchQuery(queryStringQuery(query));
-  <%_ } _%>
+    @Override
+    public Flux<<%= persistClass %>> search(Query query) {
         return reactiveElasticsearchTemplate
-            .search(nativeSearchQuery, <%= entityClass %>.class)
+            .search(query, <%= persistClass %>.class)
             .map(SearchHit::getContent);
     }
 }
@@ -99,40 +103,60 @@ class <%= entityClass %>SearchRepositoryInternalImpl implements <%= entityClass
 
 interface <%= entityClass %>SearchRepositoryInternal {
   <%_ if (paginationNo) { _%>
-    Stream<<%= entityClass %>> search(String query);
+    Stream<<%= persistClass %>> search(String query);
+
+    Stream<<%= persistClass %>> search(Query query);
   <%_ } else { _%>
-    Page<<%= entityClass %>> search(String query, Pageable pageable);
+    Page<<%= persistClass %>> search(String query, Pageable pageable);
+
+    Page<<%= persistClass %>> search(Query query);
   <%_ } _%>
+
+    void index(<%= persistClass %> entity);
 }
 
 class <%= entityClass %>SearchRepositoryInternalImpl implements <%= entityClass %>SearchRepositoryInternal {
 
     private final ElasticsearchRestTemplate elasticsearchTemplate;
+    private final <%= entityClass %>Repository repository;
 
-    <%= entityClass %>SearchRepositoryInternalImpl(ElasticsearchRestTemplate elasticsearchTemplate) {
+    <%= entityClass %>SearchRepositoryInternalImpl(ElasticsearchRestTemplate elasticsearchTemplate, <%= entityClass %>Repository repository) {
         this.elasticsearchTemplate = elasticsearchTemplate;
+        this.repository = repository;
     }
 
   <%_ if (paginationNo) { _%>
     @Override
-    public Stream<<%= entityClass %>> search(String query) {
+    public Stream<<%= persistClass %>> search(String query) {
         NativeSearchQuery nativeSearchQuery = new NativeSearchQuery(queryStringQuery(query));
+        return search(nativeSearchQuery);
+    }
+
+    @Override
+    public Stream<<%= persistClass %>> search(Query query) {
         return elasticsearchTemplate
-            .search(nativeSearchQuery, <%= entityClass %>.class)
+            .search(query, <%= persistClass %>.class)
             .map(SearchHit::getContent)
             .stream();
     }
   <%_ } else { _%>
     @Override
-    public Page<<%= entityClass %>> search(String query, Pageable pageable) {
+    public Page<<%= persistClass %>> search(String query, Pageable pageable) {
         NativeSearchQuery nativeSearchQuery = new NativeSearchQuery(queryStringQuery(query));
-        nativeSearchQuery.setPageable(pageable);
-        List<<%= entityClass %>> hits = elasticsearchTemplate.search(nativeSearchQuery, <%= entityClass %>.class).map(SearchHit::getContent)
-            .stream()
-            .collect(Collectors.toList());
+        return search(nativeSearchQuery.setPageable(pageable));
+    }
 
-        return new PageImpl<>(hits, pageable, hits.size());
+    @Override
+    public Page<<%= persistClass %>> search(Query query) {
+        SearchHits<<%= persistClass %>> searchHits = elasticsearchTemplate.search(query, <%= persistClass %>.class);
+        List<<%= persistClass %>> hits = searchHits.map(SearchHit::getContent).stream().collect(Collectors.toList());
+        return new PageImpl<>(hits, query.getPageable(), searchHits.getTotalHits());
     }
   <%_ } _%>
+
+    @Override
+    public void index(<%= persistClass %> entity) {
+        repository.find<% if (implementsEagerLoadApis) { %>OneWithEagerRelationships<% } else { %>ById<% } %>(entity.get<%= primaryKey.nameCapitalized %>()).ifPresent(elasticsearchTemplate::save);
+    }
 }
 <%_ } _%>

package/generators/entity-server/templates/src/main/java/package/service/EntityQueryService.java.ejs

@@ -78,7 +78,7 @@ public class <%= serviceClassName %> extends QueryService<<%= persistClass %>> {
      */
     @Transactional(readOnly = true)
     public List<<%= instanceType %>> findByCriteria(<%= criteria %> criteria) {
-        log.debug("find by criteria : {}", criteria);
+        log.debug("find by criteria : {}", criteria.toString().replaceAll("[\n\r\t]", "_"));
         final Specification<<%= persistClass %>> specification = createSpecification(criteria);
 <%_ if (dtoMapstruct) { _%>
         return <%= entityListToDto %>(<%= repository %>.findAll(specification));
@@ -95,7 +95,7 @@ public class <%= serviceClassName %> extends QueryService<<%= persistClass %>> {
      */
     @Transactional(readOnly = true)
     public Page<<%= instanceType %>> findByCriteria(<%= criteria %> criteria, Pageable page) {
-        log.debug("find by criteria : {}, page: {}", criteria, page);
+        log.debug("find by criteria : {}, page: {}", criteria.toString().replaceAll("[\n\r\t]", "_"), page);
         final Specification<<%= persistClass %>> specification = createSpecification(criteria);
 <%_ if (dtoMapstruct) { _%>
         return <%= repository %>.findAll(specification, page)
@@ -112,7 +112,7 @@ public class <%= serviceClassName %> extends QueryService<<%= persistClass %>> {
      */
     @Transactional(readOnly = true)
     public long countByCriteria(<%= criteria %> criteria) {
-        log.debug("count by criteria : {}", criteria);
+        log.debug("count by criteria : {}", criteria.toString().replaceAll("[\n\r\t]", "_"));
         final Specification<<%= persistClass %>> specification = createSpecification(criteria);
         return <%= repository %>.count(specification);
     }

package/generators/entity-server/templates/src/main/java/package/service/EntityService.java.ejs

@@ -30,7 +30,7 @@ import <%= entityAbsolutePackage %>.service.dto.<%= dtoClass %>;
 <%_ } else { _%>
 import <%= entityAbsolutePackage %>.domain.<%= persistClass %>;
 <%_ } _%>
-<%_ if (!paginationNo || relationshipsContainEagerLoad) { _%>
+<%_ if (!paginationNo || implementsEagerLoadApis) { _%>
 
   <%_ if (!reactive) { _%>
 import org.springframework.data.domain.Page;
@@ -65,6 +65,14 @@ public interface <%= entityClass %>Service {
      */
     <% if (reactive) { %>Mono<<% } %><%= instanceType %><% if (reactive) { %>><% } %> save(<%= instanceType %> <%= instanceName %>);
 
+    /**
+     * Updates a <%= entityInstance %>.
+     *
+     * @param <%= instanceName %> the entity to update.
+     * @return the persisted entity.
+     */
+     <% if (reactive) { %>Mono<<% } %><%= instanceType %><% if (reactive) { %>><% } %> update(<%= instanceType %> <%= instanceName %>);
+
     /**
      * Partially updates a <%= entityInstance %>.
      *
@@ -90,7 +98,7 @@ public interface <%= entityClass %>Service {
     <%= listOrFlux %><<%= instanceType %>> findAllWhere<%= relationship.relationshipNameCapitalized %>IsNull();
 <%_ } } _%>
 
-<%_ if (relationshipsContainEagerLoad) { _%>
+<%_ if (implementsEagerLoadApis) { _%>
     /**
      * Get all the <%= entityInstancePlural %> with eager load of many-to-many relationships.
      *

package/generators/entity-server/templates/src/main/java/package/service/impl/EntityServiceImpl.java.ejs

@@ -51,7 +51,7 @@ import <%= entityAbsolutePackage %>.service.mapper.<%= entityClass %>Mapper;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-<%_ if (!paginationNo || relationshipsContainEagerLoad) { _%>
+<%_ if (!paginationNo || implementsEagerLoadApis) { _%>
   <%_ if (!reactive) { _%>
 import org.springframework.data.domain.Page;
   <%_ } _%>
@@ -112,7 +112,23 @@ public class <%= serviceClassName %><% if (serviceImpl) { %> implements <%= enti
 <%_ } _%>
     public <% if (reactive) { %>Mono<<% } %><%= instanceType %><% if (reactive) { %>><% } %> save(<%= instanceType %> <%= instanceName %>) {
         log.debug("Request to save <%= entityClass %> : {}", <%= instanceName %>);
-<%- include('/partials/save_template', {asEntity, asDto, viaService: false, returnDirectly: true, isUsingMapsId: isUsingMapsId, mapsIdAssoc: mapsIdAssoc, isController: false}); -%>
+<%- include('/partials/save_template', {asEntity, asDto, viaService: false, returnDirectly: true, isUsingMapsId: isUsingMapsId, mapsIdAssoc: mapsIdAssoc, isController: false, isPersisted: false}); -%>
+    }
+
+<%_ if (!serviceImpl) { _%>
+    /**
+     * Update a <%= entityInstance %>.
+     *
+     * @param <%= instanceName %> the entity to save.
+     * @return the persisted entity.
+    */
+<%_ } _%>
+<%_ if (serviceImpl) { _%>
+    @Override
+<%_ } _%>
+    public <% if (reactive) { %>Mono<<% } %><%= instanceType %><% if (reactive) { %>><% } %> update(<%= instanceType %> <%= instanceName %>) {
+        log.debug("Request to save <%= entityClass %> : {}", <%= instanceName %>);
+<%- include('/partials/update_template', {updatableEntity, viaService: false, returnDirectly: true, isUsingMapsId: isUsingMapsId, mapsIdAssoc: mapsIdAssoc, isController: false, isPersisted: requiresPersistableImplementation}); -%>
     }
 
 <%_ if (!serviceImpl) { _%>
@@ -150,16 +166,16 @@ public class <%= serviceClassName %><% if (serviceImpl) { %> implements <%= enti
     public <% if (paginationNo) { %><%= listOrFlux %><% } else { %><%= pageOrFlux %><% } %><<%= instanceType %>> findAll(<% if (!paginationNo) { %>Pageable pageable<% } %>) {
         log.debug("Request to get all <%= entityClassPlural %>");
 <%_ if (paginationNo) { _%>
-        return <%= entityInstance %>Repository.<% if (relationshipsContainEagerLoad) { %>findAllWithEagerRelationships<% } else { %>findAll<% } %>()<% if (dtoMapstruct) { %><% if (!reactive) { %>.stream()<% } %>
+        return <%= entityInstance %>Repository.findAll()<% if (dtoMapstruct) { %><% if (!reactive) { %>.stream()<% } %>
             .map(<%= entityToDtoReference %>)<% if (!reactive) { %>
             .collect(Collectors.toCollection(LinkedList::new))<% } } %>;
 <%_ } else { _%>
-        return <%= entityInstance %>Repository.findAll<% if (reactive) { %>By<% } %>(pageable)<% if (dto !== 'mapstruct') { %>;<% } else { %>
+        return <%= entityInstance %>Repository.findAll<% if (reactive) { %>By<% } %>(pageable)<% if (!dtoMapstruct) { %>;<% } else { %>
             .map(<%= entityToDtoReference %>);<% } %>
 <%_ } _%>
     }
 
-<%_ if (relationshipsContainEagerLoad) { _%>
+<%_ if (implementsEagerLoadApis) { _%>
 
   <%_ if (!serviceImpl) { _%>
     /**
@@ -213,7 +229,7 @@ public class <%= serviceClassName %><% if (serviceImpl) { %> implements <%= enti
     @Transactional(readOnly = true)
     <%_ } _%>
     public <%= optionalOrMono %><<%= instanceType %>> findOne(<%= primaryKey.type %> id) {
-        log.debug("Request to get <%= entityClass %> : {}", id);<%- include('../../common/get_template', {asEntity, asDto, viaService: false, returnDirectly:true, relationshipsContainEagerLoad}); -%>
+        log.debug("Request to get <%= entityClass %> : {}", id);<%- include('../../common/get_template', {asEntity, asDto, viaService: false, returnDirectly:true, implementsEagerLoadApis}); -%>
     }
 
 <%_ if (!serviceImpl) { _%>

package/generators/entity-server/templates/src/main/java/package/service/mapper/EntityMapper.java.ejs

@@ -19,30 +19,34 @@
 package <%= entityAbsolutePackage %>.service.mapper;
 
 <%_
-let existingMappings = [];
-let uuidMapMethod = dtoReferences.some(reference => reference.valueReference && reference.valueReference.field && reference.valueReference.field.fieldTypeUUID);
-let byteMapMethod = dtoReferences.some(reference => reference.valueReference && reference.valueReference.field && reference.valueReference.field.fieldTypeBytes);
-for (reference of dtoReferences) {
-  // if the entity is mapped twice, we should implement the mapping once
-  if (reference.relationship && !reference.relationship.otherEntity.embedded && !existingMappings.includes(reference.name) && asEntity(reference.relationship.otherEntityNameCapitalized) !== persistClass) {
-    existingMappings.push(reference.relationship.otherEntity.entityNameCapitalized);
-  }
- }
+  const uuidMapMethod = dtoReferences.some(reference => reference.valueReference && reference.valueReference.field && reference.valueReference.field.fieldTypeUUID);
+  const byteMapMethod = dtoReferences.some(reference => reference.valueReference && reference.valueReference.field && reference.valueReference.field.fieldTypeBytes);
+  const dtoRelationships = dtoReferences.filter(reference => reference.relationship && !reference.relationship.otherEntity.embedded).map(reference => reference.relationship);
+  let otherEntitiesFields = otherEntities
+    .filter(otherEntity => dtoRelationships.some(relationship => relationship.otherEntity === otherEntity))
+    .map(otherEntity => 
+      dtoRelationships
+        .filter(relationship => relationship.otherEntity == otherEntity)
+        .map(({relatedField, collection}) => ({otherEntity, relatedField, collection}))
+    )
+    .flat();
+  otherEntitiesFields.forEach(a => {
+    a.collection = a.collection || otherEntitiesFields.some(b => a.otherEntity === b.otherEntity && a.relatedField === b.relatedField && b.collection == true)
+  });
+  otherEntitiesFields = _.uniqWith(otherEntitiesFields, (a, b) => a.otherEntity === b.otherEntity && a.collection === b.collection && a.relatedField === b.relatedField);
 _%>
 
-<%_ if (dtoReferences.some(r => r.relationship &&
-        r.relationship.otherRelationship &&
-        r.relationship.otherRelationship.reference.collection &&
-        r.relationship.relationshipManyToMany
-    ) || otherDtoReferences.some(r => r.collection)) { _%>
+<%_ if (dtoRelationships.some(r => r.collection)) { _%>
 import java.util.Set;
+import java.util.stream.Collectors;
 <%_ } _%>
 
 import <%= entityAbsoluteClass %>;
 import <%= entityAbsolutePackage %>.service.dto.<%= dtoClass %>;
 
-<%_ for (const otherEntity of _.uniq(dtoReferences.filter(ref => ref.relationship).map(ref => ref.relationship.otherEntity).filter(otherEntity => otherEntity.entityPackage !== entityPackage))) { _%>
-import <%= `${otherEntity.entityAbsolutePackage}.service.mapper.${otherEntity.entityClass}Mapper` %>;
+<%_ for (const otherEntity of _.uniq(dtoRelationships.map(relationship => relationship.otherEntity).filter(otherEntity => otherEntity !== entity))) { _%>
+import <%= otherEntity.entityAbsoluteClass %>;
+import <%= otherEntity.entityAbsolutePackage %>.service.dto.<%= otherEntity.dtoClass %>;
 <%_ } _%>
 
 import org.mapstruct.*;
@@ -55,100 +59,67 @@ import java.util.UUID;
 /**
  * Mapper for the entity {@link <%= persistClass %>} and its DTO {@link <%= dtoClass %>}.
  */
-@Mapper(componentModel = "spring", uses = {<%= [...new Set(existingMappings.map(otherEntityNameCapitalized => otherEntityNameCapitalized + 'Mapper.class'))].join(', ') %>})
+@Mapper(componentModel = "spring")
 public interface <%= entityClass %>Mapper extends EntityMapper<<%= dtoClass %>, <%= persistClass %>> {
-<%_ /***** Basic dto mapping *****/
-  if (!embedded) {
-    var renMapAnotEnt = false; //Render Mapping Annotation during Entity to DTO conversion?
-    for (reference of dtoReferences.filter(reference => reference.relationship && !reference.relationship.otherEntity.embedded)) {
+<%_ if (!embedded) { _%>
+  <%_ var renMapAnotEnt = false; //Render Mapping Annotation during Entity to DTO conversion? _%>
+  <%_ for (relationship of dtoRelationships) { _%>
+    <%_
       renMapAnotEnt = true;
-      let qualifiedByName = reference.relationship.otherEntityField;
-      qualifiedByName = qualifiedByName + (reference.collection ? 'Set' : ''); _%>
-    @Mapping(target = "<%= reference.name %>", source = "<%= reference.name %>", qualifiedByName="<%= qualifiedByName %>")
-    <%_ } _%>
-    <%_ for (reference of dtoReferences.filter(reference => reference.field && reference.field.mapstructExpression)) {
+      let qualifiedByName = relationship.otherEntity.entityInstance + _.upperFirst(relationship.otherEntityField);
+      qualifiedByName = qualifiedByName + (relationship.collection ? 'Set' : '');
+    _%>
+    @Mapping(target = "<%= relationship.propertyName %>", source = "<%= relationship.propertyName %>", qualifiedByName="<%= qualifiedByName %>")
+  <%_ } _%>
+  <%_ for (const field of fields.filter(field => field.mapstructExpression)) {
       renMapAnotEnt = true; _%>
-    @Mapping( target = "<%= reference.name %>", expression = "<%- reference.field.mapstructExpression %>")
-    <%_ } _%>
-    <%_ if (renMapAnotEnt) { _%>
+    @Mapping( target = "<%= field.propertyName %>", expression = "<%- field.mapstructExpression %>")
+  <%_ } _%>
+  <%_ if (renMapAnotEnt) { _%>
     <%= dtoClass %> toDto(<%= persistClass %> s);
-    <%_ } %>
-<%_ } %>
-<%_ /***** Id mapping *****/
-const otherIdReferences = otherDtoReferences.filter(r => !r.relatedReference || r.relatedReference.id);
-if (!embedded && otherIdReferences.length > 0) {
-  if (otherIdReferences.some(r => !r.collection)) { _%>
-
-    @Named("<%= primaryKey.name %>")
-    @BeanMapping(ignoreByDefault = true)
-    <%_ let renMapAnotEnt = false; //Render Mapping Annotation during Entity to DTO conversion?
-    for (reference of dtoReferences.filter(reference => reference.id)) {
-      renMapAnotEnt = true; _%>
-    @Mapping(target = "<%= reference.name %>", source = "<%= reference.name %>")
-    <%_ } _%>
-    <%_ if (renMapAnotEnt) { _%>
-    <%= dtoClass %> toDtoId(<%= persistClass %> <%= persistInstance %>);
-    <%_ } _%>
   <%_ } _%>
-  <%_ if (otherIdReferences.some(r => r.collection)) { _%>
 
-    @Named("<%= primaryKey.name %>Set")
-    @BeanMapping(ignoreByDefault = true)
-    <%_ let renMapAnotEnt = false; //Render Mapping Annotation during Entity to DTO conversion?
-    for (reference of dtoReferences.filter(reference => reference.id)) {
-      renMapAnotEnt = true; _%>
-    @Mapping(target = "<%= reference.name %>", source = "<%= reference.name %>")
-    <%_ } _%>
-    <%_ if (renMapAnotEnt === true) { _%>
-    Set<<%= dtoClass %>> toDtoIdSet(Set<<%= persistClass %>> <%= persistInstance %>);
+  <%_ var renMapAnotDto = false;  //Render Mapping Annotation during DTO to Entity conversion? _%>
+  <%_ if(primaryKey.ids.length > 1) { _%>
+    <%_ renMapAnotDto = true; _%>
+    <%_ for (const id of primaryKey.ids) { _%>
+    @Mapping(target = "id.<%= id.name %>", source = "<%= id.nameDotted %>")
     <%_ } _%>
   <%_ } _%>
-<%_ } _%>
-<%_ if (!embedded) {
-        // DTO -> entity mapping
-  var renMapAnotDto = false;  //Render Mapping Annotation during DTO to Entity conversion?
-  if(primaryKey.ids.length > 1) {
-    renMapAnotDto = true;
-    primaryKey.ids.forEach(id => { _%>
-
-    @Mapping(target = "id.<%= id.name %>", source = "<%= id.nameDotted %>")
-    <%_ })
-  }
-  for (reference of dtoReferences.filter(reference => reference.relationship)) {
-    if (reference.owned === false) {
-      renMapAnotDto = true; _%>
-    @Mapping(target = "<%= reference.name %>", ignore = true)
+  <%_ for (relationship of dtoRelationships) { _%>
+    <%_ if (!relationship.ownerSide) { _%>
+      <%_ renMapAnotDto = true; _%>
+    @Mapping(target = "<%= relationship.propertyName %>", ignore = true)
     <%_ }
-    if (reference.collection && fluentMethods) {
+    if (relationship.collection && fluentMethods) {
       renMapAnotDto = true; _%>
-    @Mapping(target = "remove<%= reference.relationship.relationshipNameCapitalized %>", ignore = true)
+    @Mapping(target = "remove<%= relationship.relationshipNameCapitalized %>", ignore = true)
     <%_ } _%>
   <%_ } _%>
   <%_ if (renMapAnotDto) { _%>
     <%= persistClass %> toEntity(<%= dtoClass %> <%= dtoInstance %>);
   <%_ } _%>
-  <%_ /***** Add filtered backreference *****/
-  const addedMappers = [];
-  for (const otherReference of otherDtoReferences.filter(r => r.relatedReference && !r.relatedReference.id)) {
-    const reference = otherReference.relationship.otherRelationship && otherReference.relationship.otherRelationship.reference;
-    const collection = otherReference.collection;
-    const mapperName = otherReference.relationship.otherEntityField + (collection ? 'Set' : '');
-    if (addedMappers.includes(mapperName)) continue;
-    addedMappers.push(mapperName);
-    const backReferenceDtoClass = collection ? `Set<${dtoClass}>` : dtoClass;
-    const backReferenceEntityClass = collection ? `Set<${persistClass}>` : persistClass; _%>
+  <%_ for (const {otherEntity, relatedField, collection} of otherEntitiesFields) { _%>
+    <%_ const mapperName = otherEntity.entityInstance + _.upperFirst(relatedField.propertyName); _%>
 
     @Named("<%= mapperName %>")
     @BeanMapping(ignoreByDefault = true)
-    <%_ dtoReferences.filter(r => r.id && r !== reference).forEach(r => { _%>
-    @Mapping(target = "<%= r.name %>", source = "<%= r.name %>")
-    <%_ }); _%>
-    <%_ if (otherReference.relationship.relatedField && !otherReference.relationship.relatedField.id) { _%>
-    @Mapping(target = "<%= otherReference.relationship.relatedField.reference.name %>", source = "<%= otherReference.relationship.relatedField.reference.name %>")
+    <%_ for (const field of otherEntity.primaryKey.fields) { _%>
+    @Mapping(target = "<%= field.propertyName %>", source = "<%= field.propertyName %>")
     <%_ } _%>
-    <%- backReferenceDtoClass %> toDto<%= _.upperFirst(mapperName) %>(<%- backReferenceEntityClass %> <%= persistInstance %>);
-  <%_ } _%>
+    <%_ if (!relatedField.id) { _%>
+    @Mapping(target = "<%= relatedField.propertyName %>", source = "<%= relatedField.propertyName %>")
+    <%_ } _%>
+    <%- otherEntity.dtoClass %> toDto<%= _.upperFirst(mapperName) %>(<%- otherEntity.persistClass %> <%= otherEntity.persistInstance %>);
+    <%_ if (collection) { %>
+      <%_ const collectionMapperName = otherEntity.entityInstance + _.upperFirst(relatedField.propertyName) + 'Set'; _%>
 
+    @Named("<%= collectionMapperName %>")
+    default Set<<%- otherEntity.dtoClass %>> toDto<%= _.upperFirst(mapperName) %>Set(Set<<%- otherEntity.persistClass %>> <%= otherEntity.persistInstance %>) {
+        return <%= otherEntity.persistInstance %>.stream().map(this:: toDto<%= _.upperFirst(mapperName) %>).collect(Collectors.toSet());
+    }
+    <%_ } _%>
+  <%_ } _%>
   <%_ if (uuidMapMethod) { _%>
 
     default String map(UUID value) {