CrossClj

2.0.0-alpha19 docs

SourceDocs



RECENT
    VARS
    api-middleware
    api-middleware-defaults
    api-middleware-options
    call-error-handler
    compose-middleware
    create-muuntaja
    encode?
    get-components
    get-swagger-data
    middleware-fn
    set-swagger-data
    super-classes
    wrap-coercion
    wrap-components
    wrap-exceptions
    wrap-inject-data
    wrap-swagger-data

    « Index of all namespaces of this project

    (api-middleware handler)(api-middleware handler options)
    Opinionated chain of middlewares for web apis. Takes optional options-map.
    
    ### Exception handlers
    
    An error handler is a function of exception, ex-data and request to response.
    
    When defining these options, it is suggested to use alias for the exceptions namespace,
    e.g. `[compojure.api.exception :as ex]`.
    
    Default:
    
        {::ex/request-validation  ex/request-validation-handler
         ::ex/request-parsing     ex/request-parsing-handler
         ::ex/response-validation ex/response-validation-handler
         ::ex/default             ex/safe-handler}
    
    Note: Because the handlers are merged into default handlers map, to disable default handler you
    need to provide nil value as handler.
    
    Note: To catch Schema errors use `{:schema.core/error ex/schema-error-handler}`.
    
    ### Options
    
    - **:exceptions**                for *compojure.api.middleware/wrap-exceptions* (nil to unmount it)
        - **:handlers**                Map of error handlers for different exception types, type refers to :type key in ExceptionInfo data.
    
    - **:formats**                   for Muuntaja middleware. Value can be a valid muuntaja options-map,
                                     a Muuntaja instance or nil (to unmount it). See
                                     https://github.com/metosin/muuntaja/wiki/Configuration for details.
    
    - **:middleware**                vector of extra middleware to be applied last (just before the handler).
    
    - **:ring-swagger**              options for ring-swagger's swagger-json method.
                                     e.g. `{:ignore-missing-mappings? true}`
    
    - **:coercion**                  A function from request->type->coercion-matcher, used
                                     in endpoint coercion for types :body, :string and :response.
                                     Defaults to compojure.api.middleware/default-coercion
                                     Setting value to nil disables all coercion.
    
    - **:components**                Components which should be accessible to handlers using
                                     :components restructuring. (If you are using api,
                                     you might want to take look at using wrap-components
                                     middleware manually.). Defaults to nil (middleware not mounted).
    (api-middleware-options options)
    Private
    (call-error-handler default-handler handlers error request)
    (compose-middleware middleware)
    (create-muuntaja)(create-muuntaja muuntaja-or-options)
    (encode? _ response)
    Returns true if the response body is serializable: body is a
    collection or response has key :compojure.api.meta/serializable?
    (get-components req)
    (get-swagger-data request)
    Reads and deep-merges top-level swagger-data from request,
    pushed in by set-swagger-data.
    (middleware-fn middleware)
    (set-swagger-data request data)
    Add extra top-level swagger-data into a request.
    Data can be read with get-swagger-data.
    Private
    (super-classes k)
    (wrap-coercion handler coercion)
    (wrap-components handler components)
    Assoc given components to the request.
    
    (wrap-exceptions handler {:keys [handlers]})
    Catches all exceptions and delegates to correct error handler according to :type of Exceptions
    - **:handlers** - a map from exception type to handler
      - **:compojure.api.exception/default** - Handler used when exception type doesn't match other handler,
                                               by default prints stack trace.
    (wrap-inject-data handler data)
    Injects data into the request.
    
    (wrap-swagger-data handler data)
    Middleware that adds top level swagger-data into request.