@terreno/jobs 57.4.0

package/dist/jobsService.js

@@ -0,0 +1,505 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unregisterJobsService = exports.registerJobsService = exports.tryGetJobsService = exports.getJobsService = exports.JobsService = void 0;
+var api_1 = require("@terreno/api");
+var luxon_1 = require("luxon");
+var mongoose_1 = __importDefault(require("mongoose"));
+var activeJobExecution_1 = require("./activeJobExecution");
+var dispatchCompensation_1 = require("./dispatchCompensation");
+var job_1 = require("./models/job");
+var jobSchedule_1 = require("./models/jobSchedule");
+var retryBackoff_1 = require("./retryBackoff");
+var scheduleCron_1 = require("./scheduleCron");
+var scheduler_1 = require("./scheduler");
+var DEFAULT_MAX_ATTEMPTS = 5;
+var DEFAULT_TIMEZONE = "UTC";
+var UNKNOWN_JOB_NAME_TITLE = "Unknown job name";
+var isDuplicateKeyError = function (error) {
+    return Boolean(error &&
+        typeof error === "object" &&
+        "code" in error &&
+        error.code === 11000);
+};
+var JobsService = /** @class */ (function () {
+    function JobsService(options) {
+        var _a, _b;
+        this.definitions = new Map();
+        this.schedulesDirty = false;
+        this.defaultTimezone = (_a = options === null || options === void 0 ? void 0 : options.defaultTimezone) !== null && _a !== void 0 ? _a : DEFAULT_TIMEZONE;
+        this.lockTtlMs = (_b = options === null || options === void 0 ? void 0 : options.lockTtlMs) !== null && _b !== void 0 ? _b : 15 * 60 * 1000;
+        this.runner = options === null || options === void 0 ? void 0 : options.runner;
+    }
+    JobsService.prototype.define = function (name, definition) {
+        if (definition.schedule) {
+            (0, scheduleCron_1.validateScheduleDefinition)({
+                cron: definition.schedule.cron,
+                defaultTimezone: this.defaultTimezone,
+                scheduleTimezone: definition.schedule.timezone,
+            });
+        }
+        this.definitions.set(name, definition);
+    };
+    JobsService.prototype.getDefinition = function (name) {
+        return this.definitions.get(name);
+    };
+    JobsService.prototype.getDefaultTimezone = function () {
+        return this.defaultTimezone;
+    };
+    JobsService.prototype.getLockTtlMs = function () {
+        return this.lockTtlMs;
+    };
+    JobsService.prototype.isSchedulesDirty = function () {
+        return this.schedulesDirty;
+    };
+    JobsService.prototype.markSchedulesDirty = function () {
+        this.schedulesDirty = true;
+    };
+    JobsService.prototype.reconcileSchedulesIfDirty = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.schedulesDirty) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.reconcileSchedules()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    JobsService.prototype.reconcileSchedules = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b, _c, name_1, definition, timezone, cron, existing, cronTimezoneChanged, update, e_1_1;
+            var e_1, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _e.trys.push([0, 8, 9, 10]);
+                        _a = __values(this.definitions), _b = _a.next();
+                        _e.label = 1;
+                    case 1:
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        _c = __read(_b.value, 2), name_1 = _c[0], definition = _c[1];
+                        if (!definition.schedule) {
+                            return [3 /*break*/, 6];
+                        }
+                        timezone = (0, scheduleCron_1.resolveScheduleTimezone)({
+                            defaultTimezone: this.defaultTimezone,
+                            scheduleTimezone: definition.schedule.timezone,
+                        });
+                        cron = definition.schedule.cron;
+                        return [4 /*yield*/, jobSchedule_1.JobSchedule.findOneOrNone({ name: name_1 })];
+                    case 2:
+                        existing = _e.sent();
+                        if (!!existing) return [3 /*break*/, 4];
+                        return [4 /*yield*/, jobSchedule_1.JobSchedule.findOneAndUpdate({ name: name_1 }, {
+                                $setOnInsert: {
+                                    cron: cron,
+                                    enabled: true,
+                                    handlerName: name_1,
+                                    nextRunAt: (0, scheduleCron_1.computeInitialNextRunAt)(cron, timezone),
+                                    timezone: timezone,
+                                },
+                            }, { upsert: true })];
+                    case 3:
+                        _e.sent();
+                        return [3 /*break*/, 6];
+                    case 4:
+                        cronTimezoneChanged = existing.cron !== cron || existing.timezone !== timezone;
+                        update = {
+                            cron: cron,
+                            handlerName: name_1,
+                            timezone: timezone,
+                        };
+                        if (cronTimezoneChanged) {
+                            update.nextRunAt = (0, scheduleCron_1.computeInitialNextRunAt)(cron, timezone);
+                        }
+                        return [4 /*yield*/, jobSchedule_1.JobSchedule.updateOne({ _id: existing._id }, { $set: update })];
+                    case 5:
+                        _e.sent();
+                        _e.label = 6;
+                    case 6:
+                        _b = _a.next();
+                        return [3 /*break*/, 1];
+                    case 7: return [3 /*break*/, 10];
+                    case 8:
+                        e_1_1 = _e.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
+                    case 9:
+                        try {
+                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
+                    case 10:
+                        this.schedulesDirty = false;
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    JobsService.prototype.tickSchedules = function (now) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, (0, scheduler_1.tickDueSchedules)({
+                            jobsService: this,
+                            now: now,
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    JobsService.prototype.enqueue = function (params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var definition, runAt, maxAttempts, backoffMs, maxBackoffMs, idempotencyKey, existing, createPayload, job, error_1;
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            return __generator(this, function (_j) {
+                switch (_j.label) {
+                    case 0:
+                        definition = this.definitions.get(params.name);
+                        if (!definition) {
+                            throw new api_1.APIError({ status: 400, title: UNKNOWN_JOB_NAME_TITLE });
+                        }
+                        runAt = (_a = params.runAt) !== null && _a !== void 0 ? _a : luxon_1.DateTime.utc().toJSDate();
+                        maxAttempts = (_c = (_b = definition.retry) === null || _b === void 0 ? void 0 : _b.maxAttempts) !== null && _c !== void 0 ? _c : DEFAULT_MAX_ATTEMPTS;
+                        backoffMs = (_e = (_d = definition.retry) === null || _d === void 0 ? void 0 : _d.backoffMs) !== null && _e !== void 0 ? _e : retryBackoff_1.DEFAULT_BACKOFF_MS;
+                        maxBackoffMs = (_g = (_f = definition.retry) === null || _f === void 0 ? void 0 : _f.maxBackoffMs) !== null && _g !== void 0 ? _g : retryBackoff_1.DEFAULT_MAX_BACKOFF_MS;
+                        idempotencyKey = (_h = params.idempotencyKey) === null || _h === void 0 ? void 0 : _h.trim();
+                        if (!idempotencyKey) return [3 /*break*/, 2];
+                        return [4 /*yield*/, job_1.Job.findOneOrNone({
+                                idempotencyKey: idempotencyKey,
+                                name: params.name,
+                            })];
+                    case 1:
+                        existing = _j.sent();
+                        if (existing) {
+                            return [2 /*return*/, existing];
+                        }
+                        _j.label = 2;
+                    case 2:
+                        createPayload = __assign(__assign({ attemptCount: 0, backoffMs: backoffMs, maxAttempts: maxAttempts, maxBackoffMs: maxBackoffMs, name: params.name, payload: params.payload, payloadRedacted: false, runAt: runAt, status: "pending" }, (idempotencyKey ? { idempotencyKey: idempotencyKey } : {})), (params.scheduleId ? { scheduleId: new mongoose_1.default.Types.ObjectId(params.scheduleId) } : {}));
+                        _j.label = 3;
+                    case 3:
+                        _j.trys.push([3, 5, , 6]);
+                        return [4 /*yield*/, job_1.Job.create(createPayload)];
+                    case 4:
+                        job = _j.sent();
+                        return [3 /*break*/, 6];
+                    case 5:
+                        error_1 = _j.sent();
+                        if (!idempotencyKey || !isDuplicateKeyError(error_1)) {
+                            throw error_1;
+                        }
+                        return [2 /*return*/, job_1.Job.findExactlyOne({
+                                idempotencyKey: idempotencyKey,
+                                name: params.name,
+                            })];
+                    case 6:
+                        if (!this.runner) return [3 /*break*/, 8];
+                        return [4 /*yield*/, (0, dispatchCompensation_1.dispatchJobToRunner)(this.runner, job)];
+                    case 7:
+                        _j.sent();
+                        _j.label = 8;
+                    case 8: return [2 /*return*/, job];
+                }
+            });
+        });
+    };
+    JobsService.prototype.adminRetryJob = function (jobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var original, definition, now, retry, linked, current;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!mongoose_1.default.isValidObjectId(jobId)) {
+                            throw new api_1.NotFoundError("Job not found");
+                        }
+                        return [4 /*yield*/, job_1.Job.findOneOrNone({ _id: jobId })];
+                    case 1:
+                        original = _a.sent();
+                        if (!original) {
+                            throw new api_1.NotFoundError("Job not found");
+                        }
+                        if (original.retriedById) {
+                            throw new api_1.APIError({ status: 409, title: "Job already retried" });
+                        }
+                        if (original.status !== "dead" && original.status !== "failed") {
+                            throw new api_1.APIError({
+                                detail: "Status is ".concat(original.status),
+                                status: 400,
+                                title: "Job cannot be retried",
+                            });
+                        }
+                        definition = this.definitions.get(original.name);
+                        if (!definition) {
+                            throw new api_1.APIError({ status: 400, title: UNKNOWN_JOB_NAME_TITLE });
+                        }
+                        now = luxon_1.DateTime.utc().toJSDate();
+                        return [4 /*yield*/, job_1.Job.create({
+                                attemptCount: 0,
+                                attempts: [],
+                                backoffMs: original.backoffMs,
+                                maxAttempts: original.maxAttempts,
+                                maxBackoffMs: original.maxBackoffMs,
+                                name: original.name,
+                                payload: original.payload,
+                                payloadRedacted: original.payloadRedacted,
+                                retriedFromId: original._id,
+                                runAt: now,
+                                scheduleId: original.scheduleId,
+                                status: "pending",
+                            })];
+                    case 2:
+                        retry = _a.sent();
+                        return [4 /*yield*/, job_1.Job.findOneAndUpdate({
+                                _id: original._id,
+                                retriedById: { $exists: false },
+                                status: { $in: ["dead", "failed"] },
+                            }, { $set: { retriedById: retry._id } }, { returnDocument: "after" })];
+                    case 3:
+                        linked = _a.sent();
+                        if (!!linked) return [3 /*break*/, 6];
+                        return [4 /*yield*/, job_1.Job.deleteOne({ _id: retry._id })];
+                    case 4:
+                        _a.sent();
+                        return [4 /*yield*/, job_1.Job.findOneOrNone({ _id: original._id })];
+                    case 5:
+                        current = _a.sent();
+                        if (current === null || current === void 0 ? void 0 : current.retriedById) {
+                            throw new api_1.APIError({ status: 409, title: "Job already retried" });
+                        }
+                        throw new api_1.APIError({ status: 409, title: "Job state changed" });
+                    case 6:
+                        if (!this.runner) return [3 /*break*/, 8];
+                        return [4 /*yield*/, (0, dispatchCompensation_1.dispatchJobToRunner)(this.runner, retry)];
+                    case 7:
+                        _a.sent();
+                        _a.label = 8;
+                    case 8: return [2 /*return*/, { original: linked, retry: retry }];
+                }
+            });
+        });
+    };
+    JobsService.prototype.adminRequeueJob = function (jobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var now, requeued, existing;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!mongoose_1.default.isValidObjectId(jobId)) {
+                            throw new api_1.NotFoundError("Job not found");
+                        }
+                        now = luxon_1.DateTime.utc().toJSDate();
+                        return [4 /*yield*/, job_1.Job.findOneAndUpdate({
+                                _id: jobId,
+                                retriedById: { $exists: false },
+                                status: { $in: ["cancelled", "dead", "failed"] },
+                            }, {
+                                $set: { runAt: now, status: "pending" },
+                                $unset: { lockedAt: "", lockedBy: "" },
+                            }, { returnDocument: "after" })];
+                    case 1:
+                        requeued = _a.sent();
+                        if (!!requeued) return [3 /*break*/, 3];
+                        return [4 /*yield*/, job_1.Job.findOneOrNone({ _id: jobId })];
+                    case 2:
+                        existing = _a.sent();
+                        if (!existing) {
+                            throw new api_1.NotFoundError("Job not found");
+                        }
+                        if (existing.retriedById) {
+                            throw new api_1.APIError({ status: 409, title: "Job already retried" });
+                        }
+                        throw new api_1.APIError({
+                            detail: "Status is ".concat(existing.status),
+                            status: 400,
+                            title: "Job cannot be requeued",
+                        });
+                    case 3:
+                        if (!this.runner) return [3 /*break*/, 5];
+                        return [4 /*yield*/, (0, dispatchCompensation_1.dispatchJobToRunner)(this.runner, requeued)];
+                    case 4:
+                        _a.sent();
+                        _a.label = 5;
+                    case 5: return [2 /*return*/, requeued];
+                }
+            });
+        });
+    };
+    JobsService.prototype.adminCancelJob = function (jobId) {
+        return __awaiter(this, void 0, void 0, function () {
+            var cancelled, existing;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!mongoose_1.default.isValidObjectId(jobId)) {
+                            throw new api_1.NotFoundError("Job not found");
+                        }
+                        return [4 /*yield*/, job_1.Job.findOneAndUpdate({
+                                _id: jobId,
+                                status: { $in: ["pending", "running", "scheduled"] },
+                            }, {
+                                $set: { status: "cancelled" },
+                                $unset: { lockedAt: "", lockedBy: "" },
+                            }, { returnDocument: "after" })];
+                    case 1:
+                        cancelled = _a.sent();
+                        if (!!cancelled) return [3 /*break*/, 3];
+                        return [4 /*yield*/, job_1.Job.findOneOrNone({ _id: jobId })];
+                    case 2:
+                        existing = _a.sent();
+                        if (!existing) {
+                            throw new api_1.NotFoundError("Job not found");
+                        }
+                        throw new api_1.APIError({
+                            detail: "Status is ".concat(existing.status),
+                            status: 400,
+                            title: "Job cannot be cancelled",
+                        });
+                    case 3:
+                        (0, activeJobExecution_1.abortActiveJobExecution)(jobId);
+                        return [2 /*return*/, cancelled];
+                }
+            });
+        });
+    };
+    JobsService.prototype.pauseSchedule = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var updated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, jobSchedule_1.JobSchedule.findOneAndUpdate({ name: name }, { $set: { enabled: false } }, { returnDocument: "after" })];
+                    case 1:
+                        updated = _a.sent();
+                        if (!updated) {
+                            throw new api_1.NotFoundError("Schedule not found");
+                        }
+                        return [2 /*return*/, updated];
+                }
+            });
+        });
+    };
+    JobsService.prototype.resumeSchedule = function (name) {
+        return __awaiter(this, void 0, void 0, function () {
+            var updated;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, jobSchedule_1.JobSchedule.findOneAndUpdate({ name: name }, { $set: { enabled: true } }, { returnDocument: "after" })];
+                    case 1:
+                        updated = _a.sent();
+                        if (!updated) {
+                            throw new api_1.NotFoundError("Schedule not found");
+                        }
+                        return [2 /*return*/, updated];
+                }
+            });
+        });
+    };
+    return JobsService;
+}());
+exports.JobsService = JobsService;
+var registeredJobsService;
+var getJobsService = function () {
+    if (!registeredJobsService) {
+        throw new api_1.APIError({ status: 500, title: "JobsApp is not registered" });
+    }
+    return registeredJobsService;
+};
+exports.getJobsService = getJobsService;
+/** Returns the registered jobs service when `JobsApp` is mounted; otherwise `undefined`. */
+var tryGetJobsService = function () { return registeredJobsService; };
+exports.tryGetJobsService = tryGetJobsService;
+var registerJobsService = function (service) {
+    registeredJobsService = service;
+};
+exports.registerJobsService = registerJobsService;
+/** Clears the process-wide jobs service. Tests use this so AdminApp falls back to in-process runs. */
+var unregisterJobsService = function () {
+    registeredJobsService = undefined;
+};
+exports.unregisterJobsService = unregisterJobsService;

