Improve generated code for Pageable (#11729)

vercel-talented · Sep 3, 2021 · 2311387 · 2311387
1 parent ee92995
commit 2311387
Show file tree

Hide file tree

Showing 9 changed files with 106 additions and 96 deletions.
diff --git a/...ndpoint/src/main/java/com/vaadin/fusion/endpointransfermapper/EndpointTransferMapper.java b/...ndpoint/src/main/java/com/vaadin/fusion/endpointransfermapper/EndpointTransferMapper.java
@@ -48,7 +48,7 @@
  * generates a TypeScript and converts data as if the method was defined as
  * <p>
  * <code>
- * public List&lt;Person&gt; list(PageableDTO pageable) {
+ * public List&lt;Person&gt; list(com.vaadin.fusion.mappedtypes.Pageable pageable) {
  * }
  * </code>
  * 

diff --git a/...fusion-endpoint/src/main/java/com/vaadin/fusion/endpointransfermapper/PageableMapper.java b/...fusion-endpoint/src/main/java/com/vaadin/fusion/endpointransfermapper/PageableMapper.java
@@ -16,41 +16,45 @@
 package com.vaadin.fusion.endpointransfermapper;
 
 import com.vaadin.fusion.endpointransfermapper.EndpointTransferMapper.Mapper;
+import com.vaadin.fusion.mappedtypes.Pageable;
 
 import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
-import org.springframework.data.domain.Sort;
 
 /**
- * A mapper between {@link Pageable} and {@link PageableDTO}.
+ * A mapper between {@link Pageable} and {@link Pageable}.
  */
-public class PageableMapper implements Mapper<Pageable, PageableDTO> {
+public class PageableMapper
+        implements Mapper<org.springframework.data.domain.Pageable, Pageable> {
 
     private SortMapper sortMapper = new SortMapper();
 
     @Override
-    public Class<? extends Pageable> getEndpointType() {
-        return Pageable.class;
+    public Class<? extends org.springframework.data.domain.Pageable> getEndpointType() {
+        return org.springframework.data.domain.Pageable.class;
     }
 
     @Override
-    public Class<? extends PageableDTO> getTransferType() {
-        return PageableDTO.class;
+    public Class<? extends Pageable> getTransferType() {
+        return Pageable.class;
     }
 
     @Override
-    public PageableDTO toTransferType(Pageable pageable) {
-        PageableDTO dto = new PageableDTO();
-        dto.setPageNumber(pageable.getPageNumber());
-        dto.setPageSize(pageable.getPageSize());
-        dto.setSort(sortMapper.toTransferType(pageable.getSort()));
-
-        return dto;
+    public Pageable toTransferType(
+            org.springframework.data.domain.Pageable pageable) {
+        Pageable transferPageable = new Pageable();
+        transferPageable.setPageNumber(pageable.getPageNumber());
+        transferPageable.setPageSize(pageable.getPageSize());
+        transferPageable.setSort(sortMapper.toTransferType(pageable.getSort()));
+
+        return transferPageable;
     }
 
     @Override
-    public Pageable toEndpointType(PageableDTO dto) {
-        Sort sort = sortMapper.toEndpointType(dto.getSort());
-        return PageRequest.of(dto.getPageNumber(), dto.getPageSize(), sort);
+    public org.springframework.data.domain.Pageable toEndpointType(
+            Pageable transferPageable) {
+        org.springframework.data.domain.Sort sort = sortMapper
+                .toEndpointType(transferPageable.getSort());
+        return PageRequest.of(transferPageable.getPageNumber(),
+                transferPageable.getPageSize(), sort);
     }
 }
diff --git a/...ava/fusion-endpoint/src/main/java/com/vaadin/fusion/endpointransfermapper/SortMapper.java b/...ava/fusion-endpoint/src/main/java/com/vaadin/fusion/endpointransfermapper/SortMapper.java
@@ -19,58 +19,61 @@
 import java.util.List;
 
 import com.vaadin.fusion.endpointransfermapper.EndpointTransferMapper.Mapper;
-
-import org.springframework.data.domain.Sort;
-import org.springframework.data.domain.Sort.Order;
+import com.vaadin.fusion.mappedtypes.Order;
+import com.vaadin.fusion.mappedtypes.Sort;
 
 /**
- * A mapper between {@link Sort} and {@link SortDTO}.
+ * A mapper between {@link org.springframework.data.domain.Sort} and
+ * {@link Sort}.
  */
-public class SortMapper implements Mapper<Sort, SortDTO> {
+public class SortMapper
+        implements Mapper<org.springframework.data.domain.Sort, Sort> {
 
     @Override
-    public Class<? extends Sort> getEndpointType() {
-        return Sort.class;
+    public Class<? extends org.springframework.data.domain.Sort> getEndpointType() {
+        return org.springframework.data.domain.Sort.class;
     }
 
     @Override
-    public Class<? extends SortDTO> getTransferType() {
-        return SortDTO.class;
+    public Class<? extends Sort> getTransferType() {
+        return Sort.class;
     }
 
     @Override
-    public SortDTO toTransferType(Sort sort) {
+    public Sort toTransferType(org.springframework.data.domain.Sort sort) {
 
-        SortDTO sortDto = new SortDTO();
-        List<OrderDTO> orders = new ArrayList<>();
-        for (Order order : sort) {
-            OrderDTO orderDTO = new OrderDTO();
-            orderDTO.setProperty(order.getProperty());
-            orderDTO.setDirection(order.getDirection());
-            orderDTO.setIgnoreCase(order.isIgnoreCase());
-            orderDTO.setNullHandling(order.getNullHandling());
-            orders.add(orderDTO);
+        Sort transferSort = new Sort();
+        List<Order> transferOrders = new ArrayList<>();
+        for (org.springframework.data.domain.Sort.Order order : sort) {
+            Order transferOrder = new Order();
+            transferOrder.setProperty(order.getProperty());
+            transferOrder.setDirection(order.getDirection());
+            transferOrder.setIgnoreCase(order.isIgnoreCase());
+            transferOrder.setNullHandling(order.getNullHandling());
+            transferOrders.add(transferOrder);
         }
 
-        sortDto.setOrders(orders);
-        return sortDto;
+        transferSort.setOrders(transferOrders);
+        return transferSort;
     }
 
     @Override
-    public Sort toEndpointType(SortDTO sort) {
-        if (sort == null) {
+    public org.springframework.data.domain.Sort toEndpointType(
+            Sort transferSort) {
+        if (transferSort == null) {
             return null;
         }
-        List<Order> orders = new ArrayList<>();
-        for (OrderDTO orderDto : sort.getOrders()) {
-            Order order = new Order(orderDto.getDirection(),
-                    orderDto.getProperty(), orderDto.getNullHandling());
-            if (orderDto.isIgnoreCase()) {
+        List<org.springframework.data.domain.Sort.Order> orders = new ArrayList<>();
+        for (Order transferOrder : transferSort.getOrders()) {
+            org.springframework.data.domain.Sort.Order order = new org.springframework.data.domain.Sort.Order(
+                    transferOrder.getDirection(), transferOrder.getProperty(),
+                    transferOrder.getNullHandling());
+            if (transferOrder.isIgnoreCase()) {
                 order = order.ignoreCase();
             }
             orders.add(order);
         }
-        return Sort.by(orders);
+        return org.springframework.data.domain.Sort.by(orders);
     }
 
 }
diff --git a/...usion/endpointransfermapper/OrderDTO.java → .../com/vaadin/fusion/mappedtypes/Order.java b/...usion/endpointransfermapper/OrderDTO.java → .../com/vaadin/fusion/mappedtypes/Order.java
@@ -13,20 +13,19 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.vaadin.fusion.endpointransfermapper;
+package com.vaadin.fusion.mappedtypes;
 
 import javax.validation.constraints.NotBlank;
 
 import com.vaadin.fusion.Nonnull;
 
 import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.domain.Sort.NullHandling;
-import org.springframework.data.domain.Sort.Order;
 
 /**
- * A DTO for {@link Order}.
+ * A DTO for {@link org.springframework.data.domain.Sort.Order}.
  */
-public class OrderDTO {
+public class Order {
     @Nonnull
     private Direction direction;
     @Nonnull

diff --git a/...on/endpointransfermapper/PageableDTO.java → ...m/vaadin/fusion/mappedtypes/Pageable.java b/...on/endpointransfermapper/PageableDTO.java → ...m/vaadin/fusion/mappedtypes/Pageable.java
@@ -13,20 +13,18 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.vaadin.fusion.endpointransfermapper;
+package com.vaadin.fusion.mappedtypes;
 
 import com.vaadin.fusion.Nonnull;
 
-import org.springframework.data.domain.Pageable;
-
 /**
- * A DTO for {@link Pageable}.
+ * A DTO for {@link org.springframework.data.domain.Pageable}.
  */
-public class PageableDTO {
+public class Pageable {
     private int pageNumber;
     private int pageSize;
     @Nonnull
-    private SortDTO sort = new SortDTO();
+    private Sort sort = new Sort();
 
     public int getPageNumber() {
         return pageNumber;
@@ -44,11 +42,11 @@ public void setPageSize(int pageSize) {
         this.pageSize = pageSize;
     }
 
-    public SortDTO getSort() {
+    public Sort getSort() {
         return sort;
     }
 
-    public void setSort(SortDTO sort) {
+    public void setSort(Sort sort) {
         this.sort = sort;
     }
 

diff --git a/...fusion/endpointransfermapper/SortDTO.java → ...a/com/vaadin/fusion/mappedtypes/Sort.java b/...fusion/endpointransfermapper/SortDTO.java → ...a/com/vaadin/fusion/mappedtypes/Sort.java
@@ -13,27 +13,25 @@
  * License for the specific language governing permissions and limitations under
  * the License.
  */
-package com.vaadin.fusion.endpointransfermapper;
+package com.vaadin.fusion.mappedtypes;
 
 import java.util.ArrayList;
 import java.util.List;
 
 import com.vaadin.fusion.Nonnull;
 
-import org.springframework.data.domain.Sort;
-
 /**
- * A DTO for {@link Sort}.
+ * A DTO for {@link org.springframework.data.domain.Sort}.
  */
-public class SortDTO {
+public class Sort {
     @Nonnull
-    private List<OrderDTO> orders = new ArrayList<>();
+    private List<Order> orders = new ArrayList<>();
 
-    public List<OrderDTO> getOrders() {
+    public List<Order> getOrders() {
         return orders;
     }
 
-    public void setOrders(List<OrderDTO> orders) {
+    public void setOrders(List<Order> orders) {
         this.orders = orders;
     }
 

diff --git a/...int/src/test/java/com/vaadin/fusion/endpointransfermapper/EndpointTransferMapperTest.java b/...int/src/test/java/com/vaadin/fusion/endpointransfermapper/EndpointTransferMapperTest.java
@@ -4,28 +4,30 @@
 import java.util.List;
 import java.util.UUID;
 
+import com.vaadin.fusion.mappedtypes.Order;
+import com.vaadin.fusion.mappedtypes.Pageable;
+
 import org.junit.Assert;
 import org.junit.Test;
 import org.springframework.data.domain.AbstractPageRequest;
 import org.springframework.data.domain.Page;
 import org.springframework.data.domain.PageImpl;
 import org.springframework.data.domain.PageRequest;
-import org.springframework.data.domain.Pageable;
 import org.springframework.data.domain.Sort.Direction;
 import org.springframework.data.domain.Sort.NullHandling;
-import org.springframework.data.domain.Sort.Order;
 
 public class EndpointTransferMapperTest {
 
     private EndpointTransferMapper endpointTransferMapper = new EndpointTransferMapper();
 
     @Test
     public void getTransferTypeClass_works() {
-        Assert.assertEquals(PageableDTO.class,
-                endpointTransferMapper.getTransferType(Pageable.class));
-        Assert.assertEquals(PageableDTO.class, endpointTransferMapper
+        Assert.assertEquals(Pageable.class,
+                endpointTransferMapper.getTransferType(
+                        org.springframework.data.domain.Pageable.class));
+        Assert.assertEquals(Pageable.class, endpointTransferMapper
                 .getTransferType(AbstractPageRequest.class));
-        Assert.assertEquals(PageableDTO.class,
+        Assert.assertEquals(Pageable.class,
                 endpointTransferMapper.getTransferType(PageRequest.class));
         Assert.assertEquals(List.class,
                 endpointTransferMapper.getTransferType(Page.class));
@@ -37,8 +39,10 @@ public void getTransferTypeClass_works() {
 
     @Test
     public void getTransferTypeString_works() {
-        Assert.assertEquals(PageableDTO.class.getName(), endpointTransferMapper
-                .getTransferType(Pageable.class.getName()));
+        Assert.assertEquals(Pageable.class.getName(),
+                endpointTransferMapper.getTransferType(
+                        org.springframework.data.domain.Pageable.class
+                                .getName()));
         // When defining the methods, the defined classes are used to we do not
         // need to
         // support e.g. AbstractPageRequest and PageRequest here
@@ -60,12 +64,13 @@ public void integer_not_mapped() {
 
     @Test
     public void pageable_simple_toEndpointType() {
-        PageableDTO dto = new PageableDTO();
+        Pageable dto = new Pageable();
         dto.setPageNumber(1);
         dto.setPageSize(2);
 
-        Pageable pageable = endpointTransferMapper.toEndpointType(dto,
-                Pageable.class);
+        org.springframework.data.domain.Pageable pageable = endpointTransferMapper
+                .toEndpointType(dto,
+                        org.springframework.data.domain.Pageable.class);
 
         Assert.assertEquals(1, pageable.getPageNumber());
         Assert.assertEquals(2, pageable.getPageSize());
@@ -74,23 +79,24 @@ public void pageable_simple_toEndpointType() {
 
     @Test
     public void pageable_sortorder_toEndpointType() {
-        PageableDTO dto = new PageableDTO();
+        Pageable dto = new Pageable();
         dto.setPageNumber(1);
         dto.setPageSize(2);
 
-        OrderDTO order1 = new OrderDTO();
+        Order order1 = new Order();
         order1.setDirection(Direction.ASC);
         order1.setProperty("p1");
-        OrderDTO order2 = new OrderDTO();
+        Order order2 = new Order();
         order2.setDirection(Direction.DESC);
         order2.setIgnoreCase(true);
         order2.setNullHandling(NullHandling.NULLS_LAST);
         order2.setProperty("p2");
 
         dto.getSort().getOrders().add(order1);
         dto.getSort().getOrders().add(order2);
-        Pageable pageable = endpointTransferMapper.toEndpointType(dto,
-                Pageable.class);
+        org.springframework.data.domain.Pageable pageable = endpointTransferMapper
+                .toEndpointType(dto,
+                        org.springframework.data.domain.Pageable.class);
 
         Assert.assertEquals(1, pageable.getPageNumber());
         Assert.assertEquals(2, pageable.getPageSize());
@@ -101,8 +107,10 @@ public void pageable_sortorder_toEndpointType() {
         Assert.assertEquals("p2",
                 pageable.getSort().toList().get(1).getProperty());
 
-        Order p1Order = pageable.getSort().getOrderFor("p1");
-        Order p2Order = pageable.getSort().getOrderFor("p2");
+        org.springframework.data.domain.Sort.Order p1Order = pageable.getSort()
+                .getOrderFor("p1");
+        org.springframework.data.domain.Sort.Order p2Order = pageable.getSort()
+                .getOrderFor("p2");
 
         Assert.assertEquals(Direction.ASC, p1Order.getDirection());
         Assert.assertEquals(Direction.DESC, p2Order.getDirection());
@@ -114,9 +122,9 @@ public void pageable_sortorder_toEndpointType() {
 
     @Test
     public void pageable_toTransferType() {
-        Pageable p = Pageable.ofSize(10);
-        PageableDTO dto = (PageableDTO) endpointTransferMapper
-                .toTransferType(p);
+        org.springframework.data.domain.Pageable p = org.springframework.data.domain.Pageable
+                .ofSize(10);
+        Pageable dto = (Pageable) endpointTransferMapper.toTransferType(p);
         Assert.assertEquals(10, dto.getPageSize());
     }