function-tree-firebase-admin/lib/TaskRunner.js

Firebase admin execution and provider

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.TaskRunner = 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 _firebaseQueue = require('firebase-queue');

var _firebaseQueue2 = _interopRequireDefault(_firebaseQueue);

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

function authenticate(_ref) {
  var firebase = _ref.firebase,
      props = _ref.props,
      path = _ref.path;

  return firebase.verifyIdToken(props.data._token).then(function (decodedToken) {
    return path.success({ uid: decodedToken.uid });
  }).catch(function (error) {
    return path.error({ error: error });
  });
}

function createRunTask(task, run) {
  return function (data, progress, resolve, reject) {
    var _execution = data._execution;

    delete data._execution;

    run(task.specId, [authenticate, {
      success: task.tree,
      error: function authenticationError(context) {
        context.props.task.reject(context.props.error);
      }
    }], {
      _execution: _execution,
      data: data,
      task: {
        type: task.specId,
        resolve: resolve,
        reject: reject
      }
    });
  };
}

var TaskRunner = exports.TaskRunner = function () {
  function TaskRunner() {
    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

    _classCallCheck(this, TaskRunner);

    this.specPrefix = options.specPrefix || '';
    this.run = options.run || function () {
      throw new Error('You have to add a function tree executer as a "run" property');
    };
    this.tasks = options.tasks || [];
    this.queueRef = options.queueRef;
    this.registeredQueues = [];
  }

  _createClass(TaskRunner, [{
    key: 'start',
    value: function start() {
      var _this = this;

      this.registeredQueues = this.tasks.map(function (task) {
        return new _firebaseQueue2.default(_this.queueRef, {
          specId: _this.specPrefix ? _this.specPrefix + '_' + task.specId : task.specId,
          numWorkers: task.numWorkers
        }, createRunTask(task, _this.run));
      });
    }
  }, {
    key: 'stop',
    value: function stop() {
      return Promise.all(this.registeredQueues.map(function (queue, index) {
        return new Promise(function (resolve, reject) {
          queue.shutdown().then(resolve, reject);
        });
      }));
    }
  }]);

  return TaskRunner;
}();
//# sourceMappingURL=TaskRunner.js.map