1.0

lib/stripe.ex

@@ -28,41 +28,50 @@ defmodule Stripe do
       STRIPE_SECRET_KEY=YOUR_SECRET_KEY
   """
 
-  defp get_secret_key do
+  defp get_secret_key(opts) do
+    Keyword.get(opts, :secret_key) ||
     System.get_env("STRIPE_SECRET_KEY") || 
     Application.get_env(:stripe, :secret_key) || 
     raise AuthenticationError, message: @missing_secret_key_error_message
   end
 
-  defp request_url(endpoint) do
-    Path.join(@api, endpoint)
-  end
-
   defp request_url(endpoint, []) do
     Path.join(@api, endpoint)
   end
 
-  defp request_url(endpoint, data) do
+  defp request_url(endpoint, params) do
     base_url = request_url(endpoint)
-    query_params = Stripe.Utils.encode_data(data)
+    query_params = Stripe.Utils.encode_data(params)
     "#{base_url}?#{query_params}"
   end
 
-  defp create_headers(opts) do
+  defp create_headers(request_opts) do
     headers = 
-      [{"Authorization", "Bearer #{get_secret_key()}"},
+      [{"Authorization", "Bearer #{get_secret_key(opts)}"},
        {"User-Agent", "Stripe/v1 stripe-elixir/#{@client_version}"},
        {"Content-Type", "application/x-www-form-urlencoded"}]
 
-    case Keyword.get(opts, :stripe_account) do 
+    case Keyword.get(request_opts, :stripe_account) do 
       nil -> headers 
       account_id -> [{"Stripe-Account", account_id} | headers]
     end
   end
 
-  def request(action, endpoint, data, opts) when action in [:get, :post, :delete] do
-    HTTPoison.request(action, request_url(endpoint, data), "", create_headers(opts))
-    |> handle_response
+  def request(%Stripe.Request{method: method, endpoint: endpoint, params: params}, request_opts \\ []) do
+    HTTPoison.request(
+      method, 
+      request_url(endpoint, params), 
+      <<>>, 
+      create_headers(request_opts)
+    )
+    |> handle_response()
+  end
+
+  def request!(%Stripe.Request{} = request_struct, opts \\ []) do 
+    case request(request_struct, opts) do 
+      {:ok, result} -> result 
+      {:error, error} -> raise error
+    end
   end
 
   defp handle_response({:ok, %{body: body, status_code: 200}}) do

lib/stripe/api.ex

@@ -1,53 +1,8 @@
 defmodule Stripe.API do
-  defmacro __using__(opts) do
-    quote do
-      if :create in unquote(opts) do
-        @doc """
-        Create a(n) #{__MODULE__ |> to_string |> String.split(".") |> List.last}
-        """
-        def create(data, opts \\ []) do
-          Stripe.request(:post, endpoint(), data, opts)
-        end
-      end
-
-      if :retrieve in unquote(opts) do
-        @doc """
-        Retrive a(n) #{__MODULE__ |> to_string |> String.split(".") |> List.last} by its ID
-        """
-        def retrieve(id, opts \\ []) when is_bitstring(id) do
-          resource_url = Path.join(endpoint(), id)
-          Stripe.request(:get, resource_url, [], opts)
-        end
-      end
-
-      if :update in unquote(opts) do
-        @doc """
-        Update a(n) #{__MODULE__ |> to_string |> String.split(".") |> List.last}
-        """
-        def update(id, data, opts \\ []) do
-          resource_url = Path.join(endpoint(), id)
-          Stripe.request(:post, resource_url, data, opts)
-        end
-      end
-
-      if :list in unquote(opts) do
-        @doc """
-        List all #{__MODULE__ |> to_string |> String.split(".") |> List.last}s
-        """
-        def list(pagination_opts \\ [], opts \\ []) when is_list(pagination_opts) do
-          Stripe.request(:get, endpoint(), pagination_opts, opts)
-        end
-      end
-
-      if :delete in unquote(opts) do
-        @doc """
-        Delete a(n) #{__MODULE__ |> to_string |> String.split(".") |> List.last}
-        """
-        def delete(id, data \\ [], opts \\ []) when is_bitstring(id) do
-          resource_url = Path.join(endpoint(), id)
-          Stripe.request(:delete, resource_url, data, opts)
-        end
-      end
-    end
-  end
+  @callback list(pagination_opts :: Enum.t) :: Stripe.Request.t
+  @callback retrieve(id :: binary) :: Stripe.Request.t 
+  @callback create(Enum.t) :: Stripe.Request.t
+  @callback update(id :: binary, updates :: Enum.t) :: Stripe.Request.t 
+  @callback delete(id :: binary, options :: Enum.t) :: Stripe.Request.t
+  @optional_callbacks list: 1, retrieve: 1, create: 1, update: 2, delete: 2
 end

lib/stripe/balance.ex

@@ -1,11 +1,20 @@
 defmodule Stripe.Balance do
-  use Stripe.API, [:list]
+  @moduledoc""" 
+  Functions related to get balance information
+  """
 
+  @behaviour Stripe.API
+
+  @spec endpoint :: binary
   def endpoint do
     "balance"
   end
 
+  @spec retrieve() :: Stripe.Request.t
   def retrieve do
-    list
+    %Stripe.Request{
+      method: :get,
+      endpoint: endpoint()
+    }
   end
 end

lib/stripe/balance_transaction.ex

@@ -1,11 +1,29 @@
 defmodule Stripe.BalanceTransaction do
-  use Stripe.API, [:retrieve, :list]
+  @moduledoc"""
+  Functions related for balance history
+  """
 
-  def endpoint do
-    "balance/history"
+  @behaviour Stripe.API
+
+  @spec endpoint(binary) :: binary
+  def endpoint(id \\ "") do
+    "balance/history/#{id}"
+  end
+
+  @spec retrieve(binary) :: Stripe.Request.t
+  def retrieve(balance_id) do 
+    %Stripe.Request{
+      method: :get, 
+      endpoint: endpoint(balance_id)
+    }
   end
 
-  def all(opts \\ []) do
-    list([], opts)
+  @spec all(Enum.t) :: Stripe.Request.t
+  def all(pagination_opts \\ []) do 
+    %Stripe.Request{
+      method: :get,
+      endpoint: endpoint(),
+      params: pagination_opts
+    }
   end
 end

lib/stripe/bitcoin_receiver.ex

@@ -1,6 +1,4 @@
 defmodule Stripe.BitcoinReceiver do
-  use Stripe.API, [:create, :retrieve, :list]
-
   def endpoint do
     "bitcoin/receivers"
   end

lib/stripe/charge.ex

@@ -1,15 +1,54 @@
 defmodule Stripe.Charge do
-  use Stripe.API, [:list, :retrieve, :create, :update]
+  @moduledoc"""
+  Functions related to charges
+  """
+  @behaviour Stripe.API
 
-  def endpoint do
-    "charges"
+  @spec endpoint(binary) :: binary
+  def endpoint(id \\ "") do
+    "charges/#{id}"
   end
 
-  def capture_endpoint(id) do
-    "#{endpoint()}/#{id}/capture"
+  @spec list(Enum.t) :: Stripe.Request.t
+  def list(pagination_opts \\ []) do 
+    %Stripe.Request{
+      method: :get,
+      endpoint: endpoint(),
+      params: pagination_opts
+    }
+  end
+
+  @spec retrieve(binary) :: Stripe.Request.t
+  def retrieve(charge_id) do
+    %Stripe.Request{
+      method: :get,
+      endpoint: endpoint(charge_id)
+    }
+  end
+
+  @spec create(Enum.t) :: Stripe.Request.t
+  def create(params) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: endpoint(),
+      params: params
+    }
+  end
+
+  @spec update(binary, Enum.t) :: Stripe.Request.t
+  def update(charge_id, params) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: endpoint(charge_id),
+      params: params
+    }
   end
 
-  def capture(id, opts \\ []) do
-    Stripe.request(:post, capture_endpoint(id), [], opts)
+  @spec capture(binary) :: Stripe.Request.t
+  def capture(charge_id) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: "#{endpoint()}/#{charge_id}/capture"
+    }
   end
 end

lib/stripe/connect/account.ex

@@ -1,38 +1,114 @@
 defmodule Stripe.Account do
-  use Stripe.API, [:create, :retrieve, :update, :list, :delete]
+  @moduledoc"""
+  Functions related to connect accounts
+  """
 
-  def endpoint, do: "accounts"
+  @behaviour Stripe.API
 
-  def reject(account_id, [reason: reason], opts \\ []) do
-    Stripe.request(:post, "#{endpoint()}/#{account_id}/reject", [reason: reason], opts)
+  @spec endpoint(binary) :: binary
+  def endpoint(account_id \\ "") do 
+    "accounts/#{account_id}"
   end
 
+  @spec list(Enum.t) :: Stripe.Request.t
+  def list(pagination_opts \\ []) do 
+    %Stripe.Request{
+      method: :get,
+      endpoint: endpoint(),
+      params: pagination_opts
+    }
+  end
+
+  @spec retrieve(binary) :: Stripe.Request.t
+  def retrieve(account_id) do
+    %Stripe.Request{
+      method: :get,
+      endpoint: endpoint(account_id)
+    }
+  end
+
+  @spec create(Enum.t) :: Stripe.Request.t
+  def create(params) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: endpoint(),
+      params: params
+    }
+  end
+
+  @spec update(binary, Enum.t) :: Stripe.Request.t
+  def update(account_id, params) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: endpoint(account_id),
+      params: params
+    }
+  end
+
+  @spec delete(binary) :: Stripe.Request.t
+  def delete(account_id) do
+    %Stripe.Request{
+      method: :delete,
+      endpoint: endpoint(account_id)
+    }
+  end
+
+  @spec reject(binary, Enum.t) :: Stripe.Request.t
+  def reject(account_id, params) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: "#{endpoint(account_id)}/reject",
+      params: params
+    }
+  end
+
+  # external accounts
+
+  @spec external_account_endpoint(binary) :: binary
   def external_account_endpoint(account_id, external_account_id \\ "") do 
-    "#{endpoint()}/#{account_id}/external_accounts/#{external_account_id}"
+    "#{endpoint(account_id)}/external_accounts/#{external_account_id}"
   end 
 
-  def create_external_account(account_id, [external_account: token_id], opts \\ []) do
-    url = external_account_endpoint(account_id)
-    Stripe.request(:post, url, [external_account: token_id], opts)
+  @spec list_external_account(binary, Enum.t) :: Stripe.Request.t
+  def list_external_account(account_id, pagination_opts \\ []) do
+    %Stripe.Request{
+      method: :get,
+      endpoint: external_account_endpoint(account_id),
+      params: pagination_opts
+    }
   end
 
-  def retrieve_external_account(account_id, external_account_id, opts \\ []) do
-    url = external_account_endpoint(account_id, external_account_id)
-    Stripe.request(:get, url, [], opts)
+  @spec retrieve_external_account(binary, binary) :: Stripe.Request.t
+  def retrieve_external_account(account_id, external_account_id) do
+    %Stripe.Request{
+      method: :get,
+      endpoint: external_account_endpoint(account_id, external_account_id)
+    }
   end
 
-  def update_external_account(account_id, external_account_id, updates, opts \\ []) do
-    url = external_account_endpoint(account_id, external_account_id)
-    Stripe.request(:post, url, updates, opts)
+  @spec create_external_account(binary, Enum.t) :: Stripe.Request.t
+  def create_external_account(account_id, params) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: external_account_endpoint(account_id),
+      params: params
+    }
   end
 
-  def delete_external_account(account_id, external_account_id, opts \\ []) do
-    url = external_account_endpoint(account_id, external_account_id)
-    Stripe.request(:delete, url, [], opts)
+  @spec update_external_account(binary, binary, Enum.t) :: Stripe.Request.t
+  def update_external_account(account_id, external_account_id, params) do
+    %Stripe.Request{
+      method: :post,
+      endpoint: external_account_endpoint(account_id, external_account_id),
+      params: params
+    }
   end
 
-  def list_external_account(account_id, pagination_opts \\ [], opts \\ []) do
-    url = external_account_endpoint(account_id)
-    Stripe.request(:get, url, pagination_opts, opts)
+  @spec delete_external_account(binary, binary) :: Stripe.Request.t
+  def delete_external_account(account_id, external_account_id) do
+    %Stripe.Request{
+      method: :delete,
+      endpoint: external_account_endpoint(account_id, external_account_id)
+    }
   end
 end