@eggjs/schedule 5.0.0

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

@@ -0,0 +1,92 @@
+import assert from 'node:assert';
+import { parseExpression } from 'cron-parser';
+import { ms } from 'humanize-ms';
+import safeTimers from 'safe-timers';
+import { logDate } from 'utility';
+import { BaseStrategy } from './base.js';
+export class TimerStrategy extends BaseStrategy {
+    cronInstance;
+    constructor(scheduleConfig, agent, key) {
+        super(scheduleConfig, agent, key);
+        const { interval, cron, cronOptions, immediate } = this.scheduleConfig;
+        assert(interval || cron || immediate, `[@eggjs/schedule] ${this.key} \`schedule.interval\` or \`schedule.cron\` or \`schedule.immediate\` must be present`);
+        // init cron parser
+        if (cron) {
+            try {
+                this.cronInstance = parseExpression(cron, cronOptions);
+            }
+            catch (err) {
+                throw new TypeError(`[@eggjs/schedule] ${this.key} parse cron instruction(${cron}) error: ${err.message}`, { cause: err });
+            }
+        }
+    }
+    handler() {
+        throw new TypeError(`[@eggjs/schedule] ${this.key} strategy should override \`handler()\` method`);
+    }
+    start() {
+        /* istanbul ignore next */
+        if (this.agent.schedule.closed)
+            return;
+        if (this.scheduleConfig.immediate) {
+            this.logger.info(`[Timer] ${this.key} next time will execute immediate`);
+            setImmediate(() => this.handler());
+        }
+        else {
+            this.#scheduleNext();
+        }
+    }
+    #scheduleNext() {
+        /* istanbul ignore next */
+        if (this.agent.schedule.closed)
+            return;
+        // get next tick
+        const nextTick = this.getNextTick();
+        if (nextTick) {
+            this.logger.info(`[Timer] ${this.key} next time will execute after ${nextTick}ms at ${logDate(new Date(Date.now() + nextTick))}`);
+            this.safeTimeout(() => this.handler(), nextTick);
+        }
+        else {
+            this.logger.info(`[Timer] ${this.key} reach endDate, will stop`);
+        }
+    }
+    onJobStart() {
+        // Next execution will trigger task at a fix rate, regardless of its execution time.
+        this.#scheduleNext();
+    }
+    /**
+     * calculate next tick
+     *
+     * @return {Number|undefined} time interval, if out of range then return `undefined`
+     */
+    getNextTick() {
+        // interval-style
+        if (this.scheduleConfig.interval) {
+            return ms(this.scheduleConfig.interval);
+        }
+        // cron-style
+        if (this.cronInstance) {
+            // calculate next cron tick
+            const now = Date.now();
+            let nextTick;
+            // loop to find next feature time
+            do {
+                try {
+                    const nextInterval = this.cronInstance.next();
+                    nextTick = nextInterval.getTime();
+                }
+                catch (err) {
+                    // Error: Out of the timespan range
+                    this.logger.info(`[Timer] ${this.key} cron out of the timespan range, error: %s`, err);
+                    return;
+                }
+            } while (now >= nextTick);
+            return nextTick - now;
+        }
+        // won\'t run here
+    }
+    safeTimeout(handler, delay, ...args) {
+        const fn = delay < safeTimers.maxInterval ? setTimeout : safeTimers.setTimeout;
+        return fn(handler, delay, ...args);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

@@ -0,0 +1,53 @@
+import type { ParserOptions as CronOptions } from 'cron-parser';
+import type { Schedule } from './schedule.js';
+import type { ScheduleWorker } from './schedule_worker.js';
+/**
+ * Schedule Config
+ * @see https://www.eggjs.org/zh-CN/basics/schedule
+ */
+export interface EggScheduleConfig {
+    type?: 'worker' | 'all';
+    interval?: string | number;
+    cron?: string;
+    cronOptions?: CronOptions;
+    immediate?: boolean;
+    disable?: boolean;
+    env?: string[];
+}
+export type EggScheduleTask = (ctx: any, ...args: any[]) => Promise<void>;
+export interface EggScheduleItem {
+    schedule: EggScheduleConfig;
+    scheduleQueryString: string;
+    task: EggScheduleTask;
+    key: string;
+}
+export interface EggScheduleJobInfo {
+    id: string;
+    key: string;
+    workerId: number;
+    args: any[];
+    success?: boolean;
+    message?: string;
+    rt?: number;
+}
+declare module 'egg' {
+    interface EggScheduleAgent {
+        schedule: Schedule;
+    }
+    interface Agent extends EggScheduleAgent {
+    }
+    interface EggScheduleApplication {
+        scheduleWorker: ScheduleWorker;
+        /** runSchedule in unittest */
+        runSchedule: (schedulePath: string, ...args: any[]) => Promise<void>;
+    }
+    interface Application extends EggScheduleApplication {
+    }
+    interface EggScheduleAppConfig {
+        schedule: {
+            directory: string[];
+        };
+    }
+    interface EggAppConfig extends EggScheduleAppConfig {
+    }
+}

package/dist/esm/lib/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "@eggjs/schedule",
+  "version": "5.0.0"
+}

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "@eggjs/schedule",
+  "version": "5.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18.19.0"
+  },
+  "description": "schedule plugin for egg, support corn job.",
+  "eggPlugin": {
+    "name": "schedule",
+    "exports": {
+      "import": "./dist/esm",
+      "require": "./dist/commonjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:eggjs/egg-schedule.git"
+  },
+  "keywords": [
+    "egg",
+    "egg-plugin",
+    "eggPlugin",
+    "schedule",
+    "cron"
+  ],
+  "dependencies": {
+    "@eggjs/utils": "^4.0.3",
+    "cron-parser": "^4.9.0",
+    "humanize-ms": "^2.0.0",
+    "is-type-of": "^2.1.0",
+    "safe-timers": "^1.1.0",
+    "utility": "^2.1.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.1",
+    "@eggjs/tsconfig": "1",
+    "@types/mocha": "10",
+    "@types/node": "22",
+    "@types/safe-timers": "^1.1.2",
+    "egg": "beta",
+    "egg-bin": "beta",
+    "egg-logrotator": "^3.2.0",
+    "egg-mock": "beta",
+    "egg-tracer": "2",
+    "eslint": "8",
+    "eslint-config-egg": "14",
+    "tshy": "3",
+    "tshy-after": "1",
+    "typescript": "5"
+  },
+  "scripts": {
+    "lint": "eslint --cache src test --ext .ts",
+    "pretest": "npm run lint -- --fix && npm run prepublishOnly",
+    "test": "egg-bin test",
+    "preci": "npm run lint && npm run prepublishOnly && attw --pack",
+    "ci": "egg-bin cov",
+    "prepublishOnly": "tshy && tshy-after"
+  },
+  "author": "dead_horse",
+  "license": "MIT",
+  "type": "module",
+  "tshy": {
+    "exports": {
+      ".": "./src/index.ts",
+      "./package.json": "./package.json"
+    }
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/commonjs/index.d.ts",
+        "default": "./dist/commonjs/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "types": "./dist/commonjs/index.d.ts",
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js"
+}

package/src/agent.ts

@@ -0,0 +1,36 @@
+import { debuglog } from 'node:util';
+import type { Agent, ILifecycleBoot } from 'egg';
+import { WorkerStrategy } from './lib/strategy/worker.js';
+import { AllStrategy } from './lib/strategy/all.js';
+import { EggScheduleJobInfo } from './lib/types.js';
+
+const debug = debuglog('@eggjs/schedule/agent');
+
+export default class Boot implements ILifecycleBoot {
+  #agent: Agent;
+  constructor(agent: Agent) {
+    this.#agent = agent;
+  }
+
+  async didLoad(): Promise<void> {
+    // register built-in strategy
+    this.#agent.schedule.use('worker', WorkerStrategy);
+    this.#agent.schedule.use('all', AllStrategy);
+
+    // wait for other plugin to register custom strategy
+    await this.#agent.schedule.init();
+
+    // dispatch job finish event to strategy
+    this.#agent.messenger.on('egg-schedule', (info: EggScheduleJobInfo) => {
+      // get job info from worker
+      this.#agent.schedule.onJobFinish(info);
+    });
+    debug('didLoad');
+  }
+
+  async serverDidReady(): Promise<void> {
+    // start schedule after worker ready
+    this.#agent.schedule.start();
+    debug('serverDidReady, schedule start');
+  }
+}

