@hazeljs/cron 0.2.0-alpha.1

package/dist/cron.test.js

@@ -0,0 +1,401 @@
+"use strict";
+/// <reference types="jest" />
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+jest.mock('@hazeljs/core', () => ({
+    __esModule: true,
+    Service: () => () => undefined,
+    HazelModule: () => () => undefined,
+    Container: { getInstance: jest.fn() },
+    logger: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+    default: { info: jest.fn(), debug: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const core_1 = require("@hazeljs/core");
+const cron_service_1 = require("./cron.service");
+const cron_module_1 = require("./cron.module");
+const cron_decorator_1 = require("./cron.decorator");
+const cron_types_1 = require("./cron.types");
+// Use a minute-level cron expression that won't fire during tests
+const EVERY_MINUTE = '* * * * *';
+describe('CronService', () => {
+    let service;
+    beforeEach(() => {
+        service = new cron_service_1.CronService();
+    });
+    afterEach(() => {
+        service.clearAll();
+    });
+    describe('registerJob()', () => {
+        it('registers a job and increments count', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            expect(service.getJobCount()).toBe(1);
+        });
+        it('replaces an existing job with the same name', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            expect(service.getJobCount()).toBe(1);
+        });
+        it('does not auto-start when enabled is false', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn(), {
+                cronTime: EVERY_MINUTE,
+                enabled: false,
+            });
+            const status = service.getJobStatus('job1');
+            expect(status).toBeDefined();
+            expect(status?.enabled).toBe(false);
+        });
+        it('throws for invalid cron expression', () => {
+            expect(() => service.registerJob('bad', 'not-a-cron', jest.fn())).toThrow('Invalid cron expression');
+        });
+        it('registers multiple independent jobs', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            service.registerJob('job2', EVERY_MINUTE, jest.fn());
+            service.registerJob('job3', EVERY_MINUTE, jest.fn());
+            expect(service.getJobCount()).toBe(3);
+        });
+    });
+    describe('deleteJob()', () => {
+        it('returns true and removes the job', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            expect(service.deleteJob('job1')).toBe(true);
+            expect(service.getJobCount()).toBe(0);
+        });
+        it('returns false for unknown job', () => {
+            expect(service.deleteJob('unknown')).toBe(false);
+        });
+    });
+    describe('startJob() / stopJob()', () => {
+        it('startJob returns true for existing job', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn(), {
+                cronTime: EVERY_MINUTE,
+                enabled: false,
+            });
+            expect(service.startJob('job1')).toBe(true);
+        });
+        it('startJob returns false for unknown job', () => {
+            expect(service.startJob('unknown')).toBe(false);
+        });
+        it('stopJob returns true for existing job', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            expect(service.stopJob('job1')).toBe(true);
+        });
+        it('stopJob returns false for unknown job', () => {
+            expect(service.stopJob('unknown')).toBe(false);
+        });
+    });
+    describe('enableJob() / disableJob()', () => {
+        it('enableJob returns true for existing job', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn(), {
+                cronTime: EVERY_MINUTE,
+                enabled: false,
+            });
+            expect(service.enableJob('job1')).toBe(true);
+        });
+        it('enableJob returns false for unknown job', () => {
+            expect(service.enableJob('unknown')).toBe(false);
+        });
+        it('disableJob returns true for existing job', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            expect(service.disableJob('job1')).toBe(true);
+        });
+        it('disableJob returns false for unknown job', () => {
+            expect(service.disableJob('unknown')).toBe(false);
+        });
+    });
+    describe('getJobStatus()', () => {
+        it('returns status for registered job', () => {
+            service.registerJob('job1', EVERY_MINUTE, jest.fn());
+            const status = service.getJobStatus('job1');
+            expect(status).toBeDefined();
+            expect(status?.name).toBe('job1');
+            expect(status?.runCount).toBe(0);
+            expect(status?.enabled).toBe(true);
+        });
+        it('returns undefined for unknown job', () => {
+            expect(service.getJobStatus('unknown')).toBeUndefined();
+        });
+    });
+    describe('getAllJobStatuses()', () => {
+        it('returns empty array when no jobs', () => {
+            expect(service.getAllJobStatuses()).toEqual([]);
+        });
+        it('returns all job statuses', () => {
+            service.registerJob('j1', EVERY_MINUTE, jest.fn());
+            service.registerJob('j2', EVERY_MINUTE, jest.fn());
+            const statuses = service.getAllJobStatuses();
+            expect(statuses).toHaveLength(2);
+            expect(statuses.map((s) => s.name)).toContain('j1');
+            expect(statuses.map((s) => s.name)).toContain('j2');
+        });
+    });
+    describe('stopAll() / startAll() / clearAll()', () => {
+        it('stopAll stops all registered jobs', () => {
+            service.registerJob('j1', EVERY_MINUTE, jest.fn());
+            service.registerJob('j2', EVERY_MINUTE, jest.fn());
+            expect(() => service.stopAll()).not.toThrow();
+        });
+        it('startAll starts all registered jobs', () => {
+            service.registerJob('j1', EVERY_MINUTE, jest.fn(), {
+                cronTime: EVERY_MINUTE,
+                enabled: false,
+            });
+            expect(() => service.startAll()).not.toThrow();
+        });
+        it('clearAll removes all jobs', () => {
+            service.registerJob('j1', EVERY_MINUTE, jest.fn());
+            service.registerJob('j2', EVERY_MINUTE, jest.fn());
+            service.clearAll();
+            expect(service.getJobCount()).toBe(0);
+        });
+    });
+    describe('getJobCount()', () => {
+        it('returns 0 when no jobs registered', () => {
+            expect(service.getJobCount()).toBe(0);
+        });
+        it('returns correct count after adding/removing jobs', () => {
+            service.registerJob('j1', EVERY_MINUTE, jest.fn());
+            service.registerJob('j2', EVERY_MINUTE, jest.fn());
+            expect(service.getJobCount()).toBe(2);
+            service.deleteJob('j1');
+            expect(service.getJobCount()).toBe(1);
+        });
+    });
+    describe('job options: runOnInit', () => {
+        it('executes callback immediately when runOnInit is true', async () => {
+            const callback = jest.fn().mockResolvedValue(undefined);
+            service.registerJob('runNow', EVERY_MINUTE, callback, {
+                cronTime: EVERY_MINUTE,
+                runOnInit: true,
+            });
+            // Allow the async execute() to run
+            await new Promise((r) => setTimeout(r, 20));
+            expect(callback).toHaveBeenCalled();
+        });
+    });
+    describe('job options: onComplete / onError', () => {
+        it('calls onComplete after successful execution (via runOnInit)', async () => {
+            const onComplete = jest.fn();
+            service.registerJob('complete-job', EVERY_MINUTE, jest.fn().mockResolvedValue(undefined), {
+                cronTime: EVERY_MINUTE,
+                runOnInit: true,
+                onComplete,
+            });
+            await new Promise((r) => setTimeout(r, 20));
+            expect(onComplete).toHaveBeenCalled();
+        });
+        it('calls onError when callback throws (via runOnInit)', async () => {
+            const onError = jest.fn();
+            service.registerJob('error-job', EVERY_MINUTE, jest.fn().mockRejectedValue(new Error('fail')), {
+                cronTime: EVERY_MINUTE,
+                runOnInit: true,
+                onError,
+            });
+            await new Promise((r) => setTimeout(r, 20));
+            expect(onError).toHaveBeenCalledWith(expect.any(Error));
+        });
+    });
+    describe('startJob on disabled job', () => {
+        it('warns but does not crash when starting a disabled job', () => {
+            service.registerJob('disabled-job', EVERY_MINUTE, jest.fn(), {
+                cronTime: EVERY_MINUTE,
+                enabled: false,
+            });
+            // startJob calls job.start() which logs a warn since job is disabled
+            expect(() => service.startJob('disabled-job')).not.toThrow();
+        });
+    });
+    describe('starting an already-started job', () => {
+        it('does not throw when starting a job that is already running', () => {
+            service.registerJob('already-running', EVERY_MINUTE, jest.fn());
+            // job is already started by registerJob
+            expect(() => service.startJob('already-running')).not.toThrow();
+        });
+    });
+});
+describe('Cron decorator', () => {
+    it('attaches metadata to the class', () => {
+        class MyService {
+            doWork() {
+                // noop
+            }
+        }
+        __decorate([
+            (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'myJob' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], MyService.prototype, "doWork", null);
+        const metadata = Reflect.getMetadata(cron_decorator_1.CRON_METADATA_KEY, MyService);
+        expect(metadata).toHaveLength(1);
+        expect(metadata[0].methodName).toBe('doWork');
+        expect(metadata[0].options.name).toBe('myJob');
+        expect(metadata[0].options.cronTime).toBe(EVERY_MINUTE);
+    });
+    it('uses default name based on class and method when name is not provided', () => {
+        class AnotherService {
+            handleTask() {
+                // noop
+            }
+        }
+        __decorate([
+            (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], AnotherService.prototype, "handleTask", null);
+        const metadata = Reflect.getMetadata(cron_decorator_1.CRON_METADATA_KEY, AnotherService);
+        expect(metadata[0].options.name).toBe('AnotherService.handleTask');
+    });
+    it('accumulates metadata for multiple methods', () => {
+        class MultiService {
+            firstJob() {
+                // noop
+            }
+            secondJob() {
+                // noop
+            }
+        }
+        __decorate([
+            (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'first' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], MultiService.prototype, "firstJob", null);
+        __decorate([
+            (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'second' }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], MultiService.prototype, "secondJob", null);
+        const metadata = Reflect.getMetadata(cron_decorator_1.CRON_METADATA_KEY, MultiService);
+        expect(metadata).toHaveLength(2);
+        const names = metadata.map((m) => m.options.name);
+        expect(names).toContain('first');
+        expect(names).toContain('second');
+    });
+});
+describe('getCronMetadata()', () => {
+    it('returns empty array for class with no @Cron decorators', () => {
+        class Plain {
+            doThing() {
+                // noop
+            }
+        }
+        const instance = new Plain();
+        expect((0, cron_decorator_1.getCronMetadata)(instance)).toEqual([]);
+    });
+    it('returns metadata for class with @Cron decorators', () => {
+        class Scheduled {
+            job() {
+                // noop
+            }
+        }
+        __decorate([
+            (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], Scheduled.prototype, "job", null);
+        const instance = new Scheduled();
+        const meta = (0, cron_decorator_1.getCronMetadata)(instance);
+        expect(meta).toHaveLength(1);
+        expect(meta[0].methodName).toBe('job');
+    });
+});
+describe('CronModule', () => {
+    const EVERY_MINUTE = '* * * * *';
+    describe('forRoot()', () => {
+        it('returns module configuration with defaults', () => {
+            const result = cron_module_1.CronModule.forRoot();
+            expect(result.module).toBe(cron_module_1.CronModule);
+            expect(result.providers).toContain(cron_service_1.CronService);
+            expect(result.exports).toContain(cron_service_1.CronService);
+            expect(result.global).toBe(true);
+        });
+        it('respects isGlobal: false', () => {
+            const result = cron_module_1.CronModule.forRoot({ isGlobal: false });
+            expect(result.global).toBe(false);
+        });
+        it('respects isGlobal: true explicitly', () => {
+            const result = cron_module_1.CronModule.forRoot({ isGlobal: true });
+            expect(result.global).toBe(true);
+        });
+    });
+    describe('registerJobsFromProvider()', () => {
+        it('registers cron jobs from a provider with @Cron decorated methods', () => {
+            const cronService = new cron_service_1.CronService();
+            core_1.Container.getInstance.mockReturnValue({
+                resolve: jest.fn().mockReturnValue(cronService),
+            });
+            class TaskService {
+                doTask() {
+                    // noop
+                }
+            }
+            __decorate([
+                (0, cron_decorator_1.Cron)({ cronTime: EVERY_MINUTE, name: 'myTask' }),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], TaskService.prototype, "doTask", null);
+            const instance = new TaskService();
+            cron_module_1.CronModule.registerJobsFromProvider(instance);
+            expect(cronService.getJobCount()).toBeGreaterThan(0);
+            cronService.clearAll();
+        });
+        it('does nothing when CronService is not in container', () => {
+            core_1.Container.getInstance.mockReturnValue({
+                resolve: jest.fn().mockReturnValue(null),
+            });
+            class NoopService {
+            }
+            expect(() => cron_module_1.CronModule.registerJobsFromProvider(new NoopService())).not.toThrow();
+        });
+        it('does nothing when provider has no @Cron metadata', () => {
+            const cronService = new cron_service_1.CronService();
+            core_1.Container.getInstance.mockReturnValue({
+                resolve: jest.fn().mockReturnValue(cronService),
+            });
+            class EmptyService {
+                plainMethod() {
+                    // noop
+                }
+            }
+            cron_module_1.CronModule.registerJobsFromProvider(new EmptyService());
+            expect(cronService.getJobCount()).toBe(0);
+        });
+        it('handles errors gracefully', () => {
+            core_1.Container.getInstance.mockImplementation(() => {
+                throw new Error('container not ready');
+            });
+            class TaskService {
+            }
+            expect(() => cron_module_1.CronModule.registerJobsFromProvider(new TaskService())).not.toThrow();
+        });
+    });
+});
+describe('CronExpression constants', () => {
+    it('EVERY_SECOND is a valid 6-field expression', () => {
+        expect(cron_types_1.CronExpression.EVERY_SECOND).toBe('* * * * * *');
+    });
+    it('EVERY_MINUTE is a valid expression', () => {
+        expect(cron_types_1.CronExpression.EVERY_MINUTE).toBe('0 * * * * *');
+    });
+    it('EVERY_HOUR is a valid expression', () => {
+        expect(cron_types_1.CronExpression.EVERY_HOUR).toBe('0 0 * * * *');
+    });
+    it('EVERY_DAY_AT_MIDNIGHT is a valid expression', () => {
+        expect(cron_types_1.CronExpression.EVERY_DAY_AT_MIDNIGHT).toBe('0 0 0 * * *');
+    });
+    it('EVERY_YEAR is a valid expression', () => {
+        expect(cron_types_1.CronExpression.EVERY_YEAR).toBe('0 0 0 1 1 *');
+    });
+});

package/dist/cron.types.d.ts

@@ -0,0 +1,174 @@
+/**
+ * Cron job types and interfaces
+ */
+/**
+ * Cron expression type
+ * Format: second minute hour day-of-month month day-of-week
+ * Examples:
+ * - '* * * * * *' - Every second
+ * - '0 * * * * *' - Every minute
+ * - '0 0 * * * *' - Every hour
+ * - '0 0 0 * * *' - Every day at midnight
+ * - '0 0 9 * * 1-5' - Every weekday at 9 AM
+ */
+export type CronExpression = string;
+/**
+ * Cron job options
+ */
+export interface CronOptions {
+    /**
+     * Name of the cron job (for logging and management)
+     */
+    name?: string;
+    /**
+     * Cron expression defining when the job should run
+     */
+    cronTime: CronExpression;
+    /**
+     * Timezone for the cron job
+     * @default 'UTC'
+     */
+    timeZone?: string;
+    /**
+     * Whether to start the job immediately
+     * @default true
+     */
+    runOnInit?: boolean;
+    /**
+     * Whether the job is enabled
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Maximum number of times the job can run
+     */
+    maxRuns?: number;
+    /**
+     * Error handler for the job
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Callback when job completes
+     */
+    onComplete?: () => void;
+}
+/**
+ * Cron job metadata
+ */
+export interface CronJobMetadata {
+    /**
+     * Target class
+     */
+    target: object;
+    /**
+     * Method name
+     */
+    methodName: string;
+    /**
+     * Cron options
+     */
+    options: CronOptions;
+}
+/**
+ * Cron job status
+ */
+export interface CronJobStatus {
+    /**
+     * Job name
+     */
+    name: string;
+    /**
+     * Whether the job is running
+     */
+    isRunning: boolean;
+    /**
+     * Last execution time
+     */
+    lastExecution?: Date;
+    /**
+     * Next execution time
+     */
+    nextExecution?: Date;
+    /**
+     * Number of times the job has run
+     */
+    runCount: number;
+    /**
+     * Whether the job is enabled
+     */
+    enabled: boolean;
+}
+/**
+ * Predefined cron expressions
+ */
+export declare const CronExpression: {
+    /**
+     * Every second
+     */
+    readonly EVERY_SECOND: "* * * * * *";
+    /**
+     * Every 5 seconds
+     */
+    readonly EVERY_5_SECONDS: "*/5 * * * * *";
+    /**
+     * Every 10 seconds
+     */
+    readonly EVERY_10_SECONDS: "*/10 * * * * *";
+    /**
+     * Every 30 seconds
+     */
+    readonly EVERY_30_SECONDS: "*/30 * * * * *";
+    /**
+     * Every minute
+     */
+    readonly EVERY_MINUTE: "0 * * * * *";
+    /**
+     * Every 5 minutes
+     */
+    readonly EVERY_5_MINUTES: "0 */5 * * * *";
+    /**
+     * Every 10 minutes
+     */
+    readonly EVERY_10_MINUTES: "0 */10 * * * *";
+    /**
+     * Every 30 minutes
+     */
+    readonly EVERY_30_MINUTES: "0 */30 * * * *";
+    /**
+     * Every hour
+     */
+    readonly EVERY_HOUR: "0 0 * * * *";
+    /**
+     * Every day at midnight
+     */
+    readonly EVERY_DAY_AT_MIDNIGHT: "0 0 0 * * *";
+    /**
+     * Every day at noon
+     */
+    readonly EVERY_DAY_AT_NOON: "0 0 12 * * *";
+    /**
+     * Every week (Sunday at midnight)
+     */
+    readonly EVERY_WEEK: "0 0 0 * * 0";
+    /**
+     * Every weekday (Monday-Friday at midnight)
+     */
+    readonly EVERY_WEEKDAY: "0 0 0 * * 1-5";
+    /**
+     * Every weekend (Saturday and Sunday at midnight)
+     */
+    readonly EVERY_WEEKEND: "0 0 0 * * 0,6";
+    /**
+     * Every month (1st day at midnight)
+     */
+    readonly EVERY_MONTH: "0 0 0 1 * *";
+    /**
+     * Every quarter (1st day of Jan, Apr, Jul, Oct at midnight)
+     */
+    readonly EVERY_QUARTER: "0 0 0 1 */3 *";
+    /**
+     * Every year (Jan 1st at midnight)
+     */
+    readonly EVERY_YEAR: "0 0 0 1 1 *";
+};
+//# sourceMappingURL=cron.types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cron.types.d.ts","sourceRoot":"","sources":["../src/cron.types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,QAAQ,EAAE,cAAc,CAAC;IAEzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IAEpB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjC;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,IAAI,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,aAAa,CAAC,EAAE,IAAI,CAAC;IAErB;;OAEG;IACH,aAAa,CAAC,EAAE,IAAI,CAAC;IAErB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;CAEK,CAAC"}

package/dist/cron.types.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Cron job types and interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronExpression = void 0;
+/**
+ * Predefined cron expressions
+ */
+exports.CronExpression = {
+    /**
+     * Every second
+     */
+    EVERY_SECOND: '* * * * * *',
+    /**
+     * Every 5 seconds
+     */
+    EVERY_5_SECONDS: '*/5 * * * * *',
+    /**
+     * Every 10 seconds
+     */
+    EVERY_10_SECONDS: '*/10 * * * * *',
+    /**
+     * Every 30 seconds
+     */
+    EVERY_30_SECONDS: '*/30 * * * * *',
+    /**
+     * Every minute
+     */
+    EVERY_MINUTE: '0 * * * * *',
+    /**
+     * Every 5 minutes
+     */
+    EVERY_5_MINUTES: '0 */5 * * * *',
+    /**
+     * Every 10 minutes
+     */
+    EVERY_10_MINUTES: '0 */10 * * * *',
+    /**
+     * Every 30 minutes
+     */
+    EVERY_30_MINUTES: '0 */30 * * * *',
+    /**
+     * Every hour
+     */
+    EVERY_HOUR: '0 0 * * * *',
+    /**
+     * Every day at midnight
+     */
+    EVERY_DAY_AT_MIDNIGHT: '0 0 0 * * *',
+    /**
+     * Every day at noon
+     */
+    EVERY_DAY_AT_NOON: '0 0 12 * * *',
+    /**
+     * Every week (Sunday at midnight)
+     */
+    EVERY_WEEK: '0 0 0 * * 0',
+    /**
+     * Every weekday (Monday-Friday at midnight)
+     */
+    EVERY_WEEKDAY: '0 0 0 * * 1-5',
+    /**
+     * Every weekend (Saturday and Sunday at midnight)
+     */
+    EVERY_WEEKEND: '0 0 0 * * 0,6',
+    /**
+     * Every month (1st day at midnight)
+     */
+    EVERY_MONTH: '0 0 0 1 * *',
+    /**
+     * Every quarter (1st day of Jan, Apr, Jul, Oct at midnight)
+     */
+    EVERY_QUARTER: '0 0 0 1 */3 *',
+    /**
+     * Every year (Jan 1st at midnight)
+     */
+    EVERY_YEAR: '0 0 0 1 1 *',
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @hazeljs/cron - Cron job scheduling module for HazelJS
+ */
+export { CronModule, type CronModuleOptions } from './cron.module';
+export { CronService } from './cron.service';
+export { Cron, getCronMetadata } from './cron.decorator';
+export type { CronOptions, CronJobMetadata, CronJobStatus } from './cron.types';
+export { CronExpression } from './cron.types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACzD,YAAY,EAAE,WAAW,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * @hazeljs/cron - Cron job scheduling module for HazelJS
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronExpression = exports.getCronMetadata = exports.Cron = exports.CronService = exports.CronModule = void 0;
+var cron_module_1 = require("./cron.module");
+Object.defineProperty(exports, "CronModule", { enumerable: true, get: function () { return cron_module_1.CronModule; } });
+var cron_service_1 = require("./cron.service");
+Object.defineProperty(exports, "CronService", { enumerable: true, get: function () { return cron_service_1.CronService; } });
+var cron_decorator_1 = require("./cron.decorator");
+Object.defineProperty(exports, "Cron", { enumerable: true, get: function () { return cron_decorator_1.Cron; } });
+Object.defineProperty(exports, "getCronMetadata", { enumerable: true, get: function () { return cron_decorator_1.getCronMetadata; } });
+var cron_types_1 = require("./cron.types");
+Object.defineProperty(exports, "CronExpression", { enumerable: true, get: function () { return cron_types_1.CronExpression; } });