defmodule UnkeyElixirSdk do
use GenServer
require Logger
alias HTTPoison
alias Jason
@moduledoc """
Documentation for `UnkeyElixirSdk`.
"""
# Client
@doc """
Start the GenServer
Returns {:ok, pid}
## Examples
iex> UnkeyElixirSdk.start_link(%{token: "yourtoken"})
`{:ok, pid}`
iex> UnkeyElixirSdk.start_link(%{token: "yourtoken", base_url: "theunkeybaseurl"})
`{:ok, pid}`
"""
@spec start_link(map) :: {:ok, pid}
def start_link(default) when is_map(default) do
:ets.new(:pid_store, [:set, :public, :named_table])
if map_size(default) === 0 do
handle_error(
"You need to specify at least the token in either the supervisor or via the start_link function i.e. start_link(%{token: 'mytoken'})"
)
end
{:ok, pid} = GenServer.start_link(__MODULE__, default)
# save the PID to a store so the user does not need to alwayd supply it
:ets.insert(:pid_store, {"pid", pid})
{:ok, pid}
end
@doc """
Creates an API key for your users
Returns a map with the key
`%{"keyId" => "key_cm9vdCBvZiBnb29kXa", "key" => "xyz_AS5HDkXXPot2MMoPHD8jnL"}`
## Examples
iex> UnkeyElixirSdk.create_key(%{"apiId" => "myapiid"})
%{"keyId" => "key_cm9vdCBvZiBnb29kXa", "key" => "xyz_AS5HDkXXPot2MMoPHD8jnL"}
iex> `UnkeyElixirSdk.create_key(%{
"apiId" => "myapiid",
"prefix" => "xyz",
"byteLength" => 16,
"ownerId" => "glamboyosa",
"meta" => %{
"hello" => "world"
},
"expires" => 1_686_941_966_471,
"ratelimit" => %{
"type" => "fast",
"limit" => 10,
"refillRate" => 1,
"refillInterval" => 1000
},
"remaining" => 5
})`
%{"keyId" => "key_cm9vdCBvZiBnb29kXa", "key" => "xyz_AS5HDkXXPot2MMoPHD8jnL"}
"""
@spec create_key(map) :: map()
def create_key(opts) when is_map(opts) do
if(is_nil(Map.get(opts, "apiId"))) do
handle_error("You need to specify at least the apiId in the form %{apiId: 'yourapiId'}")
end
[{_m, pid}] = :ets.lookup(:pid_store, "pid")
GenServer.call(pid, {:create_key, opts}, 6000)
end
@doc """
Verify a key from your users. You only need to send the api key from your user. Optionally, second param is a map with the key `apiId` which sends the apiId
Returns a map with whether the key is valid or not. Optionally sends `ownerId` and `meta`
## Examples
iex> UnkeyElixirSdk.verify_key("xyz_AS5HDkXXPot2MMoPHD8jnL")
`%{"valid" => true,
"ownerId" => "chronark",
"meta" => %{
"hello" => "world"
}}`
iex> UnkeyElixirSdk.verify_key("xyz_AS5HDkXXPot2MMoPHD8jnL", %{"apiId"} => "api_sASDSsgeegd")
`%{"valid" => true,
"ownerId" => "chronark",
"meta" => %{
"hello" => "world"
}}`
"""
@spec verify_key(binary, map()) :: map()
def verify_key(key, opts \\ %{}) when is_binary(key) do
[{_m, pid}] = :ets.lookup(:pid_store, "pid")
GenServer.call(pid, {:verify_key, key, opts}, :infinity)
end
@doc """
Delete an api key for your users
Returns :ok
## Examples
iex> UnkeyElixirSdk.delete_key("key_cm9vdCBvZiBnb29kXa")
:ok
"""
@spec delete_key(binary) :: :ok
def delete_key(key) when is_binary(key) do
[{_m, pid}] = :ets.lookup(:pid_store, "pid")
GenServer.call(pid, {:delete_key, key}, :infinity)
end
@doc """
Updates the `remaining` value for a specified key.
Takes in a map of the shape:
%{
"keyId": "key_123",
"op": "increment",
"value": 1
}
Where "op" is "increment" | "decrement" | "set"
and value is the value you want to increase by or nil (unlimited)
Returns a map with the updated "remaining" value.
## Examples
iex> UnkeyElixirSdk.update_remaining(%{
"keyId": "key_123",
"op": "increment",
"value": 1
})
%{remaining: 100}
"""
@spec update_remaining(map()) :: :ok
def update_remaining(opts) when is_map(opts) do
[{_m, pid}] = :ets.lookup(:pid_store, "pid")
GenServer.call(pid, {:update_remaining, opts}, :infinity)
end
@doc """
Updates the configuration of a key
Takes in a `key_id` argument and a map whose members are optional
but must have at most 1 member present.
```
%{
"name" => "my_new_key",
"ownerId" => "still_glamboyosa",
"meta" => %{
"hello" => "world"
},
"expires" => 1_686_941_966_471,
"ratelimit" => %{
"type" => "fast",
"limit" => 15,
"refillRate" => 2,
"refillInterval" => 500
},
"remaining" => 3
}
```
Returns :ok
## Examples
```
iex> UnkeyElixirSdk.update_key("key_cm9vdCBvZiBnb29kXa", %{
"name" => "my_new_key",
"ownerId" => "still_glamboyosa",
"meta" => %{
"hello" => "world"
},
"expires" => 1_686_941_966_471,
"ratelimit" => %{
"type" => "fast",
"limit" => 15,
"refillRate" => 2,
"refillInterval" => 500
},
"remaining" => 3
})
```
:ok
"""
@spec update_key(binary(), map()) :: :ok
def update_key(key_id, opts) when is_map(opts) and is_binary(key_id) do
[{_m, pid}] = :ets.lookup(:pid_store, "pid")
GenServer.call(pid, {:update_key, key_id, opts}, :infinity)
end
# Server (callbacks)
@impl true
def init(elements) do
case Map.get(elements, :base_url) do
nil ->
base_url = "https://api.unkey.dev/v1/keys."
elements = Map.put(elements, :base_url, base_url)
{:ok, elements}
_ ->
base_url = "https://api.unkey.dev/v1/keys."
elements = Map.put_new(elements, :base_url, base_url)
{:ok, elements}
end
end
@impl true
def handle_call({:create_key, opts}, _from, state) do
body = opts |> Jason.encode!()
case HTTPoison.post("#{state.base_url}createKey", body, headers(state.token)) do
{:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
{:reply, Map.new(Jason.decode!(body)), state}
{:ok, %HTTPoison.Response{status_code: 404}} ->
handle_error("Not found :(")
{:ok, %HTTPoison.Response{status_code: 401}} ->
handle_error("Unauthorised")
{:error, %HTTPoison.Error{reason: reason}} ->
IO.inspect(reason)
handle_error(to_string(reason))
{:ok, %HTTPoison.Response{body: body}} ->
handle_error(to_string(body))
_ ->
handle_error(to_string("Something went wrong"))
end
end
@impl true
def handle_call({:update_remaining, opts}, _from, state) do
validate_params(opts)
body = opts |> Jason.encode!()
case HTTPoison.post("#{state.base_url}updateRemaining", body, headers(state.token)) do
{:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
{:reply, Map.new(Jason.decode!(body)), state}
{:ok, %HTTPoison.Response{status_code: 404}} ->
handle_error("Not found :(")
{:ok, %HTTPoison.Response{status_code: 401}} ->
handle_error("Unauthorised")
{:error, %HTTPoison.Error{reason: reason}} ->
IO.inspect(reason)
handle_error(to_string(reason))
{:ok, %HTTPoison.Response{body: body}} ->
handle_error(to_string(body))
_ ->
handle_error(to_string("Something went wrong"))
end
end
@impl true
def handle_call({:delete_key, key_id}, _from, state) do
body = %{"keyId" => key_id} |> Jason.encode!()
case HTTPoison.post("#{state.base_url}deleteKey", body, headers(state.token)) do
{:ok, %HTTPoison.Response{status_code: 200}} ->
{:reply, :ok, state}
{:ok, %HTTPoison.Response{status_code: 404}} ->
handle_error("Not found :(")
{:ok, %HTTPoison.Response{status_code: 401}} ->
handle_error("Unauthorised")
{:error, %HTTPoison.Error{reason: reason}} ->
IO.inspect(reason)
handle_error(to_string(reason))
{:ok, %HTTPoison.Response{body: body}} ->
handle_error(to_string(body))
_ ->
handle_error(to_string("Something went wrong"))
end
end
@impl true
def handle_call({:update_key, key_id, opts}, _from, state) do
body =
%{
"keyId" => key_id,
"name" => :undefined,
"ownerId" => :undefined,
"meta" => :undefined,
"expires" => :undefined,
"ratelimit" => :undefined,
"remaining" => :undefined
}
|> Map.merge(opts)
|> Map.filter(&(elem(&1, 1) !== :undefined))
|> Jason.encode!()
case HTTPoison.post("#{state.base_url}updateKey", body, headers(state.token)) do
{:ok, %HTTPoison.Response{status_code: 200}} ->
{:reply, :ok, state}
{:ok, %HTTPoison.Response{status_code: 404}} ->
handle_error("Not found :(")
{:ok, %HTTPoison.Response{status_code: 401}} ->
handle_error("Unauthorised")
{:error, %HTTPoison.Error{reason: reason}} ->
IO.inspect(reason)
handle_error(to_string(reason))
{:ok, %HTTPoison.Response{body: body}} ->
handle_error(to_string(body))
_ ->
handle_error(to_string("Something went wrong"))
end
end
@impl true
def handle_call({:verify_key, key, opts}, _from, state) do
body =
%{"key" => key}
|> Map.merge(opts)
|> Jason.encode!()
case HTTPoison.post("#{state.base_url}verifyKey", body, headers(state.token)) do
{:ok, %HTTPoison.Response{status_code: 200, body: body}} ->
{:reply, Jason.decode!(body), state}
{:ok, %HTTPoison.Response{status_code: 404}} ->
handle_error("Not found :(")
{:ok, %HTTPoison.Response{status_code: 401}} ->
handle_error("Unauthorised")
{:error, %HTTPoison.Error{reason: reason}} ->
IO.inspect(reason)
handle_error(to_string(reason))
{:ok, %HTTPoison.Response{body: body}} ->
handle_error(to_string(body))
_ ->
handle_error(to_string("Something went wrong"))
end
end
defp handle_error(error_message) when is_binary(error_message) do
try do
throw(error_message)
catch
err ->
log_error("Error Message #{err}")
end
end
defp log_error(input) when is_binary(input) do
IO.puts(input)
end
defp headers(token) do
[{"Authorization", "Bearer #{token}"}, {"Content-Type", "application/json; charset=UTF-8"}]
end
defp validate_params(params) do
# Runtime checks to ensure op is valid and value is a number or nil
valid_ops = ~w(increment decrement set)a
op = String.to_atom(params["op"])
if !Enum.member?(valid_ops, op) do
raise ArgumentError, "Invalid operation '#{op}', expected one of: #{inspect(valid_ops)}"
end
value = params["value"]
unless is_nil(value) || is_integer(value) do
raise ArgumentError, "Invalid value '#{value}', expected an integer or nil"
end
end
end
