@terreno/jobs 57.4.0 → 57.6.0

package/dist/jobsService.js

@@ -1,112 +1,38 @@
 "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;
+const api_1 = require("@terreno/api");
+const luxon_1 = require("luxon");
+const mongoose_1 = __importDefault(require("mongoose"));
+const activeJobExecution_1 = require("./activeJobExecution");
+const dispatchCompensation_1 = require("./dispatchCompensation");
+const job_1 = require("./models/job");
+const jobSchedule_1 = require("./models/jobSchedule");
+const retryBackoff_1 = require("./retryBackoff");
+const scheduleCron_1 = require("./scheduleCron");
+const scheduler_1 = require("./scheduler");
+const DEFAULT_MAX_ATTEMPTS = 5;
+const DEFAULT_TIMEZONE = "UTC";
+const UNKNOWN_JOB_NAME_TITLE = "Unknown job name";
+const isDuplicateKeyError = (error) => Boolean(error &&
+    typeof error === "object" &&
+    "code" in error &&
+    error.code === 11_000);
+class JobsService {
+    defaultTimezone;
+    definitions = new Map();
+    lockTtlMs;
+    runner;
+    schedulesDirty = false;
+    constructor(options) {
+        this.defaultTimezone = options?.defaultTimezone ?? DEFAULT_TIMEZONE;
+        this.lockTtlMs = options?.lockTtlMs ?? 15 * 60 * 1000;
+        this.runner = options?.runner;
     }
-    JobsService.prototype.define = function (name, definition) {
+    define(name, definition) {
         if (definition.schedule) {
             (0, scheduleCron_1.validateScheduleDefinition)({
                 cron: definition.schedule.cron,
@@ -115,376 +41,250 @@ var JobsService = /** @class */ (function () {
             });
         }
         this.definitions.set(name, definition);
-    };
-    JobsService.prototype.getDefinition = function (name) {
+    }
+    getDefinition(name) {
         return this.definitions.get(name);
-    };
-    JobsService.prototype.getDefaultTimezone = function () {
+    }
+    getDefaultTimezone() {
         return this.defaultTimezone;
-    };
-    JobsService.prototype.getLockTtlMs = function () {
+    }
+    getLockTtlMs() {
         return this.lockTtlMs;
-    };
-    JobsService.prototype.isSchedulesDirty = function () {
+    }
+    isSchedulesDirty() {
         return this.schedulesDirty;
-    };
-    JobsService.prototype.markSchedulesDirty = function () {
+    }
+    markSchedulesDirty() {
         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];
-                }
+    }
+    async reconcileSchedulesIfDirty() {
+        if (!this.schedulesDirty) {
+            return;
+        }
+        await this.reconcileSchedules();
+    }
+    async reconcileSchedules() {
+        for (const [name, definition] of this.definitions) {
+            if (!definition.schedule) {
+                continue;
+            }
+            const timezone = (0, scheduleCron_1.resolveScheduleTimezone)({
+                defaultTimezone: this.defaultTimezone,
+                scheduleTimezone: definition.schedule.timezone,
             });
+            const cron = definition.schedule.cron;
+            const existing = await jobSchedule_1.JobSchedule.findOneOrNone({ name });
+            if (!existing) {
+                await jobSchedule_1.JobSchedule.findOneAndUpdate({ name }, {
+                    $setOnInsert: {
+                        cron,
+                        enabled: true,
+                        handlerName: name,
+                        nextRunAt: (0, scheduleCron_1.computeInitialNextRunAt)(cron, timezone),
+                        timezone,
+                    },
+                }, { upsert: true });
+                continue;
+            }
+            const cronTimezoneChanged = existing.cron !== cron || existing.timezone !== timezone;
+            const update = {
+                cron,
+                handlerName: name,
+                timezone,
+            };
+            if (cronTimezoneChanged) {
+                update.nextRunAt = (0, scheduleCron_1.computeInitialNextRunAt)(cron, timezone);
+            }
+            await jobSchedule_1.JobSchedule.updateOne({ _id: existing._id }, { $set: update });
+        }
+        this.schedulesDirty = false;
+    }
+    async tickSchedules(now) {
+        await (0, scheduler_1.tickDueSchedules)({
+            jobsService: this,
+            now,
         });
-    };
-    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 }];
-                }
+    }
+    async enqueue(params) {
+        const definition = this.definitions.get(params.name);
+        if (!definition) {
+            throw new api_1.APIError({ status: 400, title: UNKNOWN_JOB_NAME_TITLE });
+        }
+        const runAt = params.runAt ?? luxon_1.DateTime.utc().toJSDate();
+        const maxAttempts = definition.retry?.maxAttempts ?? DEFAULT_MAX_ATTEMPTS;
+        const backoffMs = definition.retry?.backoffMs ?? retryBackoff_1.DEFAULT_BACKOFF_MS;
+        const maxBackoffMs = definition.retry?.maxBackoffMs ?? retryBackoff_1.DEFAULT_MAX_BACKOFF_MS;
+        const idempotencyKey = params.idempotencyKey?.trim();
+        if (idempotencyKey) {
+            const existing = await job_1.Job.findOneOrNone({
+                idempotencyKey,
+                name: params.name,
             });
-        });
-    };
-    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];
-                }
+            if (existing) {
+                return existing;
+            }
+        }
+        const createPayload = {
+            attemptCount: 0,
+            backoffMs,
+            maxAttempts,
+            maxBackoffMs,
+            name: params.name,
+            payload: params.payload,
+            payloadRedacted: false,
+            runAt,
+            status: "pending",
+            ...(idempotencyKey ? { idempotencyKey } : {}),
+            ...(params.scheduleId ? { scheduleId: new mongoose_1.default.Types.ObjectId(params.scheduleId) } : {}),
+        };
+        let job;
+        try {
+            job = await job_1.Job.create(createPayload);
+        }
+        catch (error) {
+            if (!idempotencyKey || !isDuplicateKeyError(error)) {
+                throw error;
+            }
+            return job_1.Job.findExactlyOne({
+                idempotencyKey,
+                name: params.name,
             });
-        });
-    };
-    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];
-                }
+        }
+        if (this.runner) {
+            await (0, dispatchCompensation_1.dispatchJobToRunner)(this.runner, job);
+        }
+        return job;
+    }
+    async adminRetryJob(jobId) {
+        if (!mongoose_1.default.isValidObjectId(jobId)) {
+            throw new api_1.NotFoundError("Job not found");
+        }
+        const original = await job_1.Job.findOneOrNone({ _id: jobId });
+        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 ${original.status}`,
+                status: 400,
+                title: "Job cannot be retried",
             });
+        }
+        const definition = this.definitions.get(original.name);
+        if (!definition) {
+            throw new api_1.APIError({ status: 400, title: UNKNOWN_JOB_NAME_TITLE });
+        }
+        const now = luxon_1.DateTime.utc().toJSDate();
+        const retry = await 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",
         });
-    };
-    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];
-                }
+        const linked = await job_1.Job.findOneAndUpdate({
+            _id: original._id,
+            retriedById: { $exists: false },
+            status: { $in: ["dead", "failed"] },
+        }, { $set: { retriedById: retry._id } }, { returnDocument: "after" });
+        if (!linked) {
+            await job_1.Job.deleteOne({ _id: retry._id });
+            const current = await job_1.Job.findOneOrNone({ _id: original._id });
+            if (current?.retriedById) {
+                throw new api_1.APIError({ status: 409, title: "Job already retried" });
+            }
+            throw new api_1.APIError({ status: 409, title: "Job state changed" });
+        }
+        if (this.runner) {
+            await (0, dispatchCompensation_1.dispatchJobToRunner)(this.runner, retry);
+        }
+        return { original: linked, retry };
+    }
+    async adminRequeueJob(jobId) {
+        if (!mongoose_1.default.isValidObjectId(jobId)) {
+            throw new api_1.NotFoundError("Job not found");
+        }
+        const now = luxon_1.DateTime.utc().toJSDate();
+        const requeued = await job_1.Job.findOneAndUpdate({
+            _id: jobId,
+            retriedById: { $exists: false },
+            status: { $in: ["cancelled", "dead", "failed"] },
+        }, {
+            $set: { runAt: now, status: "pending" },
+            $unset: { lockedAt: "", lockedBy: "" },
+        }, { returnDocument: "after" });
+        if (!requeued) {
+            const existing = await job_1.Job.findOneOrNone({ _id: jobId });
+            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 ${existing.status}`,
+                status: 400,
+                title: "Job cannot be requeued",
             });
