@rebasepro/server-core 0.0.1-canary.94dff14 → 0.0.1-canary.bbcb8b4

package/dist/index.umd.js

@@ -49254,46 +49254,98 @@ export default ${safeId}Collection;
     __proto__: null,
     loadCronJobsFromDirectory
   }, Symbol.toStringTag, { value: "Module" }));
+  function expandCronField(field, min, max) {
+    const results = /* @__PURE__ */ new Set();
+    for (const segment of field.split(",")) {
+      const trimmed = segment.trim();
+      if (trimmed === "*") {
+        for (let i2 = min; i2 <= max; i2++) results.add(i2);
+      } else if (trimmed.includes("/")) {
+        const [rangeStr, stepStr] = trimmed.split("/");
+        const step = parseInt(stepStr, 10);
+        if (isNaN(step) || step <= 0) {
+          throw new Error(`Invalid step value "${stepStr}" in cron field "${field}"`);
+        }
+        let start = min;
+        let end = max;
+        if (rangeStr !== "*") {
+          if (rangeStr.includes("-")) {
+            const [a2, b] = rangeStr.split("-").map(Number);
+            start = a2;
+            end = b;
+          } else {
+            start = parseInt(rangeStr, 10);
+          }
+        }
+        for (let i2 = start; i2 <= end; i2 += step) results.add(i2);
+      } else if (trimmed.includes("-")) {
+        const [a2, b] = trimmed.split("-").map(Number);
+        for (let i2 = a2; i2 <= b; i2++) results.add(i2);
+      } else {
+        const val = parseInt(trimmed, 10);
+        if (isNaN(val)) {
+          throw new Error(`Invalid value "${trimmed}" in cron field "${field}"`);
+        }
+        results.add(val);
+      }
+    }
+    return [...results].sort((a2, b) => a2 - b);
+  }
+  function validateCronExpression(schedule) {
+    if (!schedule || typeof schedule !== "string") {
+      return {
+        valid: false,
+        reason: "Schedule must be a non-empty string"
+      };
+    }
+    const parts = schedule.trim().split(/\s+/);
+    if (parts.length !== 5) {
+      return {
+        valid: false,
+        reason: `Expected 5 fields, got ${parts.length}`
+      };
+    }
+    const fieldRanges = [["minute", 0, 59], ["hour", 0, 23], ["day of month", 1, 31], ["month", 1, 12], ["day of week", 0, 6]];
+    for (let i2 = 0; i2 < 5; i2++) {
+      const [name2, min, max] = fieldRanges[i2];
+      try {
+        const values2 = expandCronField(parts[i2], min, max);
+        if (values2.length === 0) {
+          return {
+            valid: false,
+            reason: `${name2} field "${parts[i2]}" produces no values`
+          };
+        }
+        for (const v of values2) {
+          if (v < min || v > max) {
+            return {
+              valid: false,
+              reason: `${name2} field value ${v} out of range [${min}–${max}]`
+            };
+          }
+        }
+      } catch (err) {
+        return {
+          valid: false,
+          reason: `${name2} field: ${err instanceof Error ? err.message : String(err)}`
+        };
+      }
+    }
+    return {
+      valid: true
+    };
+  }
   function parseCronExpression(expression, after) {
     const parts = expression.trim().split(/\s+/);
     if (parts.length < 5) {
       throw new Error(`Invalid cron expression: "${expression}". Expected 5 fields.`);
     }
     const [minField, hourField, domField, monField, dowField] = parts;
-    const expand = (field, min, max) => {
-      const results = /* @__PURE__ */ new Set();
-      for (const segment of field.split(",")) {
-        if (segment === "*") {
-          for (let i2 = min; i2 <= max; i2++) results.add(i2);
-        } else if (segment.includes("/")) {
-          const [rangeStr, stepStr] = segment.split("/");
-          const step = parseInt(stepStr, 10);
-          let start = min;
-          let end = max;
-          if (rangeStr !== "*") {
-            if (rangeStr.includes("-")) {
-              const [a2, b] = rangeStr.split("-").map(Number);
-              start = a2;
-              end = b;
-            } else {
-              start = parseInt(rangeStr, 10);
-            }
-          }
-          for (let i2 = start; i2 <= end; i2 += step) results.add(i2);
-        } else if (segment.includes("-")) {
-          const [a2, b] = segment.split("-").map(Number);
-          for (let i2 = a2; i2 <= b; i2++) results.add(i2);
-        } else {
-          results.add(parseInt(segment, 10));
-        }
-      }
-      return [...results].sort((a2, b) => a2 - b);
-    };
-    const minutes = expand(minField, 0, 59);
-    const hours = expand(hourField, 0, 23);
-    const doms = expand(domField, 1, 31);
-    const months = expand(monField, 1, 12);
-    const dows = expand(dowField, 0, 6);
+    const minutes = expandCronField(minField, 0, 59);
+    const hours = expandCronField(hourField, 0, 23);
+    const doms = expandCronField(domField, 1, 31);
+    const months = expandCronField(monField, 1, 12);
+    const dows = expandCronField(dowField, 0, 6);
     const candidate = new Date(after);
     candidate.setSeconds(0, 0);
     candidate.setMinutes(candidate.getMinutes() + 1);
@@ -49314,6 +49366,7 @@ export default ${safeId}Collection;
     return fallback;
   }
   const MAX_LOGS_PER_JOB = 50;
