@clipboard-health/mongo-jobs 0.1.0

package/README.md

@@ -0,0 +1,26 @@
+# @clipboard-health/mongo-jobs
+
+> A robust, MongoDB-backed background job processing library for Node.js with TypeScript support
+
+## Features
+
+- **Reliable job processing** - Built on MongoDB for persistent, reliable job storage
+- **Automatic retries** - Exponential backoff with configurable max attempts
+- **Delayed jobs** - Schedule jobs to run at specific times
+- **Unique jobs** - Ensure only one instance of a job is enqueued or running
+- **Cron scheduling** - Built-in support for recurring jobs with cron expressions
+- **Job groups** - Organize jobs into groups and run dedicated workers per group
+- **Transaction support** - Enqueue jobs atomically with MongoDB sessions
+- **Type-safe** - Full TypeScript support with strongly-typed job payloads
+- **Concurrency control** - Configure worker concurrency per group
+- **Observability** - Built-in metrics reporting and logging support
+
+## Installation
+
+```bash
+npm install @clipboard-health/mongo-jobs
+```
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@clipboard-health/mongo-jobs",
+  "description": "MongoDB-powered background jobs.",
+  "version": "0.1.0",
+  "bugs": "https://github.com/ClipboardHealth/core-utils/issues",
+  "dependencies": {
+    "cron-parser": "5.4.0",
+    "hot-shots": "11.2.0",
+    "tslib": "2.8.1"
+  },
+  "devDependencies": {
+    "@clipboard-health/util-ts": "3.17.0",
+    "@opentelemetry/api": "1.9.0",
+    "mongodb": "6.18.0",
+    "mongoose": "8.18.0"
+  },
+  "keywords": [],
+  "license": "MIT",
+  "main": "./src/index.js",
+  "peerDependencies": {
+    "@opentelemetry/api": ">=1.0",
+    "mongodb": ">=6.9",
+    "mongoose": ">=8.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "directory": "packages/mongo-jobs",
+    "type": "git",
+    "url": "git+https://github.com/ClipboardHealth/core-utils.git"
+  },
+  "scripts": {
+    "build": "nx build mongo-jobs",
+    "lint": "nx lint mongo-jobs",
+    "test": "nx test mongo-jobs"
+  },
+  "type": "commonjs",
+  "typings": "./src/index.d.ts",
+  "types": "./src/index.d.ts"
+}

package/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./lib/backgroundJobs";
+export * from "./lib/handler";
+export type { BackgroundJobType } from "./lib/job";

package/src/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./lib/backgroundJobs"), exports);
+tslib_1.__exportStar(require("./lib/handler"), exports);
+//# sourceMappingURL=index.js.map

package/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/mongo-jobs/src/index.ts"],"names":[],"mappings":";;;AAAA,+DAAqC;AACrC,wDAA8B"}

package/src/lib/backgroundJobs.d.ts

