but then you’re adding overhead all over the place to keep the thing up to date, and if it turns out the lack of an index isn’t a real problem, then you just added a bunch of crap to your app for no reason

that's a good question

I'm mainly doing an evaluation of something like fulcro vs datascript. I'm coming from the perspective of having used datascript/datomic before which does allow multiple unique indexes for a given entity

sure, and then you let them “hide” the overhead of indexing 😉

but it is still there.. remember you’re making an app db largely for the purpose of rendering

and having all that overhead in your render pipeline, esp when not needed, isn’t a great idea

Yep, perf of arbitrary queries is def a concern w/ datascript

Thanks for laying out the tradeoffs

Can I specify to a server mutation to add stuff like session data? EG: I have a pathom resolver:

(pc/defresolver session-account-resolver [env _]
  {::pc/output [:account/name]}
  (let [session (get-session env)
        username (some-> session :account/name)]
    {:account/name username}))

{::pc/input  [:account/name]}

I'm continuing to try to get SSR working with routers on node.js the strategy of calling (app/render! my-app) works in that the rendered string is in the runtime-atom under the ::app/app-root key, but I'd like to get the (renderToString (ui-root data-tree)) version working.

(defn init-app [root-component]
  (let [app (app/fulcro-app {:render-root! react-server/renderToString})]
    (app/set-root! app root-component {:initialize-state? true})
    (swap! (::app/runtime-atom app) #(assoc % ::app/root-factory (comp/factory root-component)))
    (app/update-shared! app)
    (dr/initialize! app)
    (dr/change-route! app ["main"])
    app))


  (def a (init-app root/Root))

  (dr/current-route a root/Root) ; => nil

  (dr/ast-node-for-live-router
    a
    (eql/query->ast (comp/get-query root/Root (app/current-state a))))
    ; => nil

I've traced the problem to the above ^^ - on the client current-route returns ["main"] but on node.js it's returning nil. it seems like this is from the call to ast-node-for-live-router returning nil. This is as far as I got, and am basically stuck here. Wondering if anyone has any pointers on how to debug this

@danvingo the current-route function relies on the mounted components index…you’re not mounting components, so there is no “current route”

it was “the easy way” to implement that function, but technically it could be rewritten as a (fn [state])

Fulcro is designed to have as much isomorphic support as possible (for the stuff that normally runs in a client or server, so in either direction). I use the “run stuff as a server on the client”, but not “run client headless on a server”, so there are certainly many holes in the implementation. I do not need it to behave that way, so contributors will have to step up with patches where the implementation isn’t working

node should be much easier to make work, since the component implementation is complete in js (it is not in clj)

thanks @tony.kay

(defn init-app [root-component]
  (let [app (app/fulcro-app {:render-root! react-server/renderToString})]
    (app/set-root! app root-component {:initialize-state? true})
    (swap! (::app/runtime-atom app) #(assoc % ::app/root-factory (comp/factory root-component)))
    (app/update-shared! app)
    (dr/initialize! app)
    (app/mount! app root-component {})
    (dr/change-route! app ["main"])
    app))

timing? change-route can cause async behaviors

and mount schedules a render….async is fun!

tehcnically change-route is almost certainly working

ast-node-for-live-router (and therefore current-route) will not work…but that does not prevent you from rendering

otherwise the other would not be able to work either

The biggest problem you’ll face doing isomorphic rendering is the fact that if you do it on node everything is async, and I have not really left much in the way of hooks for “wait until everything is done”…e.g. you could install loopback remotes and make the thing fully-functional, but that requires everything in Fulcro be wired to allow you to hook into some concept of async notifications about completion. But, since so much is async, it’s difficult to say when that moment is (just because a remote goes idle doesn’t mean you didn’t just submit some new remote request from th result-handler of that prior load)

so I don’t

gotcha, thanks for the info - i think it may be the indexes as you suggested:

(comp/class->any a root/TopRouter) ; => nil 

right, that requires a mounted component

which you don’t have

none of the indexes are populated, unless you implement a headless React that calls lifecycle methods (which is where I control indexes).

ah okay, so it's probably not worth it to keep going down this route? I should just use the render! method then?

I don’t understand why you say that…

all it is doing is calling the function for you

there’s nothing magical under the hood for this…change-route changes state (via a transaction)…that is async. You’re seeing the result in app probably because you’re waiting long enough

sorry I may not have been clear. I understand about the async issue. But even when waiting for the state to update, this is working:

(app/render! app)
(-> (::app/runtime-atom app) deref ::app/app-root)

but all it is doing is calling renderToString

you need: 1. Correct state map 2. ((comp/factory Root) (db->tree Root state-map state-map))

that is all render is…at that point you should have a “react element” that can be rendered

I see. then I assume my app state is not setup as I think it is. Thanks for the help debugging

found the issue! the query for the root component wasn't getting constructed properly because of the dynamic queries for the router (I wasn't passing the state parameter)... This is working now:

(defn data-tree [app root]
  (let [state     (app/current-state app)
        query     (comp/get-query root state)] ;; I wasn't passing "state" here before...
    (fdn/db->tree query state state)))

(defn init-app [root-component]
  (let [app (app/fulcro-app {:render-root! react-server/renderToString})]
    (app/set-root! app root-component {:initialize-state? true})
    (dr/initialize! app)
    ;; start user state machines here.
    (app/mount! app root-component {})
    app))

(defn render-to-str [cb]
  (let [a (init-app root/Root)]
    (dr/change-route! a ["main"])
    (js/setTimeout #(binding [*app* a]
                      (cb (react-server/renderToString ((comp/factory root/Root) (data-tree a root/Root))))))))