@eggjs/schedule 5.0.2 → 6.0.0-beta.13

package/README.md

@@ -1,16 +1,12 @@
 # @eggjs/schedule
 
 [![NPM version][npm-image]][npm-url]
-[![Node.js CI](https://github.com/eggjs/schedule/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/schedule/actions/workflows/nodejs.yml)
-[![Test coverage][codecov-image]][codecov-url]
 [![Known Vulnerabilities][snyk-image]][snyk-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version](https://img.shields.io/node/v/@eggjs/schedule.svg?style=flat)](https://nodejs.org/en/download/)
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/schedule.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/schedule
-[codecov-image]: https://codecov.io/github/eggjs/schedule/coverage.svg?branch=master
-[codecov-url]: https://codecov.io/github/eggjs/schedule?branch=master
 [snyk-image]: https://snyk.io/test/npm/@eggjs/schedule/badge.svg?style=flat-square
 [snyk-url]: https://snyk.io/test/npm/@eggjs/schedule
 [download-image]: https://img.shields.io/npm/dm/@eggjs/schedule.svg?style=flat-square
@@ -64,7 +60,7 @@ export const schedule = {
   cron: '0 0 3 * * *',
   // interval: '1h',
   // immediate: true,
-}
+};
 
 export async function task(ctx: EggContext) {
   await ctx.service.db.cleandb();
@@ -197,7 +193,7 @@ export default (agent: Agent) => {
   }
 
   agent.schedule.use('custom', CustomStrategy);
-}
+};
 ```
 
 Then you could use it to defined your job:
@@ -235,7 +231,7 @@ export default (app: Application) => {
         // only start task when hostname match
         disable: require('os').hostname() !== app.config.sync.hostname,
         // only start task at prod mode
-        env: [ 'prod' ],
+        env: ['prod'],
       };
     }
 
@@ -245,7 +241,7 @@ export default (app: Application) => {
   }
 
   return SyncTask;
-}
+};
 ```
 
 ## Configuration
@@ -278,9 +274,7 @@ import { EggAppConfig } from 'egg';
 
 export default {
   schedule: {
-    directory: [
-      'path/to/otherSchedule',
-    ],
+    directory: ['path/to/otherSchedule'],
   },
 } as Partial<EggAppConfig>;
 ```
@@ -308,6 +302,6 @@ Please open an issue [here](https://github.com/eggjs/egg/issues).
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/schedule)](https://github.com/eggjs/schedule/graphs/contributors)
+[![Contributors](https://contrib.rocks/image?repo=eggjs/egg)](https://github.com/eggjs/egg/graphs/contributors)
 
 Made with [contributors-img](https://contrib.rocks).

package/dist/agent.d.ts

@@ -0,0 +1,13 @@
+import Agent$1 from "./app/extend/agent.js";
+import { ILifecycleBoot } from "egg";
+
+//#region src/agent.d.ts
+declare class Boot implements ILifecycleBoot {
+  #private;
+  constructor(agent: Agent$1);
+  configDidLoad(): Promise<void>;
+  serverDidReady(): Promise<void>;
+  beforeClose(): Promise<void>;
+}
+//#endregion
+export { Boot as default };

package/dist/agent.js

@@ -0,0 +1,32 @@
+import { WorkerStrategy } from "./lib/strategy/worker.js";
+import { AllStrategy } from "./lib/strategy/all.js";
+import { debuglog } from "node:util";
+
+//#region src/agent.ts
+const debug = debuglog("egg/schedule/agent");
+var Boot = class {
+	#agent;
+	constructor(agent) {
+		this.#agent = agent;
+	}
+	async configDidLoad() {
+		this.#agent.schedule.use("worker", WorkerStrategy);
+		this.#agent.schedule.use("all", AllStrategy);
+		await this.#agent.schedule.init();
+		this.#agent.messenger.on("egg-schedule", (info) => {
+			this.#agent.schedule.onJobFinish(info);
+		});
+		debug("configDidLoad");
+	}
+	async serverDidReady() {
+		await this.#agent.schedule.start();
+		debug("serverDidReady, schedule start");
+	}
+	async beforeClose() {
+		await this.#agent.schedule.close();
+		debug("beforeClose, schedule close");
+	}
+};
+
+//#endregion
+export { Boot as default };

package/dist/app/extend/agent.d.ts

@@ -0,0 +1,22 @@
+import { BaseStrategy } from "../../lib/strategy/base.js";
+import { TimerStrategy } from "../../lib/strategy/timer.js";
+import { Schedule } from "../../lib/schedule.js";
+import { Agent as Agent$1 } from "egg";
+
+//#region src/app/extend/agent.d.ts
+declare class Agent extends Agent$1 {
+  /**
+   * @member agent#ScheduleStrategy
+   */
+  get ScheduleStrategy(): typeof BaseStrategy;
+  /**
+   * @member agent#TimerScheduleStrategy
+   */
+  get TimerScheduleStrategy(): typeof TimerStrategy;
+  /**
+   * @member agent#schedule
+   */
+  get schedule(): Schedule;
+}
+//#endregion
+export { Agent as default };

package/dist/app/extend/agent.js

@@ -0,0 +1,32 @@
+import { BaseStrategy } from "../../lib/strategy/base.js";
+import { TimerStrategy } from "../../lib/strategy/timer.js";
+import { Schedule } from "../../lib/schedule.js";
+import { Agent as Agent$1 } from "egg";
+
+//#region src/app/extend/agent.ts
+const SCHEDULE = Symbol("agent schedule");
+var Agent = class extends Agent$1 {
+	/**
+	* @member agent#ScheduleStrategy
+	*/
+	get ScheduleStrategy() {
+		return BaseStrategy;
+	}
+	/**
+	* @member agent#TimerScheduleStrategy
+	*/
+	get TimerScheduleStrategy() {
+		return TimerStrategy;
+	}
+	/**
+	* @member agent#schedule
+	*/
+	get schedule() {
+		let schedule = this[SCHEDULE];
+		if (!schedule) this[SCHEDULE] = schedule = new Schedule(this);
+		return schedule;
+	}
+};
+
+//#endregion
+export { Agent as default };

package/dist/app/extend/application.d.ts

@@ -0,0 +1,16 @@
+import { ScheduleWorker } from "../../lib/schedule_worker.js";
+import { Application as Application$1 } from "egg";
+
+//#region src/app/extend/application.d.ts
+declare class Application extends Application$1 {
+  /**
+   * @member app#schedule
+   */
+  get scheduleWorker(): ScheduleWorker;
+  /**
+   * For unittest only - run a specific schedule task
+   */
+  runSchedule?(schedulePath: string, ...args: any[]): Promise<any>;
+}
+//#endregion
+export { Application as default };

package/dist/app/extend/application.js

@@ -0,0 +1,18 @@
+import { ScheduleWorker } from "../../lib/schedule_worker.js";
+import { Application as Application$1 } from "egg";
+
+//#region src/app/extend/application.ts
+const SCHEDULE_WORKER = Symbol("application scheduleWorker");
+var Application = class extends Application$1 {
+	/**
+	* @member app#schedule
+	*/
+	get scheduleWorker() {
+		let scheduleWorker = this[SCHEDULE_WORKER];
+		if (!scheduleWorker) this[SCHEDULE_WORKER] = scheduleWorker = new ScheduleWorker(this);
+		return scheduleWorker;
+	}
+};
+
+//#endregion
+export { Application as default };

package/dist/app/extend/application.unittest.d.ts

@@ -0,0 +1,13 @@
+import Application from "./application.js";
+
+//#region src/app/extend/application.unittest.d.ts
+declare class ApplicationUnittest extends Application {
+  runSchedule(schedulePath: string, ...args: any[]): Promise<void>;
+}
+declare module '@eggjs/mock' {
+  interface MockApplication {
+    runSchedule(schedulePath: string, ...args: any[]): Promise<any>;
+  }
+}
+//#endregion
+export { ApplicationUnittest as default };

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

@@ -0,0 +1,43 @@
+import Application from "./application.js";
+import { debuglog } from "node:util";
+import path from "node:path";
+import { importResolve } from "@eggjs/utils";
+
+//#region src/app/extend/application.unittest.ts
+const debug = debuglog("egg/schedule/app");
+var ApplicationUnittest = class extends Application {
+	async runSchedule(schedulePath, ...args) {
+		debug("[runSchedule] start schedulePath: %o, args: %o", schedulePath, args);
+		const config = this.config;
+		const directory = [path.join(config.baseDir, "app/schedule"), ...config.schedule.directory];
+		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 = this.scheduleWorker.scheduleItems[schedulePath];
+			if (!schedule) throw new TypeError(`Cannot find schedule ${schedulePath}`);
+		} catch (err) {
+			err.message = `[@eggjs/schedule] ${err.message}`;
+			throw err;
+		}
+		const ctx = this.createAnonymousContext({
+			method: "SCHEDULE",
+			url: `/__schedule?path=${schedulePath}&${schedule.scheduleQueryString}`
+		});
+		return await this.ctxStorage.run(ctx, async () => {
+			return await schedule.task(ctx, ...args);
+		});
+	}
+};
+
+//#endregion
+export { ApplicationUnittest as default };

package/dist/app.d.ts

@@ -0,0 +1,11 @@
+import Application$1 from "./app/extend/application.js";
+import { ILifecycleBoot } from "egg";
+
+//#region src/app.d.ts
+declare class Boot implements ILifecycleBoot {
+  #private;
+  constructor(app: Application$1);
+  configDidLoad(): Promise<void>;
+}
+//#endregion
+export { Boot as default };

package/dist/app.js

@@ -0,0 +1,69 @@
+import { debuglog } from "node:util";
+
+//#region src/app.ts
+const debug = debuglog("egg/schedule/app");
+var Boot = class {
+	#app;
+	#logger;
+	constructor(app) {
+		this.#app = app;
+		this.#logger = app.getLogger("scheduleLogger");
+	}
+	async configDidLoad() {
+		const scheduleWorker = this.#app.scheduleWorker;
+		await scheduleWorker.init();
+		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);
+		}
+		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`);
+			const ctx = this.#app.createAnonymousContext({
+				method: "SCHEDULE",
+				url: `/__schedule?path=${key}&${schedule.scheduleQueryString}`
+			});
+			const start = Date.now();
+			let success;
+			let e;
+			try {
+				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);
+			this.#app.messenger.sendToAgent("egg-schedule", {
+				...info,
+				success,
+				workerId: process.pid,
+				rt,
+				message: e?.message
+			});
+		});
+		debug("configDidLoad");
+	}
+};
+
+//#endregion
+export { Boot as default };

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

