@stonyx/cron 0.2.1-alpha.41 → 0.2.1-alpha.42

package/README.md

@@ -35,6 +35,8 @@ When a job is executed, its next trigger time is updated, and it is re-inserted
 |  `register`  | `key: string, callback: Function, interval: number, runOnInit?: boolean` | Register a new job with a given interval in seconds. If `runOnInit` is true, the job runs immediately upon registration. |
 | `unregister` |                               `key: string`                              | Remove a previously registered job.                                                                                      |
 
+> Job callbacks are invoked fire-and-forget: two *different* jobs due in the same tick may overlap, and a job whose previous invocation has not settled is skipped (and logged) when it next comes due rather than running concurrently with itself. A callback that throws — synchronously or by rejecting — is logged, never propagated.
+
 > `MinHeap` is also exported as a public subpath (`@stonyx/cron/min-heap`) and can be imported directly for advanced usage.
 
 ## Configuration

package/dist/main.d.ts

@@ -3,6 +3,7 @@ interface CronJob extends HeapItem {
     callback: () => void | Promise<void>;
     interval: string;
     key: string;
+    running: boolean;
 }
 export default class Cron {
     static instance: Cron | null;
@@ -15,6 +16,15 @@ export default class Cron {
     runDueJobs(): Promise<void>;
     register(key: string, callback: () => void | Promise<void>, interval: string, runOnInit?: boolean): void;
     unregister(key: string): void;
+    /**
+     * Invoke a consumer callback without ever blocking the caller.
+     *
+     * Synchronous throws and rejected thenables are both routed to `log.error`
+     * with `errorMessage`; a callback that never settles simply never clears its
+     * in-flight flag. The job is skipped (and logged) while a previous invocation
+     * is still running, so fire-and-forget cannot stack invocations on one job.
+     */
+    invokeJob(job: CronJob, errorMessage: string): void;
     setNextTrigger(job: CronJob): void;
     log(text: string, key?: string | null): void;
 }

package/dist/main.js

@@ -55,19 +55,17 @@ export default class Cron {
             const job = heap.pop();
             if (config.debug)
                 this.log('job has been triggered', job.key);
-            try {
-                await job.callback();
-            }
-            catch (err) {
-                log.error(`Cron job "${job.key}" failed:`, err);
-            }
+            // Reschedule before invoking: a consumer callback is never awaited here,
+            // so a callback that hangs or rejects can no longer starve the drain loop
+            // or leave the job orphaned outside the heap.
             this.setNextTrigger(job);
             heap.push(job);
+            this.invokeJob(job, `Cron job "${job.key}" failed:`);
         }
         this.scheduleNextRun();
     }
     register(key, callback, interval, runOnInit = false) {
-        const job = { callback, interval, key, nextTrigger: 0 };
+        const job = { callback, interval, key, nextTrigger: 0, running: false };
         this.jobs[key] = job;
         this.setNextTrigger(job);
         this.heap.push(job);
@@ -75,12 +73,7 @@ export default class Cron {
             this.log(`job has been registered with interval: ${interval}`, key);
         }
         if (runOnInit) {
-            try {
-                callback();
-            }
-            catch (err) {
-                log.error(`Cron job "${key}" failed on init:`, err);
-            }
+            this.invokeJob(job, `Cron job "${key}" failed on init:`);
         }
         this.scheduleNextRun();
     }
@@ -95,6 +88,39 @@ export default class Cron {
             this.log('job has been unregistered', key);
         this.scheduleNextRun();
     }
+    /**
+     * Invoke a consumer callback without ever blocking the caller.
+     *
+     * Synchronous throws and rejected thenables are both routed to `log.error`
+     * with `errorMessage`; a callback that never settles simply never clears its
+     * in-flight flag. The job is skipped (and logged) while a previous invocation
+     * is still running, so fire-and-forget cannot stack invocations on one job.
+     */
+    invokeJob(job, errorMessage) {
+        if (job.running) {
+            this.log('job is still running, skipping this run', job.key);
+            return;
+        }
+        job.running = true;
+        const settle = () => { job.running = false; };
+        let result;
+        try {
+            result = job.callback();
+        }
+        catch (err) {
+            log.error(errorMessage, err);
+            settle();
+            return;
+        }
+        if (!result || typeof result.then !== 'function') {
+            settle();
+            return;
+        }
+        result.then(settle, (err) => {
+            log.error(errorMessage, err);
+            settle();
+        });
+    }
     setNextTrigger(job) {
         job.nextTrigger = getTimestamp() + parseInt(job.interval, 10);
     }

package/package.json

@@ -3,7 +3,7 @@
   "keywords": [
     "stonyx-module"
   ],
-  "version": "0.2.1-alpha.41",
+  "version": "0.2.1-alpha.42",
   "description": "Cron/job scheduler for Stonyx framework",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",