@tsed/bullmq 7.48.0 → 7.49.0

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.48.0",
+  "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.48.0",
-    "@tsed/core": "7.48.0",
-    "@tsed/di": "7.48.0",
+    "@tsed/common": "7.49.0",
+    "@tsed/core": "7.49.0",
+    "@tsed/di": "7.49.0",
     "@tsed/eslint": "7.44.1",
-    "@tsed/schema": "7.48.0",
+    "@tsed/schema": "7.49.0",
     "@tsed/typescript": "7.44.1",
     "bullmq": "^4.12.3",
     "eslint": "^8.12.0",

package/src/BullMQModule.spec.ts

@@ -7,7 +7,7 @@ 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();
@@ -319,4 +319,63 @@ describe("BullMQModule", () => {
       });
     });
   });
+
+  describe("with fallback controller", () => {
+    beforeEach(async () => {
+      @FallbackJobController("foo")
+      class FooFallbackController {
+        handle() {}
+      }
+
+      @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: "unknown-name",
+        queueName: "foo",
+        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 run overall fallback job controller", async () => {
+      const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
+      const worker = PlatformTest.get<JobMethods>("bullmq.fallback-job");
+      const job = {
+        name: "unknown-name",
+        queueName: "default",
+        data: {test: "123"}
+      };
+
+      jest.spyOn(worker, "handle").mockResolvedValueOnce(undefined as never);
+
+      await (bullMQModule as any).onProcess(job);
+
+      expect(worker.handle).toHaveBeenCalledWith({test: "123"}, job);
+    });
+  });
 });

package/src/BullMQModule.ts

@@ -74,7 +74,17 @@ export class BullMQModule implements BeforeInit {
   }
 
   private getJob(name: string, queueName: string) {
-    return this.injector.get<JobMethods>(`bullmq.job.${queueName}.${name}`);
+    const job = this.injector.get<JobMethods>(`bullmq.job.${queueName}.${name}`);
+    if (job) {
+      return job;
+    }
+
+    const fallbackJobForQueue = this.injector.get(`bullmq.fallback-job.${queueName}`);
+    if (fallbackJobForQueue) {
+      return fallbackJobForQueue;
+    }
+
+    return this.injector.get("bullmq.fallback-job");
   }
 
   private async onProcess(job: Job) {

package/src/decorators/JobController.spec.ts

@@ -1,7 +1,10 @@
-import {JobController} from "./JobController";
+import {FallbackJobController, JobController} from "./JobController";
 import {Store} from "@tsed/core";
+import {GlobalProviders} from "@tsed/di";
 
 describe("JobController", () => {
+  afterEach(() => GlobalProviders.clear());
+
   it("should set the proper store data", () => {
     @JobController("testjob")
     class TestJob {}
@@ -48,3 +51,43 @@ describe("JobController", () => {
     expect(store);
   });
 });
+
+describe("FallbackJobController", () => {
+  afterEach(() => GlobalProviders.clear());
+
+  describe("with queue", () => {
+    it("should set the proper store data", () => {
+      @FallbackJobController("default")
+      class FallbackJob {}
+
+      const store = Store.from(FallbackJob).get("bullmq");
+      expect(store.queue).toBe("default");
+
+      const fallbackControllerForQueue = GlobalProviders.get("bullmq.fallback-job.default");
+      expect(fallbackControllerForQueue).not.toBeUndefined();
+      expect(fallbackControllerForQueue.type).toEqual("bullmq:fallback-job");
+      expect(fallbackControllerForQueue.useClass).toEqual(FallbackJob);
+
+      const fallbackController = GlobalProviders.get("bullmq.fallback-job");
+      expect(fallbackController).toBeUndefined();
+    });
+  });
+
+  describe("without queue", () => {
+    it("should set the proper store data", () => {
+      @FallbackJobController()
+      class FallbackJob {}
+
+      const store = Store.from(FallbackJob).get("bullmq");
+      expect(store.queue).toBeUndefined();
+
+      const fallbackController = GlobalProviders.get("bullmq.fallback-job");
+      expect(fallbackController).not.toBeUndefined();
+      expect(fallbackController.type).toEqual("bullmq:fallback-job");
+      expect(fallbackController.useClass).toEqual(FallbackJob);
+
+      const fallbackControllerForQueue = GlobalProviders.get("bullmq.fallback-job.default");
+      expect(fallbackControllerForQueue).toBeUndefined();
+    });
+  });
+});

package/src/decorators/JobController.ts

@@ -15,3 +15,15 @@ export function JobController(name: string, queue: string = "default", opts: Job
     })
   );
 }
