Changes for findOne command

pom.xml

@@ -97,6 +97,16 @@
       <type>test-jar</type>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>io.quarkus</groupId>
+      <artifactId>quarkus-junit5-mockito</artifactId>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-junit-jupiter</artifactId>
+      <scope>test</scope>
+    </dependency>
   </dependencies>
   <build>
     <plugins>

src/main/java/io/stargate/sgv3/docsapi/exception/ErrorCode.java

@@ -6,6 +6,8 @@ public enum ErrorCode {
   /** Command error codes. */
   COMMAND_NOT_IMPLEMENTED("The provided command is not implemented."),
 
+  DOCUMENT_UNPARSEABLE("Unable to parse the document"),
+
   FILTER_UNRESOLVABLE("Unable to resolve the filter"),
 
   SHRED_BAD_DOCUMENT_TYPE("Bad document type to shred"),
@@ -18,7 +20,9 @@ public enum ErrorCode {
 
   SHRED_UNRECOGNIZED_NODE_TYPE("Unrecognized JSON node type in input document"),
 
-  UNSUPPORTED_FILTER_DATA_TYPE("Unsupported filter data type");
+  UNSUPPORTED_FILTER_DATA_TYPE("Unsupported filter data type"),
+
+  UNSUPPORTED_FILTER_OPERATION("Unsupported filter operator");
 
   private final String message;
 

src/main/java/io/stargate/sgv3/docsapi/service/bridge/config/DocumentConfig.java

@@ -26,9 +26,24 @@
 @ConfigMapping(prefix = "stargate.document")
 public interface DocumentConfig {
 
-  /** @return Defines the maximum document page size, defaults to <code>20</code>. */
-  @Max(100)
+  /** @return Defines the maximum document page size, defaults to <code>100</code>. */
+  @Max(500)
+  @Positive
+  @WithDefault("100")
+  int maxPageSize();
+
+  /** @return Defines the default document page size, defaults to <code>100</code>. */
+  @Max(500)
   @Positive
   @WithDefault("20")
-  int pageSize();
+  int defaultPageSize();
+
+  /**
+   * @return Defines the maximum limit of document that can be returned for a request, defaults to
+   *     <code>1000</code>.
+   */
+  @Max(Integer.MAX_VALUE)
+  @Positive
+  @WithDefault("1000")
+  int maxLimit();
 }

src/main/java/io/stargate/sgv3/docsapi/service/bridge/executor/QueryExecutor.java

@@ -52,10 +52,10 @@ public Uni<QueryOuterClass.ResultSet> executeRead(
     }
 
     if (pageSize.isPresent()) {
-      int page = Math.min(pageSize.get(), documentConfig.pageSize());
+      int page = Math.min(pageSize.get(), documentConfig.maxPageSize());
       params.setPageSize(Int32Value.of(page));
     } else {
-      params.setPageSize(Int32Value.of(documentConfig.pageSize()));
+      params.setPageSize(Int32Value.of(documentConfig.defaultPageSize()));
     }
     return queryBridge(
         QueryOuterClass.Query.newBuilder(query).setParameters(params).buildPartial());

src/main/java/io/stargate/sgv3/docsapi/service/operation/model/Operation.java

@@ -1,7 +1,6 @@
 package io.stargate.sgv3.docsapi.service.operation.model;
 
 import io.smallrye.mutiny.Uni;
-import io.stargate.sgv3.docsapi.api.model.command.CommandContext;
 import io.stargate.sgv3.docsapi.api.model.command.CommandResult;
 import io.stargate.sgv3.docsapi.service.bridge.executor.QueryExecutor;
 import java.util.function.Supplier;
@@ -25,9 +24,5 @@
  * OperationExecutor}
  */
 public interface Operation {
-
-  /** @return The context of the command responsible for this operation. */
-  CommandContext commandContext();
-
   Uni<Supplier<CommandResult>> execute(QueryExecutor queryExecutor);
 }

src/main/java/io/stargate/sgv3/docsapi/service/operation/model/ReadOperation.java

@@ -0,0 +1,98 @@
+package io.stargate.sgv3.docsapi.service.operation.model;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.BytesValue;
+import io.smallrye.mutiny.Uni;
+import io.stargate.bridge.grpc.Values;
+import io.stargate.bridge.proto.QueryOuterClass;
+import io.stargate.sgv3.docsapi.exception.DocsException;
+import io.stargate.sgv3.docsapi.exception.ErrorCode;
+import io.stargate.sgv3.docsapi.service.bridge.executor.QueryExecutor;
+import io.stargate.sgv3.docsapi.service.operation.model.impl.ReadDocument;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+
+/**
+ * ReadOperation interface which all find command operations will use. It also provides the
+ * implementation to excute and query and parse the result set as {@link FindResponse}
+ */
+public interface ReadOperation extends Operation {
+  static String[] documentColumns = {"key", "tx_id", "doc_json"};
+  static String[] documentKeyColumns = {"key", "tx_id"};
+
+  /**
+   * Default implementation to query and parse the result set
+   *
+   * @param queryExecutor
+   * @param query
+   * @param pagingState
+   * @param readDocument This flag is set to false if the read is done to just identify the document
+   *     id and tx_id to perform another DML operation
+   * @param objectMapper
+   * @return
+   */
+  default Uni<FindResponse> findDocument(
+      QueryExecutor queryExecutor,
+      QueryOuterClass.Query query,
+      String pagingState,
+      boolean readDocument,
+      ObjectMapper objectMapper) {
+    return queryExecutor
+        .executeRead(query, Optional.ofNullable(pagingState), Optional.empty())
+        .onItem()
+        .transform(
+            rSet -> {
+              int remaining = rSet.getRowsCount();
+              int colCount = rSet.getColumnsCount();
+              List<ReadDocument> documents = new ArrayList<>(remaining);
+              Iterator<QueryOuterClass.Row> rowIterator = rSet.getRowsList().stream().iterator();
+              while (--remaining >= 0 && rowIterator.hasNext()) {
+                QueryOuterClass.Row row = rowIterator.next();
+                ReadDocument document = null;
+                try {
+                  document =
+                      new ReadDocument(
+                          Values.string(row.getValues(0)), // key
+                          Optional.of(Values.uuid(row.getValues(1))), // tx_id
+                          readDocument
+                              ? objectMapper.readTree(Values.string(row.getValues(2)))
+                              : null);
+                } catch (JsonProcessingException e) {
+                  throw new DocsException(ErrorCode.DOCUMENT_UNPARSEABLE);
+                }
+                documents.add(document);
+              }
+              return new FindResponse(documents, extractPagingStateFromResultSet(rSet));
+            });
+  }
+
+  private String extractPagingStateFromResultSet(QueryOuterClass.ResultSet rSet) {
+    BytesValue pagingStateOut = rSet.getPagingState();
+    if (pagingStateOut.isInitialized()) {
+      ByteString rawPS = pagingStateOut.getValue();
+      if (!rawPS.isEmpty()) {
+        byte[] b = rawPS.toByteArray();
+        // Could almost use "ByteBufferUtils.toBase64" but need variant that takes 'byte[]'
+        return Base64.getEncoder().encodeToString(b);
+      }
+    }
+    return null;
+  }
+
+  public static record FindResponse(List<ReadDocument> docs, String pagingState) {}
+
+  /**
+   * This method not needed once Tatu implements new shredder for document
+   *
+   * @param coll
+   * @return
+   */
+  private int verifyMapLength(QueryOuterClass.Collection coll) {
+    return 0;
+  }
+}