@@ -0,0 +1,59 @@
+import mongoose from "mongoose";
+import { type RegisterCronOptions } from "./internal/cron";
+import { type EnqueueOptions, JobsRepository, type SessionOptions } from "./internal/jobsRepository";
+import type { Logger } from "./internal/logger";
+import { type MetricsReporter } from "./internal/metrics";
+import { type AnyHandlerClassOrInstance, type InstantiableHandlerClassOrInstance, Registry } from "./internal/registry";
+import { Worker, type WorkerOptions } from "./internal/worker";
+import { type BackgroundJobType } from "./job";
+import { type ScheduleType } from "./schedule";
+export interface ConstructorOptions {
+    logger?: Logger;
+    dbConnection?: mongoose.Connection;
+    metricsReporter?: MetricsReporter;
+    allowHandlerOverride?: boolean;
+}
+export declare class BackgroundJobsService {
+    readonly jobModel: mongoose.Model<BackgroundJobType<unknown>>;
+    readonly scheduleModel: mongoose.Model<ScheduleType<unknown>>;
+    readonly jobsRepo: JobsRepository;
+    readonly registry: Registry;
+    private readonly logger;
+    private readonly connection;
+    private readonly metrics;
+    private readonly cron;
+    private worker?;
+    constructor(options?: ConstructorOptions);
+    register<T>(handlerClassOrInstance: InstantiableHandlerClassOrInstance<T>, group: string): void;
+    registerCron<T>(handlerClassOrInstance: InstantiableHandlerClassOrInstance<T>, options: RegisterCronOptions<T>): Promise<void>;
+    enqueue<T>(handlerClassOrInstance: string | AnyHandlerClassOrInstance<T>, data: T, options?: EnqueueOptions): Promise<BackgroundJobType<T> | undefined>;
+    removeCron(scheduleName: string): Promise<void>;
+    start(groups: string[], workerOptions?: WorkerOptions): Promise<void>;
+    buildWorker(groups: string[], workerOptions: WorkerOptions): Worker;
+    stop(waitTime?: number): Promise<void>;
+    getJobById(jobId: string): Promise<(mongoose.Document<unknown, {}, BackgroundJobType<unknown>, {}, {}> & BackgroundJobType<unknown> & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }) | null>;
+    /**
+     * Retry a job by id
+     *
+     * This method is useful if you have a job that exhausted its attempts limit
+     * but you want to run it again. By calling this method you will bring the
+     * attempts count of the job to 0 and set the next run time to current time
+     * (so the job will be picked up as soon as possible).
+     **/
+    retryJobById(jobId: string): Promise<void>;
+    /**
+     * Cancel jobs
+     *
+     * This method will remove jobs with given ids from the DB. So if the job is
+     * scheduled and waiting to be run then you would prevent the job from being
+     * executed in the future. If you call this method while the job is currently
+     * running then you won't affect the current execution of the job but you
+     * will prevent the job from being executed again in the future (in case it
+     * failed)
+     **/
+    cancel(jobIds: string[], options?: SessionOptions): Promise<void>;
+}

package/src/lib/backgroundJobs.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackgroundJobsService = void 0;
+const tslib_1 = require("tslib");
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+const cron_1 = require("./internal/cron");
+const jobsRepository_1 = require("./internal/jobsRepository");
+const metrics_1 = require("./internal/metrics");
+const registry_1 = require("./internal/registry");
+const worker_1 = require("./internal/worker");
+const job_1 = require("./job");
+const schedule_1 = require("./schedule");
+class BackgroundJobsService {
+    jobModel;
+    scheduleModel;
+    jobsRepo;
+    registry;
+    logger;
+    connection;
+    metrics;
+    cron;
+    worker;
+    constructor(options = {}) {
+        this.logger = options.logger;
+        this.connection = options.dbConnection ?? mongoose_1.default.connection;
+        this.jobModel = this.connection.model(job_1.BackgroundJobSchemaName, job_1.BackgroundJobSchema);
+        this.scheduleModel = this.connection.model(schedule_1.ScheduleSchemaName, schedule_1.ScheduleSchema);
+        this.registry = new registry_1.Registry({ allowHandlerOverride: options.allowHandlerOverride });
+        const metricsReporter = options.metricsReporter ?? (0, metrics_1.defaultMetricsReporter)();
+        this.metrics = new metrics_1.Metrics(metricsReporter, this.jobModel, this.registry);
+        this.jobsRepo = new jobsRepository_1.JobsRepository({ jobModel: this.jobModel, registry: this.registry });
+        this.cron = new cron_1.Cron({
+            registry: this.registry,
+            scheduleModel: this.scheduleModel,
+            jobsRepo: this.jobsRepo,
+        });
+    }
+    register(handlerClassOrInstance, group) {
+        this.registry.register(handlerClassOrInstance, group);
+    }
+    async registerCron(handlerClassOrInstance, options) {
+        await this.cron.registerCron(handlerClassOrInstance, options);
+    }
+    async enqueue(handlerClassOrInstance, data, options = {}) {
+        return await this.jobsRepo.createJob({
+            handler: handlerClassOrInstance,
+            data,
+            ...options,
+        });
+    }
+    async removeCron(scheduleName) {
+        await this.cron.removeCron(scheduleName);
+    }
+    async start(groups, workerOptions = {}) {
+        if (this.worker && !this.worker.stopped) {
+            throw new Error("BackgroundJobs currently running");
+        }
+        this.worker = this.buildWorker(groups, workerOptions);
+        await this.worker.start();
+        await this.metrics.startReporting();
+    }
+    buildWorker(groups, workerOptions) {
+        return new worker_1.Worker({
+            groups,
+            cron: this.cron,
+            registry: this.registry,
+            logger: this.logger,
+            metrics: this.metrics,
+            jobsRepo: this.jobsRepo,
+            ...workerOptions,
+        });
+    }
+    async stop(waitTime) {
+        await this.worker?.stop(waitTime);
+    }
+    async getJobById(jobId) {
+        const jobObjectId = new mongoose_1.default.Types.ObjectId(jobId);
+        return await this.jobsRepo.getJob(jobObjectId);
+    }
+    /**
+     * Retry a job by id
+     *
+     * This method is useful if you have a job that exhausted its attempts limit
+     * but you want to run it again. By calling this method you will bring the
+     * attempts count of the job to 0 and set the next run time to current time
+     * (so the job will be picked up as soon as possible).
+     **/
+    async retryJobById(jobId) {
+        const jobObjectId = new mongoose_1.default.Types.ObjectId(jobId);
+        await this.jobsRepo.resetJob(jobObjectId);
+    }
+    /**
+     * Cancel jobs
+     *
+     * This method will remove jobs with given ids from the DB. So if the job is
+     * scheduled and waiting to be run then you would prevent the job from being
+     * executed in the future. If you call this method while the job is currently
+     * running then you won't affect the current execution of the job but you
+     * will prevent the job from being executed again in the future (in case it
+     * failed)
+     **/
+    async cancel(jobIds, options = {}) {
+        const jobObjectIds = jobIds.map((jobId) => new mongoose_1.default.Types.ObjectId(jobId));
+        await this.jobsRepo.deleteJobs(jobObjectIds, options);
+    }
+}
+exports.BackgroundJobsService = BackgroundJobsService;
+//# sourceMappingURL=backgroundJobs.js.map

