Merge pull request #39 from Systems-Modeling/feature/ST5AS-107

ivan-gomes · web-flow · commit 105a956404d7 · 2021-01-23T12:49:44.000-08:00
ST5AS-107 Implement cursor pagination in getElementsByProjectCommit endpoint
diff --git a/app/controllers/ElementController.java b/app/controllers/ElementController.java
@@ -22,6 +22,7 @@
 package controllers;
 
 import com.fasterxml.jackson.databind.JsonNode;
+import com.google.common.primitives.Bytes;
 import config.MetamodelProvider;
 import jackson.JacksonHelper;
 import jackson.JsonLdMofObjectAdornment;
@@ -36,10 +37,8 @@
 import services.ElementService;
 
 import javax.inject.Inject;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-import java.util.UUID;
+import java.time.Instant;
+import java.util.*;
 import java.util.stream.Collectors;
 
 import static jackson.JsonLdMofObjectAdornment.JSONLD_MIME_TYPE;
@@ -83,22 +82,70 @@ public Result create(Http.Request request) {
     }
 
     public Result getElementsByProjectIdCommitId(UUID projectId, UUID commitId, Http.Request request) {
-        Set<Element> elements = elementService.getElementsByProjectIdCommitId(projectId, commitId);
+        UUID pageAfter = Optional.ofNullable(request.getQueryString("page[after]"))
+                .map(ElementController::fromCursor)
+                //.map(UUID::fromString)
+                .orElse(null);
+        UUID pageBefore = Optional.ofNullable(request.getQueryString("page[before]"))
+                .map(ElementController::fromCursor)
+                //.map(UUID::fromString)
+                .orElse(null);
+        int pageSize = Optional.ofNullable(request.getQueryString("page[size]"))
+                .map(Integer::parseInt)
+                .orElse(100);
+        if (pageSize <= 0) {
+            return Results.badRequest("Page size must be greater than zero.");
+        }
+
+        List<Element> elements = elementService.getElementsByProjectIdCommitId(projectId, commitId, pageAfter, pageBefore, pageSize);
         boolean respondWithJsonLd = respondWithJsonLd(request);
+        final String linkHeaderValue;
+        if (elements.size() > 0) {
+            boolean pageFull = elements.size() == pageSize;
+            boolean hasNext = pageFull || pageBefore != null;
+            boolean hasPrev = pageFull && pageBefore != null || pageAfter != null;
+            // hasPrev -> !pageFull || pageAfter != null
+            StringBuilder linkHeaderValueBuilder = new StringBuilder();
+            if (hasNext) {
+                linkHeaderValueBuilder.append(String.format("<http://%s/projects/%s/commits/%s/elements?page[after]=%s&page[size]=%s>; rel=\"next\"",
+                        request.host(),
+                        projectId,
+                        commitId,
+                        toCursor(elements.get(elements.size() - 1).getIdentifier()),
+                        pageSize));
+                if (hasPrev) {
+                    linkHeaderValueBuilder.append(", ");
+                }
+            }
+            if (hasPrev) {
+                linkHeaderValueBuilder.append(String.format("<http://%s/projects/%s/commits/%s/elements?page[before]=%s&page[size]=%s>; rel=\"prev\"",
+                        request.host(),
+                        projectId,
+                        commitId,
+                        toCursor(elements.get(0).getIdentifier()),
+                        pageSize));
+            }
+            linkHeaderValue = linkHeaderValueBuilder.toString();
+        }
+        else {
+            linkHeaderValue = null;
+        }
+
         return Optional.of(
                 elements.stream()
                         .map(e -> respondWithJsonLd ?
                                 adornMofObject(e, request, metamodelProvider, environment, projectId, commitId) :
                                 e
                         )
-                        .collect(Collectors.toSet())
+                        .collect(Collectors.toList())
         )
-                .map(set -> JacksonHelper.collectionToTree(set, Set.class, respondWithJsonLd ?
+                .map(collection -> JacksonHelper.collectionToTree(collection, List.class, respondWithJsonLd ?
                         JsonLdMofObjectAdornment.class :
                         metamodelProvider.getImplementationClass(Element.class))
                 )
                 .map(Results::ok)
                 .map(result -> respondWithJsonLd ? result.as(JSONLD_MIME_TYPE) : result)
+                .map(result -> linkHeaderValue != null ? result.withHeader("Link", linkHeaderValue) : result)
                 .orElseThrow();
     }
 
@@ -123,7 +170,7 @@ static JsonLdMofObjectAdornment adornMofObject(MofObject mof, Http.Request reque
     }
 
     public Result getRootsByProjectIdCommitId(UUID projectId, UUID commitId, Http.Request request) {
-        Set<Element> roots = elementService.getRootsByProjectIdCommitId(projectId, commitId);
+        List<Element> roots = elementService.getRootsByProjectIdCommitId(projectId, commitId);
         boolean respondWithJsonLd = respondWithJsonLd(request);
         return ok(JacksonHelper.collectionToTree(roots.stream()
                         .map(e -> respondWithJsonLd ? adornMofObject(e, request, metamodelProvider, environment, projectId, commitId) : e)
@@ -135,4 +182,24 @@ public Result getRootsByProjectIdCommitId(UUID projectId, UUID commitId, Http.Re
     static boolean respondWithJsonLd(Http.Request request) {
         return request.accepts(JSONLD_MIME_TYPE);
     }
+
+    protected static char CURSOR_SEPARATOR = '|';
+
+    protected static UUID fromCursor(String cursor) throws IllegalArgumentException {
+        byte[] decoded = Base64.getUrlDecoder().decode(cursor);
+        int separatorIndex = Bytes.indexOf(decoded, (byte) CURSOR_SEPARATOR);
+        if (separatorIndex < 0) {
+            throw new IllegalArgumentException("Cursor separator missing");
+        }
+        return UUID.fromString(
+                new String(decoded, separatorIndex + 1, decoded.length - separatorIndex - 1)
+        );
+    }
+
+    protected static String toCursor(UUID id) throws IllegalArgumentException {
+        String unencoded = String.valueOf(Instant.now().toEpochMilli()) +
+                CURSOR_SEPARATOR +
+                id.toString();
+        return Base64.getUrlEncoder().withoutPadding().encodeToString(unencoded.getBytes());
+    }
 }
diff --git a/app/controllers/QueryController.java b/app/controllers/QueryController.java
@@ -106,7 +106,7 @@ public Result getQueryResultsByProjectIdQuery(UUID projectId, @SuppressWarnings(
     }
 
     private Result buildResponse(QueryService.QueryResults result, UUID projectId, Http.Request request) {
-        Set<Element> elements = result.getElements();
+        List<Element> elements = result.getElements();
         AllowedPropertyFilter filter = result.getPropertyFilter();
         boolean respondWithJsonLd = ElementController.respondWithJsonLd(request);
         JsonNode json = JacksonHelper.collectionToTree(elements.stream()
diff --git a/app/dao/ElementDao.java b/app/dao/ElementDao.java
@@ -25,17 +25,17 @@
 import org.omg.sysml.metamodel.Element;
 import org.omg.sysml.query.Query;
 
+import java.util.List;
 import java.util.Optional;
-import java.util.Set;
 import java.util.UUID;
 
 public interface ElementDao extends Dao<Element> {
 
-    Set<Element> findAllByCommit(Commit commit);
+    List<Element> findAllByCommit(Commit commit, UUID after, UUID before, int maxResults);
 
     Optional<Element> findByCommitAndId(Commit commit, UUID id);
 
-    Set<Element> findRootsByCommit(Commit commit);
+    List<Element> findRootsByCommit(Commit commit);
 
-    Set<Element> findByCommitAndQuery(Commit commit, Query query);
+    List<Element> findByCommitAndQuery(Commit commit, Query query);
 }
diff --git a/app/dao/impl/jpa/JpaElementDao.java b/app/dao/impl/jpa/JpaElementDao.java
@@ -47,6 +47,7 @@
 import javax.persistence.EntityManager;
 import javax.persistence.EntityTransaction;
 import javax.persistence.NoResultException;
+import javax.persistence.TypedQuery;
 import javax.persistence.criteria.*;
 import java.beans.PropertyDescriptor;
 import java.util.*;
@@ -101,7 +102,9 @@ public List<Element> findAll() {
             CriteriaQuery<MofObjectImpl> query = builder.createQuery(MofObjectImpl.class);
             Root<MofObjectImpl> root = query.from(MofObjectImpl.class);
             query.select(root).where(getTypeExpression(builder, root));
-            return em.createQuery(query).getResultStream().map(o -> (Element) o).collect(Collectors.toList());
+            return em.createQuery(query).getResultStream()
+                    .map(o -> (Element) o)
+                    .collect(Collectors.toList());
         });
     }
 
@@ -112,21 +115,50 @@ public void deleteAll() {
             CriteriaDelete<MofObjectImpl> query = builder.createCriteriaDelete(MofObjectImpl.class);
             Root<MofObjectImpl> root = query.from(MofObjectImpl.class);
             query.where(getTypeExpression(builder, root));
-            return ((Stream<?>) em.createQuery(query).getResultStream()).map(o -> (Element) o).collect(Collectors.toList());
+            return ((Stream<?>) em.createQuery(query).getResultStream())
+                    .map(o -> (Element) o)
+                    .collect(Collectors.toList());
         });
     }
 
-    @Override
-    public Set<Element> findAllByCommit(Commit commit) {
+    public List<Element> findAllByCommit(Commit commit, UUID after, UUID before, int maxResults) {
         return jpaManager.transact(em -> {
             // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods.
             Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
-            return getCommitIndex(c, em).getWorkingElementVersions().stream()
+            CommitIndex commitIndex = getCommitIndex(c, em);
+
+            CriteriaBuilder builder = em.getCriteriaBuilder();
+            CriteriaQuery<ElementVersionImpl> query = builder.createQuery(ElementVersionImpl.class);
+            Root<CommitIndexImpl> commitIndexRoot = query.from(CommitIndexImpl.class);
+            SetJoin<CommitIndexImpl, ElementVersionImpl> workingElementVersionsJoin = commitIndexRoot.join(CommitIndexImpl_.workingElementVersions);
+            Join<ElementVersionImpl, ElementIdentityImpl> elementIdentityJoin = workingElementVersionsJoin.join(ElementVersionImpl_.identity);
+            query.select(workingElementVersionsJoin);
+            Expression<Boolean> whereExpression = builder.equal(commitIndexRoot.get(CommitIndexImpl_.id), commitIndex.getId());
+            if (after != null) {
+                whereExpression = builder.and(whereExpression, builder.greaterThan(elementIdentityJoin.get(ElementIdentityImpl_.id), after));
+            }
+            if (before != null) {
+                whereExpression = builder.and(whereExpression, builder.lessThan(elementIdentityJoin.get(ElementIdentityImpl_.id), before));
+            }
+            query.where(whereExpression);
+            boolean flip = after == null && before != null;
+            Function<Path<UUID>, Order> orderFunction = flip ? builder::desc : builder::asc;
+            query.orderBy((orderFunction).apply(elementIdentityJoin.get(ElementIdentityImpl_.id)));
+            TypedQuery<ElementVersionImpl> typedQuery = em.createQuery(query);
+            if (maxResults >= 0) {
+                typedQuery.setMaxResults(maxResults);
+            }
+            List<Element> result = typedQuery
+                    .getResultStream()
                     .map(ElementVersion::getData)
                     .filter(mof -> mof instanceof Element)
                     .map(mof -> (Element) mof)
                     .map(PROXY_RESOLVER)
-                    .collect(Collectors.toSet());
+                    .collect(Collectors.toList());
+            if (flip) {
+                Collections.reverse(result);
+            }
+            return result;
         });
     }
 
@@ -159,7 +191,7 @@ public Optional<Element> findByCommitAndId(Commit commit, UUID id) {
     }
 
     @Override
-    public Set<Element> findRootsByCommit(Commit commit) {
+    public List<Element> findRootsByCommit(Commit commit) {
         return jpaManager.transact(em -> {
             // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods.
             Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
@@ -169,12 +201,12 @@ public Set<Element> findRootsByCommit(Commit commit) {
                     .map(mof -> (Element) mof)
                     .filter(element -> element.getOwner() == null)
                     .map(PROXY_RESOLVER)
-                    .collect(Collectors.toSet());
+                    .collect(Collectors.toList());
         });
     }
 
     @Override
-    public Set<Element> findByCommitAndQuery(Commit commit, Query query) {
+    public List<Element> findByCommitAndQuery(Commit commit, Query query) {
         return jpaManager.transact(em -> {
             // TODO Commit is detached at this point. This ternary mitigates by requerying for the Commit in this transaction. A better solution would be moving transaction handling up to service layer (supported by general wisdom) and optionally migrating to using Play's @Transactional/JPAApi. Pros would include removal of repetitive transaction handling at the DAO layer and ability to interface with multiple DAOs in the same transaction (consistent view). Cons include increased temptation to keep transaction open for longer than needed, e.g. during JSON serialization due to the convenience of @Transactional (deprecated in >= 2.8.x), and the service, a higher level of abstraction, becoming aware of transactions. An alternative would be DAO-to-DAO calls (generally discouraged) and delegating to non-transactional versions of methods.
             Commit c = em.contains(commit) ? commit : em.find(metamodelProvider.getImplementationClass(Commit.class), commit.getId());
@@ -186,7 +218,7 @@ public Set<Element> findByCommitAndQuery(Commit commit, Query query) {
                     .map(mof -> (Element) mof)
                     .filter(constrain(q.getWhere()))
                     .map(PROXY_RESOLVER)
-                    .collect(Collectors.toSet());
+                    .collect(Collectors.toList());
         });
     }
 
diff --git a/app/services/ElementService.java b/app/services/ElementService.java
@@ -30,8 +30,8 @@
 import javax.inject.Inject;
 import javax.inject.Singleton;
 import java.util.Collections;
+import java.util.List;
 import java.util.Optional;
-import java.util.Set;
 import java.util.UUID;
 
 @Singleton
@@ -53,21 +53,16 @@ public Optional<Element> create(Element element) {
         return element.getIdentifier() != null ? dao.update(element) : dao.persist(element);
     }
 
-    public Set<Element> getByCommitId(UUID commitId) {
-        return commitDao.findById(commitId)
-                .map(dao::findAllByCommit).orElse(Collections.emptySet());
-    }
-
     public Optional<Element> getByCommitIdAndId(UUID commitId, UUID elementId) {
         return commitDao.findById(commitId)
                 .flatMap(m -> dao.findByCommitAndId(m, elementId));
     }
 
-    public Set<Element> getElementsByProjectIdCommitId(UUID projectId, UUID commitId) {
+    public List<Element> getElementsByProjectIdCommitId(UUID projectId, UUID commitId, UUID after, UUID before, int maxResults) {
         return projectDao.findById(projectId)
                 .flatMap(project -> commitDao.findByProjectAndId(project, commitId))
-                .map(dao::findAllByCommit)
-                .orElse(Collections.emptySet());
+                .map(commit -> dao.findAllByCommit(commit, after, before, maxResults))
+                .orElse(Collections.emptyList());
     }
 
     public Optional<Element> getElementsByProjectIdCommitIdElementId(UUID projectId, UUID commitId, UUID elementId) {
@@ -76,10 +71,10 @@ public Optional<Element> getElementsByProjectIdCommitIdElementId(UUID projectId,
                 .flatMap(commit -> dao.findByCommitAndId(commit, elementId));
     }
 
-    public Set<Element> getRootsByProjectIdCommitId(UUID projectId, UUID commitId) {
+    public List<Element> getRootsByProjectIdCommitId(UUID projectId, UUID commitId) {
         return projectDao.findById(projectId)
                 .flatMap(project -> commitDao.findByProjectAndId(project, commitId))
                 .map(dao::findRootsByCommit)
-                .orElse(Collections.emptySet());
+                .orElse(Collections.emptyList());
     }
 }
diff --git a/app/services/QueryService.java b/app/services/QueryService.java
@@ -34,7 +34,10 @@
 import javax.annotation.Nullable;
 import javax.inject.Inject;
 import javax.inject.Singleton;
-import java.util.*;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.UUID;
 import java.util.function.Function;
 
 @Singleton
@@ -90,17 +93,17 @@ private QueryResults getQueryResults(UUID projectId, Function<Project, Query> qu
     }
 
     public static class QueryResults {
-        private final Set<Element> elements;
+        private final List<Element> elements;
         private final Commit commit;
         private final AllowedPropertyFilter propertyFilter;
 
-        public QueryResults(Set<Element> elements, Commit commit, AllowedPropertyFilter propertyFilter) {
+        public QueryResults(List<Element> elements, Commit commit, AllowedPropertyFilter propertyFilter) {
             this.elements = elements;
             this.commit = commit;
             this.propertyFilter = propertyFilter;
         }
 
-        public Set<Element> getElements() {
+        public List<Element> getElements() {
             return elements;
         }
 
diff --git a/public/swagger/openapi.yaml b/public/swagger/openapi.yaml
@@ -217,6 +217,21 @@ paths:
         type: string
         format: uuid
         required: true
+      - name: page[after]
+        in: query
+        description: Page after
+        type: string
+        required: false
+      - name: page[before]
+        in: query
+        description: Page before
+        type: string
+        required: false
+      - name: page[size]
+        in: query
+        description: Page size
+        type: integer
+        required: false
     get:
       tags:
         - Element

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ public Result getQueryResultsByProjectIdQuery(UUID projectId, @SuppressWarnings(`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`private Result buildResponse(QueryService.QueryResults result, UUID projectId, Http.Request request) {`
`109`		`- Set<Element> elements = result.getElements();`
	`109`	`+ List<Element> elements = result.getElements();`
`110`	`110`	`AllowedPropertyFilter filter = result.getPropertyFilter();`
`111`	`111`	`boolean respondWithJsonLd = ElementController.respondWithJsonLd(request);`
`112`	`112`	`JsonNode json = JacksonHelper.collectionToTree(elements.stream()`