reitit 2023-05-24 | Slack Archive

what is the correct way to invoke a function before and after on invocation of every route defined

consider the example of this demo application https://github.com/prestancedesign/usermanager-reitit-example/blob/main/src/usermanager/handler.clj#L27-L39

RAJKUMAR19:05:51

I have 2 functions

RAJKUMAR19:05:53

(defn before-fn [request]
 (println "before") 
  (assoc "before" :before))

(defn after-fn []
  ( println "after"))

RAJKUMAR19:05:37

I want the before-fn be invoked before processing the request and after-fn after processing

p-himik19:05:46

That would be a regular middleware, no?

RAJKUMAR20:05:03

I see there are two options

RAJKUMAR20:05:23

1. defining the middleware and setting it in the options param of (ring/router) as {:data {:middleware [ &middlewares]}}

RAJKUMAR20:05:41

2. wrapping the (ring/ring-handler) in a custom function say my-ring-handler and use it to create app

RAJKUMAR20:05:53

(defn app
  (my-ring-handler 
   (ring/router []))

RAJKUMAR20:05:58

@U2FRKM4TW how about custom like my-ring-handler?

p-himik20:05:47

The approaches are identical in terms of the end result that you desire. But if you use the middleware approach, that middleware will become available to other things such as :reitit.middleware/transform. Whether you need that or not is up to you.

RAJKUMAR20:05:22

is this a correct way to define custom-ring-handler?

RAJKUMAR20:05:26

(defn before-fn [request]
 (println "before") 
  (assoc "before" :before))

(defn after-fn []
  (println "after"))

(defn my-ring-handler
  ([router opts]
   (my-ring-handler router nil opts))
  ([router handler opts]
    (fn
      ([request]
       (before-fn request)
       (http/ring-handler router default-handler nil)
       (after-fn))
      ([request respond raise]
       (before-fn request)
       (http/ring-handler router default-handler opts)
       (after-fn)))))

RAJKUMAR20:05:02

not sure how to use respond and raise

RAJKUMAR20:05:10

in this case

p-himik20:05:55

Something like this, haven't checked:

(defn my-ring-handler
  ([router]
   (my-ring-handler router nil))
  ([router default-handler]
   (my-ring-handler router default-handler nil))
  ([router default-handler opts]
   (let [handler (http/ring-handler router default-handler opts)]
     (with-meta
       (fn
         ([request]
          (before-fn request)
          (hanler router default-handler nil)
          (after-fn))
         ([request respond raise]
          (before-fn request)
          (handler router
                   (fn [response]
                     (after-fn)
                     (respond response))
                   raise)))
       (meta handler)))))

And you don't really need the respond raise arity unless you use Ring 2 with async requests.

2023-05-24

Channels