@eggjs/schedule 6.0.0-beta.19 → 6.0.0-beta.20

package/dist/lib/schedule.d.ts

@@ -1,35 +1,4 @@
-import { EggScheduleItem, EggScheduleJobInfo } from "./types.js";
-import { BaseStrategy } from "./strategy/base.js";
-import ScheduleAgent from "../app/extend/agent.js";
-
-//#region src/lib/schedule.d.ts
-declare class Schedule {
-  #private;
-  closed: boolean;
-  constructor(agent: ScheduleAgent);
-  /**
-   * 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
+import "../config.default-Oe7rctMS.js";
+import "../types-D3XkzB3g.js";
+import { Schedule } from "../agent-DUNNeo72.js";
 export { Schedule };

package/dist/lib/schedule.js

@@ -1,77 +1,4 @@
-import { loadSchedule } from "./load_schedule.js";
-import { debuglog } from "node:util";
+import "../load_schedule-BwGbsGkz.js";
+import { Schedule } from "../schedule-C0pZBoiR.js";
 
-//#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

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

package/dist/lib/schedule_worker.js

@@ -1,22 +1,4 @@
-import { loadSchedule } from "./load_schedule.js";
+import "../load_schedule-BwGbsGkz.js";
+import { ScheduleWorker } from "../schedule_worker-DsbRF__K.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

@@ -1,4 +1,6 @@
-import { TimerStrategy } from "./timer.js";
+import "../../config.default-Oe7rctMS.js";
+import "../../types-D3XkzB3g.js";
+import { TimerStrategy } from "../../agent-DUNNeo72.js";
 
 //#region src/lib/strategy/all.d.ts
 declare class AllStrategy extends TimerStrategy {

package/dist/lib/strategy/all.js

@@ -1,11 +1,5 @@
-import { TimerStrategy } from "./timer.js";
+import "../../base-BQ53Qv2t.js";
+import "../../timer-B-5D2wim.js";
+import { AllStrategy } from "../../all-DY7LEzzF.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

@@ -1,36 +1,4 @@
-import { EggScheduleConfig } from "../../config/config.default.js";
-import { EggScheduleJobInfo } from "../types.js";
-import ScheduleAgent from "../../app/extend/agent.js";
-import { EggLogger } from "egg";
-
-//#region src/lib/strategy/base.d.ts
-declare class BaseStrategy {
-  protected agent: ScheduleAgent;
-  protected scheduleConfig: EggScheduleConfig;
-  protected key: string;
-  protected logger: EggLogger;
-  protected closed: boolean;
-  count: number;
-  constructor(scheduleConfig: EggScheduleConfig, agent: ScheduleAgent, 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
+import "../../config.default-Oe7rctMS.js";
+import "../../types-D3XkzB3g.js";
+import { BaseStrategy } from "../../agent-DUNNeo72.js";
 export { BaseStrategy };

package/dist/lib/strategy/base.js

@@ -1,73 +1,3 @@
-//#region src/lib/strategy/base.ts
-var BaseStrategy = class {
-	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;
-	}
-	async start() {}
-	async close() {
-		this.closed = true;
-	}
-	onJobStart(_info) {}
-	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`);
-		this.agent.messenger.send("egg-schedule", info);
-		this.onJobStart(info);
-	}
-	getSeqId() {
-		return `${Date.now()}${process.hrtime().join("")}${this.count}`;
-	}
-};
+import { BaseStrategy } from "../../base-BQ53Qv2t.js";
 
-//#endregion
 export { BaseStrategy };

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

@@ -1,24 +1,4 @@
-import { EggScheduleConfig } from "../../config/config.default.js";
-import { BaseStrategy } from "./base.js";
-import ScheduleAgent from "../../app/extend/agent.js";
-import { CronExpression } from "cron-parser";
-import safeTimers from "safe-timers";
-
-//#region src/lib/strategy/timer.d.ts
-declare abstract class TimerStrategy extends BaseStrategy {
-  #private;
-  protected cronInstance?: CronExpression;
-  constructor(scheduleConfig: EggScheduleConfig, agent: ScheduleAgent, key: string);
-  protected handler(): void;
-  start(): Promise<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;
-}
-//#endregion
+import "../../config.default-Oe7rctMS.js";
+import "../../types-D3XkzB3g.js";
+import { TimerStrategy } from "../../agent-DUNNeo72.js";
 export { TimerStrategy };

package/dist/lib/strategy/timer.js

@@ -1,71 +1,4 @@
-import { BaseStrategy } from "./base.js";
-import assert from "node:assert";
-import cronParser from "cron-parser";
-import { ms } from "humanize-ms";
-import safeTimers from "safe-timers";
-import { logDate } from "utility";
+import "../../base-BQ53Qv2t.js";
+import { TimerStrategy } from "../../timer-B-5D2wim.js";
 
-//#region src/lib/strategy/timer.ts
-var TimerStrategy = class 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`);
-		if (cron) try {
-			this.cronInstance = cronParser.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`);
-	}
-	async 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;
-		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() {
-		this.#scheduleNext();
-	}
-	/**
-	* calculate next tick
-	*
-	* @return {Number|undefined} time interval, if out of range then return `undefined`
-	*/
-	getNextTick() {
-		if (this.scheduleConfig.interval) return ms(this.scheduleConfig.interval);
-		if (this.cronInstance) {
-			const now = Date.now();
-			let nextTick;
-			do
-				try {
-					nextTick = this.cronInstance.next().getTime();
-				} catch (err) {
-					this.logger.info(`[Timer] ${this.key} cron out of the timespan range, error: %s`, err);
-					return;
-				}
-			while (now >= nextTick);
-			return nextTick - now;
-		}
-	}
-	safeTimeout(handler, delay, ...args) {
-		return (delay < safeTimers.maxInterval ? setTimeout : safeTimers.setTimeout)(handler, delay, ...args);
-	}
-};
-
-//#endregion
 export { TimerStrategy };

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