package/src/app/extend/agent.ts

@@ -0,0 +1,30 @@
+import { BaseStrategy } from '../../lib/strategy/base.js';
+import { TimerStrategy } from '../../lib/strategy/timer.js';
+import { Schedule } from '../../lib/schedule.js';
+
+const SCHEDULE = Symbol('agent#schedule');
+
+export default {
+  /**
+   * @member agent#ScheduleStrategy
+   */
+  ScheduleStrategy: BaseStrategy,
+
+  /**
+   * @member agent#TimerScheduleStrategy
+   */
+  TimerScheduleStrategy: TimerStrategy,
+
+  /**
+   * @member agent#schedule
+   */
+  get schedule() {
+    if (!this[SCHEDULE]) {
+      this[SCHEDULE] = new Schedule(this);
+      this.lifecycle.registerBeforeClose(() => {
+        return this[SCHEDULE].close();
+      });
+    }
+    return this[SCHEDULE];
+  },
+} as any;

package/src/app/extend/application.ts

@@ -0,0 +1,16 @@
+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];
+  },
+} as any;
+

package/src/app.ts

@@ -0,0 +1,142 @@
+import { debuglog } from 'node:util';
+import path from 'node:path';
+import type {
+  Application, ILifecycleBoot, EggLogger,
+} from 'egg';
+import { importResolve } from '@eggjs/utils';
+import { EggScheduleItem, EggScheduleJobInfo } from './lib/types.js';
+
+const debug = debuglog('@eggjs/schedule/app');
+
+export default class Boot implements ILifecycleBoot {
+  #app: Application;
+  #logger: EggLogger;
+  constructor(app: Application) {
+    this.#app = app;
+    this.#logger = app.getLogger('scheduleLogger');
+  }
+
+  async didLoad(): Promise<void> {
+    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: boolean;
+      let e: Error | undefined;
+      try {
+        // execute
+        await this.#app.ctxStorage.run(ctx, async () => {
+          return await schedule.task(ctx, ...info.args);
+        });
+        success = true;
+      } catch (err: any) {
+        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,
+      } as EggScheduleJobInfo);
+    });
+
+    // for test purpose
+    const config = this.#app.config;
+    const directory = [
+      path.join(config.baseDir, 'app/schedule'),
+      ...config.schedule.directory,
+    ];
+    const runSchedule = async (schedulePath: string, ...args: any[]) => {
+      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: EggScheduleItem;
+      try {
+        schedule = scheduleWorker.scheduleItems[schedulePath];
+        if (!schedule) {
+          throw new Error(`Cannot find schedule ${schedulePath}`);
+        }
+      } catch (err: any) {
+        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');
+  }
+}

