@tsed/bullmq 7.38.0

package/lib/types/decorators/Job.d.ts

@@ -0,0 +1,2 @@
+import { JobsOptions } from "bullmq";
+export declare function Job(name: string, queue?: string, opts?: JobsOptions): any;

package/lib/types/decorators/JobController.d.ts

@@ -0,0 +1,2 @@
+import { JobsOptions } from "bullmq";
+export declare function JobController(name: string, queue?: string, opts?: JobsOptions): any;

package/lib/types/decorators/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+export * from "./JobController";

package/lib/types/dispatchers/JobDispatcher.d.ts

@@ -0,0 +1,9 @@
+import { InjectorService } from "@tsed/di";
+import { JobMethods } from "../contracts";
+import { Type } from "@tsed/core";
+import { Job as BullMQJob } from "bullmq";
+export declare class JobDispatcher {
+    private readonly injector;
+    constructor(injector: InjectorService);
+    dispatch<T extends JobMethods>(job: Type<JobMethods>, payload?: Parameters<T["handle"]>[0]): Promise<BullMQJob>;
+}

package/lib/types/dispatchers/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+export * from "./JobDispatcher";

package/lib/types/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @file Automatically generated by barrelsby.
+ */
+export * from "./BullMQModule";
+export * from "./config/config";
+export * from "./contracts/JobMethods";
+export * from "./contracts/JobStore";
+export * from "./decorators/JobController";
+export * from "./dispatchers/JobDispatcher";

package/lib/types/processors/ProcessorFactory.d.ts

@@ -0,0 +1,7 @@
+import { InjectorService } from "@tsed/di";
+import { Processor } from "bullmq";
+export default class ProcessorFactory {
+    private readonly injector;
+    constructor(injector: InjectorService);
+    build(): Processor;
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@tsed/bullmq",
+  "version": "7.38.0",
+  "description": "BullMQ integration for Ts.ED",
+  "keywords": [
+    "Ts.ED",
+    "BullMQ"
+  ],
+  "source": "./src/index.ts",
+  "main": "./lib/cjs/index.js",
+  "module": "./lib/esm/index.js",
+  "typings": "./lib/types/index.d.ts",
+  "exports": {
+    "types": "./lib/types/index.d.ts",
+    "import": "./lib/esm/index.js",
+    "require": "./lib/cjs/index.js",
+    "default": "./lib/esm/index.js"
+  },
+  "scripts": {
+    "build": "yarn barrels && yarn build:ts",
+    "barrels": "yarn barrelsby --config .barrelsby.json",
+    "test": "cross-env NODE_ENV=test yarn jest --runInBand && jest-coverage-thresholds-bumper",
+    "build:ts": "tsc --build tsconfig.json && tsc --build tsconfig.esm.json",
+    "lint": "eslint '**/*.{ts,js}'",
+    "lint:fix": "eslint '**/*.{ts,js}' --fix"
+  },
+  "dependencies": {
+    "tslib": "2.5.0"
+  },
+  "devDependencies": {
+    "@tsed/common": "7.38.0",
+    "@tsed/core": "7.38.0",
+    "@tsed/di": "7.38.0",
+    "@tsed/eslint": "7.38.0",
+    "@tsed/schema": "7.38.0",
+    "@tsed/typescript": "7.38.0",
+    "bullmq": "^4.12.3",
+    "eslint": "^8.12.0",
+    "ts-mockito": "^2.6.1"
+  },
+  "peerDependencies": {
+    "bullmq": "^4.12.3"
+  },
+  "repository": "https://github.com/tsedio/tsed",
+  "bugs": {
+    "url": "https://github.com/tsedio/tsed/issues"
+  },
+  "homepage": "https://github.com/tsedio/tsed/tree/production/packages/third-parties/bullmq",
+  "author": "Romain Lenzotti",
+  "license": "MIT"
+}

package/src/BullMQModule.js

