velocious 1.0.317 → 1.0.319

package/README.md

@@ -1630,6 +1630,37 @@ Supported schedule syntax:
 - `every: ["1h", {first_in: "30s"}]`
 - `every: ["1 day", {firstIn: "5 minutes"}]`
 
+Or a 5-field POSIX crontab expression via `cron`:
+
+```js
+scheduledBackgroundJobs: {
+  jobs: {
+    nightlyDigest: {
+      class: NightlyDigestJob,
+      cron: "0 3 * * *" // every day at 03:00 server-local time
+    },
+    weekdayMornings: {
+      class: WeekdayMorningJob,
+      cron: "0 9 * * 1-5" // 09:00 Mon–Fri
+    },
+    everyHour: {
+      class: HourlyCleanupJob,
+      cron: "@hourly"
+    }
+  }
+}
+```
+
+Cron fields are: `minute hour day-of-month month day-of-week`. Supported syntax:
+
+- `*` (any), single values (`5`), ranges (`1-5`), lists (`1,3,5`).
+- Step expressions: `*/15` (every 15 minutes), `0-30/5` (every 5 between 0 and 30).
+- Month and weekday names: `jan`-`dec`, `sun`-`sat` (case-insensitive). Both `0` and `7` mean Sunday.
+- POSIX shortcuts: `@hourly`, `@daily` / `@midnight`, `@weekly`, `@monthly`, `@yearly` / `@annually`.
+- Day-of-month and day-of-week interaction follows POSIX/Vixie cron: when both are restricted (neither `*`), the job fires when **either** matches.
+
+Each job must define exactly one of `every` or `cron`. Cron times are evaluated in the **server's local timezone**, at minute granularity.
+
 `background-jobs-main` owns the schedule and enqueues the configured jobs into the normal Velocious background-jobs queue. The HTTP server does not run scheduled jobs itself.
 
 ## Persistence and retries

package/build/src/background-jobs/cron-expression.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @typedef {object} ParsedCron
+ * @property {Set<number>} minute - Allowed minute values (0-59).
+ * @property {Set<number>} hour - Allowed hour values (0-23).
+ * @property {Set<number>} dayOfMonth - Allowed day-of-month values (1-31).
+ * @property {Set<number>} month - Allowed month values (1-12).
+ * @property {Set<number>} dayOfWeek - Allowed day-of-week values (0-6, 0=Sun).
+ * @property {boolean} dayOfMonthRestricted - True when the dayOfMonth field is not `*`.
+ * @property {boolean} dayOfWeekRestricted - True when the dayOfWeek field is not `*`.
+ * @property {string} expression - Original expression for diagnostics.
+ */
+/**
+ * @param {string} expression - Cron expression or shortcut.
+ * @returns {ParsedCron}
+ */
+export function parseCronExpression(expression: string): ParsedCron;
+/**
+ * Returns the next Date strictly after `from` that satisfies `parsed`.
+ * Operates at minute granularity. Bails out with an error after five
+ * years of search, which only happens if the expression matches no
+ * real time (e.g., `0 0 31 2 *` — Feb 31st).
+ *
+ * @param {ParsedCron} parsed - Parsed cron expression.
+ * @param {Date} from - Reference Date — the next match is strictly after this.
+ * @returns {Date}
+ */
+export function nextCronFireDate(parsed: ParsedCron, from: Date): Date;
+export type ParsedCron = {
+    /**
+     * - Allowed minute values (0-59).
+     */
+    minute: Set<number>;
+    /**
+     * - Allowed hour values (0-23).
+     */
+    hour: Set<number>;
+    /**
+     * - Allowed day-of-month values (1-31).
+     */
+    dayOfMonth: Set<number>;
+    /**
+     * - Allowed month values (1-12).
+     */
+    month: Set<number>;
+    /**
+     * - Allowed day-of-week values (0-6, 0=Sun).
+     */
+    dayOfWeek: Set<number>;
+    /**
+     * - True when the dayOfMonth field is not `*`.
+     */
+    dayOfMonthRestricted: boolean;
+    /**
+     * - True when the dayOfWeek field is not `*`.
+     */
+    dayOfWeekRestricted: boolean;
+    /**
+     * - Original expression for diagnostics.
+     */
+    expression: string;
+};
+//# sourceMappingURL=cron-expression.d.ts.map

package/build/src/background-jobs/cron-expression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron-expression.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/cron-expression.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;GAUG;AAEH;;;GAGG;AACH,gDAHW,MAAM,GACJ,UAAU,CA+BtB;AAsID;;;;;;;;;GASG;AACH,yCAJW,UAAU,QACV,IAAI,GACF,IAAI,CAehB;;;;;YAxMa,GAAG,CAAC,MAAM,CAAC;;;;UACX,GAAG,CAAC,MAAM,CAAC;;;;gBACX,GAAG,CAAC,MAAM,CAAC;;;;WACX,GAAG,CAAC,MAAM,CAAC;;;;eACX,GAAG,CAAC,MAAM,CAAC;;;;0BACX,OAAO;;;;yBACP,OAAO;;;;gBACP,MAAM"}

package/build/src/background-jobs/cron-expression.js