@@ -0,0 +1,6 @@
+import { PartialEggConfig } from "egg";
+
+//#region src/config/config.default.d.ts
+declare const _default: PartialEggConfig;
+//#endregion
+export { _default as default };

package/dist/config/config.default.js

@@ -0,0 +1,13 @@
+import "egg";
+
+//#region src/config/config.default.ts
+var config_default_default = {
+	customLogger: { scheduleLogger: {
+		consoleLevel: "NONE",
+		file: "egg-schedule.log"
+	} },
+	schedule: { directory: [] }
+};
+
+//#endregion
+export { config_default_default as default };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { EggScheduleConfig, EggScheduleItem, EggScheduleJobInfo, EggScheduleTask } from "./lib/types.js";
+import { Schedule } from "./lib/schedule.js";
+import Agent from "./app/extend/agent.js";
+import { ScheduleWorker } from "./lib/schedule_worker.js";
+import Application from "./app/extend/application.js";
+import ApplicationUnittest from "./app/extend/application.unittest.js";
+export { Agent, Application, ApplicationUnittest, EggScheduleConfig, EggScheduleItem, EggScheduleJobInfo, EggScheduleTask, Schedule, ScheduleWorker };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { Schedule } from "./lib/schedule.js";
+import Agent from "./app/extend/agent.js";
+import { ScheduleWorker } from "./lib/schedule_worker.js";
+import Application from "./app/extend/application.js";
+import ApplicationUnittest from "./app/extend/application.unittest.js";
+
+export { Agent, Application, ApplicationUnittest, Schedule, ScheduleWorker };

