v0.3.1

* fix(query): multiple `where` or `orderBy` parameters - compojoom
* fix(orderedReducer): subcollection not updating `state.ordered` - #46
* fix(orderedReducer): multiple subcollections on same parent collection correctly merges doc data - #34
* fix(dataReducer): `setListeners` clears out the subcollection of a document - #49
* feat(orderedReducer): `mergeOrdered`, `mergeOrderedDocUpdates`, and `mergeOrderedCollectionUpdates` config options added to allow for enabling/disabling merging of ordered data within `orderedReducer`
* feat(README): FAQ section added to clarify common questions - #47
* feat(README): Config Options section added to explain config options and their default values

Author: prescottprue

README.md

@@ -31,7 +31,7 @@ Most likely, you'll want react bindings, for that you will need [react-redux-fir
 npm install --save react-redux-firebase
 ```
 
-[react-redux-firebase](https://github.com/prescottprue/react-redux-firebase) provides [`withFirestore`](http://docs.react-redux-firebase.com/history/v2.0.0/docs/api/withFirestore.html) and [`firestoreConnect`](http://docs.react-redux-firebase.com/history/v2.0.0/docs/api/withFirestore.html) higher order components, which handle automatically calling `redux-firestore` internally based on component's lifecycle (i.e. mounting/un-mounting)
+[react-redux-firebase](https://github.com/prescottprue/react-redux-firebase) provides [`withFirestore`](http://react-redux-firebase.com/docs/api/withFirestore.html) and [`firestoreConnect`](http://react-redux-firebase.com/docs/api/firestoreConnect.html) higher order components, which handle automatically calling `redux-firestore` internally based on component's lifecycle (i.e. mounting/un-mounting)
 
 ## Use
 
@@ -396,6 +396,61 @@ const enhance = compose(
 export default enhance(SomeComponent)
 ```
 
+## Config Options
+
+#### enableLogging
+Default: `false`
+
+Whether or not to enable Firebase client logging.
+
+#### logListenerError
+Default: `true`
+
+Whether or not to use `console.error` to log listener error objects. Errors from listeners are helpful to developers on multiple occasions including when index needs to be added.
+
+#### enhancerNamespace
+Default: `'firestore'`
+
+Namespace under which enhancer places internal instance on redux store (i.e. `store.firestore`).
+
+#### allowMultipleListeners
+Default: `false`
+
+Whether or not to allow multiple listeners to be attached for the same query. If a function is passed the arguments it receives are `listenerToAttach`, `currentListeners`, and the function should return a boolean.
+
+#### preserveOnDelete
+Default: `null`
+
+Values to preserve from state when DELETE_SUCCESS action is dispatched. Note that this will not prevent the LISTENER_RESPONSE action from removing items from state.ordered if you have a listener attached.
+
+#### preserveOnListenerError
+Default: `null`
+
+Values to preserve from state when LISTENER_ERROR action is dispatched.
+
+#### onAttemptCollectionDelete
+Default: `null`
+
+Arguments:`(queryOption, dispatch, firebase)`
+
+Function run when attempting to delete a collection. If not provided (default) delete promise will be rejected with "Only documents can be deleted" unless. This is due to the fact that Collections can not be deleted from a client, it should instead be handled within a cloud function (which can be called by providing a promise to `onAttemptCollectionDelete` that calls the cloud function).
+
+#### mergeOrdered
+Default: `true`
+
+Whether or not to merge data within `orderedReducer`.
+
+#### mergeOrderedDocUpdate
+Default: `true`
+
+Whether or not to merge data from document listener updates within `orderedReducer`.
+
+
+#### mergeOrderedCollectionUpdates
+Default: `true`
+
+Whether or not to merge data from collection listener updates within `orderedReducer`.
+
 <!-- #### Middleware
 
 `redux-firestore`'s enhancer offers a new middleware setup that was not offered in `react-redux-firebase` (but will eventually make it `redux-firebase`)