package/src/lib/backgroundJobs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backgroundJobs.js","sourceRoot":"","sources":["../../../../../packages/mongo-jobs/src/lib/backgroundJobs.ts"],"names":[],"mappings":"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"}

package/src/lib/handler.d.ts

@@ -0,0 +1,6 @@
+import type { BackgroundJobType } from "./job";
+export interface HandlerInterface<T> {
+    name: string;
+    maxAttempts?: number;
+    perform(data: T, job?: BackgroundJobType<T>): Promise<void>;
+}

package/src/lib/handler.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=handler.js.map

package/src/lib/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../../../../packages/mongo-jobs/src/lib/handler.ts"],"names":[],"mappings":""}

package/src/lib/internal/cron.d.ts

@@ -0,0 +1,29 @@
+import type mongoose from "mongoose";
+import type { BackgroundJobType } from "../job";
+import type { ScheduleType } from "../schedule";
+import type { JobsRepository } from "./jobsRepository";
+import type { InstantiableHandlerClassOrInstance, Registry } from "./registry";
+interface ConstructorOptions {
+    scheduleModel: mongoose.Model<ScheduleType<unknown>>;
+    jobsRepo: JobsRepository;
+    registry: Registry;
+}
+export interface RegisterCronOptions<T> {
+    group: string;
+    cronExpression: string;
+    timeZone?: string;
+    scheduleName: string;
+    data: T;
+}
+export declare class Cron {
+    private readonly scheduleModel;
+    private readonly jobsRepo;
+    private readonly registry;
+    constructor(options: ConstructorOptions);
+    maybeScheduleNextJob(job: BackgroundJobType<unknown>): Promise<void>;
+    registerCron<T>(handlerClassOrInstance: InstantiableHandlerClassOrInstance<T>, options: RegisterCronOptions<T>): Promise<void>;
+    scheduleNextIteration(schedule: Omit<ScheduleType<unknown>, "_id">): Promise<void>;
+    removeCron(scheduleName: string): Promise<void>;
+    private upsertSchedule;
+}
+export {};

