Support tuples as keys for get_all/put_all callbacks in Redis/Client cluster

lib/nebulex_redis_adapter.ex

@@ -537,7 +537,7 @@ defmodule NebulexRedisAdapter do
 
   defp do_get_all(adapter_meta, keys, opts) do
     keys
-    |> group_keys_by_hash_slot(adapter_meta)
+    |> group_keys_by_hash_slot(adapter_meta, :keys)
     |> Enum.reduce(%{}, fn {hash_slot, keys}, acc ->
       return = mget(hash_slot, adapter_meta, keys, opts)
 
@@ -599,7 +599,7 @@ defmodule NebulexRedisAdapter do
 
       _ ->
         entries
-        |> group_keys_by_hash_slot(adapter_meta)
+        |> group_keys_by_hash_slot(adapter_meta, :tuples)
         |> Enum.reduce(:ok, fn {hash_slot, group}, acc ->
           acc && do_put_all(adapter_meta, hash_slot, group, ttl, on_write, opts)
         end)
@@ -782,7 +782,7 @@ defmodule NebulexRedisAdapter do
        when is_list(keys) do
     :ok =
       keys
-      |> group_keys_by_hash_slot(adapter_meta)
+      |> group_keys_by_hash_slot(adapter_meta, :keys)
       |> Enum.each(fn {hash_slot, keys_group} ->
         Command.exec!(
           adapter_meta,
@@ -876,16 +876,20 @@ defmodule NebulexRedisAdapter do
     apply(RedisCluster, :exec!, args ++ extra_args)
   end
 
-  defp group_keys_by_hash_slot(enum, %{
-         mode: :client_side_cluster,
-         nodes: nodes,
-         keyslot: keyslot
-       }) do
-    ClientCluster.group_keys_by_hash_slot(enum, nodes, keyslot)
+  defp group_keys_by_hash_slot(
+         enum,
+         %{
+           mode: :client_side_cluster,
+           nodes: nodes,
+           keyslot: keyslot
+         },
+         enum_type
+       ) do
+    ClientCluster.group_keys_by_hash_slot(enum, nodes, keyslot, enum_type)
   end
 
-  defp group_keys_by_hash_slot(enum, %{mode: :redis_cluster, keyslot: keyslot}) do
-    RedisCluster.group_keys_by_hash_slot(enum, keyslot)
+  defp group_keys_by_hash_slot(enum, %{mode: :redis_cluster, keyslot: keyslot}, enum_type) do
+    RedisCluster.group_keys_by_hash_slot(enum, keyslot, enum_type)
   end
 
   defp enc_key(%{serializer: serializer, encode_key_opts: enc_key_opts}, key) do

lib/nebulex_redis_adapter/client_cluster.ex

@@ -102,19 +102,13 @@ defmodule NebulexRedisAdapter.ClientCluster do
     Pool.get_conn(registry, {name, node_name}, pool_size)
   end
 
-  @spec group_keys_by_hash_slot(Enum.t(), nodes_config, module) :: map
-  def group_keys_by_hash_slot(enum, nodes, module) do
-    Enum.reduce(enum, %{}, fn
-      {key, _} = entry, acc ->
-        hash_slot = hash_slot(module, key, nodes)
-
-        Map.put(acc, hash_slot, [entry | Map.get(acc, hash_slot, [])])
-
-      key, acc ->
-        hash_slot = hash_slot(module, key, nodes)
+  @spec group_keys_by_hash_slot(Enum.t(), nodes_config, module, atom()) :: map
+  def group_keys_by_hash_slot(enum, nodes, module, :keys) do
+    Enum.group_by(enum, &hash_slot(module, &1, nodes))
+  end
 
-        Map.put(acc, hash_slot, [key | Map.get(acc, hash_slot, [])])
-    end)
+  def group_keys_by_hash_slot(enum, nodes, module, :tuples) do
+    Enum.group_by(enum, fn {key, _} -> hash_slot(module, key, nodes) end)
   end
 
   ## Private Functions

lib/nebulex_redis_adapter/redis_cluster.ex

@@ -111,19 +111,13 @@ defmodule NebulexRedisAdapter.RedisCluster do
     end)
   end
 
-  @spec group_keys_by_hash_slot(Enum.t(), module) :: map
-  def group_keys_by_hash_slot(enum, keyslot) do
-    Enum.reduce(enum, %{}, fn
-      {key, _} = entry, acc ->
-        slot = hash_slot(key, keyslot)
-
-        Map.put(acc, slot, [entry | Map.get(acc, slot, [])])
-
-      key, acc ->
-        slot = hash_slot(key, keyslot)
+  @spec group_keys_by_hash_slot(Enum.t(), module, atom()) :: map
+  def group_keys_by_hash_slot(enum, keyslot, :keys) do
+    Enum.group_by(enum, &hash_slot(&1, keyslot))
+  end
 
-        Map.put(acc, slot, [key | Map.get(acc, slot, [])])
-    end)
+  def group_keys_by_hash_slot(enum, keyslot, :tuples) do
+    Enum.group_by(enum, fn {key, _} -> hash_slot(key, keyslot) end)
   end
 
   @spec hash_slot(any, module) :: {:"$hash_slot", pos_integer}

test/nebulex_redis_adapter/redis_cluster_test.exs

@@ -160,6 +160,31 @@ defmodule NebulexRedisAdapter.RedisClusterTest do
 
       assert Cache.get_all(["{foo}.1", "{foo}.2"]) == %{"{foo}.1" => "bar1", "{foo}.2" => "bar2"}
     end
+
+    test "put and get operations with tupled keys" do
+      assert Cache.put_all(%{
+               {RedisCache.Testing, "key1"} => "bar1",
+               {RedisCache.Testing, "key2"} => "bar2"
+             }) == :ok
+
+      assert Cache.get_all([{RedisCache.Testing, "key1"}, {RedisCache.Testing, "key2"}]) == %{
+               {RedisCache.Testing, "key1"} => "bar1",
+               {RedisCache.Testing, "key2"} => "bar2"
+             }
+
+      assert Cache.put_all(%{
+               {RedisCache.Testing, {Nested, "key1"}} => "bar1",
+               {RedisCache.Testing, {Nested, "key2"}} => "bar2"
+             }) == :ok
+
+      assert Cache.get_all([
+               {RedisCache.Testing, {Nested, "key1"}},
+               {RedisCache.Testing, {Nested, "key2"}}
+             ]) == %{
+               {RedisCache.Testing, {Nested, "key1"}} => "bar1",
+               {RedisCache.Testing, {Nested, "key2"}} => "bar2"
+             }
+    end
   end
 
   describe "MOVED" do