package/src/config/config.default.ts

@@ -0,0 +1,17 @@
+export default () => {
+  const config = {} as Record<string, any>;
+
+  config.customLogger = {
+    scheduleLogger: {
+      consoleLevel: 'NONE',
+      file: 'egg-schedule.log',
+    },
+  };
+
+  config.schedule = {
+    // custom additional directory, full path
+    directory: [],
+  };
+
+  return config;
+};

package/src/index.ts

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

package/src/lib/load_schedule.ts

@@ -0,0 +1,74 @@
+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';
+import type { EggApplicationCore, EggContext } from 'egg';
+import type { EggScheduleConfig, EggScheduleTask, EggScheduleItem } from './types.js';
+
+function getScheduleLoader(app: EggApplicationCore) {
+  return class ScheduleLoader extends app.loader.FileLoader {
+    async load() {
+      const target = this.options.target as Record<string, EggScheduleItem>;
+      const items = await this.parse();
+      for (const item of items) {
+        const schedule = item.exports as { schedule: EggScheduleConfig, task: EggScheduleTask };
+        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: EggScheduleTask;
+        if (isClass(schedule)) {
+          assert(!isGeneratorFunction(schedule.prototype.subscribe),
+            `schedule(${fullpath}): "schedule" generator function is not support, should use async function instead`);
+          task = async (ctx: EggContext, ...args: any[]) => {
+            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 as any),
+          task,
+          key: realFullpath,
+        };
+      }
+      return target;
+    }
+  };
+}
+
+export async function loadSchedule(app: EggApplicationCore) {
+  const dirs = [
+    ...app.loader.getLoadUnits().map(unit => path.join(unit.path, 'app/schedule')),
+    ...app.config.schedule.directory,
+  ];
+
+  const Loader = getScheduleLoader(app);
+  const schedules = {} as Record<string, EggScheduleItem>;
+  await new Loader({
+    directory: dirs,
+    target: schedules,
+    inject: app,
+  }).load();
+  Reflect.set(app, 'schedules', schedules);
+  return schedules;
+}