@harmonyjs/controller-auth-jwt/dist-node/index.js

Authentication controller for Harmony using JWT

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var FastifyJWT = _interopDefault(require('fastify-jwt'));
require('fastify-cookie');

function _defineProperty(obj, key, value) {
  if (key in obj) {
    Object.defineProperty(obj, key, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: true
    });
  } else {
    obj[key] = value;
  }

  return obj;
}

function ownKeys(object, enumerableOnly) {
  var keys = Object.keys(object);

  if (Object.getOwnPropertySymbols) {
    var symbols = Object.getOwnPropertySymbols(object);
    if (enumerableOnly) symbols = symbols.filter(function (sym) {
      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
    });
    keys.push.apply(keys, symbols);
  }

  return keys;
}

function _objectSpread2(target) {
  for (var i = 1; i < arguments.length; i++) {
    var source = arguments[i] != null ? arguments[i] : {};

    if (i % 2) {
      ownKeys(Object(source), true).forEach(function (key) {
        _defineProperty(target, key, source[key]);
      });
    } else if (Object.getOwnPropertyDescriptors) {
      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
    } else {
      ownKeys(Object(source)).forEach(function (key) {
        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
      });
    }
  }

  return target;
}

const ControllerAuthenticationJWT = configuration => ({
  name: 'ControllerAuthenticationJWT',
  global: true,

  async initialize({
    server,
    logger
  }) {
    const {
      secret
    } = configuration;

    if (!secret) {
      logger.warn('Please avoid using the default secret for authentication.');
      logger.warn('Provide your own secret through AuthenticationJWTConfig::secret');
    }

    await server.register(FastifyJWT, _objectSpread2(_objectSpread2({
      sign: {
        algorithm: 'HS256'
      }
    }, configuration), {}, {
      secret: secret || 'harmony',
      cookie: configuration.cookie
    }));
    await server.decorate(ControllerAuthenticationJWT.validator, {
      block: async (request, reply) => {
        try {
          await request.jwtVerify();
        } catch (err) {
          reply.send(err);
        }
      },
      try: async request => {
        try {
          await request.jwtVerify();
        } catch (err) {// Ignore, just decoding
        }
      },
      get: request => request.user,
      create: (request, reply, payload, opts) => {
        const token = server.jwt.sign(payload, opts);

        if (configuration.cookie && configuration.cookie.cookieName) {
          reply.setCookie(configuration.cookie.cookieName, token, configuration.cookie);
        }

        return token;
      }
    });
    logger.info('Authentication system initialized');
  }

});

ControllerAuthenticationJWT.validator = 'jwtAuthenticate';

exports.default = ControllerAuthenticationJWT;
//# sourceMappingURL=index.js.map