@rxdi/rabbitmq-pubsub 0.7.118

package/.babelrc

@@ -0,0 +1,4 @@
+
+{
+  "presets": ["es2015", "stage-0", "stage-2"]
+}

package/.travis.yml

@@ -0,0 +1,14 @@
+language: node_js
+node_js:
+  - "6"
+  - "4"
+
+cache:
+  directories:
+    - node_modules
+
+install:
+  - npm install
+
+services:
+  - redis-server

package/README.md

@@ -0,0 +1,2 @@
+# @rxdi/graphql-rabbitmq-pubsub
+Hard Forked from [graphql-rabbitmq-subscriptions](https://github.com/cdmbase/rabbitmq-pubsub)

package/dist/childLogger.d.ts

@@ -0,0 +1,10 @@
+export declare function createChildLogger(logger: Logger, className: string): {
+    trace: (...message: any[]) => void;
+    error: (...message: any[]) => void;
+    debug: (...message: any[]) => void;
+};
+export interface Logger {
+    trace: (...m: any[]) => void;
+    error: (...m: any[]) => void;
+    debug: (...m: any[]) => void;
+}

package/dist/childLogger.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createChildLogger = void 0;
+function createChildLogger(logger, className) {
+    return {
+        trace: (...message) => process.env.PUBSUB_LOGGING && console.log(...message),
+        error: (...message) => process.env.PUBSUB_LOGGING && console.error(...message),
+        debug: (...message) => process.env.PUBSUB_LOGGING && console.log(...message),
+    };
+}
+exports.createChildLogger = createChildLogger;

package/dist/common.d.ts

@@ -0,0 +1,36 @@
+export interface IQueueNameConfig {
+    /**
+     *  Set the prefetch count for this channel.
+     *  The count given is the maximum number of messages
+     *  sent over the channel that can be awaiting acknowledgement
+     *  once there are count messages outstanding,
+     *  the server will not send more messages on this channel
+     *  until one or more have been acknowledged.
+     *  A falsey value for count indicates no such limit.
+     *  https://www.squaremobius.net/amqp.node/channel_api.html#channel_prefetch
+     */
+    prefetch?: number;
+    /**
+     *  If we set global to true we will apply prefetch count globally for the queue
+     *  The count given is the maximum number of messages
+     */
+    globalPrefetch?: boolean;
+    name: string;
+    dlq: string;
+    dlx: string;
+    strictName?: boolean;
+}
+export declare class DefaultQueueNameConfig implements IQueueNameConfig {
+    name: string;
+    dlq: string;
+    dlx: string;
+    constructor(name: string);
+}
+export declare class DefaultPubSubQueueConfig implements IQueueNameConfig {
+    name: string;
+    dlq: string;
+    dlx: string;
+    constructor(name: string);
+}
+export declare function asQueueNameConfig(config: IQueueNameConfig | string): IQueueNameConfig;
+export declare function asPubSubQueueNameConfig(config: IQueueNameConfig | string): IQueueNameConfig;

package/dist/common.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asPubSubQueueNameConfig = exports.asQueueNameConfig = exports.DefaultPubSubQueueConfig = exports.DefaultQueueNameConfig = void 0;
+class DefaultQueueNameConfig {
+    constructor(name) {
+        this.name = name;
+        this.dlq = `${name}.DLQ`;
+        this.dlx = `${this.dlq}.Exchange`;
+    }
+}
+exports.DefaultQueueNameConfig = DefaultQueueNameConfig;
+class DefaultPubSubQueueConfig {
+    constructor(name) {
+        this.name = name;
+        this.dlq = "";
+        this.dlx = `${name}.DLQ.Exchange`;
+    }
+}
+exports.DefaultPubSubQueueConfig = DefaultPubSubQueueConfig;
+function asQueueNameConfig(config) {
+    return isQueueNameConfig(config)
+        ? config
+        : new DefaultQueueNameConfig(config);
+}
+exports.asQueueNameConfig = asQueueNameConfig;
+function asPubSubQueueNameConfig(config) {
+    return isQueueNameConfig(config)
+        ? config
+        : new DefaultPubSubQueueConfig(config);
+}
+exports.asPubSubQueueNameConfig = asPubSubQueueNameConfig;
+function isQueueNameConfig(config) {
+    if (config.name &&
+        config.dlq &&
+        config.dlx) {
+        return true;
+    }
+}

package/dist/connectionFactory.d.ts

@@ -0,0 +1,23 @@
+import * as amqp from "amqplib";
+import { Logger } from "./childLogger";
+export interface IRabbitMqConnectionFactory {
+    create(): Promise<amqp.Connection>;
+}
+export interface IRabbitMqConnectionConfig {
+    host: string;
+    port: number;
+}
+export declare class RabbitMqConnectionFactory implements IRabbitMqConnectionFactory {
+    private logger;
+    private connection;
+    connect: any;
+    constructor(logger: Logger, config: IRabbitMqConnectionConfig | string);
+    create(): Promise<amqp.Connection>;
+}
+export declare class RabbitMqSingletonConnectionFactory implements IRabbitMqConnectionFactory {
+    private logger;
+    private connection;
+    private promise;
+    constructor(logger: Logger, config: IRabbitMqConnectionConfig | string);
+    create(): Promise<amqp.Connection>;
+}

package/dist/connectionFactory.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMqSingletonConnectionFactory = exports.RabbitMqConnectionFactory = void 0;
+const amqp = require("amqplib");
+const childLogger_1 = require("./childLogger");
+function isConnectionConfig(config) {
+    if (config.host &&
+        config.port) {
+        return true;
+    }
+}
+class RabbitMqConnectionFactory {
+    constructor(logger, config) {
+        this.logger = logger;
+        this.connection = isConnectionConfig(config)
+            ? `amqp://${config.host}:${config.port}`
+            : config;
+        this.logger = childLogger_1.createChildLogger(logger, "RabbitMqConnectionFactory");
+    }
+    create() {
+        this.logger.debug("connecting to %s", this.connection);
+        if (this.connect) {
+            return Promise.resolve(this.connect);
+        }
+        return Promise.resolve(amqp.connect(this.connection))
+            .then((connect) => {
+            this.connect = connect;
+            return connect;
+        })
+            .catch((err) => {
+            this.logger.error("failed to create connection '%s'", this.connection);
+            return Promise.reject(err);
+        });
+    }
+}
+exports.RabbitMqConnectionFactory = RabbitMqConnectionFactory;
+class RabbitMqSingletonConnectionFactory {
+    constructor(logger, config) {
+        this.logger = logger;
+        this.connection = isConnectionConfig(config)
+            ? `amqp://${config.host}:${config.port}`
+            : config;
+    }
+    create() {
+        if (this.promise) {
+            this.logger.trace("reusing connection to %s", this.connection);
+            return this.promise;
+        }
+        this.logger.debug("creating connection to %s", this.connection);
+        return (this.promise = Promise.resolve(amqp.connect(this.connection)));
+    }
+}
+exports.RabbitMqSingletonConnectionFactory = RabbitMqSingletonConnectionFactory;

package/dist/consumer.d.ts

@@ -0,0 +1,19 @@
+import * as amqp from "amqplib";
+import { IRabbitMqConnectionFactory } from "./connectionFactory";
+import { IQueueNameConfig } from "./common";
+import { Logger } from "./childLogger";
+export interface IRabbitMqConsumerDisposer {
+    (): Promise<unknown>;
+}
+export declare class RabbitMqConsumer {
+    private logger;
+    private connectionFactory;
+    constructor(logger: Logger, connectionFactory: IRabbitMqConnectionFactory);
+    subscribe<T>(queue: string | IQueueNameConfig, action: (message: T) => Promise<any> | void): Promise<IRabbitMqConsumerDisposer>;
+    private setupChannel;
+    private subscribeToChannel;
+    protected getMessageObject<T>(message: amqp.Message): T;
+    protected getChannelSetup(channel: amqp.Channel, queueConfig: IQueueNameConfig): import("bluebird")<amqp.Replies.Empty>[];
+    protected getQueueSettings(deadletterExchangeName: string): amqp.Options.AssertQueue;
+    protected getDLSettings(): amqp.Options.AssertQueue;
+}

package/dist/consumer.js

@@ -0,0 +1,86 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMqConsumer = void 0;
+const common_1 = require("./common");
+const childLogger_1 = require("./childLogger");
+class RabbitMqConsumer {
+    constructor(logger, connectionFactory) {
+        this.logger = logger;
+        this.connectionFactory = connectionFactory;
+        this.logger = childLogger_1.createChildLogger(logger, "RabbitMqConsumer");
+    }
+    subscribe(queue, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queueConfig = common_1.asQueueNameConfig(queue);
+            const connection = yield this.connectionFactory.create();
+            const channel = yield connection.createChannel();
+            this.logger.trace("got channel for queue '%s'", queueConfig.name);
+            yield this.setupChannel(channel, queueConfig);
+            return this.subscribeToChannel(channel, queueConfig, action);
+        });
+    }
+    setupChannel(channel, queueConfig) {
+        this.logger.trace("setup '%j'", queueConfig);
+        return Promise.all(this.getChannelSetup(channel, queueConfig));
+    }
+    subscribeToChannel(channel, queueConfig, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.trace("subscribing to queue '%s'", queueConfig.name);
+            const opts = yield channel.consume(queueConfig.name, (message) => __awaiter(this, void 0, void 0, function* () {
+                let msg = this.getMessageObject(message);
+                this.logger.trace("message arrived from queue '%s' (%j)", queueConfig.name, msg);
+                try {
+                    yield action(msg);
+                }
+                catch (err) {
+                    this.logger.error(err, "message processing failed from queue '%j' (%j)", queueConfig, msg);
+                    channel.nack(message, false, false);
+                    return;
+                }
+                this.logger.trace("message processed from queue '%s' (%j)", queueConfig.name, msg);
+                channel.ack(message);
+            }));
+            this.logger.trace("subscribed to queue '%s' (%s)", queueConfig.name, opts.consumerTag);
+            return (() => __awaiter(this, void 0, void 0, function* () {
+                this.logger.trace("disposing subscriber to queue '%s' (%s)", queueConfig.name, opts.consumerTag);
+                yield channel.cancel(opts.consumerTag);
+                yield channel.close();
+                return Promise.resolve();
+            }));
+        });
+    }
+    getMessageObject(message) {
+        return JSON.parse(message.content.toString("utf8"));
+    }
+    getChannelSetup(channel, queueConfig) {
+        return [
+            channel.assertQueue(queueConfig.name, this.getQueueSettings(queueConfig.dlx)),
+            channel.assertQueue(queueConfig.dlq, this.getDLSettings()),
+            channel.assertExchange(queueConfig.dlx, "fanout", this.getDLSettings()),
+            channel.bindQueue(queueConfig.dlq, queueConfig.dlx, "*"),
+        ];
+    }
+    getQueueSettings(deadletterExchangeName) {
+        var settings = this.getDLSettings();
+        settings.arguments = {
+            "x-dead-letter-exchange": deadletterExchangeName,
+        };
+        return settings;
+    }
+    getDLSettings() {
+        return {
+            durable: true,
+            autoDelete: true,
+        };
+    }
+}
+exports.RabbitMqConsumer = RabbitMqConsumer;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { IRabbitMqConnectionFactory, IRabbitMqConnectionConfig, RabbitMqConnectionFactory, RabbitMqSingletonConnectionFactory, } from "./connectionFactory";
+export { RabbitMqConsumer, IRabbitMqConsumerDisposer } from "./consumer";
+export { RabbitMqProducer } from "./producer";
+export { RabbitMqPublisher } from "./publisher";
+export { RabbitMqSubscriber, IRabbitMqSubscriberDisposer } from "./subscriber";
+export { IQueueNameConfig } from "./common";

