aleph.http.client-middleware

This middleware is adapted from clj-http, whose license is amendable to this sort of
copy/pastery

accept-encoding-value

(accept-encoding-value accept-encoding)

basic-auth-value

(basic-auth-value basic-auth)

client-error?

(client-error? {:keys [status]})

coerce-clojure-body

(coerce-clojure-body request {:keys [body], :as resp})

coerce-form-params

multimethod

coerce-json-body

(coerce-json-body {:keys [coerce], :as req} {:keys [body status], :as resp} keyword? strict? & [charset])

coerce-response-body

multimethod

coerce-transit-body

(coerce-transit-body {:keys [transit-opts], :as request} {:keys [body], :as resp} type)

conflict?

(conflict? {:keys [status]})

content-type-value

(content-type-value type)

default-middleware

detect-charset

(detect-charset content-type)
Given a charset header, detect the charset, returns UTF-8 if not found.

dissoc-in

(dissoc-in m [k & ks :as keys])
Dissociates an entry from a nested associative structure returning a new
nested structure. keys is a sequence of keys. Any empty maps that result
will not be present in the new structure.

follow-redirect

(follow-redirect client {:keys [uri url scheme server-name server-port trace-redirects], :or {trace-redirects []}, :as req} {:keys [body], :as rsp})
Attempts to follow the redirects from the "location" header, if no such
header exists (bad server!), returns the response without following the
request.

generate-query-string

(generate-query-string params & [content-type])

generate-query-string-with-encoding

(generate-query-string-with-encoding params encoding)

handle-redirects

(handle-redirects client {:keys [request-method max-redirects redirects-count trace-redirects url], :or {redirects-count 0, max-redirects 20}, :as req} {:keys [status], :as rsp})
Middleware that follows redirects in the response. A slingshot exception is
thrown if too many redirects occur. Options
:follow-redirects - default:true, whether to follow redirects
:max-redirects - default:20, maximum number of redirects to follow
:force-redirects - default:false, force redirecting methods to GET requests

In the response:
:redirects-count - number of redirects
:trace-redirects - vector of sites the request was redirected from

json-decode

dynamic

(json-decode & args)
Resolve and apply cheshire's json decoding dynamically.

json-decode-strict

dynamic

(json-decode-strict & args)
Resolve and apply cheshire's json decoding dynamically (with lazy parsing
disabled).

json-enabled?

json-encode

dynamic

(json-encode & args)
Resolve and apply cheshire's json encoding dynamically.

missing?

(missing? {:keys [status]})

opt

(opt req param)
Check the request parameters for a keyword  boolean option, with or without
the ?

Returns false if either of the values are false, or the value of
(or key1 key2) otherwise (truthy)

parse-content-type

(parse-content-type s)
Parse `s` as an RFC 2616 media type.

parse-transit

dynamic

(parse-transit in type & [opts])
Resolve and apply Transit's JSON/MessagePack decoding.

parse-url

(parse-url url)
Parse a URL string into a map of interesting parts.

parse-user-info

(parse-user-info user-info)

redirect?

(redirect? {:keys [status]})

server-error?

(server-error? {:keys [status]})

success?

(success? {:keys [status]})

transit-enabled?

transit-encode

dynamic

(transit-encode out type & [opts])
Resolve and apply Transit's JSON/MessagePack encoding.

unexceptional-status?

update

(update m k f & args)

url-encode

(url-encode s)(url-encode s encoding)

url-encode-illegal-characters

(url-encode-illegal-characters path-or-query)
Takes a raw url path or query and url-encodes any illegal characters.
Minimizes ambiguity by encoding space to %20.

when-pos

(when-pos v)

wrap-accept

(wrap-accept {:keys [accept], :as req})
Middleware converting the :accept key in a request to application/<type>

wrap-accept-encoding

(wrap-accept-encoding {:keys [accept-encoding], :as req})
Middleware converting the :accept-encoding option to an acceptable
Accept-Encoding header in the request.

wrap-basic-auth

(wrap-basic-auth req)
Middleware converting the :basic-auth option into an Authorization header.

wrap-content-type

(wrap-content-type {:keys [content-type character-encoding], :as req})
Middleware converting a `:content-type <keyword>` option to the formal
application/<name> format and adding it as a header.

wrap-exceptions

(wrap-exceptions client)
Middleware that throws a slingshot exception if the response is not a
regular response. If :throw-entire-message? is set to true, the entire
response is used as the message, instead of just the status number.

wrap-form-params

(wrap-form-params {:keys [form-params content-type request-method], :or {content-type :x-www-form-urlencoded}, :as req})
Middleware wrapping the submission or form parameters.

wrap-method

(wrap-method req)
Middleware converting the :method option into the :request-method option

wrap-nested-params

(wrap-nested-params {:keys [content-type], :as req})
Middleware wrapping nested parameters for query strings.

wrap-oauth

(wrap-oauth req)
Middleware converting the :oauth-token option into an Authorization header.

wrap-query-params

(wrap-query-params {:keys [query-params content-type], :or {content-type :x-www-form-urlencoded}, :as req})
Middleware converting the :query-params option to a querystring on
the request.

wrap-request

(wrap-request client)
Returns a batteries-included HTTP request function corresponding to the given
core client. See default-middleware for the middleware wrappers that are used
by default

wrap-request-timing

(wrap-request-timing client)
Middleware that times the request, putting the total time (in milliseconds)
of the request into the :request-time key in the response.

wrap-url

(wrap-url req)
Middleware wrapping request URL parsing.

wrap-user-info

(wrap-user-info req)
Middleware converting the :user-info option into a :basic-auth option