@tsed/bullmq 7.49.0 → 7.51.0

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

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

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

@@ -7,7 +7,8 @@ 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>;
+    dispatch<P = unknown>(job: JobDispatcherOptions, payload?: P, options?: JobsOptions): Promise<BullMQJob>;
+    dispatch<P = unknown>(job: string, payload?: P, options?: JobsOptions): Promise<BullMQJob>;
     private resolveDispatchArgs;
+    private retrieveJobOptionsFromClassBasedJob;
 }

package/package.json

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

package/jest.config.js

@@ -1,11 +0,0 @@
-module.exports = {
-  ...require("@tsed/jest-config"),
-  coverageThreshold: {
-    global: {
-      branches: 89.58,
-      functions: 100,
-      lines: 100,
-      statements: 100
-    }
-  }
-};

package/src/BullMQModule.spec.ts

@@ -1,381 +0,0 @@
-import {PlatformTest} from "@tsed/common";
-import {catchAsyncError} from "@tsed/core";
-import {Queue, Worker} from "bullmq";
-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 {FallbackJobController, JobController} from "./decorators";
-import {JobDispatcher} from "./dispatchers";
-
-const queueConstructorSpy = jest.fn();
-const workerConstructorSpy = jest.fn();
-
-jest.mock("bullmq", () => {
-  return {
-    Queue: class {
-      constructor(...args: any[]) {
-        queueConstructorSpy(...args);
-      }
-      close() {}
-    },
-    Worker: class {
-      constructor(...args: any[]) {
-        workerConstructorSpy(...args);
-      }
-      close() {}
-    }
-  };
-});
-
-@JobController("cron", "default", {
-  repeat: {
-    pattern: "* * * * *"
-  }
-})
-class CustomCronJob implements JobMethods {
-  handle() {}
-}
-
-@JobController("regular", "default")
-class RegularJob {
-  handle() {}
-}
-
-describe("BullMQModule", () => {
-  let dispatcher: JobDispatcher;
-
-  beforeEach(() => {
-    dispatcher = mock(JobDispatcher);
-    when(dispatcher.dispatch(CustomCronJob)).thenResolve();
-  });
-
-  afterEach(PlatformTest.reset);
-
-  describe("configuration", () => {
-    beforeEach(() => {
-      queueConstructorSpy.mockClear();
-      workerConstructorSpy.mockClear();
-    });
-
-    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)
-            }
-          ]
-        });
-      });
-
-      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
-        });
-      });
-    });
-
-    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)
-            }
-          ]
-        });
-      });
-
-      it("should not create any workers", () => {
-        expect(workerConstructorSpy).toHaveBeenCalledTimes(0);
-      });
-    });
-
-    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("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)
-          }
-        ]
-      });
-    });
-
-    describe("cronjobs", () => {
-      it("should dispatch cron jobs automatically", () => {
-        verify(dispatcher.dispatch(CustomCronJob)).once();
-      });
-    });
-
-    describe("queues", () => {
-      it("should get default", () => {
-        const instance = PlatformTest.get<Queue>("bullmq.queue.default");
-
-        expect(instance).toBeInstanceOf(Queue);
-      });
-
-      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 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);
-      });
-
-      it.each(config.workerQueues)("should register worker(%s)", (queue) => {
-        const instance = PlatformTest.get<Worker>(`bullmq.worker.${queue}`);
-
-        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");
-      });
-    });
-  });
-
-  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

@@ -1,122 +0,0 @@
-import {BeforeInit, DIContext, runInContext} from "@tsed/common";
-import {Constant, InjectorService, Module} from "@tsed/di";
-import {deepMerge} from "@tsed/core";
-import {getComputedType} from "@tsed/schema";
-import {Job, Queue, type QueueOptions, Worker, type WorkerOptions} from "bullmq";
-import {v4} from "uuid";
-import {BullMQConfig} from "./config/config";
-import {JobMethods} from "./contracts";
-import {JobDispatcher} from "./dispatchers";
-
-@Module()
-export class BullMQModule implements BeforeInit {
-  @Constant("bullmq")
-  private readonly bullmq: BullMQConfig;
-
-  constructor(private readonly injector: InjectorService, private readonly dispatcher: JobDispatcher) {}
-
-  $beforeInit() {
-    if (!this.bullmq) {
-      return;
-    }
-
-    if (!this.bullmq.disableWorker) {
-      this.buildWorkers();
-    }
-    this.buildQueues();
-
-    this.injector.getMany<JobMethods>("bullmq:cron").map((job) => this.dispatcher.dispatch(getComputedType(job)));
-  }
-
-  private buildQueues() {
-    this.bullmq.queues.forEach((queue) => {
-      const ops = deepMerge<QueueOptions, QueueOptions>(
-        {
-          connection: this.bullmq.connection,
-          defaultJobOptions: this.bullmq.defaultJobOptions,
-          ...this.bullmq.defaultQueueOptions
-        },
-        this.bullmq.queueOptions?.[queue]
-      )!;
-
-      this.injector
-        .add(`bullmq.queue.${queue}`, {
-          type: "bullmq:queue",
-          useValue: new Queue(queue, ops),
-          hooks: {
-            $onDestroy: (queue) => queue.close()
-          }
-        })
-        .invoke<Queue>(`bullmq.queue.${queue}`);
-    });
-  }
-
-  private buildWorkers() {
-    (this.bullmq.workerQueues ?? this.bullmq.queues).forEach((queue) => {
-      const ops = deepMerge<WorkerOptions, WorkerOptions>(
-        {
-          connection: this.bullmq.connection,
-          ...this.bullmq.defaultWorkerOptions
-        },
-        this.bullmq.workerOptions?.[queue]
-      )!;
-
-      this.injector
-        .add(`bullmq.worker.${queue}`, {
-          type: "bullmq:worker",
-          useValue: new Worker(queue, this.onProcess.bind(this), ops),
-          hooks: {
-            $onDestroy: (worker) => worker.close()
-          }
-        })
-        .invoke<Worker>(`bullmq.worker.${queue}`);
-    });
-  }
-
-  private getJob(name: string, queueName: string) {
-    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) {
-    const jobService = this.getJob(job.name, job.queueName);
-
-    if (!jobService) {
-      this.injector.logger.warn({
-        event: "BULLMQ_JOB_NOT_FOUND",
-        message: `Job ${job.name} ${job.queueName} not found`
-      });
-      return;
-    }
-
-    const $ctx = new DIContext({
-      injector: this.injector,
-      logger: this.injector.logger,
-      id: job.id || v4().split("-").join("")
-    });
-
-    $ctx.set("BULLMQ_JOB", job);
-
-    try {
-      return await runInContext($ctx, () => jobService.handle(job.data, job));
-    } catch (er) {
-      $ctx.logger.error({
-        event: "BULLMQ_JOB_ERROR",
-        message: er.message,
-        stack: er.stack
-      });
-      throw er;
-    } finally {
-      await $ctx.destroy();
-    }
-  }
-}

package/src/config/config.ts

@@ -1,64 +0,0 @@
-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 {
-    interface Configuration {
-      bullmq?: BullMQConfig;
-    }
-  }
-}

package/src/contracts/JobMethods.ts

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

package/src/contracts/JobStore.ts

@@ -1,7 +0,0 @@
-import {JobsOptions} from "bullmq";
-
-export type JobStore = {
-  name: string;
-  queue: string;
-  opts: JobsOptions;
-};

package/src/contracts/index.ts

@@ -1,6 +0,0 @@
-/**
- * @file Automatically generated by barrelsby.
- */
-
-export * from "./JobMethods";
-export * from "./JobStore";