+  const MIN_SCHEDULE_INTERVAL_MS = 5e3;
   class CronScheduler {
     jobs = /* @__PURE__ */ new Map();
     started = false;
@@ -49335,23 +49388,39 @@ export default ${safeId}Collection;
     }
     /**
      * Register a batch of loaded cron jobs.
+     *
+     * If the scheduler is already started, newly registered jobs are
+     * automatically scheduled (so late-registered jobs don't sit idle).
+     *
+     * Validates the cron schedule on registration — invalid schedules
+     * are rejected with a warning and the job is NOT registered.
      */
     registerJobs(loadedJobs) {
       for (const loaded of loadedJobs) {
+        const validation = validateCronExpression(loaded.definition.schedule);
+        if (!validation.valid) {
+          console.error(`[cron] Rejecting job "${loaded.id}": invalid schedule "${loaded.definition.schedule}" — ${validation.reason}`);
+          continue;
+        }
         const existing = this.jobs.get(loaded.id);
         if (existing) {
           console.warn(`[cron] Duplicate cron job id: "${loaded.id}". Overwriting.`);
           this.stopJob(loaded.id);
         }
+        const enabled = loaded.definition.enabled !== false;
         this.jobs.set(loaded.id, {
           id: loaded.id,
           definition: loaded.definition,
-          enabled: loaded.definition.enabled !== false,
-          state: loaded.definition.enabled !== false ? "idle" : "disabled",
+          enabled,
+          state: enabled ? "idle" : "disabled",
           totalRuns: 0,
           totalFailures: 0,
-          logs: []
+          logs: [],
+          executing: false
         });
+        if (this.started && enabled) {
+          this.scheduleNext(loaded.id);
+        }
       }
     }
     /**
@@ -49385,6 +49454,9 @@ export default ${safeId}Collection;
     }
     /**
      * Stop the scheduler and clear all timers.
+     *
+     * Currently-executing handlers run to completion (they are async),
+     * but no further scheduling occurs after stop.
      */
     stop() {
       this.started = false;
@@ -49443,32 +49515,81 @@ export default ${safeId}Collection;
     }
     /**
      * Manually trigger a job execution immediately.
+     *
+     * Returns `undefined` if the job doesn't exist.
+     * If the job is currently executing, returns the log entry with
+     * a `skipped: true` result rather than running concurrently.
      */
     async triggerJob(id) {
       const job = this.jobs.get(id);
       if (!job) return void 0;
+      if (job.executing) {
+        console.warn(`[cron] Skipping manual trigger of "${id}" — already executing`);
+        const logEntry = {
+          jobId: id,
+          startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          durationMs: 0,
+          success: true,
+          result: {
+            skipped: true,
+            reason: "already_executing"
+          },
+          logs: ["Skipped: job is already running"],
+          manual: true
+        };
+        job.logs.push(logEntry);
+        if (job.logs.length > MAX_LOGS_PER_JOB) job.logs.shift();
+        return logEntry;
+      }
       return this.executeJob(job, true);
     }
     // ─── Internal ────────────────────────────────────────────────────
