mongo-job-scheduler 0.1.3 → 0.1.5

package/README.md

@@ -21,6 +21,7 @@ Designed for distributed systems that need:
 - **Interval jobs**
 - **Resume on restart**
 - **Stale lock recovery**
+- **Automatic Lock Renewal** (Heartbeats): Long-running jobs automatically extend their lock.
 - **Sharding-safe design**
 
 ## Distributed Systems
@@ -76,6 +77,20 @@ await scheduler.schedule(
 );
 ```
 
+## Interval Scheduling
+
+Run a job repeatedly with a fixed delay between executions (e.g., every 5 minutes).
+
+```typescript
+await scheduler.schedule({
+  name: "cleanup-logs",
+  data: {},
+  repeat: {
+    every: 5 * 60 * 1000, // 5 minutes in milliseconds
+  },
+});
+```
+
 ## Job Deduplication
 
 Prevent duplicate jobs using `dedupeKey`. If a job with the same key exists, it returns the existing job instead of creating a new one.
@@ -101,6 +116,18 @@ await scheduler.cancel(jobId);
 const job = await scheduler.getJob(jobId);
 ```
 
+## Job Persistence & Updates
+
+Update job `data`, reschedule, or modify configuration safely.
+
+```typescript
+await scheduler.updateJob(jobId, {
+  data: { page: 2 },
+  nextRunAt: new Date(Date.now() + 60000), // delay by 1 min
+  repeat: { every: 60000 }, // Change to run every minute
+});
+```
+
 ## Bulk Scheduling
 
 For high-performance ingestion, use `scheduleBulk` to insert multiple jobs in a single database operation:

package/dist/core/scheduler.d.ts

@@ -1,5 +1,5 @@
 import { SchedulerEventMap } from "../types/events";
-import { JobStore } from "../store";
+import { JobStore, JobUpdates } from "../store";
 import { Job } from "../types/job";
 import { ScheduleOptions } from "../types/schedule";
 export interface SchedulerOptions {
@@ -33,6 +33,10 @@ export declare class Scheduler {
      * Get a job by ID
      */
     getJob(jobId: unknown): Promise<Job | null>;
+    /**
+     * Update job data or schedule
+     */
+    updateJob(jobId: unknown, updates: JobUpdates): Promise<void>;
     /**
      * Cancel a job
      */

package/dist/core/scheduler.js

@@ -94,6 +94,15 @@ class Scheduler {
         }
         return this.store.findById(jobId);
     }
+    /**
+     * Update job data or schedule
+     */
+    async updateJob(jobId, updates) {
+        if (!this.store) {
+            throw new Error("Scheduler has no JobStore configured");
+        }
+        await this.store.update(jobId, updates);
+    }
     /**
      * Cancel a job
      */

package/dist/store/in-memory-job-store.d.ts

@@ -1,5 +1,5 @@
 import { Job } from "../types/job";
-import { JobStore } from "./job-store";
+import { JobStore, JobUpdates } from "./job-store";
 export declare class InMemoryJobStore implements JobStore {
     private jobs;
     private mutex;
@@ -22,4 +22,6 @@ export declare class InMemoryJobStore implements JobStore {
     }): Promise<number>;
     cancel(jobId: unknown): Promise<void>;
     findById(jobId: unknown): Promise<Job | null>;
+    renewLock(jobId: unknown, workerId: string): Promise<void>;
+    update(jobId: unknown, updates: JobUpdates): Promise<void>;
 }

package/dist/store/in-memory-job-store.js

@@ -119,5 +119,35 @@ class InMemoryJobStore {
         const job = this.jobs.get(String(jobId));
         return job ? { ...job } : null;
     }
+    async renewLock(jobId, workerId) {
+        const job = this.jobs.get(String(jobId));
+        if (!job)
+            throw new store_errors_1.JobNotFoundError();
+        if (job.status === "running" && job.lockedBy === workerId) {
+            job.lockedAt = new Date();
+            job.updatedAt = new Date();
+        }
+        else {
+            throw new Error("Job lock lost or owner changed");
+        }
+    }
+    async update(jobId, updates) {
+        const job = this.jobs.get(String(jobId));
+        if (!job)
+            throw new store_errors_1.JobNotFoundError();
+        if (updates.data !== undefined) {
+            job.data = updates.data;
+        }
+        if (updates.nextRunAt !== undefined) {
+            job.nextRunAt = updates.nextRunAt;
+        }
+        if (updates.retry !== undefined) {
+            job.retry = updates.retry;
+        }
+        if (updates.repeat !== undefined) {
+            job.repeat = updates.repeat;
+        }
+        job.updatedAt = new Date();
+    }
 }
 exports.InMemoryJobStore = InMemoryJobStore;

