Response encoding for single items and lists

example/src/index.ts

@@ -1,13 +1,28 @@
 import {Redis} from "@upstash/redis";
 
 const redis = new Redis({
-  url: process.env.REDIS_CONNECTION_URL,
+  url: "http://127.0.0.1:8080",
   token: "example_token",
-  responseEncoding: false,
+  // responseEncoding: true,
 });
 
 (async () => {
-  await redis.set("key", "value");
-  const value = await redis.get("key");
+  // await redis.set("key", "value");
+  const value = await redis.get("foo");
   console.log(value); // value
+
+  // Run a pipeline operation
+  const pipelineResponse = await redis.pipeline()
+    .set("amazing-key", "bar")
+    .get("amazing-key")
+    .del("amazing-other-key")
+    .del("random-key-that-doesnt-exist")
+    .srandmember("random-key-that-doesnt-exist")
+    .sadd("amazing-set", "item1", "item2", "item3", "bar", "foo", "example")
+    .smembers("amazing-set")
+    // .evalsha("aijsojiasd", [], [])
+    .get("foo")
+    .exec();
+
+  console.log(pipelineResponse);
 })();

lib/srh/http/base_router.ex

@@ -2,6 +2,7 @@ defmodule Srh.Http.BaseRouter do
   use Plug.Router
   alias Srh.Http.RequestValidator
   alias Srh.Http.CommandHandler
+  alias Srh.Http.ResultEncoder
 
   plug(:match)
   plug(Plug.Parsers, parsers: [:json], pass: ["application/json"], json_decoder: Jason)
@@ -12,27 +13,30 @@ defmodule Srh.Http.BaseRouter do
   end
 
   post "/" do
-    conn
-    |> handle_extract_auth(&CommandHandler.handle_command(conn, &1))
-    |> handle_response(conn)
+    do_command_request(conn, &CommandHandler.handle_command(&1, &2))
   end
 
   post "/pipeline" do
-    conn
-    |> handle_extract_auth(&CommandHandler.handle_command_array(conn, &1))
-    |> handle_response(conn)
+    do_command_request(conn, &CommandHandler.handle_command_array(&1, &2))
   end
 
   post "/multi-exec" do
-    conn
-    |> handle_extract_auth(&CommandHandler.handle_command_transaction_array(conn, &1))
-    |> handle_response(conn)
+    do_command_request(conn, &CommandHandler.handle_command_transaction_array(&1, &2))
   end
 
   match _ do
     send_resp(conn, 404, "Endpoint not found")
   end
 
+  defp do_command_request(conn, success_lambda) do
+    encoding_enabled = handle_extract_encoding(conn)
+
+    conn
+    |> handle_extract_auth(&success_lambda.(conn, &1))
+    |> handle_encoding_step(encoding_enabled)
+    |> handle_response(conn)
+  end
+
   defp handle_extract_auth(conn, success_lambda) do
     case conn
          |> get_req_header("authorization")
@@ -45,6 +49,24 @@ defmodule Srh.Http.BaseRouter do
     end
   end
 
+  defp handle_extract_encoding(conn) do
+    case conn
+         |> get_req_header("upstash-encoding")
+         |> RequestValidator.validate_encoding_header() do
+      {:ok, _encoding_enabled} -> true
+      {:error, _} -> false # it's not required to be present
+    end
+  end
+
+  defp handle_encoding_step(response, encoding_enabled) do
+    case encoding_enabled do
+      true ->
+        # We need to use the encoder to
+        ResultEncoder.encode_response(response)
+      false -> response
+    end
+  end
+
   defp handle_response(response, conn) do
     %{code: code, message: message, json: json} =
       case response do

lib/srh/http/request_validator.ex

@@ -26,6 +26,21 @@ defmodule Srh.Http.RequestValidator do
 
   defp do_validate_pipeline_item(_), do: :error
 
+  def validate_encoding_header(header_value_array) when is_list(header_value_array) do
+    do_validate_encoding_header(header_value_array)
+  end
+
+  # This has been broken up like this to future-proof different encoding modes in the future
+  defp do_validate_encoding_header([first_item | rest]) do
+    case first_item do
+      "base64" -> {:ok, true}
+
+      _ -> do_validate_encoding_header(rest)
+    end
+  end
+
+  defp do_validate_encoding_header([]), do: {:error, :not_found}
+
   def validate_bearer_header(header_value_array) when is_list(header_value_array) do
     do_validate_bearer_header(header_value_array)
   end

lib/srh/http/result_encoder.ex

@@ -0,0 +1,66 @@
+defmodule Srh.Http.ResultEncoder do
+
+  # Errors don't get encoded, we need to skip over those
+  def encode_response({:redis_error, error_result_map}) do
+    {:redis_error, error_result_map}
+  end
+
+  # List-based responses, they will contain multiple entries
+  # It's important to note that this is DIFFERENT from a list of values,
+  # as it's a list of separate command responses. Each is a map that either
+  # Contains a result or an error
+  def encode_response({:ok, result_list}) when is_list(result_list) do
+    # Each one of these entries needs to be encoded
+    {:ok, encode_response_list(result_list, [])}
+  end
+
+  # Single item response
+  def encode_response({:ok, %{result: result_value}}) do
+    {:ok, %{result: encode_result_value(result_value)}}
+  end
+
+  ## RESULT LIST ENCODING ##
+
+  defp encode_response_list([current | rest], encoded_responses) do
+    encoded_current_entry = case current do
+      %{result: value} ->
+        %{result: encode_result_value(value)} # Encode the value
+      %{error: error_message} ->
+        %{error: error_message} # We don't encode errors
+    end
+
+    encode_response_list(rest, [encoded_current_entry | encoded_responses])
+  end
+
+  defp encode_response_list([], encoded_responses) do
+    Enum.reverse(encoded_responses)
+  end
+
+  ## RESULT VALUE ENCODING ##
+
+  # Numbers are ignored
+  defp encode_result_value(value) when is_number(value), do: value
+
+  # Null/nil is ignored
+  defp encode_result_value(value) when is_nil(value), do: value
+
+  # Strings / blobs (any binary data) is encoded to Base64
+  defp encode_result_value(value) when is_binary(value), do: Base.encode64(value)
+
+  defp encode_result_value(arr) when is_list(arr) do
+    encode_result_value_list(arr, [])
+  end
+
+  ## RESULT VALUE LIST ENCODING ##
+
+  # Arrays can have values that are encoded, or aren't, based on whats laid out above
+  defp encode_result_value_list([current | rest], encoded_responses) do
+    encoded_value = encode_result_value(current)
+    encode_result_value_list(rest, [encoded_value | encoded_responses])
+  end
+
+  defp encode_result_value_list([], encoded_responses) do
+    # There are no responses left, and since we add them backwards, we need to flip the list
+    Enum.reverse(encoded_responses)
+  end
+end