So you don't want a function like (num-combination 5 3) that returns 10. You want a function like (combinations ["a" "b" "c" "d" "e"] 3) that returns a collection of 10 3-element collections, all different?

yes,that's it

Do you already have an idea of how you might solve it, in words, perhaps using some kind of recursive approach?

sorry,not yet

but i have thought it may be recur

There are definitely multiple ways to solve this, and if this is part of an exercise to learn how to solve such problems, I wouldn't want to just give the whole answer away all at once 🙂

Clojure's recur can be used for some kinds of recursive approaches, but not all of them. I suspect it would be simpler to ignore the existence of recur at first, and think of that as an optimization that might be useful later, after you have something working that doesn't use recur

I can give a significant hint for one way to solve it recursively, first just in words rather than writing code for it.

I don't mind that

If you think of all of the 3-element subsets of the 5-element set #{"a" "b" "c" "d" "e"} some of them contain the element "a", and some do not.

Of all of the 3-element sets that do contain "a", how many other elements besides "a" must they have in them?

sorry,I haven't used to communicate with English,please hang on

No problem. Take your time.

i'm just catching up. can you say in words what you want to achieve with wrap-uuid-type?

sure! so i have an incoming json from a POST request that is like

{
  id: "uuid-here-but-as-a-string"
}

i thought i had it last night but i am mistaken 😞

