@hazeljs/cron 0.2.0-rc.2 → 0.2.0-rc.5

package/dist/cron.service.d.ts

@@ -1,9 +1,15 @@
+import type { HazelApp } from '@hazeljs/core';
 import { CronOptions, CronJobStatus } from './cron.types';
 /**
  * Cron service for managing scheduled jobs
  */
 export declare class CronService {
     private jobs;
+    /**
+     * Auto-discover and register cron jobs from all providers with @Cron decorators.
+     * Called automatically after the application boots.
+     */
+    onApplicationBootstrap(_app: HazelApp): Promise<void>;
     /**
      * Register a new cron job
      */

package/dist/cron.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cron.service.d.ts","sourceRoot":"","sources":["../src/cron.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAgK1D;;GAEG;AACH,qBACa,WAAW;IACtB,OAAO,CAAC,IAAI,CAA8B;IAE1C;;OAEG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACpC,OAAO,GAAE,WAA0C,GAClD,IAAI;IAeP;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAWhC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAU/B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAU9B;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUhC;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUjC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAKrD;;OAEG;IACH,iBAAiB,IAAI,aAAa,EAAE;IAIpC;;OAEG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAMhB;;OAEG;IACH,WAAW,IAAI,MAAM;CAGtB"}
+{"version":3,"file":"cron.service.d.ts","sourceRoot":"","sources":["../src/cron.service.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAsK1D;;GAEG;AACH,qBACa,WAAW;IACtB,OAAO,CAAC,IAAI,CAA8B;IAE1C;;;OAGG;IACG,sBAAsB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IA+B3D;;OAEG;IACH,WAAW,CACT,IAAI,EAAE,MAAM,EACZ,cAAc,EAAE,MAAM,EACtB,QAAQ,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACpC,OAAO,GAAE,WAA0C,GAClD,IAAI;IAeP;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAWhC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAU/B;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAU9B;;OAEG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUhC;;OAEG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUjC;;OAEG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS;IAKrD;;OAEG;IACH,iBAAiB,IAAI,aAAa,EAAE;IAIpC;;OAEG;IACH,OAAO,IAAI,IAAI;IAKf;;OAEG;IACH,QAAQ,IAAI,IAAI;IAKhB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAMhB;;OAEG;IACH,WAAW,IAAI,MAAM;CAGtB"}

package/dist/cron.service.js

@@ -11,8 +11,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CronService = void 0;
 const core_1 = require("@hazeljs/core");
+const cron_decorator_1 = require("./cron.decorator");
 const core_2 = __importDefault(require("@hazeljs/core"));
-const node_cron_1 = __importDefault(require("node-cron"));
+/** Lazy-load node-cron to avoid blocking startup (require can hang in some environments) */
+function getCron() {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- intentional lazy load
+    return require('node-cron');
+}
 /**
  * Represents a scheduled cron job
  * Uses node-cron for proper cron expression parsing and scheduling
@@ -31,7 +36,7 @@ class CronJob {
         // node-cron uses 5-field (minute-level) or 6-field (second-level) expressions
         // Validate the expression upfront
         const expr = this.normalizeExpression(this.cronExpression);
-        if (!node_cron_1.default.validate(expr)) {
+        if (!getCron().validate(expr)) {
             throw new Error(`Invalid cron expression: ${this.cronExpression}. ` +
                 `Format: second minute hour day-of-month month day-of-week`);
         }
@@ -56,7 +61,7 @@ class CronJob {
             return;
         }
         const expr = this.normalizeExpression(this.cronExpression);
-        this.task = node_cron_1.default.schedule(expr, async () => {
+        this.task = getCron().schedule(expr, async () => {
             await this.execute();
         }, {
             scheduled: true,
@@ -149,6 +154,36 @@ let CronService = class CronService {
     constructor() {
         this.jobs = new Map();
     }
+    /**
+     * Auto-discover and register cron jobs from all providers with @Cron decorators.
+     * Called automatically after the application boots.
+     */
+    async onApplicationBootstrap(_app) {
+        const container = core_1.Container.getInstance();
+        const tokens = container.getTokens();
+        for (const token of tokens) {
+            if (typeof token !== 'function' || !token.prototype)
+                continue;
+            try {
+                const instance = container.resolve(token);
+                if (!instance || typeof instance !== 'object')
+                    continue;
+                const metadata = (0, cron_decorator_1.getCronMetadata)(instance);
+                if (metadata && metadata.length > 0) {
+                    for (const job of metadata) {
+                        const callback = instance[job.methodName];
+                        if (typeof callback === 'function') {
+                            this.registerJob(job.options.name || job.methodName, job.options.cronTime, callback.bind(instance), job.options);
+                            core_2.default.info(`Registered cron job: ${job.options.name || job.methodName}`);
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip request-scoped or unresolvable providers
+            }
+        }
+    }
     /**
      * Register a new cron job
      */

package/dist/cron.test.js

@@ -156,6 +156,69 @@ describe('CronService', () => {
             expect(service.getJobCount()).toBe(0);
         });
     });
+    describe('onApplicationBootstrap()', () => {
+        it('discovers and registers cron jobs from container tokens', async () => {
+            class DiscoveredService {
+                run() {
+                    // noop
+                }
+            }
+            __decorate([
+                (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'discovered-job' }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], DiscoveredService.prototype, "run", null);
+            const instance = new DiscoveredService();
+            const tokens = [DiscoveredService];
+            core_1.Container.getInstance.mockReturnValue({
+                getTokens: () => tokens,
+                resolve: (token) => (token === DiscoveredService ? instance : null),
+            });
+            await service.onApplicationBootstrap({});
+            expect(service.getJobCount()).toBe(1);
+            expect(service.getJobStatus('discovered-job')).toBeDefined();
+        });
+        it('skips tokens that are not functions', async () => {
+            core_1.Container.getInstance.mockReturnValue({
+                getTokens: () => ['string-token', 123],
+                resolve: jest.fn(),
+            });
+            await service.onApplicationBootstrap({});
+            expect(service.getJobCount()).toBe(0);
+        });
+        it('skips when resolve throws (request-scoped)', async () => {
+            class Unresolvable {
+            }
+            core_1.Container.getInstance.mockReturnValue({
+                getTokens: () => [Unresolvable],
+                resolve: () => {
+                    throw new Error('request-scoped');
+                },
+            });
+            await expect(service.onApplicationBootstrap({})).resolves.not.toThrow();
+            expect(service.getJobCount()).toBe(0);
+        });
+        it('skips when metadata method is not a function on instance', async () => {
+            class NonFunctionMethod {
+                get myJob() {
+                    return 'not callable';
+                }
+            }
+            __decorate([
+                (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'getter-job' }),
+                __metadata("design:type", String),
+                __metadata("design:paramtypes", [])
+            ], NonFunctionMethod.prototype, "myJob", null);
+            const instance = new NonFunctionMethod();
+            core_1.Container.getInstance.mockReturnValue({
+                getTokens: () => [NonFunctionMethod],
+                resolve: () => instance,
+            });
+            await service.onApplicationBootstrap({});
+            expect(service.getJobCount()).toBe(0);
+        });
+    });
     describe('getJobCount()', () => {
         it('returns 0 when no jobs registered', () => {
             expect(service.getJobCount()).toBe(0);
@@ -180,6 +243,23 @@ describe('CronService', () => {
             expect(callback).toHaveBeenCalled();
         });
     });
+    describe('job options: maxRuns', () => {
+        it('stops job when maxRuns is reached', async () => {
+            const callback = jest.fn().mockResolvedValue(undefined);
+            service.registerJob('maxRuns-job', cron_types_1.CronExpression.EVERY_SECOND, callback, {
+                cronTime: cron_types_1.CronExpression.EVERY_SECOND,
+                runOnInit: true,
+                maxRuns: 1,
+            });
+            await new Promise((r) => setTimeout(r, 50));
+            expect(callback).toHaveBeenCalledTimes(1);
+            // Wait for schedule tick at 1s - should hit maxRuns branch and stop (no second callback)
+            await new Promise((r) => setTimeout(r, 1500));
+            expect(callback).toHaveBeenCalledTimes(1);
+            const status = service.getJobStatus('maxRuns-job');
+            expect(status?.runCount).toBe(1);
+        });
+    });
     describe('job options: onComplete / onError', () => {
         it('calls onComplete after successful execution (via runOnInit)', async () => {
             const onComplete = jest.fn();
@@ -219,6 +299,19 @@ describe('CronService', () => {
             expect(() => service.startJob('already-running')).not.toThrow();
         });
     });
+    describe('skip duplicate run when already executing', () => {
+        it('skips execution when job is already running (concurrent tick)', async () => {
+            const callback = jest.fn().mockImplementation(() => new Promise((r) => setTimeout(r, 2500)));
+            // Use every-second cron so a second tick can fire while first is still running
+            service.registerJob('slow-job', cron_types_1.CronExpression.EVERY_SECOND, callback, {
+                cronTime: cron_types_1.CronExpression.EVERY_SECOND,
+                runOnInit: true,
+            });
+            await new Promise((r) => setTimeout(r, 2500));
+            // First run (runOnInit) takes 2.5s; second tick at ~1s fires but is skipped (_isRunning)
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+    });
 });
 describe('Cron decorator', () => {
     it('attaches metadata to the class', () => {
@@ -380,6 +473,48 @@ describe('CronModule', () => {
             }
             expect(() => cron_module_1.CronModule.registerJobsFromProvider(new TaskService())).not.toThrow();
         });
+        it('handles resolve throwing (e.g. container error)', () => {
+            const cronService = new cron_service_1.CronService();
+            core_1.Container.getInstance.mockReturnValue({
+                resolve: jest.fn().mockImplementation(() => {
+                    throw new Error('resolve failed');
+                }),
+            });
+            class TaskService {
+                doTask() {
+                    // noop
+                }
+            }
+            __decorate([
+                (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'task' }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TaskService.prototype, "doTask", null);
+            expect(() => cron_module_1.CronModule.registerJobsFromProvider(new TaskService())).not.toThrow();
+            cronService.clearAll();
+        });
+        it('skips when callback is not a function', () => {
+            const cronService = new cron_service_1.CronService();
+            core_1.Container.getInstance.mockReturnValue({
+                resolve: jest.fn().mockReturnValue(cronService),
+            });
+            class BadProvider {
+                get doTask() {
+                    return 'not a function';
+                }
+            }
+            __decorate([
+                (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'bad' }),
+                __metadata("design:type", String),
+                __metadata("design:paramtypes", [])
+            ], BadProvider.prototype, "doTask", null);
+            const instance = new BadProvider();
+            // getCronMetadata returns methodName 'doTask' but instance.doTask is a getter returning string
+            cron_module_1.CronModule.registerJobsFromProvider(instance);
+            expect(cronService.getJobCount()).toBe(0);
+            cronService.clearAll();
+        });
     });
 });
 describe('CronExpression constants', () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/cron",
-  "version": "0.2.0-rc.2",
+  "version": "0.2.0-rc.5",
   "description": "Cron job scheduling module for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,5 +50,5 @@
   "peerDependencies": {
     "@hazeljs/core": ">=0.2.0-beta.0"
   },
-  "gitHead": "d81cfed182d5236ca8aef4b855fbd3ee5b4fd048"
+  "gitHead": "84ad3db0f24f75a9d55c6eec5997849fed3aa00e"
 }