@actonate/mirkwood/dist/utils/queue/index.js

GraphQL based Rapid Server-side Development framework

'use strict';

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

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

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 _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _types = require('../../lib/types');

var _types2 = _interopRequireDefault(_types);

var _resolver = require('../../lib/resolver');

var _resolver2 = _interopRequireDefault(_resolver);

var _graphql = require('graphql');

var _queries = require('../database/queries');

var _queries2 = _interopRequireDefault(_queries);

var _lodash = require('lodash');

var _queue = require('./queue');

var _queue2 = _interopRequireDefault(_queue);

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 QueueUtility = function () {
  function QueueUtility(_ref) {
    var config = _ref.config;

    _classCallCheck(this, QueueUtility);

    //Passing config to the Queue Utility
    _queue2.default.init({ config: config });

    this.resolvers = {
      push: this.pushResolver.bind(this),
      clean: this.cleanResolver.bind(this)
    };
  }

  _createClass(QueueUtility, [{
    key: 'pushResolver',
    value: function pushResolver(resolverName, type, model, inputSchema) {

      var schemaArgs = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;

      schemaArgs = _extends({
        data: {
          type: _types2.default.String,
          required: true
        },
        jobType: {
          type: _types2.default.String
        }
      }, schemaArgs, {
        queue: {
          type: _types2.default.String,
          required: true
        },
        options: {
          type: {
            name: "QueueOptions",
            fields: {
              jobId: {
                type: _types2.default.String
              },
              attempts: {
                type: _types2.default.Int,
                defaultValue: 3
              },
              lifo: {
                type: _types2.default.Boolean
              },
              priority: {
                type: _types2.default.Int,
                defaultValue: 1
              },
              delay: {
                type: _types2.default.Int,
                defaultValue: 0
              },
              removeOnComplete: {
                type: _types2.default.Boolean,
                defaultValue: false
              },
              removeOnFail: {
                type: _types2.default.Boolean,
                defaultValue: false
              },
              backoff: {
                type: {
                  name: "RetryOptions",
                  fields: {
                    type: {
                      type: _types2.default.String,
                      defaultValue: "exponential"
                    },
                    delay: {
                      type: _types2.default.Int
                    }
                  }
                }
              }
            }
          }
        }
      });

      var argsObjects = _types2.default.generateArgs(schemaArgs, inputSchema.name);

      var resolvedType = _types2.default.generateType({
        name: "QueueCreated",
        fields: {
          id: {
            type: _types2.default.ID
          },
          data: {
            type: _types2.default.String
          }
        }
      });

      return {
        type: resolvedType,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return _queue2.default.push(model, args);
        })
      };
    }
  }, {
    key: 'cleanResolver',
    value: function cleanResolver(resolverName, type, model, inputSchema) {
      var schemaArgs = inputSchema.args;
      var schema = model.schema;
      var modelName = schema.name;

      schemaArgs = {
        queue: {
          type: _types2.default.String,
          required: true
        },
        type: {
          type: _types2.default.Enum('QueueType', {
            'active': { value: 'active' },
            'delayed': { value: 'delayed' },
            'wait': { value: 'wait' },
            'completed': { value: 'completed' },
            'failed': { value: 'failed' }
          }),
          defaultValue: 'active'
        },
        grace: {
          type: _types2.default.Int,
          defaultValue: 0
        }
      };

      var argsObjects = _types2.default.generateArgs(schemaArgs, inputSchema.name);

      return {
        type: _types2.default.Boolean,
        args: argsObjects,
        resolve: new _resolver2.default(resolverName, function (_, args, ctx) {
          return _queue2.default.clean(model, args);
        })
      };
    }
  }, {
    key: 'mutations',
    value: function mutations(type, inputType, model) {
      return null;
    }
  }, {
    key: 'queries',
    value: function queries(type, inputType, model) {
      return null;
    }
  }]);

  return QueueUtility;
}();

exports.default = QueueUtility;