Merge pull request #14 from jerelmiller/initial-state

Initial state

Author: jerelmiller

README.md

@@ -25,8 +25,8 @@ yarn add redux-simple-auth
 
 ### Setup
 
-This library ships with middleware and a reducer. You will need to do the
-following:
+This library ships with middleware, a reducer, and an optional store enhancer.
+You will need to do the following:
 
 ##### Apply the middleware
 
@@ -60,6 +60,32 @@ export default combineReducers({
 })
 ```
 
+##### Optionally add the store enhancer
+
+In order to use the enhancer, you will need to provide it with the storage used.
+If you do not need a custom storage adapter, you may import the default storage.
+
+```javascript
+// ...
+import {
+  createAuthMiddleware,
+  getInitialAuthState,
+  storage // or custom storage creator
+} from 'redux-simple-auth'
+import { createStore, compose, applyMiddleware } from 'redux'
+
+const authMiddleware = createAuthMiddleware(/*...*/)
+
+const store = createStore(
+  rootReducer,
+  /* initialState, */
+  compose(
+    applyMiddleware(authMiddleware),
+    getInitialAuthState({ storage })
+  )
+)
+```
+
 ## How does it work?
 
 Redux Simple Auth aims to make authentication and authorization within your
@@ -429,6 +455,21 @@ const authMiddleware = createAuthMiddleware({
   needed for authorization. It accepts a header name for its first argument and
   that header's value as its second argument.
 
+### Store Enhancer
+
+There may be cases where you may want the redux store initialized with the
+sesion data from the storage device. The store enhancer does just that. On store
+initialization, it will ask the storage device for the session data.
+
+```javascript
+const enhancer = getInitialAuthState({ storage })
+```
+
+**Options:**
+
+* `storage` (_object_): The storage mechanism used to store the session. **This
+  must** be the same storage device configured with the middleware.
+
 ## Actions
 
 Redux Simple Auth ships with several actions to aide in authentication for your
@@ -498,6 +539,49 @@ import { invalidateSession } from 'redux-simple-auth'
 store.dispatch(invalidateSession())
 ```
 
+## Selectors
+
+To aid in selecting specific session state, redux simple auth ships with a few
+selectors for your convenience. All selectors take the store `state` as an
+argument. Note this is the entire store state, not just the session state.
+
+### `getSessionData(state)`
+
+(_object_) Returns the session data set when user was authenticated. If not yet
+authenticated, this returns an empty object.
+
+```javascript
+import { getSessionData } from 'redux-simple-auth'
+
+const mapStateToProps = state => ({
+  session: getSessionData(state)
+})
+```
+
+### `getIsAuthenticated(state)`
+
+(_boolean_) Returns whether the user is authenticated.
+
+```javascript
+import { getIsAuthenticated } from 'redux-simple-auth'
+
+const mapStateToProps = state => ({
+  isAuthenticated: getIsAuthenticated(state)
+})
+```
+
+### `getAuthenticator(state)`
+
+(_string_) Returns the `authenticator` used when authenticating. If not yet
+authenticated, this is set to `null`.
+
+```javascript
+import { getAuthenticator } from 'redux-simple-auth'
+
+const mapStateToProps = state => ({
+  authenticator: getAuthenticator(state)
+})
+```
 
 ## License
 

src/actionTypes.js

@@ -4,6 +4,7 @@ export const AUTHENTICATE = `${prefix}/AUTHENTICATE`
 export const AUTHENTICATE_FAILED = `${prefix}/AUTHENTICATE_FAILED`
 export const AUTHENTICATE_SUCCEEDED = `${prefix}/AUTHENTICATE_SUCCEEDED`
 export const FETCH = `${prefix}/FETCH`
+export const INITIALIZE = `${prefix}/INITIALIZE`
 export const INVALIDATE_SESSION = `${prefix}/INVALIDATE_SESSION`
 export const RESTORE = `${prefix}/RESTORE`
 export const RESTORE_FAILED = `${prefix}/RESTORE_FAILED`

src/actions.js

