@thosmos F2 or 3?

F3 (I’m migrating my F2 app to F3)

ok, so derived data requires that you do either one of: 1. Use the keyframe renderer, and don’t worry about anything like this ever again. 2. Add a standard F2 follow-on read of a prop on the parent to the transact! that makes the change.

There’s a 3rd option I’ve added recently that actually is a better alt in many (probably all) cases: <http://book.fulcrologic.com/#RenderingOptimizations>

keyframe 2

It does keyframe, but supports :only-refresh on transactions. This lets you do targeted refresh at component-local state speeds when you need it, but otherwise “just works”

I personally have come to prefer this last option, as it is a “forget it” until something is slow, then add a single option to a transact to speed it back up

it will probably become the default when I have time to rewrite the portions of the book that matter…which means reading the whole book 😜

haha, ok yeah I just read about those earlier today, sounds like keyframe2 is the way to go

Ah yeah that works more like I was expecting …

Where do we need Legacy UI Routers When we have Dynamic Router ?

Hi there! I’m trying to figure out how to get ::fs/config normalized when I add it in :pre-merge:

(defsc SomeComponent [this props]
  {:query         [:some-field
                   fs/form-config-join]
   :form-fields   #{:some-field}
   :ident         (fn [] [:component/id :some-component])
   :pre-merge     (fn [{:keys [data-tree]}]
                    (fs/add-form-config SomeComponent data-tree))})

How much does Fulcro weigh at baseline when gzipped, together with cljs? Is it around ~500kb?

closer to about 200kb gzip'd

within a component, can I expect calling set-value! on a second, imported component to work correctly? e.g. (fm/set-value! SomeOtherImportedComponent :field 123)

any known impediment of using react 16.10.x with fulcro ?

none I know of

Hi. I’m a total beginner with fulcro and I’m trying to get a websocket connection working both ways. I got com.fulcrologic/fulcro-websockets working on the client side:

(defonce APP (app/fulcro-app
               {:remotes {:remote (fws/fulcro-websocket-remote
                                    {:push-handler (fn [whatever] (println (str "WS EVENT! " whatever)))})}}))

(def websockets
  (fws/start! (fws/make-websockets
                api-parser
                {:http-server-adapter (get-sch-adapter)
                 :sente-options       {:csrf-token-fn nil}})))

(def middleware
  (-> not-found-handler
      (fws/wrap-api websockets)
      (server/wrap-transit-params)
      (server/wrap-transit-response)
      wrap-keyword-params
      wrap-params
      (wrap-resource "public")
      wrap-content-type))

@nocnashada sente has a concept of client IDs

you have to indicate which client(s) the send message should go to

Assuming websockets is your “started” websockets:

(defn active-cids
  "Returns the active websocket client IDs in the given websockets handler. If a websockets handler
  is not supplied it defaults to the running server's gondola.component.websockets/websockets."
  ([]
   (active-cids websockets))
  ([ws-net]
   (-> ws-net :connected-uids deref :any set)))

(defn push-notification!
  "Send a message with verb :verb and payload :edn to all clients matching the :cids.  If ws-net is not
  supplied it defaults to the running gondola.component.websockets component."
  ([cids verb edn]
   (push-notification! websockets cids verb edn))
  ([ws-net cids verb edn]
   (let [clients   (active-cids ws-net)
         scids     (set cids)
         valid-ids (set/intersection clients scids)]
     (doseq [id valid-ids]
       (wsp/push websockets id verb edn)))))

the :connected-uids is all connected clients

the env of a mutation or resolve should include a client ID of the client (I think under key :cid) that talked to you (so if you want to do subscription registration, etc.)

broadcast is just doing a push using all of the connected ids

would love it if you want to update the docs…that got lost somewhere along the lines…used to be well-documented

(defn send-ws [uid] ((:send-fn app.server.server/websockets) uid [::asdf {:data "data"}]))
=> #'user/send-ws
(map send-ws (:ws @(:connected-uids app.server.server/websockets)))
=> (nil)

You mean got lost in the fulcro 2.7 -> 3.0?

you also have to enable “parser-receives-env?” option

if you want to see CID on the env, I think

be careful using map…is lazy

REPL eval probably saves you, but if you look I think you don’t have the data path quite right?

yeah, i know, but it should work when used in repl, right?

connected-uids is an atom that contains :any

I don’t remember the :ws key

i mean, i played around with creating the client ID watch (what’s it called …?) and it prints out client ids into the repl nicely

i’ll check the “parser-receives-env” thing

the parser thing is just for mutations/resolvers

not this REPL stuff

oh

I actively use the websockets support in two production projects. It works. The problem is almost certainly an understanding of how Sente figures out who you want to talk to

yeah, that’s what i figured 🙂

the push function in the ws protocol is what I use

as show in code above

Thanks for the help. I’ll go over this a bit more and check the code you pasted and I’ll see if I manage to get it working.

it is defined as follows:

(defrecord Websockets [parser server-adapter server-options transit-handlers
                       ring-ajax-post ring-ajax-get-or-ws-handshake websockets-uri
                       ch-recv send-fn connected-uids stop-fn listeners
                       parser-accepts-env?]
  WSNet
  (add-listener [this listener]
    (log/info "Adding channel listener to websockets")
    (swap! listeners conj listener))
  (remove-listener [this listener]
    (log/info "Removing channel listener from websockets")
    (swap! listeners disj listener))
  (push [this cid verb edn]
    (send-fn cid [:api/server-push {:topic verb :msg edn}])))

listener, that’s the one.

Note that the client expects the message be a :api/server-push

you’re using send-fn directly, and inventing a diff one

uhh …

oh!

yeah, i figured if i just throw everything into the function “it might work” …

It works! It’s just repl hacking, but that’s fine for now. Thanks @tony.kay

welcome

@nocnashada https://github.com/fulcrologic/fulcro-websockets/blob/develop/README.adoc#connected-clients-and-server-push I updated the README…let me know if I messed up at all

yup, this is it