apollo-passport-local/lib/resolvers.js

Local strategy using email address and hashed, bcrypted password

"use strict";

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

  RootMutation: {
    apCreateUserEmailPassword: function apCreateUserEmailPassword(root, _ref) {
      var email = _ref.email;
      var password = _ref.password;
      var existing, user, userId;
      return regeneratorRuntime.async(function apCreateUserEmailPassword$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _context.next = 2;
              return regeneratorRuntime.awrap(this.db.fetchUserByEmail(email));

            case 2:
              existing = _context.sent;

              if (!existing) {
                _context.next = 5;
                break;
              }

              return _context.abrupt("return", { token: "", error: "E-mail already registered" });

            case 5:
              _context.t0 = [{ address: email }];
              _context.next = 8;
              return regeneratorRuntime.awrap(this.hashPassword(password));

            case 8:
              _context.t1 = _context.sent;
              _context.t2 = {
                bcrypt: _context.t1
              };
              _context.t3 = {
                password: _context.t2
              };
              user = {
                emails: _context.t0,
                services: _context.t3
              };
              userId = void 0;
              _context.prev = 13;
              _context.next = 16;
              return regeneratorRuntime.awrap(this.createUser(user));

            case 16:
              userId = _context.sent;
              _context.next = 22;
              break;

            case 19:
              _context.prev = 19;
              _context.t4 = _context["catch"](13);
              return _context.abrupt("return", {
                error: _context.t4.message,
                token: ""
              });

            case 22:

              // XXX correct id field?
              user.id = userId;

              return _context.abrupt("return", {
                error: "",
                token: this.createTokenFromUser(user)
              });

            case 24:
            case "end":
              return _context.stop();
          }
        }
      }, null, this, [[13, 19]]);
    },
    apLoginEmailPassword: function apLoginEmailPassword(root, args) {
      var _this = this;

      return new Promise(function (resolve, reject) {

        _this.passport.authenticate('local', function (err, user, info) {

          if (err) return reject(err);

          if (!user || info) return resolve({ error: info, token: "" });

          resolve({
            error: "",
            token: _this.createTokenFromUser(user)
          });
        })({ query: args }); // fake req.query using args from graphQL
      });
    },
    apUpdateUserPassword: function apUpdateUserPassword(root, _ref2, context) {
      var userId = _ref2.userId;
      var oldPassword = _ref2.oldPassword;
      var newPassword = _ref2.newPassword;
      var user, storedPassword, match;
      return regeneratorRuntime.async(function apUpdateUserPassword$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              if (context && context.auth && context.auth.userId === userId) {
                _context2.next = 2;
                break;
              }

              return _context2.abrupt("return", "Not logged in as " + userId);

            case 2:
              _context2.next = 4;
              return regeneratorRuntime.awrap(this.db.fetchUserById(userId));

            case 4:
              user = _context2.sent;

              if (user) {
                _context2.next = 7;
                break;
              }

              return _context2.abrupt("return", 'No such userId');

            case 7:

              console.log(user);
              storedPassword = user && user.services && user.services.password && user.services.password.bcrypt;

              console.log('storedPassword', storedPassword);

              // TODO allow no password only if email set.  allow email as part of query?

              if (!storedPassword) {
                _context2.next = 19;
                break;
              }

              _context2.next = 13;
              return regeneratorRuntime.awrap(this.comparePassword(oldPassword, storedPassword));

            case 13:
              match = _context2.sent;

              console.log('match', match);

              if (match) {
                _context2.next = 17;
                break;
              }

              return _context2.abrupt("return", "Invalid old password");

            case 17:
              _context2.next = 20;
              break;

            case 19:
              return _context2.abrupt("return", "No old password set");

            case 20:
              _context2.prev = 20;
              _context2.t0 = regeneratorRuntime;
              _context2.t1 = this.db;
              _context2.t2 = userId;
              _context2.next = 26;
              return regeneratorRuntime.awrap(this.hashPassword(newPassword));

            case 26:
              _context2.t3 = _context2.sent;
              _context2.t4 = {
                bcrypt: _context2.t3
              };
              _context2.t5 = _context2.t1.assertUserServiceData.call(_context2.t1, _context2.t2, 'password', _context2.t4);
              _context2.next = 31;
              return _context2.t0.awrap.call(_context2.t0, _context2.t5);

            case 31:
              _context2.next = 36;
              break;

            case 33:
              _context2.prev = 33;
              _context2.t6 = _context2["catch"](20);
              return _context2.abrupt("return", _context2.t6.message);

            case 36:
              return _context2.abrupt("return", "");

            case 37:
            case "end":
              return _context2.stop();
          }
        }
      }, null, this, [[20, 33]]);
    }
  }

};

exports.default = resolvers;