Latch.Store behaviour (latch v0.5.0)

Copy Markdown

Storage backend for in-flight OAuth requests and long-lived sessions.

Implement this behavior in your app. The library is storage-agnostic. It hands you plains tructs and expects you to persist them however you like (Ecto, Redis, ETS, ...). The library never sees encryption or the database, that's your concerns.

Requests are keyed by the OAuth state. Sessions are keyed by the user's DID.

Summary

Types

did()
reason()
state()
store_error()

Callbacks

delete_session(did)

Delete the session for did. Return :ok even if missing.

fetch_session(did)

Fetch the session for did.

put_request(state, t, ttl_seconds)

Store an inflight request under state for at least ttl_seconds.

put_session(did, t)

Insert or replace session for did.

take_request(state)

Atomically fetch and remove the request for state.

update_session(did, function)

Run fun against the session for did under an exclusive lock, within an atomic transaction. Rotating refresh tokens are single use, so two concurrent refreshes must run in serial.

Types

did()

@type did() :: binary()

reason()

@type reason() :: :not_found | :backend_error

state()

@type state() :: binary()

store_error()

@type store_error() :: {:error, reason()}

Callbacks

delete_session(did)

@callback delete_session(did()) :: :ok | store_error()

Delete the session for did. Return :ok even if missing.

fetch_session(did)

@callback fetch_session(did()) :: {:ok, Latch.Session.t()} | store_error()

Fetch the session for did.

put_request(state, t, ttl_seconds)

@callback put_request(state(), Latch.Request.t(), ttl_seconds :: pos_integer()) ::
  :ok | store_error()

Store an inflight request under state for at least ttl_seconds.

put_session(did, t)

@callback put_session(did(), Latch.Session.t()) :: :ok | store_error()

Insert or replace session for did.

take_request(state)

@callback take_request(state()) :: {:ok, Latch.Request.t()} | store_error()

Atomically fetch and remove the request for state.

Single use. Must be consumable exactly once, even under concurrency. Return {:error, :not_found} if used or non-existant.

update_session(did, function)

@callback update_session(did(), (Latch.Session.t() ->
                         {:ok, Latch.Session.t()} | {:error, term()})) ::
  {:ok, Latch.Session.t()} | store_error()

Run fun against the session for did under an exclusive lock, within an atomic transaction. Rotating refresh tokens are single use, so two concurrent refreshes must run in serial.

Use FOR UPDATE or CAS to make atomic.

  • {:ok, new_session} persists new_session inside the same transaction and returns it.
  • {:error, reason} rolled back, reason propagated.

{:error, :not_found} if no session exists for did.