package/dist/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var connectionFactory_1 = require("./connectionFactory");
+Object.defineProperty(exports, "RabbitMqConnectionFactory", { enumerable: true, get: function () { return connectionFactory_1.RabbitMqConnectionFactory; } });
+Object.defineProperty(exports, "RabbitMqSingletonConnectionFactory", { enumerable: true, get: function () { return connectionFactory_1.RabbitMqSingletonConnectionFactory; } });
+var consumer_1 = require("./consumer");
+Object.defineProperty(exports, "RabbitMqConsumer", { enumerable: true, get: function () { return consumer_1.RabbitMqConsumer; } });
+var producer_1 = require("./producer");
+Object.defineProperty(exports, "RabbitMqProducer", { enumerable: true, get: function () { return producer_1.RabbitMqProducer; } });
+var publisher_1 = require("./publisher");
+Object.defineProperty(exports, "RabbitMqPublisher", { enumerable: true, get: function () { return publisher_1.RabbitMqPublisher; } });
+var subscriber_1 = require("./subscriber");
+Object.defineProperty(exports, "RabbitMqSubscriber", { enumerable: true, get: function () { return subscriber_1.RabbitMqSubscriber; } });

package/dist/producer.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import * as amqp from "amqplib";
+import { IRabbitMqConnectionFactory } from "./connectionFactory";
+import { IQueueNameConfig } from "./common";
+import { Logger } from "./childLogger";
+export declare class RabbitMqProducer {
+    private logger;
+    private connectionFactory;
+    constructor(logger: Logger, connectionFactory: IRabbitMqConnectionFactory);
+    publish<T>(queue: string | IQueueNameConfig, message: T, options?: IQueueNameConfig): Promise<void>;
+    protected getMessageBuffer<T>(message: T): Buffer;
+    protected getQueueSettings(deadletterExchangeName: string): amqp.Options.AssertQueue;
+}

