apollo-passport-local-strategy/lib/index.js

Local strategy using email address and hashed, bcrypted password

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Strategy = undefined;

var _bcrypt = require('bcrypt');

var _bcrypt2 = _interopRequireDefault(_bcrypt);

var _passportLocal = require('passport-local');

var _defaultOptions = require('./defaultOptions');

var _defaultOptions2 = _interopRequireDefault(_defaultOptions);

var _verify = require('./verify');

var _verify2 = _interopRequireDefault(_verify);

var _resolvers = require('./resolvers');

var _resolvers2 = _interopRequireDefault(_resolvers);

var _schema = require('./schema');

var _schema2 = _interopRequireDefault(_schema);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Core node modules && npm packages


var crypto = require('crypto');

// Passport modules


// Local modules


var BCRYPT_SALT_ROUNDS = 10;

// Default Tokens Expiration (1 week)
var WEEK = 60 * 60 * 24 * 7;

// Default Tokens Expiration (1 week)
var defaultTokensExpirationLength = {
  verification: WEEK,
  resetPass: WEEK
};

var extensionMethods = {
  hashPassword: function hashPassword(password, cb) {
    if (cb) return _bcrypt2.default.hash(password, BCRYPT_SALT_ROUNDS, cb);

    return new Promise(function (resolve, reject) {
      _bcrypt2.default.hash(password, BCRYPT_SALT_ROUNDS, function (err, res) {
        return err ? reject(err) : resolve(res);
      });
    });
  },
  comparePassword: function comparePassword(password, hash, cb) {
    if (cb) return _bcrypt2.default.compare(password, hash, cb);

    return new Promise(function (resolve, reject) {
      _bcrypt2.default.compare(password, hash, function (err, res) {
        return err ? reject(err) : resolve(res);
      });
    });
  },


  // Used for email verification and for reset password
  generateVerificationToken: function generateVerificationToken(expirationSeconds) {
    return new Promise(function (resolve, reject) {
      crypto.randomBytes(20, function (err, buf) {
        var token = buf.toString('hex');
        var expiration = Date.now() + expirationSeconds * 1000;
        err ? reject(err) : resolve({ token: token, expiration: expiration });
      });
    });
  }
};

var AugmentedLocalStrategy = function AugmentedLocalStrategy(apolloPassport, options) {
  _classCallCheck(this, AugmentedLocalStrategy);

  this.ap = apolloPassport;

  if (!options) options = _defaultOptions2.default;

  // extensionMethods.hookFuncs = options.hookFuncs;
  Object.assign(extensionMethods, options.hookMethods);
  var tokensExpirationLength = Object.assign({}, defaultTokensExpirationLength, options.tokensExpirationLength);
  this.tokensExpirationLength = tokensExpirationLength;
  this.strategy = new _passportLocal.Strategy(options, _verify2.default.bind(this.ap));

  this.resolvers = _resolvers2.default;
  this.schema = _schema2.default;

  // this.ap.extendWith(tokensExpiration);
  this.ap.extendWith(extensionMethods);
};

AugmentedLocalStrategy.__isAugmented = true;

exports.Strategy = AugmentedLocalStrategy;
exports.default = AugmentedLocalStrategy;