apply some refactors

Signed-off-by: Vinay Krishna Pudyodu <vinkrish.neo@gmail.com>

Author: vinaykpud

sandbox/plugins/dsl-query-executor/src/main/java/org/opensearch/dsl/converter/CollationResolver.java

@@ -57,42 +57,62 @@ public static List<RelFieldCollation> resolve(AggregationMetadata metadata, RelD
      * then looks up the field's post-agg schema index(es) to create collations.
      * CompoundOrders are never seen here — they are flattened by AggregationMetadataBuilder.addBucketOrder.
      */
+    /** Resolved field name and sort direction from a BucketOrder. */
+    private record OrderTarget(String fieldName, boolean ascending) {
+    }
+
     private static void resolveOrder(BucketOrder order, Map<String, List<Integer>> postAggFieldIndex, List<RelFieldCollation> collations)
         throws ConversionException {
-        String fieldName;
-        boolean ascending;
+        // Determine which field to sort on and in which direction
+        OrderTarget target = resolveOrderTarget(order);
 
-        if (order instanceof InternalOrder.Aggregation aggOrder) {
-            fieldName = aggOrder.path().toString();
-            ascending = aggOrder.equals(BucketOrder.aggregation(fieldName, true));
-        } else if (InternalOrder.isKeyOrder(order)) {
-            fieldName = "_key";
-            ascending = InternalOrder.isKeyAsc(order);
-        } else if (InternalOrder.isCountDesc(order)) {
-            fieldName = "_count";
-            ascending = false;
-        } else if (order.equals(BucketOrder.count(true))) {
-            fieldName = "_count";
-            ascending = true;
-        } else {
-            throw new ConversionException("Unsupported BucketOrder type: " + order.getClass().getName());
-        }
-
-        List<Integer> indices = postAggFieldIndex.get(fieldName);
+        // Look up the field's post-agg schema index(es); _key may resolve to multiple indices
+        List<Integer> indices = postAggFieldIndex.get(target.fieldName);
         if (indices == null) {
-            throw new ConversionException("Sort field '" + fieldName + "' not found. Available: " + postAggFieldIndex.keySet());
+            throw new ConversionException("Sort field '" + target.fieldName + "' not found. Available: " + postAggFieldIndex.keySet());
         }
 
-        RelFieldCollation.Direction direction = ascending ? RelFieldCollation.Direction.ASCENDING : RelFieldCollation.Direction.DESCENDING;
-        RelFieldCollation.NullDirection nullDirection = ascending
+        // Map direction: ASC nulls last, DESC nulls first (matches OpenSearch default)
+        RelFieldCollation.Direction direction = target.ascending
+            ? RelFieldCollation.Direction.ASCENDING
+            : RelFieldCollation.Direction.DESCENDING;
+        RelFieldCollation.NullDirection nullDirection = target.ascending
             ? RelFieldCollation.NullDirection.LAST
             : RelFieldCollation.NullDirection.FIRST;
 
+        // Create a collation per index (one for most fields, multiple for _key with nested GROUP BY)
         for (int idx : indices) {
             collations.add(new RelFieldCollation(idx, direction, nullDirection));
         }
     }
 
+    private static OrderTarget resolveOrderTarget(BucketOrder order) throws ConversionException {
+        if (order instanceof InternalOrder.Aggregation aggOrder) {
+            return resolveMetricOrder(aggOrder);
+        } else if (InternalOrder.isKeyOrder(order)) {
+            return resolveKeyOrder(order);
+        } else if (InternalOrder.isCountDesc(order) || order.equals(BucketOrder.count(true))) {
+            return resolveCountOrder(order);
+        }
+        throw new ConversionException("Unsupported BucketOrder type: " + order.getClass().getName());
+    }
+
+    // InternalOrder.Aggregation.order is private with no accessor; equality check is the only way
+    private static OrderTarget resolveMetricOrder(InternalOrder.Aggregation aggOrder) {
+        String fieldName = aggOrder.path().toString();
+        boolean ascending = aggOrder.equals(BucketOrder.aggregation(fieldName, true));
+        return new OrderTarget(fieldName, ascending);
+    }
+
+    private static OrderTarget resolveKeyOrder(BucketOrder order) {
+        return new OrderTarget("_key", InternalOrder.isKeyAsc(order));
+    }
+
+    // no InternalOrder.isCountAsc() helper; count desc is checked via isCountDesc(), count asc via equality
+    private static OrderTarget resolveCountOrder(BucketOrder order) {
+        return new OrderTarget("_count", !InternalOrder.isCountDesc(order));
+    }
+
     /**
      * Builds a map from sort field names to their indices in the post-aggregation schema.
      *

sandbox/plugins/dsl-query-executor/src/main/java/org/opensearch/dsl/converter/ProjectConverter.java

@@ -101,6 +101,8 @@ private static Pattern toWildcardRegex(String wildcardPattern) {
         return Pattern.compile(regex.toString());
     }
 
+    // Unlike includes (resolveField throws for unknown fields), excludes silently ignore
+    // nonexistent field names — consistent with OpenSearch core behavior.
     private Set<String> buildExcludeSet(String[] excludes, RelDataType rowType) {
         Set<String> excludeSet = new HashSet<>();
         for (String pattern : excludes) {