settle on order for request args

lib/ex_aws/dynamo/impl.ex

@@ -38,7 +38,7 @@ defmodule ExAws.Dynamo.Impl do
   ######################
 
   def list_tables(client) do
-    request(%{}, :list_tables, client)
+    request(client, :list_tables, %{})
   end
 
   def create_table(client, name, primary_key, key_definitions, read_capacity, write_capacity)
@@ -60,14 +60,15 @@ defmodule ExAws.Dynamo.Impl do
         "WriteCapacityUnits" => write_capacity
       }
     }
-    %{
+    data = %{
       "GlobalSecondaryIndexes" => global_indexes |> camelize_keys(deep: true),
       "LocalSecondaryIndexes"  => local_indexes  |> camelize_keys(deep: true)
     } |> Enum.reduce(data, fn
       ({_, indices = %{}}, data) when map_size(indices) == 0 -> data
       {name, indices}, data -> Map.put(data, name, Enum.into(indices, %{}))
     end)
-    |> request(:create_table, client)
+
+    request(client, :create_table, data)
   end
 
   defp build_key_schema(key_schema) do
@@ -80,36 +81,37 @@ defmodule ExAws.Dynamo.Impl do
   end
 
   def describe_table(client, name) do
-    %{"TableName" => name}
-    |> request(:describe_table, client)
+    request(client, :describe_table, %{"TableName" => name})
   end
 
   def update_table(client, name, attributes) do
-    attributes
+    data = attributes
     |> camelize_keys(deep: true)
     |> Map.merge(%{"TableName" => name})
-    |> request(:update_table, client)
+
+    request(client, :update_table, data)
   end
 
   def delete_table(client, table) do
-    %{"TableName" => table}
-    |> request(:delete_table, client)
+    request(client, :delete_table, %{"TableName" => table})
   end
 
   ## Records
   ######################
   def scan(client, name, opts \\ []) do
-    opts
+    data = opts
     |> build_opts
     |> Map.merge(%{"TableName" => name})
-    |> request(:scan, client)
+
+    request(client, :scan, data)
   end
 
   def query(client, name, opts \\ []) do
-    opts
+    data = opts
     |> build_opts
     |> Map.merge(%{"TableName" => name})
-    |> request(:query, client)
+
+    request(client, :query, data)
   end
 
   def batch_get_item(client, data, opts \\ []) do
@@ -129,19 +131,22 @@ defmodule ExAws.Dynamo.Impl do
       Map.put(query, table_name, dynamized_table_query)
     end)
 
-    opts
+    data = opts
     |> camelize_keys
     |> Map.merge(%{"RequestItems" => request_items})
-    |> request(:batch_get_item, client)
+
+    request(client, :batch_get_item, data)
   end
 
   def put_item(client, name, record, opts \\ []) do
-    opts
+    data = opts
     |> build_opts
     |> Map.merge(%{
       "TableName" => name,
       "Item" => Dynamo.Encoder.encode(record)
-    }) |> request(:put_item, client)
+    })
+
+    request(client, :put_item, data)
   end
 
   def batch_write_item(client, data, opts \\ []) do
@@ -157,19 +162,22 @@ defmodule ExAws.Dynamo.Impl do
       Map.put(query, table_name, queries)
     end)
 
-    opts
+    data = opts
     |> camelize_keys
     |> Map.merge(%{"RequestItems" => request_items})
-    |> request(:batch_write_item, client)
+
+    request(client, :batch_write_item, data)
   end
 
   def get_item(client, name, primary_key, opts \\ []) do
-    opts
+    data = opts
     |> build_opts
     |> Map.merge(%{
       "TableName" => name,
       "Key" => primary_key |> Enum.into(%{}) |> Dynamo.Encoder.encode_flat
-    }) |> request(:get_item, client)
+    })
+
+    request(client, :get_item, data)
   end
 
   def get_item!(client, name, primary_key, opts \\ []) do
@@ -178,24 +186,27 @@ defmodule ExAws.Dynamo.Impl do
   end
 
   def update_item(client, table_name, primary_key, update_opts) do
-    update_opts
+    data = update_opts
     |> build_opts
     |> Map.merge(%{
       "TableName" => table_name,
       "Key" => primary_key |> Enum.into(%{}) |> Dynamo.Encoder.encode_flat
-    }) |> request(:update_item, client)
+    })
+
+    request(client, :update_item, data)
   end
 
   def delete_item(client, name, primary_key, opts \\ []) do
-    opts
+    data = opts
     |> build_opts
     |> Map.merge(%{
       "TableName" => name,
       "Key" => primary_key |> Enum.into(%{}) |> Dynamo.Encoder.encode_flat})
-    |> request(:delete_item, client)
+
+    request(client, :delete_item, data)
   end
 
-  defp request(data, action, %{__struct__: client_module} = client) do
+  defp request(%{__struct__: client_module} = client, action, data) do
     client_module.request(client, action, data)
   end
 

lib/ex_aws/kinesis/client.ex