package/dist/lib/load_schedule.d.ts

@@ -0,0 +1,7 @@
+import { EggScheduleItem } from "./types.js";
+import { EggApplicationCore } from "egg";
+
+//#region src/lib/load_schedule.d.ts
+declare function loadSchedule(app: EggApplicationCore): Promise<Record<string, EggScheduleItem>>;
+//#endregion
+export { loadSchedule };

package/dist/lib/load_schedule.js

@@ -0,0 +1,61 @@
+import assert from "node:assert";
+import path from "node:path";
+import { stringify } from "node:querystring";
+import { isClass, isFunction, isGeneratorFunction } from "is-type-of";
+import { importResolve } from "@eggjs/utils";
+
+//#region src/lib/load_schedule.ts
+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) => {
+						return new schedule(ctx).subscribe(...args);
+					};
+				} else {
+					assert(!isGeneratorFunction(schedule.task), `schedule(${fullpath}): "task" generator function is not support, should use async function instead`);
+					task = 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;
+				}
+				const realFullpath = importResolve(fullpath);
+				target[realFullpath] = {
+					schedule: scheduleConfig,
+					scheduleQueryString: stringify(scheduleConfig),
+					task,
+					key: realFullpath
+				};
+			}
+			return target;
+		}
+	};
+}
+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;
+}
+
+//#endregion
+export { loadSchedule };