@@ -1,4 +1,6 @@
-import { TimerStrategy } from "./timer.js";
+import "../../config.default-Oe7rctMS.js";
+import "../../types-D3XkzB3g.js";
+import { TimerStrategy } from "../../agent-DUNNeo72.js";
 
 //#region src/lib/strategy/worker.d.ts
 declare class WorkerStrategy extends TimerStrategy {

package/dist/lib/strategy/worker.js

@@ -1,11 +1,5 @@
-import { TimerStrategy } from "./timer.js";
+import "../../base-BQ53Qv2t.js";
+import "../../timer-B-5D2wim.js";
+import { WorkerStrategy } from "../../worker-Dc570kZo.js";
 
-//#region src/lib/strategy/worker.ts
-var WorkerStrategy = class extends TimerStrategy {
-	handler() {
-		this.sendOne();
-	}
-};
-
-//#endregion
 export { WorkerStrategy };

package/dist/lib/types.d.ts

@@ -1,21 +1,3 @@
-import { EggScheduleConfig } from "../config/config.default.js";
-
-//#region src/lib/types.d.ts
-type EggScheduleTask = (ctx: any, ...args: any[]) => Promise<void>;
-interface EggScheduleItem {
-  schedule: EggScheduleConfig;
-  scheduleQueryString: string;
-  task: EggScheduleTask;
-  key: string;
-}
-interface EggScheduleJobInfo {
-  id: string;
-  key: string;
-  workerId: number;
-  args: any[];
-  success?: boolean;
-  message?: string;
-  rt?: number;
-}
-//#endregion
+import "../config.default-Oe7rctMS.js";
+import { EggScheduleItem, EggScheduleJobInfo, EggScheduleTask } from "../types-D3XkzB3g.js";
 export { EggScheduleItem, EggScheduleJobInfo, EggScheduleTask };

package/dist/lib/types.js

@@ -1 +1,3 @@
+import "../types-C43iyhAd.js";
+
 export {  };

package/dist/load_schedule-BwGbsGkz.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/schedule-C0pZBoiR.js

@@ -0,0 +1,77 @@
+import { loadSchedule } from "./load_schedule-BwGbsGkz.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/schedule_worker-DsbRF__K.js

@@ -0,0 +1,22 @@
+import { loadSchedule } from "./load_schedule-BwGbsGkz.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 };