ring.middleware.turnstile — threatgrid/ring-turnstile-middleware 0.1.1

AnyMap clj

compute-limits clj

(compute-limits limit-fns request ctx)

Inputs: [limit-fns :- [LimitFunction] request :- HttpRequest ctx] Returns: [Limit]

Conf clj

default-rate-limit-handler clj

(default-rate-limit-handler request next-slot-in-sec limit)

first-reached-limit clj

(first-reached-limit limits)

Inputs: [limits :- [Limit]] Returns: (s/maybe Limit)

header-limit clj

(header-limit n header name-in-headers)

Inputs: [n header name-in-headers] Returns: LimitFunction

HttpRequest clj

HttpResponse clj

ip-limit clj

(ip-limit n)

Inputs: [n]

Limit clj

LimitFunction clj

make-token clj

(make-token)

next-slot-in-sec clj

(next-slot-in-sec next-slot-in-ms)

rate-limit-headers clj

(rate-limit-headers {:keys [turnstile nb-request-per-hour name-in-headers]}
                    remaining-header-enabled)

Inputs: [{:keys [turnstile nb-request-per-hour name-in-headers]} :- Limit remaining-header-enabled :- s/Bool]

rate-limited? clj

(rate-limited? {:keys [turnstile nb-request-per-hour]})

Inputs: [{:keys [turnstile nb-request-per-hour]} :- Limit] Returns: s/Bool

RedisConn clj

RedisSpec clj

turnstile-expiration-ms clj

with-turnstile clj

(with-turnstile {:keys [rate-limit-key] :as limit}
                {:keys [redis-conn key-prefix] :as ctx})

Inputs: [{:keys [rate-limit-key], :as limit} :- Limit {:keys [redis-conn key-prefix], :as ctx}] Returns: Limit

wrap-rate-limit clj

(wrap-rate-limit handler
                 {:keys [redis-conn limit-fns rate-limit-handler key-prefix
                         remaining-header-enabled]
                  :or {rate-limit-handler default-rate-limit-handler
                       key-prefix ""
                       remaining-header-enabled false}
                  :as conf})

Middleware for the turnstile rate limiting service