Shameless plug 😅 check out conduit https://github.com/jacekschae/conduit most events manage call to server and based on success or failure update app state

People on here (including me) have asked for some real examples of re-frame apps that are open source to take a look at. I just found this one https://github.com/district0x/ethlance

I believe that district0x has perhaps 1 or 2 more in their github org too

it’s quite a large example though

@jacek.schae Nice. This this conduit impl looks interesting to read through.

@mikerod it's heavily inspired by todomvc example when it comes to comments/structure. There is also API spec that could help you understand what we get from the server https://github.com/gothinkster/realworld/tree/master/api

@jaceklach thanks. Yeah I’m familiar with this server spec. Inspiration from the commenting from the todo is a good choice too!

https://github.com/bbatsov/clojure-style-guide#documentation This is the convention to document clojure functions. Is there an idiomatic way to do the same for re-frame handlers?

https://github.com/Day8/re-com/blob/master/src/re_com/misc.cljs#L77 Why is there a note saying avoid nil?

@p-himik perhaps you can’t have :value = nil on an :input ?

@mikerod I think you can - I use it all the time.

https://react-cn.github.io/react/tips/controlled-input-null-value.html

maybe that? I don’t know though, just throwing some thoughts out there 😛

I thought I had an issue with setting a :value nil before on an :input, but I don’t remember anything specific

Ah, thanks! That link makes sense.

is there a reason that (rf/reg-sub ::state ::state) will, when subscribed to, return [::state] instead of the result of (::state db) ? I thought I’d take a nice shortcut over (fn [db] (::state db)) but it seems re-frame is being clever

hm, perhaps it’s mistaking what I’m doing for the :<- syntax sugar

I get the same behavior with (rf/reg-sub ::state (partial ::state)) as well

it has to be (rf/reg-sub ::state (fn [db] (::state db))

@mattly I think it’s because your db doesn’t have that key?

re-frame is really passing 2 args

(fn [db qvec] (::state db))

so when you shorten, I think you end up doing (::state db qvec)

So db has no entry for ::state key and it is returning the qvec as the “return when missing” value to calling the keyword as a fn

the qvec for your subscription is just [::state] since you aren’t passing query args and the first item in the query vector is the name of the subscription itself - ::state here

ah

yeah you’re right I forgot about the extra arg since js doesn’t enforce arity

(rf/reg-sub ::state (comp ::state (partial apply first))) works as well but I may as well use the anon fn at that point

thanks

> but I may as well use the anon fn at that point Yep, hah

No problem

@mattly after writing long-hand subscription and event handlers for a while, I ended up just making a few macros

There is also a lib or 2 that define some.

I’ve used a generalized :get-in subscription in the past

you could do that too, but that has some caveats on the reactivity of the subscription

but that encouraged some bad patterns

yeah

(e.g. everything watching the top db level for changes, etc)

a macro you can make expand out to something that isn’t problematic

then again, I know it is nice to avoid macros at times

I didn’t write a macro for a get-in sort of thing. I ended up feeling the need for them more for subscriptions that have query vec arguments passed in that also are have other subscriptions as signals

that can get a bit messy and verbose

a pattern I’ve been inching towards is for each namespace storing their stuff inside ::data and then helpers around subscribing to that

btw, I’m giving a talk on re-frame at our local clojure group on the 4th of Jan: https://www.meetup.com/clojure-pdx/events/245270782/

This sort of thing is what I meant:

(rf/reg-sub
:mine/mine
(fn [[_ x y]]
  (rf/subscribe [:mine/something x y]))
 (fn [something [_ x y]] (do-stuff something x y))

ah yeah

I guess you can use rf/reg-sub-raw to cut down boilerplate on those too, but I still wanted to macro away the boilerplate over reg-sub-raw in this case 😛

I’ve tried to resist writing my own little dsl around creating subscriptions & event handlers since that’s never worked out well for me in other areas

> btw, I’m giving a talk on re-frame at our local clojure group on the 4th of Jan Nice. I’m not in the Portland area. But cool you are giving a talk on re-frame . I fairly recently switched over an app that was only reagent to re-frame. I’m also in the progress of a brand new app that is starting with re-frame. I’ve definitely become a fan of re-frame now.

> I’ve tried to resist writing my own little dsl So did I, but then I gave in… Perhaps bad choice. Remains to be seen. 😛

Hi everyone. can you guys help me refactor my app a bit please? So basically I have a little application that needs to poll a few different APIs every x (let’s say 4) seconds. So I created this tick event

(defn- get-events-to-run [section]
  (when-not (:waiting-for-data section)
    (:ticker-event section)))

(re-frame/reg-event-db
 ::initialize-db
 (fn  [_ _]
   db/default-db))

(re-frame/reg-event-fx
 ::initialize
 (fn [cofx _]
   {:dispatch-n [[::initialize-db] [::tick]]}))

(re-frame/reg-event-fx
 ::tick
 (fn [cofx _]
   (let [events (->> (map (:db cofx) [:accounts :balances :orders])
                     (map get-events-to-run)
                     (remove nil?)
                     (into []))]
     {:dispatch-n (if (empty? events) [] [events])
      :dispatch-later [{:ms 4000
                        :dispatch [::tick]}]})))

A bit late to the party but here's another re-frame open source app: https://github.com/lambdaclass/holiday_ping (re-frame code is under directory priv/ui)