@@ -0,0 +1,228 @@
+// @ts-check
+/**
+ * Minimal POSIX-style 5-field cron parser used by the background-job
+ * scheduler. Supports `*`, single values, ranges (`N-M`), steps
+ * (`*\/N` or `N-M/N`), comma-separated lists, and the common
+ * `@hourly`/`@daily`/`@weekly`/`@monthly`/`@yearly`/`@midnight`
+ * shortcuts. Month and day-of-week names (`jan`-`dec`, `sun`-`sat`,
+ * case-insensitive) are also accepted.
+ *
+ * For day-of-month + day-of-week interaction, follows POSIX/Vixie
+ * cron semantics: when both fields are restricted (neither `*`), the
+ * job fires when EITHER matches. When one is `*` it has no effect.
+ */
+const MONTH_NAMES = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+const DAY_NAMES = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+const SHORTCUTS = {
+    "@hourly": "0 * * * *",
+    "@daily": "0 0 * * *",
+    "@midnight": "0 0 * * *",
+    "@weekly": "0 0 * * 0",
+    "@monthly": "0 0 1 * *",
+    "@yearly": "0 0 1 1 *",
+    "@annually": "0 0 1 1 *"
+};
+const FIELDS = [
+    { name: "minute", min: 0, max: 59 },
+    { name: "hour", min: 0, max: 23 },
+    { name: "dayOfMonth", min: 1, max: 31 },
+    { name: "month", min: 1, max: 12, names: MONTH_NAMES },
+    // Accept 0-7 so ranges like `5-7` (Fri-Sun) work; we normalize 7
+    // down to 0 after parsing in `normalizeDayOfWeek` below.
+    { name: "dayOfWeek", min: 0, max: 7, names: DAY_NAMES }
+];
+/**
+ * @typedef {object} ParsedCron
+ * @property {Set<number>} minute - Allowed minute values (0-59).
+ * @property {Set<number>} hour - Allowed hour values (0-23).
+ * @property {Set<number>} dayOfMonth - Allowed day-of-month values (1-31).
+ * @property {Set<number>} month - Allowed month values (1-12).
+ * @property {Set<number>} dayOfWeek - Allowed day-of-week values (0-6, 0=Sun).
+ * @property {boolean} dayOfMonthRestricted - True when the dayOfMonth field is not `*`.
+ * @property {boolean} dayOfWeekRestricted - True when the dayOfWeek field is not `*`.
+ * @property {string} expression - Original expression for diagnostics.
+ */
+/**
+ * @param {string} expression - Cron expression or shortcut.
+ * @returns {ParsedCron}
+ */
+export function parseCronExpression(expression) {
+    if (typeof expression !== "string" || !expression.trim()) {
+        throw new Error(`Invalid cron expression: ${expression}`);
+    }
+    const trimmed = expression.trim().toLowerCase();
+    const expanded = SHORTCUTS[ /** @type {keyof typeof SHORTCUTS} */(trimmed)] || trimmed;
+    const fields = expanded.split(/\s+/);
+    if (fields.length !== 5) {
+        throw new Error(`Invalid cron expression "${expression}": expected 5 fields, got ${fields.length}`);
+    }
+    const [minuteField, hourField, dayOfMonthField, monthField, dayOfWeekField] = fields;
+    const parsed = {
+        minute: parseField(minuteField, FIELDS[0], expression),
+        hour: parseField(hourField, FIELDS[1], expression),
+        dayOfMonth: parseField(dayOfMonthField, FIELDS[2], expression),
+        month: parseField(monthField, FIELDS[3], expression),
+        // Cron treats both 0 and 7 as Sunday. We accept 7 throughout the
+        // parse pass (so `5-7` for Fri-Sun works) and then normalize any
+        // 7s down to 0 so the matcher only deals with 0-6.
+        dayOfWeek: normalizeDayOfWeek(parseField(dayOfWeekField, FIELDS[4], expression)),
+        dayOfMonthRestricted: dayOfMonthField !== "*",
+        dayOfWeekRestricted: dayOfWeekField !== "*",
+        expression
+    };
+    return parsed;
+}
+/**
+ * @param {Set<number>} dayOfWeek
+ * @returns {Set<number>}
+ */
+function normalizeDayOfWeek(dayOfWeek) {
+    if (dayOfWeek.has(7)) {
+        dayOfWeek.delete(7);
+        dayOfWeek.add(0);
+    }
+    return dayOfWeek;
+}
+/**
+ * @param {string} field - Field expression.
+ * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.
+ * @param {string} expression - Whole cron expression for error messages.
+ * @returns {Set<number>}
+ */
+function parseField(field, fieldSpec, expression) {
+    const result = new Set();
+    for (const part of field.split(",")) {
+        addPartValues(part, fieldSpec, expression, result);
+    }
+    return result;
+}
+/**
+ * @param {string} part - Single comma-separated chunk.
+ * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.
+ * @param {string} expression - Original expression for errors.
+ * @param {Set<number>} result - Accumulator.
+ * @returns {void}
+ */
+function addPartValues(part, fieldSpec, expression, result) {
+    if (!part) {
+        throw new Error(`Invalid ${fieldSpec.name} field in cron expression "${expression}"`);
+    }
+    const [rangePart, stepPart] = part.split("/");
+    const step = stepPart === undefined ? 1 : parseStep(stepPart, fieldSpec, expression);
+    const [start, end] = parseRange(rangePart, fieldSpec, expression, stepPart !== undefined);
+    for (let value = start; value <= end; value += step) {
+        if (value < fieldSpec.min || value > fieldSpec.max) {
+            throw new Error(`Value ${value} out of range for ${fieldSpec.name} in cron expression "${expression}"`);
+        }
+        result.add(value);
+    }
+}
+/**
+ * @param {string} value - Step value.
+ * @param {{name: string, min: number, max: number}} fieldSpec - Field spec.
+ * @param {string} expression - Original expression for errors.
+ * @returns {number}
+ */
+function parseStep(value, fieldSpec, expression) {
+    const step = Number(value);
+    if (!Number.isInteger(step) || step <= 0) {
+        throw new Error(`Invalid step "${value}" for ${fieldSpec.name} in cron expression "${expression}"`);
+    }
+    return step;
+}
+/**
+ * @param {string} rangePart - Range portion (before any `/`).
+ * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.
+ * @param {string} expression - Original expression for errors.
+ * @param {boolean} hasStep - Whether the part had a `/step` suffix.
+ * @returns {[number, number]}
+ */
+function parseRange(rangePart, fieldSpec, expression, hasStep) {
+    if (rangePart === "*") {
+        return [fieldSpec.min, fieldSpec.max];
+    }
+    const dashIndex = rangePart.indexOf("-");
+    if (dashIndex === -1) {
+        const value = parseValue(rangePart, fieldSpec, expression);
+        // `N/step` is shorthand for `N-max/step` (Vixie cron).
+        return [value, hasStep ? fieldSpec.max : value];
+    }
+    const start = parseValue(rangePart.slice(0, dashIndex), fieldSpec, expression);
+    const end = parseValue(rangePart.slice(dashIndex + 1), fieldSpec, expression);
+    if (start > end) {
+        throw new Error(`Range start ${start} > end ${end} for ${fieldSpec.name} in cron expression "${expression}"`);
+    }
+    return [start, end];
+}
+/**
+ * @param {string} rawValue - Raw value (may be a name).
+ * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.
+ * @param {string} expression - Original expression for errors.
+ * @returns {number}
+ */
+function parseValue(rawValue, fieldSpec, expression) {
+    if (!rawValue) {
+        throw new Error(`Invalid ${fieldSpec.name} value in cron expression "${expression}"`);
+    }
+    const namedIndex = fieldSpec.names?.indexOf(rawValue);
+    if (typeof namedIndex === "number" && namedIndex !== -1) {
+        return namedIndex + fieldSpec.min;
+    }
+    const value = Number(rawValue);
+    if (!Number.isInteger(value)) {
+        throw new Error(`Invalid ${fieldSpec.name} value "${rawValue}" in cron expression "${expression}"`);
+    }
+    return value;
+}
+// 5 years of minutes — covers the worst-case legitimate gap, the
+// `0 0 29 2 *` (Feb 29) leap-year-only schedule, with a one-year
+// buffer so we never report a real cron pattern as "never matches".
+const MAX_NEXT_FIRE_ITERATIONS = 5 * 366 * 24 * 60;
+/**
+ * Returns the next Date strictly after `from` that satisfies `parsed`.
+ * Operates at minute granularity. Bails out with an error after five
+ * years of search, which only happens if the expression matches no
+ * real time (e.g., `0 0 31 2 *` — Feb 31st).
+ *
+ * @param {ParsedCron} parsed - Parsed cron expression.
+ * @param {Date} from - Reference Date — the next match is strictly after this.
+ * @returns {Date}
+ */
+export function nextCronFireDate(parsed, from) {
+    const candidate = new Date(from.getTime());
+    candidate.setSeconds(0, 0);
+    candidate.setMinutes(candidate.getMinutes() + 1);
+    for (let iterations = 0; iterations < MAX_NEXT_FIRE_ITERATIONS; iterations += 1) {
+        if (candidateMatches(candidate, parsed))
+            return candidate;
+        candidate.setMinutes(candidate.getMinutes() + 1);
+    }
+    throw new Error(`Cron expression "${parsed.expression}" never matches`);
+}
+/**
+ * @param {Date} candidate - Candidate Date (in local time).
+ * @param {ParsedCron} parsed - Parsed expression.
+ * @returns {boolean}
+ */
+function candidateMatches(candidate, parsed) {
+    if (!parsed.minute.has(candidate.getMinutes()))
+        return false;
+    if (!parsed.hour.has(candidate.getHours()))
+        return false;
+    if (!parsed.month.has(candidate.getMonth() + 1))
+        return false;
+    const dayOfMonthMatch = parsed.dayOfMonth.has(candidate.getDate());
+    const dayOfWeekMatch = parsed.dayOfWeek.has(candidate.getDay());
+    // POSIX/Vixie cron OR semantics: when both day fields are
+    // restricted, fire when EITHER matches. When only one is
+    // restricted, only that one applies.
+    if (parsed.dayOfMonthRestricted && parsed.dayOfWeekRestricted) {
+        return dayOfMonthMatch || dayOfWeekMatch;
+    }
+    if (parsed.dayOfMonthRestricted)
+        return dayOfMonthMatch;
+    if (parsed.dayOfWeekRestricted)
+        return dayOfWeekMatch;
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cron-expression.js","sourceRoot":"","sources":["../../../src/background-jobs/cron-expression.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\n/**\n * Minimal POSIX-style 5-field cron parser used by the background-job\n * scheduler. Supports `*`, single values, ranges (`N-M`), steps\n * (`*\\/N` or `N-M/N`), comma-separated lists, and the common\n * `@hourly`/`@daily`/`@weekly`/`@monthly`/`@yearly`/`@midnight`\n * shortcuts. Month and day-of-week names (`jan`-`dec`, `sun`-`sat`,\n * case-insensitive) are also accepted.\n *\n * For day-of-month + day-of-week interaction, follows POSIX/Vixie\n * cron semantics: when both fields are restricted (neither `*`), the\n * job fires when EITHER matches. When one is `*` it has no effect.\n */\n\nconst MONTH_NAMES = [\"jan\", \"feb\", \"mar\", \"apr\", \"may\", \"jun\", \"jul\", \"aug\", \"sep\", \"oct\", \"nov\", \"dec\"]\nconst DAY_NAMES = [\"sun\", \"mon\", \"tue\", \"wed\", \"thu\", \"fri\", \"sat\"]\n\nconst SHORTCUTS = {\n  \"@hourly\": \"0 * * * *\",\n  \"@daily\": \"0 0 * * *\",\n  \"@midnight\": \"0 0 * * *\",\n  \"@weekly\": \"0 0 * * 0\",\n  \"@monthly\": \"0 0 1 * *\",\n  \"@yearly\": \"0 0 1 1 *\",\n  \"@annually\": \"0 0 1 1 *\"\n}\n\nconst FIELDS = [\n  {name: \"minute\", min: 0, max: 59},\n  {name: \"hour\", min: 0, max: 23},\n  {name: \"dayOfMonth\", min: 1, max: 31},\n  {name: \"month\", min: 1, max: 12, names: MONTH_NAMES},\n  // Accept 0-7 so ranges like `5-7` (Fri-Sun) work; we normalize 7\n  // down to 0 after parsing in `normalizeDayOfWeek` below.\n  {name: \"dayOfWeek\", min: 0, max: 7, names: DAY_NAMES}\n]\n\n/**\n * @typedef {object} ParsedCron\n * @property {Set<number>} minute - Allowed minute values (0-59).\n * @property {Set<number>} hour - Allowed hour values (0-23).\n * @property {Set<number>} dayOfMonth - Allowed day-of-month values (1-31).\n * @property {Set<number>} month - Allowed month values (1-12).\n * @property {Set<number>} dayOfWeek - Allowed day-of-week values (0-6, 0=Sun).\n * @property {boolean} dayOfMonthRestricted - True when the dayOfMonth field is not `*`.\n * @property {boolean} dayOfWeekRestricted - True when the dayOfWeek field is not `*`.\n * @property {string} expression - Original expression for diagnostics.\n */\n\n/**\n * @param {string} expression - Cron expression or shortcut.\n * @returns {ParsedCron}\n */\nexport function parseCronExpression(expression) {\n  if (typeof expression !== \"string\" || !expression.trim()) {\n    throw new Error(`Invalid cron expression: ${expression}`)\n  }\n\n  const trimmed = expression.trim().toLowerCase()\n  const expanded = SHORTCUTS[/** @type {keyof typeof SHORTCUTS} */ (trimmed)] || trimmed\n  const fields = expanded.split(/\\s+/)\n\n  if (fields.length !== 5) {\n    throw new Error(`Invalid cron expression \"${expression}\": expected 5 fields, got ${fields.length}`)\n  }\n\n  const [minuteField, hourField, dayOfMonthField, monthField, dayOfWeekField] = fields\n  const parsed = {\n    minute: parseField(minuteField, FIELDS[0], expression),\n    hour: parseField(hourField, FIELDS[1], expression),\n    dayOfMonth: parseField(dayOfMonthField, FIELDS[2], expression),\n    month: parseField(monthField, FIELDS[3], expression),\n    // Cron treats both 0 and 7 as Sunday. We accept 7 throughout the\n    // parse pass (so `5-7` for Fri-Sun works) and then normalize any\n    // 7s down to 0 so the matcher only deals with 0-6.\n    dayOfWeek: normalizeDayOfWeek(parseField(dayOfWeekField, FIELDS[4], expression)),\n    dayOfMonthRestricted: dayOfMonthField !== \"*\",\n    dayOfWeekRestricted: dayOfWeekField !== \"*\",\n    expression\n  }\n\n  return parsed\n}\n\n/**\n * @param {Set<number>} dayOfWeek\n * @returns {Set<number>}\n */\nfunction normalizeDayOfWeek(dayOfWeek) {\n  if (dayOfWeek.has(7)) {\n    dayOfWeek.delete(7)\n    dayOfWeek.add(0)\n  }\n\n  return dayOfWeek\n}\n\n/**\n * @param {string} field - Field expression.\n * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.\n * @param {string} expression - Whole cron expression for error messages.\n * @returns {Set<number>}\n */\nfunction parseField(field, fieldSpec, expression) {\n  const result = new Set()\n\n  for (const part of field.split(\",\")) {\n    addPartValues(part, fieldSpec, expression, result)\n  }\n\n  return result\n}\n\n/**\n * @param {string} part - Single comma-separated chunk.\n * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.\n * @param {string} expression - Original expression for errors.\n * @param {Set<number>} result - Accumulator.\n * @returns {void}\n */\nfunction addPartValues(part, fieldSpec, expression, result) {\n  if (!part) {\n    throw new Error(`Invalid ${fieldSpec.name} field in cron expression \"${expression}\"`)\n  }\n\n  const [rangePart, stepPart] = part.split(\"/\")\n  const step = stepPart === undefined ? 1 : parseStep(stepPart, fieldSpec, expression)\n  const [start, end] = parseRange(rangePart, fieldSpec, expression, stepPart !== undefined)\n\n  for (let value = start; value <= end; value += step) {\n    if (value < fieldSpec.min || value > fieldSpec.max) {\n      throw new Error(`Value ${value} out of range for ${fieldSpec.name} in cron expression \"${expression}\"`)\n    }\n\n    result.add(value)\n  }\n}\n\n/**\n * @param {string} value - Step value.\n * @param {{name: string, min: number, max: number}} fieldSpec - Field spec.\n * @param {string} expression - Original expression for errors.\n * @returns {number}\n */\nfunction parseStep(value, fieldSpec, expression) {\n  const step = Number(value)\n\n  if (!Number.isInteger(step) || step <= 0) {\n    throw new Error(`Invalid step \"${value}\" for ${fieldSpec.name} in cron expression \"${expression}\"`)\n  }\n\n  return step\n}\n\n/**\n * @param {string} rangePart - Range portion (before any `/`).\n * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.\n * @param {string} expression - Original expression for errors.\n * @param {boolean} hasStep - Whether the part had a `/step` suffix.\n * @returns {[number, number]}\n */\nfunction parseRange(rangePart, fieldSpec, expression, hasStep) {\n  if (rangePart === \"*\") {\n    return [fieldSpec.min, fieldSpec.max]\n  }\n\n  const dashIndex = rangePart.indexOf(\"-\")\n\n  if (dashIndex === -1) {\n    const value = parseValue(rangePart, fieldSpec, expression)\n\n    // `N/step` is shorthand for `N-max/step` (Vixie cron).\n    return [value, hasStep ? fieldSpec.max : value]\n  }\n\n  const start = parseValue(rangePart.slice(0, dashIndex), fieldSpec, expression)\n  const end = parseValue(rangePart.slice(dashIndex + 1), fieldSpec, expression)\n\n  if (start > end) {\n    throw new Error(`Range start ${start} > end ${end} for ${fieldSpec.name} in cron expression \"${expression}\"`)\n  }\n\n  return [start, end]\n}\n\n/**\n * @param {string} rawValue - Raw value (may be a name).\n * @param {{name: string, min: number, max: number, names?: string[]}} fieldSpec - Field spec.\n * @param {string} expression - Original expression for errors.\n * @returns {number}\n */\nfunction parseValue(rawValue, fieldSpec, expression) {\n  if (!rawValue) {\n    throw new Error(`Invalid ${fieldSpec.name} value in cron expression \"${expression}\"`)\n  }\n\n  const namedIndex = fieldSpec.names?.indexOf(rawValue)\n\n  if (typeof namedIndex === \"number\" && namedIndex !== -1) {\n    return namedIndex + fieldSpec.min\n  }\n\n  const value = Number(rawValue)\n\n  if (!Number.isInteger(value)) {\n    throw new Error(`Invalid ${fieldSpec.name} value \"${rawValue}\" in cron expression \"${expression}\"`)\n  }\n\n  return value\n}\n\n// 5 years of minutes — covers the worst-case legitimate gap, the\n// `0 0 29 2 *` (Feb 29) leap-year-only schedule, with a one-year\n// buffer so we never report a real cron pattern as \"never matches\".\nconst MAX_NEXT_FIRE_ITERATIONS = 5 * 366 * 24 * 60\n\n/**\n * Returns the next Date strictly after `from` that satisfies `parsed`.\n * Operates at minute granularity. Bails out with an error after five\n * years of search, which only happens if the expression matches no\n * real time (e.g., `0 0 31 2 *` — Feb 31st).\n *\n * @param {ParsedCron} parsed - Parsed cron expression.\n * @param {Date} from - Reference Date — the next match is strictly after this.\n * @returns {Date}\n */\nexport function nextCronFireDate(parsed, from) {\n  const candidate = new Date(from.getTime())\n\n  candidate.setSeconds(0, 0)\n  candidate.setMinutes(candidate.getMinutes() + 1)\n\n  for (let iterations = 0; iterations < MAX_NEXT_FIRE_ITERATIONS; iterations += 1) {\n    if (candidateMatches(candidate, parsed)) return candidate\n\n    candidate.setMinutes(candidate.getMinutes() + 1)\n  }\n\n  throw new Error(`Cron expression \"${parsed.expression}\" never matches`)\n}\n\n/**\n * @param {Date} candidate - Candidate Date (in local time).\n * @param {ParsedCron} parsed - Parsed expression.\n * @returns {boolean}\n */\nfunction candidateMatches(candidate, parsed) {\n  if (!parsed.minute.has(candidate.getMinutes())) return false\n  if (!parsed.hour.has(candidate.getHours())) return false\n  if (!parsed.month.has(candidate.getMonth() + 1)) return false\n\n  const dayOfMonthMatch = parsed.dayOfMonth.has(candidate.getDate())\n  const dayOfWeekMatch = parsed.dayOfWeek.has(candidate.getDay())\n\n  // POSIX/Vixie cron OR semantics: when both day fields are\n  // restricted, fire when EITHER matches. When only one is\n  // restricted, only that one applies.\n  if (parsed.dayOfMonthRestricted && parsed.dayOfWeekRestricted) {\n    return dayOfMonthMatch || dayOfWeekMatch\n  }\n\n  if (parsed.dayOfMonthRestricted) return dayOfMonthMatch\n  if (parsed.dayOfWeekRestricted) return dayOfWeekMatch\n\n  return true\n}\n"]}