package/dist/store/job-store.d.ts

@@ -47,4 +47,20 @@ export interface JobStore {
      * Get job by ID
      */
     findById(jobId: unknown): Promise<Job | null>;
+    /**
+     * Renew the lock for a running job (heartbeat)
+     */
+    renewLock(jobId: unknown, workerId: string): Promise<void>;
+    /**
+     * Update job properties (data persistence)
+     */
+    update(jobId: unknown, updates: JobUpdates): Promise<void>;
+}
+import { RetryOptions } from "../types/retry";
+import { RepeatOptions } from "../types/repeat";
+export interface JobUpdates {
+    data?: unknown;
+    nextRunAt?: Date;
+    retry?: RetryOptions;
+    repeat?: RepeatOptions;
 }

package/dist/store/mongo/mongo-job-store.d.ts

@@ -1,5 +1,5 @@
 import { Db, ObjectId } from "mongodb";
-import { JobStore } from "../job-store";
+import { JobStore, JobUpdates } from "../job-store";
 import { Job } from "../../types/job";
 export interface MongoJobStoreOptions {
     collectionName?: string;
@@ -28,4 +28,6 @@ export declare class MongoJobStore implements JobStore {
         now: Date;
         lockTimeoutMs: number;
     }): Promise<number>;
+    renewLock(id: ObjectId, workerId: string): Promise<void>;
+    update(id: ObjectId, updates: JobUpdates): Promise<void>;
 }

package/dist/store/mongo/mongo-job-store.js

@@ -165,5 +165,35 @@ class MongoJobStore {
         });
         return result.modifiedCount;
     }
+    async renewLock(id, workerId) {
+        const now = new Date();
+        const result = await this.collection.updateOne({
+            _id: id,
+            lockedBy: workerId,
+            status: "running",
+        }, {
+            $set: {
+                lockedAt: now,
+                updatedAt: now,
+            },
+        });
+        if (result.matchedCount === 0) {
+            throw new Error("Job lock lost or owner changed");
+        }
+    }
+    async update(id, updates) {
+        if (Object.keys(updates).length === 0)
+            return;
+        const $set = { updatedAt: new Date() };
+        if (updates.data !== undefined)
+            $set.data = updates.data;
+        if (updates.nextRunAt !== undefined)
+            $set.nextRunAt = updates.nextRunAt;
+        if (updates.retry !== undefined)
+            $set.retry = updates.retry;
+        if (updates.repeat !== undefined)
+            $set.repeat = updates.repeat;
+        await this.collection.updateOne({ _id: id }, { $set });
+    }
 }
 exports.MongoJobStore = MongoJobStore;

package/dist/worker/worker.js

@@ -80,10 +80,35 @@ class Worker {
             job.lastScheduledAt = next;
             await this.store.reschedule(job._id, next);
         }
+        // ---------------------------
+        // HEARTBEAT
+        // ---------------------------
+        const heartbeatIntervalMs = Math.max(50, this.lockTimeout / 2);
+        const heartbeatParams = {
+            jobId: job._id,
+            workerId: this.workerId,
+        };
+        let stopHeartbeat = false;
+        const heartbeatLoop = async () => {
+            while (!stopHeartbeat) {
+                await this.sleep(heartbeatIntervalMs);
+                if (stopHeartbeat)
+                    break;
+                try {
+                    await this.store.renewLock(heartbeatParams.jobId, heartbeatParams.workerId);
+                }
+                catch (err) {
+                    this.emitter.emitSafe("worker:error", new Error(`Heartbeat failed for job ${heartbeatParams.jobId}: ${err}`));
+                    break;
+                }
+            }
+        };
+        const heartbeatPromise = heartbeatLoop();
         try {
             const current = await this.store.findById(job._id);
             if (current && current.status === "cancelled") {
                 this.emitter.emitSafe("job:complete", job);
+                stopHeartbeat = true; // stop fast
                 return;
             }
             await this.handler(job);
@@ -112,10 +137,14 @@ class Worker {
                     attempts,
                     lastError: error.message,
                 });
-                return;
             }
-            await this.store.markFailed(job._id, error.message);
-            this.emitter.emitSafe("job:fail", { job, error });
+            else {
+                await this.store.markFailed(job._id, error.message);
+                this.emitter.emitSafe("job:fail", { job, error });
+            }
+        }
+        finally {
+            stopHeartbeat = true;
         }
     }
     sleep(ms) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mongo-job-scheduler",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Production-grade MongoDB-backed job scheduler with retries, cron, timezone support, and crash recovery",
   "license": "MIT",
   "author": "Darshan Bhut",