package/dist/producer.js

@@ -0,0 +1,54 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMqProducer = void 0;
+const common_1 = require("./common");
+const childLogger_1 = require("./childLogger");
+class RabbitMqProducer {
+    constructor(logger, connectionFactory) {
+        this.logger = logger;
+        this.connectionFactory = connectionFactory;
+        this.logger = childLogger_1.createChildLogger(logger, "RabbitMqProducer");
+    }
+    publish(queue, message, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queueConfig = common_1.asQueueNameConfig(queue);
+            const settings = this.getQueueSettings(queueConfig.dlx);
+            const connection = yield this.connectionFactory.create();
+            const channel = yield connection.createChannel();
+            if (options === null || options === void 0 ? void 0 : options.prefetch) {
+                yield channel.prefetch(options.prefetch, options.globalPrefetch);
+            }
+            yield channel.assertQueue(queueConfig.name, settings);
+            if (!channel.sendToQueue(queueConfig.name, this.getMessageBuffer(message), {
+                persistent: true,
+            })) {
+                this.logger.error("unable to send message to queue '%j' {%j}", queueConfig, message);
+                throw new Error("Unable to send message");
+            }
+            this.logger.trace("message sent to queue '%s' (%j)", queueConfig.name, message);
+            return channel.close();
+        });
+    }
+    getMessageBuffer(message) {
+        return Buffer.from(JSON.stringify(message), "utf8");
+    }
+    getQueueSettings(deadletterExchangeName) {
+        return {
+            durable: true,
+            autoDelete: true,
+            arguments: {
+                "x-dead-letter-exchange": deadletterExchangeName,
+            },
+        };
+    }
+}
+exports.RabbitMqProducer = RabbitMqProducer;

