reitit.coercion — metosin/reitit 0.8.0

-compile-parameters clj/s

(-compile-parameters data coercion)

-identity-coercer clj/s

(-identity-coercer value _format)

coerce! clj/s

(coerce! match)

Returns a map of coerced input parameters using pre-compiled coercers in Match under path [:result :coerce] (provided by compile-request-coercers. Throws ex-info if parameters can't be coerced. If coercion or parameters are not defined, returns nil

coerce-query-params clj/s

(coerce-query-params match query-params)

Uses an input schema and coercion implementation from the given match to encode query-parameters map.

If no match, no input schema or coercion implementation, just returns the original parameters map.

coerce-request clj/s

(coerce-request coercers request)

coerce-response clj/s

(coerce-response coercers request response)

Coercion clj/s protocol

Pluggable coercion protocol

-get-name clj/s

(-get-name this)

Keyword name for the coercion

-get-options clj/s

(-get-options this)

Coercion options

-request-coercer clj/s

(-request-coercer this type model)

Returns a value format => value request coercion function

-response-coercer clj/s

(-response-coercer this model)

Returns a value format => value response coercion function

-compile-model clj/s

(-compile-model this model name)

Compiles a model

-get-model-apidocs clj/s

(-get-model-apidocs this specification model options)

Convert model into a format that can be used in api docs

-encode-error clj/s

(-encode-error this error)

Converts error in to a serializable format

-open-model clj/s

(-open-model this model)

Returns a new model which allows extra keys in maps

-query-string-coercer clj/s

(-query-string-coercer this model)

Returns a value => value query string coercion function

-get-apidocs clj/s

(-get-apidocs this specification data)

Returns api documentation

compile-request-coercers clj/s

(compile-request-coercers [_ {:keys [parameters coercion] :as data}] opts)

A router :compile implementation which reads the :parameters and :coercion data to both compile the schemas and create compiled coercers into Match under `:result with the following keys:

key	description
:data	data with compiled schemas
:coerce	function of Match -> coerced parameters to coerce parameters

A pre-requisite to use coerce!.

NOTE: this is not needed with ring/http, where the coercion compilation is managed in the request coercion middleware/interceptors.

content-request-coercer clj/s

(content-request-coercer
  coercion
  {:keys [content body]}
  {:reitit.coercion/keys [extract-request-format serialize-failed-result]
   :or {extract-request-format extract-request-format-default}})

encode-error clj/s

(encode-error data)

error? clj/s

(error? x)

extract-request-format-default clj/s

(extract-request-format-default request)

extract-response-format-default clj/s

(extract-response-format-default request _)

get-default clj/s

(get-default request-or-response)

match->path clj/s

(match->path match)

(match->path match query-params)

Create routing path from given match and optional query-parameters map.

Query-parameters are encoded using the input schema and coercion implementation.

request-coercer clj/s

(request-coercer coercion
                 type
                 model
                 {:reitit.coercion/keys [extract-request-format
                                         parameter-coercion
                                         serialize-failed-result skip]
                  :or {extract-request-format extract-request-format-default
                       parameter-coercion default-parameter-coercion
                       skip #{}}})

request-coercers clj/s

(request-coercers coercion parameters opts)

(request-coercers coercion parameters route-request opts)

response-coercer clj/s

(response-coercer coercion
                  {:keys [content body]}
                  {:keys [extract-response-format serialize-failed-result]
                   :or {extract-response-format
                          extract-response-format-default}})

response-coercers clj/s

(response-coercers coercion responses opts)