package/build/src/background-jobs/scheduler.d.ts

@@ -33,6 +33,8 @@ export default class BackgroundJobsScheduler {
     intervalIds: Array<ReturnType<typeof setInterval>>;
     /** @type {Array<ReturnType<typeof setTimeout>>} */
     timeoutIds: Array<ReturnType<typeof setTimeout>>;
+    /** @type {boolean} - True between stop() and the next start(); cron self-rescheduler checks this so a stop() during an in-flight enqueue doesn't immediately re-arm. */
+    stopped: boolean;
     /** @returns {Promise<void>} */
     start(): Promise<void>;
     /** @returns {void} */
@@ -47,6 +49,31 @@ export default class BackgroundJobsScheduler {
         jobConfiguration: import("../configuration-types.js").ScheduledBackgroundJobConfiguration;
         jobKey: string;
     }): void;
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {void}
+     */
+    scheduleEveryJob({ jobConfiguration, jobKey }: {
+        jobConfiguration: import("../configuration-types.js").ScheduledBackgroundJobConfiguration;
+        jobKey: string;
+    }): void;
+    /**
+     * Crontab schedules don't have a constant interval (`0 9 * * 1-5`
+     * fires once per weekday at 9 AM, with gaps of varying length), so
+     * we self-reschedule with `setTimeout` after every fire instead of
+     * using `setInterval`.
+     *
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {void}
+     */
+    scheduleCronJob({ jobConfiguration, jobKey }: {
+        jobConfiguration: import("../configuration-types.js").ScheduledBackgroundJobConfiguration;
+        jobKey: string;
+    }): void;
     /**
      * @param {object} args - Options.
      * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
@@ -58,10 +85,10 @@ export default class BackgroundJobsScheduler {
         jobKey: string;
     }): Promise<void>;
     /**
-     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]} every - Every config.
+     * @param {NonNullable<import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]>} every - Every config (caller must guarantee not undefined).
      * @returns {{everyValue: number | string, firstInValue?: number | string}} - Normalized interval and first-run delay values.
      */