package/src/lib/internal/cron.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cron = void 0;
+const cron_parser_1 = require("cron-parser");
+const handlerAlreadyRegisteredError_1 = require("./handlerAlreadyRegisteredError");
+function validateCronExpression(expression) {
+    try {
+        cron_parser_1.CronExpressionParser.parse(expression);
+    }
+    catch (error) {
+        throw new Error("Invalid cron expression", { cause: error });
+    }
+}
+class Cron {
+    scheduleModel;
+    jobsRepo;
+    registry;
+    constructor(options) {
+        this.scheduleModel = options.scheduleModel;
+        this.jobsRepo = options.jobsRepo;
+        this.registry = options.registry;
+    }
+    async maybeScheduleNextJob(job) {
+        if (!job.scheduleName) {
+            return;
+        }
+        if (job.attemptsCount > 0) {
+            return;
+        }
+        const schedule = await this.scheduleModel.findOne({ name: job.scheduleName });
+        if (schedule) {
+            await this.scheduleNextIteration(schedule);
+        }
+    }
+    async registerCron(handlerClassOrInstance, options) {
+        try {
+            this.registry.register(handlerClassOrInstance, options.group);
+        }
+        catch (error) {
+            if (!(error instanceof handlerAlreadyRegisteredError_1.HandlerAlreadyRegisteredError)) {
+                throw error;
+            }
+        }
+        const { handler, queue } = this.registry.getRegisteredHandler(handlerClassOrInstance);
+        await this.upsertSchedule(handler.name, queue, options);
+    }
+    async scheduleNextIteration(schedule) {
+        const nextRunAt = cron_parser_1.CronExpressionParser.parse(schedule.cronExpression, { tz: schedule.timeZone })
+            .next()
+            .toDate();
+        const nextRunAtInteger = nextRunAt.getTime();
+        const uniqueKey = `${schedule.name}-${nextRunAtInteger}`;
+        await this.jobsRepo.createJob({
+            handler: schedule.handlerName,
+            data: schedule.data,
+            startAt: nextRunAt,
+            unique: uniqueKey,
+            scheduleName: schedule.name,
+            queue: schedule.queue,
+        });
+    }
+    async removeCron(scheduleName) {
+        await this.scheduleModel.deleteOne({ name: scheduleName });
+        await this.jobsRepo.deleteUpcomingScheduleJobs(scheduleName);
+    }
+    async upsertSchedule(handlerName, queue, options) {
+        const { scheduleName, cronExpression, data } = options;
+        const timeZone = options.timeZone ?? "utc";
+        validateCronExpression(cronExpression);
+        const scheduleAttributes = {
+            name: scheduleName,
+            handlerName,
+            cronExpression,
+            timeZone,
+            queue,
+            data,
+        };
+        const upsertResult = await this.scheduleModel.updateOne({ name: scheduleName }, { $set: scheduleAttributes }, { upsert: true });
+        if (upsertResult.modifiedCount > 0) {
+            /* If the schedule is updated then we are clearing all future jobs for this schedule
+             * so that we can reschedule them with proper timing/handler etc
+             */
+            await this.jobsRepo.deleteUpcomingScheduleJobs(scheduleName);
+        }
+        await this.scheduleNextIteration(scheduleAttributes);
+    }
+}
+exports.Cron = Cron;
+//# sourceMappingURL=cron.js.map

package/src/lib/internal/cron.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.js","sourceRoot":"","sources":["../../../../../../packages/mongo-jobs/src/lib/internal/cron.ts"],"names":[],"mappings":"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"}

package/src/lib/internal/duplicateRunningError.d.ts

@@ -0,0 +1,2 @@
+export declare class DuplicateRunningError extends Error {
+}

package/src/lib/internal/duplicateRunningError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DuplicateRunningError = void 0;
+class DuplicateRunningError extends Error {
+}
+exports.DuplicateRunningError = DuplicateRunningError;
+//# sourceMappingURL=duplicateRunningError.js.map

package/src/lib/internal/duplicateRunningError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplicateRunningError.js","sourceRoot":"","sources":["../../../../../../packages/mongo-jobs/src/lib/internal/duplicateRunningError.ts"],"names":[],"mappings":";;;AAAA,MAAa,qBAAsB,SAAQ,KAAK;CAAG;AAAnD,sDAAmD"}

package/src/lib/internal/handlerAlreadyRegisteredError.d.ts

@@ -0,0 +1,2 @@
+export declare class HandlerAlreadyRegisteredError extends Error {
+}

package/src/lib/internal/handlerAlreadyRegisteredError.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HandlerAlreadyRegisteredError = void 0;
+class HandlerAlreadyRegisteredError extends Error {
+}
+exports.HandlerAlreadyRegisteredError = HandlerAlreadyRegisteredError;
+//# sourceMappingURL=handlerAlreadyRegisteredError.js.map

package/src/lib/internal/handlerAlreadyRegisteredError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlerAlreadyRegisteredError.js","sourceRoot":"","sources":["../../../../../../packages/mongo-jobs/src/lib/internal/handlerAlreadyRegisteredError.ts"],"names":[],"mappings":";;;AAAA,MAAa,6BAA8B,SAAQ,KAAK;CAAG;AAA3D,sEAA2D"}

