This snippet enables to iterate over a Firebase reference in a non-blocking way. If you need to iterate over a large reference, a child_added query may block your Firebase as it will query the whole data before iteration. With this snippet, children are retrieved one by one, making it slower / safer.

throttledChildAdded.js

module.exports = function throttledChildAdded(ref, callback, onError, sortChildKey = null /* uses `key` if null */) {

  const state = { stopped: false }
  let listener = null

  throttledChildAdded({ state, endReached: lastSeen => { listener = listenForNewChildren({ startAfter: lastSeen }) } })

  return () => {
    state.stopped = true
    if (listener) ref.off('child_added', listener)
  }

  function throttledChildAdded({ state, endReached, start = null }) {
    if (state.stopped) return

    withStart(ref, start).limitToFirst(2).once('value',
      snap => {
        const atLast = snap.numChildren() < 2

        if (!state.stopped && atLast) endReached(start)

        snap.forEach(snap => {
          const sortValue = getSortValue(snap)
          if (sortValue === start || state.stopped) return

          callback(snap)

          if (!atLast) setTimeout(() => throttledChildAdded({ state, endReached, start: sortValue }), 0)

          return true // stop iteration
        })
      },
      onError
    )
  }

  function listenForNewChildren({ startAfter }) {
    return withStart(ref, startAfter)
      .on('child_added',
        snap => {
          const sortValue = getSortValue(snap)
          if (sortValue === startAfter) return
          callback(snap)
        },
        onError
      )
  }

  function getSortValue(snap) {
    return sortChildKey ? snap.child(sortChildKey).val() : snap.key
  }

  function withStart(ref, start = null) {
    const query = sortChildKey ? ref.orderByChild(sortChildKey) : ref.orderByKey()
    return start ? query.startAt(start) : query
  }
}

This is a modified version based on the same principle. This however is implemented using a different design (a simple function, I don't like this).

The differences:

1. It returns a function that can be called to stop
2. Once the existing items have been retrieved, it switches to the regular ref.on('child_added', ...)

Last version also allows to use other keys than key for sorting