defmodule EPTSDK do
@default_query_options %{
filter: %{},
include: [],
sort: [],
page: [],
fields: %{}
}
@enforce_keys [
:authorization,
:user_agent,
:host,
:json_decoder,
:json_encoder,
:namespace,
:finch_options
]
@default_headers []
defstruct authorization: nil,
user_agent: nil,
host: "api.tryedge.com",
json_decoder: &Jason.decode/1,
json_encoder: &Jason.encode/1,
namespace: EPTSDK.Finch,
finch_options: [],
response: nil,
links: nil,
included: nil,
meta: nil
def client(%{token: token, user_agent: user_agent} = properties) when is_map(properties) do
struct(
__MODULE__,
%{
authorization: "Bearer #{token}",
user_agent: user_agent
}
|> Map.merge(properties)
)
end
def get(%EPTSDK{} = client, path, query \\ [])
when is_binary(path) do
Finch.build(
:get,
encode_uri(client.host, path, with_query_defaults(query)),
default_headers(client, [
{"Accept", "application/vnd.api+json"}
])
)
|> request(client)
|> response(client)
end
def options(%EPTSDK{} = client, path, query \\ [])
when is_binary(path) do
Finch.build(
:options,
encode_uri(client.host, path, with_query_defaults(query)),
default_headers(client)
)
|> request(client)
|> response(client)
end
def delete(%EPTSDK{} = client, path, query \\ [])
when is_binary(path) do
Finch.build(
:delete,
encode_uri(client.host, path, with_query_defaults(query)),
default_headers(client)
)
|> request(client)
|> response(client)
end
def post(%EPTSDK{} = client, path, data, query \\ [])
when is_binary(path) and is_map(data) do
data
|> client.json_encoder.()
|> case do
{:ok, payload} ->
Finch.build(
:post,
encode_uri(client.host, path, with_query_defaults(query)),
default_headers(client, [
{"Content-Type", "application/vnd.api+json"},
{"Accept", "application/vnd.api+json"}
]),
payload
)
|> request(client)
|> response(client)
error ->
error
end
end
def patch(%EPTSDK{} = client, path, data, query \\ [])
when is_binary(path) and is_map(data) do
data
|> client.json_encoder.()
|> case do
{:ok, payload} ->
Finch.build(
:patch,
encode_uri(client.host, path, with_query_defaults(query)),
default_headers(client, [
{"Content-Type", "application/vnd.api+json"},
{"Accept", "application/vnd.api+json"}
]),
payload
)
|> request(client)
|> response(client)
error ->
error
end
end
def put(%EPTSDK{} = client, path, data, query \\ [])
when is_binary(path) and is_map(data) do
data
|> client.json_encoder.()
|> case do
{:ok, payload} ->
Finch.build(
:put,
encode_uri(client.host, path, with_query_defaults(query)),
default_headers(client, [
{"Content-Type", "application/vnd.api+json"},
{"Accept", "application/vnd.api+json"}
]),
payload
)
|> request(client)
|> response(client)
error ->
error
end
end
defp encode_uri(host, path, nil)
when is_binary(host) and is_binary(path),
do:
encode_uri(
URI.parse("https://#{host}"),
URI.parse(path),
nil
)
defp encode_uri(host, path, nil)
when is_struct(host, URI) and is_struct(path, URI),
do: URI.parse("#{host}#{path}")
defp encode_uri(host, path, query)
when is_binary(host) and is_binary(path) and is_map(query),
do:
encode_uri(
URI.parse("https://#{host}"),
URI.parse(path),
Plug.Conn.Query.encode(query)
)
defp encode_uri(host, path, query)
when is_struct(host, URI) and is_struct(path, URI) and is_binary(query),
do: URI.parse("#{host}#{path}?#{query}")
defp default_headers(
%EPTSDK{user_agent: user_agent, authorization: authorization},
custom_headers \\ []
)
when is_binary(user_agent) and is_list(custom_headers) do
@default_headers
|> Enum.concat([
{"User-Agent", Enum.join(["Edge Payment Client/1.0.0", user_agent], " ")},
{"Authorization", authorization}
])
|> Enum.concat(custom_headers)
end
defp request(finch_client, edge_client),
do: finch_client |> Finch.request(edge_client.namespace, edge_client.finch_options)
defp response({:ok, %Finch.Response{status: 422, body: body} = response}, edge_client) do
edge_client.json_decoder.(body)
|> case do
{:ok, payload} -> {:unprocessable_content, payload, response}
{:error, decoding_error} -> {:decoding_error, decoding_error, response}
end
end
defp response({:ok, %Finch.Response{status: status} = response}, _edge_client)
when status in 400..499 do
{:error, response}
end
defp response({:ok, %Finch.Response{body: ""} = response}, _edge_client) do
{:ok, nil, response}
end
defp response({:ok, %Finch.Response{body: body} = response}, edge_client) do
edge_client.json_decoder.(body)
|> case do
{:ok, payload} -> {:ok, payload, response}
{:error, decoding_error} -> {:decoding_error, decoding_error, response}
end
end
defp response({:error, error}, _edge_client) do
{:error, error}
end
defp with_query_defaults(nil), do: nil
defp with_query_defaults([]), do: nil
defp with_query_defaults(query) when is_list(query) do
%{
filter: query |> Keyword.get(:filter, @default_query_options[:filter]),
fields:
query
|> Keyword.get(:fields, @default_query_options[:fields])
|> encode_fields_query(),
sort: query |> Keyword.get(:sort, @default_query_options[:sort]) |> Enum.join(","),
page: query |> Keyword.get(:page, @default_query_options[:page]),
include: query |> Keyword.get(:include, @default_query_options[:include]) |> Enum.join(",")
}
|> Enum.filter(fn
{_key, ""} -> false
{_key, nil} -> false
{_key, _value} -> true
end)
|> Map.new()
end
defp with_query_defaults(%{}), do: %{}
defp encode_fields_query(fields) when is_map(fields) do
fields
|> Enum.map(fn {resource, fields} when is_list(fields) ->
{resource, Enum.join(fields, ",")}
end)
|> Map.new()
end
def update_client_from_request(
{:ok, payload, %Finch.Response{} = response},
%EPTSDK{} = client
)
when is_map(payload) do
{:ok, payload,
%__MODULE__{
client
| response: response,
included: Enum.map(payload["included"] || [], &EPTSDK.Entity.to_struct(&1, nil)),
links: payload["links"],
meta: payload["meta"]
}}
end
def update_client_from_request({:error, _exception} = error, _client), do: error
def update_client_from_request(
{:unprocessable_content, _exception, _response} = error,
_client
),
do: error
def update_client_from_request({:decoding_error, _exception, _response} = error, _client),
do: error
def update_client_from_request({:error, _exception, _response} = error, _client), do: error
end
