Some effect handler returns the channel as DB?

re-frame by itself doesn't use channels, so it's most likely an issue with your own code.

The effect handler in this case is the http-xhrio. You provide an on-successand an on-failure and it calls you back on one of them.

Perhaps yes something went wrong with my specification of on-failure or on-success

Sorry, I meant event handler.

Yea, sorry, I did too

🙂

Actually no it is an effect in this case

Can you show the code?

For which?

For the event handler where you use the http-xhrio effect.

I have several layers of wrappers. Would be too complicated to show. But I think you've helped me isolate it to those wrappers

Thx

One of the wrappers probably returns the channel within an event handler that's registered with reg-event-db. Small advice: add an interceptor to all your event handlers that check your DB against some spec. Makes debugging so much more simpler. No problem.

Basically the result is coming back in to an event handler which then does: {:dispatch (conj [::original-event] result)}

but that dispatched event should get the cofx (or db) inserted automatically by re-frame no ?

i.e., i don't need to explicitly thread the cofx (or db) through

Yes. It means that the error happens some place else. Most likely, somewhere earlier.

I hope you don't have code like:

(reg-event-db :my-cool-event
  (fn [_ _]
    (do-stuff)))

what's wrong with that code?

should be fx instead of db ?

If do-stuff just returns a new DB and does nothing else, then all is good! Event handlers must not have side effects.

oh, i bet that's the problem

If you want to have a side effect, create an effect handler and return the effect from one of the event handlers that you've registered with reg-event-fx.

i have a db handler that doesn't return a db

yep, good call

let me look in to that

i remember having this problem once before

Returning nil is not fine as well - your DB will just become nil.

once one reg-event-db returns a non-db, then that becomes the db from there on out!

🙂

haha right

That's why I mentioned having a global interceptor that validates stuff. 🙂

kee-frame has a built-in support for it, for example, because it's such a good practice.

Do you have an example of that interceptor?

Here's how kee-frame does it: https://github.com/ingesolvoll/kee-frame/blob/master/src/kee_frame/core.cljc#L82

The interceptor itself: https://github.com/ingesolvoll/kee-frame/blob/master/src/kee_frame/spec.cljc#L50-L57

cool thx

found the culprit:

+  (rf/reg-event-db
+   ::init-base-data
+   [(rf/inject-cofx ::inject/sub [:state.core/timerange])]
+   (fn-traced [{:keys [state.core/timerange]} _]
+              (reset! route-matrix/*state (assoc-in route-matrix/initial-state
+                                                    [:filters :group-by]
+                                                    (if (app-config-service/get-supports-routes?)
+                                                      "Route" "Path")))
+              (reset! route-matrix/*on-redraw (.. js/ChartUtils -donutcharts -onRedraw))
+              (reset! route-matrix/*timerange timerange)
+              (route-matrix/init!)
+              (reset! route-matrix/*poll (async/poll! init!))))

(this code is halfway in an old-world state and is being re-frameized incrementally)

async/poll! returns a many to many channel

And you must not have reset! within event handlers.

Yes, I am aware

BTW what's ::inject/sub?

[vimsical.re-frame.cofx.inject :as inject]

Ah, right.

so... this is the "fix":

(rf/reg-event-fx
   ::init-base-data
   [(rf/inject-cofx ::inject/sub [:state.core/timerange])]
   (fn-traced [{:keys [state.core/timerange]} _]
              {:state.core/callback
               (fn []
                 (reset! route-matrix/*state (assoc-in route-matrix/initial-state
                                                       [:filters :group-by]
                                                       (if (app-config-service/get-supports-routes?)
                                                         "Route" "Path")))
                 (reset! route-matrix/*on-redraw chart-utils/donut-chart-on-redraw)
                 (reset! route-matrix/*timerange timerange)
                 (route-matrix/init!)
                 (reset! route-matrix/*poll (async/poll! init!)))}))

👍

where :state.core/callback is reg'd as an fx handler which calls the function.

Not an ideal solution but definitely better than it was before. 🙂

yea, like i said "incremental improvements" here. the codebase is in a state of flux

while being modernized