Clojurians Log v2

I use them very much like a normal remote most of the time. Most of the systems I work on don’t need much from the push side. A few select features/screens. No, I don’t really have any public examples I know of that use them extensively.

Grokking Fulcro part 2 is now available: https://youtu.be/102nHLzIbE4

Thank you all who contributed to the Fulcro Rationale! I will now add it to the minimalist tutorial and also share it with the community.

On the topic inputs, I'd like to revisit a question I asked previously, but didn't quite get straight in my head. Let's say I have a number of inputs, and a save button (or something else that needs to know some sum total of the inputs). Let's say I want the save button to disable and enable interactively as the user types valid or invalid values into the inputs. I only want the save button and the currently selected input to refresh. I don't want to re-render all components in the parent when the currently selected input is manipulated. It seems to me that in order to get this to work, I'd have to put the save button in a component with some ident that can be targeted independently, and give it props to know whether the inputs are valid or not. After that, I seem to have two options: 1. Use transact! and give :only-refresh the idents of the input and the save button component. 2. Use transact!! and immediately schedule a refresh of the save button component afterwards, by putting a comp/refresh-component! as the second arg to a do block. Which of these is preferable? Is there some other option that I haven't considered (barring "don't refresh the state of the save button interactively" of course, which would invalidate the entire question)

I isolated a quirky situation with a union query and placeholder logic :>/bla where the final merged result is not what I would expect. The :cmmn.case/state prop is missing, as demonstrated in the test at the bottom. I'm not sure whether this is a bug or expected behaviour?

(defn get-case-ident
  [props]
  (let [case-id? string?]
    (cond
      (-> props :nexus.case.image-annotation/id merge/nilify-not-found case-id?) [:nexus.case.image-annotation/id (:nexus.case.image-annotation/id props)]
      (-> props :nexus.case.test-case/id merge/nilify-not-found case-id?) [:nexus.case.test-case/id (:nexus.case.test-case/id props)]
      :else (log/error "Cannot derive a valid ident. Invalid props." props))))

(defsc AddState [_ _]
  {:query [:nexus.case.image-annotation/id
           :cmmn.case/state]
   :ident :nexus.case.image-annotation/id})

(defsc ImageAnnotationCase [this props]
  {:query [:nexus.case.image-annotation/id
           :cmmn.case/name
           ;; cmmn.case/state -> not queried here but under :>/bla placeholder!
           {:>/bla (comp/get-query AddState)}]
   :ident :nexus.case.image-annotation/id})

(defsc TestCase [this props]
  {:query [:nexus.case.test-case/id
           :cmmn.case/name
           :cmmn.case/state]
   :ident :nexus.case.test-case/id})

(defsc CaseUnion
  "Union query component for different Case types."
  [this props computed]
  {:query (fn [] {:nexus.case.test-case/id        (comp/get-query TestCase)
                  :nexus.case.image-annotation/id (comp/get-query ImageAnnotationCase)})
   :ident (fn [] (get-case-ident props))})


(deftest bla
  (behavior "Reproduce situation where the :cmmn.case/state of the first case doesn't show up in merged props"
    (let [response [{:nexus.case.image-annotation/id "case-id-00000001"
                     :cmmn.case/name                 "Annotate Image 1"
                     :cmmn.case/state                ::merge/not-found ;; Note: I captured this by logging data-tree in pre-merge
                     :>/bla                          {:nexus.case.image-annotation/id "case-id-00000001"
                                                      :cmmn.case/state                "completed"}}
                    {:nexus.case.test-case/id "case-id-00000004"
                     :cmmn.case/name          "Test Case 1",
                     :cmmn.case/state         "active"}]]

      (assertions
        "Show that :cmmn.case/state isn't merged"
        (merge/merge-component {} CaseUnion response) =>
        {:nexus.case.image-annotation/id {"case-id-00000001" {:nexus.case.image-annotation/id "case-id-00000001"
                                                              :cmmn.case/name                 "Annotate Image 1"
                                                              ;; :cmmn.case/state             "completed" <== EXPECTED!!
                                                              :>/bla                          [:nexus.case.image-annotation/id "case-id-00000001"]}}
         :nexus.case.test-case/id        {"case-id-00000004" {:nexus.case.test-case/id "case-id-00000004"
                                                              :cmmn.case/name          "Test Case 1"
                                                              :cmmn.case/state         "active"}}}

        ))))

since there's not a guardrails channel, I'll ask here: is there a way of creating a normal value with a spec (like def)? It seems that >def is used to create specs, non specced values

also, when I trigger a spec error, is there a way of getting back a stack trace of the functions that triggered it?

1. Why do you care which inputs “refresh”. You’re in control of their state, so the question of React checking them should be irrelevant. You control the state. Do what is right in state, and trust the UI to be correct. 2. Targeted refresh requires each input have an ident, which means making quite the mess of your UI tree to get what you’re talking about. Typically a form will have an ident, and that is what you can control refreshing. If you rewrite so that inputs have idents, it means you spread your form out in a really wacky way, and have to invent idents on the fly (and not use form state). The unit of refresh control is “something with an ident” (unless you use component local state). The !! notation will get you localized refresh on closest parent IDENT, not some logical component.

If you’re seeing what you think are performance problems you should first run it in prod mode to turn off inspect, guardrails, logging, and react dev.

Has anyone tried to connect Fulcro with Firestore (from the client side, no server)? That's the setup I'm working with and considering using Fulcro. It feels like Firestore could be treated as a remote, and any real time updates simply fed to the app as load!s. Is there any prior art here?

I'm a bit worried about spamming Firestore with reads that aren't necessary. But perhaps if I write it properly the queries never hit Firestore, and instead I just request all the working data up front, and let Firestore subscriptions keep the client DB up to date. That's not going to be practical in every app, but it is for my two use cases.

Not a ton, but the rad-kv-store is a decent first step to getting there for RAD-based stuff

I do not have time to look into this right now. Since you seem to have a repro case and test you could just open an issue, yes.

in terms of it being expected or not…I’m not saying yes/no…I just don’t have time to read all that period

no

Values do not have specs. Call sites and map values have specs (the latter via their keys)

values are checked by specs

You can use timbre log/error and hand it an exception (log/error (ex-info …) "Message")

timbre will show the stack trace then (first arg is exception)

Ok, I'll clean it up some more and log an issue. I don't think it's a pressing issue, more of an edge case to be aware of.

sorry, I probably used some slightly wrong terminology: by value I didn't mean an atomic one, but also a map value for example. Basically, I can define a value and then call conform to see if it obeys some spec. I was interested in understanding if I could do that when I define my map, for example.

awesome, I'll look into that, thanks!