package/dist/publisher.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import * as amqp from "amqplib";
+import { IRabbitMqConnectionFactory } from "./connectionFactory";
+import { IQueueNameConfig } from "./common";
+import { Logger } from "./childLogger";
+export declare class RabbitMqPublisher {
+    private logger;
+    private connectionFactory;
+    constructor(logger: Logger, connectionFactory: IRabbitMqConnectionFactory);
+    publish<T>(queue: string | IQueueNameConfig, message: T, options?: IQueueNameConfig): Promise<void>;
+    private setupChannel;
+    protected getMessageBuffer<T>(message: T): Buffer;
+    protected getChannelSetup(channel: amqp.Channel, queueConfig: IQueueNameConfig): import("bluebird")<amqp.Replies.AssertExchange>[];
+    protected getSettings(): amqp.Options.AssertQueue;
+}

package/dist/publisher.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMqPublisher = void 0;
+const common_1 = require("./common");
+const childLogger_1 = require("./childLogger");
+class RabbitMqPublisher {
+    constructor(logger, connectionFactory) {
+        this.logger = logger;
+        this.connectionFactory = connectionFactory;
+        this.logger = childLogger_1.createChildLogger(logger, "RabbitMqPublisher");
+    }
+    publish(queue, message, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queueConfig = common_1.asPubSubQueueNameConfig(queue);
+            try {
+                const connection = yield this.connectionFactory.create();
+                const channel = yield connection.createChannel();
+                if (options === null || options === void 0 ? void 0 : options.prefetch) {
+                    channel.prefetch(options.prefetch, options.globalPrefetch);
+                }
+                yield this.setupChannel(channel, queueConfig);
+                channel.publish(queueConfig.dlx, "", this.getMessageBuffer(message));
+                this.logger.trace("message sent to exchange '%s' (%j)", queueConfig.dlx, message);
+                return channel.close();
+            }
+            catch (e) {
+                this.logger.error("unable to send message to exchange '%j' {%j}", queueConfig.dlx, message);
+                throw new Error("Unable to send message");
+            }
+        });
+    }
+    setupChannel(channel, queueConfig) {
+        this.logger.trace("setup '%j'", queueConfig);
+        return Promise.all(this.getChannelSetup(channel, queueConfig));
+    }
+    getMessageBuffer(message) {
+        return Buffer.from(JSON.stringify(message), "utf8");
+    }
+    getChannelSetup(channel, queueConfig) {
+        return [
+            channel.assertExchange(queueConfig.dlx, "fanout", this.getSettings()),
+        ];
+    }
+    getSettings() {
+        return {
+            durable: true,
+            autoDelete: true,
+        };
+    }
+}
+exports.RabbitMqPublisher = RabbitMqPublisher;

