If anybody is looking for a solution in future I got GitHub actions CI running the shadow-cljs tests: https://github.com/chr15m/sitefox/blob/main/.github/workflows/tests.yml

With promises, you don't wait, you never wait. You schedule work. "Do this, .then do that, .then something else." In re-frame, there's nothing built-in. But there are at least 2 libraries that provide an effect for HTTP requests. Using their code as an inspiration, you can easily write your own effect that support issuing multiple HTTP requests and then dispatching a new event once all those requests are completed. So it would be something like

(rf/reg-fx ::fetch-all ...)

(rf/reg-event-fx ::button-clicked
  (fn [_ _]
    {::fetch-all {:urls [url-x, url-y, url-z], :on-success [::-then-fetch-a], ...}}))

(rf/reg-event-fx ::-then-fetch-a
  (fn [_ [_ result-x result-y result-z]]
    {::fetch-all {:urls [url-a], ...}}))

Also, there's #re-frame

@U03SF5VUF6Y, in my opinion this is a bit of a limitation on the re-frame framework. I think the best you can do is stuff this into a reg-fx. I can be more specific if you like. Also you may want to consider taking advantage of some clojurescript constructs for concurrency instead of promises. I realize what you asked for was a re-frame specific answer -- this is not that. I have had some luck in attempting to get https://github.com/day8/re-frame-http-fx to do the job, but you will be forcing the issue to some extent.

Thanks p-himik and unbalanced. I will take a look at using reg-fx. I was hoping for something that would let me compose dispatch calls together in a way similar to how I am used to working with promises rather than having to create a specific handler for each case where I want to ensure that I can schedule some asynchronous work and then only schedule additional work once the previous set of tasks has completed.

Yeah, not possible since dispatch has no return value. You're supposed to compose actions from within (either by hard-coding stuff or by adjusting relevant event handlers so they accept follow-up event vectors), not from the outside (like it's done with promises). There is a way to compose actions from the outside by basically peeking into re-frame's machinery. But I wouldn't recommend even looking in that direction.

@U03SF5VUF6Y the other part of the puzzle is using this library: https://github.com/day8/re-frame-async-flow-fx this will accomplish "wait until I've seen dispatches X, Y, and Z before performing action Foo. It's not perfect because you also need to specify X-fail|Y-fail|Z-fail and then Foo-fail . This also doesn't exactly easily cover usecases like pagination. However, it is a coherent framework for colating data from known, non-dynamic sources.

And personally at this point is when I stopped using re-frame altogether and just switch to reagent + core.async.

That library is exactly what I was referring to in the "wouldn't recommend even looking in that direction". :D

hahahaha

By searching for its name in #re-frame you can find plenty of discussions and descriptions of good reasons not to use it.

Cool, taking a look at core.async now.

If you end up going down that route, Eric Normand has several really friendly video courses on it. That being said -- core.async is not as friendly to debug as promises. I will tell you that the punchline is, 1. do some async work with core.async 2. update your re-frame.db/app-db or some reagent/atom with the result of the core.async work. 3. your page will update accordingly. Updating the page state is your "exit plan" from core.async, otherwise you'll be like, how do I ever get out of this? Because one you start down the core.async pathway it seems like everything needs to be a core.async function and you don't really want that. want to work in sync-land as much as possible. /opinion

Good thread. Can it be moved/linked to #re-frame?

@U032EFN0T33, a link to this thread has been shared to #re-frame Thanks!

if you’re just looking for default behavior you can use extend-type default then in the implementation check what you need to check and call the right implementation

(defprotocol IFoo
  (foo [this] [this that]))

(let [foo-do (reify IFoo (foo [this] "this"))]
  (println (foo foo-do))
  (println (foo (specify! foo-do IFoo (foo [this] "that"))))
  (println (foo foo-do)))

(defmacro extend-types [types & specs]
  (let [impls (parse-impls specs)]
    (list* 'do
           (map
            (fn [protocol]
              (let [spec       (get impls protocol)
                    next-specs (list* 'extend-protocol protocol
                                      (mapcat
                                       (fn [type]
                                         (conj spec type))
                                       types))]
                next-specs))
            (keys impls)))))

