Include Support to restrict

CHANGELOG.adoc

@@ -12,6 +12,11 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version
 
 - Define Java 21 as the minimum version to run JNoSQL
 
+=== Added
+
+- Include support to Restriction interface
+
+
 == [1.1.8] - 2025-05-21
 
 === Removed

jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxy.java

@@ -14,7 +14,7 @@
  */
 package org.eclipse.jnosql.mapping.core.query;
 
-import jakarta.data.exceptions.MappingException;
+import jakarta.data.restrict.Restriction;
 import jakarta.enterprise.inject.spi.CDI;
 import org.eclipse.jnosql.mapping.core.repository.ThrowingSupplier;
 import org.eclipse.jnosql.mapping.metadata.EntityMetadata;
@@ -139,6 +139,18 @@ public abstract class AbstractRepositoryProxy<T, K> implements InvocationHandler
      */
     protected abstract Object executeParameterBased(Object instance, Method method, Object[] params);
 
+
+    /**
+     * Executes a delete operation based on the method and parameters, specifically for methods that
+     * involve a {@link jakarta.data.restrict.Restriction} as a parameter.
+     *
+     * @param instance The instance on which the method was invoked.
+     * @param method   The method being invoked, representing the delete operation.
+     * @param params   The parameters of the method, including the restriction.
+     * @return The result of the delete operation.
+     */
+    protected abstract Object executeDeleteRestriction(Object instance, Method method, Object[] params);
+
     @Override
     public Object invoke(Object instance, Method method, Object[] params) throws Throwable {
 
@@ -169,8 +181,6 @@ public Object invoke(Object instance, Method method, Object[] params) throws Thr
             case DEFAULT_METHOD -> {
                 return unwrapInvocationTargetException(() -> InvocationHandler.invokeDefault(instance, method, params));
             }
-            case ORDER_BY ->
-                    throw new MappingException("Eclipse JNoSQL has not support for method that has OrderBy annotation");
             case QUERY -> {
                 return unwrapInvocationTargetException(() ->  executeQuery(instance, method, params));
             }
@@ -188,6 +198,9 @@ public Object invoke(Object instance, Method method, Object[] params) throws Thr
                 return unwrapInvocationTargetException(() -> INSERT.invoke(new AnnotationOperation.Operation(method, params, repository())));
             }
             case DELETE -> {
+                if(params.length > 0 && params[0] instanceof Restriction<?>) {
+                    return unwrapInvocationTargetException(() -> executeDeleteRestriction(instance, method, params));
+                }
                 return unwrapInvocationTargetException(() -> DELETE.invoke(new AnnotationOperation.Operation(method, params, repository())));
             }
             case UPDATE -> {

jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/query/RepositoryType.java

@@ -20,7 +20,6 @@
 import jakarta.data.repository.Delete;
 import jakarta.data.repository.Find;
 import jakarta.data.repository.Insert;
-import jakarta.data.repository.OrderBy;
 import jakarta.data.repository.Query;
 import jakarta.data.repository.Save;
 import jakarta.data.repository.Update;
@@ -79,10 +78,6 @@ public enum RepositoryType {
      * The method that belongs to the interface using a custom repository.
      */
     CUSTOM_REPOSITORY(""),
-    /**
-     * Method that has {@link jakarta.data.repository.OrderBy} annotation
-     */
-    ORDER_BY(""),
     /**
      * Method that has {@link Query} annotation
      */
@@ -162,19 +157,19 @@ public static RepositoryType of(Method method, Class<?> repositoryType) {
         if (method.getReturnType().equals(CursoredPage.class)) {
             return CURSOR_PAGINATION;
         }
-        String methodName = method.getName();
-        if (FIND_ALL.keyword.equals(methodName)) {
-            return FIND_ALL;
-        }
-        if (method.getAnnotationsByType(OrderBy.class).length > 0) {
-            return method.getAnnotation(Find.class) == null? ORDER_BY: PARAMETER_BASED;
-        }
+
         Predicate<RepositoryType> hasAnnotation = a -> method.getAnnotation(a.annotation) != null;
         if (OPERATION_ANNOTATIONS.stream().anyMatch(hasAnnotation)) {
             return OPERATION_ANNOTATIONS.stream()
                     .filter(hasAnnotation)
                     .findFirst().orElseThrow();
         }
+
+        String methodName = method.getName();
+        if (FIND_ALL.keyword.equals(methodName)) {
+            return FIND_ALL;
+        }
+
         return KEY_WORLD_METHODS.stream()
                 .filter(k -> methodName.startsWith(k.keyword))
                 .findFirst()

jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/SpecialParameters.java

@@ -19,6 +19,7 @@
 import jakarta.data.Order;
 import jakarta.data.page.PageRequest;
 import jakarta.data.Sort;
+import jakarta.data.restrict.Restriction;
 
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -33,17 +34,20 @@
  * to apply pagination and sorting to your queries dynamically.
  */
 public final class SpecialParameters {
-    static final SpecialParameters EMPTY = new SpecialParameters(null, null, Collections.emptyList());
+    static final SpecialParameters EMPTY = new SpecialParameters(null, null, Collections.emptyList(), null);
 
     private final PageRequest pageRequest;
 
     private final List<Sort<?>> sorts;
     private final Limit limit;
 
-    private SpecialParameters(PageRequest pageRequest, Limit limit, List<Sort<?>> sorts) {
+    private final Restriction<?> restriction;
+
+    private SpecialParameters(PageRequest pageRequest, Limit limit, List<Sort<?>> sorts, Restriction<?> restriction) {
         this.pageRequest = pageRequest;
         this.sorts = sorts;
         this.limit = limit;
+        this.restriction = restriction;
     }
 
     /**
@@ -71,7 +75,7 @@ public List<Sort<?>> sorts() {
      * @return when there is no sort and PageRequest
      */
     public boolean isEmpty() {
-        return this.sorts.isEmpty() && pageRequest == null && limit == null;
+        return this.sorts.isEmpty() && pageRequest == null && limit == null && restriction == null;
     }
 
     /**
@@ -89,7 +93,7 @@ public boolean isSortEmpty() {
      * @return true if only have {@link PageRequest}
      */
     public boolean hasOnlySort() {
-        return pageRequest == null && !sorts.isEmpty();
+        return pageRequest == null && !sorts.isEmpty() && restriction == null && limit == null;
     }
 
     /**
@@ -101,35 +105,47 @@ public Optional<Limit> limit() {
         return Optional.ofNullable(limit);
     }
 
+    /**
+     * Returns the Restriction instance or {@link Optional#empty()}
+     *
+     * @return the Restriction instance or {@link Optional#empty()}
+     */
+    public Optional<Restriction<?>> restriction() {
+        return Optional.ofNullable(restriction);
+    }
+
     @Override
     public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        }
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
         SpecialParameters that = (SpecialParameters) o;
-        return Objects.equals(pageRequest, that.pageRequest) && Objects.equals(sorts, that.sorts);
+        return Objects.equals(pageRequest, that.pageRequest)
+                && Objects.equals(sorts, that.sorts)
+                && Objects.equals(limit, that.limit)
+                && Objects.equals(restriction, that.restriction);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(pageRequest, sorts);
+        return Objects.hash(pageRequest, sorts, limit, restriction);
     }
 
     @Override
     public String toString() {
         return "SpecialParameters{" +
-                "PageRequest=" + pageRequest +
+                "pageRequest=" + pageRequest +
                 ", sorts=" + sorts +
+                ", limit=" + limit +
+                ", restriction=" + restriction +
                 '}';
     }
 
     static SpecialParameters of(Object[] parameters, Function<String, String> sortParser) {
         List<Sort<?>> sorts = new ArrayList<>();
         PageRequest pageRequest = null;
         Limit limit = null;
+        Restriction<?> restriction = null;
         for (Object parameter : parameters) {
             if (parameter instanceof Sort<?> sort) {
                 sorts.add(mapper(sort, sortParser));
@@ -141,6 +157,8 @@ static SpecialParameters of(Object[] parameters, Function<String, String> sortPa
                 Arrays.stream(sortArray).map(s -> mapper(s, sortParser)).forEach(sorts::add);
             } else if (parameter instanceof PageRequest request) {
                pageRequest = request;
+            } else if (parameter instanceof Restriction<?> restrictionParameter) {
+                restriction = restrictionParameter;
             }else {
                 if (parameter instanceof Iterable<?> iterable) {
                     for (Object value : iterable) {
@@ -151,7 +169,7 @@ static SpecialParameters of(Object[] parameters, Function<String, String> sortPa
                 }
             }
         }
-        return new SpecialParameters(pageRequest, limit, sorts);
+        return new SpecialParameters(pageRequest, limit, sorts, restriction);
     }
 
     /**
@@ -189,6 +207,7 @@ public static boolean isSpecialParameter(Class<?> parameter) {
                 || Limit.class.isAssignableFrom(parameter)
                 || Order.class.isAssignableFrom(parameter)
                 || PageRequest.class.isAssignableFrom(parameter)
+                || Restriction.class.isAssignableFrom(parameter)
                 || parameter.isArray() && Sort.class.isAssignableFrom(parameter.getComponentType());
     }
 

jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/query/AbstractRepositoryProxyTest.java

@@ -14,6 +14,7 @@
  */
 package org.eclipse.jnosql.mapping.core.query;
 
+import jakarta.data.restrict.Restriction;
 import org.junit.jupiter.api.Test;
 
 import java.lang.reflect.Method;
@@ -90,4 +91,11 @@ void shouldInvokeThrowsMappingException() throws Throwable {
         assertThrows(UnsupportedOperationException.class, () -> proxy.invoke(proxy, method, new Object[]{}));
     }
 
+    @Test
+    void shouldExecuteDeleteRestriction() throws Throwable {
+        Method method = TestRepository.class.getMethod("delete", Restriction.class);
+        Object result = proxy.invoke(proxy, method, new Object[]{(Restriction<String>) () -> null});
+        assertEquals("executeDeleteRestriction", result);
+    }
+
 }