package/dist/subscriber.d.ts

@@ -0,0 +1,19 @@
+import * as amqp from "amqplib";
+import { IRabbitMqConnectionFactory } from "./connectionFactory";
+import { IQueueNameConfig } from "./common";
+import { Logger } from "./childLogger";
+export interface IRabbitMqSubscriberDisposer {
+    (): Promise<void>;
+}
+export declare class RabbitMqSubscriber {
+    private logger;
+    private connectionFactory;
+    constructor(logger: Logger, connectionFactory: IRabbitMqConnectionFactory);
+    subscribe<T>(queue: string | IQueueNameConfig, action: (message: T) => Promise<IRabbitMqSubscriberDisposer>, options?: Partial<IQueueNameConfig>): Promise<IRabbitMqSubscriberDisposer>;
+    private setupChannel;
+    private subscribeToChannel;
+    protected getMessageObject<T>(message: amqp.Message): T;
+    protected getChannelSetup(channel: amqp.Channel, queueConfig: IQueueNameConfig): Promise<string>;
+    protected getQueueSettings(): amqp.Options.AssertQueue;
+    protected getDLSettings(): amqp.Options.AssertQueue;
+}

package/dist/subscriber.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RabbitMqSubscriber = void 0;
+const common_1 = require("./common");
+const childLogger_1 = require("./childLogger");
+class RabbitMqSubscriber {
+    constructor(logger, connectionFactory) {
+        this.logger = logger;
+        this.connectionFactory = connectionFactory;
+        this.logger = childLogger_1.createChildLogger(logger, "RabbitMqConsumer");
+    }
+    subscribe(queue, action, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queueConfig = common_1.asPubSubQueueNameConfig(queue);
+            const connection = yield this.connectionFactory.create();
+            const channel = yield connection.createChannel();
+            if (options === null || options === void 0 ? void 0 : options.prefetch) {
+                yield channel.prefetch(options.prefetch, options.globalPrefetch);
+            }
+            this.logger.trace("got channel for queue '%s'", queueConfig.name);
+            const queueName = yield this.setupChannel(channel, Object.assign(Object.assign({}, queueConfig), options));
+            this.logger.debug("queue name generated for subscription queue '(%s)' is '(%s)'", queueConfig.name, queueName);
+            const queConfig = Object.assign(Object.assign({}, queueConfig), { dlq: queueName });
+            return this.subscribeToChannel(channel, queConfig, action);
+        });
+    }
+    setupChannel(channel, queueConfig) {
+        this.logger.trace("setup '%j'", queueConfig);
+        return this.getChannelSetup(channel, queueConfig);
+    }
+    subscribeToChannel(channel, queueConfig, action) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.trace("subscribing to queue '%s'", queueConfig.name);
+            const opts = yield channel.consume(queueConfig.dlq, (message) => __awaiter(this, void 0, void 0, function* () {
+                let msg = this.getMessageObject(message);
+                this.logger.trace("message arrived from queue '%s' (%j)", queueConfig.name, msg);
+                try {
+                    const disposer = yield action(msg);
+                    this.logger.trace("message processed from queue '%s' (%j)", queueConfig.name, msg);
+                    channel.ack(message);
+                    return disposer;
+                }
+                catch (err) {
+                    this.logger.error(err, "message processing failed from queue '%j' (%j)", queueConfig, msg);
+                    channel.nack(message, false, false);
+                    throw err;
+                }
+            }));
+            this.logger.trace("subscribed to queue '%s' (%s)", queueConfig.name, opts.consumerTag);
+            return (() => __awaiter(this, void 0, void 0, function* () {
+                this.logger.trace("disposing subscriber to queue '%s' (%s)", queueConfig.name, opts.consumerTag);
+                yield channel.close();
+            }));
+        });
+    }
+    getMessageObject(message) {
+        return JSON.parse(message.content.toString("utf8"));
+    }
+    getChannelSetup(channel, queueConfig) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield channel.assertExchange(queueConfig.dlx, "fanout", this.getDLSettings());
+            let result = yield channel.assertQueue(queueConfig.strictName ? queueConfig.name : queueConfig.dlq, this.getQueueSettings());
+            yield channel.bindQueue(result.queue, queueConfig.dlx, "");
+            return result.queue;
+        });
+    }
+    getQueueSettings() {
+        return {
+            exclusive: false,
+            autoDelete: true,
+        };
+    }
+    getDLSettings() {
+        return {
+            durable: true,
+            autoDelete: true,
+        };
+    }
+}
+exports.RabbitMqSubscriber = RabbitMqSubscriber;

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@rxdi/rabbitmq-pubsub",
+  "version": "0.7.118",
+  "description": "A graphql-subscriptions PubSub Engine using RabbitMQ",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rxdi/graphql-rabbitmq-subscriptions.git"
+  },
+  "keywords": [
+    "graphql",
+    "rabbitmq",
+    "apollo",
+    "subscriptions"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/rxdi/graphql-rabbitmq-subscriptions/issues"
+  },
+  "homepage": "https://github.com/rxdi/graphql-rabbitmq-subscriptions",
+  "scripts": {
+    "test": "echo Test rabbitmq subscriptions",
+    "build": "tsc || true",
+    "lint": "tslint ./src/**/*.ts"
+  },
+  "dependencies": {
+    "amqplib": "^0.6.0"
+  },
+  "devDependencies": {
+    "@types/amqplib": "^0.5.17",
+    "@types/node": "^12.0.10",
+    "tslint": "^5.20.1",
+    "typescript": "^3.9.3"
+  },
+  "typings": "dist/index.d.ts",
+  "typescript": {
+    "definition": "dist/index.d.ts"
+  }
+}