ah ok. so you want to modify the request before the handler i think. see how you do response (handler request) ? that means the request is going in unchanged. you want to (handler (change-things-to-uuids request) instead

if i dont call the handler early then the :body is an input stream

i ahve it working in other places where i can do response (handler request) and just return response and things work ok

my issue is after i do the replacement it says it cannot write it back to a stream which makes me think there is no good way to do this

sure. but that means the handler you are calling is not getting an updated request

also, look at this error message

> No implementation of method: :write-body-to-stream of protocol: #'ring.core.protocols/StreamableResponseBody found for class: clojure.lang.PersistentArrayMap

can't write a map to body-stream is how i read that

look at these two handlers:

(defn handler [request]
  {:status 200
   :headers {"Content-Type" "application/edn"}
   :body {:data {:important :stuff}}})

(defn handler [request]
  {:status 200
   :headers {"Content-Type" "application/edn"}
   :body (pr-str {:data {:important :stuff}})})

what does pr-str do?

and yes per the error you are correct. i have to convert the :body to a keyword made and then do the replacement

(id->uuid (json/read-str (:body response) :key-fn keyword) ids-to-replace)

(defn ^:private id->uuid
  [original-map to-replace]
  (reduce
   (fn [cur-map k]
     (if (contains? cur-map k)
       (assoc cur-map k (string-util/to-uuid (k cur-map))) cur-map))
   original-map to-replace))

(pr-str {:a :b}) => "{:a :b}"

and pr-str: > pr to a string, returning it

im afraid ill get the same error as i did with str where it has no idea how to serialize the UUID type

let me check

clojure.core/pr
([] [x] [x & more])
  Prints the object(s) to the output stream that is the current value
  of *out*.  Prints the object(s), separated by spaces if there is
  more than one.  By default, pr and prn print in a way that objects
  can be read by the reader

oh it legit just prints it

{:id #uuid "c0c03eff-9870-4c0e-83ac-506bf59d69cf", :first "Yusuke", :last "Urameshi", :email ""}

is how the JSON response is returned to my client 😕

emphasis here: > By default, pr and prn print in a way that objects > can be read by the reader

JSON is a string

so just emit json as the body

that's not json

that's edn basically

so now your only issue is turning clojure datastructures into json strings rather than edn strings

which i hope (wrap-json-body {:keywords? true}) would take care of

you've seen the helpful pr-str and now you need to figure out how to turn clojure datastructures into json

but it seems with the changes this is ignored

where did you find that function? is that a lib or in ring core i forgot

[ring.middleware.json :refer [wrap-json-response, wrap-json-body]]

don't you want to wrap-json-response?

you want json to go back to the client

am i understanding correctly? you are happy with what you are receiving from your client but you are not happy with the format you are sending back to the client

> Middleware that converts responses with a map or a vector for a body into a JSON response.

isnt that what this is doing? it should convert the map into a JSON response

let me try and detail the flow out a bit

> wrap-json-response

Request client -> middlware -> replace ID with UUID type -> pass to controller -> save in DB Response Save in db --> response middlware --> convert to JSON --> client

> which i hope `(wrap-json-body {:keywords? true})` would take care of

notice json-body versus json-response?

yeah! after reading the desc i think i was confusing myself

> Middleware that parses the body of JSON request maps, and replaces the :body key with the parsed data structure.

ok. so i think i follow what you're trying to do but i'm not sure what parts are working and you're happy with and which parts you are still working on

perhaps this is what i want instead of pr-str

yes exactly

ok let me try one second pls

on my request middleware i have this now

(defn routes-handler [database]
  (println "routers-handler fired")
  (-> routes/define-main-routes
      (wrap-json-body {:keywords? true})
      (wrap-uuid-type)
      (wrap-database-component database)))

cause i was json-body to resolve prior to feeding into wrap-uuid-type

i think i have that right :thinking_face:

now if i print the request in wrap-uuid-type i would expect my :body to be a keyword map

if i just print request i get

:body #object[org.eclipse.jetty.server.HttpInputOverHTTP 0x784ebb6c [email protected][c=0,q=0,[0]=null,s=STREAM]]

:body {"id":"c0c03eff-9870-4c0e-83ac-506bf59d69cf","first":"Yusuke","last":"Urameshi","email":""}

grrrr

what happens if you swap the order of wrap-uuid-type and wrap-json-body?

same types 😞

trying to figure this out via the REPL too

and you're sure that you saw the new updated code and not the old code?

correct i restarted my server and all

follow https://github.com/ring-clojure/ring-json#wrap-json-body and make sure you can verify that the stuff coming in is json

ok checking now

was trying some stuff but no dice haha

can i recommend that we follow those docs and don't move on until we understand that part?

i think we understand sending back json but lets work on getting json in

yes in agreement w that

ok it was broke af

UNTIL i added a malformed message

(wrap-json-body handler {:keywords? true :or {:message "Broke"}})

i'm not following

nvm its not important. when i tried to load my app nothing would load but with the :or message responses happen again

when i try to submit JSON now from my client to the API server the :body is still in the same type

:body #object[org.eclipse.jetty.server.HttpInputOverHTTP 0x2fa5e7f4 "[email protected][c=0,q=0,[0]=null,s=STREAM]"]

ok i made some progress

instead of using my angular app i went to postman and it seems like the content-type is not getting set to application/json so it was being ignored

right

ring.middleware.json/wrap-json-body
([handler] [handler options])
  Middleware that parses the body of JSON request maps, and replaces the :body
  key with the parsed data structure. Requests without a JSON content type are
  unaffected.

yup

cool. so are you getting json parsed as clojure data structures in the handler now?

i am still not 😞

(defn handler [request]
  (println "json-body handler")
  (println (handler request)))

(defn routes-handler [database]
  (println "routers-handler fired")
  (-> routes/define-main-routes
      (wrap-json-body handler {:keywords? true :or {:message "Broke"}})
      (wrap-uuid-type)
      (wrap-database-component database)))

take handler out of there

sure

wrap-json-body needs to wrap your define-main-routes

also i don't think that's valid clojure

no request is printed 😕

which is not valid?

{:keywords? true :or {:message "Broke"}} oh i guess it is but that's super weird to me

i think that should be {:keywords true :malformed-response some-json-here}

(ns server
  (:require [ring.adapter.jetty :as jetty]
            [ring.middleware.json :refer [wrap-json-body wrap-json-response]]))

(defn handler [request]
  (prn (get request :body))
  {:status 200
   :headers {"Content-Type" "application/edn"}
   :body {:data {:important :stuff}}})

(defn run-server []
  (jetty/run-jetty (wrap-json-response (wrap-json-body #'handler))
                   {:port  3000
                    :join? false}))

^ that should work

and that's the same as

(defn run-server []
  (jetty/run-jetty (-> handler
                       wrap-json-body
                       wrap-json-response)
                   {:port  3000
                    :join? false}))

the threading is just wrapping them

correct i am just really confused by this (wrap-json-body) seems to be doing nothing

you're calling it with too many arguments right? see i'm passing handler into mine. but you're calling it with both routes/define-main-routes and handler?

(-> routes/define-main-routes
      (wrap-json-body handler {:keywords? true :or {:message "Broke"}})

yeah i removed the handler i got confused with a message above

and we read the docstring that wrap-json-body will only do work if the application/json content type header is set

can you post your main function here again?

correct so i have the content type set

(defn routes-handler [database]
  (-> routes/define-main-routes
      (wrap-json-body {:keywords? true :or {:message "Broke"}})
      (wrap-uuid-type)
      (wrap-database-component database)))

ok. and which route in define-main-routes are you hitting?

(defroutes define-main-routes
  (context "/api/v1/items" [] (wrap-routes item/define-routes))
  (context "/api/v1/users" [] (wrap-routes user/define-routes))
  (context "/api" [] (wrap-routes app-routes))
  (route/not-found "Incorrect API endpoint."))

and presumably go put a (prn request) in that handler

which route do you end up? those are kinda more routes

which one do i end up hitting?

you tell me

you're sending a request

which handler should end up handling it

yeah sorry im clarifying that is what you are asking

right yeah

ok word so i am drilling into "api/v1/users"

which points to this method

(def define-routes
  "Return all user routes"
  (routes
   (GET "/:id" [id :as req] (response (get-user id req)))
   (GET "/:id/address" [id :as req] (response (get-address-by-user id req)))
   (POST "/" req (response (create req)))
   (POST "/:id" [id :as req] (response (update-user id req)))))

and i am hitting this function

(POST "/:id" [id :as req] (response (update-user id req)))

replace it with (POST "/:id" [id :as req] (do (prn req) (response (update-user id req))))

on it

stand by

the body prints correctly as expected

:body {:id "c0c03eff-9870-4c0e-83ac-506bf59d69cf", :first "Yusuke", :last "Urameshi", :email ""}

awesome!

then we are turning json into clojure

and wrap-json-body is working

BUT i want to intercept this request prior to getting to this point is what im attempting to do

ok

does that makes sense?

then lets try that now that we know the json is working

or is that sorta a no-go with clojure?

which i didn't think we had seen before

we've made progress

that totally makes sense

ok cool

we're gonna update that request. that's exactly what middleware do

that is my understanding too 🙂

and its gonna be basically this

(defn with-uuids
  [handler]
  (fn [request]
    (handler (update-in request [:body :uuid-key] #(java.util.UUID/fromString %)))))

where would this live?

so that's a middleware functin

put it in the ns next to where your app handler is defined. the one that hooks up all the middleware

maybe ive been looking at the wrong spot cause i thought it would go in this thread

(defn routes-handler [database]
  (-> routes/define-main-routes
      (wrap-json-body {:keywords? true :or {:message "Broke"}})
      (wrap-uuid-type)
      (wrap-database-component database)))

right put it in there

yes it will go in that thread

now before or after the line with wrap json body

yeah that is what wrap-uuid-type does but we are back to the :body being an input stream

ok. so we have our middleware out of order then

put the middleware on the other side of wrap-json-body then

if its below put it above; if above put below

right this is what happens in both situations

https://clojurians.slack.com/archives/C053AK3F9/p1587698595461300?thread_ts=1587696826.448300&cid=C053AK3F9

use my function not yours

or post yours

its not correct

let me try yours first before we go to mine

ill comment mine out

yeah we need this to run after the body has been turned into json

and we will update the uuid to be a UUID type and then call the handler on that

im so effing confused why it is working now

maybe my function was wrong?

yeah it was super wrong

post it

lets look over it

sure so i had this

(defn wrap-uuid-type
  [handler]
  (fn
    ([request]
     (let [body (id->uuid (:body request) ids-to-replace)]
       (handler (assoc request :body body))))))

and id->uuid is this

(defn ^:private id->uuid
  [original-map to-replace]
  (reduce
   (fn [cur-map k]
     (if (contains? cur-map k)
       (assoc cur-map k (string-util/to-uuid (k cur-map))) cur-map))
   original-map to-replace))

let me post all three it will be more readable sorry

(def ids-to-replace
  [:id :user_id :seller_id])

(defn ^:private id->uuid
  [original-map to-replace]
  (reduce
   (fn [cur-map k]
     (if (contains? cur-map k)
       (assoc cur-map k (string-util/to-uuid (k cur-map))) cur-map))
   original-map to-replace))

(defn wrap-uuid-type
  [handler]
  (fn
    ([request]
     (let [body (id->uuid (:body request) ids-to-replace)]
       (handler (assoc request :body body))))))

now i tried ^ and it works?

im so confused what has changed....

that's different from earlier

(defn wrap-uuid-type
  [handler]
  (fn
    ([request]
     (println "first on submit")
     (let [response (handler request)
           body (id->uuid (json/read-str (:body response) :key-fn keyword) ids-to-replace)]
       (println (assoc response :body body))
       (assoc response :body body)))))

yeah im confusing myself and changing things then getting frustrated and forgetting what i did

so couple things wrong. imagine this is run before the body is changed into a clojure map

scratch that. you see (let [response (handler request) this line? You're calling the handler on the request without updating the body to be either json or uuid'd

so double wrong

yeah

so posting now works like a charm which is nice but i see where i was confusing myself

now we've separated things. we have just a json middleware that turns application/json requests into clojure maps

correct

now when we fetch data we are getting the stream issue

what's the stream issue?

which the error looks like this

java.lang.IllegalArgumentException: contains? not supported on type: org.eclipse.jetty.server.HttpInputOverHTTP

ok. so you're calling something on a map but you haven't run the json middleware

since the body looks like

:body #object[org.eclipse.jetty.server.HttpInputOverHTTP 0x1ab8640f "[email protected][c=0,q=0,[0]=null,s=STREAM]"]

yup. so the json middleware didn't run?

it seems like it, correct

ok. why not? did the request include the application/json header?

and if so, did the json middleware run before this error happened?

that may be it...let me see

so i know for a fact i have not been explicitly setting it anywhere

so that is probably the problem...

in clojure land, should it be explicit in each endpoint?

setting what?

content type

that's not set by an endpoint, that's set on a request

yes every request needs to set its content-type to indicate that its sending json

via chrome i see

Content-Type: application/json

let me try with postman

are you saying the request has the content type header correctly set?

chrome says yes but i just tried in postman with explicitly setting the content type and it works

so i think the angular app needs to explicitly set it

one second

no dice with explicitly setting it

but works in postman so hmm

this is def an angular issue now

Dan thank you so much for being patient with me and helping me understand

i truly appreciate the mentorship

well hate to say it but awesome lol

with simple curls it should work

curl localhost:3000 --request POST --header "Content-Type: application/json" --data '{"thing":"0f248583-d687-4417-b621-1ac1af92962a"}'

that's what i was doing

yup it does and i see that the content type is empty so its def a client facing issue now

well at least we're square on the backend

i hope the frontend can easily be set somewhere

oh and i meant to say that you're incredibly welcome

i hope your project goes smoothly in the future 🙂

lein help test is a good start.

ahh perfect! cheers

And a bit of context: https://github.com/technomancy/leiningen/blob/master/doc/TUTORIAL.md#tests

let me clarify, you don't get a stack trace?

wait..so I just got my eval defun at point to work, but I don't see how this is a debugger

like how would I actually use it? I thought I could go through each expressions and see where it breaks???

https://docs.cider.mx/cider/debugging/debugger.html

For doom-emacs what I have to do is: • f9 on the function definition • f9 on the function call

where f9 is cider-debug-defun-at-point

ohhh yeah ot

it's working now. I messed up the functions I was doing eval not the debug this whole time thxs a lot 😄

This is interesting. I've been playing with this, trying to get it to work, and the only way to "pass the test" is to say (thrown? clojure.lang.Compiler$CompilerException (macroexpand '(...)))

you could also try/catch on the Compiler$CompilerException and then assert about the cause

okay, i'll give that a whirl

hmm - but to really ensure the test runs and can fail, you should return the exception from the try/catch, then assert on that outside the catch

got that working. further testing has shown that using macroexpand in the repl works, but not in a test file run with lein test. Using eval works with lein test as long as I fully-qualify the name: cond-plus.core/cond+

thanks so much for the help

macros are happy to expand to functions / macros that are not (yet?) in scope, so ensure that all the code that is in the expansion is required in the context you are using it (clojure won't enforce this in the way it would for functions)

of course this turns into an error at runtime, it's just that it won't be reported in the way we are used to

sorry for this confusion. Just updated the message