Merge pull request #330 from bertho-zero/async

async/await + minor changes

Author: bertho-zero

.gitignore

@@ -10,4 +10,5 @@ npm-debug.log
 .happypack
 webpack/dlls/*.json
 api/**/*.nedb
-*.report.html
+*.report.html
+coverage

api/actions/__tests__/widget-load-test.js

@@ -14,17 +14,15 @@ describe('widget load', () => {
       sinon.stub(Math, 'random').returns(0.4);
     });
 
-    it('uses the widgets from the session', () => {
-      load({ session: { user: {}, widgets: ['a', 'b', 'c'] } }, undefined).then(widgets => {
-        expect(widgets.length).to.equal(3);
-      });
+    it('uses the widgets from the session', async () => {
+      const widgets = await load({ session: { user: {}, widgets: ['a', 'b', 'c'] } }, undefined);
+      expect(widgets.length).to.equal(3);
     });
 
-    it('initializes the widgets ', () => {
-      load({ session: { user: {} } }, undefined).then(widgets => {
-        expect(widgets.length).to.equal(4);
-        expect(widgets[0].color).to.equal('Red');
-      });
+    it('initializes the widgets ', async () => {
+      const widgets = await load({ session: { user: {} } }, undefined);
+      expect(widgets.length).to.equal(4);
+      expect(widgets[0].color).to.equal('Red');
     });
   });
 
@@ -33,13 +31,12 @@ describe('widget load', () => {
       sinon.stub(Math, 'random').returns(0.2);
     });
 
-    it('rejects the call', () => {
-      load({ session: { user: {} } }, undefined).then(
-        () => {},
-        err => {
-          expect(err).to.equal('Widget load fails 33% of the time. You were unlucky.');
-        }
-      );
+    it('rejects the call', async () => {
+      try {
+        await load({ session: { user: {} } }, undefined);
+      } catch (err) {
+        expect(err).to.equal('Widget load fails 33% of the time. You were unlucky.');
+      }
     });
   });
 });

api/actions/__tests__/widget-update-test.js

@@ -23,33 +23,30 @@ describe('widget update', () => {
       }
     });
 
