[skip ci]

Author: frenchy64

CONTRIBUTING.md .github/CONTRIBUTING.md

@@ -1,61 +1,70 @@
-(defproject metosin/compojure-api "1.1.15-SNAPSHOT"
+(defproject metosin/compojure-api "2.0.0-alpha34-SNAPSHOT"
   :description "Compojure Api"
   :url "https://github.com/metosin/compojure-api"
   :license {:name "Eclipse Public License"
             :url "http://www.eclipse.org/legal/epl-v10.html"
             :distribution :repo
             :comments "same as Clojure"}
-  :scm {:name "git"
-        :url "https://github.com/metosin/compojure-api"}
-  :dependencies [[prismatic/plumbing "0.6.0"]
-                 [cheshire "5.13.0"]
-                 [compojure "1.6.1"]
-                 [prismatic/schema "1.1.12"]
-                 [org.tobereplaced/lettercase "1.0.0"]
-                 [frankiesardo/linked "1.3.0"]
-                 [ring-middleware-format "0.7.4"]
+  :dependencies [[prismatic/schema "1.1.12"]
+                 [prismatic/plumbing "0.5.5"]
+                 [ikitommi/linked "1.3.1-alpha1"] ;; waiting for the original
+                 [metosin/muuntaja "0.6.6"]
+                 [com.fasterxml.jackson.datatype/jackson-datatype-joda "2.10.1"]
+                 [ring/ring-core "1.8.0"]
+                 [compojure "1.6.1" ]
+                 [metosin/spec-tools "0.10.6"]
                  [metosin/ring-http-response "0.9.1"]
+                 [metosin/ring-swagger-ui "3.24.3"]
                  [metosin/ring-swagger "1.0.0"]
-                 [metosin/ring-swagger-ui "2.2.10"]]
+
+                 ;; Fix dependency conflicts
+                 [clj-time "0.15.2"]
+                 [joda-time "2.10.5"]
+                 [riddley "0.2.0"]]
+  :pedantic? :abort
   :profiles {:uberjar {:aot :all
                        :ring {:handler examples.thingie/app}
                        :source-paths ["examples/thingie/src"]
                        :dependencies [[org.clojure/clojure "1.9.0"]
                                       [http-kit "2.3.0"]
                                       [reloaded.repl "0.2.4"]
                                       [com.stuartsierra/component "0.4.0"]]}
-             :dev {:jvm-opts ["-Dcompojure.api.core.allow-dangerous-middleware=true"]
-                   :repl-options {:init-ns user}
-                   :plugins [[lein-clojars "0.9.1"]
-                             [lein-midje "3.2.1"]
-                             [lein-ring "0.12.0"]
+             :dev {:plugins [[lein-clojars "0.9.1"]
+                             [lein-ring "0.12.5"]
                              [funcool/codeina "0.5.0"]]
                    :dependencies [[org.clojure/clojure "1.9.0"]
-                                  ;; bump
-                                  [fipp "0.6.26"]
-                                  [metosin/spec-tools "0.10.6"]
-                                  [metosin/muuntaja "0.6.6"]
-                                  [metosin/jsonista "0.2.5"]
-                                  [com.fasterxml.jackson.datatype/jackson-datatype-joda "2.10.1"]
-                                  [slingshot "0.12.2"]
-                                  [peridot "0.5.1"]
-                                  [javax.servlet/servlet-api "2.5"]
-                                  [midje "1.9.9"]
+                                  [org.clojure/core.unify "0.6.0"]
+                                  [org.clojure/core.async "0.6.532"]
+                                  [javax.servlet/javax.servlet-api "4.0.1"]
+                                  [peridot "0.5.2"]
                                   [com.stuartsierra/component "0.4.0"]
+                                  [expound "0.8.2"]
+                                  [metosin/jsonista "0.2.5"]
                                   [reloaded.repl "0.2.4"]
+                                  [metosin/muuntaja-msgpack "0.6.6"]
+                                  [metosin/muuntaja-yaml "0.6.6"]
+                                  [org.immutant/immutant "2.1.10"]
                                   [http-kit "2.3.0"]
                                   [criterium "0.4.5"]]
+                   :jvm-opts ["-Dcompojure.api.meta.static-context-coach={:default :assert :verbose true}"]
+                   :test-paths ["test19"]
                    :ring {:handler examples.thingie/app
                           :reload-paths ["src" "examples/thingie/src"]}
                    :source-paths ["examples/thingie/src" "examples/thingie/dev-src"]
                    :main examples.server}
              :perf {:jvm-opts ^:replace ["-server"
                                          "-Xmx4096m"
                                          "-Dclojure.compiler.direct-linking=true"]}
-             :logging {:dependencies [[org.clojure/tools.logging "0.5.0"]]}
+             :logging {:dependencies [[org.clojure/tools.logging "0.5.0"]
+                                      [org.slf4j/jcl-over-slf4j "1.7.30"]
+                                      [org.slf4j/jul-to-slf4j "1.7.30"]
+                                      [org.slf4j/log4j-over-slf4j "1.7.30"]
+                                      [ch.qos.logback/logback-classic "1.2.3" ]]}
              :1.10 {:dependencies [[org.clojure/clojure "1.10.1"]]}
              :1.11 {:dependencies [[org.clojure/clojure "1.11.3"]]}
-             :1.12 {:dependencies [[org.clojure/clojure "1.12.0-alpha11"]]}}
+             :1.12 {:dependencies [[org.clojure/clojure "1.12.0-alpha11"]]}
+             :async {:jvm-opts ["-Dcompojure-api.test.async=true"]
+                     :dependencies [[manifold "0.1.8" :exclusions [org.clojure/tools.logging]]]}}
   :eastwood {:namespaces [:source-paths]
              :add-linters [:unused-namespaces]}
   :codeina {:sources ["src"]
@@ -79,10 +88,10 @@
                   ["change" "version" "leiningen.release/bump-version"]
                   ["vcs" "commit"]
                   ["vcs" "push"]]
-  :aliases {"all" ["with-profile" "dev:dev,logging:dev,1.10:dev,1.11:dev,1.12"]
+  :aliases {"all" ["with-profile" "dev:dev,async:dev,1.10:dev,1.11:dev,1.12"]
             "start-thingie" ["run"]
             "aot-uberjar" ["with-profile" "uberjar" "do" "clean," "ring" "uberjar"]
-            "test-ancient" ["midje"]
+            "test-ancient" ["test"]
             "perf" ["with-profile" "default,dev,perf"]
             "deploy!" ^{:doc "Recompile sources, then deploy if tests succeed."}
-            ["do" ["clean"] ["midje"] ["deploy" "clojars"]]})
+            ["do" ["clean"] ["test"] ["deploy" "clojars"]]})

project.clj

@@ -1,16 +1,17 @@
 (ns compojure.api.api
   (:require [compojure.api.core :as c]
             [compojure.api.swagger :as swagger]
-            [compojure.api.middleware :as middleware]
+            [compojure.api.middleware :as mw]
+            [compojure.api.request :as request]
             [compojure.api.routes :as routes]
             [compojure.api.common :as common]
-            [compojure.api.coerce :as coerce]
+            [compojure.api.request :as request]
             [ring.swagger.common :as rsc]
             [ring.swagger.middleware :as rsm]))
 
 (def api-defaults
   (merge
-    middleware/api-middleware-defaults
+    mw/api-middleware-defaults
     {:api {:invalid-routes-fn routes/log-invalid-child-routes
            :disable-api-middleware? false}
      :swagger {:ui nil, :spec nil}}))
@@ -23,8 +24,7 @@
   options map as the first parameter:
 
       (api
-        {:formats [:json-kw :edn :transit-msgpack :transit-json]
-         :exceptions {:handlers {:compojure.api.exception/default my-logging-handler}}
+        {:exceptions {:handlers {:compojure.api.exception/default my-logging-handler}}
          :api {:invalid-routes-fn (constantly nil)}
          :swagger {:spec \"/swagger.json\"
                    :ui \"/api-docs\"
@@ -47,30 +47,55 @@
 
   ### api-middleware options
 
+  See `compojure.api.middleware/api-middleware` for more available options.
+
   " (:doc (meta #'compojure.api.middleware/api-middleware)))}
   api
   [& body]
   (let [[options handlers] (common/extract-parameters body false)
+        _ (assert (not (contains? options :format))
+                  (str "ERROR: Option [:format] is not used with 2.* version.\n"
+                       "Compojure-api uses now Muuntaja insted of ring-middleware-format,\n"
+                       "the new formatting options for it should be under [:formats]. See\n"
+                       "[[api-middleware]] documentation for more details.\n"))
+        _ (when (and (not (:formatter options))
+                     (not (contains? options :formats))
+                     (not (System/getProperty "compojure.api.middleware.global-default-formatter")))
+            (throw (ex-info (str "ERROR: Please set `:formatter :muuntaja` in the options map of `api`.\n"
+                                 "e.g., (api {:formatter :muuntaja} routes...)\n"
+                                 "To prepare for backwards compatibility with compojure-api 1.x, the formatting library must be\n"
+                                 "explicitly chosen if not configured by `:format` (ring-middleware-format) or \n"
+                                 "`:formats` (muuntaja). Once 2.x is stable, the default will be `:formatter :ring-middleware-format`.\n"
+                                 "To globally override the formatter, use -Dcompojure.api.middleware.global-default-formatter=:muuntaja")
+                            {})))
         options (rsc/deep-merge api-defaults options)
         handler (apply c/routes (concat [(swagger/swagger-routes (:swagger options))] handlers))
-        routes (routes/get-routes handler (:api options))
+        partial-api-route (routes/map->Route
+                            {:childs [handler]
+                             :info {:coercion (:coercion options)}})
+        routes (routes/get-routes partial-api-route (:api options))
         paths (-> routes routes/ring-swagger-paths swagger/transform-operations)
         lookup (routes/route-lookup-table routes)
         swagger-data (get-in options [:swagger :data])
         enable-api-middleware? (not (get-in options [:api :disable-api-middleware?]))
-        api-handler (cond-> handler
-                            swagger-data (rsm/wrap-swagger-data swagger-data)
-                            enable-api-middleware? (middleware/api-middleware
-                                                     (dissoc options :api :swagger))
-                            true (middleware/wrap-options
-                                   {:paths paths
-                                    :coercer (coerce/memoized-coercer)
-                                    :lookup lookup}))]
-    (routes/create nil nil {} [handler] api-handler)))
+        api-middleware-options (dissoc (mw/api-middleware-options (assoc (dissoc options :api :swagger) ::via-api true))
+                                       ::mw/api-middleware-defaults)
+        api-handler (-> handler
+                        (cond-> swagger-data (rsm/wrap-swagger-data swagger-data))
+                        (cond-> enable-api-middleware? (mw/api-middleware
+                                                         api-middleware-options))
+                        (mw/wrap-inject-data
+                          {::request/paths paths
+                           ::request/lookup lookup}))]
+    (assoc partial-api-route :handler api-handler)))
 
 (defmacro
-  ^{:doc (str
-  "Defines an api.
+  ^{:superseded-by "api" 
+    :deprecated "2.0.0"
+    :doc (str
+  "Deprecated: please use (def name (api ...body..))
+  
+  Defines an api.
 
   API middleware options:
 

src/compojure/api/api.clj

@@ -1,3 +1,4 @@
+;; 1.1.x
 (ns compojure.api.coerce
   (:require [schema.coerce :as sc]
             [compojure.api.middleware :as mw]

src/compojure/api/coerce.clj

@@ -54,16 +54,16 @@
    :deprecated "1.1.14"
    :superseded-by "route-middleware"}
   [middleware & body]
-  (when (not= "true" (System/getProperty "compojure.api.core.suppress-middleware-warning"))
-    (println (str "compojure.api.core.middleware is deprecated because of security issues. "
-                  "Please use route-middleware instead. middleware will be disabled in a future release."
-                  "Set -dcompojure.api.core.suppress-middleware-warning=true to suppress this warning.")))
+  (assert (= "true" (System/getProperty "compojure.api.core.allow-dangerous-middleware"))
+          (str "compojure.api.core.middleware is deprecated because of security issues. "
+               "Please use route-middleware instead. "
+               "Set compojure.api.core.allow-dangerous-middleware=true to keep using middleware."))
   `(let [body# (routes ~@body)
          wrap-mw# (mw/compose-middleware ~middleware)]
      (routes/create nil nil {} [body#] (wrap-mw# body#))))
 
 (defn route-middleware
-  "Wraps routes with given middleware using thread-first macro."
+  "Wraps routes with given middlewares using thread-first macro."
   {:style/indent 1
    :supercedes "middleware"}
   [middleware & body]
@@ -76,11 +76,11 @@
 
 (defmacro context {:style/indent 2} [& args] (meta/restructure nil args {:context? true :&form &form :&env &env}))
 
-(defmacro GET     {:style/indent 2} [& args] (meta/restructure :get     args nil))
-(defmacro ANY     {:style/indent 2} [& args] (meta/restructure nil      args nil))
-(defmacro HEAD    {:style/indent 2} [& args] (meta/restructure :head    args nil))
-(defmacro PATCH   {:style/indent 2} [& args] (meta/restructure :patch   args nil))
-(defmacro DELETE  {:style/indent 2} [& args] (meta/restructure :delete  args nil))
+(defmacro GET {:style/indent 2} [& args] (meta/restructure :get args nil))
+(defmacro ANY {:style/indent 2} [& args] (meta/restructure nil args nil))
+(defmacro HEAD {:style/indent 2} [& args] (meta/restructure :head args nil))
+(defmacro PATCH {:style/indent 2} [& args] (meta/restructure :patch args nil))
+(defmacro DELETE {:style/indent 2} [& args] (meta/restructure :delete args nil))
 (defmacro OPTIONS {:style/indent 2} [& args] (meta/restructure :options args nil))
-(defmacro POST    {:style/indent 2} [& args] (meta/restructure :post    args nil))
-(defmacro PUT     {:style/indent 2} [& args] (meta/restructure :put     args nil))
+(defmacro POST {:style/indent 2} [& args] (meta/restructure :post args nil))
+(defmacro PUT {:style/indent 2} [& args] (meta/restructure :put args nil))

src/compojure/api/core.clj

@@ -2,10 +2,8 @@
   (:require [ring.util.http-response :as response]
             [clojure.walk :as walk]
             [compojure.api.impl.logging :as logging]
-            [schema.utils :as su])
-  (:import [schema.utils ValidationError NamedError]
-           [com.fasterxml.jackson.core JsonParseException]
-           [org.yaml.snakeyaml.parser ParserException]))
+            [compojure.api.coercion.core :as cc]
+            [compojure.api.coercion.schema]))
 
 ;;
 ;; Default exception handlers
@@ -21,42 +19,62 @@
   (response/internal-server-error {:type "unknown-exception"
                                    :class (.getName (.getClass e))}))
 
-(defn stringify-error
-  "Stringifies symbols and validation errors in Schema error, keeping the structure intact."
-  [error]
-  (walk/postwalk
-    (fn [x]
-      (cond
-        (instance? ValidationError x) (str (su/validation-error-explain x))
-        (instance? NamedError x) (str (su/named-error-explain x))
-        :else x))
-    error))
-
+;; TODO: coercion should handle how to publish data
 (defn response-validation-handler
-  "Creates error response based on Schema error."
+  "Creates error response based on a response error. The following keys are available:
+
+    :type            type of the exception (::response-validation)
+    :coercion        coercion instance used
+    :in              location of the value ([:response :body])
+    :schema          schema to be validated against
+    :error           schema error
+    :request         raw request
+    :response        raw response"
   [e data req]
-  (response/internal-server-error {:errors (stringify-error (su/error-val data))}))
+  (response/internal-server-error
+    (-> data
+        (dissoc :request :response)
+        (update :coercion cc/get-name)
+        (assoc :value (-> data :response :body))
+        (->> (cc/encode-error (:coercion data))))))
 
+;; TODO: coercion should handle how to publish data
 (defn request-validation-handler
-  "Creates error response based on Schema error."
+  "Creates error response based on Schema error. The following keys are available:
+
+    :type            type of the exception (::request-validation)
+    :coercion        coercion instance used
+    :value           value that was validated
+    :in              location of the value (e.g. [:request :query-params])
+    :schema          schema to be validated against
+    :error           schema error
+    :request         raw request"
   [e data req]
-  (response/bad-request {:errors (stringify-error (su/error-val data))}))
+  (response/bad-request
+    (-> data
+        (dissoc :request)
+        (update :coercion cc/get-name)
+        (->> (cc/encode-error (:coercion data))))))
+
+(defn http-response-handler
+  "reads response from ex-data :response"
+  [_ {:keys [response]} _]
+  response)
 
 (defn schema-error-handler
   "Creates error response based on Schema error."
   [e data req]
-  ; FIXME: Why error is not wrapped to ErrorContainer here?
-  (response/bad-request {:errors (stringify-error (:error data))}))
+  (response/bad-request
+    {:errors (compojure.api.coercion.schema/stringify (:error data))}))
 
 (defn request-parsing-handler
   [^Exception ex data req]
-  (let [cause (.getCause ex)]
-    (response/bad-request {:type (cond
-                                   (instance? JsonParseException cause) "json-parse-exception"
-                                   (instance? ParserException cause) "yaml-parse-exception"
-                                   :else "parse-exception")
-                           :message (.getMessage cause)})))
-
+  (let [cause (.getCause ex)
+        original (.getCause cause)]
+    (response/bad-request
+      (merge (select-keys data [:type :format :charset])
+             (if original {:original (.getMessage original)})
+             {:message (.getMessage cause)}))))
 ;;
 ;; Logging
 ;;
@@ -75,5 +93,6 @@
 ;; Mappings from other Exception types to our base types
 ;;
 
-(def legacy-exception-types
-  {:ring.swagger.schema/validation ::request-validation})
+(def mapped-exception-types
+  {:ring.swagger.schema/validation ::request-validation
+   :muuntaja/decode ::request-parsing})

src/compojure/api/exception.clj

@@ -6,17 +6,18 @@
 (declare log!)
 
 ;; use c.t.l logging if available, default to console logging
-(if (find-ns 'clojure.tools.logging)
+(try
   (eval
     `(do
        (require 'clojure.tools.logging)
        (defmacro ~'log! [& ~'args]
-         `(do
-            (clojure.tools.logging/log ~@~'args)))))
-  (let [log (fn [level more] (println (.toUpperCase (name level)) (str/join " " more)))]
-    (defn log! [level x & more]
-      (if (instance? Throwable x)
-        (do
-          (log level more)
-          (.printStackTrace ^Throwable x))
-        (log level (into [x] more))))))
+         `(clojure.tools.logging/log ~@~'args))))
+  (catch Exception _
+    (let [log (fn [level more] (println (.toUpperCase (name level)) (str/join " " more)))]
+      (defn log! [level x & more]
+        (if (instance? Throwable x)
+          (do
+            (log level more)
+            (.printStackTrace ^Throwable x))
+          (log level (into [x] more))))
+      (log! :warn "clojure.tools.logging not found on classpath, compojure.api logging to console."))))

src/compojure/api/impl/logging.clj

@@ -1,13 +1,16 @@
 (ns compojure.api.resource
   (:require [compojure.api.routes :as routes]
-            [compojure.api.coerce :as coerce]
+            [compojure.api.coercion :as coercion]
+            [compojure.api.methods :as methods]
             [ring.swagger.common :as rsc]
             [schema.core :as s]
             [plumbing.core :as p]
-            [compojure.api.middleware :as mw]))
+            [compojure.api.async]
+            [compojure.api.middleware :as mw]
+            [compojure.api.coercion.core :as cc]))
 
 (def ^:private +mappings+
-  {:methods #{:get :head :patch :delete :options :post :put}
+  {:methods methods/all-methods
    :parameters {:query-params [:query-params :query :string true]
                 :body-params [:body-params :body :body false]
                 :form-params [:form-params :formData :string true]
@@ -25,51 +28,112 @@
           (:parameters +mappings+))
         (dissoc info :handler)))
 
+(defn- inject-coercion [request info]
+  (if (contains? info :coercion)
+    (coercion/set-request-coercion request (:coercion info))
+    request))
+
 (defn- coerce-request [request info ks]
   (reduce-kv
     (fn [request ring-key [compojure-key _ type open?]]
-      (if-let [schema (get-in info (concat ks [:parameters ring-key]))]
-        (let [schema (if open? (assoc schema s/Keyword s/Any) schema)]
-          (update request ring-key merge (coerce/coerce! schema compojure-key type request)))
+      (if-let [model (get-in info (concat ks [:parameters ring-key]))]
+        (let [coerced (coercion/coerce-request!
+                        model compojure-key type (not= :body type) open? request)]
+          (if open?
+            (update request ring-key merge coerced)
+            (assoc request ring-key coerced)))
         request))
-    request
+    (inject-coercion request info)
     (:parameters +mappings+)))
 
 (defn- coerce-response [response info request ks]
-  (coerce/coerce-response! request response (get-in info (concat ks [:responses]))))
-
-(defn- resolve-handler [info request-method]
-  (or
-    (get-in info [request-method :handler])
-    (get-in info [:handler])))
+  (coercion/coerce-response! request response (get-in info (concat ks [:responses]))))
+
+(defn- maybe-async [async? x]
+  (if (and async? x) [x true]))
+
+(defn- maybe-sync [x]
+  (if x [x false]))
+
+(defn- resolve-handler [info path-info route request-method async?]
+  (and
+    (or
+      ;; directly under a context
+      (= path-info "/")
+      ;; under an compojure endpoint
+      route
+      ;; vanilla ring
+      (nil? path-info))
+    (let [[handler async] (or
+                            (maybe-async async? (get-in info [request-method :async-handler]))
+                            (maybe-sync (get-in info [request-method :handler]))
+                            (maybe-async async? (get-in info [:async-handler]))
+                            (maybe-sync (get-in info [:handler])))]
+      (if handler
+        [handler async]))))
+
+(defn- middleware-chain [info request-method handler]
+  (let [direct-mw (:middleware info)
+        method-mw (:middleware (get info request-method))
+        middleware (mw/compose-middleware (concat direct-mw method-mw))]
+    (middleware handler)))
 
 (defn- create-childs [info]
   (map
     (fn [[method info]]
-      (routes/create "/" method (swaggerize info) nil nil))
+      (routes/map->Route
+        {:path "/"
+         :method method
+         :info {:public (swaggerize info)}}))
     (select-keys info (:methods +mappings+))))
 
-(defn- create-handler [info {:keys [coercion]}]
-  (fn [{:keys [request-method] :as request}]
-    (let [request (if coercion (assoc-in request mw/coercion-request-ks coercion) request)
-          ks (if (contains? info request-method) [request-method] [])]
-      (if-let [handler (resolve-handler info request-method)]
-        (-> (coerce-request request info ks)
-            handler
-            (coerce-response info request ks))))))
+(defn- handle-sync [info {:keys [request-method path-info :compojure/route] :as request}]
+  (when-let [[raw-handler] (resolve-handler info path-info route request-method false)]
+    (let [ks (if (contains? info request-method) [request-method] [])
+          handler (middleware-chain info request-method raw-handler)]
+      (-> (coerce-request request info ks)
+          (handler)
+          (compojure.response/render request)
+          (coerce-response info request ks)))))
+
+(defn- handle-async [info {:keys [request-method path-info :compojure/route] :as request} respond raise]
+  (if-let [[raw-handler async?] (resolve-handler info path-info route request-method true)]
+    (let [ks (if (contains? info request-method) [request-method] [])
+          respond-coerced (fn [response]
+                            (respond
+                              (try (coerce-response response info request ks)
+                                   (catch Throwable e (raise e)))))
+          handler (middleware-chain info request-method raw-handler)]
+      (try
+        (as-> (coerce-request request info ks) $
+              (if async?
+                (handler $ #(compojure.response/send % $ respond-coerced raise) raise)
+                (compojure.response/send (handler $) $ respond-coerced raise)))
+        (catch Throwable e
+          (raise e))))
+    (respond nil)))
+
+(defn- create-handler [info]
+  (fn
+    ([request]
+     (handle-sync info request))
+    ([request respond raise]
+     (handle-async info request respond raise))))
 
 (defn- merge-parameters-and-responses [info]
   (let [methods (select-keys info (:methods +mappings+))]
     (-> info
         (merge
-          (p/for-map [[method method-info] methods]
-            method (-> method-info
-                       (->> (rsc/deep-merge (select-keys info [:parameters])))
-                       (update :responses (fn [responses] (merge (:responses info) responses)))))))))
-
-(defn- root-info [info]
+          (p/for-map [[method method-info] methods
+                      :let [responses (merge
+                                        (:responses info)
+                                        (:responses method-info))]]
+            method (cond-> (->> method-info (rsc/deep-merge (select-keys info [:parameters])))
+                           (seq responses) (assoc :responses responses)))))))
+
+(defn- public-root-info [info]
   (-> (reduce dissoc info (:methods +mappings+))
-      (dissoc :parameters :responses)))
+      (dissoc :parameters :responses :coercion)))
 
 ;;
 ;; Public api
@@ -81,17 +145,21 @@
 ; TODO: validate input against ring-swagger schema, fail for missing handlers
 ; TODO: extract parameter schemas from handler fnks?
 (defn resource
-  "Creates a nested compojure-api Route from enchanced ring-swagger operations map and options.
+  "Creates a nested compojure-api Route from enchanced ring-swagger operations map.
   By default, applies both request- and response-coercion based on those definitions.
 
-  Options:
+  Extra keys:
+
+  - **:middleware**     Middleware in duct-format either at top-level or under methods.
+                        Top-level mw are applied first if route matches, method-level
+                        mw are applied next if method matches
 
   - **:coercion**       A function from request->type->coercion-matcher, used
                         in resource coercion for :body, :string and :response.
                         Setting value to `(constantly nil)` disables both request- &
                         response coercion. See tests and wiki for details.
 
-  Enchancements to ring-swagger operations map:
+  Enhancements to ring-swagger operations map:
 
   1) :parameters use ring request keys (query-params, path-params, ...) instead of
   swagger-params (query, path, ...). This keeps things simple as ring keys are used in
@@ -104,9 +172,14 @@
     2.2) :responses are merged into operation :responses (operation can fully override them)
     2.3) all others (:produces, :consumes, :summary,...) are deep-merged by compojure-api
 
-  3) special key `:handler` either under operations or at top-level. Value should be a
-  ring-handler function, responsible for the actual request processing. Handler lookup
-  order is the following: operations-level, top-level.
+  3) special keys `:handler` and/or `:async-handler` either under operations or at top-level.
+  They should be 1-ary and 3-ary Ring handler functions, respectively, that are responsible
+  for the actual request processing. Handler lookup order is the following:
+
+    3.1) If called asynchronously, operations-level :async-handler
+    3.2) Operations-level :handler
+    3.3) If called asynchronously, top-level :async-handler
+    3.4) Top-level :handler
 
   4) request-coercion is applied once, using deep-merged parameters for a given
   operation or resource-level if only resource-level handler is defined.