-    normalizeEvery(every: import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]): {
+    normalizeEvery(every: NonNullable<import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]>): {
         everyValue: number | string;
         firstInValue?: number | string;
     };

package/build/src/background-jobs/scheduler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/scheduler.js"],"names":[],"mappings":"AAsBA,gEAAgE;AAEhE;;;;GAIG;AACH,8CAJW,MAAM,GAAG,MAAM,aACf,MAAM,GACJ,MAAM,CA8BlB;AAED,0DAA0D;AAC1D;IACE;;;;OAIG;IACH,2CAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QAC0H,UAAU,EAAzK,CAAS,IAA8H,EAA9H;YAAC,IAAI,EAAE,GAAG,EAAE,CAAC;YAAC,QAAQ,EAAE,cAAc,UAAU,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC;KAClK,EASA;IAPC,qDAAkC;IAClC,mBAJkB;QAAC,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,EAAE,cAAc,UAAU,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAIrI;IAC5B,eAA8B;IAC9B,oDAAoD;IACpD,aADW,KAAK,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAC3B;IACrB,mDAAmD;IACnD,YADW,KAAK,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAC3B;IAGtB,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAiB1B;IAED,sBAAsB;IACtB,QADc,IAAI,CAYjB;IAED;;;;;OAKG;IACH,0CAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,IAAI,CA0BhB;IAED;;;;;OAKG;IACH,kDAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;OAGG;IACH,sBAHW,OAAO,2BAA2B,EAAE,mCAAmC,CAAC,OAAO,CAAC,GAC9E;QAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAczE;CACF;2BA3Ja,MAAM,OAAO,oBAAoB;mBApB5B,cAAc"}
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/scheduler.js"],"names":[],"mappings":"AAuBA,gEAAgE;AAEhE;;;;GAIG;AACH,8CAJW,MAAM,GAAG,MAAM,aACf,MAAM,GACJ,MAAM,CA8BlB;AAED,0DAA0D;AAC1D;IACE;;;;OAIG;IACH,2CAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;QAC0H,UAAU,EAAzK,CAAS,IAA8H,EAA9H;YAAC,IAAI,EAAE,GAAG,EAAE,CAAC;YAAC,QAAQ,EAAE,cAAc,UAAU,EAAE,OAAO,CAAC;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;SAAC,KAAI,OAAO,CAAC,IAAI,CAAC;KAClK,EAWA;IATC,qDAAkC;IAClC,mBAJkB;QAAC,IAAI,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,EAAE,cAAc,UAAU,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,YAAY,EAAE,oBAAoB,CAAA;KAAC,KAAI,OAAO,CAAC,IAAI,CAAC,CAIrI;IAC5B,eAA8B;IAC9B,oDAAoD;IACpD,aADW,KAAK,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAC3B;IACrB,mDAAmD;IACnD,YADW,KAAK,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAC3B;IACpB,wKAAwK;IACxK,SADW,OAAO,CACE;IAGtB,+BAA+B;IAC/B,SADc,OAAO,CAAC,IAAI,CAAC,CAmB1B;IAED,sBAAsB;IACtB,QADc,IAAI,CAcjB;IAED;;;;;OAKG;IACH,0CAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,IAAI,CAsBhB;IAED;;;;;OAKG;IACH,+CAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,IAAI,CAuBhB;IAED;;;;;;;;;;OAUG;IACH,8CAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,IAAI,CA+BhB;IAED;;;;;OAKG;IACH,kDAJG;QAAsF,gBAAgB,EAA9F,OAAO,2BAA2B,EAAE,mCAAmC;QAC1D,MAAM,EAAnB,MAAM;KACd,GAAU,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;OAGG;IACH,sBAHW,WAAW,CAAC,OAAO,2BAA2B,EAAE,mCAAmC,CAAC,OAAO,CAAC,CAAC,GAC3F;QAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAC,CAczE;CACF;2BApOa,MAAM,OAAO,oBAAoB;mBArB5B,cAAc"}

