@tsed/bullmq 8.11.1 → 8.11.2-rc.1

package/src/BullMQModule.spec.ts

@@ -1,482 +0,0 @@
-import "./BullMQModule.js";
-
-import {catchAsyncError} from "@tsed/core";
-import {logger} from "@tsed/di";
-import {PlatformTest} from "@tsed/platform-http/testing";
-import {Queue, Worker} from "bullmq";
-import {anything, instance, mock, verify, when} from "ts-mockito";
-import {beforeEach} from "vitest";
-
-import {BullMQModule} from "./BullMQModule.js";
-import {type BullMQConfig} from "./config/config.js";
-import {JobMethods} from "./contracts/index.js";
-import {FallbackJobController, JobController} from "./decorators/index.js";
-import {InjectQueue} from "./decorators/InjectQueue.js";
-import {InjectWorker} from "./decorators/InjectWorker.js";
-import {JobDispatcher} from "./dispatchers/index.js";
-
-const queueConstructorSpy = vi.fn();
-const workerConstructorSpy = vi.fn();
-
-vi.spyOn(logger(), "error");
-
-vi.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 {
-  @InjectQueue("default")
-  queue: Queue;
-
-  @InjectWorker("default")
-  worker: Worker;
-
-  handle() {}
-}
-
-@JobController("regular", "default")
-class RegularJob {
-  handle() {}
-}
-
-describe("BullMQModule", () => {
-  let dispatcher: JobDispatcher;
-
-  beforeEach(() => {
-    dispatcher = mock(JobDispatcher);
-    when(dispatcher.dispatch(CustomCronJob)).thenResolve();
-  });
-  beforeEach(() => {
-    queueConstructorSpy.mockClear();
-    workerConstructorSpy.mockClear();
-  });
-
-  afterEach(PlatformTest.reset);
-
-  describe("configuration", () => {
-    describe("merges config correctly", () => {
-      beforeEach(() =>
-        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("discover queues from decorators", () => {
-      beforeEach(() =>
-        PlatformTest.create({
-          bullmq: {
-            queues: ["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(() =>
-        PlatformTest.create({
-          bullmq: config,
-          imports: [
-            {
-              token: JobDispatcher,
-              use: instance(dispatcher)
-            }
-          ]
-        })
-      );
-
-      it("should not create any workers", () => {
-        expect(workerConstructorSpy).toHaveBeenCalledTimes(0);
-      });
-    });
-    describe("without", () => {
-      beforeEach(() =>
-        PlatformTest.create({
-          imports: [
-            {
-              token: JobDispatcher,
-              use: instance(dispatcher)
-            }
-          ]
-        })
-      );
-      it("skips initialization", async () => {
-        expect(queueConstructorSpy).not.toHaveBeenCalled();
-        verify(dispatcher.dispatch(anything())).never();
-      });
-    });
-  });
-
-  describe("functionality", () => {
-    const config = {
-      queues: ["default", "foo", "bar"],
-      connection: {},
-      workerQueues: ["default", "foo"]
-    } as BullMQConfig;
-
-    beforeEach(() =>
-      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);
-      });
-    });
-
-    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 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"}
-        };
-
-        vi.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);
-
-        vi.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 () => {
-        vi.spyOn(logger(), "error").mockReturnThis();
-
-        logger().level = "error";
-
-        const bullMQModule = PlatformTest.get<BullMQModule>(BullMQModule);
-        const worker = PlatformTest.get<JobMethods>("bullmq.job.default.regular");
-        const job = {
-          name: "regular",
-          queueName: "default",
-          data: {test: "test"},
-          attemptsMade: 1
-        };
-
-        vi.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(logger().error).toHaveBeenCalledWith({
-          attempt: 1,
-          name: "regular",
-          queue: "default",
-          logType: "bullmq",
-          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"}
-      };
-
-      vi.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"}
-      };
-
-      vi.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,151 +0,0 @@
-import {
-  constant,
-  DIContext,
-  inject,
-  injectable,
-  injectMany,
-  injector,
-  logger,
-  OnDestroy,
-  type OnInit,
-  ProviderType,
-  runInContext
-} from "@tsed/di";
-import {getComputedType} from "@tsed/schema";
-import {Job, Queue, Worker} from "bullmq";
-import {v4} from "uuid";
-
-import {BullMQConfig} from "./config/config.js";
-import {BullMQTypes} from "./constants/BullMQTypes.js";
-import {BULLMQ} from "./constants/constants.js";
-import {JobMethods, JobStore} from "./contracts/index.js";
-import {JobDispatcher} from "./dispatchers/index.js";
-import {createQueueProvider} from "./utils/createQueueProvider.js";
-import {createWorkerProvider} from "./utils/createWorkerProvider.js";
-import {getFallbackJobToken, getJobToken} from "./utils/getJobToken.js";
-import {mapQueueOptions} from "./utils/mapQueueOptions.js";
-import {mapWorkerOptions} from "./utils/mapWorkerOptions.js";
-
-export class BullMQModule implements OnInit, OnDestroy {
-  private readonly dispatcher = inject(JobDispatcher);
-
-  constructor() {
-    // build providers allow @Inject(queue) usage in JobController instance
-    if (this.isEnabled()) {
-      const queues = [...this.getUniqQueueNames()];
-
-      this.buildQueues(queues);
-
-      if (!this.isWorkerEnabled()) {
-        const workers = this.config.workerQueues?.length ? this.config.workerQueues : queues;
-
-        this.buildWorkers(workers);
-      }
-    }
-  }
-
-  get config() {
-    return constant<BullMQConfig>("bullmq")!;
-  }
-
-  $onInit() {
-    if (this.isEnabled()) {
-      injectMany<JobMethods>(BullMQTypes.CRON).map((job) => this.dispatcher.dispatch(getComputedType(job)));
-    }
-  }
-
-  async $onDestroy() {
-    if (!this.isEnabled()) {
-      return;
-    }
-
-    await Promise.all(injectMany<Queue>(BullMQTypes.QUEUE).map((queue) => queue.close()));
-    await Promise.all(injectMany<Worker>(BullMQTypes.WORKER).map((worker) => worker.close()));
-  }
-
-  isEnabled() {
-    return !!this.config;
-  }
-
-  isWorkerEnabled() {
-    return this.config.disableWorker;
-  }
-
-  private buildQueues(queues: string[]) {
-    queues.forEach((queue) => {
-      const opts = mapQueueOptions(queue, this.config);
-      createQueueProvider(queue, opts);
-    });
-  }
-
-  private buildWorkers(workers: string[]) {
-    workers.forEach((worker) => {
-      const opts = mapWorkerOptions(worker, this.config);
-      createWorkerProvider(worker, this.onProcess, opts);
-    });
-  }
-
-  /**
-   * Auto discover queue names from provider and merge it with queue names from global configuration.
-   * @private
-   */
-  private getUniqQueueNames() {
-    return new Set(
-      injector()
-        .getProviders([BullMQTypes.JOB, BullMQTypes.CRON, BullMQTypes.FALLBACK_JOB])
-        .map((provider) => provider.store.get<JobStore>(BULLMQ)?.queue)
-        .concat(this.config.queues!)
-        .filter(Boolean)
-    );
-  }
-
-  private getJob(name: string, queueName: string) {
-    return inject<JobMethods>(getJobToken(queueName, name)) || inject(getFallbackJobToken(queueName)) || inject(getFallbackJobToken());
-  }
-
-  private onProcess = async (job: Job) => {
-    const jobService = this.getJob(job.name, job.queueName);
-
-    if (!jobService) {
-      logger().warn({
-        event: "BULLMQ_JOB_NOT_FOUND",
-        message: `Job ${job.name} ${job.queueName} not found`
-      });
-      return;
-    }
-
-    const $ctx = new DIContext({
-      id: job.id || v4().split("-").join(""),
-      additionalProps: {
-        logType: "bullmq",
-        name: job.name,
-        queue: job.queueName,
-        attempt: job.attemptsMade
-      }
-    });
-
-    $ctx.set("BULLMQ_JOB", job);
-
-    try {
-      return await runInContext($ctx, () => {
-        $ctx.logger.info("Processing job");
-        try {
-          return jobService.handle(job.data, job);
-        } finally {
-          $ctx.logger.info("Finished processing job");
-        }
-      });
-    } catch (er) {
-      $ctx.logger.error({
-        event: "BULLMQ_JOB_ERROR",
-        message: er.message,
-        stack: er.stack
-      });
-      throw er;
-    } finally {
-      await $ctx.destroy();
-    }
-  };
-}
-
-injectable(BullMQModule).type(ProviderType.MODULE);

package/src/config/config.ts

@@ -1,59 +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;
-
-  /**
-   * Default queue options which are applied to every queue
-   *
-   * Can be extended/overridden by `queueOptions`
-   */
-  defaultQueueOptions?: Partial<QueueOptions>;
-
-  /**
-   * Specify additional queue options by queue name
-   */
-  queueOptions?: Record<string, Partial<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?: Partial<WorkerOptions>;
-
-  /**
-   * Specify additional worker options by queue name
-   */
-  workerOptions?: Record<string, Partial<WorkerOptions>>;
-};
-
-declare global {
-  namespace TsED {
-    interface Configuration {
-      bullmq?: BullMQConfig;
-    }
-  }
-}

package/src/constants/BullMQTypes.ts

@@ -1,7 +0,0 @@
-export enum BullMQTypes {
-  CRON = "bullmq:cron",
-  QUEUE = "bullmq:queue",
-  JOB = "bullmq:job",
-  WORKER = "bullmq:worker",
-  FALLBACK_JOB = "bullmq:fallback-job"
-}

package/src/constants/constants.ts

@@ -1 +0,0 @@
-export const BULLMQ = "bullmq";

package/src/contracts/JobMethods.ts

@@ -1,7 +0,0 @@
-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>;
-}