@tsed/bullmq 7.47.1 → 7.49.0

package/lib/types/config/config.d.ts

@@ -1,10 +1,49 @@
-import { type ConnectionOptions, type DefaultJobOptions } from "bullmq";
+import type { ConnectionOptions, DefaultJobOptions, QueueOptions, WorkerOptions } from "bullmq";
 export type BullMQConfig = {
+    /**
+     * Specify queue name's to create
+     */
     queues: string[];
+    /**
+     * Default connection to use for queue's and worker's
+     */
     connection: ConnectionOptions;
+    /**
+     * @deprecated Use defaultQueueOptions instead. Will be removed in the next major release
+     */
     defaultJobOptions?: DefaultJobOptions;
+    /**
+     * Default queue options which are applied to every queue
+     *
+     * Can be extended/overridden by `queueOptions`
+     */
+    defaultQueueOptions?: QueueOptions;
+    /**
+     * Specify additional queue options by queue name
+     */
+    queueOptions?: Record<string, QueueOptions>;
+    /**
+     * Disable the creation of any worker.
+     *
+     * All other worker configuration will be ignored
+     */
     disableWorker?: boolean;
+    /**
+     * Specify for which queues to start a worker for.
+     *
+     * Defaultly for every queue added in the `queues` parameter
+     */
     workerQueues?: string[];
+    /**
+     * Default worker options which are applied to every worker
+     *
+     * Can be extended/overridden by `workerOptions`
+     */
+    defaultWorkerOptions?: WorkerOptions;
+    /**
+     * Specify additional worker options by queue name
+     */
+    workerOptions?: Record<string, WorkerOptions>;
 };
 declare global {
     namespace TsED {

package/lib/types/contracts/JobMethods.d.ts

@@ -1,3 +1,4 @@
-export interface JobMethods {
-    handle(payload: unknown): unknown;
+import { Job } from "bullmq";
+export interface JobMethods<DataType = unknown, ReturnType = unknown> {
+    handle(payload: DataType, job: Job<DataType, ReturnType>): ReturnType | Promise<ReturnType>;
 }

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

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

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

@@ -2,8 +2,12 @@ import { InjectorService } from "@tsed/di";
 import { JobMethods } from "../contracts";
 import { Type } from "@tsed/core";
 import { Job as BullMQJob, JobsOptions } from "bullmq";
+import type { JobDispatcherOptions } from "./JobDispatcherOptions";
 export declare class JobDispatcher {
     private readonly injector;
     constructor(injector: InjectorService);
     dispatch<T extends JobMethods>(job: Type<T>, payload?: Parameters<T["handle"]>[0], options?: JobsOptions): Promise<BullMQJob>;
+    dispatch<T = any>(job: JobDispatcherOptions, payload?: T, options?: JobsOptions): Promise<BullMQJob>;
+    dispatch<T = any>(job: string, payload?: T, options?: JobsOptions): Promise<BullMQJob>;
+    private resolveDispatchArgs;
 }

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

@@ -0,0 +1,4 @@
+export interface JobDispatcherOptions {
+    queue: string;
+    name: string;
+}

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

@@ -2,3 +2,4 @@
  * @file Automatically generated by barrelsby.
  */
 export * from "./JobDispatcher";
+export * from "./JobDispatcherOptions";

package/lib/types/index.d.ts

@@ -7,3 +7,4 @@ export * from "./contracts/JobMethods";
 export * from "./contracts/JobStore";
 export * from "./decorators/JobController";
 export * from "./dispatchers/JobDispatcher";
+export * from "./dispatchers/JobDispatcherOptions";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/bullmq",
-  "version": "7.47.1",
+  "version": "7.49.0",
   "private": false,
   "description": "BullMQ integration for Ts.ED",
   "keywords": [
@@ -29,11 +29,11 @@
     "tslib": "2.5.0"
   },
   "devDependencies": {
-    "@tsed/common": "7.47.1",
-    "@tsed/core": "7.47.1",
-    "@tsed/di": "7.47.1",
+    "@tsed/common": "7.49.0",
+    "@tsed/core": "7.49.0",
+    "@tsed/di": "7.49.0",
     "@tsed/eslint": "7.44.1",
-    "@tsed/schema": "7.47.1",
+    "@tsed/schema": "7.49.0",
     "@tsed/typescript": "7.44.1",
     "bullmq": "^4.12.3",
     "eslint": "^8.12.0",

package/src/BullMQModule.spec.ts

@@ -1,42 +1,35 @@
-import {InjectorService, PlatformTest} from "@tsed/common";
+import {PlatformTest} from "@tsed/common";
 import {catchAsyncError} from "@tsed/core";
 import {Queue, Worker} from "bullmq";
-import {anyString, anything, instance, mock, verify, when} from "ts-mockito";
+import {anything, 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 {FallbackJobController, JobController} from "./decorators";
 import {JobDispatcher} from "./dispatchers";
 
+const queueConstructorSpy = jest.fn();
+const workerConstructorSpy = jest.fn();
+
 jest.mock("bullmq", () => {
   return {
     Queue: class {
-      public name: string;
-
-      constructor(name: string) {
-        this.name = name;
+      constructor(...args: any[]) {
+        queueConstructorSpy(...args);
       }
       close() {}
     },
     Worker: class {
-      public name: string;
-
-      constructor(name: string) {
-        this.name = name;
+      constructor(...args: any[]) {
+        workerConstructorSpy(...args);
       }
       close() {}
     }
   };
 });
 
-const bullmq = {
-  queues: ["default", "foo", "bar"],
-  connection: {},
-  workerQueues: ["default", "foo"]
-} as BullMQConfig;
-
 @JobController("cron", "default", {
   repeat: {
     pattern: "* * * * *"
@@ -51,154 +44,338 @@ class RegularJob {
   handle() {}
 }
 
-describe("module", () => {
+describe("BullMQModule", () => {
   let dispatcher: JobDispatcher;
-  beforeEach(async () => {
+
+  beforeEach(() => {
     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("configuration", () => {
+    beforeEach(() => {
+      queueConstructorSpy.mockClear();
+      workerConstructorSpy.mockClear();
     });
-  });
 
-  describe("queues", () => {
-    it("should get default", () => {
-      const instance = PlatformTest.get<Queue>("bullmq.queue.default");
+    describe("merges config correctly", () => {
+      beforeEach(async () => {
+        await PlatformTest.create({
+          bullmq: {
+            queues: ["default", "special"],
+            connection: {
+              connectionName: "defaultConnectionName"
+            },
+            defaultQueueOptions: {
+              defaultJobOptions: {
+                delay: 100
+              },
+              blockingConnection: true
+            },
+            queueOptions: {
+              special: {
+                connection: {
+                  connectionName: "specialConnectionName"
+                },
+                defaultJobOptions: {
+                  attempts: 9
+                }
+              }
+            },
+            defaultWorkerOptions: {
+              connection: {
+                connectTimeout: 123
+              },
+              concurrency: 50
+            },
+            workerOptions: {
+              special: {
+                concurrency: 1,
+                lockDuration: 2
+              }
+            }
+          },
+          imports: [
+            {
+              token: JobDispatcher,
+              use: instance(dispatcher)
+            }
+          ]
+        });
+      });
 
-      expect(instance).toBeInstanceOf(Queue);
-      expect(instance.name).toBe("default");
+      it("queue", () => {
+        expect(queueConstructorSpy).toHaveBeenCalledTimes(2);
+
+        expect(queueConstructorSpy).toHaveBeenNthCalledWith(1, "default", {
+          connection: {
+            connectionName: "defaultConnectionName"
+          },
+          defaultJobOptions: {
+            delay: 100
+          },
+          blockingConnection: true
+        });
+
+        expect(queueConstructorSpy).toHaveBeenNthCalledWith(2, "special", {
+          connection: {
+            connectionName: "specialConnectionName"
+          },
+          defaultJobOptions: {
+            attempts: 9,
+            delay: 100
+          },
+          blockingConnection: true
+        });
+      });
+
+      it("worker", () => {
+        expect(workerConstructorSpy).toHaveBeenCalledTimes(2);
+
+        expect(workerConstructorSpy).toHaveBeenNthCalledWith(1, "default", expect.any(Function), {
+          connection: {
+            connectTimeout: 123
+          },
+          concurrency: 50
+        });
+
+        expect(workerConstructorSpy).toHaveBeenNthCalledWith(2, "special", expect.any(Function), {
+          connection: {
+            connectTimeout: 123
+          },
+          concurrency: 1,
+          lockDuration: 2
+        });
+      });
     });
 
-    it.each(bullmq.queues)("should register queue(%s)", (queue) => {
-      const instance = PlatformTest.get<Queue>(`bullmq.queue.${queue}`);
+    describe("disableWorker", () => {
+      const config = {
+        queues: ["default", "foo", "bar"],
+        connection: {},
+        disableWorker: true
+      } as BullMQConfig;
+
+      beforeEach(async () => {
+        await PlatformTest.create({
+          bullmq: config,
+          imports: [
+            {
+              token: JobDispatcher,
+              use: instance(dispatcher)
+            }
+          ]
+        });
+      });
 
-      expect(instance).toBeInstanceOf(Queue);
-      expect(instance.name).toBe(queue);
+      it("should not create any workers", () => {
+        expect(workerConstructorSpy).toHaveBeenCalledTimes(0);
+      });
     });
 
-    it("should not allow direct injection of the queue", () => {
-      expect(PlatformTest.get(Queue)).not.toBeInstanceOf(Queue);
+    describe("without", () => {
+      it("skips initialization", async () => {
+        await PlatformTest.create({
+          imports: [
+            {
+              token: JobDispatcher,
+              use: instance(dispatcher)
+            }
+          ]
+        });
+
+        expect(queueConstructorSpy).not.toHaveBeenCalled();
+        verify(dispatcher.dispatch(anything())).never();
+      });
     });
   });
 
-  describe("workers", () => {
-    it("should get default", () => {
-      const instance = PlatformTest.get<Worker>("bullmq.worker.default");
+  describe("functionality", () => {
+    const config = {
+      queues: ["default", "foo", "bar"],
+      connection: {},
+      workerQueues: ["default", "foo"]
+    } as BullMQConfig;
+
+    beforeEach(async () => {
+      await PlatformTest.create({
+        bullmq: config,
+        imports: [
+          {
+            token: JobDispatcher,
+            use: instance(dispatcher)
+          }
+        ]
+      });
+    });
 
-      expect(instance).toBeInstanceOf(Worker);
-      expect(instance.name).toBe("default");
+    describe("cronjobs", () => {
+      it("should dispatch cron jobs automatically", () => {
+        verify(dispatcher.dispatch(CustomCronJob)).once();
+      });
     });
 
-    it.each(bullmq.workerQueues)("should register worker(%s)", (queue) => {
-      const instance = PlatformTest.get<Worker>(`bullmq.worker.${queue}`);
+    describe("queues", () => {
+      it("should get default", () => {
+        const instance = PlatformTest.get<Queue>("bullmq.queue.default");
 
-      expect(instance).toBeInstanceOf(Worker);
-      expect(instance.name).toBe(queue);
-    });
+        expect(instance).toBeInstanceOf(Queue);
+      });
 
-    it("should not register unspecified worker queue", () => {
-      expect(PlatformTest.get("bullmq.worker.bar")).toBeUndefined();
-    });
+      it.each(config.queues)("should register queue(%s)", (queue) => {
+        const instance = PlatformTest.get<Queue>(`bullmq.queue.${queue}`);
+
+        expect(instance).toBeInstanceOf(Queue);
+      });
 
-    it("should not allow direct injection of the worker", () => {
-      expect(PlatformTest.get(Worker)).not.toBeInstanceOf(Worker);
+      it("should not allow direct injection of the queue", () => {
+        expect(PlatformTest.get(Queue)).not.toBeInstanceOf(Queue);
+      });
     });
 
-    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"}
-      };
+    describe("workers", () => {
+      it("should get default", () => {
+        const instance = PlatformTest.get<Worker>("bullmq.worker.default");
 
-      jest.spyOn(worker, "handle").mockResolvedValueOnce(undefined as never);
+        expect(instance).toBeInstanceOf(Worker);
+      });
 
-      await (bullMQModule as any).onProcess(job);
+      it.each(config.workerQueues)("should register worker(%s)", (queue) => {
+        const instance = PlatformTest.get<Worker>(`bullmq.worker.${queue}`);
 
-      expect(worker.handle).toHaveBeenCalledWith({test: "test"}, job);
+        expect(instance).toBeInstanceOf(Worker);
+      });
+
+      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");
+      });
     });
+  });
 
-    it("should log warning when the worker doesn't exists", async () => {
-      const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
+  describe("with fallback controller", () => {
+    beforeEach(async () => {
+      @FallbackJobController("foo")
+      class FooFallbackController {
+        handle() {}
+      }
 
-      jest.spyOn(PlatformTest.injector.logger, "warn");
+      @FallbackJobController()
+      class FallbackController {
+        handle() {}
+      }
 
+      await PlatformTest.create({
+        bullmq: {
+          queues: ["default", "foo"],
+          connection: {}
+        },
+        imports: [
+          {
+            token: JobDispatcher,
+            use: instance(dispatcher)
+          }
+        ]
+      });
+    });
+
+    it("should run queue specific fallback job controller", async () => {
+      const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
+      const worker = PlatformTest.get<JobMethods>("bullmq.fallback-job.foo");
       const job = {
-        name: "regular",
-        queueName: "toto",
+        name: "unknown-name",
+        queueName: "foo",
         data: {test: "test"}
       };
 
+      jest.spyOn(worker, "handle").mockResolvedValueOnce(undefined as never);
+
       await (bullMQModule as any).onProcess(job);
 
-      expect(PlatformTest.injector.logger.warn).toHaveBeenCalledWith({
-        event: "BULLMQ_JOB_NOT_FOUND",
-        message: "Job regular toto not found"
-      });
+      expect(worker.handle).toHaveBeenCalledWith({test: "test"}, job);
     });
 
-    it("should run worker, execute processor and handle error", async () => {
+    it("should run overall fallback job controller", async () => {
       const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
-      const worker = PlatformTest.get<JobMethods>("bullmq.job.default.regular");
+      const worker = PlatformTest.get<JobMethods>("bullmq.fallback-job");
       const job = {
-        name: "regular",
+        name: "unknown-name",
         queueName: "default",
-        data: {test: "test"}
+        data: {test: "123"}
       };
 
-      jest.spyOn(PlatformTest.injector.logger, "error");
-
-      jest.spyOn(worker, "handle").mockRejectedValue(new Error("error") as never);
+      jest.spyOn(worker, "handle").mockResolvedValueOnce(undefined as never);
 
-      const error = await catchAsyncError(() => (bullMQModule as any).onProcess(job));
+      await (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");
+      expect(worker.handle).toHaveBeenCalledWith({test: "123"}, job);
     });
   });
 });
-
-it('skips initialization when no config is provided', async () => {
-  const injector = mock(InjectorService)
-  const dispatcher = mock(JobDispatcher);
-  await PlatformTest.create({
-    imports: [
-      {
-        token: InjectorService,
-        use: instance(injector),
-      },
-      {
-        token: JobDispatcher,
-        use: instance(dispatcher)
-      }
-    ]
-  })
-
-  verify(injector.add(anyString(), anything())).never();
-  verify(dispatcher.dispatch(anything())).never()
-});