@rxdi/graphql-rabbitmq-subscriptions 0.7.192 → 0.7.194

package/dist/amqp-pubsub.d.ts

@@ -14,6 +14,7 @@ export declare class AmqpPubSub {
     private currentSubscriptionId;
     private triggerTransform;
     private unsubscribeChannelMap;
+    private pendingSubscriptions;
     private logger;
     constructor(options?: PubSubRabbitMQBusOptions);
     publish(trigger: string, payload: any, config?: IQueueNameConfig): Promise<void>;

package/dist/amqp-pubsub.js

@@ -15,17 +15,18 @@ const rabbitmq_pubsub_1 = require("@rxdi/rabbitmq-pubsub");
 const child_logger_1 = require("./child-logger");
 class AmqpPubSub {
     constructor(options = {}) {
-        this.subscriptionMap = {};
-        this.subsRefsMap = {};
+        this.subscriptionMap = new Map();
+        this.subsRefsMap = new Map();
         this.currentSubscriptionId = 0;
-        this.unsubscribeChannelMap = {};
+        this.unsubscribeChannelMap = new Map();
+        // Track in-progress subscriptions to prevent race conditions
+        this.pendingSubscriptions = new Map();
         this.triggerTransform = options.triggerTransform || ((trigger) => trigger);
         const config = options.config || { host: '127.0.0.1', port: 5672 };
-        const { logger } = options;
-        this.logger = (0, child_logger_1.createChildLogger)(logger, 'AmqpPubSub');
-        const factory = new rabbitmq_pubsub_1.RabbitMqSingletonConnectionFactory(logger, config);
-        this.consumer = new rabbitmq_pubsub_1.RabbitMqSubscriber(logger, factory);
-        this.producer = new rabbitmq_pubsub_1.RabbitMqPublisher(logger, factory);
+        this.logger = (0, child_logger_1.createChildLogger)(options.logger, 'AmqpPubSub');
+        const factory = new rabbitmq_pubsub_1.RabbitMqSingletonConnectionFactory(options.logger, config);
+        this.consumer = new rabbitmq_pubsub_1.RabbitMqSubscriber(options.logger, factory);
+        this.producer = new rabbitmq_pubsub_1.RabbitMqPublisher(options.logger, factory);
     }
     publish(trigger, payload, config) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -37,71 +38,93 @@ class AmqpPubSub {
         return __awaiter(this, void 0, void 0, function* () {
             const triggerName = this.triggerTransform(trigger, options);
             const id = this.currentSubscriptionId++;
-            this.subscriptionMap[id] = [triggerName, onMessage];
-            let refs = this.subsRefsMap[triggerName];
-            if (refs && refs.length > 0) {
-                const newRefs = [...refs, id];
-                this.subsRefsMap[triggerName] = newRefs;
-                this.logger.trace("subscriber exist, adding triggerName '%s' to saved list.", triggerName);
+            this.subscriptionMap.set(id, [triggerName, onMessage]);
+            const refs = this.subsRefsMap.get(triggerName);
+            if (refs === null || refs === void 0 ? void 0 : refs.length) {
+                this.subsRefsMap.set(triggerName, [...refs, id]);
+                this.logger.trace("subscriber exists, adding triggerName '%s' to saved list.", triggerName);
                 return id;
             }
+            // Subscription already in progress
+            const pending = this.pendingSubscriptions.get(triggerName);
+            if (pending) {
+                this.logger.trace("subscription in progress for '%s', waiting for it to complete", triggerName);
+                try {
+                    const disposer = yield pending;
+                    const nextRefs = [...(this.subsRefsMap.get(triggerName) || []), id];
+                    this.subsRefsMap.set(triggerName, nextRefs);
+                    this.unsubscribeChannelMap.set(triggerName, disposer);
+                    return id;
+                }
+                catch (err) {
+                    this.logger.error(err, "failed to receive message from queue '%s'", triggerName);
+                    return id;
+                }
+            }
             this.logger.trace("trying to subscribe to queue '%s'", triggerName);
+            const subscriptionPromise = this.consumer.subscribe(triggerName, (msg) => this.onMessage(triggerName, msg), options);
+            this.pendingSubscriptions.set(triggerName, subscriptionPromise);
             try {
-                const disposer = yield this.consumer.subscribe(triggerName, (msg) => this.onMessage(triggerName, msg), options);
-                this.subsRefsMap[triggerName] = [...(this.subsRefsMap[triggerName] || []), id];
-                this.unsubscribeChannelMap[id] = disposer;
+                const disposer = yield subscriptionPromise;
+                this.subsRefsMap.set(triggerName, [...(this.subsRefsMap.get(triggerName) || []), id]);
+                this.unsubscribeChannelMap.set(triggerName, disposer);
+                this.pendingSubscriptions.delete(triggerName);
                 return id;
             }
             catch (err) {
-                this.logger.error(err, "failed to recieve message from queue '%s'", triggerName);
+                this.logger.error(err, "failed to receive message from queue '%s'", triggerName);
+                this.pendingSubscriptions.delete(triggerName);
                 return id;
             }
         });
     }
     unsubscribe(subId) {
-        const [triggerName = null] = this.subscriptionMap[subId] || [];
-        const refs = this.subsRefsMap[triggerName];
-        if (!refs) {
+        const entry = this.subscriptionMap.get(subId);
+        const triggerName = entry === null || entry === void 0 ? void 0 : entry[0];
+        if (!triggerName) {
             this.logger.error("There is no subscription of id '%s'", subId);
             throw new Error(`There is no subscription of id "${subId}"`);
         }
-        let newRefs;
+        const refs = this.subsRefsMap.get(triggerName);
+        if (!refs)
+            return;
         if (refs.length === 1) {
-            newRefs = [];
-            if (typeof this.unsubscribeChannelMap[subId] === 'function') {
-                this.unsubscribeChannelMap[subId]()
+            const disposer = this.unsubscribeChannelMap.get(triggerName);
+            if (typeof disposer === 'function') {
+                disposer()
                     .then(() => {
                     this.logger.trace("cancelled channel from subscribing to queue '%s'", triggerName);
                 })
                     .catch((err) => {
-                    this.logger.error(err, "channel cancellation failed from queue '%j'", triggerName);
+                    this.logger.error(err, "channel cancellation failed from queue '%s'", triggerName);
+                })
+                    .finally(() => {
+                    this.unsubscribeChannelMap.delete(triggerName);
                 });
             }
+            this.subsRefsMap.delete(triggerName);
         }
         else {
-            const index = refs.indexOf(subId);
-            if (index !== -1) {
-                newRefs = [...refs.slice(0, index), ...refs.slice(index + 1)];
-            }
-            this.logger.trace("removing triggerName from listening '%s' ", triggerName);
+            this.subsRefsMap.set(triggerName, refs.filter((id) => id !== subId));
+            this.logger.trace("removing triggerName from listening '%s'", triggerName);
         }
-        this.subsRefsMap[triggerName] = newRefs;
-        delete this.subscriptionMap[subId];
-        this.logger.trace("list of subscriptions still available '(%j)'", this.subscriptionMap);
+        this.subscriptionMap.delete(subId);
+        this.logger.trace("list of subscriptions still available '(%j)'", Array.from(this.subscriptionMap.entries()));
     }
     asyncIterator(triggers, options) {
         return new pubsub_async_iterator_1.PubSubAsyncIterator(this, triggers, options);
     }
     onMessage(channel, message) {
         return __awaiter(this, void 0, void 0, function* () {
-            const subscribers = this.subsRefsMap[channel];
-            // Don't work for nothing..
-            if (!subscribers || !subscribers.length) {
+            const subscribers = this.subsRefsMap.get(channel);
+            if (!(subscribers === null || subscribers === void 0 ? void 0 : subscribers.length))
                 return;
-            }
             this.logger.trace("sending message to subscriber callback function '(%j)'", message);
             for (const subId of subscribers) {
-                const [triggerName, listener] = this.subscriptionMap[subId];
+                const entry = this.subscriptionMap.get(subId);
+                if (!entry)
+                    continue;
+                const [, listener] = entry;
                 yield listener(message);
             }
         });

package/dist/index.d.ts

@@ -1 +1,3 @@
 export { AmqpPubSub } from './amqp-pubsub';
+import { FilterFn, ResolverFn } from 'graphql-subscriptions';
+export declare function withFilter<T>(this: T, asyncIteratorFn: ResolverFn<any, any, any>, filterFn: FilterFn<any, any, any>): import("graphql-subscriptions").IterableResolverFn<any, any, any>;

package/dist/index.js

@@ -1,5 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AmqpPubSub = void 0;
+exports.withFilter = withFilter;
 var amqp_pubsub_1 = require("./amqp-pubsub");
 Object.defineProperty(exports, "AmqpPubSub", { enumerable: true, get: function () { return amqp_pubsub_1.AmqpPubSub; } });
+const graphql_subscriptions_1 = require("graphql-subscriptions");
+function withFilter(asyncIteratorFn, filterFn) {
+    return (0, graphql_subscriptions_1.withFilter)(asyncIteratorFn, filterFn);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rxdi/graphql-rabbitmq-subscriptions",
-  "version": "0.7.192",
+  "version": "0.7.194",
   "description": "A graphql-subscriptions PubSub Engine using RabbitMQ",
   "main": "dist/index.js",
   "repository": {
@@ -24,7 +24,7 @@
     "lint": "tslint ./src/**/*.ts"
   },
   "dependencies": {
-    "@rxdi/rabbitmq-pubsub": "^0.7.191",
+    "@rxdi/rabbitmq-pubsub": "^0.7.193",
     "graphql-subscriptions": "^3.0.0"
   },
   "devDependencies": {