@@ -3,6 +3,7 @@ import {
   AUTHENTICATE_FAILED,
   AUTHENTICATE_SUCCEEDED,
   FETCH,
+  INITIALIZE,
   INVALIDATE_SESSION,
   RESTORE,
   RESTORE_FAILED
@@ -41,3 +42,8 @@ export const restore = payload => ({
 export const restoreFailed = () => ({
   type: RESTORE_FAILED
 })
+
+export const initialize = payload => ({
+  type: INITIALIZE,
+  payload
+})

src/enhancer.js

@@ -0,0 +1,27 @@
+import isPlainObject from 'lodash.isplainobject'
+import { initialize } from './actions'
+import reducer from './reducer'
+
+const validateStorage = storage => {
+  if (!isPlainObject(storage) || storage.restore == null) {
+    throw new Error(
+      'Expected `storage` to be a valid storage. You either forgot to ' +
+        'include it or you passed an invalid storage object'
+    )
+  }
+}
+
+const enhancer = ({ storage } = {}) => {
+  validateStorage(storage)
+
+  return createStore => (rootReducer, preloadedState, enhancer) => {
+    const initialState = {
+      session: reducer(null, initialize(storage.restore())),
+      ...preloadedState
+    }
+
+    return createStore(rootReducer, initialState, enhancer)
+  }
+}
+
+export default enhancer

src/index.js

@@ -5,3 +5,10 @@ export { authenticate, fetch, invalidateSession } from './actions'
 export { default as createAdaptiveStore } from './storage/adaptive'
 export { default as createLocalStorageStore } from './storage/localStorage'
 export { default as createCookieStore } from './storage/cookie'
+export { default as getInitialAuthState } from './enhancer'
+export { default as storage } from './storage/default'
+export {
+  getSessionData,
+  getIsAuthenticated,
+  getAuthenticator
+} from './selectors'

src/middleware.js

@@ -1,4 +1,4 @@
-import createAdaptiveStore from './storage/adaptive'
+import defaultStorage from './storage/default'
 import isPlainObject from 'lodash.isplainobject'
 import { AUTHENTICATE, FETCH } from './actionTypes'
 import {
@@ -52,7 +52,7 @@ export default (config = {}) => {
     authenticator,
     authenticators,
     authorize,
-    storage = createAdaptiveStore()
+    storage = defaultStorage
   } = config
 
   const findAuthenticator = authenticator

src/reducer.js

@@ -1,6 +1,7 @@
 import {
   AUTHENTICATE_FAILED,
   AUTHENTICATE_SUCCEEDED,
+  INITIALIZE,
   INVALIDATE_SESSION,
   RESTORE,
   RESTORE_FAILED
@@ -14,6 +15,14 @@ const initialState = {
 
 const reducer = (state = initialState, action) => {
   switch (action.type) {
+    case INITIALIZE:
+      const { authenticated: { authenticator, ...data } = {} } = action.payload
+
+      return {
+        authenticator,
+        data,
+        isAuthenticated: false
+      }
     case AUTHENTICATE_SUCCEEDED:
       return {
         ...state,
@@ -46,3 +55,7 @@ const reducer = (state = initialState, action) => {
 }
 
 export default reducer
+
+export const getData = state => state.data
+export const getIsAuthenticated = state => state.isAuthenticated
+export const getAuthenticator = state => state.authenticator

src/selectors.js

@@ -0,0 +1,9 @@
+import * as fromSession from './reducer'
+
+export const getSessionData = state => fromSession.getData(state.session)
+
+export const getIsAuthenticated = state =>
+  fromSession.getIsAuthenticated(state.session)
+
+export const getAuthenticator = state =>
+  fromSession.getAuthenticator(state.session)

src/storage/default.js

@@ -0,0 +1,3 @@
+import createAdaptiveStore from './adaptive'
+
+export default createAdaptiveStore()

test/enhancer.spec.js

@@ -0,0 +1,47 @@
+import enhancer from '../src/enhancer'
+import createMockStorage from './utils/testStorage'
+
+describe('enhancer', () => {
+  it('returns enhanced store with initial storage state', () => {
+    const enhancedCreateStore = enhancer({ storage: createMockStorage() })
+
+    expect(enhancedCreateStore).toBeInstanceOf(Function)
+  })
+
+  it('sets up store with initial storage state', () => {
+    const mock = jest.fn()
+    const dummyData = {
+      authenticated: {
+        authenticator: 'dummy',
+        token: 'abcde'
+      }
+    }
+    const storage = createMockStorage(dummyData)
+    const createStore = jest.fn()
+
+    const enhancedCreateStore = enhancer({ storage })(createStore)(
+      mock,
+      null,
+      mock
+    )
+
+    expect(createStore).toHaveBeenCalledWith(
+      mock,
+      {
+        session: {
+          authenticator: 'dummy',
+          data: { token: 'abcde' },
+          isAuthenticated: false
+        }
+      },
+      mock
+    )
+  })
+
+  it('throws when no storage given', () => {
+    expect(() => enhancer({ storage: null })).toThrow(
+      'Expected `storage` to be a valid storage. You either forgot to ' +
+        'include it or you passed an invalid storage object'
+    )
+  })
+})