amqp-model/dist/lib/AmqpModel.js

Model for connecting to Amqp and simply publish or subscribe messages.

'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 _amqp = require('amqp');

var _amqp2 = _interopRequireDefault(_amqp);

var _connection = require('amqp/lib/connection');

var _connection2 = _interopRequireDefault(_connection);

var _async = require('async');

var _async2 = _interopRequireDefault(_async);

var _AmqpModelError = require('./AmqpModelError');

var _AmqpModelError2 = _interopRequireDefault(_AmqpModelError);

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 defaultQueueOptions = {
    durable: true,
    autoDelete: false
};

var defaultExchangeOptions = {
    autoDelete: false,
    durable: true,
    confirm: true
};

var IAmqpModel = function () {
    /**
     *
     * @param connection
     * @param exchangeOptions
     * @param queueOptions
     * @param subscribeOptions
     * @param queueName
     * @param exchangeName
     * @param bind
     * @param onReady
     * @param onError
     * @param routingKey
     * @param publishOptions
     */
    function IAmqpModel(_ref) {
        var connection = _ref.connection,
            _ref$exchangeOptions = _ref.exchangeOptions,
            exchangeOptions = _ref$exchangeOptions === undefined ? {} : _ref$exchangeOptions,
            _ref$queueOptions = _ref.queueOptions,
            queueOptions = _ref$queueOptions === undefined ? {} : _ref$queueOptions,
            _ref$subscribeOptions = _ref.subscribeOptions,
            subscribeOptions = _ref$subscribeOptions === undefined ? {
            ack: true
        } : _ref$subscribeOptions,
            _ref$queueName = _ref.queueName,
            queueName = _ref$queueName === undefined ? null : _ref$queueName,
            _ref$exchangeName = _ref.exchangeName,
            exchangeName = _ref$exchangeName === undefined ? null : _ref$exchangeName,
            _ref$bind = _ref.bind,
            bind = _ref$bind === undefined ? false : _ref$bind,
            _ref$onReady = _ref.onReady,
            onReady = _ref$onReady === undefined ? function () {} : _ref$onReady,
            _ref$onError = _ref.onError,
            onError = _ref$onError === undefined ? function () {} : _ref$onError,
            _ref$routingKey = _ref.routingKey,
            routingKey = _ref$routingKey === undefined ? '#' : _ref$routingKey,
            _ref$publishOptions = _ref.publishOptions,
            publishOptions = _ref$publishOptions === undefined ? {
            contentType: 'application/json'
        } : _ref$publishOptions;

        _classCallCheck(this, IAmqpModel);

        this._queueName = queueName;
        this._exchangeName = exchangeName;
        this._bind = bind;

        this._queueOptions = _extends({}, defaultQueueOptions, queueOptions);

        this._exchangeOptions = _extends({}, defaultExchangeOptions, exchangeOptions);

        this._subscribeOptions = subscribeOptions;
        this._routingKey = routingKey;
        this._publishOptions = publishOptions;

        this._queue = null;
        this._exchange = null;
        this._consumerTags = [];
        this._publishWaitingList = [];
        this._subscribeWaitingList = [];

        this._initConnection(connection, onReady, onError);
    }

    _createClass(IAmqpModel, [{
        key: '_initConnection',
        value: async function _initConnection(connection, onReady) {
            var _this = this;

            var onError = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

            if (connection instanceof _connection2.default) {
                this._connection = connection;
                await this._afterConnect();
            } else {
                this._connection = _amqp2.default.createConnection(connection);

                this._connection.on('ready', async function () {
                    await _this._afterConnect();
                    if (typeof onReady === 'function') {
                        await onReady();
                    }
                });
            }

            if (typeof onError === 'function') {
                this._connection.on('error', onError);
            }
        }
    }, {
        key: '_afterConnect',
        value: async function _afterConnect() {
            await this._initQueue(this._queueName);
            await this._initExchange(this._exchangeName);
            await this._initBind(this._bind);
            await this._handleWaitingLists();
        }
    }, {
        key: '_initQueue',
        value: function _initQueue(queueName) {
            var _this2 = this;

            return new Promise(function (resolve, reject) {
                if (!queueName) {
                    return resolve();
                }

                _this2._connection.queue(queueName, _this2._queueOptions, function (queue) {
                    if (!queue) {
                        return reject('Queue initialization failed');
                    }

                    _this2._queue = queue;
                    resolve();
                });
            });
        }
    }, {
        key: '_initExchange',
        value: function _initExchange(exchangeName) {
            var _this3 = this;

            return new Promise(function (resolve, reject) {
                if (!exchangeName) {
                    return resolve();
                }

                _this3._connection.exchange(exchangeName, _this3._exchangeOptions, function (exchange) {
                    if (!exchange) {
                        return reject('Exchange initialization failed');
                    }

                    _this3._exchange = exchange;
                    resolve();
                });
            });
        }
    }, {
        key: '_initBind',
        value: function _initBind(bind) {
            var _this4 = this;

            return new Promise(function (resolve, reject) {
                if (!bind) {
                    return resolve();
                }

                _this4._queue.bind(_this4._exchange.name, _this4._routingKey, function () {
                    resolve();
                });
            });
        }
    }, {
        key: '_handleWaitingLists',
        value: function _handleWaitingLists() {
            var _this5 = this;

            var runWaitingItem = function runWaitingItem(item, next) {
                var f = item[0];
                var res = item[1];
                var rej = item[2];

                f(function () {
                    res.apply(arguments);
                    next();
                }, function () {
                    rej.apply(arguments);
                    next();
                });
            };

            var handleList = function handleList(list) {
                return function (cb) {
                    _async2.default.each(list, runWaitingItem, cb);
                };
            };

            return new Promise(function (resolve, reject) {
                _async2.default.waterfall([handleList(_this5._subscribeWaitingList), handleList(_this5._publishWaitingList)], function (err) {
                    if (err) {
                        return reject(err);
                    }

                    resolve();
                });
            });
        }

        /**
         * Publish message to exchange
         *
         * @param message
         * @param options
         * @param routingKey
         * @return {Promise}
         */

    }, {
        key: 'publish',
        value: function publish(message) {
            var _this6 = this;

            var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
            var routingKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : this._routingKey;

            if (!this._exchangeName) {
                throw new _AmqpModelError2.default('Exchange is not set.');
            }

            var publishOptions = _extends({}, this._publishOptions, options);

            var publishMessage = function publishMessage(resolve, reject) {
                var publishCallback = !_this6._exchangeOptions.confirm ? null : function (isError, err) {
                    if (isError) {
                        return reject(err);
                    }

                    resolve();
                };

                _this6._exchange.publish(routingKey, message, publishOptions, publishCallback);

                if (!_this6._exchangeOptions.confirm) {
                    resolve();
                }
            };

            return new Promise(function (resolve, reject) {
                if (!_this6._exchange) {
                    return _this6._publishWaitingList.push([publishMessage, resolve, reject]);
                }

                publishMessage(resolve, reject);
            });
        }

        /**
         *
         * @param fn
         * @param subscribeOptions
         */

    }, {
        key: 'queueByOne',
        value: function queueByOne(fn) {
            var _this7 = this;

            var subscribeOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

            if (!this._queueName) {
                throw new _AmqpModelError2.default('Queue is not set.');
            }

            var next = function next() {
                _this7._queue.shift();
            };

            var options = _extends({}, this._subscribeOptions, subscribeOptions);

            var subscribeQueue = function subscribeQueue(resolve, reject) {
                _this7._queue.subscribe(options, function (message, headers, deliveryInfo, messageObject) {
                    fn(message, next);
                }).addCallback(function (ok) {
                    _this7._consumerTags.push(ok.consumerTag);
                    resolve(ok.consumerTag);
                });
            };

            return new Promise(function (resolve, reject) {
                if (!_this7._queue) {
                    return _this7._subscribeWaitingList.push([subscribeQueue, resolve, reject]);
                }

                subscribeQueue(resolve, reject);
            });
        }
    }, {
        key: 'disconnect',
        value: function disconnect() {
            return this._connection.disconnect();
        }
    }, {
        key: 'unsubscribe',
        value: function unsubscribe(cTag) {
            var _this8 = this;

            return new Promise(function (resolve, reject) {
                _this8._queue.unsubscribe(cTag).addCallback(function () {
                    _this8._consumerTags.splice(_this8._consumerTags.indexOf(cTag), 1);
                    resolve();
                });
            });
        }
    }, {
        key: 'unsubscribeAll',
        value: function unsubscribeAll() {
            var _this9 = this;

            return new Promise(function (resolve, reject) {
                _async2.default.each(_this9._consumerTags, async function (cTag) {
                    await _this9.unsubscribe(cTag);
                }, function (err) {
                    if (err) {
                        return reject(err);
                    }

                    resolve();
                });
            });
        }
    }]);

    return IAmqpModel;
}();

exports.default = IAmqpModel;