deep-framework/lib.compiled/Framework.js

DEEP Framework

/**
 * Created by AlexanderC on 11/5/15.
 */

'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _deepKernel = require('deep-kernel');

var _deepKernel2 = _interopRequireDefault(_deepKernel);

var _deepCore = require('deep-core');

var _deepCore2 = _interopRequireDefault(_deepCore);

var _ContextProvider = require('./ContextProvider');

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"); } }

var AWSXRay = require('xray-sdk-core');
var AWS = require('aws-sdk');
var https = require('https');

const DEEP_X_RAY_ENABLED = AWSXRay && process.env.DEEP_X_RAY_ENABLED == 'true';

if (DEEP_X_RAY_ENABLED) {
  AWSXRay.captureAWS(AWS);
  AWSXRay.captureHTTPs(https);
}

let Framework = exports.Framework = function () {
  /**
   * @param {Object} servicesMap
   * @param {String} context
   */
  function Framework(servicesMap, context) {
    _classCallCheck(this, Framework);

    this._context = context;
    this._services = servicesMap;
    this._version = require('../package.json').version;
    this._kernelsMap = {};
  }

  /**
   * @returns {string}
   */


  _createClass(Framework, [{
    key: 'LambdaHandler',


    /**
     * @param {DeepFramework.Core.AWS.Lambda.Runtime|Handler|*} Handler
     * @returns {{handler: Function}}
     */
    value: function LambdaHandler(Handler) {
      let handler = {
        handler: (event, context, callback) => {
          this.KernelFromLambdaContext(context, event).bootstrap(deepKernel => {
            new Handler(deepKernel).run(event, context, callback);
          });
        }
      };

      if (DEEP_X_RAY_ENABLED) {
        handler = {
          handler: (event, context, callback) => {
            let contextSegment = AWSXRay.getSegment();

            let overheadSubSegment = contextSegment.addNewSubsegment('DeepCustom_FrameworkOverhead');
            let bootstrapSubSegment = contextSegment.addNewSubsegment('DeepCustom_KernelBootstrap');

            this.KernelFromLambdaContext(context, event).bootstrap(deepKernel => {
              bootstrapSubSegment.close();

              // injecting it into context to be closed into /deep-core/lib/AWS/Lambda/Runtime.js
              context.overheadSubSegment = overheadSubSegment;

              new Handler(deepKernel).run(event, context, callback);
            });
          }
        };
      }

      return handler;
    }

    /**
     *
     * @todo: improve it
     *
     * @param {Object} lambdaContext
     * @param {Object} lambdaEvent
     * @returns {Kernel}
     *
     * @sample:
     * ```
     * exports.handler = function (event, context) {
     *   DeepFramework.KernelFromLambdaContext(context).loadFromFile("_config.json", function (deepKernel) {
     *     new Handler(deepKernel).run(event, context);
     *   });
     * };
     * KernelFromLambdaContext
     * ```
     */

  }, {
    key: 'KernelFromLambdaContext',
    value: function KernelFromLambdaContext(lambdaContext, lambdaEvent) {
      let contextProvider = new _ContextProvider.ContextProvider(lambdaContext).fillContextWithEventData(lambdaEvent);

      let identityId = Framework.ANONYMOUS_IDENTITY_KEY;

      if (lambdaContext.hasOwnProperty('identity') && lambdaContext.identity.cognitoIdentityPoolId && lambdaContext.identity.cognitoIdentityId) {

        identityId = lambdaContext.identity.cognitoIdentityId;
      }

      let kernel = this._kernelCached(identityId);

      kernel.runtimeContext = lambdaContext; // @todo: remove "runtimeContext" on next major release
      kernel.contextProvider = contextProvider;

      return kernel;
    }

    /**
     * @param {String} id
     * @returns {Kernel}
     * @constructor
     */

  }, {
    key: '_kernelCached',
    value: function _kernelCached(id) {
      if (this._kernelsMap.hasOwnProperty(id)) {
        return this._kernelsMap[id];
      }

      this._kernelsMap[id] = this._createKernel();

      return this._kernelsMap[id];
    }

    /**
     * @todo: remove method in next release (back compatibility)
     *
     * @returns {Kernel}
     * @constructor
     */

  }, {
    key: '_createKernel',


    /**
     * @returns {Kernel}
     * @private
     */
    value: function _createKernel() {
      return new _deepKernel2.default(this._services, this._context);
    }

    /**
     * @returns {String}
     */

  }, {
    key: 'context',


    /**
     * @returns {String}
     */
    get: function get() {
      return this._context;
    }

    /**
     * @returns {String}
     */

  }, {
    key: 'version',
    get: function get() {
      return this._version;
    }
  }, {
    key: 'Kernel',
    get: function get() {
      return this._kernelCached(Framework.ANONYMOUS_IDENTITY_KEY);
    }

    /**
     * @returns {Function}
     * @constructor
     */

  }, {
    key: 'Core',
    get: function get() {
      return _deepCore2.default;
    }
  }], [{
    key: 'ANONYMOUS_IDENTITY_KEY',
    get: function get() {
      return 'anonymous';
    }
  }, {
    key: 'BACKEND_CONTEXT',
    get: function get() {
      return _deepKernel2.default.BACKEND_CONTEXT;
    }

    /**
     * @returns {String}
     */

  }, {
    key: 'FRONTEND_CONTEXT',
    get: function get() {
      return _deepKernel2.default.FRONTEND_CONTEXT;
    }
  }]);

  return Framework;
}();