package/dist/lib/schedule.d.ts

@@ -0,0 +1,35 @@
+import { EggScheduleItem, EggScheduleJobInfo } from "./types.js";
+import { BaseStrategy } from "./strategy/base.js";
+import Agent from "../app/extend/agent.js";
+
+//#region src/lib/schedule.d.ts
+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 special 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(): Promise<void>;
+  close(): Promise<void>;
+}
+//#endregion
+export { Schedule };

package/dist/lib/schedule.js

@@ -0,0 +1,77 @@
+import { loadSchedule } from "./load_schedule.js";
+import { debuglog } from "node:util";
+
+//#region src/lib/schedule.ts
+const debug = debuglog("egg/schedule/lib/schedule");
+var Schedule = class {
+	closed = false;
+	#agent;
+	#logger;
+	#strategyClassMap = /* @__PURE__ */ new Map();
+	#strategyInstanceMap = /* @__PURE__ */ 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 special 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;
+		const Strategy = this.#strategyClassMap.get(type);
+		if (!Strategy) {
+			const err = /* @__PURE__ */ new Error(`schedule type [${type}] is not defined`);
+			err.name = "EggScheduleError";
+			throw err;
+		}
+		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
+	*/
+	async start() {
+		debug("start");
+		this.closed = false;
+		for (const instance of this.#strategyInstanceMap.values()) instance.start();
+	}
+	async close() {
+		this.closed = true;
+		for (const instance of this.#strategyInstanceMap.values()) await instance.close();
+		debug("close");
+	}
+};
+
+//#endregion
+export { Schedule };

package/dist/lib/schedule_worker.d.ts

@@ -0,0 +1,14 @@
+import { EggScheduleItem } from "./types.js";
+import Application from "../app/extend/application.js";
+
+//#region src/lib/schedule_worker.d.ts
+declare class ScheduleWorker {
+  #private;
+  scheduleItems: Record<string, EggScheduleItem>;
+  constructor(app: Application);
+  init(): Promise<void>;
+  registerSchedule(scheduleItem: EggScheduleItem): void;
+  unregisterSchedule(key: string): void;
+}
+//#endregion
+export { ScheduleWorker };

package/dist/lib/schedule_worker.js

@@ -0,0 +1,22 @@
+import { loadSchedule } from "./load_schedule.js";
+
+//#region src/lib/schedule_worker.ts
+var ScheduleWorker = class {
+	#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];
+	}
+};
+
+//#endregion
+export { ScheduleWorker };

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

@@ -0,0 +1,8 @@
+import { TimerStrategy } from "./timer.js";
+
+//#region src/lib/strategy/all.d.ts
+declare class AllStrategy extends TimerStrategy {
+  handler(): void;
+}
+//#endregion
+export { AllStrategy };

package/dist/lib/strategy/all.js

@@ -0,0 +1,11 @@
+import { TimerStrategy } from "./timer.js";
+
+//#region src/lib/strategy/all.ts
+var AllStrategy = class extends TimerStrategy {
+	handler() {
+		this.sendAll();
+	}
+};
+
+//#endregion
+export { AllStrategy };

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

@@ -0,0 +1,35 @@
+import { EggScheduleConfig, EggScheduleJobInfo } from "../types.js";
+import Agent$1 from "../../app/extend/agent.js";
+import { EggLogger } from "egg";
+
+//#region src/lib/strategy/base.d.ts
+declare class BaseStrategy {
+  protected agent: Agent$1;
+  protected scheduleConfig: EggScheduleConfig;
+  protected key: string;
+  protected logger: EggLogger;
+  protected closed: boolean;
+  count: number;
+  constructor(scheduleConfig: EggScheduleConfig, agent: Agent$1, key: string);
+  /** keep compatibility */
+  get schedule(): EggScheduleConfig;
+  start(): Promise<void>;
+  close(): Promise<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;
+}
+//#endregion
+export { BaseStrategy };