package/dist/modelTypes.d.ts

@@ -0,0 +1,52 @@
+import type { FindExactlyOnePlugin, FindOneOrNonePlugin } from "@terreno/api";
+import type mongoose from "mongoose";
+export type JobStatus = "cancelled" | "completed" | "dead" | "failed" | "pending" | "running" | "scheduled";
+export declare const IN_FLIGHT_JOB_STATUSES: readonly JobStatus[];
+export interface JobAttempt {
+    at: Date;
+    error?: string;
+    errorClass?: string;
+}
+export type JobMethods = Record<never, never>;
+export interface JobDocument extends mongoose.Document<mongoose.Types.ObjectId>, JobMethods {
+    attemptCount: number;
+    attempts: JobAttempt[];
+    backoffMs: number;
+    created: Date;
+    idempotencyKey?: string;
+    lastError?: string;
+    lockedAt?: Date;
+    lockedBy?: string;
+    maxAttempts: number;
+    maxBackoffMs: number;
+    name: string;
+    payload?: unknown;
+    payloadRedacted: boolean;
+    retriedById?: mongoose.Types.ObjectId;
+    retriedFromId?: mongoose.Types.ObjectId;
+    runAt: Date;
+    scheduleId?: mongoose.Types.ObjectId;
+    status: JobStatus;
+    updated: Date;
+}
+export interface JobStatics extends FindExactlyOnePlugin<JobDocument>, FindOneOrNonePlugin<JobDocument> {
+}
+export interface JobModel extends mongoose.Model<JobDocument>, JobStatics {
+}
+export type JobSchema = mongoose.Schema<JobDocument, JobModel, JobMethods>;
+export type JobScheduleMethods = Record<never, never>;
+export interface JobScheduleDocument extends mongoose.Document<mongoose.Types.ObjectId>, JobScheduleMethods {
+    created: Date;
+    cron: string;
+    enabled: boolean;
+    handlerName: string;
+    name: string;
+    nextRunAt: Date;
+    timezone: string;
+    updated: Date;
+}
+export interface JobScheduleStatics extends FindExactlyOnePlugin<JobScheduleDocument>, FindOneOrNonePlugin<JobScheduleDocument> {
+}
+export interface JobScheduleModel extends mongoose.Model<JobScheduleDocument>, JobScheduleStatics {
+}
+export type JobScheduleSchema = mongoose.Schema<JobScheduleDocument, JobScheduleModel, JobScheduleMethods>;

package/dist/modelTypes.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IN_FLIGHT_JOB_STATUSES = void 0;
+exports.IN_FLIGHT_JOB_STATUSES = ["pending", "running", "scheduled"];

package/dist/models/job.d.ts

@@ -0,0 +1,2 @@
+import type { JobModel } from "../modelTypes";
+export declare const Job: JobModel;