@terreno/jobs 57.4.0

package/dist/models/job.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Job = void 0;
+var api_1 = require("@terreno/api");
+var mongoose_1 = __importDefault(require("mongoose"));
+var jobSchema = new mongoose_1.default.Schema({
+    attemptCount: {
+        default: 0,
+        description: "Number of execution attempts recorded for this job",
+        type: Number,
+    },
+    attempts: {
+        default: [],
+        description: "History of execution attempts including errors",
+        type: [
+            {
+                _id: false,
+                at: {
+                    description: "When this execution attempt ran",
+                    required: true,
+                    type: Date,
+                },
+                error: {
+                    description: "Error message captured for this attempt",
+                    type: String,
+                },
+                errorClass: {
+                    description: "Classified error category for this attempt",
+                    type: String,
+                },
+            },
+        ],
+    },
+    backoffMs: {
+        default: 1000,
+        description: "Base delay in milliseconds for exponential retry backoff",
+        type: Number,
+    },
+    idempotencyKey: {
+        description: "Optional deduplication key scoped to the job name",
+        type: String,
+    },
+    lastError: {
+        description: "Most recent error message from a failed attempt",
+        type: String,
+    },
+    lockedAt: {
+        description: "When this job row was claimed by a worker",
+        type: Date,
+    },
+    lockedBy: {
+        description: "Worker identity that claimed this job row",
+        type: String,
+    },
+    maxAttempts: {
+        default: 5,
+        description: "Maximum execution attempts before the job is dead-lettered",
+        type: Number,
+    },
+    maxBackoffMs: {
+        default: 15 * 60 * 1000,
+        description: "Maximum retry delay in milliseconds before backoff is capped",
+        type: Number,
+    },
+    name: {
+        description: "Registered handler name for this job",
+        index: true,
+        required: true,
+        type: String,
+    },
+    payload: {
+        description: "JSON-serializable input passed to the handler",
+        type: mongoose_1.default.Schema.Types.Mixed,
+    },
+    payloadRedacted: {
+        default: false,
+        description: "Whether the stored payload has been redacted for admin display",
+        type: Boolean,
+    },
+    retriedById: {
+        description: "Follow-up job created by an admin retry action",
+        ref: "Job",
+        type: mongoose_1.default.Schema.Types.ObjectId,
+    },
+    retriedFromId: {
+        description: "Original job row that this retry was created from",
+        ref: "Job",
+        type: mongoose_1.default.Schema.Types.ObjectId,
+    },
+    runAt: {
+        description: "Earliest time a worker may claim this job",
+        index: true,
+        required: true,
+        type: Date,
+    },
+    scheduleId: {
+        description: "Recurring schedule that enqueued this job, when applicable",
+        ref: "JobSchedule",
+        type: mongoose_1.default.Schema.Types.ObjectId,
+    },
+    status: {
+        description: "Current lifecycle status of the job row",
+        enum: ["cancelled", "completed", "dead", "failed", "pending", "running", "scheduled"],
+        index: true,
+        required: true,
+        type: String,
+    },
+}, { strict: "throw", toJSON: { virtuals: true }, toObject: { virtuals: true } });
+jobSchema.plugin(api_1.createdUpdatedPlugin);
+jobSchema.plugin(api_1.findOneOrNone);
+jobSchema.plugin(api_1.findExactlyOne);
+jobSchema.index(
+// biome-ignore assist/source/useSortedKeys: IP specifies (name, idempotencyKey) index field order
+{ name: 1, idempotencyKey: 1 }, {
+    partialFilterExpression: { idempotencyKey: { $exists: true, $type: "string" } },
+    unique: true,
+});
+// biome-ignore assist/source/useSortedKeys: IP specifies (status, runAt) claim index field order
+jobSchema.index({ status: 1, runAt: 1 });
+jobSchema.index({ scheduleId: 1, status: 1 });
+exports.Job = mongoose_1.default.model("Job", jobSchema);

package/dist/models/jobSchedule.d.ts

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

