I am trying to build some functions to upload and download images to mongodb using monger and grid-fs, and I am using reitit and swagger-ui for the routes. I am able to upload the images to the mongo/gridfs database, that works fine. I am running into problems when trying to download the images in swagger. In a gridfs namespace I have the following functions:

(ns guestbook.db.grid-fs
  (:require
   [monger.core :as mg :refer
    [connect connect-via-uri disconnect get-db get-gridfs]]
   [monger.gridfs :as mgfs :refer
    [store-file make-input-file filename content-type metadata]]
   [monger.collection :as collection]
   [monger.conversion :as conv]
   [basevan.config :refer [env]]
   [ :as io]
   [ring.util.http-response :as response])
  (:import
   [java.nio.file Paths]))


(defn connect-grid-fs []
  (connect {:uri (env :database-url)}))

(defn upload [file body]
  (let [conn (connect-grid-fs)
        db   (get-db conn "base")
        fs   (get-gridfs conn "base")
        {:keys [tempfile size filename content-type]} file]
    (store-file (make-input-file fs body)
                (mgfs/filename filename)
                (mgfs/metadata {:format (get-extension filename)})
                (mgfs/content-type content-type))))

(defn download [file]
  (let [conn (connect-grid-fs)
        db   (get-db conn "base")
        fs   (get-gridfs conn "base")]
    (mgfs/find-by-filename fs file)))

(ns guestbook.routes.services
  (:require
   [guestbook.auth :as auth]
   [guestbook.db.core :as db]
   [guestbook.db.grid-fs :as grid-fs]
   [guestbook.listings.handlers :as listings]
   [guestbook.auth.ring :refer
    [wrap-authorized get-roles-from-match]]
   [guestbook.media :as media]
   [guestbook.middleware :as middleware]
   [guestbook.middleware.formats :as formats]
   [guestbook.responses :as responses]
   [ :as io]
   [clojure.tools.logging :as log]
   [clojure.spec.alpha :as s]
   [clojure.string :as string]
   [reitit.swagger :as swagger]
   [reitit.swagger-ui :as swagger-ui]
   [reitit.ring.coercion :as coercion]
   [reitit.coercion.spec :as spec-coercion]
   [reitit.ring.middleware.muuntaja :as muuntaja]
   [reitit.ring.middleware.exception :as exception]
   [reitit.ring.middleware.multipart :as multipart]
   [reitit.ring.middleware.parameters :as parameters]
   [spec-tools.data-spec :as ds]
   [ring.middleware.cors :refer [wrap-cors]]
   [ring.util.response :as rr]
   [ring.util.http-response :as response]
   [ring.middleware.multipart-params :as multipart-params]))

;; At the top of the routes I have this:

{:middleware [;; query-params & form-params
                 parameters/parameters-middleware
                 ;; content-negotiation
                 muuntaja/format-negotiate-middleware
                 ;; encoding response body
                 muuntaja/format-response-middleware
                 ;; exception handling
                 (exception/create-exception-middleware
                  (assoc exception/default-handlers ::exception/wrap
                         (fn [handler e request]
                           (.printStackTrace e)
                           (handler e request))))
                 ;; cors handling TODO double check this
                 [wrap-cors
                  :access-control-allow-origin [#"" #""] ; <-- order matters
                  :access-control-allow-methods [:get :post :put :patch :delete]
                  :Access-Control-Allow-Credentials "true"]
                 exception/exception-middleware
                 ;; decoding request body
                 muuntaja/format-request-middleware
                 ;; coercing response bodys
                 coercion/coerce-response-middleware
                 ;; coercing request parameters
                 coercion/coerce-request-middleware
                 ;; multipart params
                 multipart/multipart-middleware
                 ;;Our auth middleware
                 (fn [handler]
                   (wrap-authorized
                    handler
                    (fn handle-unauthorized [req]
                      (let [route-roles (get-roles-from-match req)]
                        (log/debug
                         "Roles for route: "
                         (:uri req)
                         route-roles)
                        (log/debug "User is unauthorized!"
                                   (-> req
                                       :session
                                       :identity
                                       :roles))
                        (response/forbidden
                         {:message
                          (str "User must have one of the following roles: "
                               route-roles)})))))]
    :muuntaja formats/instance
    :coercion spec-coercion/coercion
    :swagger {:id ::api}}

;; and the two routes I have for the upload and download are below, and like I said the upload works fine, it is the download that is giving me problems:

["/media-name/:name"
    {::auth/roles (auth/roles :media/get)
     :get {:parameters
           {:path {:name string?}}
           :handler (fn [{{{:keys [name]} :path} :parameters}]
                      (if-let [{:keys [data type]}
                               (grid-fs/download {:name name})]
                        (-> (io/input-stream data)
                            (response/ok)
                            (response/content-type type))
                        (response/not-found)))}}]

["/media/upload"
    {::auth/roles (auth/roles :media/upload)
     ;; :conflicting true
     :post
     {:summary "upload a file"
      :parameters {:multipart {:file multipart/temp-file-part}}
      :handler (fn [{:keys [params body]}]
                 (let [file (:file params)]
                   (grid-fs/upload file body)))}}]

I'd like to find out if I have unused functions in a library that has quite a large API, and several other internal projects that using it. They are all leinigen projects, and reside in under different folders/repos. Something like this, where both app1 and app2 use lib1:

If I require a library via Git dependency in my Clojure project and the GitHub repo moves to a different organization, will the redirect GitHub creates for the repository also work for Clojure tools, or would builds break?

Is there a way to debug reify not being able to find a method in an interface that definitely has the method defined?

Hi , I am trying to work with on Hazelcast jet with clojure , I was wondering if there is a way lambda expressions in java can be expressed in clojure?

(def node {:value 1
           :children [{:value 2
                       :children [{:value 3
                                   :children []}]}
                      {:value 4
                       :children []}]})

(acc-values node) 
; => 
(1 2 3 4)

(map
 :value
 (tree-seq
  (fn [x] (contains? x :value))
  :children
  node))