Added code tidy comments

src/main/java/io/stargate/sgv2/jsonapi/api/model/command/clause/filter/ComparisonExpression.java

@@ -23,6 +23,7 @@ public class ComparisonExpression {
 
   @Valid @NotEmpty private List<FilterOperation<?>> filterOperations;
 
+  // TIDY Why are there DB filters in the API layer, these should only be used by operations.
   private List<DBFilterBase> dbFilters;
 
   public List<DBFilterBase> getDbFilters() {

src/main/java/io/stargate/sgv2/jsonapi/api/model/command/clause/filter/LogicalExpression.java

@@ -8,6 +8,11 @@
  * you can do this, compare equals to a literal {"username" : "aaron"} This is a shortcut for
  * {"username" : {"$eq" : "aaron"}} In here we expand the shortcut into a canonical long form, so it
  * is all the same.
+ *
+ * <p>TIDY: this class is part of the public API, and yet it is also getting handed into the
+ * operations and has some serious business logic in it. The is breaking the rules of the
+ * architecture, the public API classes should be basic POJO with some validation. We need another
+ * class to represent the logic in here
  */
 public class LogicalExpression {
 

src/main/java/io/stargate/sgv2/jsonapi/service/operation/collections/ExpressionBuilder.java

@@ -14,6 +14,8 @@
 import java.util.List;
 import java.util.stream.Collectors;
 
+// TIDY: this class needs a large refactor and tidy, it is breaking the archiecture by having
+// classes from the API package use DBFilters from the Operations, and vice-verse
 public class ExpressionBuilder {
 
   public static List<Expression<BuiltCondition>> buildExpressions(

src/main/java/io/stargate/sgv2/jsonapi/service/resolver/matcher/CaptureExpression.java

@@ -3,5 +3,6 @@
 import io.stargate.sgv2.jsonapi.api.model.command.clause.filter.FilterOperation;
 import java.util.List;
 
+// TIDY What does this do ?
 public record CaptureExpression(
     Object marker, List<FilterOperation<?>> filterOperations, String path) {}

src/main/java/io/stargate/sgv2/jsonapi/service/resolver/matcher/FilterMatcher.java

@@ -58,6 +58,7 @@ public Optional<LogicalExpression> apply(T command) {
     return matchStrategyCounter.applyStrategy(strategy, filter);
   }
 
+  // TIDY: Why is this public ?
   public void captureRecursive(
       LogicalExpression expression,
       List<Capture> unmatchedCaptures,
@@ -74,6 +75,7 @@ public void captureRecursive(
         Capture capture = captureIter.next();
         List<FilterOperation<?>> matched = capture.match(comparisonExpression);
         if (!matched.isEmpty()) {
+          // TIDY - this must change, no DB Filters that come from the Operator level into the API
           comparisonExpression.setDBFilters(
               resolveFunction.apply(
                   new CaptureExpression(capture.marker, matched, comparisonExpression.getPath())));
@@ -147,6 +149,26 @@ public FilterMatcher<T> compareValues(
     }
   }
 
+  // TIDY - refactor this class, unclear why the original needed to change
+  // it is based on some original code, but is duplicating counting
+  // that was done by looking at lists of captures and expressions
+  //
+  // Or if it should stay, implement as a strategy that has sublcasses the implement the bahviour
+  // original below
+  //      switch (strategy) {
+  //    case STRICT:
+  //      if (unmatchedCaptures.isEmpty() && unmatchedExpressions.isEmpty()) {
+  //        // everything group and expression matched
+  //        return Optional.of(captures);
+  //      }
+  //      break;
+  //    case GREEDY:
+  //      if (unmatchedExpressions.isEmpty()) {
+  //        // everything expression matched, some captures may not match
+  //        return Optional.of(captures);
+  //      }
+  //      break;
+  //  }
   public static final class MatchStrategyCounter {
 
     private int unmatchedCaptureCount;