What if you just try

(defn label [text]
  [:div {:class "label"} text])

(label "my text)

Works perfect, thanks! And you solved my issue in my next example, where I had wrapped my input text in square brackets unnecessarily. It seems like by defining my "components" as functions like your example provides all the functionality I'd really need, in what scenarios (if any) would you want / need to use (rum/defc to create a custom component? It seems this is creating a react component?

It's useful if you're defining components on the frontend (I.e. in cljs). In that case, defc does create a react component. With server side rendering, defc is basically the same as defn. I'm honestly not sure if there's any difference. (I guess one difference I am aware of: if you're making components that are shared between your clj and cljs code, then besides letting you use the same code, defc can help rum insert metadata on the backend which will help the frontend do hydration). basically, for biff apps, you can just stick with defn :).

You can just call your non-hard-coded myHTMLFunction with

(myHtmlFunction "Hello World!")

(my-function ["yay"])

Minor style point: typically, Clojure functions are named with dash-seperated-lowercase-words (“kebob case”) so your function would be

(defn my-html-function [inputText]
  [:div {} inputText])

(my-html-function "Hello World!")

Thanks so much! That was very helpful. I know these are the super basics, but having shifted a paradigm from from oop to functional, client to server side, and html to rum syntax is enough change to make the tiny things a bit overwhelming, and cracking the door open enough to experiment with your help is much appreciated.

you're returning a middleware function inside a middleware function; I think you just want to slurp the contents of that second function into the else part of your if form, unless I'm not understanding what you're trying to do. the xt/pull call looks weird, but I haven't used it directly; I always use biff/q or biff/lookup . As for 'isolating' it, I would extract the function, and pass it the db as an arg. For testing, though, you can dereference the biff/system atom. something like:

(defn user-by-session-uid [{:keys [biff.xtdb/node]} session-uid]
  (let [db (xt/db node)]
    (biff/lookup db :mem/session-uid session-uid)))

(defn wrap-signed-in [handler]
  (fn [{:keys [session] :as req}]
    (if-let [session-uid (:uid session)]
      (let [user (user-by-session-uid req session-uid)]
        (handler (assoc req :mem/user user)))
      {:status 303
       :headers {"location" "/"}})))

(comment
  (let [sys @biff/system
        _ (tap> sys)
        fake-req (assoc sys :session {:uid "hardcoded-uid"})
        fake-handler (fn [{:keys [mem/user]}]
                       (ui/page
                        {}
                        [:div#user user]))
        middleware-fn (wrap-signed-in fake-handler)]
    (middleware-fn fake-req))
  )

btw, I recommend the pattern of putting code to exercise the function(s) you're writing in a comment and sending self-contained forms to the repl; (Ctrl-x-e in emacs and iirc intelliJ). https://github.com/djblue/portal is also super useful for seeing what is inside datastructures like biff/system (`tap>` sends to anything that registers as a tap)

here is the non-diff version of the function from the tutorial code: https://github.com/jacobobryant/eelchat/blob/master/src/com/eelchat/middleware.clj#L11

from taking a look at the diff on https://biffweb.com/docs/tutorial/communities/, it looks like you added the new/green-highlighted code but didn't delete the old/red-highlighted code

(the xt/pull call is discussed briefly in the tutorial btw--it's handy when you already have the document ID and you want to use the pull syntax to get additional referenced documents)

also for debugging/isolating the pull stuff, I often do it in repl.clj (see the let form that calls get-sys, which is kinda handy since then the db is right there. though you may have to add requires to that file, in which case adding a comment form to the original namespace you're working on can be more convenient.

didn't know about get-sys- thanks 🙂

You all rock! Thank you so much. This discussion hit so many little issues I was having and it’ll allow me to hit cruising altitude with my workflow. 🙂 I have to implement and play with it all and so there may be a few little follow on questions here.

For the record, lol… I actually had a non middleware-inside-middleware version of wrap-signed-in up until I flailed and somehow modified it as I posted it at 3:30 am… but I’m glad I did as this thread has been really helpful. “Suuuuure, Macro Bartfast… if you say so.” I’m not sure what the issue was but something was wrong with whatever I had previously, that’s for sure. It’s all working now. I’ll take a crack at working with the db call in isolation next.

And I’m also going to set up Portal. Pumped on that.

(for anyone seeing this question… see my previous question and the comprehensive answers which addressed this.)