@@ -443,6 +498,30 @@ Note: In an effort to keep things simple, the wording from this explanation was
 ## Applications Using This
 * [fireadmin.io](http://fireadmin.io) - Firebase Instance Management Tool (source [available here](https://github.com/prescottprue/fireadmin))
 
+## FAQ
+1. How do I update a document within a subcollection?
+
+    Provide `subcollections` config the same way you do while querying:
+
+    ```js
+    props.firestore.update(
+      {
+        collection: 'cities',
+        doc: 'SF',
+        subcollections: [{ collection: 'counties', doc: 'San Mateo' }],
+      },
+      { some: 'changes' }
+    );
+    ```
+
+1. How do I get auth state in redux?
+
+    You will most likely want to use [`react-redux-firebase`](https://github.com/prescottprue/react-redux-firebase) or another redux/firebase connector. For more information please visit the [complementary package section](#complementary-package).
+
+1. Are there Higher Order Components for use with React?
+
+    [`react-redux-firebase`](https://github.com/prescottprue/react-redux-firebase) contains `firebaseConnect`, `firestoreConnect`, `withFirebase` and `withFirestore` HOCs. For more information please visit the [complementary package section](#complementary-package).
+
 ## Roadmap
 
 * Automatic support for documents that have a parameter and a subcollection with the same name (currently requires `storeAs`)

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "redux-firestore",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Redux bindings for Firestore.",
   "main": "lib/index.js",
   "module": "es/index.js",

package.json

@@ -71,6 +71,12 @@ export function set(firebase, dispatch, queryOption, ...args) {
 export function get(firebase, dispatch, queryOption) {
   const meta = getQueryConfig(queryOption);
   // Wrap get call in dispatch calls
+  const {
+    mergeOrdered,
+    mergeOrderedDocUpdates,
+    mergeOrderedCollectionUpdates,
+  } =
+    firebase._.config || {};
   return wrapInDispatch(dispatch, {
     ref: firestoreRef(firebase, dispatch, meta),
     method: 'get',
@@ -83,6 +89,10 @@ export function get(firebase, dispatch, queryOption) {
           data: dataByIdSnapshot(snap),
           ordered: orderedFromSnap(snap),
         }),
+        merge: {
+          docs: mergeOrdered && mergeOrderedDocUpdates,
+          collections: mergeOrdered && mergeOrderedCollectionUpdates,
+        },
       },
       actionTypes.GET_FAILURE,
     ],
@@ -167,6 +177,12 @@ export function deleteRef(firebase, dispatch, queryOption) {
  */
 export function setListener(firebase, dispatch, queryOpts, successCb, errorCb) {
   const meta = getQueryConfig(queryOpts);
+  const {
+    mergeOrdered,
+    mergeOrderedDocUpdates,
+    mergeOrderedCollectionUpdates,
+  } =
+    firebase._.config || {};
   // Create listener
   const unsubscribe = firestoreRef(firebase, dispatch, meta).onSnapshot(
     docData => {
@@ -177,21 +193,29 @@ export function setListener(firebase, dispatch, queryOpts, successCb, errorCb) {
           data: dataByIdSnapshot(docData),
           ordered: orderedFromSnap(docData),
         },
+        merge: {
+          docs: mergeOrdered && mergeOrderedDocUpdates,
+          collections: mergeOrdered && mergeOrderedCollectionUpdates,
+        },
       });
       // Invoke success callback if it exists
       if (successCb) successCb(docData);
     },
     err => {
       // TODO: Look into whether listener is automatically removed in all cases
-      // TODO: Provide a setting that allows for silencing of console error
-      const { config } = firebase._;
       // Log error handling the case of it not existing
-      if (config.logListenerError) invoke(console, 'error', err);
+      const { logListenerError, preserveOnListenerError } =
+        firebase._.config || {};
+      if (logListenerError) invoke(console, 'error', err);
       dispatch({
         type: actionTypes.LISTENER_ERROR,
         meta,
         payload: err,
-        preserve: config.preserveOnListenerError,
+        merge: {
+          docs: mergeOrdered && mergeOrderedDocUpdates,
+          collections: mergeOrdered && mergeOrderedCollectionUpdates,
+        },
+        preserve: preserveOnListenerError,
       });
       // Invoke error callback if it exists
       if (errorCb) errorCb(err);

src/actions/firestore.js

@@ -91,7 +91,7 @@ export const actionTypes = {
  * state.ordered if you have a listener attached.
  * @property {Object} preserveOnListenerError - `null` Values to
  * preserve from state when LISTENER_ERROR action is dispatched.
- * @property {Boolean} enhancerNamespace - `'firestore'` Namespace underwhich
+ * @property {Boolean} enhancerNamespace - `'firestore'` Namespace under which
  * enhancer places internal instance on redux store (i.e. store.firestore).
  * @property {Boolean|Function} allowMultipleListeners - `null` Whether or not
  * to allow multiple listeners to be attached for the same query. If a function
@@ -115,6 +115,9 @@ export const defaultConfig = {
   preserveOnDelete: null,
   preserveOnListenerError: null,
   onAttemptCollectionDelete: null,
+  mergeOrdered: true,
+  mergeOrderedDocUpdates: true,
+  mergeOrderedCollectionUpdates: true,
 };
 
 export default {

src/constants.js

@@ -1,5 +1,5 @@
 import { get } from 'lodash';
-import { setWith, assign } from 'lodash/fp';
+import { setWith, merge } from 'lodash/fp';
 import { actionTypes } from '../constants';
 import { pathFromMeta, preserveValuesFromState } from '../utils/reducers';
 
@@ -50,7 +50,7 @@ export default function dataReducer(state = {}, action) {
         return setWith(Object, pathFromMeta(meta), data, state);
       }
       // Otherwise merge with existing data
-      const mergedData = assign(previousData, data);
+      const mergedData = merge(previousData, data);
       // Set data to state (with merge) immutabily (lodash/fp's setWith creates copy)
       return setWith(Object, pathFromMeta(meta), mergedData, state);
     case DELETE_SUCCESS:

src/reducers/dataReducer.js

@@ -1,4 +1,5 @@
-import { first } from 'lodash';
+import { first, size, get, unionBy } from 'lodash';
+import { merge as mergeObjects } from 'lodash/fp';
 import { actionTypes } from '../constants';
 import { updateItemInArray, preserveValuesFromState } from '../utils/reducers';
 
@@ -20,15 +21,14 @@ function updateDocInOrdered(state, action) {
   const itemToAdd = first(action.payload.ordered);
   const subcollection = first(action.meta.subcollections);
   const storeUnderKey = action.meta.storeAs || action.meta.collection;
-  // TODO: Make this recursive so that is supports multiple subcollections
   return {
     ...state,
     [storeUnderKey]: updateItemInArray(
       state[storeUnderKey] || [],
       action.meta.doc,
       item =>
-        Object.assign(
-          {},
+        // Use merge to preserve existing subcollections
+        mergeObjects(
           item,
           subcollection
             ? { [subcollection.collection]: action.payload.ordered }
@@ -65,13 +65,25 @@ export default function orderedReducer(state = {}, action) {
       if (!action.payload || !action.payload.ordered) {
         return state;
       }
-      // TODO: Support merging
-      if (action.meta.doc) {
+      const { meta, merge = { doc: true, collection: true } } = action;
+      const parentPath = meta.storeAs || meta.collection;
+      // Handle doc update (update item in array instead of whole array)
+      if (meta.doc && merge.doc && size(get(state, parentPath))) {
+        // Merge if data already exists
+        // Merge with existing ordered array if collection merge enabled
         return updateDocInOrdered(state, action);
       }
+      const parentData = get(state, parentPath);
+      // Merge with existing ordered array if collection merge enabled
+      if (merge.collection && size(parentData)) {
+        return {
+          ...state,
+          [parentPath]: unionBy(parentData, action.payload.ordered, 'id'),
+        };
+      }
       return {
         ...state,
-        [action.meta.storeAs || action.meta.collection]: action.payload.ordered,
+        [parentPath]: action.payload.ordered,
       };
     case CLEAR_DATA:
       // support keeping data when logging out - #125

src/reducers/orderedReducer.js

@@ -47,6 +47,10 @@ export function wrapInDispatch(
       if (successIsObject && successType.preserve) {
         actionObj.preserve = successType.preserve;
       }
+      // Attach merge to action if it is passed
+      if (successIsObject && successType.merge) {
+        actionObj.merge = successType.merge;
+      }
       dispatch(actionObj);
       return result;
     })

src/utils/actions.js

@@ -1,4 +1,13 @@
-import { isObject, isString, isArray, size, trim, forEach, has } from 'lodash';
+import {
+  isObject,
+  isString,
+  isArray,
+  size,
+  trim,
+  forEach,
+  has,
+  isFunction,
+} from 'lodash';
 import { actionTypes } from '../constants';
 
 /**
@@ -15,7 +24,8 @@ function addWhereToRef(ref, where) {
   if (isString(where[0])) {
     return where.length > 1 ? ref.where(...where) : ref.where(where[0]);
   }
-  return where.reduce((acc, whereArgs) => addWhereToRef(ref, whereArgs), ref);
+
+  return where.reduce((acc, whereArgs) => addWhereToRef(acc, whereArgs), ref);
 }
 
 /**
@@ -37,16 +47,33 @@ function addOrderByToRef(ref, orderBy) {
     return ref.orderBy(...orderBy);
   }
   return orderBy.reduce(
-    (acc, orderByArgs) => addOrderByToRef(ref, orderByArgs),
+    (acc, orderByArgs) => addOrderByToRef(acc, orderByArgs),
     ref,
   );
 }
 
-/* eslint-disable no-param-reassign */
+/**
+ * Call methods on ref object for provided subcollection list (from queryConfig
+ * object)
+ * @param  {firebase.firestore.CollectionReference} ref - reference on which
+ * to call methods to apply queryConfig
+ * @param  {Array} subcollectionList - List of subcollection settings from
+ * queryConfig object
+ * @return {firebase.firestore.Query} Query object referencing path within
+ * firestore
+ */
 function handleSubcollections(ref, subcollectionList) {
   if (subcollectionList) {
     forEach(subcollectionList, subcollection => {
+      /* eslint-disable no-param-reassign */
       if (subcollection.collection) {
+        if (!isFunction(ref.collection)) {
+          throw new Error(
+            `Collection can only be run on a document. Check that query config for subcollection: "${
+              subcollection.collection
+            }" contains a doc parameter.`,
+          );
+        }
         ref = ref.collection(subcollection.collection);
       }
       if (subcollection.doc) ref = ref.doc(subcollection.doc);
@@ -61,11 +88,13 @@ function handleSubcollections(ref, subcollectionList) {
       }
       if (subcollection.endAt) ref = ref.endAt(subcollection.endAt);
       if (subcollection.endBefore) ref = ref.endBefore(subcollection.endBefore);
-      handleSubcollections(subcollection.subcollections);
+      /* eslint-enable */
+
+      handleSubcollections(ref, subcollection.subcollections);
     });
   }
+  return ref;
 }
-/* eslint-enable */
 
 /**
  * Create a Cloud Firestore reference for a collection or document
@@ -96,7 +125,7 @@ export function firestoreRef(firebase, dispatch, meta) {
   let ref = firebase.firestore().collection(collection);
   // TODO: Compare other ways of building ref
   if (doc) ref = ref.doc(doc);
-  handleSubcollections(ref, subcollections);
+  ref = handleSubcollections(ref, subcollections);
   if (where) ref = addWhereToRef(ref, where);
   if (orderBy) ref = addOrderByToRef(ref, orderBy);
   if (limit) ref = ref.limit(limit);