guide/dist/fromGuide.js

Encrypted Globally Unique Identifier generator.

'use strict';

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

var _crypto = require('crypto');

var _crypto2 = _interopRequireDefault(_crypto);

var _base64Url = require('base64-url');

var _errors = require('./errors');

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

/**
 * @throws InvalidGuideError Throws if input guide cannot be decrypted.
 * @throws UnexpectedNamespaceValueError Throws if the namespace contained in the payload does not match the expected namespace.
 * @throws UnexpectedResourceTypeNameValueError Throws if the resource type name contained in the payload does not match the expected resource type name.
 */
/*:: import type {
  FromGuideType
} from './types';*/ // @flow

var fromGuide /*: FromGuideType*/ = function fromGuide(initializationVectorValue, expectedNamespace, expectedResourceTypeName, guide) {
  var decodedGuide = new Buffer((0, _base64Url.unescape)(guide), 'base64');

  var tag = decodedGuide.slice(0, 16);
  var body /*: Buffer*/ = decodedGuide.slice(16);

  var decipher = _crypto2.default.createDecipher('aes-256-gcm', initializationVectorValue);

  decipher.setAuthTag(tag);

  var payload = void 0;

  try {
    var decryptedGuide = decipher.update(body).toString() + decipher.final().toString();

    payload = JSON.parse(decryptedGuide);
  } catch (error) {
    // console.log('error', error);
    throw new _errors.InvalidGuideError(guide);
  }

  if (expectedNamespace !== payload.namespace) {
    throw new _errors.UnexpectedNamespaceValueError(guide, expectedNamespace, expectedResourceTypeName, payload);
  }

  if (expectedResourceTypeName !== payload.type) {
    throw new _errors.UnexpectedResourceTypeNameValueError(guide, expectedNamespace, expectedResourceTypeName, payload);
  }

  return {
    id: payload.id,
    namespace: payload.namespace,
    type: payload.type
  };
};

exports.default = fromGuide;
//# sourceMappingURL=fromGuide.js.map