@hazeljs/queue 0.2.0-beta.54 → 0.2.0-beta.56

package/dist/__tests__/queue.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=queue.decorator.test.d.ts.map

package/dist/__tests__/queue.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.decorator.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/queue.decorator.test.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC"}

package/dist/__tests__/queue.decorator.test.js

@@ -0,0 +1,127 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const queue_decorator_1 = require("../queue.decorator");
+describe('Queue decorator', () => {
+    describe('@Queue', () => {
+        it('should attach metadata to a method', () => {
+            class TestProcessor {
+                handleJob() { }
+            }
+            __decorate([
+                (0, queue_decorator_1.Queue)('test-queue'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestProcessor.prototype, "handleJob", null);
+            const metadata = (0, queue_decorator_1.getQueueProcessorMetadata)(new TestProcessor());
+            expect(metadata).toHaveLength(1);
+            expect(metadata[0].queueName).toBe('test-queue');
+            expect(metadata[0].methodName).toBe('handleJob');
+            expect(metadata[0].options).toEqual({});
+        });
+        it('should attach metadata with options', () => {
+            class TestProcessor {
+                handleWelcome() { }
+            }
+            __decorate([
+                (0, queue_decorator_1.Queue)('emails', { name: 'welcome-handler' }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestProcessor.prototype, "handleWelcome", null);
+            const metadata = (0, queue_decorator_1.getQueueProcessorMetadata)(new TestProcessor());
+            expect(metadata).toHaveLength(1);
+            expect(metadata[0].queueName).toBe('emails');
+            expect(metadata[0].options).toEqual({ name: 'welcome-handler' });
+        });
+        it('should support multiple processors on the same class', () => {
+            class MultiQueueProcessor {
+                handleEmail() { }
+                handleOrder() { }
+                handleNotification() { }
+            }
+            __decorate([
+                (0, queue_decorator_1.Queue)('emails'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], MultiQueueProcessor.prototype, "handleEmail", null);
+            __decorate([
+                (0, queue_decorator_1.Queue)('orders'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], MultiQueueProcessor.prototype, "handleOrder", null);
+            __decorate([
+                (0, queue_decorator_1.Queue)('notifications'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], MultiQueueProcessor.prototype, "handleNotification", null);
+            const metadata = (0, queue_decorator_1.getQueueProcessorMetadata)(new MultiQueueProcessor());
+            expect(metadata).toHaveLength(3);
+            const queueNames = metadata.map((m) => m.queueName);
+            expect(queueNames).toContain('emails');
+            expect(queueNames).toContain('orders');
+            expect(queueNames).toContain('notifications');
+            const methodNames = metadata.map((m) => m.methodName);
+            expect(methodNames).toContain('handleEmail');
+            expect(methodNames).toContain('handleOrder');
+            expect(methodNames).toContain('handleNotification');
+        });
+        it('should support multiple methods for the same queue', () => {
+            class SameQueueProcessor {
+                handleWelcome() { }
+                handleReminder() { }
+            }
+            __decorate([
+                (0, queue_decorator_1.Queue)('emails'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], SameQueueProcessor.prototype, "handleWelcome", null);
+            __decorate([
+                (0, queue_decorator_1.Queue)('emails'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], SameQueueProcessor.prototype, "handleReminder", null);
+            const metadata = (0, queue_decorator_1.getQueueProcessorMetadata)(new SameQueueProcessor());
+            expect(metadata).toHaveLength(2);
+            expect(metadata.every((m) => m.queueName === 'emails')).toBe(true);
+        });
+    });
+    describe('getQueueProcessorMetadata', () => {
+        it('should return empty array for class without @Queue decorators', () => {
+            class PlainClass {
+                plainMethod() { }
+            }
+            const metadata = (0, queue_decorator_1.getQueueProcessorMetadata)(new PlainClass());
+            expect(metadata).toEqual([]);
+        });
+        it('should preserve target reference in metadata', () => {
+            class ProcessorWithTarget {
+                handle() { }
+            }
+            __decorate([
+                (0, queue_decorator_1.Queue)('test'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], ProcessorWithTarget.prototype, "handle", null);
+            const instance = new ProcessorWithTarget();
+            const metadata = (0, queue_decorator_1.getQueueProcessorMetadata)(instance);
+            expect(metadata[0].target).toBeDefined();
+        });
+    });
+});

package/dist/__tests__/queue.module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queue.module.test.d.ts.map

package/dist/__tests__/queue.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.module.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/queue.module.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/queue.module.test.js

@@ -0,0 +1,94 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@hazeljs/core");
+const queue_decorator_1 = require("../queue.decorator");
+const queue_module_1 = require("../queue.module");
+const queue_service_1 = require("../queue.service");
+// Mock bullmq
+jest.mock('bullmq', () => ({
+    Queue: jest.fn().mockImplementation(() => ({
+        add: jest.fn().mockResolvedValue({ id: 'job-1' }),
+        close: jest.fn().mockResolvedValue(undefined),
+    })),
+}));
+describe('QueueModule', () => {
+    beforeEach(() => {
+        core_1.Container.getInstance().clear?.();
+    });
+    describe('forRoot', () => {
+        it('should return module config with providers and exports', () => {
+            const config = queue_module_1.QueueModule.forRoot({
+                connection: { host: 'localhost', port: 6379 },
+            });
+            expect(config.module).toBe(queue_module_1.QueueModule);
+            expect(config.providers).toHaveLength(1);
+            expect(config.providers[0].provide).toBe(queue_service_1.QueueService);
+            expect(config.providers[0].useFactory).toBeDefined();
+            expect(config.exports).toContain(queue_service_1.QueueService);
+            expect(config.global).toBe(true);
+        });
+        it('should use isGlobal option', () => {
+            const config = queue_module_1.QueueModule.forRoot({
+                connection: { host: 'localhost' },
+                isGlobal: false,
+            });
+            expect(config.global).toBe(false);
+        });
+        it('should create QueueService with connection when useFactory is called', () => {
+            const config = queue_module_1.QueueModule.forRoot({
+                connection: { host: 'redis.example.com', port: 6380 },
+            });
+            const factory = config.providers[0].useFactory;
+            const service = factory();
+            expect(service).toBeInstanceOf(queue_service_1.QueueService);
+            // Service should be usable (connection was set)
+            expect(() => service.getQueue('test')).not.toThrow();
+        });
+    });
+    describe('getProcessorMetadata', () => {
+        it('should return empty array for object without @Queue decorators', () => {
+            const metadata = queue_module_1.QueueModule.getProcessorMetadata({ foo: 'bar' });
+            expect(metadata).toEqual([]);
+        });
+        it('should return processor metadata for class with @Queue decorators', () => {
+            class TestProcessor {
+                handleEmail() { }
+            }
+            __decorate([
+                (0, queue_decorator_1.Queue)('emails'),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TestProcessor.prototype, "handleEmail", null);
+            const instance = new TestProcessor();
+            const metadata = queue_module_1.QueueModule.getProcessorMetadata(instance);
+            expect(metadata).toHaveLength(1);
+            expect(metadata[0].queueName).toBe('emails');
+            expect(metadata[0].methodName).toBe('handleEmail');
+            expect(metadata[0].options).toEqual({});
+        });
+    });
+    describe('getQueueService', () => {
+        it('should throw when QueueService is not in container', () => {
+            // Register undefined so resolve returns undefined (container auto-resolves classes otherwise)
+            core_1.Container.getInstance().register(queue_service_1.QueueService, undefined);
+            expect(() => queue_module_1.QueueModule.getQueueService()).toThrow('QueueService not found. Ensure QueueModule is imported.');
+        });
+        it('should return QueueService when registered in container', () => {
+            const service = new queue_service_1.QueueService();
+            service.setConnection({ host: 'localhost' });
+            core_1.Container.getInstance().register(queue_service_1.QueueService, service);
+            const resolved = queue_module_1.QueueModule.getQueueService();
+            expect(resolved).toBe(service);
+        });
+    });
+});

package/dist/__tests__/queue.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queue.service.test.d.ts.map

package/dist/__tests__/queue.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"queue.service.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/queue.service.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/queue.service.test.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const queue_service_1 = require("../queue.service");
+// Mock bullmq
+const mockAdd = jest.fn();
+const mockClose = jest.fn();
+jest.mock('bullmq', () => ({
+    Queue: jest.fn().mockImplementation(() => ({
+        add: mockAdd,
+        close: mockClose,
+    })),
+}));
+describe('QueueService', () => {
+    let service;
+    const connection = { host: 'localhost', port: 6379 };
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockAdd.mockResolvedValue({ id: 'job-123' });
+        mockClose.mockResolvedValue(undefined);
+        service = new queue_service_1.QueueService();
+        service.setConnection(connection);
+    });
+    describe('setConnection', () => {
+        it('should store connection options', () => {
+            const svc = new queue_service_1.QueueService();
+            svc.setConnection(connection);
+            expect(() => svc.getQueue('test')).not.toThrow();
+        });
+    });
+    describe('getQueue', () => {
+        it('should throw when connection is not configured', () => {
+            const svc = new queue_service_1.QueueService();
+            expect(() => svc.getQueue('test')).toThrow('QueueService not configured. Call setConnection() or use QueueModule.forRoot()');
+        });
+        it('should create and return a queue for the given name', () => {
+            const queue = service.getQueue('my-queue');
+            expect(queue).toBeDefined();
+            expect(queue.add).toBeDefined();
+        });
+        it('should reuse existing queue for same name', () => {
+            const queue1 = service.getQueue('reused');
+            const queue2 = service.getQueue('reused');
+            expect(queue1).toBe(queue2);
+        });
+        it('should create different queues for different names', () => {
+            const queue1 = service.getQueue('queue-a');
+            const queue2 = service.getQueue('queue-b');
+            expect(queue1).not.toBe(queue2);
+        });
+    });
+    describe('add', () => {
+        it('should add a job and return id', async () => {
+            const result = await service.add('emails', 'welcome', { userId: '1', email: 'a@b.com' });
+            expect(result).toEqual({ id: 'job-123' });
+            expect(mockAdd).toHaveBeenCalledWith('welcome', { userId: '1', email: 'a@b.com' }, undefined);
+        });
+        it('should add job with empty object when data is undefined', async () => {
+            await service.add('tasks', 'run');
+            expect(mockAdd).toHaveBeenCalledWith('run', {}, undefined);
+        });
+        it('should pass job options to BullMQ', async () => {
+            await service.add('tasks', 'process', { id: 1 }, { delay: 5000, priority: 10 });
+            expect(mockAdd).toHaveBeenCalledWith('process', { id: 1 }, {
+                delay: 5000,
+                priority: 10,
+            });
+        });
+    });
+    describe('addDelayed', () => {
+        it('should add job with delay', async () => {
+            await service.addDelayed('emails', 'reminder', { userId: '1' }, 3000);
+            expect(mockAdd).toHaveBeenCalledWith('reminder', { userId: '1' }, { delay: 3000 });
+        });
+    });
+    describe('addWithRetry', () => {
+        it('should add job with retry options', async () => {
+            await service.addWithRetry('orders', 'process', { orderId: 'o1' }, {
+                attempts: 3,
+                backoff: { type: 'exponential', delay: 1000 },
+            });
+            expect(mockAdd).toHaveBeenCalledWith('process', { orderId: 'o1' }, {
+                attempts: 3,
+                backoff: { type: 'exponential', delay: 1000 },
+            });
+        });
+    });
+    describe('close', () => {
+        it('should close all queues', async () => {
+            service.getQueue('q1');
+            service.getQueue('q2');
+            await service.close();
+            expect(mockClose).toHaveBeenCalledTimes(2);
+        });
+        it('should clear queues map after close', async () => {
+            service.getQueue('q1');
+            await service.close();
+            // After close, getQueue would create new instance - we verify close was called
+            expect(mockClose).toHaveBeenCalled();
+        });
+    });
+});

package/dist/queue.service.js

@@ -92,5 +92,5 @@ let QueueService = class QueueService {
 };
 exports.QueueService = QueueService;
 exports.QueueService = QueueService = __decorate([
-    (0, core_1.Injectable)()
+    (0, core_1.Service)()
 ], QueueService);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/queue",
-  "version": "0.2.0-beta.54",
+  "version": "0.2.0-beta.56",
   "description": "Redis-backed job queue module for HazelJS framework using BullMQ",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -58,5 +58,5 @@
       "description": "Required for Redis connection. BullMQ uses ioredis for Redis connectivity."
     }
   },
-  "gitHead": "c593ce33447cdc62d7bd2386cc2db47840292fcb"
+  "gitHead": "c2737e90974458a8438eee623726f0a453b66b8b"
 }