@@ -130,11 +203,13 @@
      :post {}
      :handler (constantly
                 (internal-server-error {:reason \"not implemented\"}))})"
-  ([info]
-   (resource info {}))
-  ([info options]
-   (let [info (merge-parameters-and-responses info)
-         root-info (swaggerize (root-info info))
-         childs (create-childs info)
-         handler (create-handler info options)]
-     (routes/create nil nil root-info childs handler))))
+  [data]
+  (let [data (merge-parameters-and-responses data)
+        public-info (swaggerize (public-root-info data))
+        info (merge {:public public-info} (select-keys data [:coercion]))
+        childs (create-childs data)
+        handler (create-handler data)]
+    (routes/map->Route
+      {:info info
+       :childs childs
+       :handler handler})))

src/compojure/api/meta.clj

@@ -1,16 +1,20 @@
 (ns compojure.api.routes
   (:require [compojure.core :refer :all]
             [clojure.string :as string]
-            [cheshire.core :as json]
-            [compojure.api.middleware :as mw]
+            [compojure.api.methods :as methods]
+            [compojure.api.request :as request]
             [compojure.api.impl.logging :as logging]
+            [compojure.api.impl.json :as json]
             [compojure.api.common :as common]
+            [muuntaja.core :as m]
             [ring.swagger.common :as rsc]
             [clojure.string :as str]
             [linked.core :as linked]
             [compojure.response]
-            [schema.core :as s])
-  (:import [clojure.lang AFn IFn Var]))
+            [schema.core :as s]
+            [compojure.api.coercion :as coercion])
+  (:import (clojure.lang AFn IFn Var IDeref)
+           (java.io Writer)))
 
 ;;
 ;; Route records
