promisified AbstractGrantType

lib/grant-types/abstract-grant-type.js

@@ -1,20 +1,13 @@
 'use strict';
 
-/**
- * Module dependencies.
- */
-
 var InvalidArgumentError = require('../errors/invalid-argument-error');
-var InvalidScopeError = require('../errors/invalid-scope-error');
-var Promise = require('bluebird');
-var promisify = require('promisify-any').use(Promise);
+// var InvalidScopeError = require('../errors/invalid-scope-error');
 var is = require('../validator/is');
 var tokenUtil = require('../utils/token-util');
 
 /**
  * Constructor.
  */
-
 function AbstractGrantType(options) {
   options = options || {};
 
@@ -35,55 +28,73 @@ function AbstractGrantType(options) {
 /**
  * Generate access token.
  */
+AbstractGrantType.prototype.generateAccessToken = async function(client, user, scope) {
+
+  let accessToken;
+
+  if (
+    this.model &&
+    this.model.generateAccessToken &&
+    typeof this.model.generateAccessToken === 'function'
+  ) {
+
+    try {
+      accessToken = await this.model.generateAccessToken
+        .call(this.model, client, user, scope);
+    } catch (err) {
+      return Promise.reject(err);
+    }
 
-AbstractGrantType.prototype.generateAccessToken = function(client, user, scope) {
-  if (this.model.generateAccessToken) {
-    return promisify(this.model.generateAccessToken, 3).call(this.model, client, user, scope)
-      .then(function(accessToken) {
-        return accessToken || tokenUtil.generateRandomToken();
-      });
   }
 
-  return tokenUtil.generateRandomToken();
+  return Promise.resolve( accessToken || tokenUtil.generateRandomToken() );
 };
 
 /**
  * Generate refresh token.
  */
+AbstractGrantType.prototype.generateRefreshToken = async function(client, user, scope) {
+
+  let refreshToken;
+
+  if (
+    this.model &&
+    this.model.generateRefreshToken &&
+    typeof this.model.generateRefreshToken === 'function'
+  ) {
+
+    try {
+      refreshToken = await this.model.generateRefreshToken
+        .call(this.model, client, user, scope); 
+    } catch (err) {
+      return Promise.reject(err);
+    }
 
-AbstractGrantType.prototype.generateRefreshToken = function(client, user, scope) {
-  if (this.model.generateRefreshToken) {
-    return promisify(this.model.generateRefreshToken, 3).call(this.model, client, user, scope)
-      .then(function(refreshToken) {
-        return refreshToken || tokenUtil.generateRandomToken();
-      });
   }
 
-  return tokenUtil.generateRandomToken();
+  return Promise.resolve( refreshToken || tokenUtil.generateRandomToken() );
 };
 
 /**
  * Get access token expiration date.
  */
-
 AbstractGrantType.prototype.getAccessTokenExpiresAt = function() {
   return new Date(Date.now() + this.accessTokenLifetime * 1000);
 };
 
 /**
  * Get refresh token expiration date.
  */
-
 AbstractGrantType.prototype.getRefreshTokenExpiresAt = function() {
   return new Date(Date.now() + this.refreshTokenLifetime * 1000);
 };
 
 /**
  * Get scope from the request body.
  */
-
 AbstractGrantType.prototype.getScope = function(request) {
-  if (!is.nqschar(request.body.scope)) {
+
+  if (!request || !request.body || !is.nqschar(request.body.scope)) {
     throw new InvalidArgumentError('Invalid parameter: `scope`');
   }
 
@@ -93,23 +104,35 @@ AbstractGrantType.prototype.getScope = function(request) {
 /**
  * Validate requested scope.
  */
-AbstractGrantType.prototype.validateScope = function(user, client, scope) {
-  if (this.model.validateScope) {
-    return promisify(this.model.validateScope, 3).call(this.model, user, client, scope)
-      .then(function (scope) {
-        if (!scope) {
-          throw new InvalidScopeError('Invalid scope: Requested scope is invalid');
-        }
-
-        return scope;
-      });
-  } else {
-    return scope;
+AbstractGrantType.prototype.validateScope = async function(user, client, scope) {
+
+  // scope is valid by default
+  let isValidScope = true;
+
+  if (
+    this.model &&
+    this.model.validateScope &&
+    typeof this.model.validateScope === 'function'
+  ) {
+
+    try {
+      isValidScope = await this.model.validateScope
+        .call(this.model, user, client, scope);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+
   }
-};
 
-/**
- * Export constructor.
- */
+  // This should never return an error, only true or false.
+  // if (!isValidScope) {
+  //   Promise.reject( 
+  //     new InvalidScopeError('Invalid scope: Requested scope is invalid')
+  //   );
+  // }
+
+  return Promise.resolve(isValidScope);
+
+};
 
 module.exports = AbstractGrantType;

lib/utils/token-util.js

@@ -3,9 +3,8 @@
 /**
  * Module dependencies.
  */
-
-var crypto = require('crypto');
-var randomBytes = require('bluebird').promisify(require('crypto').randomBytes);
+const crypto = require('crypto');
+const {promisify} = require('util');
 
 /**
  * Export `TokenUtil`.
@@ -16,14 +15,21 @@ module.exports = {
   /**
    * Generate random token.
    */
+  generateRandomToken: async function() {
+
+    let buffer;
+
+    try {
+      buffer = await promisify(crypto.randomBytes)(256);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+
+    return crypto
+      .createHash('sha256')
+      .update(buffer)
+      .digest('hex');
 
-  generateRandomToken: function() {
-    return randomBytes(256).then(function(buffer) {
-      return crypto
-        .createHash('sha256')
-        .update(buffer)
-        .digest('hex');
-    });
   }
 
 };

test/integration/utils/token-util_test.js

@@ -4,21 +4,31 @@
  * Module dependencies.
  */
 
-var TokenUtil = require('../../../lib/utils/token-util');
 var should = require('chai').should();
+var TokenUtil = require('../../../lib/utils/token-util');
 
 /**
  * Test `TokenUtil` integration.
  */
-
 describe('TokenUtil integration', function() {
+
   describe('generateRandomToken()', function() {
-    it('should return a sha-256 token', function() {
-      return TokenUtil.generateRandomToken()
-        .then(function(token) {
-          token.should.be.a.sha256();
-        })
-        .catch(should.fail);
+
+    it('should return a sha-256 token', async function() {
+
+      let token;
+
+      try {
+        token = await TokenUtil.generateRandomToken();
+      } catch (err) {
+        should.not.exist(err, err.stack);
+      }
+
+      should.exist(token);
+      token.should.be.a.sha256();
+
     });
+
   });
-});
+
+});