aleph.http.client-middleware — com.7theta/aleph 0.5.0-1

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

->Cookie clj

(->Cookie cookie)

accept-encoding-value clj

(accept-encoding-value accept-encoding)

add-cookie-header clj

(add-cookie-header cookie-store cookie-spec req)

basic-auth-value clj

(basic-auth-value basic-auth)

Accept a String of the form "username:password" or a vector of 2 strings [username password], return a String with the basic auth header (see https://tools.ietf.org/html/rfc2617#page-5)

client-error? clj

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

coerce-clojure-body clj

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

coerce-form-params clj multimethod

coerce-json-body clj

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

coerce-response-body clj multimethod

coerce-transit-body clj

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

conflict? clj

(conflict? {:keys [status]})

content-type-value clj

(content-type-value type)

cookie->netty-cookie clj

(cookie->netty-cookie {:keys [domain http-only? secure? max-age name path
                              value]})

cookie-expired? clj

(cookie-expired? {:keys [created max-age]})

cookie-header-name clj

CookieSpec clj protocol

Implement rules for accepting and returning cookies

match-cookie-origin? clj

(match-cookie-origin? this origin cookie)

parse-cookie clj

(parse-cookie this cookie-str)

write-cookies clj

(write-cookies this cookies)

CookieStore clj protocol

add-cookies! clj

(add-cookies! this cookies)

get-cookies clj

(get-cookies this)

decode-set-cookie-header clj

(decode-set-cookie-header header)

(decode-set-cookie-header cookie-spec header)

default-cookie-spec clj

Default cookie spec implementation providing RFC6265 compliant behavior with no validation for cookie names and values. In case you need strict validation feel free to create impl. using {ClientCookieDecoder,ClientCookiEncoder}/STRICT instead of LAX instances

default-middleware clj

detect-charset clj

(detect-charset content-type)

Given a charset header, detect the charset, returns UTF-8 if not found.

enrich-with-current-time clj

(enrich-with-current-time cookies)

extract-cookies-from-response-headers clj

(extract-cookies-from-response-headers headers)

(extract-cookies-from-response-headers cookie-spec headers)

follow-redirect clj

(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 clj

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

generate-query-string-with-encoding clj

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

(generate-query-string-with-encoding params encoding multi-param-style)

handle-cookies clj

(handle-cookies {:keys [cookie-store cookie-spec]
                 :or {cookie-spec default-cookie-spec}}
                {:keys [headers] :as rsp})

handle-redirects clj

(handle-redirects client req 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

handle-response-debug clj

(handle-response-debug req rsp)

in-memory-cookie-store clj

(in-memory-cookie-store)

(in-memory-cookie-store seed-cookies)

In-memory storage to maintain cookies across requests

json-decode clj

(json-decode & args)

Resolve and apply cheshire's json decoding dynamically.

json-decode-strict clj

(json-decode-strict & args)

Resolve and apply cheshire's json decoding dynamically (with lazy parsing disabled).

json-enabled? clj

json-encode clj

(json-encode & args)

Resolve and apply cheshire's json encoding dynamically.

match-cookie-domain? clj

(match-cookie-domain? origin domain)

match-cookie-path? clj

(match-cookie-path? origin-path cookie-path)

merge-cookies clj

(merge-cookies stored-cookies new-cookies)

missing? clj

(missing? {:keys [status]})

multi-param-suffix clj

(multi-param-suffix index multi-param-style)

netty-cookie->cookie clj

(netty-cookie->cookie cookie)

opt clj

(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 clj

(parse-content-type s)

Parse s as an RFC 2616 media type.

parse-transit clj

(parse-transit in type & [opts])

Resolve and apply Transit's JSON/MessagePack decoding.

parse-url clj

(parse-url url)

Parse a URL string into a map of interesting parts.

parse-user-info clj

(parse-user-info user-info)

redirect? clj

(redirect? {:keys [status]})

reduce-to-unique-cookie-names clj

(reduce-to-unique-cookie-names cookies)

req->cookie-origin clj

(req->cookie-origin {:keys [url] :as req})

server-error? clj

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

set-cookie-header-name clj

success? clj

(success? {:keys [status]})

transit-enabled? clj

transit-encode clj

(transit-encode out type & [opts])

Resolve and apply Transit's JSON/MessagePack encoding.

unexceptional-status? clj

url-encode clj

(url-encode s)

(url-encode s encoding)

url-encode-illegal-characters clj

(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 clj

(when-pos v)

wrap-accept clj

(wrap-accept {:keys [accept] :as req})

Middleware converting the :accept key in a request to application/<type>

wrap-accept-encoding clj

(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 clj

(wrap-basic-auth req)

Middleware converting the :basic-auth option into an Authorization header.

wrap-content-type clj

(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-cookies clj

(wrap-cookies {:keys [cookie-store cookie-spec cookies]
               :or {cookie-spec default-cookie-spec cookies (quote ())}
               :as req})

Middleware that set 'Cookie' header based on the content of cookies passed with the request or from cookies storage (when provided). Source for 'Cookie' header content by priorities:

• 'Cookie' header (already set)
• non-empty :cookies
• non-nil :cookie-store

Each cookie should be represented as a map:

|:---|:--- | name | name of this cookie | value | value of this cookie | domain | specifies allowed hosts to receive the cookie (including subdomains) | path | indicates a URL path that must exist in the requested URL in order to send the 'Cookie' header | http-only? | when set to true, cookie can only be accessed by HTTP. Optional, defaults to false | secure? | when set to true, cookie can only be transmitted over an encrypted connection. Optional, defaults to false | max-age | set maximum age of this cookie in seconds. Options, defaults to io.netty.handler.codec.http.cookie.Cookie/UNDEFINED_MAX_AGE.

wrap-exceptions clj

(wrap-exceptions client)

Middleware that throws response as an ExceptionInfo if the response has unsuccessful status code. :throw-exceptions set to false in the request disables this middleware.

wrap-form-params clj

(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 clj

(wrap-method req)

Middleware converting the :method option into the :request-method option

wrap-nested-params clj

(wrap-nested-params {:keys [content-type flatten-nested-keys] :as req})

Middleware wrapping nested parameters for query strings.

wrap-oauth clj

(wrap-oauth req)

Middleware converting the :oauth-token option into an Authorization header.

wrap-query-params clj

(wrap-query-params {:keys [query-params content-type multi-param-style]
                    :or {content-type :x-www-form-urlencoded
                         multi-param-style :default}
                    :as req})

Middleware converting the :query-params option to a querystring on the request.

wrap-request clj

(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-debug clj

(wrap-request-debug req)

wrap-request-timing clj

(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 clj

(wrap-url req)

Middleware wrapping request URL parsing.

wrap-user-info clj

(wrap-user-info req)

Middleware converting the :user-info option into a :basic-auth option

write-cookie-header clj

(write-cookie-header cookies cookie-spec req)