package/src/lib/internal/jobsRepository.d.ts

@@ -0,0 +1,51 @@
+import type { ChangeStream, ClientSession } from "mongodb";
+import type mongoose from "mongoose";
+import type { BackgroundJobType, JobUniqueOptions } from "../job";
+import type { AnyHandlerClassOrInstance, Registry } from "./registry";
+type EnqueueUniqueOptions = string | JobUniqueOptions;
+export interface UpsertChangeStreamEvent {
+    fullDocument: BackgroundJobType<unknown>;
+}
+export interface SessionOptions {
+    session?: ClientSession;
+}
+export interface EnqueueOptions extends SessionOptions {
+    startAt?: Date;
+    unique?: EnqueueUniqueOptions;
+}
+interface CreateJobParameters<T> extends EnqueueOptions {
+    handler: string | AnyHandlerClassOrInstance<T>;
+    data: T;
+    scheduleName?: string;
+    queue?: string;
+}
+interface ConstructorOptions {
+    registry: Registry;
+    jobModel: mongoose.Model<BackgroundJobType<unknown>>;
+}
+export declare class JobsRepository {
+    private readonly registry;
+    private readonly jobModel;
+    constructor(options: ConstructorOptions);
+    createJob<T>(parameters: CreateJobParameters<T>): Promise<BackgroundJobType<T> | undefined>;
+    fetchAndLockNextJob(queues: string[]): Promise<BackgroundJobType<unknown> | undefined>;
+    fetchNextJob(queue: string): Promise<BackgroundJobType<unknown> | undefined>;
+    updateOne(id: mongoose.Types.ObjectId, update: mongoose.UpdateQuery<BackgroundJobType<unknown>>): Promise<void>;
+    unlockFirstExpiredJob(lockedAtThreshold: Date): Promise<(mongoose.Document<unknown, {}, BackgroundJobType<unknown>, {}, {}> & BackgroundJobType<unknown> & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }) | undefined>;
+    deleteJobs(ids: mongoose.Types.ObjectId[], options?: SessionOptions): Promise<void>;
+    getJob(id: mongoose.Types.ObjectId): Promise<(mongoose.Document<unknown, {}, BackgroundJobType<unknown>, {}, {}> & BackgroundJobType<unknown> & Required<{
+        _id: mongoose.Types.ObjectId;
+    }> & {
+        __v: number;
+    }) | null>;
+    deleteUpcomingScheduleJobs(scheduleName: string): Promise<void>;
+    watchInserts(queues: string[]): ChangeStream<BackgroundJobType<unknown>>;
+    watchUpserts(queues: string[]): ChangeStream<BackgroundJobType<unknown>>;
+    resetJob(id: mongoose.Types.ObjectId): Promise<void>;
+    fetchQueuesWithJobs(pertinentQueues: string[]): Promise<string[]>;
+}
+export {};

