@terreno/jobs 57.4.0

package/dist/routes/jobsExecute.js

@@ -0,0 +1,119 @@
+"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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerJobsExecuteRoute = void 0;
+var api_1 = require("@terreno/api");
+var jobExecutor_1 = require("../jobExecutor");
+var JOB_NOT_FOUND_TITLE = "Job not found";
+var readJobId = function (body) {
+    if (!body || typeof body !== "object" || !("jobId" in body)) {
+        return undefined;
+    }
+    var jobId = body.jobId;
+    if (typeof jobId !== "string") {
+        return undefined;
+    }
+    var trimmed = jobId.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+var serializeJob = function (job) {
+    var json = job.toJSON();
+    if (json._id && typeof json._id === "object" && "toString" in json._id) {
+        return __assign(__assign({}, json), { id: json._id.toString() });
+    }
+    return json;
+};
+var registerJobsExecuteRoute = function (_a) {
+    var app = _a.app, options = _a.options;
+    var path = "".concat(options.basePath, "/execute");
+    app.post(path, (0, api_1.asyncHandler)(function (req, res) { return __awaiter(void 0, void 0, void 0, function () {
+        var authorized, _a, _b, jobId, outcome;
+        return __generator(this, function (_c) {
+            switch (_c.label) {
+                case 0:
+                    authorized = false;
+                    _c.label = 1;
+                case 1:
+                    _c.trys.push([1, 3, , 4]);
+                    _a = Boolean;
+                    return [4 /*yield*/, options.executeAuth(req)];
+                case 2:
+                    authorized = _a.apply(void 0, [_c.sent()]);
+                    return [3 /*break*/, 4];
+                case 3:
+                    _b = _c.sent();
+                    authorized = false;
+                    return [3 /*break*/, 4];
+                case 4:
+                    if (!authorized) {
+                        throw new api_1.UnauthorizedError("Unauthorized");
+                    }
+                    jobId = readJobId(req.body);
+                    if (!jobId) {
+                        throw new api_1.APIError({ status: 400, title: "jobId is required" });
+                    }
+                    return [4 /*yield*/, (0, jobExecutor_1.executeJobById)({
+                            host: options.host,
+                            jobId: jobId,
+                            signal: AbortSignal.timeout(30 * 60 * 1000),
+                        })];
+                case 5:
+                    outcome = _c.sent();
+                    if (outcome.kind === "not_found") {
+                        throw new api_1.NotFoundError(JOB_NOT_FOUND_TITLE);
+                    }
+                    if (outcome.kind === "conflict") {
+                        throw new api_1.ConflictError(outcome.reason === "not_due" ? "Job is not due yet" : "Job is already running");
+                    }
+                    return [2 /*return*/, res.status(200).json({ data: serializeJob(outcome.job) })];
+            }
+        });
+    }); }));
+};
+exports.registerJobsExecuteRoute = registerJobsExecuteRoute;

package/dist/runners/gcpCloudTasks.d.ts

@@ -0,0 +1,78 @@
+import type { JobDocument } from "../modelTypes";
+import type { JobRunner, JobRunnerStartOptions } from "../types";
+export interface GcpTimestamp {
+    nanos?: number;
+    seconds: number;
+}
+/** protobuf Duration (`google.protobuf.Duration`) — used by `@google-cloud/tasks`. */
+export interface GcpDuration {
+    nanos?: number;
+    seconds: number;
+}
+export interface GcpHttpRequest {
+    body?: string;
+    headers?: Record<string, string>;
+    httpMethod: "POST";
+    oidcToken?: {
+        audience?: string;
+        serviceAccountEmail: string;
+    };
+    url: string;
+}
+export interface GcpTask {
+    dispatchDeadline?: GcpDuration;
+    httpRequest?: GcpHttpRequest;
+    scheduleTime?: GcpTimestamp;
+}
+export interface GcpCreateTaskRequest {
+    parent: string;
+    task: GcpTask;
+}
+export interface GcpCreateTaskResponse {
+    name?: string;
+}
+/** Narrow Cloud Tasks client seam — inject in tests; production loads `@google-cloud/tasks`. */
+export interface GcpCloudTasksClient {
+    createTask(request: GcpCreateTaskRequest): Promise<[GcpCreateTaskResponse]>;
+    queuePath(project: string, location: string, queue: string): string;
+}
+/** Cloud Tasks HTTP `dispatchDeadline` bounds (15s–30min). Default 30min matches Cloud Run. */
+export declare const GCP_HTTP_TASK_MIN_DISPATCH_DEADLINE_SECONDS = 15;
+export declare const GCP_HTTP_TASK_MAX_DISPATCH_DEADLINE_SECONDS = 1800;
+export declare const GCP_HTTP_TASK_DEFAULT_DISPATCH_DEADLINE_SECONDS = 1800;
+export interface GcpCloudTasksRunnerConfig {
+    basePath?: string;
+    /** Injected client for tests. Production wiring loads `@google-cloud/tasks`. */
+    client?: GcpCloudTasksClient;
+    /**
+     * Seconds Cloud Tasks waits for POST /jobs/execute before retrying.
+     * HTTP range is 15–1800. Default 1800 so a 30-minute handler is not retried at 10 minutes.
+     */
+    dispatchDeadlineSeconds?: number;
+    location: string;
+    oidcAudience?: string;
+    project: string;
+    publicUrl: string;
+    queue: string;
+    serviceAccountEmail: string;
+}
+/**
+ * Dispatch-only runner that enqueues Cloud Tasks HTTP POST callbacks to
+ * `{publicUrl}{basePath}/execute` with an OIDC token.
+ *
+ * `start()` ticks Mongo schedules so cron rows enqueue Cloud Tasks. It does not
+ * claim job rows — execution happens on POST /jobs/execute.
+ */
+export declare class GcpCloudTasksRunner implements JobRunner {
+    readonly id = "gcp-cloud-tasks";
+    readonly requiresExecuteRoute = true;
+    private readonly client;
+    private readonly config;
+    private pollIntervalMs;
+    private running;
+    private stopResolve;
+    constructor(config: GcpCloudTasksRunnerConfig);
+    enqueue(job: JobDocument): Promise<void>;
+    start(options: JobRunnerStartOptions): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist/runners/gcpCloudTasks.js

@@ -0,0 +1,256 @@
+"use strict";
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GcpCloudTasksRunner = exports.GCP_HTTP_TASK_DEFAULT_DISPATCH_DEADLINE_SECONDS = exports.GCP_HTTP_TASK_MAX_DISPATCH_DEADLINE_SECONDS = exports.GCP_HTTP_TASK_MIN_DISPATCH_DEADLINE_SECONDS = void 0;
+var node_module_1 = require("node:module");
+var luxon_1 = require("luxon");
+/** Cloud Tasks HTTP `dispatchDeadline` bounds (15s–30min). Default 30min matches Cloud Run. */
+exports.GCP_HTTP_TASK_MIN_DISPATCH_DEADLINE_SECONDS = 15;
+exports.GCP_HTTP_TASK_MAX_DISPATCH_DEADLINE_SECONDS = 1800;
+exports.GCP_HTTP_TASK_DEFAULT_DISPATCH_DEADLINE_SECONDS = 1800;
+var nodeRequire = (0, node_module_1.createRequire)(__filename);
+var requireNonEmpty = function (value, label) {
+    var trimmed = value === null || value === void 0 ? void 0 : value.trim();
+    if (!trimmed) {
+        throw new Error("GcpCloudTasksRunner requires ".concat(label));
+    }
+    return trimmed;
+};
+var normalizePublicUrl = function (publicUrl) {
+    var parsed;
+    try {
+        parsed = new URL(publicUrl);
+    }
+    catch (_a) {
+        throw new Error("GcpCloudTasksRunner publicUrl must be an absolute http(s) URL, received: ".concat(publicUrl));
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("GcpCloudTasksRunner publicUrl must use http or https, received: ".concat(publicUrl));
+    }
+    return parsed.toString().replace(/\/+$/, "");
+};
+var normalizeBasePath = function (basePath) {
+    var trimmed = (basePath !== null && basePath !== void 0 ? basePath : "/jobs").trim();
+    if (!trimmed.startsWith("/")) {
+        throw new Error("GcpCloudTasksRunner basePath must start with \"/\", received: ".concat(basePath));
+    }
+    return trimmed.replace(/\/+$/, "") || "/";
+};
+var validateDispatchDeadlineSeconds = function (dispatchDeadlineSeconds) {
+    if (dispatchDeadlineSeconds === undefined) {
+        return exports.GCP_HTTP_TASK_DEFAULT_DISPATCH_DEADLINE_SECONDS;
+    }
+    if (!Number.isFinite(dispatchDeadlineSeconds) ||
+        dispatchDeadlineSeconds < exports.GCP_HTTP_TASK_MIN_DISPATCH_DEADLINE_SECONDS ||
+        dispatchDeadlineSeconds > exports.GCP_HTTP_TASK_MAX_DISPATCH_DEADLINE_SECONDS) {
+        throw new Error("GcpCloudTasksRunner dispatchDeadlineSeconds must be between ".concat(exports.GCP_HTTP_TASK_MIN_DISPATCH_DEADLINE_SECONDS, " and ").concat(exports.GCP_HTTP_TASK_MAX_DISPATCH_DEADLINE_SECONDS, " seconds"));
+    }
+    return dispatchDeadlineSeconds;
+};
+var toProtobufDuration = function (dispatchDeadlineSeconds) { return ({
+    seconds: dispatchDeadlineSeconds,
+}); };
+var resolveConfig = function (config) {
+    var _a;
+    return ({
+        basePath: normalizeBasePath(config.basePath),
+        dispatchDeadline: toProtobufDuration(validateDispatchDeadlineSeconds(config.dispatchDeadlineSeconds)),
+        location: requireNonEmpty(config.location, "location"),
+        oidcAudience: ((_a = config.oidcAudience) === null || _a === void 0 ? void 0 : _a.trim()) || undefined,
+        project: requireNonEmpty(config.project, "project"),
+        publicUrl: normalizePublicUrl(requireNonEmpty(config.publicUrl, "publicUrl")),
+        queue: requireNonEmpty(config.queue, "queue"),
+        serviceAccountEmail: requireNonEmpty(config.serviceAccountEmail, "serviceAccountEmail"),
+    });
+};
+var loadCloudTasksClient = function () {
+    try {
+        var module_1 = nodeRequire("@google-cloud/tasks");
+        return module_1.CloudTasksClient;
+    }
+    catch (_a) {
+        throw new Error("GcpCloudTasksRunner requires optional peer dependency @google-cloud/tasks. " +
+            "Install it with: bun add @google-cloud/tasks");
+    }
+};
+var buildExecuteUrl = function (publicUrl, basePath) {
+    return "".concat(publicUrl).concat(basePath, "/execute");
+};
+var buildScheduleTime = function (runAt) {
+    var scheduled = luxon_1.DateTime.fromJSDate(runAt, { zone: "utc" });
+    var now = luxon_1.DateTime.utc();
+    if (scheduled <= now) {
+        return undefined;
+    }
+    return {
+        nanos: (scheduled.toMillis() % 1000) * 1000000,
+        seconds: Math.floor(scheduled.toSeconds()),
+    };
+};
+var waitForAbortOrTimeout = function (signal, timeoutMs) {
+    return new Promise(function (resolve) {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        var timer = setTimeout(function () {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, timeoutMs);
+        var onAbort = function () {
+            clearTimeout(timer);
+            resolve();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+};
+var DEFAULT_SCHEDULE_POLL_INTERVAL_MS = 1000;
+/**
+ * Dispatch-only runner that enqueues Cloud Tasks HTTP POST callbacks to
+ * `{publicUrl}{basePath}/execute` with an OIDC token.
+ *
+ * `start()` ticks Mongo schedules so cron rows enqueue Cloud Tasks. It does not
+ * claim job rows — execution happens on POST /jobs/execute.
+ */
+var GcpCloudTasksRunner = /** @class */ (function () {
+    function GcpCloudTasksRunner(config) {
+        var _a;
+        this.id = "gcp-cloud-tasks";
+        this.requiresExecuteRoute = true;
+        this.pollIntervalMs = DEFAULT_SCHEDULE_POLL_INTERVAL_MS;
+        this.running = false;
+        this.config = resolveConfig(config);
+        this.client = (_a = config.client) !== null && _a !== void 0 ? _a : new (loadCloudTasksClient())();
+    }
+    GcpCloudTasksRunner.prototype.enqueue = function (job) {
+        return __awaiter(this, void 0, void 0, function () {
+            var executeUrl, body, task, scheduleTime, parent;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        executeUrl = buildExecuteUrl(this.config.publicUrl, this.config.basePath);
+                        body = Buffer.from(JSON.stringify({ jobId: job._id.toString() })).toString("base64");
+                        task = {
+                            dispatchDeadline: this.config.dispatchDeadline,
+                            httpRequest: {
+                                body: body,
+                                headers: {
+                                    "Content-Type": "application/json",
+                                },
+                                httpMethod: "POST",
+                                oidcToken: {
+                                    audience: (_a = this.config.oidcAudience) !== null && _a !== void 0 ? _a : executeUrl,
+                                    serviceAccountEmail: this.config.serviceAccountEmail,
+                                },
+                                url: executeUrl,
+                            },
+                        };
+                        scheduleTime = buildScheduleTime(job.runAt);
+                        if (scheduleTime) {
+                            task.scheduleTime = scheduleTime;
+                        }
+                        parent = this.client.queuePath(this.config.project, this.config.location, this.config.queue);
+                        return [4 /*yield*/, this.client.createTask({ parent: parent, task: task })];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GcpCloudTasksRunner.prototype.start = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.pollIntervalMs = (_a = options.pollIntervalMs) !== null && _a !== void 0 ? _a : DEFAULT_SCHEDULE_POLL_INTERVAL_MS;
+                        this.running = true;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, , 7, 8]);
+                        _c.label = 2;
+                    case 2:
+                        if (!!options.signal.aborted) return [3 /*break*/, 6];
+                        return [4 /*yield*/, options.jobs.reconcileSchedulesIfDirty()];
+                    case 3:
+                        _c.sent();
+                        return [4 /*yield*/, options.jobs.tickSchedules()];
+                    case 4:
+                        _c.sent();
+                        if (options.signal.aborted) {
+                            return [3 /*break*/, 6];
+                        }
+                        return [4 /*yield*/, waitForAbortOrTimeout(options.signal, this.pollIntervalMs)];
+                    case 5:
+                        _c.sent();
+                        return [3 /*break*/, 2];
+                    case 6: return [3 /*break*/, 8];
+                    case 7:
+                        this.running = false;
+                        (_b = this.stopResolve) === null || _b === void 0 ? void 0 : _b.call(this);
+                        this.stopResolve = undefined;
+                        return [7 /*endfinally*/];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    GcpCloudTasksRunner.prototype.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.running) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                _this.stopResolve = resolve;
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return GcpCloudTasksRunner;
+}());
+exports.GcpCloudTasksRunner = GcpCloudTasksRunner;

package/dist/runners/mongoRunner.d.ts

@@ -0,0 +1,14 @@
+import type { JobDocument } from "../modelTypes";
+import type { JobRunner, JobRunnerStartOptions } from "../types";
+/** @internal */
+export { getWorkerId, hasWorkerIdPrefix } from "../claimLock";
+export declare class MongoJobRunner implements JobRunner {
+    readonly id = "mongo";
+    private pollIntervalMs;
+    private running;
+    private stopResolve;
+    enqueue(_job: JobDocument): Promise<void>;
+    start(options: JobRunnerStartOptions): Promise<void>;
+    stop(): Promise<void>;
+    private processNext;
+}

package/dist/runners/mongoRunner.js

@@ -0,0 +1,204 @@
+"use strict";
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoJobRunner = exports.hasWorkerIdPrefix = exports.getWorkerId = void 0;
+var luxon_1 = require("luxon");
+var claimLock_1 = require("../claimLock");
+var jobExecutor_1 = require("../jobExecutor");
+var job_1 = require("../models/job");
+var DEFAULT_POLL_INTERVAL_MS = 1000;
+/** @internal */
+var claimLock_2 = require("../claimLock");
+Object.defineProperty(exports, "getWorkerId", { enumerable: true, get: function () { return claimLock_2.getWorkerId; } });
+Object.defineProperty(exports, "hasWorkerIdPrefix", { enumerable: true, get: function () { return claimLock_2.hasWorkerIdPrefix; } });
+var buildLockExpiry = function (lockTtlMs) {
+    return luxon_1.DateTime.utc().minus({ milliseconds: lockTtlMs }).toJSDate();
+};
+var waitForAbortOrTimeout = function (signal, timeoutMs) {
+    return new Promise(function (resolve) {
+        if (signal.aborted) {
+            resolve();
+            return;
+        }
+        var timer = setTimeout(function () {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, timeoutMs);
+        var onAbort = function () {
+            clearTimeout(timer);
+            resolve();
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+};
+var readClaimLock = function (job) {
+    if (!job.lockedAt || !job.lockedBy) {
+        throw new Error("Job ".concat(job._id.toString(), " is missing claim lock metadata"));
+    }
+    return {
+        lockedAt: job.lockedAt,
+        lockedBy: job.lockedBy,
+    };
+};
+var MongoJobRunner = /** @class */ (function () {
+    function MongoJobRunner() {
+        this.id = "mongo";
+        this.pollIntervalMs = DEFAULT_POLL_INTERVAL_MS;
+        this.running = false;
+    }
+    MongoJobRunner.prototype.enqueue = function (_job) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/];
+            });
+        });
+    };
+    MongoJobRunner.prototype.start = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var processedAny, processed;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        this.pollIntervalMs = (_a = options.pollIntervalMs) !== null && _a !== void 0 ? _a : DEFAULT_POLL_INTERVAL_MS;
+                        this.running = true;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, , 11, 12]);
+                        _c.label = 2;
+                    case 2:
+                        if (!!options.signal.aborted) return [3 /*break*/, 10];
+                        return [4 /*yield*/, options.jobs.reconcileSchedulesIfDirty()];
+                    case 3:
+                        _c.sent();
+                        return [4 /*yield*/, options.jobs.tickSchedules()];
+                    case 4:
+                        _c.sent();
+                        processedAny = false;
+                        _c.label = 5;
+                    case 5:
+                        if (!!options.signal.aborted) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.processNext(options)];
+                    case 6:
+                        processed = _c.sent();
+                        if (!processed) {
+                            return [3 /*break*/, 7];
+                        }
+                        processedAny = true;
+                        return [3 /*break*/, 5];
+                    case 7:
+                        if (options.signal.aborted) {
+                            return [3 /*break*/, 10];
+                        }
+                        if (!!processedAny) return [3 /*break*/, 9];
+                        return [4 /*yield*/, waitForAbortOrTimeout(options.signal, this.pollIntervalMs)];
+                    case 8:
+                        _c.sent();
+                        _c.label = 9;
+                    case 9: return [3 /*break*/, 2];
+                    case 10: return [3 /*break*/, 12];
+                    case 11:
+                        this.running = false;
+                        (_b = this.stopResolve) === null || _b === void 0 ? void 0 : _b.call(this);
+                        this.stopResolve = undefined;
+                        return [7 /*endfinally*/];
+                    case 12: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MongoJobRunner.prototype.stop = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.running) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, new Promise(function (resolve) {
+                                _this.stopResolve = resolve;
+                            })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    MongoJobRunner.prototype.processNext = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var now, lockExpiry, claim, claimed;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        now = luxon_1.DateTime.utc().toJSDate();
+                        lockExpiry = buildLockExpiry(options.jobs.getLockTtlMs());
+                        claim = (0, claimLock_1.createClaimLock)(now);
+                        return [4 /*yield*/, job_1.Job.findOneAndUpdate({
+                                $or: [{ lockedAt: { $exists: false } }, { lockedAt: null }, { lockedAt: { $lte: lockExpiry } }],
+                                runAt: { $lte: now },
+                                status: { $in: ["pending", "running", "scheduled"] },
+                            }, {
+                                $set: {
+                                    lockedAt: claim.lockedAt,
+                                    lockedBy: claim.lockedBy,
+                                    status: "running",
+                                },
+                            }, { returnDocument: "after", sort: { runAt: 1 } })];
+                    case 1:
+                        claimed = _a.sent();
+                        if (!claimed) {
+                            return [2 /*return*/, false];
+                        }
+                        return [4 /*yield*/, (0, jobExecutor_1.runClaimedJob)({
+                                claim: readClaimLock(claimed),
+                                host: options.jobs,
+                                job: claimed,
+                                signal: options.signal,
+                            })];
+                    case 2:
+                        _a.sent();
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    return MongoJobRunner;
+}());
+exports.MongoJobRunner = MongoJobRunner;