Is there some build cache I need to clear somewhere, or something?

looking in the shadowcljs ui, it says it's watching main

Not sure, but you might be mixing up backend servers in both projects. Could be that you started a backend server in the billing-app and never stopped it, so your backend port is still serving from there. I'd look for a process using the port in question and kill it if it's there, then try again with the fulcro-template project. Take a look through this section and some of the surrounding ones https://book.fulcrologic.com/#_setting_up_a_server

i thought that at first. but have been through a pgrep java | xargs kill`

this am. and a restart this afternoon.

(and a kill of clojures, too)

:man-shrugging:

did you change some paths but still have the old output files lying arround?

the error is telling you that the .js files you have loaded where not produced by the shadow-cljs instance currently running

this can happen if you have changed some paths but didn't update your html accordingly, thus loading old files

or sometimes when running 2 shadow-cljs instances in the same project concurrently

figure out which files you are actually loading and where they come from 😛

when you say "changed paths", what do you mean? do you mean, changed content of file, or changed some value named path in say deps.edn or other config file? This morning It looked very much like serving the other project. Which would make me think I had a phantom shadowjs hanging about, if it wasn't for both this morning, and this afternoon I refreshed the shadowjs ui between app ui refreshes and saw that it wasn't running.

but I fully conceded I don't know what I'm doing yet. or might have misremembered something. when it was just this once, this morning, I assumed silly transient thing I'd done. When it happened again, I was most confused 🙂 hence the question!

paths as in your actual .js files produced by shadow-cljs and where you access them. so your <script src="...">

so if you change :output-dir in shadow-cljs.edn for example

one good test is deleting the files you think you are loading and loading your page

if its still loading then go look for the correct files 😛

could also just have changed :modules (which changes the filenames) but still loading the old files

thanks! I'll dig through those options if i make it happen again. Appreciate the help 🙂

* is a wildcard. It means "get everything". Unfortunately * is also a valid clojure symbol (that would resolve to multiplication) so you have to quote it so that you get JUST the symbol as data in the query

Thanks @tony.kay

@U6VPZS1EK the link is busted (or perhaps private)

I don't remember what RAD report auto-adds to its query internally. You can run get-query on the report in a REPL and see. Pretty sure the cache stuff isn't there because that would cause a lot more query load during rendering, and you typically are not going to render those things. You really should not be directly using filtered-rows or loaded-data in the UI...current-rows is the intended visible data. I guess you might want a count of those, but you can do that on the vector of idents. If you really need other things, and the number of things is relatively small, then while it isn't ideal (for performance) you can use db->tree on (app/current-state this) to convert your idents to their denormalized counterparts. What you should do instead is customize the state machine for that report, so you can do these "other" calculations or whatever at a well-defined user event instead of on every render. For example, if you're trying to get some overall stats (how many cards have label X), you should do that in the state machine just after the data load, and put the statistic in the cache so that rendering is super fast (and isn't recalculating it every time).

Stats on the current-rows is quite tractable, so calculating those in the UI is usually fine and even preferred (no cache to invalidate)

Oh…. I knew that you’d mention creating a state machine, and I knew I’d roll my eyes when you did. 😆 But holy cow, you’re right — in one particular Trello list, there’s 2000+ elements, and the current approach seems fast enough. But I think putting that (get-all-rows) action makes a lot more sense in the “sort” portion of the state machine. Thanks again!

Sure, It really isn't hard...here's an example of where I customized one, just so you can see it can be pretty easy:

(defn load-statistics [env]
  (let [{:project/keys [id]} (report/current-control-parameters env)]
    (uism/load env :local/stats TheStats {:params {:project/id id}
                                          :target (conj (uism/actor->ident env :actor/report) :local/stats)})))

;; Use the normal report state machine, but change the handler that post-processes running the report,
;; and adds an additional load that gets the stats
(defstatemachine report-with-stats
  (let [base-machine report/report-machine
        handler-path [::uism/states :state/loading ::uism/events :event/loaded ::uism/handler]
        base-handler (get-in base-machine handler-path)]
    (assoc-in base-machine handler-path
      (fn [env]
        (-> env
          (base-handler)
          (load-statistics))))))

ro/machine             report-with-stats
   ro/query-inclusions    [{:local/stats (comp/get-query TheStats)}]

Thanks for posting such a helpful example of implementing this inside of the RAD state machine, @tony.kay — it took a little studying to see how you extended the default RAD state machine. Very cool.

I should probably add helper functions for common modifications like this...since it's pretty boilerplate

The reason is in your implementation of the resolver. If there are no allergies, then either return an empty list or just elide the :order/allergies-list. The only way you get what you're getting is if you return something like {:order/allergies-list [{}]} and the normalization tries to create an ident out of that.

@tony.kay the resolver looks like this:

(pc/defresolver order-allergies-list-resolver
  [{:keys [crux] :as env}
   {:order/keys [id]}]
  {::pc/input #{:order/id}
   ::pc/output [:order/allergies-list]}
  (log/debug "order-allergies-list-resolver" {:order/id id})
  (when-let [allergies-list-id (q/order-id->allergies-list-id crux {:order/id id})]
    {:order/allergies-list allergies-list-id})
  {})

[{[:order/id 2]
  [{:order/allergies-list
    [:allergies-list/id]}]}]

{[:order/id 2] {:order/allergies-list {}}}

the empty map is the problem in the result

when-let isn't sufficient...an empty map is still "true"

the resolver code sent here will always return an empty map (need to use if-let and make the empty map the false path)

wonder how you are getting the empty map under :order/allergies-list in this case

Updating the resolver like this still produces the same result:

(pc/defresolver order-allergies-list-resolver
  [{:keys [crux] :as env}
   {:order/keys [id]}]
  {::pc/input #{:order/id}
   ::pc/output [:order/allergies-list]}
  (log/debug "order-allergies-list-resolver" {:order/id id})
  (if-let [allergies-list-id false #_(q/order-id->allergies-list-id crux {:order/id id})]
    {:order/allergies-list allergies-list-id}
    {}))

> when-let isn't sufficient...an empty map is still "true" > need to use if-let and make the empty map the false path Just to clarify these two points -- is returning an empty map okay in cases when the data cannot be found, or should it return false or nil?

> If there are no allergies, then either return an empty list or just elide the :order/allergies-list. Eliding the key still produces the same behaviour as I described, but returning something like {:order/allergies-list '()} results in:

{:order/id 1
 :order/allergies-list []}

empty map is fine, it shouldn't have the key on the output in this case

I'm gonna try to reproduce your case here

(ns com.wsscode.demos.repro-elide
  (:require [com.wsscode.pathom.core :as p]
            [com.wsscode.pathom.connect :as pc]))

(pc/defresolver order-allergies-list-resolver
  [{:keys [crux] :as env}
   {:order/keys [id]}]
  {::pc/input #{:order/id}
   ::pc/output [:order/allergies-list]}
  (if-let [allergies-list-id false]
    {:order/allergies-list allergies-list-id}
    {}))

(def registry
  [order-allergies-list-resolver])

(def parser
  (p/parser
    {::p/env     {::p/reader               [p/map-reader
                                            pc/reader2
                                            pc/open-ident-reader
                                            p/env-placeholder-reader]
                  ::p/placeholder-prefixes #{">"}}
     ::p/mutate  pc/mutate
     ::p/plugins [(pc/connect-plugin {::pc/register registry})
                  p/elide-special-outputs-plugin
                  p/error-handler-plugin
                  p/trace-plugin]}))

(comment
  (parser {}
    [{[:order/id 2]
      [{:order/allergies-list
        [:allergies-list/id]}]}]))

outputs:

{[:order/id 2] {}}

maybe there is some plugin that's messing with the output?

@U066U8JQJ my parser is setup like this:

(ns sheluchin.parser
  (:require
    [sheluchin.resolvers]
    [sheluchin.mutations]
    [sheluchin.server.config :refer [config]]
    [sheluchin.server.db.mounts :refer [crux-node]]
    [com.wsscode.pathom.core :as p]
    [com.wsscode.pathom.connect :as pc]
    [taoensso.timbre :as log]))

;; helper from glam repo
(defn mk-augment-env-request
  [get-config-map]
  (fn augment-env-request
    [env]
    (merge env (get-config-map env))))

(def resolvers [sheluchin.resolvers/resolvers sheluchin.mutations/mutations])

(def env-additions
  (fn [env]
    {:crux crux-node
     :config config}))

(def pathom-parser
  (p/parser {::p/env        {::p/reader                 [p/map-reader
                                                         pc/reader2
                                                         pc/ident-reader
                                                         pc/index-reader]
                             ::pc/mutation-join-globals [:tempids]}
             ::p/mutate   pc/mutate
             ::p/plugins  [(pc/connect-plugin {::pc/register resolvers})
                           p/error-handler-plugin
                           (p/env-wrap-plugin (mk-augment-env-request env-additions))]}))

(defn api-parser [query]
  (log/info "Process" query)
  (pathom-parser {} query))

is there any other resolver that might also output :order/allergies-list?

with your setup I would expect the it to output ::p/not-found, as you are not using the plugin to elide special values, that output you saw from the REPL or calling from Fulcro?

I have a log/debug in every resolver and I can see that no other resolver is being hit. I notice that the output is different in Inspect's EQL tab and in my REPL. Query:

(api-parser
   [{[:note/id 1]
     [{:note/x
       [:x/id]}]}])

{[:note/id 1] {:note/x {}}}

{[:note/id 1] #:note{:x :com.wsscode.pathom.core/not-found}}

And sure enough, after adding p/elide-special-outputs-plugin, the REPL output for the query is as yours was: {[:note/id 1] {}}

yeah, the problem is that Fulcro considered there was a key there, and then turns that into an empty map (because of the sub-query)

should work fine with the elide plugins, please let us know if you have further issues

Interesting. I just confirmed that with the elide plugin activated, the original issue that I noticed:

{:order/id 1
 :order/allergies-list [:allergy-list/id nil]}

{:order/id 1}

I suppose the importance of the elide plugin should be highlighted somewhere in the docs. I could make a PR for that if you'd like. Thank you both very much for helping me figure this out.

yes, this caused a lot of pain already, that's why I removed the concept of ::p/not-found in Pathom 3

so you just get a missing key in this same case

maybe add here? https://github.com/fulcrologic/fulcro-template/commit/f7d97957d0016ba62526306c78b3f50c85063f86#diff-dcf0e5876ca3ebf3570d220cbd821b102b1a4b4985b9f16b308a783d68341443R49

It has (p/post-process-parser-plugin p/elide-not-found) just a few lines below. Looks like elide-not-found is a slightly more conservative option than elide-special-outputs since it doesn't elide reader errors. Do you still think e-s-o would still be helpful to add there? I was thinking of mentioning it in the Fulcro Book around where the first Pathom parser is configured, because without using either of those elide plugins, Fulcro behaviour can be unexpected/buggy in not-found situations. Maybe here? https://book.fulcrologic.com/#_the_communication

true, I missed that, this would work the same in your case

https://github.com/fulcrologic/fulcro-developer-guide/pull/90 Hope that helps.