-        });
-    };
-    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];
-                }
+        }
+        if (this.runner) {
+            await (0, dispatchCompensation_1.dispatchJobToRunner)(this.runner, requeued);
+        }
+        return requeued;
+    }
+    async adminCancelJob(jobId) {
+        if (!mongoose_1.default.isValidObjectId(jobId)) {
+            throw new api_1.NotFoundError("Job not found");
+        }
+        const cancelled = await job_1.Job.findOneAndUpdate({
+            _id: jobId,
+            status: { $in: ["pending", "running", "scheduled"] },
+        }, {
+            $set: { status: "cancelled" },
+            $unset: { lockedAt: "", lockedBy: "" },
+        }, { returnDocument: "after" });
+        if (!cancelled) {
+            const existing = await job_1.Job.findOneOrNone({ _id: jobId });
+            if (!existing) {
+                throw new api_1.NotFoundError("Job not found");
+            }
+            throw new api_1.APIError({
+                detail: `Status is ${existing.status}`,
+                status: 400,
+                title: "Job cannot be cancelled",
             });
-        });
-    };
-    return JobsService;
-}());
+        }
+        (0, activeJobExecution_1.abortActiveJobExecution)(jobId);
+        return cancelled;
+    }
+    async pauseSchedule(name) {
+        const updated = await jobSchedule_1.JobSchedule.findOneAndUpdate({ name }, { $set: { enabled: false } }, { returnDocument: "after" });
+        if (!updated) {
+            throw new api_1.NotFoundError("Schedule not found");
+        }
+        return updated;
+    }
+    async resumeSchedule(name) {
+        const updated = await jobSchedule_1.JobSchedule.findOneAndUpdate({ name }, { $set: { enabled: true } }, { returnDocument: "after" });
+        if (!updated) {
+            throw new api_1.NotFoundError("Schedule not found");
+        }
+        return updated;
+    }
+}
 exports.JobsService = JobsService;
-var registeredJobsService;
-var getJobsService = function () {
+let registeredJobsService;
+const getJobsService = () => {
     if (!registeredJobsService) {
         throw new api_1.APIError({ status: 500, title: "JobsApp is not registered" });
     }
@@ -492,14 +292,14 @@ var getJobsService = function () {
 };
 exports.getJobsService = getJobsService;
 /** Returns the registered jobs service when `JobsApp` is mounted; otherwise `undefined`. */
-var tryGetJobsService = function () { return registeredJobsService; };
+const tryGetJobsService = () => registeredJobsService;
 exports.tryGetJobsService = tryGetJobsService;
-var registerJobsService = function (service) {
+const registerJobsService = (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 () {
+const unregisterJobsService = () => {
     registeredJobsService = undefined;
 };
 exports.unregisterJobsService = unregisterJobsService;