-    it('does not accept green widgets', () => {
+    it('does not accept green widgets', async () => {
       sinon.stub(load, 'default').resolves(widgets);
-      return update({ session: {}, body: { color: 'Green' } }).then(
-        () => {},
-        err => {
-          expect(err.color).to.equal('We do not accept green widgets');
-        }
-      );
+      try {
+        await update({ session: {}, body: { color: 'Green' } });
+      } catch (err) {
+        expect(err.color).to.equal('We do not accept green widgets');
+      }
     });
 
-    it('fails to load widgets', () => {
+    it('fails to load widgets', async () => {
       sinon.stub(load, 'default').rejects(new Error('Widget fail to load.'));
-      return update({ session: {}, body: { color: 'Blue' } }).then(
-        () => {},
-        err => {
-          expect(err.message).to.equal('Widget fail to load.');
-        }
-      );
+      try {
+        await update({ session: {}, body: { color: 'Blue' } });
+      } catch (err) {
+        expect(err.message).to.equal('Widget fail to load.');
+      }
     });
 
-    it('updates a widget', () => {
+    it('updates a widget', async () => {
       sinon.stub(load, 'default').resolves(widgets);
       const widget = { id: 2, color: 'Blue' };
-      return update({ session: {}, body: widget }).then(res => {
-        expect(res).to.deep.equal(widget);
-        expect(widgets[1]).to.deep.equal(widget);
-      });
+      const res = await update({ session: {}, body: widget });
+      expect(res).to.deep.equal(widget);
+      expect(widgets[1]).to.deep.equal(widget);
     });
   });
 
@@ -58,13 +55,12 @@ describe('widget update', () => {
       sinon.stub(Math, 'random').returns(0.1);
     });
 
-    it('rejects the call in 20% of the time', () => {
-      update().then(
-        () => {},
-        err => {
-          expect(err).to.equal('Oh no! Widget save fails 20% of the time. Try again.');
-        }
-      );
+    it('rejects the call in 20% of the time', async () => {
+      try {
+        update();
+      } catch (err) {
+        expect(err).to.equal('Oh no! Widget save fails 20% of the time. Try again.');
+      }
     });
   });
 });

api/actions/widget/update.js

@@ -3,29 +3,27 @@ import load from './load';
 export default function update(req) {
   return new Promise((resolve, reject) => {
     // write to database
-    setTimeout(() => {
+    setTimeout(async () => {
       if (Math.random() < 0.2) {
         reject('Oh no! Widget save fails 20% of the time. Try again.');
       } else {
-        load(req).then(
-          data => {
-            const widgets = data;
-            const widget = req.body;
-            if (widget.color === 'Green') {
-              reject({
-                color: 'We do not accept green widgets' // example server-side validation error
-              });
-            }
-            if (widget.id) {
-              widgets[widget.id - 1] = widget; // id is 1-based. please don't code like this in production! :-)
-              req.session.widgets = widgets;
-            }
-            resolve(widget);
-          },
-          err => {
-            reject(err);
+        try {
+          const data = await load(req);
+          const widgets = data;
+          const widget = req.body;
+          if (widget.color === 'Green') {
+            reject({
+              color: 'We do not accept green widgets' // example server-side validation error
+            });
           }
-        );
+          if (widget.id) {
+            widgets[widget.id - 1] = widget; // id is 1-based. please don't code like this in production! :-)
+            req.session.widgets = widgets;
+          }
+          resolve(widget);
+        } catch (err) {
+          reject(err);
+        }
       }
     }, 1500); // simulate async db write
   });

api/api.js

@@ -6,7 +6,6 @@ import cookieParser from 'cookie-parser';
 import hooks from 'feathers-hooks';
 import rest from 'feathers-rest';
 import socketio from 'feathers-socketio';
-import isPromise from 'is-promise';
 import PrettyError from 'pretty-error';
 import config from './config';
 import middleware from './middleware';
@@ -35,7 +34,7 @@ app
   .use(bodyParser.urlencoded({ extended: true }))
   .use(bodyParser.json());
 
-const actionsHandler = (req, res, next) => {
+const actionsHandler = async (req, res, next) => {
   const splittedUrlPath = req.url
     .split('?')[0]
     .split('/')
@@ -44,31 +43,28 @@ const actionsHandler = (req, res, next) => {
 
   req.app = app;
 
-  const catchError = error => {
+  const catchError = async error => {
     console.error('API ERROR:', pretty.render(error));
     res.status(error.status || 500).json(error);
   };
 
   if (action) {
     try {
-      const handle = action(req, params);
-      (isPromise(handle) ? handle : Promise.resolve(handle))
-        .then(result => {
-          if (result instanceof Function) {
-            result(res);
-          } else {
-            res.json(result);
-          }
-        })
-        .catch(reason => {
-          if (reason && reason.redirect) {
-            res.redirect(reason.redirect);
-          } else {
-            catchError(reason);
-          }
-        });
+      try {
+        const result = await action(req, params);
+        if (result instanceof Function) {
+          result(res);
+        } else {
+          res.json(result);
+        }
+      } catch (reason) {
+        if (reason && reason.redirect) {
+          return res.redirect(reason.redirect);
+        }
+        return catchError(reason);
+      }
     } catch (error) {
-      catchError(error);
+      return catchError(error);
     }
   } else {
     next();

api/hooks/validateHook.js

@@ -2,12 +2,14 @@ import errors from 'feathers-errors';
 import { createAsyncValidator as validator } from 'utils/validation';
 
 export default function validateHook(schema) {
-  return hook =>
-    validator(schema, { hook })(hook.data)
-      .then(() => hook)
-      .catch(errorsValidation => {
-        if (Object.keys(errorsValidation).length) {
-          throw new errors.BadRequest('Validation failed', errorsValidation);
-        }
-      });
+  return async hook => {
+    try {
+      await validator(schema, { hook })(hook.data);
+      return hook;
+    } catch (errorsValidation) {
+      if (Object.keys(errorsValidation).length) {
+        throw new errors.BadRequest('Validation failed', errorsValidation);
+      }
+    }
+  };
 }

api/services/authentication/index.js

@@ -9,13 +9,11 @@ import { discard } from 'feathers-hooks-common';
 export socketAuth from './socketAuth';
 
 function populateUser(authConfig) {
-  return hook =>
-    hook.app.passport
-      .verifyJWT(hook.result.accessToken, authConfig)
-      .then(payload => hook.app.service('users').get(payload.userId))
-      .then(user => {
-        hook.result.user = user;
-      });
+  return async hook => {
+    const payload = await hook.app.passport.verifyJWT(hook.result.accessToken, authConfig);
+    const user = await hook.app.service('users').get(payload.userId);
+    hook.result.user = user;
+  };
 }
 
 function restToSocketAuth() {

api/services/authentication/socketAuth.js

@@ -1,5 +1,5 @@
 export default function socketAuth(app) {
-  return (socket, next) => {
+  return async (socket, next) => {
     const { cookie } = socket.request.headers;
     const cookies =
       cookie &&
@@ -17,17 +17,17 @@ export default function socketAuth(app) {
 
     if (!accessToken) return next();
 
-    app.passport
-      .verifyJWT(accessToken, app.get('auth'))
-      .then(payload => app.service('users').get(payload.userId))
-      .then(user => {
-        Object.assign(socket.feathers, {
-          accessToken,
-          user,
-          authenticated: true
-        });
-        next();
-      })
-      .catch(() => next());
+    try {
+      const payload = await app.passport.verifyJWT(accessToken, app.get('auth'));
+      const user = await app.service('users').get(payload.userId);
+      Object.assign(socket.feathers, {
+        accessToken,
+        user,
+        authenticated: true
+      });
+      next();
+    } catch (e) {
+      next();
+    }
   };
 }

api/utils/validation.js

@@ -1,39 +1,33 @@
-import isPromise from 'is-promise';
 import * as validation from '../../src/utils/validation';
 
 function createAsyncValidator(rules, params) {
-  return (data = {}) => {
+  return async (data = {}) => {
     const errors = validation.createValidator(rules, params)(data);
 
-    const promises = Object.keys(errors).map(name => {
-      const error = errors[name];
-      const myResolve = () => ({ status: 'resolved', name });
-      const myReject = err => ({ status: 'rejected', name, error: err });
-
-      if (isPromise(error)) {
-        return error.then(myResolve).catch(myReject);
+    const finalErrors = await Object.keys(errors).reduce(async (result, name) => {
+      try {
+        const error = await errors[name];
+        return error ? Object.assign(result, { [name]: error }) : result;
+      } catch (error) {
+        return Object.assign(result, { [name]: error });
       }
+    }, {});
 
-      return error ? myReject() : myResolve();
-    });
-
-    return Promise.all(promises).then(results => {
-      const finalErrors = results
-        .filter(x => x.status === 'rejected')
-        .reduce((prev, next) => ({ ...prev, [next.name]: next.error }), {});
+    if (Object.keys(finalErrors).length) {
+      throw finalErrors;
+    }
 
-      return Object.keys(finalErrors).length ? Promise.reject(finalErrors) : Promise.resolve(data);
-    });
+    return data;
   };
 }
 
 function unique(field) {
-  return (value, data, { hook }) =>
-    hook.service.find({ query: { [field]: value } }).then(result => {
-      if (result.total !== 0) {
-        return Promise.reject('Already exist');
-      }
-    });
+  return async (value, data, { hook }) => {
+    const result = await hook.service.find({ query: { [field]: value } });
+    if (result.total !== 0) {
+      return Promise.reject('Already exist');
+    }
+  };
 }
 
 module.exports = {

package.json

@@ -149,7 +149,6 @@
     "feathers-rest": "^1.7.3",
     "feathers-socketio": "^2.0.0",
     "http-proxy": "^1.16.2",
-    "is-promise": "^2.1.0",
     "js-cookie": "^2.1.3",
     "localforage": "^1.4.3",
     "lru-memoize": "^1.0.1",