@@ -180,7 +180,7 @@ defmodule ExAws.Kinesis.Client do
   By default this just forwards the request to the `ExAws.Kinesis.Request.request/2`.
   However, this can be overriden in your client to provide pre-request adjustments to headers, params, etc.
   """
-  defcallback request(data :: %{}, action :: atom)
+  defcallback request(client :: %{}, data :: %{}, action :: atom)
 
   @doc "Retrieves the root AWS config for this client"
   defcallback config_root() :: Keyword.t
@@ -197,11 +197,11 @@ defmodule ExAws.Kinesis.Client do
       unquote(boilerplate)
 
       @doc false
-      def request(data, action) do
-        ExAws.Kinesis.Request.request(__MODULE__, action, data)
+      def request(client, action, data) do
+        ExAws.Kinesis.Request.request(client, action, data)
       end
 
-      defoverridable config_root: 0, request: 2
+      defoverridable config_root: 0, request: 3
     end
   end
 end

lib/ex_aws/kinesis/impl.ex

@@ -35,37 +35,36 @@ defmodule ExAws.Kinesis.Impl do
   ######################
 
   def list_streams(client) do
-    client.request(%{}, :list_streams)
+    request(client, :list_streams, %{})
   end
 
   def describe_stream(client, stream_name, opts \\ []) do
-    opts
+    data = opts
     |> camelize_keys
     |> Map.merge(%{"StreamName" => stream_name})
-    |> client.request(:describe_stream)
+    request(client, :describe_stream, data)
   end
 
   def create_stream(client, stream_name, shard_count \\ 1) do
-    %{
+    data = %{
       "ShardCount" => shard_count,
-      "StreamName" => stream_name
-    }
-    |> client.request(:create_stream)
+      "StreamName" => stream_name}
+    request(client, :create_stream, data)
   end
 
   def delete_stream(client, stream_name) do
-    %{"StreamName" => stream_name}
-    |> client.request(:delete_stream)
+    request(client, :delete_stream, %{"StreamName" => stream_name})
   end
 
   ## Records
   ######################
 
   def get_records(client, shard_iterator, opts \\ []) do
-    opts
+    data = opts
     |> camelize_keys
     |> Map.merge(%{"ShardIterator" => shard_iterator})
-    |> client.request(:get_records)
+
+    request(client, :get_records, data)
     |> do_get_records
   end
 
@@ -88,21 +87,23 @@ defmodule ExAws.Kinesis.Impl do
   end
 
   def put_record(client, stream_name, partition_key, data, opts \\ []) do
-    opts
+    data = opts
     |> camelize_keys
     |> Map.merge(%{
       "Data" => data |> Base.encode64,
       "PartitionKey" => partition_key,
       "StreamName" => stream_name})
-    |> client.request(:put_record)
+
+    request(client, :put_record, data)
   end
 
   def put_records(client, stream_name, records) when is_list(records) do
-    %{
-      "Records" => records |> Enum.map(&format_record/1),
+    data = %{
+      "Records"    => records |> Enum.map(&format_record/1),
       "StreamName" => stream_name
     }
-    |> client.request(:put_records)
+
+    request(client, :put_records, data)
   end
 
   defp format_record(%{data: data, partition_key: partition_key} = record) do
@@ -118,50 +119,61 @@ defmodule ExAws.Kinesis.Impl do
   ######################
 
   def get_shard_iterator(client, stream_name, shard_id, shard_iterator_type, opts \\ []) do
-    opts
+    data = opts
     |> Enum.into(%{})
     |> camelize_keys
     |> Map.merge(%{
       "StreamName" => stream_name,
       "ShardId" => shard_id,
       "ShardIteratorType" => shard_iterator_type |> upcase
-    }) |> client.request(:get_shard_iterator)
+    })
+
+    request(client, :get_shard_iterator, data)
   end
 
   def merge_shards(client, stream_name, adjacent_shard, shard) do
-    %{
+    data = %{
       "StreamName" => stream_name,
       "AdjacentShardToMerge" => adjacent_shard,
       "ShardToMerge" => shard
-    } |> client.request(:merge_shards)
+    }
+
+    request(client, :merge_shards, data)
   end
 
   def split_shard(client, stream_name, shard, new_starting_hash_key) do
-    %{
+    data = %{
       "StreamName" => stream_name,
       "ShardToSplit" => shard,
       "NewStartingHashKey" => new_starting_hash_key
-    } |> client.request(:split_shard)
+    }
+
+    request(client, :split_shard, data)
   end
 
   ## Tags
   ######################
 
   def add_tags_to_stream(client, stream_name, tags) do
-    %{"StreamName" => stream_name, "Tags" => tags |> Enum.into(%{})}
-    |> client.request(:add_tags_to_stream)
+    data = %{"StreamName" => stream_name, "Tags" => tags |> Enum.into(%{})}
+    request(client, :add_tags_to_stream, data)
   end
 
   def list_tags_for_stream(client, stream_name, opts \\ []) do
-    opts
+    data = opts
     |> Enum.into(%{})
     |> camelize_keys
     |> Map.merge(%{"StreamName" => stream_name})
-    |> client.request(:list_tags_for_stream)
+
+    request(client, :list_tags_for_stream, data)
   end
 
   def remove_tags_from_stream(client, stream_name, tag_keys) do
-    %{"StreamName" => stream_name, "TagKeys" => tag_keys}
-    |> client.request(:remove_tags_from_stream)
+    data = %{"StreamName" => stream_name, "TagKeys" => tag_keys}
+    request(client, :remove_tags_from_stream, data)
+  end
+
+  defp request(%{__struct__: client_module} = client, action, data) do
+    client_module.request(client, action, data)
   end
 end

test/lib/ex_aws/kinesis_test.exs

@@ -3,7 +3,7 @@ defmodule Test.Dummy.Kinesis do
 
   def config_root, do: Application.get_all_env(:ex_aws)
 
-  def request(data, _action), do: data
+  def request(_client, _action, data), do: data
 end
 
 defmodule ExAws.KinesisTest do