+
+export function FallbackJobController(queue?: string) {
+  return useDecorators(
+    StoreMerge("bullmq", {
+      queue
+    }),
+    Injectable({
+      provide: "bullmq.fallback-job" + (queue ? `.${queue}` : ""),
+      type: "bullmq:fallback-job"
+    })
+  );
+}

package/src/dispatchers/JobDispatcher.spec.ts

@@ -9,7 +9,7 @@ import {instance, mock, verify, when, objectContaining} from "ts-mockito";
   backoff: 69
 })
 class ExampleTestJob implements JobMethods {
-  handle(payload: { msg: string }) {}
+  handle(payload: {msg: string}) {}
 }
 
 @JobController("queue-not-configured", "not-configured")
@@ -20,20 +20,20 @@ class NotConfiguredQueueTestJob implements JobMethods {
 describe("JobDispatcher", () => {
   it("should throw an exception when a queue is not configured", () => {
     const injector = mock(InjectorService);
-    when(injector.getMany("bullmq:queue")).thenReturn([]);
+    when(injector.get("bullmq.queue.not-configured")).thenReturn();
 
     const dispatcher = new JobDispatcher(instance(injector));
 
     expect(dispatcher.dispatch(NotConfiguredQueueTestJob)).rejects.toThrow(new Error("Queue(not-configured) not defined"));
-    verify(injector.getMany("bullmq:queue")).once();
+    verify(injector.get("bullmq.queue.not-configured")).once();
   });
 
-  it("should dispatch job", async () => {
+  it("should dispatch job as type", async () => {
     const injector = mock(InjectorService);
     const queue = mock(Queue);
     when(queue.name).thenReturn("default");
 
-    when(injector.getMany("bullmq:queue")).thenReturn([instance(queue)]);
+    when(injector.get("bullmq.queue.default")).thenReturn(instance(queue));
 
     const dispatcher = new JobDispatcher(instance(injector));
 
@@ -50,16 +50,50 @@ describe("JobDispatcher", () => {
     ).once();
   });
 
-  it('should overwrite job options defined by the job', async () => {
+  it("should dispatch job as options", async () => {
+    const injector = mock(InjectorService);
+    const queue = mock(Queue);
+    when(queue.name).thenReturn("special");
+
+    when(injector.get("bullmq.queue.special")).thenReturn(instance(queue));
+
+    const dispatcher = new JobDispatcher(instance(injector));
+
+    await dispatcher.dispatch(
+      {
+        queue: "special",
+        name: "some-name"
+      },
+      {msg: "hello test"}
+    );
+
+    verify(queue.add("some-name", objectContaining({msg: "hello test"}), objectContaining({}))).once();
+  });
+
+  it("should dispatch job as string", async () => {
+    const injector = mock(InjectorService);
+    const queue = mock(Queue);
+    when(queue.name).thenReturn("default");
+
+    when(injector.get("bullmq.queue.default")).thenReturn(instance(queue));
+
+    const dispatcher = new JobDispatcher(instance(injector));
+
+    await dispatcher.dispatch("some-name", {msg: "hello test"});
+
+    verify(queue.add("some-name", objectContaining({msg: "hello test"}), objectContaining({}))).once();
+  });
+
+  it("should overwrite job options defined by the job", async () => {
     const injector = mock(InjectorService);
     const queue = mock(Queue);
     when(queue.name).thenReturn("default");
 
-    when(injector.getMany("bullmq:queue")).thenReturn([instance(queue)]);
+    when(injector.get("bullmq.queue.default")).thenReturn(instance(queue));
 
     const dispatcher = new JobDispatcher(instance(injector));
 
-    await dispatcher.dispatch(ExampleTestJob, {msg: "hello test"}, {backoff: 42, jobId: 'ffeeaa'});
+    await dispatcher.dispatch(ExampleTestJob, {msg: "hello test"}, {backoff: 42, jobId: "ffeeaa"});
 
     verify(
       queue.add(
@@ -67,22 +101,22 @@ describe("JobDispatcher", () => {
         objectContaining({msg: "hello test"}),
         objectContaining({
           backoff: 42,
-          jobId: 'ffeeaa'
+          jobId: "ffeeaa"
         })
       )
     ).once();
-  })
+  });
 
-  it('should keep existing options and add new ones', async () => {
+  it("should keep existing options and add new ones", async () => {
     const injector = mock(InjectorService);
     const queue = mock(Queue);
     when(queue.name).thenReturn("default");
 
-    when(injector.getMany("bullmq:queue")).thenReturn([instance(queue)]);
+    when(injector.get("bullmq.queue.default")).thenReturn(instance(queue));
 
     const dispatcher = new JobDispatcher(instance(injector));
 
-    await dispatcher.dispatch(ExampleTestJob, {msg: "hello test"}, {jobId: 'ffeeaa'});
+    await dispatcher.dispatch(ExampleTestJob, {msg: "hello test"}, {jobId: "ffeeaa"});
 
     verify(
       queue.add(
@@ -90,7 +124,7 @@ describe("JobDispatcher", () => {
         objectContaining({msg: "hello test"}),
         objectContaining({
           backoff: 69,
-          jobId: 'ffeeaa'
+          jobId: "ffeeaa"
         })
       )
     ).once();

package/src/dispatchers/JobDispatcher.ts

@@ -1,25 +1,61 @@
+/* eslint-disable require-await */
 import {InjectorService, Service} from "@tsed/di";
 import {JobMethods, type JobStore} from "../contracts";
 import {Store, Type} from "@tsed/core";
 import {Job as BullMQJob, JobsOptions, Queue} from "bullmq";
+import type {JobDispatcherOptions} from "./JobDispatcherOptions";
 
 @Service()
 export class JobDispatcher {
   constructor(private readonly injector: InjectorService) {}
 
-  // eslint-disable-next-line require-await
-  public async dispatch<T extends JobMethods>(job: Type<T>, payload: Parameters<T["handle"]>[0] = {}, options: JobsOptions = {}): Promise<BullMQJob> {
-    const store = Store.from(job).get<JobStore>("bullmq");
+  public async dispatch<T extends JobMethods>(
+    job: Type<T>,
+    payload?: Parameters<T["handle"]>[0],
+    options?: JobsOptions
+  ): Promise<BullMQJob>;
+  public async dispatch<T = any>(job: JobDispatcherOptions, payload?: T, options?: JobsOptions): Promise<BullMQJob>;
+  public async dispatch<T = any>(job: string, payload?: T, options?: JobsOptions): Promise<BullMQJob>;
+  public async dispatch(job: Type | JobDispatcherOptions | string, payload: any, options: JobsOptions = {}): Promise<BullMQJob> {
+    const {queueName, jobName, defaultJobOptions} = this.resolveDispatchArgs(job);
 
-    const queue = this.injector.getMany<Queue>("bullmq:queue").find((queue) => queue.name === store.queue);
+    const queue = this.injector.get<Queue>(`bullmq.queue.${queueName}`);
 
     if (!queue) {
-      throw new Error(`Queue(${store.queue}) not defined`);
+      throw new Error(`Queue(${queueName}) not defined`);
     }
 
-    return queue.add(store.name, payload, {
-      ...store.opts,
-      ...options,
+    return queue.add(jobName, payload, {
+      ...defaultJobOptions,
+      ...options
     });
   }
+
+  private resolveDispatchArgs(job: Type | JobDispatcherOptions | string) {
+    let queueName: string;
+    let jobName: string;
+    let defaultJobOptions: JobsOptions | undefined;
+
+    if (typeof job === "function") {
+      // job is passed as a Type
+      const store = Store.from(job).get<JobStore>("bullmq");
+      queueName = store.queue;
+      jobName = store.name;
+      defaultJobOptions = store.opts;
+    } else if (typeof job === "object") {
+      // job is passed as JobDispatcherOptions
+      queueName = job.queue;
+      jobName = job.name;
+    } else {
+      // job is passed as a string
+      queueName = "default";
+      jobName = job;
+    }
+
+    return {
+      queueName,
+      jobName,
+      defaultJobOptions
+    };
+  }
 }

package/src/dispatchers/JobDispatcherOptions.ts

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

package/src/dispatchers/index.ts

@@ -3,3 +3,4 @@
  */
 
 export * from "./JobDispatcher";
+export * from "./JobDispatcherOptions";

package/src/index.ts

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