enhance the implementation and interface of extractFields

Author: mhewedy

README.md

@@ -63,7 +63,7 @@ For spring-boot 3.x:
 <dependency>
   <groupId>com.github.mhewedy</groupId>
   <artifactId>spring-data-jpa-mongodb-expressions</artifactId>
-  <version>0.1.8</version>
+  <version>0.1.9</version>
 </dependency>
 
 ```

docs/include.adoc

@@ -1,5 +1,5 @@
 :author: Mohammad Hewedy, The Spring Data JPA MongoDB Expressions Team
-:revnumber: 0.1.8
+:revnumber: 0.1.9
 :jsondir: ../src/test/resources
 :sectlinks: true
 :source-highlighter: highlight.js

pom.xml

@@ -12,7 +12,7 @@
 
     <groupId>com.github.mhewedy</groupId>
     <artifactId>spring-data-jpa-mongodb-expressions</artifactId>
-    <version>0.1.8</version>
+    <version>0.1.9</version>
     <name>spring-data-jpa-mongodb-expressions</name>
     <description>Spring Data JPA Mongodb Expressions</description>
 

src/main/java/com/github/mhewedy/expressions/Expressions.java

@@ -199,11 +199,11 @@ List<Expression> getExpressions() {
     }
 
     /**
-     * Returns this object as as list of {@link Expression} to be passed to
+     * Returns this object as list of {@link Expression} to be passed to
      * Spring Data Specification builder {@link ExpressionsPredicateBuilder}
      */
     @SuppressWarnings({"unchecked"})
-    private List<Expression> getExpressions(Map<String, Object> map) {
+    private static List<Expression> getExpressions(Map<String, Object> map) {
 
         List<Expression> expressions = new ArrayList<>();
 
@@ -258,12 +258,13 @@ private static Map<String, Object> map(String key, Object value) {
     }
 
     /**
-     * Extracts all the field names (keys) from the current {@code Expressions} object,
-     * including nested fields within `$and` and `$or` compound operators.
+     * Extracts all field names and their corresponding values from the current
+     * {@code Expressions} object, including nested fields within `$and` and `$or`
+     * compound operators.
      * <p>
      * This method traverses the structure of the {@code Expressions} object recursively.
-     * If a compound operator (`$and` or `$or`) is encountered, it extracts fields from
-     * all nested expressions.
+     * If a compound operator (`$and` or `$or`) is encountered, it extracts fields and
+     * values from all nested expressions.
      * </p>
      * <p>
      * Example:
@@ -277,28 +278,34 @@ private static Map<String, Object> map(String key, Object value) {
      *     ]
      * }
      * </pre>
-     * The resulting list of fields will be:
+     * The resulting map of fields will be:
      * <pre>
-     * ["firstName", "lastName", "age"]
+     * {
+     *     "firstName": "John",
+     *     "lastName": "Doe",
+     *     "age": 30
+     * }
      * </pre>
      *
-     * @return a list of field names present in the current {@code Expressions} object, including nested fields.
+     * @return a map containing field names as keys and their corresponding values, including nested fields.
      */
-    @SuppressWarnings({"unchecked"})
-    public static List<String> extractFields(Map<String, Object> expressions) {
-        List<String> list = new ArrayList<>();
+    public Map<String, Object> extractFields() {
+        return extractFields(getExpressions(this));
+    }
 
-        for (Map.Entry<String, Object> entry : expressions.entrySet()) {
-            String key = entry.getKey();
-            if (key.equals($and.name()) || key.equals($or.name())) {
-                List<Object> values = (List<Object>) entry.getValue();
-                for (Object value : values) {
-                    list.addAll(extractFields((Map<String, Object>) value));
-                }
-            } else {
-                list.add(key);
+    private static Map<String, Object> extractFields(List<Expression> expressionList) {
+        var map = new HashMap<String, Object>();
+        for (Expression expression : expressionList) {
+            if (expression instanceof SingularExpression singularExpression) {
+                map.put(singularExpression.field, singularExpression.value);
+            } else if (expression instanceof ListExpression listExpression) {
+                map.put(listExpression.field, listExpression.values);
+            } else if (expression instanceof AndExpression andExpression) {
+                map.putAll(extractFields(andExpression.expressions));
+            } else if (expression instanceof OrExpression andExpression) {
+                map.putAll(extractFields(andExpression.expressions));
             }
         }
-        return list;
+        return map;
     }
 }

src/test/java/com/github/mhewedy/expressions/ExpressionsTest.java

@@ -5,10 +5,13 @@
 import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
+import java.util.Set;
 
 import static com.github.mhewedy.expressions.Expression.*;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatList;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -98,16 +101,16 @@ void testExtractFieldsWithCompoundOperatorsJSON() throws Exception {
                 }
                 """;
         Expressions expressions = objectMapper.readValue(json, Expressions.class);
-        List<String> fields = Expressions.extractFields(expressions);
+        Set<String> fields = expressions.extractFields().keySet();
 
-        assertEquals(Arrays.asList("firstName", "lastName", "age"), fields);
+        assertEquals(Set.of("firstName", "lastName", "age"), fields);
     }
 
     @Test
     void testExtractFieldsWithEmptyJSON() throws Exception {
         String json = "{}";
         Expressions expressions = objectMapper.readValue(json, Expressions.class);
-        List<String> fields = Expressions.extractFields(expressions);
+        Set<String> fields = expressions.extractFields().keySet();
 
         assertTrue(fields.isEmpty());
     }
@@ -123,9 +126,9 @@ void testExtractFieldsWithNestedAndOperatorJSON() throws Exception {
                 }
                 """;
         Expressions expressions = objectMapper.readValue(json, Expressions.class);
-        List<String> fields = Expressions.extractFields(expressions);
+        Set<String> fields = expressions.extractFields().keySet();
 
-        assertEquals(Arrays.asList("country", "state"), fields);
+        assertEquals(Set.of("country", "state"), fields);
     }
 
     @Test
@@ -146,8 +149,10 @@ void testExtractFieldsWithMultipleNestedOperatorsJSON() throws Exception {
                 }
                 """;
         Expressions expressions = objectMapper.readValue(json, Expressions.class);
-        List<String> fields = Expressions.extractFields(expressions);
+        Set<String> fields = expressions.extractFields().keySet();
+        List<Object> values = expressions.extractFields().values().stream().toList();
 
-        assertEquals(Arrays.asList("city", "zipcode", "city.country"), fields);
+        assertEquals(Set.of("city", "zipcode", "city.country"), fields);
+        assertThatList(values).containsExactlyInAnyOrder("New York", "10001", "USA");
     }
 }