@@ -47,37 +51,61 @@
        (update-in route [0] (fn [uri] (if (str/blank? uri) "/" uri))))
      (-get-routes handler options))))
 
+(defn get-static-context-routes
+  ([handler]
+   (get-static-context-routes handler nil))
+  ([handler options]
+   (filter (fn [[_ _ info]] (get info :static-context?))
+           (get-routes handler options))))
+
+(defn- realize-childs [route]
+  (update route :childs #(if (instance? IDeref %) @% %)))
+
+(defn- filter-childs [route]
+  (update route :childs (partial filter (partial satisfies? Routing))))
+
 (defrecord Route [path method info childs handler]
   Routing
   (-get-routes [this options]
-    (let [valid-childs (filter-routes this options)]
-      (if (seq childs)
+    (let [this (-> this realize-childs)
+          valid-childs (filter-routes this options)
+          make-method-path-fn (fn [m] [path m info])]
+      (if (-> this filter-childs :childs seq)
         (vec
           (for [[p m i] (mapcat #(-get-routes % options) valid-childs)]
             [(->paths path p) m (rsc/deep-merge info i)]))
-        (into [] (if path [[path method info]])))))
+        (into [] (cond
+                   (and path method) [(make-method-path-fn method)]
+                   path (mapv make-method-path-fn methods/all-methods))))))
 
   compojure.response/Renderable
-  (render [_ {:keys [uri request-method]}]
-    (throw
-      (ex-info
-        (str "\ncompojure.api.routes/Route can't be returned from endpoint "
-             (-> request-method name str/upper-case) " \"" uri "\". "
-             "For nested routes, use `context` instead: (context \"path\" []  ...)\n")
-        {:request-method request-method
-         :path path
-         :method method
-         :uri uri})))
+  (render [_ request]
+    (handler request))
+
+  ;; Sendable implementation in compojure.api.async
 
   IFn
   (invoke [_ request]
     (handler request))
+  (invoke [_ request respond raise]
+    (handler request respond raise))
+
   (applyTo [this args]
     (AFn/applyToHelper this args)))
 
 (defn create [path method info childs handler]
   (->Route path method info childs handler))
 
+(defmethod print-method Route
+  [this ^Writer w]
+  (let [childs (some-> this realize-childs filter-childs :childs seq vec)]
+    (.write w (str "#Route"
+                   (cond-> (dissoc this :handler :childs)
+                           (not (:path this)) (dissoc :path)
+                           (not (seq (:info this))) (dissoc :info)
+                           (not (:method this)) (dissoc :method)
+                           childs (assoc :childs childs))))))
+
 ;;
 ;; Invalid route handlers
 ;;
@@ -117,11 +145,16 @@
   {:paths
    (reduce
      (fn [acc [path method info]]
-       (update-in
-         acc [path method]
-         (fn [old-info]
-           (let [info (or old-info info)]
-             (ensure-path-parameters path info)))))
+       (if-not (:no-doc info)
+         (if-let [public-info (->> (get info :public {})
+                                   (coercion/get-apidocs (:coercion info) "swagger"))]
+           (update-in
+             acc [path method]
+             (fn [old-info]
+               (let [public-info (or old-info public-info)]
+                 (ensure-path-parameters path public-info))))
+           acc)
+         acc))
      (linked/map)
      routes)})
 
@@ -133,8 +166,19 @@
   (for [[id freq] (frequencies seq)
         :when (> freq 1)] id))
 
