feat: Sorting for search results

client/src/main/java/com/tigrisdata/db/client/FieldSort.java

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2022 Tigris Data, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tigrisdata.db.client;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/** Represents a collection field and corresponding sort order */
+public final class FieldSort implements TigrisSort {
+
+  private final String fieldName;
+  private final SortOrder operator;
+  private Map<String, Object> cachedMap;
+
+  FieldSort(String fieldName, SortOrder op) {
+    this.fieldName = fieldName;
+    this.operator = op;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public Map<String, Object> getOrder() {
+    if (cachedMap == null) {
+      cachedMap =
+          Collections.unmodifiableMap(
+              new HashMap<String, String>() {
+                {
+                  put(fieldName, operator.getOperator());
+                }
+              });
+    }
+    return cachedMap;
+  }
+
+  /** {@inheritDoc} */
+  @Override
+  public String getFieldName() {
+    return fieldName;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+
+    FieldSort fieldSort = (FieldSort) o;
+
+    if (!Objects.equals(fieldName, fieldSort.fieldName)) {
+      return false;
+    }
+    return operator == fieldSort.operator;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = fieldName != null ? fieldName.hashCode() : 0;
+    result = 31 * result + (operator != null ? operator.hashCode() : 0);
+    return result;
+  }
+}

client/src/main/java/com/tigrisdata/db/client/Sort.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2022 Tigris Data, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tigrisdata.db.client;
+
+/** Helper class to construct {@link TigrisSort} orders */
+public final class Sort {
+  private Sort() {}
+
+  /**
+   * Creates ascending sort order for given field name
+   *
+   * @param fieldName collection field name
+   * @return constructed {@link FieldSort} of ascending order
+   */
+  public static FieldSort ascending(String fieldName) {
+    return new FieldSort(fieldName, SortOrder.ASC);
+  }
+
+  /**
+   * Creates descending sort order for given field name
+   *
+   * @param fieldName collection field name
+   * @return constructed {@link FieldSort} of descending order
+   */
+  public static FieldSort descending(String fieldName) {
+    return new FieldSort(fieldName, SortOrder.DESC);
+  }
+}

client/src/main/java/com/tigrisdata/db/client/search/SortOrder.java → client/src/main/java/com/tigrisdata/db/client/SortOrder.java

@@ -12,9 +12,19 @@
  * limitations under the License.
  */
 
-package com.tigrisdata.db.client.search;
+package com.tigrisdata.db.client;
 
-import com.tigrisdata.db.client.JSONSerializable;
+enum SortOrder {
+  ASC("$asc"),
+  DESC("$desc");
 
-/** Interface to construct sorting order for search results */
-public interface SortOrder extends JSONSerializable {}
+  private final String operator;
+
+  SortOrder(String operator) {
+    this.operator = operator;
+  }
+
+  public String getOperator() {
+    return operator;
+  }
+}

client/src/main/java/com/tigrisdata/db/client/TigrisSort.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2022 Tigris Data, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the
+ * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+ * express or implied. See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.tigrisdata.db.client;
+
+import java.util.Map;
+
+/** Represents the sorting order */
+public interface TigrisSort {
+
+  /**
+   * Sort order representation as Key, Value pairs
+   *
+   * @return non-null immutable {@link Map}
+   */
+  Map<String, Object> getOrder();
+
+  /**
+   * Gets collection field name that this order represents
+   *
+   * @return {@link String}
+   */
+  String getFieldName();
+}

client/src/main/java/com/tigrisdata/db/client/TypeConverter.java

@@ -177,8 +177,8 @@ public static Api.SearchRequest toSearchRequest(
     if (Objects.nonNull(req.getFacetQuery())) {
       builder.setFacet(ByteString.copyFromUtf8(req.getFacetQuery().toJSON(objectMapper)));
     }
-    if (Objects.nonNull(req.getSortOrders())) {
-      builder.setSort(ByteString.copyFromUtf8(req.getSortOrders().toJSON(objectMapper)));
+    if (Objects.nonNull(req.getSortingOrder())) {
+      builder.setSort(ByteString.copyFromUtf8(req.getSortingOrder().toJSON(objectMapper)));
     }
     if (Objects.nonNull(options)) {
       builder.setPage(options.getPage());

client/src/main/java/com/tigrisdata/db/client/search/FacetFieldsQuery.java

@@ -31,6 +31,7 @@ public final class FacetFieldsQuery implements FacetQuery {
   private static final FacetFieldsQuery EMPTY = newBuilder().build();
 
   private final Map<String, FacetQueryOptions> internalMap;
+  private String cachedJSON;
 
   private FacetFieldsQuery(Builder builder) {
     this.internalMap = Collections.unmodifiableMap(builder.fieldMap);
@@ -65,6 +66,9 @@ public boolean isEmpty() {
 
   @Override
   public String toJSON(ObjectMapper objectMapper) {
+    if (Objects.nonNull(cachedJSON)) {
+      return cachedJSON;
+    }
     Function<FacetQueryOptions, Map<String, String>> toOptionsMap =
         o ->
             new HashMap<String, String>() {
@@ -78,7 +82,8 @@ public String toJSON(ObjectMapper objectMapper) {
         internalMap.entrySet().stream()
             .collect(Collectors.toMap(Entry::getKey, e -> toOptionsMap.apply(e.getValue())));
     try {
-      return objectMapper.writeValueAsString(fieldOptionsMap);
+      cachedJSON = objectMapper.writeValueAsString(fieldOptionsMap);
+      return cachedJSON;
     } catch (JsonProcessingException ex) {
       throw new IllegalArgumentException("Failed to serialize FacetFields to JSON", ex);
     }

client/src/main/java/com/tigrisdata/db/client/search/SearchRequest.java

@@ -15,6 +15,7 @@
 package com.tigrisdata.db.client.search;
 
 import com.tigrisdata.db.client.TigrisFilter;
+import com.tigrisdata.db.client.TigrisSort;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
@@ -29,7 +30,7 @@ public final class SearchRequest {
   private final SearchFields searchFields;
   private final TigrisFilter filter;
   private final FacetQuery facetQuery;
-  private final SortOrder sortOrder;
+  private final SortingOrder sortOrder;
   private final List<String> includeFields;
   private final List<String> excludeFields;
 
@@ -84,9 +85,9 @@ public FacetQuery getFacetQuery() {
   /**
    * Gets the Order to sort the search results
    *
-   * @return {@link SortOrder} or null
+   * @return {@link SortingOrder} or null
    */
-  public SortOrder getSortOrders() {
+  public SortingOrder getSortingOrder() {
     return sortOrder;
   }
 
@@ -135,7 +136,7 @@ public static final class Builder {
     private TigrisFilter filter;
     private SearchFields searchFields;
     private FacetQuery facetQuery;
-    private SortOrder sortOrder;
+    private SortingOrder sortOrder;
     private final Set<String> includeFields;
     private final Set<String> excludeFields;
 
@@ -214,17 +215,29 @@ public Builder withFacetQuery(FacetQuery facetQuery) {
     }
 
     /**
-     * Optional - Sets the SortOrder to sorts search results according to specified attributes and
+     * Optional - Sets the SortingOrder to sort search results according to specified attributes and
      * indicated order
      *
-     * @param sortOrder {@link SortOrder}
+     * @param sortOrder {@link SortingOrder}
      * @return {@link SearchRequest.Builder}
      */
-    public Builder withSortOrder(SortOrder sortOrder) {
+    public Builder withSort(SortingOrder sortOrder) {
       this.sortOrder = sortOrder;
       return this;
     }
 
+    /**
+     * Optional - Sets the SortingOrder to sort search results according to specified attributes and
+     * indicated order
+     *
+     * @param orders {@link TigrisSort}
+     * @return {@link SearchRequest.Builder}
+     */
+    public Builder withSort(TigrisSort... orders) {
+      this.sortOrder = SortingOrder.newBuilder().withOrder(orders).build();
+      return this;
+    }
+
     /**
      * Optional - Sets collection fields to include in returned documents
      *