+    /**
+     * Schedule the next execution for a job.
+     *
+     * Safety guarantees:
+     * 1. Clears any existing timer first (prevents leaked/duplicate timers)
+     * 2. Enforces a minimum delay to prevent tight loops from jitter
+     * 3. Unref's the timer so it doesn't prevent process exit
+     * 4. Re-checks enabled & started state before executing
+     * 5. Concurrency guard prevents overlapping handler executions
+     */
     scheduleNext(id) {
       const job = this.jobs.get(id);
       if (!job || !job.enabled || !this.started) return;
+      this.stopJob(id);
       try {
         const now = /* @__PURE__ */ new Date();
         const nextRun = parseCronExpression(job.definition.schedule, now);
         job.nextRunAt = nextRun;
-        const delay = Math.max(nextRun.getTime() - now.getTime(), 0);
-        job.timerId = setTimeout(async () => {
+        const rawDelay = nextRun.getTime() - now.getTime();
+        const delay = Math.max(rawDelay, MIN_SCHEDULE_INTERVAL_MS);
+        const timer = setTimeout(async () => {
           if (!job.enabled || !this.started) return;
+          if (job.executing) {
+            console.warn(`[cron] Skipping scheduled run of "${id}" — still executing from previous run`);
+            this.scheduleNext(id);
+            return;
+          }
           await this.executeJob(job, false);
-          this.scheduleNext(id);
+          if (this.started && job.enabled) {
+            this.scheduleNext(id);
+          }
         }, delay);
+        if (timer && typeof timer === "object" && "unref" in timer) {
+          timer.unref();
+        }
+        job.timerId = timer;
       } catch (err) {
         console.error(`[cron] Failed to schedule "${id}":`, err);
         job.state = "error";
         job.lastError = err instanceof Error ? err.message : String(err);
       }
     }
+    /**
+     * Stop a single job's timer and clear its next run state.
+     */
     stopJob(id) {
       const job = this.jobs.get(id);
       if (job?.timerId) {
@@ -49477,9 +49598,19 @@ export default ${safeId}Collection;
         job.nextRunAt = void 0;
       }
     }
+    /**
+     * Execute a job's handler with full isolation and safety.
+     *
+     * - Sets a concurrency flag to prevent overlapping runs
+     * - Wraps handler in a timeout race
+     * - Captures all logs, errors, and results
+     * - Persists to store (non-blocking) if available
+     * - Always restores state even on catastrophic errors
+     */
     async executeJob(job, manual) {
       const startedAt = /* @__PURE__ */ new Date();
       const capturedLogs = [];
+      job.executing = true;
       const ctx = {
         jobId: job.id,
         scheduledAt: startedAt,
@@ -49498,14 +49629,21 @@ export default ${safeId}Collection;
       try {
         const timeout = (job.definition.timeoutSeconds ?? 300) * 1e3;
         const handlerPromise = Promise.resolve(job.definition.handler(ctx));
+        let timeoutHandle;
         const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => reject(new Error(`Cron job "${job.id}" timed out after ${timeout}ms`)), timeout);
+          timeoutHandle = setTimeout(() => reject(new Error(`Cron job "${job.id}" timed out after ${timeout}ms`)), timeout);
         });
-        result = await Promise.race([handlerPromise, timeoutPromise]);
+        try {
+          result = await Promise.race([handlerPromise, timeoutPromise]);
+        } finally {
+          clearTimeout(timeoutHandle);
+        }
       } catch (err) {
         success = false;
         error2 = err instanceof Error ? err.message : String(err);
         job.totalFailures++;
+      } finally {
+        job.executing = false;
       }
       const finishedAt = /* @__PURE__ */ new Date();
       const durationMs = finishedAt.getTime() - startedAt.getTime();
@@ -49528,8 +49666,8 @@ export default ${safeId}Collection;
         job.logs.shift();
       }
       if (this.store) {
-        this.store.insertLog(logEntry).catch((err) => {
-          console.error(`[cron] Failed to persist log for "${job.id}":`, err);
+        this.store.insertLog(logEntry).catch((persistErr) => {
+          console.error(`[cron] Failed to persist log for "${job.id}":`, persistErr);
         });
       }
       if (success) {
@@ -49558,7 +49696,8 @@ export default ${safeId}Collection;
   }
   const cronScheduler = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
     __proto__: null,
-    CronScheduler
+    CronScheduler,
+    validateCronExpression
   }, Symbol.toStringTag, { value: "Module" }));
   function createCronRoutes(scheduler) {
     const router = new hono.Hono();
@@ -49960,6 +50099,7 @@ export default ${safeId}Collection;
   exports2.resetConsole = resetConsole;
   exports2.serveSPA = serveSPA;
   exports2.strictAuthLimiter = strictAuthLimiter;
+  exports2.validateCronExpression = validateCronExpression;
   exports2.validatePasswordStrength = validatePasswordStrength;
   exports2.verifyAccessToken = verifyAccessToken;
   exports2.verifyPassword = verifyPassword;