@alanszp/queue 9.2.4 → 9.3.0

package/src/queue/queue.ts

@@ -1,14 +1,27 @@
-import { merge } from "lodash";
+import { capitalize, merge } from "lodash";
 import { Job, JobsOptions } from "bullmq";
+import { ListResult } from "@alanszp/core";
 import { SharedContext } from "@alanszp/shared-context";
-import { ConnectionOptions, JobData, QueueOptions, RawQueue } from "../types";
+import {
+  ConnectionOptions,
+  JobData,
+  JobReturnValue,
+  JobStateEnum,
+  JobTypeEnum,
+  QueueOptions,
+  RawQueue,
+} from "../types";
+import { JobNotFoundError } from "../errors/JobNotFoundError";
+import { JobCannotBePromotedError } from "../errors/JobCannotBePromotedError";
+import { ResultTypes } from "ioredis/built/utils/RedisCommander";
 
 const BULL_PREFIX = "b";
 
 const DEFAULT_COMPLETED_JOB_MAX_AGE_IN_SECONDS = 60 * 60 * 24 * 30;
 const DEFAULT_COMPLETED_JOB_MAX_COUNT = 500;
+const DEFAULT_FAILED_JOB_MAX_COUNT = 1000;
 
-export class Queue<JobType = JobData> {
+export class Queue<Data = JobData, ReturnValue = JobReturnValue> {
   private _queue: RawQueue;
 
   private name: string;
@@ -26,7 +39,7 @@ export class Queue<JobType = JobData> {
 
     this.getSharedContext = getSharedContext;
 
-    this._queue = new RawQueue<JobType>(name, {
+    this._queue = new RawQueue<Data>(name, {
       ...merge(
         {
           defaultJobOptions: {
@@ -34,6 +47,9 @@ export class Queue<JobType = JobData> {
               age: DEFAULT_COMPLETED_JOB_MAX_AGE_IN_SECONDS,
               count: DEFAULT_COMPLETED_JOB_MAX_COUNT,
             },
+            removeOnFail: {
+              count: DEFAULT_FAILED_JOB_MAX_COUNT,
+            },
             attempts: 3,
             backoff: {
               type: "exponential",
@@ -52,34 +68,109 @@ export class Queue<JobType = JobData> {
     return this.name;
   }
 
-  async publishJob(job: JobType, opts?: JobsOptions): Promise<Job<JobType>> {
+  async publishJob(
+    job: Data,
+    opts?: JobsOptions
+  ): Promise<Job<Data, ReturnValue>> {
     const context = this.getSharedContext();
     const lid = context.getLifecycleId();
     const lch = context.getLifecycleChain();
     return this.queue.add(this.name, { ...job, lid, lch }, opts);
   }
 
-  async publishBulkJob(jobDatas: JobType[]): Promise<Job<JobType>[]> {
+  async publishBulkJob(jobDatas: Data[]): Promise<Job<Data, ReturnValue>[]> {
     const jobs = jobDatas.map((data) => ({ name: this.name, data }));
     return this.queue.addBulk(jobs);
   }
 
   async publishBulkJobWithOptions(
-    jobDefinitions: { jobData: JobType; opts: JobsOptions }[]
-  ): Promise<void> {
+    jobDefinitions: { jobData: Data; opts: JobsOptions }[]
+  ): Promise<Job<Data, ReturnValue>[]> {
     const jobs = jobDefinitions.map(({ jobData: data, opts }) => ({
       name: this.name,
       data,
       opts,
     }));
-    await this.queue.addBulk(jobs);
+    return this.queue.addBulk(jobs);
+  }
+
+  private pageToStartEnd(pageNumber: number, pageSize: number) {
+    return {
+      start: (pageNumber - 1) * pageSize,
+      end: pageNumber * pageSize - 1,
+    };
+  }
+
+  public async getJobsAndCountByStatus(
+    statuses: JobTypeEnum[],
+    page: number = 1,
+    pageSize: number = 50,
+    ascending: boolean = false
+  ): Promise<ListResult<Job<Data, ReturnValue>>> {
+    const { start, end } = this.pageToStartEnd(page, pageSize);
+    const [total, elements] = await Promise.all([
+      this.queue.getJobCountByTypes(...statuses),
+      this.queue.getJobs(statuses, start, end, ascending),
+    ]);
+
+    return {
+      total,
+      elements,
+      page,
+      pageSize,
+    };
+  }
+
+  public async getJobCountByStatus(
+    statuses: JobTypeEnum[],
+    page: number = 1,
+    pageSize: number = 50
+  ): Promise<number> {
+    return this.queue.getJobCountByTypes(...statuses);
+  }
+
+  public async getJobsByStatus(
+    statuses: JobTypeEnum[],
+    page: number = 1,
+    pageSize: number = 50,
+    ascending: boolean = false
+  ): Promise<Job<Data, ReturnValue>[]> {
+    const { start, end } = this.pageToStartEnd(page, pageSize);
+    return this.queue.getJobs(statuses, start, end, ascending);
+  }
+
+  public async deleteJob(jobId: string) {
+    this.queue.remove(jobId);
+  }
+
+  public async getJob(
+    jobId: string
+  ): Promise<Job<Data, ReturnValue> | undefined> {
+    return this.queue.getJob(jobId);
+  }
+
+  public async getJobOrFail(jobId: string): Promise<Job<Data, ReturnValue>> {
+    const job = await this.queue.getJob(jobId);
+    if (!job) throw new JobNotFoundError(jobId);
+    return job;
+  }
+
+  public async changeDelayToJob(jobId: string, delayMs: number) {
+    const job = await this.getJobOrFail(jobId);
+
+    const state = await job.getState();
+    if (state !== JobStateEnum.DELAYED) {
+      throw new JobCannotBePromotedError(jobId, state);
+    }
+
+    job.changeDelay(delayMs);
   }
 
   async close(): Promise<void> {
     await this.queue.close();
   }
 
-  private get queue(): RawQueue<JobType> {
+  private get queue(): RawQueue<Data, ReturnValue> {
     return this._queue;
   }
 }

package/src/reporter/totalCount/ITotalCountReporter.ts

@@ -0,0 +1,5 @@
+export interface ITotalCountReporter {
+  setTotal(total: number): void;
+  increment(n?: number): void;
+  reset(value?: number): void;
+}

package/src/reporter/totalCount/JobTotalCountReporter.ts

@@ -0,0 +1,37 @@
+import { Job } from "../../types";
+import { ITotalCountReporter } from "./ITotalCountReporter";
+
+export class JobTotalCountReporter<JobInstance extends Job>
+  implements ITotalCountReporter
+{
+  private total = 1;
+
+  private current = 0;
+
+  private job: JobInstance;
+
+  constructor(job: JobInstance) {
+    this.job = job;
+  }
+
+  setTotal(total: number): void {
+    this.total = total;
+    this.reset();
+  }
+
+  increment(n?: number): void {
+    this.current += n ?? 1;
+    this.report();
+  }
+
+  reset(value?: number): void {
+    this.current = value ?? 0;
+    this.report();
+  }
+
+  report() {
+    this.job
+      .updateProgress({ total: this.total, current: this.current })
+      .catch(() => {});
+  }
+}

package/src/reporter/totalCount/MockTotalCountReporter.ts

@@ -0,0 +1,20 @@
+import { ITotalCountReporter } from "./ITotalCountReporter";
+
+export class MockTotalCountReporter implements ITotalCountReporter {
+  private total = 1;
+
+  private progress = 0;
+
+  setTotal(total: number): void {
+    this.total = total;
+    this.reset();
+  }
+
+  increment(n?: number): void {
+    this.progress += n ?? 1;
+  }
+
+  reset(value?: number): void {
+    this.progress = value ?? 0;
+  }
+}

package/src/types.ts

@@ -7,9 +7,32 @@ export {
   WorkerOptions,
   Queue as RawQueue,
   QueueOptions,
+  JobState,
+  JobType,
   JobsOptions,
 } from "bullmq";
 
 export type JobData = unknown;
 
 export type JobReturnValue = unknown;
+
+export enum JobStateEnum {
+  ACTIVE = "active",
+  DELAYED = "delayed",
+  WAITING = "waiting",
+  COMPLETED = "completed",
+  FAILED = "failed",
+  WAITING_CHILDREN = "waiting-children",
+}
+
+export enum JobTypeEnum {
+  ACTIVE = "active",
+  DELAYED = "delayed",
+  WAITING = "waiting",
+  COMPLETED = "completed",
+  FAILED = "failed",
+  WAITING_CHILDREN = "waiting-children",
+  PAUSED = "paused",
+  REPEAT = "repeat",
+  WAIT = "wait",
+}

package/src/worker/workerRepository.ts

@@ -3,7 +3,7 @@ import { compact, isEmpty } from "lodash";
 import { ConnectionManager } from "../connectionManager";
 import { Worker, WorkerStatus } from "./worker";
 
-export type WokerStatusWithId = { status: WorkerStatus } & { id: string };
+export type WorkerStatusWithId = { status: WorkerStatus } & { id: string };
 interface WorkerClass {
   new (): Worker;
 }
@@ -32,7 +32,10 @@ export class WorkerRepository {
     return this._instance;
   }
 
-  public registerWorker(queueName: string, workerClass: WorkerClass): WorkerRepository {
+  public registerWorker(
+    queueName: string,
+    workerClass: WorkerClass
+  ): WorkerRepository {
     Object.assign(this.workers, { [queueName]: workerClass });
     return this;
   }
@@ -51,14 +54,19 @@ export class WorkerRepository {
           this._activeWorkers.push(worker);
           return worker;
         }
-        this.getLogger().warn("worker_repository.invalid_queue_name", { queueName });
+        this.getLogger().warn("worker_repository.invalid_queue_name", {
+          queueName,
+        });
         return null;
       })
     );
   }
 
-  getWorkerStatuses(): WokerStatusWithId[] {
-    return this.activeWorkers.map((worker) => ({ id: worker.id, status: worker.status }));
+  getWorkerStatuses(): WorkerStatusWithId[] {
+    return this.activeWorkers.map((worker) => ({
+      id: worker.id,
+      status: worker.status,
+    }));
   }
 
   public getCloseConnections(): Promise<void>[] {