refactor(json_family): address comments

Signed-off-by: Stepan Bagritsevich <[email protected]>

Author: BagritsevichStepan

src/server/detail/wrapped_json_path.h

@@ -4,8 +4,6 @@
 
 #pragma once
 
-#include <absl/container/inlined_vector.h>
-
 #include <string_view>
 #include <utility>
 #include <variant>
@@ -16,7 +14,7 @@
 
 namespace dfly {
 
-using Nothing = boost::blank;
+class Nothing {};
 using JsonExpression = jsoncons::jsonpath::jsonpath_expression<JsonType>;
 
 template <typename T>
@@ -53,22 +51,25 @@ using JsonPathMutateCallback =
 
 namespace details {
 
-template <typename T> void OptionalEmplace(std::optional<T>& optional, T&& value) {
-  optional.emplace(std::forward<T>(value));
+template <typename T> void OptionalEmplace(T&& value, std::optional<T>* optional) {
+  optional->emplace(std::forward<T>(value));
 }
 
 template <typename T>
-void OptionalEmplace(std::optional<std::optional<T>>& optional, std::optional<T>&& value) {
+void OptionalEmplace(std::optional<T>&& value, std::optional<std::optional<T>>* optional) {
   if (value.has_value()) {
-    optional.emplace(std::forward<std::optional<T>>(value));
+    optional->emplace(std::forward<std::optional<T>>(value));
   }
 }
 
 }  // namespace details
 
 template <typename T> class JsonCallbackResult {
  public:
+  /* In the case of a restricted path (legacy mode), the result consists of a single value */
   using JsonV1Result = std::optional<T>;
+
+  /* In the case of an enhanced path (starts with $), the result is an array of multiple values */
   using JsonV2Result = std::vector<T>;
 
   JsonCallbackResult() = default;
@@ -82,7 +83,7 @@ template <typename T> class JsonCallbackResult {
 
   void AddValue(T&& value) {
     if (IsV1()) {
-      details::OptionalEmplace(AsV1(), std::forward<T>(value));
+      details::OptionalEmplace(std::forward<T>(value), &AsV1());
     } else {
       AsV2().emplace_back(std::forward<T>(value));
     }
@@ -100,6 +101,14 @@ template <typename T> class JsonCallbackResult {
     return std::get<JsonV2Result>(result_);
   }
 
+  const JsonV1Result& AsV1() const {
+    return std::get<JsonV1Result>(result_);
+  }
+
+  const JsonV2Result& AsV2() const {
+    return std::get<JsonV2Result>(result_);
+  }
+
  public:
   std::error_code error_code;
 

src/server/json_family.cc

@@ -20,7 +20,6 @@
 #include "core/json/json_object.h"
 #include "core/json/path.h"
 #include "facade/cmd_arg_parser.h"
-#include "facade/error.h"
 #include "facade/op_status.h"
 #include "server/acl/acl_commands_def.h"
 #include "server/command_registry.h"
@@ -109,49 +108,53 @@ ParseResult<WrappedJsonPath> ParseJsonPath(std::string_view path) {
 
 namespace reply_generic {
 
-template <typename T> void Send(RedisReplyBuilder& rb, T value) = delete;
+template <typename T> void Send(T value, RedisReplyBuilder* rb) = delete;
 
-template <> void Send(RedisReplyBuilder& rb, std::size_t value) {
-  rb.SendLong(value);
+template <> void Send(std::size_t value, RedisReplyBuilder* rb) {
+  rb->SendLong(value);
 }
 
-template <typename T> void Send(RedisReplyBuilder& rb, const std::optional<T>& opt) {
+template <typename T> void Send(const std::optional<T>& opt, RedisReplyBuilder* rb) {
   if (opt.has_value()) {
-    Send(rb, opt.value());
+    Send(opt.value(), rb);
   } else {
-    rb.SendNull();
+    rb->SendNull();
   }
 }
 
-template <typename T> void Send(RedisReplyBuilder& rb, const std::vector<T>& vec) {
+template <typename T> void Send(const std::vector<T>& vec, RedisReplyBuilder* rb) {
   if (vec.empty()) {
-    rb.SendNullArray();
+    rb->SendNullArray();
   } else {
-    rb.StartArray(vec.size());
+    rb->StartArray(vec.size());
     for (auto&& x : vec) {
-      Send(rb, x);
+      Send(x, rb);
     }
   }
 }
 
-template <typename T> void Send(RedisReplyBuilder& rb, JsonCallbackResult<T>& result) {
+template <typename T> void Send(const JsonCallbackResult<T>& result, RedisReplyBuilder* rb) {
   if (result.error_code) {
-    rb.SendError(result.error_code.message(), kSyntaxErrType);  // todo edit
+    rb->SendError(result.error_code.message());
     return;
   }
 
   if (result.IsV1()) {
-    Send(rb, result.AsV1());
+    /* The specified path was restricted (JSON legacy mode), then the result consists only of a
+     * single value */
+    Send(result.AsV1(), rb);
   } else {
-    Send(rb, result.AsV2());
+    /* The specified path was enhanced (starts with '$'), then the result is an array of multiple
+     * values */
+    Send(result.AsV2(), rb);
   }
 }
 
-template <typename T> void Send(RedisReplyBuilder& rb, OpResult<T>& result) {
+template <typename T> void Send(const OpResult<T>& result, RedisReplyBuilder* rb) {
   if (result) {
-    Send(rb, result.value());
+    Send(result.value(), rb);
   } else {
-    rb.SendError(result.status());
+    rb->SendError(result.status());
   }
 }
 
@@ -1965,7 +1968,7 @@ void JsonFamily::StrAppend(CmdArgList args, ConnectionContext* cntx) {
   Transaction* trans = cntx->transaction;
   auto result = trans->ScheduleSingleHopT(std::move(cb));
   auto* rb = static_cast<RedisReplyBuilder*>(cntx->reply_builder());
-  reply_generic::Send(*rb, result);
+  reply_generic::Send(result, rb);
 }
 
 void JsonFamily::ObjKeys(CmdArgList args, ConnectionContext* cntx) {