package/dist/models/jobSchedule.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobSchedule = void 0;
+var api_1 = require("@terreno/api");
+var mongoose_1 = __importDefault(require("mongoose"));
+var jobScheduleSchema = new mongoose_1.default.Schema({
+    cron: {
+        description: "Cron expression that controls when this schedule fires",
+        required: true,
+        type: String,
+    },
+    enabled: {
+        default: true,
+        description: "Whether the worker should enqueue jobs for this schedule",
+        type: Boolean,
+    },
+    handlerName: {
+        description: "Registered job handler name invoked for each schedule tick",
+        required: true,
+        type: String,
+    },
+    name: {
+        description: "Unique schedule name matching the registered job definition",
+        required: true,
+        type: String,
+        unique: true,
+    },
+    nextRunAt: {
+        description: "Next UTC instant when the scheduler should evaluate this schedule",
+        index: true,
+        required: true,
+        type: Date,
+    },
+    timezone: {
+        default: "UTC",
+        description: "IANA timezone used to interpret the cron expression",
+        required: true,
+        type: String,
+    },
+}, { strict: "throw", toJSON: { virtuals: true }, toObject: { virtuals: true } });
+jobScheduleSchema.plugin(api_1.createdUpdatedPlugin);
+jobScheduleSchema.plugin(api_1.findOneOrNone);
+jobScheduleSchema.plugin(api_1.findExactlyOne);
+jobScheduleSchema.index({ enabled: 1, nextRunAt: 1 });
+exports.JobSchedule = mongoose_1.default.model("JobSchedule", jobScheduleSchema);

package/dist/retryBackoff.d.ts

@@ -0,0 +1,17 @@
+import type { DateTime } from "luxon";
+export declare const DEFAULT_BACKOFF_MS = 1000;
+export declare const DEFAULT_MAX_BACKOFF_MS: number;
+export interface RetryBackoffOptions {
+    backoffMs: number;
+    maxBackoffMs: number;
+}
+export interface ComputeRetryDelayMsParams extends RetryBackoffOptions {
+    attemptCount: number;
+    random?: () => number;
+}
+export interface ComputeRetryRunAtParams extends ComputeRetryDelayMsParams {
+    from: DateTime;
+}
+/** @internal */
+export declare const computeRetryDelayMs: (params: ComputeRetryDelayMsParams) => number;
+export declare const computeRetryRunAt: (params: ComputeRetryRunAtParams) => DateTime;

package/dist/retryBackoff.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeRetryRunAt = exports.computeRetryDelayMs = exports.DEFAULT_MAX_BACKOFF_MS = exports.DEFAULT_BACKOFF_MS = void 0;
+exports.DEFAULT_BACKOFF_MS = 1000;
+exports.DEFAULT_MAX_BACKOFF_MS = 15 * 60 * 1000;
+var equalJitterFactor = function (random) { return 0.5 + random() * 0.5; };
+/** @internal */
+var computeRetryDelayMs = function (params) {
+    var _a;
+    var random = (_a = params.random) !== null && _a !== void 0 ? _a : Math.random;
+    var exponent = Math.max(0, params.attemptCount - 1);
+    var baseDelayMs = params.backoffMs * Math.pow(2, exponent);
+    var cappedDelayMs = Math.min(params.maxBackoffMs, baseDelayMs);
+    return Math.round(cappedDelayMs * equalJitterFactor(random));
+};
+exports.computeRetryDelayMs = computeRetryDelayMs;
+var computeRetryRunAt = function (params) {
+    return params.from.plus({
+        milliseconds: (0, exports.computeRetryDelayMs)(params),
+    });
+};
+exports.computeRetryRunAt = computeRetryRunAt;

package/dist/routes/jobsAdmin.d.ts

@@ -0,0 +1,15 @@
+import { type AnyTerrenoAccess } from "@terreno/api";
+import type { Application } from "express";
+import type { JobsService } from "../jobsService";
+import type { JobsAdminRedactPayload } from "../types";
+export interface RegisterJobsAdminRouteOptions {
+    accessControl?: AnyTerrenoAccess;
+    basePath: string;
+    jobsService: JobsService;
+    openApi?: unknown;
+    redactPayload?: JobsAdminRedactPayload;
+}
+export declare const registerJobsAdminRoutes: ({ app, options, }: {
+    app: Application;
+    options: RegisterJobsAdminRouteOptions;
+}) => void;