+(defn all-paths [routes]
+  (reduce
+    (fn [acc [path method info]]
+      (let [public-info (get info :public {})]
+        (update-in acc [path method]
+                   (fn [old-info]
+                     (let [public-info (or old-info public-info)]
+                       (ensure-path-parameters path public-info))))))
+    (linked/map)
+    routes))
+
 (defn route-lookup-table [routes]
-  (let [entries (for [[path endpoints] (-> routes ring-swagger-paths :paths)
+  (let [entries (for [[path endpoints] (all-paths routes)
                       [method {:keys [x-name parameters]}] endpoints
                       :let [params (:path parameters)]
                       :when x-name]
@@ -155,12 +199,6 @@
 ;; Endpoint Trasformers
 ;;
 
-(defn strip-no-doc-endpoints
-  "Endpoint transformer, strips all endpoints that have :x-no-doc true."
-  [endpoint]
-  (if-not (some-> endpoint :x-no-doc true?)
-    endpoint))
-
 (defn non-nil-routes [endpoint]
   (or endpoint {}))
 
@@ -171,7 +209,7 @@
 (defn- un-quote [s]
   (str/replace s #"^\"(.+(?=\"$))\"$" "$1"))
 
-(defn- path-string [s params]
+(defn- path-string [m s params]
   (-> s
       (str/replace #":([^/]+)" " :$1 ")
       (str/split #" ")
@@ -181,7 +219,7 @@
                  (let [key (keyword (subs token 1))
                        value (key params)]
                    (if value
-                     (un-quote (json/generate-string value))
+                     (un-quote (slurp (m/encode m "application/json" value)))
                      (throw
                        (IllegalArgumentException.
                          (str "Missing path-parameter " key " for path " s)))))
@@ -191,14 +229,14 @@
 (defn path-for*
   "Extracts the lookup-table from request and finds a route by name."
   [route-name request & [params]]
-  (let [[path details] (some-> request
-                               mw/get-options
-                               :lookup
+  (let [m (or (::request/muuntaja request) json/muuntaja)
+        [path details] (some-> request
+                               ::request/lookup
                                route-name
                                first)
         path-params (:params details)]
     (if (seq path-params)
-      (path-string path params)
+      (path-string m path params)
       path)))
 
 (defmacro path-for

src/compojure/api/middleware.clj

@@ -1,14 +1,15 @@
 (ns compojure.api.swagger
   (:require [compojure.api.core :as c]
-            [compojure.api.common :as common]
             [compojure.api.middleware :as mw]
+            [compojure.api.request :as request]
             [ring.util.http-response :refer [ok]]
             [ring.swagger.common :as rsc]
             [ring.swagger.middleware :as rsm]
             [ring.swagger.core :as swagger]
             [ring.swagger.swagger-ui :as swagger-ui]
             [ring.swagger.swagger2 :as swagger2]
-            [compojure.api.routes :as routes]))
+            [compojure.api.routes :as routes]
+            [spec-tools.swagger.core]))
 
 (defn base-path [request]
   (let [context (swagger/context request)]
@@ -24,9 +25,7 @@
           first))
 
 (defn transform-operations [swagger]
-  (->> swagger
-       (swagger2/transform-operations routes/non-nil-routes)
-       (swagger2/transform-operations routes/strip-no-doc-endpoints)))
+  (swagger2/transform-operations routes/non-nil-routes swagger))
 
 (defn swagger-ui [options]
   (assert (map? options) "Since 1.1.11, compojure.api.swagger/swagger-ui takes just one map as argument, with `:path` for the path.")
@@ -39,12 +38,13 @@
     (c/GET path request
       :no-doc true
       :name ::swagger
-      (let [runtime-info (rsm/get-swagger-data request)
+      (let [runtime-info1 (mw/get-swagger-data request)
+            runtime-info2 (rsm/get-swagger-data request)
             base-path {:basePath (base-path request)}
-            options (:ring-swagger (mw/get-options request))
-            paths (:paths (mw/get-options request))
-            swagger (apply rsc/deep-merge (keep identity [base-path paths extra-info runtime-info]))
-            spec (swagger2/swagger-json swagger options)]
+            options (::request/ring-swagger request)
+            paths (::request/paths request)
+            swagger (apply rsc/deep-merge (keep identity [base-path paths extra-info runtime-info1 runtime-info2]))
+            spec (spec-tools.swagger.core/swagger-spec (swagger2/swagger-json swagger options))]
         (ok spec)))))
 
 ;;
@@ -56,15 +56,21 @@
 (defn swagger-routes
   "Returns routes for swagger-articats (ui & spec). Accepts an options map, with the
   following options:
+
   **:ui**              Path for the swagger-ui (defaults to \"/\").
                        Setting the value to nil will cause the swagger-ui not to be mounted
+
   **:spec**            Path for the swagger-spec (defaults to \"/swagger.json\")
                        Setting the value to nil will cause the swagger-ui not to be mounted
+
   **:data**            Swagger data in the Ring-Swagger format.
+
   **:options**
     **:ui**            Options to configure the ui
     **:spec**          Options to configure the spec. Nada at the moment.
+
   Example options:
+
     {:ui \"/api-docs\"
      :spec \"/swagger.json\"
      :options {:ui {:jsonEditor true}

src/compojure/api/resource.clj

@@ -1,5 +1,5 @@
 ;; NOTE: This namespace is generated by compojure.api.dev.gen
 (ns compojure.api.upload (:require ring.middleware.multipart-params ring.swagger.upload))
-(def ^{:arglists (quote ([handler] [handler options])), :doc "Middleware to parse multipart parameters from a request. Adds the\n  following keys to the request map:\n\n  :multipart-params - a map of multipart parameters\n  :params           - a merged map of all types of parameter\n\n  The following options are accepted\n\n  :encoding          - character encoding to use for multipart parsing.\n                       Overrides the encoding specified in the request. If not\n                       specified, uses the encoding specified in a part named\n                       \"_charset_\", or the content type for each part, or\n                       request character encoding if the part has no encoding,\n                       or \"UTF-8\" if no request character encoding is set.\n\n  :fallback-encoding - specifies the character encoding used in parsing if a\n                       part of the request does not specify encoding in its\n                       content type or no part named \"_charset_\" is present.\n                       Has no effect if :encoding is also set.\n\n  :store             - a function that stores a file upload. The function\n                       should expect a map with :filename, content-type and\n                       :stream keys, and its return value will be used as the\n                       value for the parameter in the multipart parameter map.\n                       The default storage function is the temp-file-store.\n\n  :progress-fn       - a function that gets called during uploads. The\n                       function should expect four parameters: request,\n                       bytes-read, content-length, and item-count."} wrap-multipart-params ring.middleware.multipart-params/wrap-multipart-params)
+(def ^{:arglists (quote ([handler] [handler options])), :doc "Middleware to parse multipart parameters from a request. Adds the\n  following keys to the request map:\n\n  :multipart-params - a map of multipart parameters\n  :params           - a merged map of all types of parameter\n\n  The following options are accepted\n\n  :encoding          - character encoding to use for multipart parsing.\n                       Overrides the encoding specified in the request. If not\n                       specified, uses the encoding specified in a part named\n                       \"_charset_\", or the content type for each part, or\n                       request character encoding if the part has no encoding,\n                       or \"UTF-8\" if no request character encoding is set.\n\n  :fallback-encoding - specifies the character encoding used in parsing if a\n                       part of the request does not specify encoding in its\n                       content type or no part named \"_charset_\" is present.\n                       Has no effect if :encoding is also set.\n\n  :store             - a function that stores a file upload. The function\n                       should expect a map with :filename, :content-type and\n                       :stream keys, and its return value will be used as the\n                       value for the parameter in the multipart parameter map.\n                       The default storage function is the temp-file-store.\n\n  :progress-fn       - a function that gets called during uploads. The\n                       function should expect four parameters: request,\n                       bytes-read, content-length, and item-count."} wrap-multipart-params ring.middleware.multipart-params/wrap-multipart-params)
 (def ^{:doc "Schema for file param created by ring.middleware.multipart-params.temp-file store."} TempFileUpload ring.swagger.upload/TempFileUpload)
 (def ^{:doc "Schema for file param created by ring.middleware.multipart-params.byte-array store."} ByteArrayUpload ring.swagger.upload/ByteArrayUpload)