@@ -0,0 +1,149 @@
+"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 __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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BullMQModule = void 0;
+var common_1 = require("@tsed/common");
+var di_1 = require("@tsed/di");
+var schema_1 = require("@tsed/schema");
+var bullmq_1 = require("bullmq");
+var uuid_1 = require("uuid");
+var BullMQModule = /** @class */ (function () {
+    function BullMQModule(injector, dispatcher) {
+        this.injector = injector;
+        this.dispatcher = dispatcher;
+    }
+    BullMQModule.prototype.$beforeInit = function () {
+        var _this = this;
+        this.buildWorkers();
+        this.buildQueues();
+        this.injector.getMany("bullmq:cron").map(function (job) { return _this.dispatcher.dispatch((0, schema_1.getComputedType)(job)); });
+    };
+    BullMQModule.prototype.buildQueues = function () {
+        var _this = this;
+        this.bullmq.queues.forEach(function (queue) {
+            _this.injector
+                .add("bullmq.queue.".concat(queue), {
+                type: "bullmq:queue",
+                useValue: new bullmq_1.Queue(queue, {
+                    connection: _this.bullmq.connection,
+                    defaultJobOptions: _this.bullmq.defaultJobOptions
+                }),
+                hooks: {
+                    $onDestroy: function (queue) { return queue.close(); }
+                }
+            })
+                .invoke("bullmq.queue.".concat(queue));
+        });
+    };
+    BullMQModule.prototype.buildWorkers = function () {
+        var _this = this;
+        var _a;
+        ((_a = this.bullmq.workerQueues) !== null && _a !== void 0 ? _a : this.bullmq.queues).forEach(function (queue) {
+            _this.injector
+                .add("bullmq.worker.".concat(queue), {
+                type: "bullmq:worker",
+                useValue: new bullmq_1.Worker(queue, _this.onProcess.bind(_this), {
+                    connection: _this.bullmq.connection
+                }),
+                hooks: {
+                    $onDestroy: function (worker) { return worker.close(); }
+                }
+            })
+                .invoke("bullmq.worker.".concat(queue));
+        });
+    };
+    BullMQModule.prototype.getJob = function (name, queueName) {
+        return this.injector.get("bullmq.job.".concat(queueName, ".").concat(name));
+    };
+    BullMQModule.prototype.onProcess = function (job) {
+        return __awaiter(this, void 0, void 0, function () {
+            var jobService, $ctx, er_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jobService = this.getJob(job.name, job.queueName);
+                        if (!jobService) {
+                            this.injector.logger.warn({
+                                event: "BULLMQ_JOB_NOT_FOUND",
+                                message: "Job ".concat(job.name, " ").concat(job.queueName, " not found")
+                            });
+                            return [2 /*return*/];
+                        }
+                        $ctx = new common_1.DIContext({
+                            injector: this.injector,
+                            logger: this.injector.logger,
+                            id: job.id || (0, uuid_1.v4)().split("-").join("")
+                        });
+                        $ctx.set("BULLMQ_JOB", job);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, 4, 6]);
+                        return [4 /*yield*/, (0, common_1.runInContext)($ctx, function () { return jobService.handle(job.data, job); })];
+                    case 2: return [2 /*return*/, _a.sent()];
+                    case 3:
+                        er_1 = _a.sent();
+                        $ctx.logger.error({
+                            event: "BULLMQ_JOB_ERROR",
+                            message: er_1.message,
+                            stack: er_1.stack
+                        });
+                        throw er_1;
+                    case 4: return [4 /*yield*/, $ctx.destroy()];
+                    case 5:
+                        _a.sent();
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    __decorate([
+        (0, di_1.Constant)("bullmq")
+    ], BullMQModule.prototype, "bullmq", void 0);
+    BullMQModule = __decorate([
+        (0, di_1.Module)()
+    ], BullMQModule);
+    return BullMQModule;
+}());
+exports.BullMQModule = BullMQModule;

package/src/BullMQModule.spec.js

@@ -0,0 +1,236 @@
+"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 __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());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var common_1 = require("@tsed/common");
+var core_1 = require("@tsed/core");
+var bullmq_1 = require("bullmq");
+var ts_mockito_1 = require("ts-mockito");
+require("./BullMQModule");
+var BullMQModule_1 = require("./BullMQModule");
+var decorators_1 = require("./decorators");
+var dispatchers_1 = require("./dispatchers");
+jest.mock("bullmq", function () {
+    return {
+        Queue: /** @class */ (function () {
+            function class_1(name) {
+                this.name = name;
+            }
+            class_1.prototype.close = function () { };
+            return class_1;
+        }()),
+        Worker: /** @class */ (function () {
+            function class_2(name) {
+                this.name = name;
+            }
+            class_2.prototype.close = function () { };
+            return class_2;
+        }())
+    };
+});
+var bullmq = {
+    queues: ["default", "foo", "bar"],
+    connection: {},
+    workerQueues: ["default", "foo"]
+};
+var CustomCronJob = /** @class */ (function () {
+    function CustomCronJob() {
+    }
+    CustomCronJob.prototype.handle = function () { };
+    CustomCronJob = __decorate([
+        (0, decorators_1.JobController)("cron", "default", {
+            repeat: {
+                pattern: "* * * * *"
+            }
+        })
+    ], CustomCronJob);
+    return CustomCronJob;
+}());
+var RegularJob = /** @class */ (function () {
+    function RegularJob() {
+    }
+    RegularJob.prototype.handle = function () { };
+    RegularJob = __decorate([
+        (0, decorators_1.JobController)("regular", "default")
+    ], RegularJob);
+    return RegularJob;
+}());
+describe("module", function () {
+    var dispatcher;
+    beforeEach(function () { return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    dispatcher = (0, ts_mockito_1.mock)(dispatchers_1.JobDispatcher);
+                    (0, ts_mockito_1.when)(dispatcher.dispatch(CustomCronJob)).thenResolve();
+                    return [4 /*yield*/, common_1.PlatformTest.create({
+                            bullmq: bullmq,
+                            imports: [
+                                {
+                                    token: dispatchers_1.JobDispatcher,
+                                    use: (0, ts_mockito_1.instance)(dispatcher)
+                                }
+                            ]
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); });
+    beforeEach(function () { });
+    afterEach(common_1.PlatformTest.reset);
+    describe("cronjobs", function () {
+        it("should dispatch cron jobs", function () {
+            (0, ts_mockito_1.verify)(dispatcher.dispatch(CustomCronJob)).once();
+        });
+    });
+    describe("queues", function () {
+        it("should get default", function () {
+            var instance = common_1.PlatformTest.get("bullmq.queue.default");
+            expect(instance).toBeInstanceOf(bullmq_1.Queue);
+            expect(instance.name).toBe("default");
+        });
+        it.each(bullmq.queues)("should register queue(%s)", function (queue) {
+            var instance = common_1.PlatformTest.get("bullmq.queue.".concat(queue));
+            expect(instance).toBeInstanceOf(bullmq_1.Queue);
+            expect(instance.name).toBe(queue);
+        });
+        it("should not allow direct injection of the queue", function () {
+            expect(common_1.PlatformTest.get(bullmq_1.Queue)).not.toBeInstanceOf(bullmq_1.Queue);
+        });
+    });
+    describe("workers", function () {
+        it("should get default", function () {
+            var instance = common_1.PlatformTest.get("bullmq.worker.default");
+            expect(instance).toBeInstanceOf(bullmq_1.Worker);
+            expect(instance.name).toBe("default");
+        });
+        it.each(bullmq.workerQueues)("should register worker(%s)", function (queue) {
+            var instance = common_1.PlatformTest.get("bullmq.worker.".concat(queue));
+            expect(instance).toBeInstanceOf(bullmq_1.Worker);
+            expect(instance.name).toBe(queue);
+        });
+        it("should not register unspecified worker queue", function () {
+            expect(common_1.PlatformTest.get("bullmq.worker.bar")).toBeUndefined();
+        });
+        it("should not allow direct injection of the worker", function () {
+            expect(common_1.PlatformTest.get(bullmq_1.Worker)).not.toBeInstanceOf(bullmq_1.Worker);
+        });
+        it("should run worker and execute processor", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var bullMQModule, worker, job;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        bullMQModule = common_1.PlatformTest.get(BullMQModule_1.BullMQModule);
+                        worker = common_1.PlatformTest.get("bullmq.job.default.regular");
+                        job = {
+                            name: "regular",
+                            queueName: "default",
+                            data: { test: "test" }
+                        };
+                        jest.spyOn(worker, "handle").mockResolvedValueOnce(undefined);
+                        return [4 /*yield*/, bullMQModule.onProcess(job)];
+                    case 1:
+                        _a.sent();
+                        expect(worker.handle).toHaveBeenCalledWith({ test: "test" }, job);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should log warning when the worker doesn't exists", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var bullMQModule, job;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        bullMQModule = common_1.PlatformTest.get(BullMQModule_1.BullMQModule);
+                        jest.spyOn(common_1.PlatformTest.injector.logger, "warn");
+                        job = {
+                            name: "regular",
+                            queueName: "toto",
+                            data: { test: "test" }
+                        };
+                        return [4 /*yield*/, bullMQModule.onProcess(job)];
+                    case 1:
+                        _a.sent();
+                        expect(common_1.PlatformTest.injector.logger.warn).toHaveBeenCalledWith({
+                            event: "BULLMQ_JOB_NOT_FOUND",
+                            message: "Job regular toto not found"
+                        });
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("should run worker, execute processor and handle error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var bullMQModule, worker, job, error;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        bullMQModule = common_1.PlatformTest.get(BullMQModule_1.BullMQModule);
+                        worker = common_1.PlatformTest.get("bullmq.job.default.regular");
+                        job = {
+                            name: "regular",
+                            queueName: "default",
+                            data: { test: "test" }
+                        };
+                        jest.spyOn(common_1.PlatformTest.injector.logger, "error");
+                        jest.spyOn(worker, "handle").mockRejectedValue(new Error("error"));
+                        return [4 /*yield*/, (0, core_1.catchAsyncError)(function () { return bullMQModule.onProcess(job); })];
+                    case 1:
+                        error = _a.sent();
+                        expect(worker.handle).toHaveBeenCalledWith({ test: "test" }, job);
+                        expect(common_1.PlatformTest.injector.logger.error).toHaveBeenCalledWith({
+                            duration: expect.any(Number),
+                            event: "BULLMQ_JOB_ERROR",
+                            message: "error",
+                            reqId: expect.any(String),
+                            stack: expect.any(String),
+                            time: expect.any(Object)
+                        });
+                        expect(error === null || error === void 0 ? void 0 : error.message).toEqual("error");
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});

package/src/BullMQModule.spec.ts

@@ -0,0 +1,184 @@
+import {PlatformTest} from "@tsed/common";
+import {catchAsyncError} from "@tsed/core";
+import {Queue, Worker} from "bullmq";
+import {instance, mock, verify, when} from "ts-mockito";
+
+import "./BullMQModule";
+import {BullMQModule} from "./BullMQModule";
+import {type BullMQConfig} from "./config/config";
+import {JobMethods} from "./contracts";
+import {JobController} from "./decorators";
+import {JobDispatcher} from "./dispatchers";
+
+jest.mock("bullmq", () => {
+  return {
+    Queue: class {
+      public name: string;
+
+      constructor(name: string) {
+        this.name = name;
+      }
+      close() {}
+    },
+    Worker: class {
+      public name: string;
+
+      constructor(name: string) {
+        this.name = name;
+      }
+      close() {}
+    }
+  };
+});
+
+const bullmq = {
+  queues: ["default", "foo", "bar"],
+  connection: {},
+  workerQueues: ["default", "foo"]
+} as BullMQConfig;
+
+@JobController("cron", "default", {
+  repeat: {
+    pattern: "* * * * *"
+  }
+})
+class CustomCronJob implements JobMethods {
+  handle() {}
+}
+
+@JobController("regular", "default")
+class RegularJob {
+  handle() {}
+}
+
+describe("module", () => {
+  let dispatcher: JobDispatcher;
+  beforeEach(async () => {
+    dispatcher = mock(JobDispatcher);
+    when(dispatcher.dispatch(CustomCronJob)).thenResolve();
+
+    await PlatformTest.create({
+      bullmq,
+      imports: [
+        {
+          token: JobDispatcher,
+          use: instance(dispatcher)
+        }
+      ]
+    });
+  });
+  beforeEach(() => {});
+  afterEach(PlatformTest.reset);
+
+  describe("cronjobs", () => {
+    it("should dispatch cron jobs", () => {
+      verify(dispatcher.dispatch(CustomCronJob)).once();
+    });
+  });
+
+  describe("queues", () => {
+    it("should get default", () => {
+      const instance = PlatformTest.get<Queue>("bullmq.queue.default");
+
+      expect(instance).toBeInstanceOf(Queue);
+      expect(instance.name).toBe("default");
+    });
+
+    it.each(bullmq.queues)("should register queue(%s)", (queue) => {
+      const instance = PlatformTest.get<Queue>(`bullmq.queue.${queue}`);
+
+      expect(instance).toBeInstanceOf(Queue);
+      expect(instance.name).toBe(queue);
+    });
+
+    it("should not allow direct injection of the queue", () => {
+      expect(PlatformTest.get(Queue)).not.toBeInstanceOf(Queue);
+    });
+  });
+
+  describe("workers", () => {
+    it("should get default", () => {
+      const instance = PlatformTest.get<Worker>("bullmq.worker.default");
+
+      expect(instance).toBeInstanceOf(Worker);
+      expect(instance.name).toBe("default");
+    });
+
+    it.each(bullmq.workerQueues)("should register worker(%s)", (queue) => {
+      const instance = PlatformTest.get<Worker>(`bullmq.worker.${queue}`);
+
+      expect(instance).toBeInstanceOf(Worker);
+      expect(instance.name).toBe(queue);
+    });
+
+    it("should not register unspecified worker queue", () => {
+      expect(PlatformTest.get("bullmq.worker.bar")).toBeUndefined();
+    });
+
+    it("should not allow direct injection of the worker", () => {
+      expect(PlatformTest.get(Worker)).not.toBeInstanceOf(Worker);
+    });
+
+    it("should run worker and execute processor", async () => {
+      const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
+      const worker = PlatformTest.get<JobMethods>("bullmq.job.default.regular");
+      const job = {
+        name: "regular",
+        queueName: "default",
+        data: {test: "test"}
+      };
+
+      jest.spyOn(worker, "handle").mockResolvedValueOnce(undefined as never);
+
+      await (bullMQModule as any).onProcess(job);
+
+      expect(worker.handle).toHaveBeenCalledWith({test: "test"}, job);
+    });
+
+    it("should log warning when the worker doesn't exists", async () => {
+      const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
+
+      jest.spyOn(PlatformTest.injector.logger, "warn");
+
+      const job = {
+        name: "regular",
+        queueName: "toto",
+        data: {test: "test"}
+      };
+
+      await (bullMQModule as any).onProcess(job);
+
+      expect(PlatformTest.injector.logger.warn).toHaveBeenCalledWith({
+        event: "BULLMQ_JOB_NOT_FOUND",
+        message: "Job regular toto not found"
+      });
+    });
+
+    it("should run worker, execute processor and handle error", async () => {
+      const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
+      const worker = PlatformTest.get<JobMethods>("bullmq.job.default.regular");
+      const job = {
+        name: "regular",
+        queueName: "default",
+        data: {test: "test"}
+      };
+
+      jest.spyOn(PlatformTest.injector.logger, "error");
+
+      jest.spyOn(worker, "handle").mockRejectedValue(new Error("error") as never);
+
+      const error = await catchAsyncError(() => (bullMQModule as any).onProcess(job));
+
+      expect(worker.handle).toHaveBeenCalledWith({test: "test"}, job);
+      expect(PlatformTest.injector.logger.error).toHaveBeenCalledWith({
+        duration: expect.any(Number),
+        event: "BULLMQ_JOB_ERROR",
+        message: "error",
+        reqId: expect.any(String),
+        stack: expect.any(String),
+        time: expect.any(Object)
+      });
+      expect(error?.message).toEqual("error");
+    });
+  });
+});