@onebun/core 0.2.14 → 0.2.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onebun/core",
-  "version": "0.2.14",
+  "version": "0.2.15",
   "description": "Core package for OneBun framework - decorators, DI, modules, controllers",
   "license": "LGPL-3.0",
   "author": "RemRyahirev",

package/src/queue/decorators.test.ts

@@ -189,6 +189,48 @@ describe('queue-decorators', () => {
       expect(handlers[0].propertyKey).toBe('handleReady');
     });
 
+    it('should support multiple @OnQueueReady handlers in one class', () => {
+      class TestService {
+        @OnQueueReady()
+        handleReady1() {}
+
+        @OnQueueReady()
+        handleReady2() {}
+      }
+
+      const handlers = getLifecycleHandlers(TestService, 'ON_READY');
+      expect(handlers.length).toBe(2);
+      expect(handlers[0].propertyKey).toBe('handleReady1');
+      expect(handlers[1].propertyKey).toBe('handleReady2');
+    });
+
+    it('should return empty array when no @OnQueueReady handlers', () => {
+      class TestService {
+        // eslint-disable-next-line @typescript-eslint/no-empty-function
+        handle() {}
+      }
+
+      const handlers = getLifecycleHandlers(TestService, 'ON_READY');
+      expect(handlers.length).toBe(0);
+    });
+
+    it('should not mix @OnQueueReady with other lifecycle metadata', () => {
+      class TestService {
+        @OnQueueReady()
+        handleReady() {}
+
+        @OnQueueError()
+        handleError(_error: Error) {}
+      }
+
+      const readyHandlers = getLifecycleHandlers(TestService, 'ON_READY');
+      const errorHandlers = getLifecycleHandlers(TestService, 'ON_ERROR');
+      expect(readyHandlers.length).toBe(1);
+      expect(readyHandlers[0].propertyKey).toBe('handleReady');
+      expect(errorHandlers.length).toBe(1);
+      expect(errorHandlers[0].propertyKey).toBe('handleError');
+    });
+
     it('should register @OnQueueError handler', () => {
       class TestService {
         @OnQueueError()

package/src/queue/queue.service.test.ts

@@ -13,6 +13,7 @@ import {
 import type { Message } from './types';
 
 import { InMemoryQueueAdapter } from './adapters/memory.adapter';
+import { OnQueueReady, Subscribe } from './decorators';
 import { QueueService } from './queue.service';
 
 describe('QueueService', () => {
@@ -341,6 +342,161 @@ describe('QueueService', () => {
     });
   });
 
+  describe('registerService lifecycle', () => {
+    test('should call @OnQueueReady handler when queue starts', async () => {
+      let readyCalled = false;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCalled = true;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+      expect(readyCalled).toBe(false);
+
+      await service.start();
+      expect(readyCalled).toBe(true);
+    });
+
+    test('should allow publishing from @OnQueueReady handler', async () => {
+      const received: Message[] = [];
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          service.publish('init.ready', { status: 'ok' });
+        }
+
+        @Subscribe('init.ready')
+        handleInit(_message: Message) {}
+      }
+
+      const instance = new TestService();
+
+      // Subscribe before start so the handler is in place
+      await service.subscribe('init.ready', async (message) => {
+        received.push(message);
+      });
+
+      await service.registerService(instance, TestService);
+      await service.start();
+
+      expect(received.length).toBe(1);
+      expect(received[0].data).toEqual({ status: 'ok' });
+    });
+
+    test('should call multiple @OnQueueReady handlers in order', async () => {
+      const callOrder: string[] = [];
+
+      class TestService {
+        @OnQueueReady()
+        handleReady1() {
+          callOrder.push('first');
+        }
+
+        @OnQueueReady()
+        handleReady2() {
+          callOrder.push('second');
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+      await service.start();
+
+      expect(callOrder).toEqual(['first', 'second']);
+    });
+
+    test('should call @OnQueueReady with correct this binding', async () => {
+      let capturedValue: string | null = null as string | null;
+
+      class TestService {
+        readonly name = 'test-service';
+
+        @OnQueueReady()
+        handleReady() {
+          capturedValue = this.name;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+      await service.start();
+
+      expect(capturedValue).toBe('test-service');
+    });
+
+    test('should call @OnQueueReady again after stop() and start()', async () => {
+      let readyCount = 0;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCount++;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+
+      await service.start();
+      expect(readyCount).toBe(1);
+
+      await service.stop();
+      await service.start();
+      expect(readyCount).toBe(2);
+    });
+
+    test('should call @OnQueueReady on adapter reconnect', async () => {
+      let readyCount = 0;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCount++;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+
+      await service.start();
+      expect(readyCount).toBe(1);
+
+      // Simulate reconnect without stopping the service
+      await adapter.disconnect();
+      await adapter.connect();
+      expect(readyCount).toBe(2);
+    });
+
+    test('should not call @OnQueueReady on adapter reconnect when service is stopped', async () => {
+      let readyCount = 0;
+
+      class TestService {
+        @OnQueueReady()
+        handleReady() {
+          readyCount++;
+        }
+      }
+
+      const instance = new TestService();
+      await service.registerService(instance, TestService);
+
+      await service.start();
+      expect(readyCount).toBe(1);
+
+      await service.stop();
+
+      // Reconnect while service is stopped — handler should NOT fire
+      await adapter.connect();
+      expect(readyCount).toBe(1);
+    });
+
+  });
+
   describe('error handling', () => {
     test('should handle subscription errors gracefully', async () => {
       await service.start();

package/src/queue/queue.service.ts

@@ -56,6 +56,8 @@ export class QueueService {
   private subscriptions: Subscription[] = [];
   private started = false;
   private config: QueueConfig;
+  private onReadyHandlers: Array<() => void> = [];
+  private adapterOnReadyRegistered = false;
 
   constructor(config: QueueConfig) {
     this.config = config;
@@ -86,11 +88,28 @@ export class QueueService {
       await this.adapter.connect();
     }
 
+    // Register adapter-level onReady listener once for reconnection scenarios
+    if (!this.adapterOnReadyRegistered) {
+      this.adapter.on('onReady', () => {
+        if (this.started) {
+          for (const handler of this.onReadyHandlers) {
+            handler();
+          }
+        }
+      });
+      this.adapterOnReadyRegistered = true;
+    }
+
     if (this.scheduler) {
       this.scheduler.start();
     }
 
     this.started = true;
+
+    // Call @OnQueueReady handlers — queue is fully ready at this point
+    for (const handler of this.onReadyHandlers) {
+      handler();
+    }
   }
 
   /**
@@ -359,7 +378,7 @@ export class QueueService {
     const onReadyHandlers = getMetadata(QUEUE_METADATA.ON_READY, serviceClass) || [];
     for (const handler of onReadyHandlers) {
       const method = serviceInstance[handler.propertyKey].bind(serviceInstance);
-      this.on('onReady', method);
+      this.onReadyHandlers.push(method);
     }
 
     const onErrorHandlers = getMetadata(QUEUE_METADATA.ON_ERROR, serviceClass) || [];