@eggjs/schedule 5.0.0

package/dist/esm/app/extend/application.js

@@ -0,0 +1,14 @@
+import { ScheduleWorker } from '../../lib/schedule_worker.js';
+const SCHEDULE_WORKER = Symbol('application#scheduleWorker');
+export default {
+    /**
+     * @member app#schedule
+     */
+    get scheduleWorker() {
+        if (!this[SCHEDULE_WORKER]) {
+            this[SCHEDULE_WORKER] = new ScheduleWorker(this);
+        }
+        return this[SCHEDULE_WORKER];
+    },
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwbGljYXRpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvYXBwL2V4dGVuZC9hcHBsaWNhdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFOUQsTUFBTSxlQUFlLEdBQUcsTUFBTSxDQUFDLDRCQUE0QixDQUFDLENBQUM7QUFFN0QsZUFBZTtJQUNiOztPQUVHO0lBQ0gsSUFBSSxjQUFjO1FBQ2hCLElBQUksQ0FBQyxJQUFJLENBQUMsZUFBZSxDQUFDLEVBQUUsQ0FBQztZQUMzQixJQUFJLENBQUMsZUFBZSxDQUFDLEdBQUcsSUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLENBQUM7UUFDbkQsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQy9CLENBQUM7Q0FDSyxDQUFDIn0=

package/dist/esm/app.d.ts

@@ -0,0 +1,6 @@
+import type { Application, ILifecycleBoot } from 'egg';
+export default class Boot implements ILifecycleBoot {
+    #private;
+    constructor(app: Application);
+    didLoad(): Promise<void>;
+}

package/dist/esm/app.js

@@ -0,0 +1,125 @@
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import { importResolve } from '@eggjs/utils';
+const debug = debuglog('@eggjs/schedule/app');
+export default class Boot {
+    #app;
+    #logger;
+    constructor(app) {
+        this.#app = app;
+        this.#logger = app.getLogger('scheduleLogger');
+    }
+    async didLoad() {
+        const scheduleWorker = this.#app.scheduleWorker;
+        await scheduleWorker.init();
+        // log schedule list
+        for (const s in scheduleWorker.scheduleItems) {
+            const schedule = scheduleWorker.scheduleItems[s];
+            if (!schedule.schedule.disable) {
+                this.#logger.info('[@eggjs/schedule]: register schedule %s', schedule.key);
+            }
+        }
+        // register schedule event
+        this.#app.messenger.on('egg-schedule', async (info) => {
+            debug('app got "egg-schedule" message: %o', info);
+            const { id, key } = info;
+            this.#logger.debug(`[Job#${id}] ${key} await app ready`);
+            await this.#app.ready();
+            const schedule = scheduleWorker.scheduleItems[key];
+            this.#logger.debug(`[Job#${id}] ${key} task received by app`);
+            if (!schedule) {
+                this.#logger.warn(`[Job#${id}] ${key} unknown task`);
+                return;
+            }
+            /* istanbul ignore next */
+            if (schedule.schedule.disable) {
+                this.#logger.warn(`[Job#${id}] ${key} disable`);
+                return;
+            }
+            this.#logger.info(`[Job#${id}] ${key} executing by app`);
+            // run with anonymous context
+            const ctx = this.#app.createAnonymousContext({
+                method: 'SCHEDULE',
+                url: `/__schedule?path=${key}&${schedule.scheduleQueryString}`,
+            });
+            const start = Date.now();
+            let success;
+            let e;
+            try {
+                // execute
+                await this.#app.ctxStorage.run(ctx, async () => {
+                    return await schedule.task(ctx, ...info.args);
+                });
+                success = true;
+            }
+            catch (err) {
+                success = false;
+                e = err;
+            }
+            const rt = Date.now() - start;
+            const msg = `[Job#${id}] ${key} execute ${success ? 'succeed' : 'failed'}, used ${rt}ms.`;
+            if (success) {
+                this.#logger.info(msg);
+            }
+            else {
+                this.#logger.error(msg, e);
+            }
+            // notify agent job finish
+            this.#app.messenger.sendToAgent('egg-schedule', {
+                ...info,
+                success,
+                workerId: process.pid,
+                rt,
+                message: e?.message,
+            });
+        });
+        // for test purpose
+        const config = this.#app.config;
+        const directory = [
+            path.join(config.baseDir, 'app/schedule'),
+            ...config.schedule.directory,
+        ];
+        const runSchedule = async (schedulePath, ...args) => {
+            debug('[runSchedule] start schedulePath: %o, args: %o', schedulePath, args);
+            // resolve real path
+            if (path.isAbsolute(schedulePath)) {
+                schedulePath = importResolve(schedulePath);
+            }
+            else {
+                for (const dir of directory) {
+                    const trySchedulePath = path.join(dir, schedulePath);
+                    try {
+                        schedulePath = importResolve(trySchedulePath);
+                        break;
+                    }
+                    catch (err) {
+                        debug('[runSchedule] importResolve %o error: %s', trySchedulePath, err);
+                    }
+                }
+            }
+            debug('[runSchedule] resolve schedulePath: %o', schedulePath);
+            let schedule;
+            try {
+                schedule = scheduleWorker.scheduleItems[schedulePath];
+                if (!schedule) {
+                    throw new Error(`Cannot find schedule ${schedulePath}`);
+                }
+            }
+            catch (err) {
+                err.message = `[@eggjs/schedule] ${err.message}`;
+                throw err;
+            }
+            // run with anonymous context
+            const ctx = this.#app.createAnonymousContext({
+                method: 'SCHEDULE',
+                url: `/__schedule?path=${schedulePath}&${schedule.scheduleQueryString}`,
+            });
+            return await this.#app.ctxStorage.run(ctx, async () => {
+                return await schedule.task(ctx, ...args);
+            });
+        };
+        Reflect.set(this.#app, 'runSchedule', runSchedule);
+        debug('didLoad');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2FwcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBQ3JDLE9BQU8sSUFBSSxNQUFNLFdBQVcsQ0FBQztBQUk3QixPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sY0FBYyxDQUFDO0FBRzdDLE1BQU0sS0FBSyxHQUFHLFFBQVEsQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO0FBRTlDLE1BQU0sQ0FBQyxPQUFPLE9BQU8sSUFBSTtJQUN2QixJQUFJLENBQWM7SUFDbEIsT0FBTyxDQUFZO0lBQ25CLFlBQVksR0FBZ0I7UUFDMUIsSUFBSSxDQUFDLElBQUksR0FBRyxHQUFHLENBQUM7UUFDaEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxHQUFHLENBQUMsU0FBUyxDQUFDLGdCQUFnQixDQUFDLENBQUM7SUFDakQsQ0FBQztJQUVELEtBQUssQ0FBQyxPQUFPO1FBQ1gsTUFBTSxjQUFjLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUM7UUFDaEQsTUFBTSxjQUFjLENBQUMsSUFBSSxFQUFFLENBQUM7UUFFNUIsb0JBQW9CO1FBQ3BCLEtBQUssTUFBTSxDQUFDLElBQUksY0FBYyxDQUFDLGFBQWEsRUFBRSxDQUFDO1lBQzdDLE1BQU0sUUFBUSxHQUFHLGNBQWMsQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDakQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsT0FBTyxFQUFFLENBQUM7Z0JBQy9CLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLHlDQUF5QyxFQUFFLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQztZQUM3RSxDQUFDO1FBQ0gsQ0FBQztRQUVELDBCQUEwQjtRQUMxQixJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxFQUFFLENBQUMsY0FBYyxFQUFFLEtBQUssRUFBQyxJQUFJLEVBQUMsRUFBRTtZQUNsRCxLQUFLLENBQUMsb0NBQW9DLEVBQUUsSUFBSSxDQUFDLENBQUM7WUFDbEQsTUFBTSxFQUFFLEVBQUUsRUFBRSxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUM7WUFDekIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLEtBQUssR0FBRyxrQkFBa0IsQ0FBQyxDQUFDO1lBQ3pELE1BQU0sSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUN4QixNQUFNLFFBQVEsR0FBRyxjQUFjLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBQ25ELElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLFFBQVEsRUFBRSxLQUFLLEdBQUcsdUJBQXVCLENBQUMsQ0FBQztZQUU5RCxJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7Z0JBQ2QsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLEtBQUssR0FBRyxlQUFlLENBQUMsQ0FBQztnQkFDckQsT0FBTztZQUNULENBQUM7WUFFRCwwQkFBMEI7WUFDMUIsSUFBSSxRQUFRLENBQUMsUUFBUSxDQUFDLE9BQU8sRUFBRSxDQUFDO2dCQUM5QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsS0FBSyxHQUFHLFVBQVUsQ0FBQyxDQUFDO2dCQUNoRCxPQUFPO1lBQ1QsQ0FBQztZQUVELElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxLQUFLLEdBQUcsbUJBQW1CLENBQUMsQ0FBQztZQUV6RCw2QkFBNkI7WUFDN0IsTUFBTSxHQUFHLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxzQkFBc0IsQ0FBQztnQkFDM0MsTUFBTSxFQUFFLFVBQVU7Z0JBQ2xCLEdBQUcsRUFBRSxvQkFBb0IsR0FBRyxJQUFJLFFBQVEsQ0FBQyxtQkFBbUIsRUFBRTthQUMvRCxDQUFDLENBQUM7WUFFSCxNQUFNLEtBQUssR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLENBQUM7WUFFekIsSUFBSSxPQUFnQixDQUFDO1lBQ3JCLElBQUksQ0FBb0IsQ0FBQztZQUN6QixJQUFJLENBQUM7Z0JBQ0gsVUFBVTtnQkFDVixNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxJQUFJLEVBQUU7b0JBQzdDLE9BQU8sTUFBTSxRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztnQkFDaEQsQ0FBQyxDQUFDLENBQUM7Z0JBQ0gsT0FBTyxHQUFHLElBQUksQ0FBQztZQUNqQixDQUFDO1lBQUMsT0FBTyxHQUFRLEVBQUUsQ0FBQztnQkFDbEIsT0FBTyxHQUFHLEtBQUssQ0FBQztnQkFDaEIsQ0FBQyxHQUFHLEdBQUcsQ0FBQztZQUNWLENBQUM7WUFFRCxNQUFNLEVBQUUsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsS0FBSyxDQUFDO1lBRTlCLE1BQU0sR0FBRyxHQUFHLFFBQVEsRUFBRSxLQUFLLEdBQUcsWUFBWSxPQUFPLENBQUMsQ0FBQyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsUUFBUSxVQUFVLEVBQUUsS0FBSyxDQUFDO1lBQzFGLElBQUksT0FBTyxFQUFFLENBQUM7Z0JBQ1osSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDekIsQ0FBQztpQkFBTSxDQUFDO2dCQUNOLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDLENBQUMsQ0FBQztZQUM3QixDQUFDO1lBRUQsMEJBQTBCO1lBQzFCLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxjQUFjLEVBQUU7Z0JBQzlDLEdBQUcsSUFBSTtnQkFDUCxPQUFPO2dCQUNQLFFBQVEsRUFBRSxPQUFPLENBQUMsR0FBRztnQkFDckIsRUFBRTtnQkFDRixPQUFPLEVBQUUsQ0FBQyxFQUFFLE9BQU87YUFDRSxDQUFDLENBQUM7UUFDM0IsQ0FBQyxDQUFDLENBQUM7UUFFSCxtQkFBbUI7UUFDbkIsTUFBTSxNQUFNLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUM7UUFDaEMsTUFBTSxTQUFTLEdBQUc7WUFDaEIsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUFFLGNBQWMsQ0FBQztZQUN6QyxHQUFHLE1BQU0sQ0FBQyxRQUFRLENBQUMsU0FBUztTQUM3QixDQUFDO1FBQ0YsTUFBTSxXQUFXLEdBQUcsS0FBSyxFQUFFLFlBQW9CLEVBQUUsR0FBRyxJQUFXLEVBQUUsRUFBRTtZQUNqRSxLQUFLLENBQUMsZ0RBQWdELEVBQUUsWUFBWSxFQUFFLElBQUksQ0FBQyxDQUFDO1lBRTVFLG9CQUFvQjtZQUNwQixJQUFJLElBQUksQ0FBQyxVQUFVLENBQUMsWUFBWSxDQUFDLEVBQUUsQ0FBQztnQkFDbEMsWUFBWSxHQUFHLGFBQWEsQ0FBQyxZQUFZLENBQUMsQ0FBQztZQUM3QyxDQUFDO2lCQUFNLENBQUM7Z0JBQ04sS0FBSyxNQUFNLEdBQUcsSUFBSSxTQUFTLEVBQUUsQ0FBQztvQkFDNUIsTUFBTSxlQUFlLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLEVBQUUsWUFBWSxDQUFDLENBQUM7b0JBQ3JELElBQUksQ0FBQzt3QkFDSCxZQUFZLEdBQUcsYUFBYSxDQUFDLGVBQWUsQ0FBQyxDQUFDO3dCQUM5QyxNQUFNO29CQUNSLENBQUM7b0JBQUMsT0FBTyxHQUFHLEVBQUUsQ0FBQzt3QkFDYixLQUFLLENBQUMsMENBQTBDLEVBQUUsZUFBZSxFQUFFLEdBQUcsQ0FBQyxDQUFDO29CQUMxRSxDQUFDO2dCQUNILENBQUM7WUFDSCxDQUFDO1lBRUQsS0FBSyxDQUFDLHdDQUF3QyxFQUFFLFlBQVksQ0FBQyxDQUFDO1lBQzlELElBQUksUUFBeUIsQ0FBQztZQUM5QixJQUFJLENBQUM7Z0JBQ0gsUUFBUSxHQUFHLGNBQWMsQ0FBQyxhQUFhLENBQUMsWUFBWSxDQUFDLENBQUM7Z0JBQ3RELElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztvQkFDZCxNQUFNLElBQUksS0FBSyxDQUFDLHdCQUF3QixZQUFZLEVBQUUsQ0FBQyxDQUFDO2dCQUMxRCxDQUFDO1lBQ0gsQ0FBQztZQUFDLE9BQU8sR0FBUSxFQUFFLENBQUM7Z0JBQ2xCLEdBQUcsQ0FBQyxPQUFPLEdBQUcscUJBQXFCLEdBQUcsQ0FBQyxPQUFPLEVBQUUsQ0FBQztnQkFDakQsTUFBTSxHQUFHLENBQUM7WUFDWixDQUFDO1lBRUQsNkJBQTZCO1lBQzdCLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsc0JBQXNCLENBQUM7Z0JBQzNDLE1BQU0sRUFBRSxVQUFVO2dCQUNsQixHQUFHLEVBQUUsb0JBQW9CLFlBQVksSUFBSSxRQUFRLENBQUMsbUJBQW1CLEVBQUU7YUFDeEUsQ0FBQyxDQUFDO1lBQ0gsT0FBTyxNQUFNLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxJQUFJLEVBQUU7Z0JBQ3BELE9BQU8sTUFBTSxRQUFRLENBQUMsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLElBQUksQ0FBQyxDQUFDO1lBQzNDLENBQUMsQ0FBQyxDQUFDO1FBQ0wsQ0FBQyxDQUFDO1FBQ0YsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLGFBQWEsRUFBRSxXQUFXLENBQUMsQ0FBQztRQUVuRCxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUM7SUFDbkIsQ0FBQztDQUNGIn0=

package/dist/esm/config/config.default.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Record<string, any>;
+export default _default;

package/dist/esm/config/config.default.js

@@ -0,0 +1,15 @@
+export default () => {
+    const config = {};
+    config.customLogger = {
+        scheduleLogger: {
+            consoleLevel: 'NONE',
+            file: 'egg-schedule.log',
+        },
+    };
+    config.schedule = {
+        // custom additional directory, full path
+        directory: [],
+    };
+    return config;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlnLmRlZmF1bHQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29uZmlnL2NvbmZpZy5kZWZhdWx0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsR0FBRyxFQUFFO0lBQ2xCLE1BQU0sTUFBTSxHQUFHLEVBQXlCLENBQUM7SUFFekMsTUFBTSxDQUFDLFlBQVksR0FBRztRQUNwQixjQUFjLEVBQUU7WUFDZCxZQUFZLEVBQUUsTUFBTTtZQUNwQixJQUFJLEVBQUUsa0JBQWtCO1NBQ3pCO0tBQ0YsQ0FBQztJQUVGLE1BQU0sQ0FBQyxRQUFRLEdBQUc7UUFDaEIseUNBQXlDO1FBQ3pDLFNBQVMsRUFBRSxFQUFFO0tBQ2QsQ0FBQztJQUVGLE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUMsQ0FBQyJ9

package/dist/esm/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/types.js';

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export * from './lib/types.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQkFBZ0IsQ0FBQyJ9

package/dist/esm/lib/load_schedule.d.ts

@@ -0,0 +1,3 @@
+import type { EggApplicationCore } from 'egg';
+import type { EggScheduleItem } from './types.js';
+export declare function loadSchedule(app: EggApplicationCore): Promise<Record<string, EggScheduleItem>>;

package/dist/esm/lib/load_schedule.js

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import assert from 'node:assert';
+import { stringify } from 'node:querystring';
+import { isClass, isFunction, isGeneratorFunction } from 'is-type-of';
+import { importResolve } from '@eggjs/utils';
+function getScheduleLoader(app) {
+    return class ScheduleLoader extends app.loader.FileLoader {
+        async load() {
+            const target = this.options.target;
+            const items = await this.parse();
+            for (const item of items) {
+                const schedule = item.exports;
+                const fullpath = item.fullpath;
+                const scheduleConfig = schedule.schedule;
+                assert(scheduleConfig, `schedule(${fullpath}): must have "schedule" and "task" properties`);
+                assert(isClass(schedule) || isFunction(schedule.task), `schedule(${fullpath}: \`schedule.task\` should be function or \`schedule\` should be class`);
+                let task;
+                if (isClass(schedule)) {
+                    assert(!isGeneratorFunction(schedule.prototype.subscribe), `schedule(${fullpath}): "schedule" generator function is not support, should use async function instead`);
+                    task = async (ctx, ...args) => {
+                        const instance = new schedule(ctx);
+                        // s.subscribe = app.toAsyncFunction(s.subscribe);
+                        return instance.subscribe(...args);
+                    };
+                }
+                else {
+                    assert(!isGeneratorFunction(schedule.task), `schedule(${fullpath}): "task" generator function is not support, should use async function instead`);
+                    task = schedule.task;
+                    // task = app.toAsyncFunction(schedule.task);
+                }
+                const env = app.config.env;
+                const envList = schedule.schedule.env;
+                if (Array.isArray(envList) && !envList.includes(env)) {
+                    app.coreLogger.info(`[@eggjs/schedule]: ignore schedule ${fullpath} due to \`schedule.env\` not match`);
+                    continue;
+                }
+                // handle symlink case
+                const realFullpath = importResolve(fullpath);
+                target[realFullpath] = {
+                    schedule: scheduleConfig,
+                    scheduleQueryString: stringify(scheduleConfig),
+                    task,
+                    key: realFullpath,
+                };
+            }
+            return target;
+        }
+    };
+}
+export async function loadSchedule(app) {
+    const dirs = [
+        ...app.loader.getLoadUnits().map(unit => path.join(unit.path, 'app/schedule')),
+        ...app.config.schedule.directory,
+    ];
+    const Loader = getScheduleLoader(app);
+    const schedules = {};
+    await new Loader({
+        directory: dirs,
+        target: schedules,
+        inject: app,
+    }).load();
+    Reflect.set(app, 'schedules', schedules);
+    return schedules;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/schedule.d.ts

@@ -0,0 +1,31 @@
+import type { Agent } from 'egg';
+import type { EggScheduleItem, EggScheduleJobInfo } from './types.js';
+import type { BaseStrategy } from './strategy/base.js';
+export declare class Schedule {
+    #private;
+    closed: boolean;
+    constructor(agent: Agent);
+    /**
+     * register a custom Schedule Strategy
+     * @param {String} type - strategy type
+     * @param {Strategy} clz - Strategy class
+     */
+    use(type: string, clz: typeof BaseStrategy): void;
+    /**
+     * load all schedule jobs, then initialize and register speical strategy
+     */
+    init(): Promise<void>;
+    registerSchedule(scheduleItem: EggScheduleItem): void;
+    unregisterSchedule(key: string): boolean;
+    /**
+     * job finish event handler
+     *
+     * @param {Object} info - { id, key, success, message, workerId }
+     */
+    onJobFinish(info: EggScheduleJobInfo): void;
+    /**
+     * start schedule
+     */
+    start(): void;
+    close(): void;
+}

package/dist/esm/lib/schedule.js

@@ -0,0 +1,85 @@
+import { debuglog } from 'node:util';
+import { loadSchedule } from './load_schedule.js';
+const debug = debuglog('@eggjs/schedule/lib/schedule');
+export class Schedule {
+    closed = false;
+    #agent;
+    #logger;
+    #strategyClassMap = new Map();
+    #strategyInstanceMap = new Map();
+    constructor(agent) {
+        this.#agent = agent;
+        this.#logger = agent.getLogger('scheduleLogger');
+    }
+    /**
+     * register a custom Schedule Strategy
+     * @param {String} type - strategy type
+     * @param {Strategy} clz - Strategy class
+     */
+    use(type, clz) {
+        this.#strategyClassMap.set(type, clz);
+        debug('use type: %o', type);
+    }
+    /**
+     * load all schedule jobs, then initialize and register speical strategy
+     */
+    async init() {
+        const scheduleItems = await loadSchedule(this.#agent);
+        for (const scheduleItem of Object.values(scheduleItems)) {
+            this.registerSchedule(scheduleItem);
+        }
+    }
+    registerSchedule(scheduleItem) {
+        const { key, schedule } = scheduleItem;
+        const type = schedule.type;
+        if (schedule.disable) {
+            return;
+        }
+        // find Strategy by type
+        const Strategy = this.#strategyClassMap.get(type);
+        if (!Strategy) {
+            const err = new Error(`schedule type [${type}] is not defined`);
+            err.name = 'EggScheduleError';
+            throw err;
+        }
+        // Initialize strategy and register
+        const instance = new Strategy(schedule, this.#agent, key);
+        this.#strategyInstanceMap.set(key, instance);
+        debug('registerSchedule type: %o, config: %o, key: %o', type, schedule, key);
+    }
+    unregisterSchedule(key) {
+        debug('unregisterSchedule key: %o', key);
+        return this.#strategyInstanceMap.delete(key);
+    }
+    /**
+     * job finish event handler
+     *
+     * @param {Object} info - { id, key, success, message, workerId }
+     */
+    onJobFinish(info) {
+        this.#logger.debug(`[Job#${info.id}] ${info.key} finish event received by agent from worker#${info.workerId}`);
+        const instance = this.#strategyInstanceMap.get(info.key);
+        /* istanbul ignore else */
+        if (instance) {
+            instance.onJobFinish(info);
+        }
+    }
+    /**
+     * start schedule
+     */
+    start() {
+        debug('start');
+        this.closed = false;
+        for (const instance of this.#strategyInstanceMap.values()) {
+            instance.start();
+        }
+    }
+    close() {
+        this.closed = true;
+        for (const instance of this.#strategyInstanceMap.values()) {
+            instance.close();
+        }
+        debug('close');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/schedule_worker.d.ts

@@ -0,0 +1,10 @@
+import type { Application } from 'egg';
+import type { EggScheduleItem } from './types.js';
+export declare class ScheduleWorker {
+    #private;
+    scheduleItems: Record<string, EggScheduleItem>;
+    constructor(app: Application);
+    init(): Promise<void>;
+    registerSchedule(scheduleItem: EggScheduleItem): void;
+    unregisterSchedule(key: string): void;
+}

package/dist/esm/lib/schedule_worker.js

@@ -0,0 +1,18 @@
+import { loadSchedule } from './load_schedule.js';
+export class ScheduleWorker {
+    #app;
+    scheduleItems = {};
+    constructor(app) {
+        this.#app = app;
+    }
+    async init() {
+        this.scheduleItems = await loadSchedule(this.#app);
+    }
+    registerSchedule(scheduleItem) {
+        this.scheduleItems[scheduleItem.key] = scheduleItem;
+    }
+    unregisterSchedule(key) {
+        delete this.scheduleItems[key];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZWR1bGVfd29ya2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2xpYi9zY2hlZHVsZV93b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBR2xELE1BQU0sT0FBTyxjQUFjO0lBQ3pCLElBQUksQ0FBYztJQUNsQixhQUFhLEdBQW9DLEVBQUUsQ0FBQztJQUVwRCxZQUFZLEdBQWdCO1FBQzFCLElBQUksQ0FBQyxJQUFJLEdBQUcsR0FBRyxDQUFDO0lBQ2xCLENBQUM7SUFFRCxLQUFLLENBQUMsSUFBSTtRQUNSLElBQUksQ0FBQyxhQUFhLEdBQUcsTUFBTSxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFFRCxnQkFBZ0IsQ0FBQyxZQUE2QjtRQUM1QyxJQUFJLENBQUMsYUFBYSxDQUFDLFlBQVksQ0FBQyxHQUFHLENBQUMsR0FBRyxZQUFZLENBQUM7SUFDdEQsQ0FBQztJQUVELGtCQUFrQixDQUFDLEdBQVc7UUFDNUIsT0FBTyxJQUFJLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7Q0FDRiJ9

package/dist/esm/lib/strategy/all.d.ts

@@ -0,0 +1,4 @@
+import { TimerStrategy } from './timer.js';
+export declare class AllStrategy extends TimerStrategy {
+    handler(): void;
+}

package/dist/esm/lib/strategy/all.js

@@ -0,0 +1,7 @@
+import { TimerStrategy } from './timer.js';
+export class AllStrategy extends TimerStrategy {
+    handler() {
+        this.sendAll();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWxsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9zdHJhdGVneS9hbGwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFlBQVksQ0FBQztBQUUzQyxNQUFNLE9BQU8sV0FBWSxTQUFRLGFBQWE7SUFDNUMsT0FBTztRQUNMLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUNqQixDQUFDO0NBQ0YifQ==

package/dist/esm/lib/strategy/base.d.ts

@@ -0,0 +1,30 @@
+import type { Agent, EggLogger } from 'egg';
+import type { EggScheduleConfig, EggScheduleJobInfo } from '../types.js';
+export declare class BaseStrategy {
+    protected agent: Agent;
+    protected scheduleConfig: EggScheduleConfig;
+    protected key: string;
+    protected logger: EggLogger;
+    protected closed: boolean;
+    count: number;
+    constructor(scheduleConfig: EggScheduleConfig, agent: Agent, key: string);
+    /** keep compatibility */
+    get schedule(): EggScheduleConfig;
+    start(): void;
+    close(): void;
+    onJobStart(_info: EggScheduleJobInfo): void;
+    onJobFinish(_info: EggScheduleJobInfo): void;
+    /**
+     * trigger one worker
+     *
+     * @param {...any} args - pass to job task
+     */
+    sendOne(...args: any[]): void;
+    /**
+     * trigger all worker
+     *
+     * @param {...any} args - pass to job task
+     */
+    sendAll(...args: any[]): void;
+    getSeqId(): string;
+}

package/dist/esm/lib/strategy/base.js

@@ -0,0 +1,75 @@
+export class BaseStrategy {
+    agent;
+    scheduleConfig;
+    key;
+    logger;
+    closed = false;
+    count = 0;
+    constructor(scheduleConfig, agent, key) {
+        this.agent = agent;
+        this.key = key;
+        this.scheduleConfig = scheduleConfig;
+        this.logger = this.agent.getLogger('scheduleLogger');
+    }
+    /** keep compatibility */
+    get schedule() {
+        return this.scheduleConfig;
+    }
+    start() {
+        // empty loop by default
+    }
+    close() {
+        this.closed = true;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onJobStart(_info) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onJobFinish(_info) { }
+    /**
+     * trigger one worker
+     *
+     * @param {...any} args - pass to job task
+     */
+    sendOne(...args) {
+        /* istanbul ignore next */
+        if (this.agent.schedule.closed) {
+            this.logger.warn(`${this.key} skip due to schedule closed`);
+            return;
+        }
+        this.count++;
+        const info = {
+            key: this.key,
+            id: this.getSeqId(),
+            args,
+        };
+        this.logger.info(`[Job#${info.id}] ${info.key} triggered, send random by agent`);
+        this.agent.messenger.sendRandom('egg-schedule', info);
+        this.onJobStart(info);
+    }
+    /**
+     * trigger all worker
+     *
+     * @param {...any} args - pass to job task
+     */
+    sendAll(...args) {
+        /* istanbul ignore next */
+        if (this.agent.schedule.closed) {
+            this.logger.warn(`${this.key} skip due to schedule closed`);
+            return;
+        }
+        this.count++;
+        const info = {
+            key: this.key,
+            id: this.getSeqId(),
+            args,
+        };
+        this.logger.info(`[Job#${info.id}] ${info.key} triggered, send all by agent`);
+        // send to all workers
+        this.agent.messenger.send('egg-schedule', info);
+        this.onJobStart(info);
+    }
+    getSeqId() {
+        return `${Date.now()}${process.hrtime().join('')}${this.count}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/lib/strategy/timer.d.ts

@@ -0,0 +1,20 @@
+import { type CronExpression } from 'cron-parser';
+import safeTimers from 'safe-timers';
+import type { Agent } from 'egg';
+import type { EggScheduleConfig } from '../types.js';
+import { BaseStrategy } from './base.js';
+export declare abstract class TimerStrategy extends BaseStrategy {
+    #private;
+    protected cronInstance?: CronExpression;
+    constructor(scheduleConfig: EggScheduleConfig, agent: Agent, key: string);
+    protected handler(): void;
+    start(): void;
+    onJobStart(): void;
+    /**
+     * calculate next tick
+     *
+     * @return {Number|undefined} time interval, if out of range then return `undefined`
+     */
+    protected getNextTick(): number | undefined;
+    protected safeTimeout(handler: () => void, delay: number, ...args: any[]): number | safeTimers.Timeout;
+}