Something like this

(defn get-huge-data 
  [req]
  (let [c (async/chan)]
    (async/thread 
      (doseq [v (jdbc/get-values)]
        (async/>!! c v)))
    {:body c
     :status 200}))

that makes sense, thanks! I wonder how to factor in the writer for the csv

maybe instead of returning a channel I could return an input stream, and write to that input using a thread instead of core.async?

I wonder if Pedestal will wait for the thread to finish to finish the response

searching an old complete/correct example here.

thank you very much mister ❤️

https://gist.github.com/ivarref/b57cf40ea4739dacc4bbe7bbcaa8aec0/d449ef39b35e00e9d3ae2b45313d4ec360a3303f

note that the key is "return a channel" How you will pipe the data into this channel may be tricky

(pipe jdbc, that is a sync library, into an async chan, may be tricky)

given it returns a lazy list as a result I was under the impression that I could doseq without having to load the entire collection in memory

yeah but it will require a dedicated thread

In this specific case, of a lazy seq from jdbc into the response, may be easier to write as you read, like this

(require '[io.pedestal.http :as http]
  '[clojure.core.async :as async]
  '[io.pedestal.test :refer [response-for]])
(let [index (fn [req]
              (let [lazy-jdbc-result (#_jdbc/execute.. do
                                       [1 2 3])]
                {:body   (fn [out]
                           (with-open [w (io/writer out)]
                             (doseq [v lazy-jdbc-result]
                               (json/write v w)
                               (.write w (int \newline)))))
                 :status 200}))
      service-fn (-> {::http/routes `#{["/" :get ~index
                                        :route-name ::index]}}
                   http/default-interceptors
                   http/create-servlet
                   ::http/service-fn)]
  (response-for service-fn :get "/"))

yep looks like this will do the trick thanks a lot ❤️ !!