v2.0.4

* feat(profileReducer): `PROFILE_UPDATE_SUCCESS` action updates profile state - prescottprue#395 -
 @serhiipalash
* fix(firestore): prevent issue where default profile creation would break (`createdAt` was undefined) - prescottprue#391 - @compojoom
* feat(profile): `profileFactory` support for firestore - prescottprue#391 - @compojoom
* fix(login): login-logout-login flow always correctly updates `state.firebase.profile` - prescottprue#401 - @evgeni-tsn
* fix(updateProfile): "no document to update" error no longer thrown when updating non-existant profile on Firestore (`useSet` boolean added to make this optional) - prescottprue#403

Author: prescottprue

docs/api/firebaseInstance.md

@@ -387,12 +387,21 @@ Returns **[Promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/
 
 ## updateProfile
 
-Update user profile
+Update user profile on Firebase Real Time Database or
+Firestore (if `useFirestoreForProfile: true` config passed to
+reactReduxFirebase). Real Time Database update uses `update` method
+internally while updating profile on Firestore uses `set` with
 
 **Parameters**
 
--   `profileUpdate`  
--   `profile` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Profile data to place in new profile
+-   `profileUpdate` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Profile data to place in new profile
+-   `options` **[Object](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Object)** Options object (used to change how profile
+    update occurs)
+    -   `options.useSet` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Use set with merge instead of
+        update. Setting to `false` uses update (can cause issue of profile document
+        does not exist). Note: Only used when updating profile on Firestore (optional, default `true`)
+    -   `options.merge` **[Boolean](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Boolean)** Whether or not to use merge when
+        setting profile. Note: Only used when updating profile on Firestore (optional, default `true`)
 
 Returns **[Promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise)** 
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "react-redux-firebase",
-  "version": "2.0.3",
+  "version": "2.0.4",
   "description": "Redux integration for Firebase. Comes with a Higher Order Components for use with React.",
   "main": "lib/index.js",
   "module": "es/index.js",

package.json

@@ -1,7 +1,6 @@
 import { isArray, isString, isFunction, forEach, omit } from 'lodash'
 import { actionTypes } from '../constants'
 import { populate } from '../helpers'
-import { stringToDate } from '../utils'
 import {
   getLoginMethodAndParams,
   updateProfileOnRTDB,
@@ -212,19 +211,25 @@ export const createUserProfile = (dispatch, firebase, userData, profile) => {
       .doc(userData.uid)
       .get()
       .then(profileSnap => {
-        // Convert to JSON format (to prevent issue of writing invalid type to Firestore)
-        const userDataObject = userData.toJSON ? userData.toJSON() : userData
-        // Remove unnessesary auth params (configurable) and preserve types of timestamps
-        const newProfile = {
-          ...omit(userDataObject, config.keysToRemoveFromAuth),
-          avatarUrl: userDataObject.photoURL, // match profile pattern used for RTDB
-          createdAt: stringToDate(userDataObject.createdAt),
-          lastLoginAt: stringToDate(userDataObject.lastLoginAt)
-        }
         // Return if config for updating profile is not enabled and profile exists
         if (!config.updateProfileOnLogin && profileSnap.exists) {
           return profileSnap.data()
         }
+
+        let newProfile = {}
+        // If the user did supply a profileFactory, we should use the result of it for the new Profile
+        if (isFunction(config.profileFactory)) {
+          newProfile = profile
+        } else {
+          // Convert to JSON format (to prevent issue of writing invalid type to Firestore)
+          const userDataObject = userData.toJSON ? userData.toJSON() : userData
+          // Remove unnecessary auth params (configurable) and preserve types of timestamps
+          newProfile = {
+            ...omit(userDataObject, config.keysToRemoveFromAuth),
+            avatarUrl: userDataObject.photoURL // match profile pattern used for RTDB
+          }
+        }
+
         // Create/Update the profile
         return profileSnap.ref
           .set(newProfile, { merge: true })
@@ -345,14 +350,14 @@ const handleAuthStateChange = (dispatch, firebase, authData) => {
       setupPresence(dispatch, firebase)
     }
 
-    watchUserProfile(dispatch, firebase)
-
     dispatch({
       type: actionTypes.LOGIN,
       auth: authData,
       preserve: config.preserveOnLogin
     })
 
+    watchUserProfile(dispatch, firebase)
+
     // Run onAuthStateChanged if it exists in config
     if (isFunction(config.onAuthStateChanged)) {
       config.onAuthStateChanged(authData, firebase, dispatch)

src/actions/auth.js

@@ -408,12 +408,22 @@ export const createFirebaseInstance = (firebase, configs, dispatch) => {
     authActions.verifyPasswordResetCode(dispatch, firebase, code)
 
   /**
-   * @description Update user profile
-   * @param {Object} profile - Profile data to place in new profile
+   * @description Update user profile on Firebase Real Time Database or
+   * Firestore (if `useFirestoreForProfile: true` config passed to
+   * reactReduxFirebase). Real Time Database update uses `update` method
+   * internally while updating profile on Firestore uses `set` with
+   * @param {Object} profileUpdate - Profile data to place in new profile
+   * @param {Object} options - Options object (used to change how profile
+   * update occurs)
+   * @param  {Boolean} [options.useSet=true] - Use set with merge instead of
+   * update. Setting to `false` uses update (can cause issue of profile document
+   * does not exist). Note: Only used when updating profile on Firestore
+   * @param  {Boolean} [options.merge=true] - Whether or not to use merge when
+   * setting profile. Note: Only used when updating profile on Firestore
    * @return {Promise}
    */
-  const updateProfile = profileUpdate =>
-    authActions.updateProfile(dispatch, firebase, profileUpdate)
+  const updateProfile = (profileUpdate, options) =>
+    authActions.updateProfile(dispatch, firebase, profileUpdate, options)
 
   /**
    * @description Update Auth Object

src/createFirebaseInstance.js

@@ -28,7 +28,8 @@ const {
   AUTH_LINK_SUCCESS,
   UNAUTHORIZED_ERROR,
   AUTH_UPDATE_SUCCESS,
-  AUTH_RELOAD_SUCCESS
+  AUTH_RELOAD_SUCCESS,
+  PROFILE_UPDATE_SUCCESS
 } = actionTypes
 
 /**
@@ -281,6 +282,8 @@ export const profileReducer = (
         isEmpty: false,
         isLoaded: true
       }
+    case PROFILE_UPDATE_SUCCESS:
+      return Object.assign({}, state, action.payload)
     case LOGIN:
       // Support keeping data when logging out
       if (action.preserve && action.preserve.profile) {

src/reducers.js

@@ -191,13 +191,31 @@ export const updateProfileOnRTDB = (firebase, profileUpdate) => {
 }
 
 /**
- * Update profile data on Firestore
+ * Update profile data on Firestore by calling set (with merge: true) on
+ * the profile.
  * @param  {Object} firebase - internal firebase object
  * @param  {Object} profileUpdate - Updates to profile object
+ * @param  {Object} options - Options object for configuring how profile
+ * update occurs
+ * @param  {Boolean} [options.useSet=true] - Use set with merge instead of
+ * update. Setting to `false` uses update (can cause issue of profile document
+ * does not exist).
+ * @param  {Boolean} [options.merge=true] - Whether or not to use merge when
+ * setting profile
  * @return {Promise} Resolves with results of profile get
  */
-export const updateProfileOnFirestore = (firebase, profileUpdate) => {
+export const updateProfileOnFirestore = (
+  firebase,
+  profileUpdate,
+  options = {}
+) => {
+  const { useSet = true, merge = true } = options
   const { firestore, _: { config, authUid } } = firebase
   const profileRef = firestore().doc(`${config.userProfile}/${authUid}`)
-  return profileRef.update(profileUpdate).then(() => profileRef.get())
+  // Use set with merge (to prevent "No document to update") unless otherwise
+  // specificed through options
+  const profileUpdatePromise = useSet
+    ? profileRef.set(profileUpdate, { merge })
+    : profileRef.update(profileUpdate)
+  return profileUpdatePromise.then(() => profileRef.get())
 }

src/utils/auth.js

@@ -269,6 +269,27 @@ describe('Helpers:', () => {
             exampleData.data[rootName].ABC.displayName
           )
         })
+
+        it('supports childParam', () => {
+          populates = [
+            {
+              child: 'collaborators',
+              root: rootName,
+              childParam: 'displayName'
+            }
+          ]
+          // Non matching collaborator
+          expect(
+            helpers.populate(exampleData, path, populates)
+          ).to.have.deep.property(`${valName}.collaborators.abc`, true)
+          // Matching collaborator
+          expect(
+            helpers.populate(exampleData, path, populates)
+          ).to.have.deep.property(
+            `${valName}.collaborators.ABC`,
+            exampleData.data[rootName].ABC.displayName
+          )
+        })
       })
 
       describe('config as function', () => {
@@ -354,7 +375,6 @@ describe('Helpers:', () => {
         )
       })
 
-      // Skipped since this is not currently supported
       it('from same root', () => {
         populates = [
           { child: 'owner', root: rootName },
@@ -408,4 +428,19 @@ describe('Helpers:', () => {
       expect(helpers.isEmpty([{}])).to.be.false
     })
   })
+
+  describe('fixPath', () => {
+    it('exists', () => {
+      expect(helpers).to.respondTo('fixPath')
+    })
+
+    it('returns original path if no fix is required', () => {
+      const originalPath = '/asdf'
+      expect(helpers.fixPath(originalPath)).to.equal(originalPath)
+    })
+
+    it('adds / to beginning of path', () => {
+      expect(helpers.fixPath('asdf')).to.equal('/asdf')
+    })
+  })
 })

test/unit/helpers.spec.js

@@ -527,6 +527,15 @@ describe('reducer', () => {
     })
   })
 
+  describe('PROFILE_UPDATE_SUCCESS action -', () => {
+    it('sets auth state to isLoaded: true, isEmpty: false', () => {
+      const payload = { some: 'value' }
+      action = { type: actionTypes.PROFILE_UPDATE_SUCCESS, payload }
+      const currentState = firebaseReducer({}, action)
+      expect(currentState).to.have.deep.property('profile.some', payload.some)
+    })
+  })
+
   describe('LOGIN action -', () => {
     it('sets auth state to isLoaded: true, isEmpty: false', () => {
       const auth = { some: 'value' }
@@ -552,6 +561,103 @@ describe('reducer', () => {
         true
       )
     })
+
+    describe('preserve parameter', () => {
+      describe('profile state is preserved when provided', () => {
+        it('an array of keys', () => {
+          const payload = { some: 'other' }
+          const initialState = { profile: { some: 'value' } }
+          action = {
+            type: actionTypes.LOGIN,
+            preserve: { profile: ['some'] },
+            payload
+          }
+          expect(firebaseReducer(initialState, action)).to.have.deep.property(
+            'profile.some',
+            'value'
+          )
+        })
+
+        it('a boolean (true)', () => {
+          const payload = { some: 'other' }
+          const initialState = { profile: { some: 'value' } }
+          action = {
+            type: actionTypes.LOGIN,
+            preserve: { profile: true },
+            payload
+          }
+          expect(firebaseReducer(initialState, action)).to.have.deep.property(
+            'profile.some',
+            'value'
+          )
+        })
+      })
+
+      describe('profile state is updated when is already exists and is provided', () => {
+        it('a boolean (true)', () => {
+          const payload = { some: 'other' }
+          const initialState = { profile: { some: 'value' } }
+          action = {
+            type: actionTypes.LOGIN,
+            preserve: { profile: true },
+            payload
+          }
+          expect(firebaseReducer(initialState, action)).to.have.deep.property(
+            'profile.some',
+            'value'
+          )
+        })
+      })
+
+      describe('auth state is preserved when provided', () => {
+        it('an array of keys', () => {
+          const payload = { some: 'other' }
+          const initialState = { auth: { some: 'value' } }
+          action = {
+            type: actionTypes.LOGIN,
+            preserve: { auth: ['some'] },
+            auth: payload
+          }
+          expect(firebaseReducer(initialState, action)).to.have.deep.property(
+            'auth.some',
+            'value'
+          )
+        })
+
+        it('a boolean (true)', () => {
+          const initialState = { auth: { some: 'value' } }
+          action = {
+            type: actionTypes.LOGIN,
+            preserve: { auth: true },
+            auth: {}
+          }
+          expect(firebaseReducer(initialState, action)).to.have.deep.property(
+            'auth.some',
+            'value'
+          )
+        })
+      })
+
+      describe('auth state is updated when is already exists and is provided', () => {
+        it('a boolean (true)', () => {
+          const payload = { some: 'other', another: 'thing' }
+          const initialState = { auth: { some: 'value' } }
+          action = {
+            type: actionTypes.LOGIN,
+            preserve: { auth: true },
+            auth: payload
+          }
+          expect(firebaseReducer(initialState, action)).to.have.deep.property(
+            'auth.some',
+            payload.some
+          )
+          expect(firebaseReducer(initialState, action)).to.have.deep.property(
+            'auth.another',
+            payload.another
+          )
+        })
+      })
+    })
   })
 
   describe('REMOVE action -', () => {