I actually considered doing something insane like loading up all the code into a self-hosted interpreter in a webworker and shipping over extend-type code literals, getting back the resulting code as a string, and then dynamically loading it into the calling thread via script but at that point I assumed I was starting to lose my mind

not exactly

(extend-type default IFoo (foo … (if (satisfies IDoc? x) (specify! (.-prototype x) IDefault …) …)))

you have to know a little bit about JavaScript but something like this should work

ohhhhhhh very clever

right the first time some protocol get called you fix up anybody you care about

because JS is dynamic this can work

Okay so, if I were to draw this out into a more complete example, something like this (?):

(defprotocol IDoc
  (save-doc! [this]))

(defrecord Doc [])

(defmulti specify-runtime-behavior! :runtime)

(defmethod specify-runtime-behavior! :main
  [runtime-opts]
  (specify! (.-prototype Doc)
            IDoc
            (save-doc! [this] "sent to webworker!")))


(defmethod specify-runtime-behavior! :webworker
  [runtime-opts]
  (specify! (.-prototype Doc)
            IDoc
            (save-doc! [this] "saved to database!")))

(defn -main []
  (let [runtime-opts (detect-features!)]
    (specify-runtime-behavior! runtime-opts)))

yeap that works too - much simpler

word, thanks!

Don't define ratoms in form-1 components.

Otherwise, your state gets erased on every re-render of those components. Use a form-2 or -3 component, or reagent.core/with-let.

cool thanks @U2FRKM4TW!

Also, there's #reagent

Cc: @U7MHWDLD8

Cc: @U051V5LLP, you might be interested in these, uh, developments since the last thread. :))

("my recent post"/"the last thread": https://clojurians.slack.com/archives/C03S1L9DN/p1662560058268889)

And of course, cc: @U05224H0W and @U08E3BBST! 🙂

if you want changes in shadow-cljs please take this to a shadow-cljs issue. and ideally just make a list of changes that need to happen. I can easily add them, I just don't have the time to figure out what those changes are.

if you are considering writing a patch please create a new target as a copy of the old chrome-extension. this is likely going to break stuff for v2, just in case anyone is still using that

Is #scittle an option?

Hmm, alrighty! Cheers @U05224H0W... a list of changes or a patch/new target incoming. Once we've worked through all the details of our own migration. :))

> Is #scittle an option? Say more @U8VE0UBBR... :thinking_face: My experience with Scittle is pretty minimal. Can you require cljs libs outside of the https://babashka.org/scittle/?

@U018D6NKRA4 - no, I'm afraid not. I missed that this was your requirement

Ah, no worries @U8VE0UBBR :))

it’s to satisfy a JS pattern

This ties into the code splitting conversation from yesterday -- basically I'm trying to replicate that behavior with a clojurescript namespace. I've moved all of my npm deps into external dependencies and setup externs appropriately. Now I'm loading, let's say, react, via

// src/js/components/react-deps.js
import * as React from "react";
import * as ReactDOM from "react-dom";
import { Holdable, defineHold } from 'react-touch';
window.ReactTouch = {};
window.ReactTouch.Holdable = Holdable;
window.ReactTouch.defineHold = defineHold;

<script src="js/compiled/dist/react_deps.bundle.js" type="text/javascript"></script>

(ns cljsjs.react)

(def react js/React))

Use of undeclared Var app.lib.data.pouch/pouchdb                                                                                                                                                             
                                                                                                                                                                                                                   
   6     pouchdb ))                                                                                                                                                                                                
   7                                                                                                                                                                                                               
   8                                                                                                                                                                                                               
   9                                                                                                                                                                                                               
  10  (defn make-local-pouch []                                                                                                                                                                                    
  11    (pouchdb. "local" #js {:skip_setup true                                                                                                                                                                    
        ^---                                                                                                                                                                                                       
  12                           :adapter    "memory"}))                                                                                                                                                             
  13                                                                                                                                                                                                               
  14  #_(.. pouchdb                                                                                                                                                                                                
  15        (plugin (.. js/window -pmemory))                                                                                                                                                                       
  16        (plugin (.. js/window -auth -default))         

(technique lifted and extrapolated from this comment: https://cljdoc.org/d/reagent/reagent/1.1.1/doc/frequently-asked-questions/reagent-doesn-t-work-after-updating-dependencies)

also I swear this is my last question

for at least a month