Pedestal-sample

examples/pedestal/src/example/server.clj

@@ -1,34 +1,50 @@
 (ns example.server
   (:require [io.pedestal.http :as http]
-            [io.pedestal.http.route :as route]
+            [reitit.pedestal :as pedestal]
-            [io.pedestal.http.body-params :as body-params]
+            [reitit.http :as reitit-http]
-            [io.pedestal.http.route.definition :refer [defroutes]]))
+            [reitit.ring :as ring]))
 
-(defn hello-world [request]
+(defn interceptor [x]
-  (let [name (get-in request [:params :name] "World")]
+  {:enter (fn [ctx] (println ">>" x) ctx)
-    {:status 200 :body (str "Hello " name "!\n")}))
+   :leave (fn [ctx] (println "<<" x) ctx)})
 
-(defroutes routes
+(def routing-interceptor
-           [[["/"
+  (pedestal/routing-interceptor
-              ["/hello" {:get hello-world}]]]])
+    (reitit-http/router
+      ["/api"
+       {:interceptors [[interceptor :api]
+                       [interceptor :apa]]}
 
-(def service {:env                 :prod
+       ["/ping"
-              ::http/routes        routes
+        {:interceptors [[interceptor :ping]]
-              ::http/resource-path "/public"
+         :get {:interceptors [[interceptor :get]]
-              ::http/type          :jetty
+               :handler (fn [_]
-              ::http/port          8080})
+                          (println "handler")
+                          {:status 200,
+                           :body "pong"})}}]]
+      {:data {:interceptors [[interceptor :router]]}})
+    (ring/create-default-handler)
+    {:interceptors [[interceptor :top]]}))
+
+(defonce server (atom nil))
 
 (defn start []
-  (-> service/service
+  (when @server
+    (http/stop @server)
+    (println "server stopped"))
+  (-> {:env :prod
+       ::http/routes []
+       ::http/resource-path "/public"
+       ::http/type :jetty
+       ::http/port 3000}
       (merge {:env :dev
               ::http/join? false
-              ::http/routes #(deref #'routes)
               ::http/allowed-origins {:creds true :allowed-origins (constantly true)}})
-      http/default-interceptors
+      (pedestal/default-interceptors routing-interceptor)
       http/dev-interceptors
       http/create-server
-      http/start))
+      http/start
+      (->> (reset! server)))
+  (println "server running in port 3000"))
 
-
+(start)
-(comment
-  (start))

examples/pedestal/src/reitit/pedestal.clj

@@ -1,7 +1,9 @@
-(ns example.pedestal
+(ns reitit.pedestal
   (:require [io.pedestal.interceptor.chain :as chain]
             [io.pedestal.interceptor :as interceptor]
-            [reitit.http :as http])
+            [io.pedestal.http :as http]
+            [reitit.interceptor]
+            [reitit.http])
   (:import (reitit.interceptor Executor)))
 
 (def pedestal-executor
@@ -20,16 +22,17 @@
     (routing-interceptor router nil))
   ([router default-handler]
     (routing-interceptor router default-handler nil))
-  ([router default-handler opts]
+  ([router default-handler {:keys [interceptors]}]
    (interceptor/interceptor
-     (http/routing-interceptor
+     (reitit.http/routing-interceptor
        router
        default-handler
-       (merge {:executor pedestal-executor} opts)))))
+       {:executor pedestal-executor
+        :interceptors interceptors}))))
 
-(def router http/router)
+(defn default-interceptors [spec router]
-
-(defn with-reitit-router [spec router]
   (-> spec
+      (assoc ::http/routes [])
+      (http/default-interceptors)
       (update ::http/interceptors (comp vec butlast))
       (update ::http/interceptors conj router)))

modules/reitit-core/src/reitit/interceptor.cljc

@@ -18,7 +18,10 @@
   (execute
     [this interceptors request]
     [this interceptors request respond raise]
-    "executes the interceptor chain"))
+    "executes the interceptor chain with a request")
+  (enqueue
+    [this context interceptors]
+    "enqueues the interceptors into the queue"))
 
 (defn context [request]
   (map->Context {:request request}))

modules/reitit-http/src/reitit/http.cljc

@@ -61,6 +61,33 @@
    (let [opts (meta-merge {:coerce coerce-handler, :compile compile-result} opts)]
      (r/router data opts))))
 
+(defn routing-interceptor
+  "A Pedestal-style routing interceptor that enqueus the interceptors into context."
+  [router default-handler {:keys [interceptors executor]}]
+  (let [default-handler (or default-handler (fn ([_])))
+        default-interceptors (->> interceptors
+                                  (map #(interceptor/into-interceptor % nil (r/options router))))
+        default-queue (interceptor/queue executor default-interceptors)]
+    {:name ::router
+     :enter (fn [{:keys [request] :as context}]
+              (if-let [match (r/match-by-path router (:uri request))]
+                (let [method (:request-method request)
+                      path-params (:path-params match)
+                      endpoint (-> match :result method)
+                      interceptors (or (:queue endpoint) (:interceptors endpoint))
+                      request (-> request
+                                  (impl/fast-assoc :path-params path-params)
+                                  (impl/fast-assoc ::r/match match)
+                                  (impl/fast-assoc ::r/router router))
+                      context (assoc context :request request)
+                      queue (interceptor/queue executor (concat default-interceptors interceptors))]
+                  (interceptor/enqueue executor context queue))
+                (interceptor/enqueue executor context default-queue)))
+     :leave (fn [context]
+              (if-not (:response context)
+                (assoc context :response (default-handler (:request context)))
+                context))}))
+
 (defn ring-handler
   "Creates a ring-handler out of a http-router,
   a default ring-handler and options map, with the following keys: