reitit.ring — metosin/reitit 0.3.10

coerce-handler clj/s

(coerce-handler [path data] {:keys [expand] :as opts})

compile-result clj/s

(compile-result [path data]
                {:reitit.ring/keys [default-options-handler] :as opts})

create-default-handler clj/s

(create-default-handler)

(create-default-handler
  {:keys [not-found method-not-allowed not-acceptable]
   :or {not-found (constantly {:status 404 :body "" :headers {}})
        method-not-allowed (constantly {:status 405 :body "" :headers {}})
        not-acceptable (constantly {:status 406 :body "" :headers {}})}})

A default ring handler that can handle the following cases, configured via options:

key	description
:not-found	404, no routes matches
:method-not-allowed	405, no method matches
:not-acceptable	406, handler returned nil

create-enrich-default-request clj/s

(create-enrich-default-request inject-router?)

create-enrich-request clj/s

(create-enrich-request inject-match? inject-router?)

create-resource-handler clj

(create-resource-handler)

(create-resource-handler
  {:keys [parameter root path loader allow-symlinks? index-files paths
          not-found-handler]
   :or {parameter (keyword "")
        root "public"
        index-files ["index.html"]
        paths (constantly nil)
        not-found-handler (constantly {:status 404 :body "" :headers {}})}})

A ring handler for serving classpath resources, configured via options:

key	description
:parameter	optional name of the wildcard parameter, defaults to unnamed keyword :
:root	optional resource root, defaults to "public"
:path	optional path to mount the handler to. Works only if mounted outside of a router.
:loader	optional class loader to resolve the resources
:index-files	optional vector of index-files to look in a resource directory, defaults to ["index.html"]
:not-found-handler	optional handler function to use if the requested resource is missing (404 Not Found)

default-options-handler clj/s

Endpoint cljs

get-match clj/s

(get-match request)

get-router clj/s

(get-router handler)

group-keys clj/s

(group-keys data)

http-methods clj/s

Methods cljs

redirect-trailing-slash-handler clj/s

(redirect-trailing-slash-handler)

(redirect-trailing-slash-handler {:keys [method]})

A ring handler that redirects a missing path if there is an existing path that only differs in the ending slash.

key	description
:method	:add - redirects slash-less to slashed
	:strip - redirects slashed to slash-less
	:both - works both ways (default)

ring-handler clj/s

(ring-handler router)

(ring-handler router default-handler)

(ring-handler router
              default-handler
              {:keys [middleware inject-match? inject-router?]
               :or {inject-match? true inject-router? true}})

Creates a ring-handler out of a router, optional default ring-handler and options map, with the following keys:

key	description
:middleware	Optional sequence of middleware that wrap the ring-handler
:inject-match?	Boolean to inject match into request under :reitit.core/match key (default true)
:inject-router?	Boolean to inject router into request under :reitit.core/router key (default true)

router clj/s

(router data)

(router data opts)

Creates a reitit.core/Router from raw route data and optionally an options map with support for http-methods and Middleware. See documentation on reitit.core/router for available options. In addition, the following options are available:

key	description
:reitit.middleware/transform	Function or vector of functions of type [Middleware] => [Middleware] to transform the expanded Middleware (default: identity)
:reitit.middleware/registry	Map of keyword => IntoMiddleware to replace keyword references into Middleware
:reitit.ring/default-options-handler	Default handler for :options method in endpoints (default: default-options-handler)

Example:

(router
  ["/api" {:middleware [wrap-format wrap-oauth2]}
    ["/users" {:get get-user
                 :post update-user
                 :delete {:middleware [wrap-delete]
                         :handler delete-user}}]])

routes clj/s

(routes & handlers)

Create a ring handler by combining several handlers into one.