package/src/lib/internal/jobsRepository.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobsRepository = void 0;
+const tracing_1 = require("../tracing");
+const mongoDuplicate_1 = require("./mongoDuplicate");
+function normalizeUniqueOptions(options) {
+    if (typeof options === "string") {
+        return {
+            enqueuedKey: options,
+            runningKey: options,
+        };
+    }
+    return options;
+}
+class JobsRepository {
+    registry;
+    jobModel;
+    constructor(options) {
+        this.registry = options.registry;
+        this.jobModel = options.jobModel;
+    }
+    async createJob(parameters) {
+        const handlerClassOrInstance = parameters.handler;
+        const registeredHandler = this.registry.getRegisteredHandler(handlerClassOrInstance);
+        const { handler } = registeredHandler;
+        const queue = parameters.queue ?? registeredHandler.queue;
+        const { session, unique, scheduleName, data } = parameters;
+        const startAt = parameters.startAt ?? new Date();
+        const uniqueOptions = normalizeUniqueOptions(unique);
+        const uniqueKey = uniqueOptions?.enqueuedKey;
+        return await (0, tracing_1.withProducerTrace)(handler, data, async (dataWithTrace) => {
+            try {
+                const backgroundJobCreateResult = await this.jobModel.create([
+                    {
+                        handlerName: handler.name,
+                        data: dataWithTrace,
+                        nextRunAt: startAt,
+                        queue,
+                        ...(scheduleName && { scheduleName }),
+                        ...(uniqueOptions && { options: { unique: uniqueOptions } }),
+                        ...(uniqueKey && { uniqueKey }),
+                    },
+                ], { session });
+                const createdJob = backgroundJobCreateResult[0];
+                return createdJob;
+            }
+            catch (error) {
+                if ((0, mongoDuplicate_1.isMongoDuplicateError)(error)) {
+                    // eslint-disable-next-line consistent-return
+                    return;
+                }
+                throw error;
+            }
+        });
+    }
+    async fetchAndLockNextJob(queues) {
+        return await (0, tracing_1.withInternalsTrace)("fetchAndLockNextJob", async () => {
+            const acquiredJob = await this.jobModel
+                .findOneAndUpdate({
+                queue: { $in: queues },
+                lockedAt: null,
+                nextRunAt: { $lte: new Date() },
+            }, {
+                lockedAt: new Date(),
+            }, {
+                sort: { nextRunAt: 1 },
+                returnDocument: "after",
+            })
+                .lean();
+            return acquiredJob ?? undefined;
+        });
+    }
+    async fetchNextJob(queue) {
+        return await (0, tracing_1.withInternalsTrace)("fetchNextJob", async () => {
+            const job = await this.jobModel
+                .findOne({
+                queue,
+                lockedAt: null,
+            }, {}, {
+                sort: { nextRunAt: 1 },
+            })
+                .lean();
+            return job ?? undefined;
+        });
+    }
+    async updateOne(id, update) {
+        await this.jobModel.updateOne({ _id: id }, update);
+    }
+    async unlockFirstExpiredJob(lockedAtThreshold) {
+        const expiredJob = await this.jobModel.findOneAndUpdate({
+            failedAt: null,
+            lockedAt: { $lt: lockedAtThreshold },
+        }, {
+            $unset: {
+                lockedAt: "",
+            },
+        }, {
+            sort: { lockedAt: 1 },
+        });
+        return expiredJob ?? undefined;
+    }
+    async deleteJobs(ids, options) {
+        if (ids.length === 0) {
+            return;
+        }
+        await this.jobModel.deleteMany({ _id: { $in: ids } }, options);
+    }
+    async getJob(id) {
+        return await this.jobModel.findById(id);
+    }
+    async deleteUpcomingScheduleJobs(scheduleName) {
+        await this.jobModel.deleteMany({
+            scheduleName,
+            attemptsCount: 0,
+            nextRunAt: { $gt: new Date() },
+            lockedAt: null,
+        });
+    }
+    watchInserts(queues) {
+        return this.jobModel.watch([
+            { $match: { operationType: "insert", "fullDocument.queue": { $in: queues } } },
+        ]);
+    }
+    watchUpserts(queues) {
+        return this.jobModel.watch([
+            {
+                $match: {
+                    operationType: { $in: ["insert", "update"] },
+                    "fullDocument.queue": { $in: queues },
+                },
+            },
+        ], { fullDocument: "updateLookup" });
+    }
+    async resetJob(id) {
+        const existingJob = await this.getJob(id);
+        if (!existingJob) {
+            return;
+        }
+        const resetQuery = {
+            $set: {
+                nextRunAt: new Date(),
+                attemptsCount: 0,
+            },
+            $unset: {
+                failedAt: "",
+                lockedAt: "",
+            },
+        };
+        const enqueuedUniqueKey = existingJob.options?.unique?.enqueuedKey;
+        if (enqueuedUniqueKey && resetQuery.$set) {
+            resetQuery.$set.uniqueKey = enqueuedUniqueKey;
+        }
+        if (!existingJob.queue && !existingJob.originalQueue) {
+            throw new Error("Job was taken off the queue but doesn't have value in originalQueue field");
+        }
+        if (!existingJob.queue && existingJob.originalQueue && resetQuery.$set) {
+            resetQuery.$set.queue = existingJob.originalQueue;
+        }
+        await this.updateOne(id, resetQuery);
+    }
+    async fetchQueuesWithJobs(pertinentQueues) {
+        if (pertinentQueues.length === 0) {
+            return [];
+        }
+        const queuesFilter = { queue: { $in: pertinentQueues } };
+        return await this.jobModel.distinct("queue", queuesFilter);
+    }
+}
+exports.JobsRepository = JobsRepository;
+//# sourceMappingURL=jobsRepository.js.map