package/build/src/background-jobs/scheduler.js

@@ -1,5 +1,6 @@
 // @ts-check
 import Logger from "../logger.js";
+import { nextCronFireDate, parseCronExpression } from "./cron-expression.js";
 const DURATION_MULTIPLIERS = {
     d: 24 * 60 * 60 * 1000,
     day: 24 * 60 * 60 * 1000,
@@ -61,9 +62,12 @@ export default class BackgroundJobsScheduler {
         this.intervalIds = [];
         /** @type {Array<ReturnType<typeof setTimeout>>} */
         this.timeoutIds = [];
+        /** @type {boolean} - True between stop() and the next start(); cron self-rescheduler checks this so a stop() during an in-flight enqueue doesn't immediately re-arm. */
+        this.stopped = false;
     }
     /** @returns {Promise<void>} */
     async start() {
+        this.stopped = false;
         const scheduledBackgroundJobsConfig = await this.configuration.getScheduledBackgroundJobsConfig();
         if (!scheduledBackgroundJobsConfig?.jobs) {
             return;
@@ -78,6 +82,7 @@ export default class BackgroundJobsScheduler {
     }
     /** @returns {void} */
     stop() {
+        this.stopped = true;
         for (const intervalId of this.intervalIds) {
             clearInterval(intervalId);
         }
@@ -94,15 +99,35 @@ export default class BackgroundJobsScheduler {
      * @returns {void}
      */
     scheduleJob({ jobConfiguration, jobKey }) {
-        const { everyValue, firstInValue } = this.normalizeEvery(jobConfiguration.every);
+        if (!jobConfiguration.class || typeof jobConfiguration.class.performLaterWithOptions !== "function") {
+            throw new Error(`Scheduled background job ${jobKey} must define a job class.`);
+        }
+        if (jobConfiguration.cron !== undefined && jobConfiguration.every !== undefined) {
+            throw new Error(`Scheduled background job ${jobKey} must define either "every" or "cron", not both.`);
+        }
+        if (jobConfiguration.cron !== undefined) {
+            this.scheduleCronJob({ jobConfiguration, jobKey });
+            return;
+        }
+        if (jobConfiguration.every === undefined) {
+            throw new Error(`Scheduled background job ${jobKey} must define either "every" or "cron".`);
+        }
+        this.scheduleEveryJob({ jobConfiguration, jobKey });
+    }
+    /**
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {void}
+     */
+    scheduleEveryJob({ jobConfiguration, jobKey }) {
+        const everyConfig = /** @type {NonNullable<typeof jobConfiguration.every>} */ (jobConfiguration.every);
+        const { everyValue, firstInValue } = this.normalizeEvery(everyConfig);
         const intervalMs = parseScheduledDuration(everyValue, `${jobKey}.every`);
         const firstInMs = firstInValue !== undefined ? parseScheduledDuration(firstInValue, `${jobKey}.first_in`) : intervalMs;
         if (intervalMs < 1) {
             throw new Error(`Scheduled background job ${jobKey}.every must be at least 1 millisecond.`);
         }
-        if (!jobConfiguration.class || typeof jobConfiguration.class.performLaterWithOptions !== "function") {
-            throw new Error(`Scheduled background job ${jobKey} must define a job class.`);
-        }
         const timeoutId = setTimeout(() => {
             void this.enqueueScheduledJob({ jobConfiguration, jobKey });
             const intervalId = setInterval(() => {
@@ -112,6 +137,42 @@ export default class BackgroundJobsScheduler {
         }, firstInMs);
         this.timeoutIds.push(timeoutId);
     }
+    /**
+     * Crontab schedules don't have a constant interval (`0 9 * * 1-5`
+     * fires once per weekday at 9 AM, with gaps of varying length), so
+     * we self-reschedule with `setTimeout` after every fire instead of
+     * using `setInterval`.
+     *
+     * @param {object} args - Options.
+     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
+     * @param {string} args.jobKey - Job key.
+     * @returns {void}
+     */
+    scheduleCronJob({ jobConfiguration, jobKey }) {
+        const cronExpression = jobConfiguration.cron;
+        if (typeof cronExpression !== "string") {
+            throw new Error(`Scheduled background job ${jobKey}.cron must be a string.`);
+        }
+        const parsed = parseCronExpression(cronExpression);
+        const scheduleNext = () => {
+            if (this.stopped)
+                return;
+            const nextDate = nextCronFireDate(parsed, new Date());
+            const delayMs = Math.max(1, nextDate.getTime() - Date.now());
+            const timeoutId = setTimeout(async () => {
+                if (this.stopped)
+                    return;
+                await this.enqueueScheduledJob({ jobConfiguration, jobKey });
+                // The await above can yield to a stop() call. Re-check before
+                // re-arming so we don't keep firing after shutdown.
+                if (this.stopped)
+                    return;
+                scheduleNext();
+            }, delayMs);
+            this.timeoutIds.push(timeoutId);
+        };
+        scheduleNext();
+    }
     /**
      * @param {object} args - Options.
      * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.
@@ -132,7 +193,7 @@ export default class BackgroundJobsScheduler {
         }
     }
     /**
-     * @param {import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]} every - Every config.
+     * @param {NonNullable<import("../configuration-types.js").ScheduledBackgroundJobConfiguration["every"]>} every - Every config (caller must guarantee not undefined).
      * @returns {{everyValue: number | string, firstInValue?: number | string}} - Normalized interval and first-run delay values.
      */
     normalizeEvery(every) {
@@ -146,4 +207,4 @@ export default class BackgroundJobsScheduler {
         return { everyValue: every };
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../../src/background-jobs/scheduler.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Logger from \"../logger.js\"\n\nconst DURATION_MULTIPLIERS = {\n  d: 24 * 60 * 60 * 1000,\n  day: 24 * 60 * 60 * 1000,\n  days: 24 * 60 * 60 * 1000,\n  h: 60 * 60 * 1000,\n  hour: 60 * 60 * 1000,\n  hours: 60 * 60 * 1000,\n  m: 60 * 1000,\n  minute: 60 * 1000,\n  minutes: 60 * 1000,\n  ms: 1,\n  s: 1000,\n  second: 1000,\n  seconds: 1000,\n  w: 7 * 24 * 60 * 60 * 1000,\n  week: 7 * 24 * 60 * 60 * 1000,\n  weeks: 7 * 24 * 60 * 60 * 1000\n}\n/** @typedef {keyof typeof DURATION_MULTIPLIERS} DurationUnit */\n\n/**\n * @param {number | string} value - Duration value.\n * @param {string} fieldName - Field name for errors.\n * @returns {number} - Duration in milliseconds.\n */\nexport function parseScheduledDuration(value, fieldName) {\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value) || value < 1) {\n      throw new Error(`Scheduled background job ${fieldName} must be a positive number of milliseconds.`)\n    }\n\n    return value\n  }\n\n  if (typeof value !== \"string\" || !value.trim()) {\n    throw new Error(`Scheduled background job ${fieldName} must be a non-empty string or number.`)\n  }\n\n  const normalizedValue = value.trim().toLowerCase()\n  const match = normalizedValue.match(/^(\\d+(?:\\.\\d+)?)\\s*(ms|s|m|h|d|w|second|seconds|minute|minutes|hour|hours|day|days|week|weeks)$/)\n\n  if (!match) {\n    throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`)\n  }\n\n  const numericValue = Number(match[1])\n  const multiplier = DURATION_MULTIPLIERS[/** @type {DurationUnit} */ (match[2])]\n\n  if (!multiplier) {\n    throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`)\n  }\n\n  return Math.round(numericValue * multiplier)\n}\n\n/** Runs configured recurring background job schedules. */\nexport default class BackgroundJobsScheduler {\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {function({args: any[], jobClass: typeof import(\"./job.js\").default, jobKey: string, options: import(\"./types.js\").BackgroundJobOptions}) : Promise<void>} args.enqueueJob - Enqueue callback.\n   */\n  constructor({configuration, enqueueJob}) {\n    this.configuration = configuration\n    this.enqueueJob = enqueueJob\n    this.logger = new Logger(this)\n    /** @type {Array<ReturnType<typeof setInterval>>} */\n    this.intervalIds = []\n    /** @type {Array<ReturnType<typeof setTimeout>>} */\n    this.timeoutIds = []\n  }\n\n  /** @returns {Promise<void>} */\n  async start() {\n    const scheduledBackgroundJobsConfig = await this.configuration.getScheduledBackgroundJobsConfig()\n\n    if (!scheduledBackgroundJobsConfig?.jobs) {\n      return\n    }\n\n    for (const jobKey of Object.keys(scheduledBackgroundJobsConfig.jobs)) {\n      const jobConfiguration = scheduledBackgroundJobsConfig.jobs[jobKey]\n\n      if (!jobConfiguration || jobConfiguration.enabled === false) {\n        continue\n      }\n\n      this.scheduleJob({jobConfiguration, jobKey})\n    }\n  }\n\n  /** @returns {void} */\n  stop() {\n    for (const intervalId of this.intervalIds) {\n      clearInterval(intervalId)\n    }\n\n    for (const timeoutId of this.timeoutIds) {\n      clearTimeout(timeoutId)\n    }\n\n    this.intervalIds = []\n    this.timeoutIds = []\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {void}\n   */\n  scheduleJob({jobConfiguration, jobKey}) {\n    const {everyValue, firstInValue} = this.normalizeEvery(jobConfiguration.every)\n    const intervalMs = parseScheduledDuration(everyValue, `${jobKey}.every`)\n    const firstInMs = firstInValue !== undefined ? parseScheduledDuration(firstInValue, `${jobKey}.first_in`) : intervalMs\n\n    if (intervalMs < 1) {\n      throw new Error(`Scheduled background job ${jobKey}.every must be at least 1 millisecond.`)\n    }\n\n    if (!jobConfiguration.class || typeof jobConfiguration.class.performLaterWithOptions !== \"function\") {\n      throw new Error(`Scheduled background job ${jobKey} must define a job class.`)\n    }\n\n    const timeoutId = setTimeout(() => {\n      void this.enqueueScheduledJob({jobConfiguration, jobKey})\n\n      const intervalId = setInterval(() => {\n        void this.enqueueScheduledJob({jobConfiguration, jobKey})\n      }, intervalMs)\n\n      this.intervalIds.push(intervalId)\n    }, firstInMs)\n\n    this.timeoutIds.push(timeoutId)\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {Promise<void>}\n   */\n  async enqueueScheduledJob({jobConfiguration, jobKey}) {\n    try {\n      await this.enqueueJob({\n        args: Array.isArray(jobConfiguration.args) ? jobConfiguration.args : [],\n        jobClass: jobConfiguration.class,\n        jobKey,\n        options: jobConfiguration.options || {}\n      })\n    } catch (error) {\n      await this.logger.error(() => [\"Failed to enqueue scheduled background job\", {jobKey, jobName: jobConfiguration.class.jobName()}, error])\n    }\n  }\n\n  /**\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration[\"every\"]} every - Every config.\n   * @returns {{everyValue: number | string, firstInValue?: number | string}} - Normalized interval and first-run delay values.\n   */\n  normalizeEvery(every) {\n    if (Array.isArray(every)) {\n      const [everyValue, everyOptions] = every\n\n      if (!everyOptions || typeof everyOptions !== \"object\" || Array.isArray(everyOptions)) {\n        return {everyValue}\n      }\n\n      return {everyValue, firstInValue: everyOptions.firstIn ?? everyOptions.first_in}\n    }\n\n    return {everyValue: every}\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"scheduler.js","sourceRoot":"","sources":["../../../src/background-jobs/scheduler.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport Logger from \"../logger.js\"\nimport {nextCronFireDate, parseCronExpression} from \"./cron-expression.js\"\n\nconst DURATION_MULTIPLIERS = {\n  d: 24 * 60 * 60 * 1000,\n  day: 24 * 60 * 60 * 1000,\n  days: 24 * 60 * 60 * 1000,\n  h: 60 * 60 * 1000,\n  hour: 60 * 60 * 1000,\n  hours: 60 * 60 * 1000,\n  m: 60 * 1000,\n  minute: 60 * 1000,\n  minutes: 60 * 1000,\n  ms: 1,\n  s: 1000,\n  second: 1000,\n  seconds: 1000,\n  w: 7 * 24 * 60 * 60 * 1000,\n  week: 7 * 24 * 60 * 60 * 1000,\n  weeks: 7 * 24 * 60 * 60 * 1000\n}\n/** @typedef {keyof typeof DURATION_MULTIPLIERS} DurationUnit */\n\n/**\n * @param {number | string} value - Duration value.\n * @param {string} fieldName - Field name for errors.\n * @returns {number} - Duration in milliseconds.\n */\nexport function parseScheduledDuration(value, fieldName) {\n  if (typeof value === \"number\") {\n    if (!Number.isFinite(value) || value < 1) {\n      throw new Error(`Scheduled background job ${fieldName} must be a positive number of milliseconds.`)\n    }\n\n    return value\n  }\n\n  if (typeof value !== \"string\" || !value.trim()) {\n    throw new Error(`Scheduled background job ${fieldName} must be a non-empty string or number.`)\n  }\n\n  const normalizedValue = value.trim().toLowerCase()\n  const match = normalizedValue.match(/^(\\d+(?:\\.\\d+)?)\\s*(ms|s|m|h|d|w|second|seconds|minute|minutes|hour|hours|day|days|week|weeks)$/)\n\n  if (!match) {\n    throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`)\n  }\n\n  const numericValue = Number(match[1])\n  const multiplier = DURATION_MULTIPLIERS[/** @type {DurationUnit} */ (match[2])]\n\n  if (!multiplier) {\n    throw new Error(`Invalid scheduled background job ${fieldName}: ${value}`)\n  }\n\n  return Math.round(numericValue * multiplier)\n}\n\n/** Runs configured recurring background job schedules. */\nexport default class BackgroundJobsScheduler {\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration.\n   * @param {function({args: any[], jobClass: typeof import(\"./job.js\").default, jobKey: string, options: import(\"./types.js\").BackgroundJobOptions}) : Promise<void>} args.enqueueJob - Enqueue callback.\n   */\n  constructor({configuration, enqueueJob}) {\n    this.configuration = configuration\n    this.enqueueJob = enqueueJob\n    this.logger = new Logger(this)\n    /** @type {Array<ReturnType<typeof setInterval>>} */\n    this.intervalIds = []\n    /** @type {Array<ReturnType<typeof setTimeout>>} */\n    this.timeoutIds = []\n    /** @type {boolean} - True between stop() and the next start(); cron self-rescheduler checks this so a stop() during an in-flight enqueue doesn't immediately re-arm. */\n    this.stopped = false\n  }\n\n  /** @returns {Promise<void>} */\n  async start() {\n    this.stopped = false\n\n    const scheduledBackgroundJobsConfig = await this.configuration.getScheduledBackgroundJobsConfig()\n\n    if (!scheduledBackgroundJobsConfig?.jobs) {\n      return\n    }\n\n    for (const jobKey of Object.keys(scheduledBackgroundJobsConfig.jobs)) {\n      const jobConfiguration = scheduledBackgroundJobsConfig.jobs[jobKey]\n\n      if (!jobConfiguration || jobConfiguration.enabled === false) {\n        continue\n      }\n\n      this.scheduleJob({jobConfiguration, jobKey})\n    }\n  }\n\n  /** @returns {void} */\n  stop() {\n    this.stopped = true\n\n    for (const intervalId of this.intervalIds) {\n      clearInterval(intervalId)\n    }\n\n    for (const timeoutId of this.timeoutIds) {\n      clearTimeout(timeoutId)\n    }\n\n    this.intervalIds = []\n    this.timeoutIds = []\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {void}\n   */\n  scheduleJob({jobConfiguration, jobKey}) {\n    if (!jobConfiguration.class || typeof jobConfiguration.class.performLaterWithOptions !== \"function\") {\n      throw new Error(`Scheduled background job ${jobKey} must define a job class.`)\n    }\n\n    if (jobConfiguration.cron !== undefined && jobConfiguration.every !== undefined) {\n      throw new Error(`Scheduled background job ${jobKey} must define either \"every\" or \"cron\", not both.`)\n    }\n\n    if (jobConfiguration.cron !== undefined) {\n      this.scheduleCronJob({jobConfiguration, jobKey})\n\n      return\n    }\n\n    if (jobConfiguration.every === undefined) {\n      throw new Error(`Scheduled background job ${jobKey} must define either \"every\" or \"cron\".`)\n    }\n\n    this.scheduleEveryJob({jobConfiguration, jobKey})\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {void}\n   */\n  scheduleEveryJob({jobConfiguration, jobKey}) {\n    const everyConfig = /** @type {NonNullable<typeof jobConfiguration.every>} */ (jobConfiguration.every)\n    const {everyValue, firstInValue} = this.normalizeEvery(everyConfig)\n    const intervalMs = parseScheduledDuration(everyValue, `${jobKey}.every`)\n    const firstInMs = firstInValue !== undefined ? parseScheduledDuration(firstInValue, `${jobKey}.first_in`) : intervalMs\n\n    if (intervalMs < 1) {\n      throw new Error(`Scheduled background job ${jobKey}.every must be at least 1 millisecond.`)\n    }\n\n    const timeoutId = setTimeout(() => {\n      void this.enqueueScheduledJob({jobConfiguration, jobKey})\n\n      const intervalId = setInterval(() => {\n        void this.enqueueScheduledJob({jobConfiguration, jobKey})\n      }, intervalMs)\n\n      this.intervalIds.push(intervalId)\n    }, firstInMs)\n\n    this.timeoutIds.push(timeoutId)\n  }\n\n  /**\n   * Crontab schedules don't have a constant interval (`0 9 * * 1-5`\n   * fires once per weekday at 9 AM, with gaps of varying length), so\n   * we self-reschedule with `setTimeout` after every fire instead of\n   * using `setInterval`.\n   *\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {void}\n   */\n  scheduleCronJob({jobConfiguration, jobKey}) {\n    const cronExpression = jobConfiguration.cron\n\n    if (typeof cronExpression !== \"string\") {\n      throw new Error(`Scheduled background job ${jobKey}.cron must be a string.`)\n    }\n\n    const parsed = parseCronExpression(cronExpression)\n    const scheduleNext = () => {\n      if (this.stopped) return\n\n      const nextDate = nextCronFireDate(parsed, new Date())\n      const delayMs = Math.max(1, nextDate.getTime() - Date.now())\n      const timeoutId = setTimeout(async () => {\n        if (this.stopped) return\n\n        await this.enqueueScheduledJob({jobConfiguration, jobKey})\n\n        // The await above can yield to a stop() call. Re-check before\n        // re-arming so we don't keep firing after shutdown.\n        if (this.stopped) return\n\n        scheduleNext()\n      }, delayMs)\n\n      this.timeoutIds.push(timeoutId)\n    }\n\n    scheduleNext()\n  }\n\n  /**\n   * @param {object} args - Options.\n   * @param {import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration} args.jobConfiguration - Job configuration.\n   * @param {string} args.jobKey - Job key.\n   * @returns {Promise<void>}\n   */\n  async enqueueScheduledJob({jobConfiguration, jobKey}) {\n    try {\n      await this.enqueueJob({\n        args: Array.isArray(jobConfiguration.args) ? jobConfiguration.args : [],\n        jobClass: jobConfiguration.class,\n        jobKey,\n        options: jobConfiguration.options || {}\n      })\n    } catch (error) {\n      await this.logger.error(() => [\"Failed to enqueue scheduled background job\", {jobKey, jobName: jobConfiguration.class.jobName()}, error])\n    }\n  }\n\n  /**\n   * @param {NonNullable<import(\"../configuration-types.js\").ScheduledBackgroundJobConfiguration[\"every\"]>} every - Every config (caller must guarantee not undefined).\n   * @returns {{everyValue: number | string, firstInValue?: number | string}} - Normalized interval and first-run delay values.\n   */\n  normalizeEvery(every) {\n    if (Array.isArray(every)) {\n      const [everyValue, everyOptions] = every\n\n      if (!everyOptions || typeof everyOptions !== \"object\" || Array.isArray(everyOptions)) {\n        return {everyValue}\n      }\n\n      return {everyValue, firstInValue: everyOptions.firstIn ?? everyOptions.first_in}\n    }\n\n    return {everyValue: every}\n  }\n}\n"]}