Merge pull request #1 from bernabe9/master

Update

Author: umpc

README.md

@@ -1,11 +1,11 @@
 # Redux React Session
 
 [![NPM version](https://img.shields.io/npm/v/redux-react-session.svg?style=flat)](https://npmjs.org/package/redux-react-session)
-[![Build status: Linux](https://img.shields.io/travis/bernabe9/redux-react-session.svg?style=flat)](https://travis-ci.org/bernabe9/redux-react-session)
+[![Build status: Linux](https://travis-ci.org/bernabe9/redux-react-session.svg?branch=master)](https://travis-ci.org/bernabe9/redux-react-session)
 [![Dependency Status](https://img.shields.io/david/bernabe9/redux-react-session.svg)](https://david-dm.org/bernabe9/redux-react-session)
 [![Coverage Status](https://img.shields.io/coveralls/bernabe9/redux-react-session.svg)](https://coveralls.io/github/bernabe9/redux-react-session?branch=master)
 
-Keep your session sync with localStorage and Redux :key:
+Keep your session sync with your local storage and Redux :key:
 
 Redux React Session provides an API that allows to manage sessions through the app, with authorization function for [react-router](https://github.com/ReactTraining/react-router) and a persisted session.
 
@@ -43,7 +43,7 @@ sessionService.initSessionService(store);
 ## Examples
 The examples simulates a simple login/logout that sends requests to a server.
 
-### Run the example
+### Run the example for react router v3
 1. **get into the folder**:`cd examples/example`
 2. **install dependencies**: `npm install`
 3. **run the example**: `npm start`
@@ -56,9 +56,13 @@ The examples simulates a simple login/logout that sends requests to a server.
 
 ## API
 
-### initSessionService(store, options)
+### initSessionService(store, options) : Promise
 Initialize an instance of the session service.
 
+The promise will be resolved if the session is valid, and will be rejected if there is no data in the storage.
+
+Once the promise is resolved or rejected the flag `checked` in the redux store will change from `false` to `true`. This allows to check into any component if the session was already checked and it's valid.
+
 Options:
 - refreshOnCheckAuth(**default**: false): Refresh Redux store in the `checkAuth` function
 - redirectPath(**default**: `"login"`): Path used when a session is rejected or doesn't exist
@@ -67,11 +71,15 @@ Options:
 Example:
 ```javascript
 const options = { refreshOnCheckAuth: true, redirectPath: '/home', driver: 'COOKIES' };
-sessionService.initSessionService(store, options);
+sessionService.initSessionService(store, options)
+  .then(() => console.log('Redux React Session is ready and a session was refreshed from your storage'))
+  .catch(() => console.log('Redux React Session is ready and there is no session in your storage'));
 ```
 
 ### refreshFromLocalStorage
-Force to refresh the Redux Store from the localStorage.
+Force to refresh the Redux Store from the local storage.
+
+The promise will be resolved if the session is valid, and will be rejected if there is no data in the storage.
 
 Note: this function is called once the session service is initialized
 

__mocks__/localforage.js

@@ -4,10 +4,62 @@ import { USER_SESSION, USER_DATA } from '../src/constants';
 
 const localforage = jest.genMockFromModule('localforage');
 
+function createInstance() {
+  return new LocalForage();
+}
+
 let throwError = false;
 let user = undefined;
 let session = undefined;
 
+class LocalForage {
+  constructor() {}
+
+  setItem(item, data) {
+    return new Promise((resolve, reject) => {
+      if (item === USER_SESSION) {
+        session = data;
+      } else if (item === USER_DATA) {
+        user = data;
+      }
+      throwError ? reject() : resolve(data);
+    });
+  }
+
+  getItem(item) {
+    return new Promise((resolve) => {
+      if (item === USER_SESSION) {
+        return resolve(session);
+      } else if (item === USER_DATA) {
+        return resolve(user);
+      }
+    });
+  }
+
+  removeItem(item) {
+    return new Promise((resolve) => {
+      if (item === USER_SESSION) {
+        session = undefined;
+      } else if (item === USER_DATA) {
+        user = undefined;
+      }
+      resolve();
+    });
+  }
+
+  __setError(error) {
+    throwError = error;
+  }
+
+  __setUser(item) {
+    user = item;
+  }
+
+  __setSession(item) {
+    session = item;
+  }
+}
+
 function __setError(error) {
   throwError = error;
 }
@@ -20,41 +72,7 @@ function __setSession(item) {
   session = item;
 }
 
-function setItem(item, data) {
-  return new Promise((resolve, reject) => {
-    if (item === USER_SESSION) {
-      session = data;
-    } else if (item === USER_DATA) {
-      user = data;
-    }
-    throwError ? reject() : resolve(data);
-  });
-}
-
-function getItem(item) {
-  return new Promise((resolve) => {
-    if (item === USER_SESSION) {
-      return resolve(session);
-    } else if (item === USER_DATA) {
-      return resolve(user);
-    }
-  });
-}
-
-function removeItem(item) {
-  return new Promise((resolve) => {
-    if (item === USER_SESSION) {
-      session = undefined;
-    } else if (item === USER_DATA) {
-      user = undefined;
-    }
-    resolve();
-  });
-}
-
-localforage.setItem = setItem;
-localforage.getItem = getItem;
-localforage.removeItem = removeItem;
+localforage.createInstance = createInstance;
 localforage.__setError = __setError;
 localforage.__setUser = __setUser;
 localforage.__setSession = __setSession;

_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-cayman

package.json

@@ -1,6 +1,6 @@
 {
   "name": "redux-react-session",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -53,7 +53,7 @@
   "dependencies": {
     "immutable": "^3.8.1",
     "js-cookie": "2.1.4",
-    "localforage": "1.5.0"
+    "localforage": "1.5.5"
   },
   "peerDependencies": {
     "react": "^0.14.0 || ^15.0.0",

src/__tests__/index.spec.js

@@ -3,24 +3,23 @@
 import { sessionService, sessionReducer } from '../index';
 import { initialState } from '../reducer';
 import { createStore } from 'redux';
-import { __setError, __setSession, __setUser } from 'localforage';
 import * as Cookies from "js-cookie";
 
 jest.mock('localforage');
 
+const localforage = require('localforage');
+const { __setError, __setSession, __setUser } = localforage;
+
 describe('API functions', () => {
   let store;
   const user = { email: 'test@test.com', firstName: 'test', lastName: 'test' };
   const session = { token: '12341234' };
   beforeAll((done) => {
     store = createStore(sessionReducer, initialState);
-
-    // wait for refresh redux store from localStorage
-    const unsubscribe = store.subscribe(() => {
-      unsubscribe();
+    const options = { driver: 'LOCALFORAGE' };
+    sessionService.initSessionService(store, options).then( () => {
       done();
     });
-    sessionService.initSessionService(store);
   });
 
   describe('refreshFromLocalStorage', () => {

src/index.js

@@ -1,5 +1,4 @@
 import { USER_SESSION, USER_DATA } from './constants';
-import * as localForage from 'localforage';
 import * as Cookies from "js-cookie";
 import {
   getSessionSuccess,
@@ -32,12 +31,21 @@ export class sessionService {
     instance.expires = expires;
     instance.driver = driver;
     instance.server = server;
-    driver && driver !== 'COOKIES' && localForage.setDriver(localForage[driver]);
+
+    // configure the storage
+    const storageOptions = {
+      name: 'redux-react-session'
+    };
+    const localforage = require('localforage');
+    if (driver && driver !== 'COOKIES') {
+      storageOptions.driver = localforage[driver];
+    }
+    instance.storage = localforage.createInstance(storageOptions);
   }
 
   static initSessionService(store, options) {
     instance = new sessionService(store, options);
-    sessionService.refreshFromLocalStorage();
+    return sessionService.refreshFromLocalStorage();
   }
 
   static initServerSession(store, req, options) {
@@ -54,25 +62,31 @@ export class sessionService {
 
       return list;
     };
-    sessionService.saveFromClient(parseCookies(req));
+    return sessionService.saveFromClient(parseCookies(req));
   }
 
   static saveFromClient(cookies) {
-    if (cookies[USER_SESSION]) {
-      sessionService.saveSession(cookies[USER_SESSION])
-      .then(() => {
-        if (cookies[USER_DATA]) {
-          sessionService.saveUser(cookies[USER_DATA]);
-        }
-      });
-    }
+    return new Promise((resolve, reject) => {
+      if (cookies[USER_SESSION]) {
+        sessionService.saveSession(cookies[USER_SESSION])
+        .then(() => {
+          if (cookies[USER_DATA]) {
+            sessionService.saveUser(cookies[USER_DATA])
+            .then(() => resolve());
+          }
+        });
+      } else {
+        instance.store.dispatch(getSessionError());
+        reject('Session not found');
+      }
+    });
   }
 
   static refreshFromLocalStorage() {
     return sessionService.loadSession()
     .then(() => {
       instance.store.dispatch(getSessionSuccess());
-      sessionService.loadUser().then((user) => {
+      return sessionService.loadUser().then((user) => {
         instance.store.dispatch(getUserSessionSuccess(user));
       })
       .catch(() => {
@@ -116,7 +130,7 @@ export class sessionService {
         instance.store.dispatch(getSessionSuccess());
         resolve();
       } else {
-        localForage.setItem(USER_SESSION, session)
+        instance.storage.setItem(USER_SESSION, session)
         .then(() => {
           instance.store.dispatch(getSessionSuccess());
           resolve();
@@ -138,7 +152,7 @@ export class sessionService {
         const cookies = Cookies.getJSON(USER_SESSION);
         cookies ? resolve(cookies) : reject('Session not found');
       } else {
-        localForage.getItem(USER_SESSION)
+        instance.storage.getItem(USER_SESSION)
         .then((currentSession) => {
           if (currentSession) {
             resolve(currentSession);
@@ -153,7 +167,7 @@ export class sessionService {
   }
 
   static deleteSession() {
-    return localForage.removeItem(USER_SESSION).then(() => {
+    return instance.storage.removeItem(USER_SESSION).then(() => {
       instance.store.dispatch(getSessionError());
       Cookies.remove(USER_SESSION);
       delete instance[USER_SESSION];
@@ -171,7 +185,7 @@ export class sessionService {
         instance.store.dispatch(getUserSessionSuccess(user));
         resolve();
       } else {
-        localForage.setItem(USER_DATA, user)
+        instance.storage.setItem(USER_DATA, user)
         .then((user) => {
           instance.store.dispatch(getUserSessionSuccess(user));
           resolve();
@@ -193,7 +207,7 @@ export class sessionService {
         const cookies = Cookies.getJSON(USER_DATA);
         cookies ? resolve(cookies) : reject('User not found');
       } else {
-        localForage.getItem(USER_DATA)
+        instance.storage.getItem(USER_DATA)
         .then((currentUser) => {
           if (currentUser) {
             resolve(currentUser);
@@ -208,7 +222,7 @@ export class sessionService {
   }
 
   static deleteUser() {
-    return localForage.removeItem(USER_DATA).then(() => {
+    return instance.storage.removeItem(USER_DATA).then(() => {
       instance.store.dispatch(getUserSessionError());
       Cookies.remove(USER_DATA);
       delete instance[USER_DATA];