@fraqjs/fraq 0.6.3 → 0.7.0

package/dist/index.d.mts

@@ -5679,6 +5679,7 @@ declare class Context {
   private readonly services;
   private readonly subContexts;
   private readonly parentEventForwarder?;
+  private readonly timers;
   private readonly initialReconnectDelayMs;
   private readonly maxReconnectDelayMs;
   private readonly logHandler?;
@@ -5700,16 +5701,23 @@ declare class Context {
   tryResolve<T extends object>(service: ServiceClass<T>): T | undefined;
   isProvided<T extends object>(service: ServiceClass<T>): boolean;
   fork(name: string, filter?: Filter): Context;
+  timeout(delayMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
+  interval(intervalMs: number, callback: () => void | Promise<void>): NodeJS.Timeout;
   createSession(message: IncomingMessage): Session;
   start(): Promise<void>;
   stop(): Promise<void>;
   private startInternal;
   private getState;
   private stopInternal;
+  private assertCanScheduleTimer;
+  private runTimerCallback;
+  private clearTimers;
   private stopEventStream;
   private acceptsParentEvent;
   private applyPlugins;
+  private recursiveApplyPlugins;
   private startPlugins;
+  private recursiveStartPlugins;
   private sortPlugins;
   private collectPendingProvidedServices;
   private areRequiredServicesAvailable;

package/dist/index.mjs

@@ -382,6 +382,7 @@ var Context = class Context {
 	services = /* @__PURE__ */ new Map();
 	subContexts = [];
 	parentEventForwarder;
+	timers = /* @__PURE__ */ new Set();
 	initialReconnectDelayMs;
 	maxReconnectDelayMs;
 	logHandler;
@@ -466,6 +467,23 @@ and implement the dispose method to clean up resources when the context stops.
 		this.subContexts.push(subContext);
 		return subContext;
 	}
+	timeout(delayMs, callback) {
+		this.assertCanScheduleTimer();
+		const timeout = setTimeout(() => {
+			this.timers.delete(timeout);
+			this.runTimerCallback(callback);
+		}, delayMs);
+		this.timers.add(timeout);
+		return timeout;
+	}
+	interval(intervalMs, callback) {
+		this.assertCanScheduleTimer();
+		const interval = setInterval(() => {
+			this.runTimerCallback(callback);
+		}, intervalMs);
+		this.timers.add(interval);
+		return interval;
+	}
 	createSession(message) {
 		return {
 			raw: message,
@@ -508,10 +526,10 @@ and implement the dispose method to clean up resources when the context stops.
 		}
 	}
 	async stop() {
-		if (this.state === "idle" || this.state === "stopped") return;
+		if (this.state === "idle" && this.timers.size === 0 || this.state === "stopped") return;
 		if (this.state === "starting") await this.startPromise;
 		const stateAfterStart = this.getState();
-		if (stateAfterStart === "idle" || stateAfterStart === "stopped") return;
+		if (stateAfterStart === "idle" && this.timers.size === 0 || stateAfterStart === "stopped") return;
 		if (stateAfterStart === "stopping") {
 			await this.stopPromise;
 			return;
@@ -526,16 +544,16 @@ and implement the dispose method to clean up resources when the context stops.
 		}
 	}
 	async startInternal() {
+		const appliedContextPlugins = [];
+		const startingContexts = [];
 		try {
-			const sortedPlugins = this.sortPlugins();
-			await this.applyPlugins(sortedPlugins);
-			await this.startPlugins(sortedPlugins);
+			await this.recursiveApplyPlugins(appliedContextPlugins, startingContexts);
+			await this.recursiveStartPlugins(appliedContextPlugins);
 		} catch (error) {
-			this.state = "idle";
+			for (const context of startingContexts) if (context.state === "starting") context.state = "idle";
 			throw error;
 		}
-		for (const subContext of this.subContexts) await subContext.start();
-		this.state = "started";
+		for (const { context } of appliedContextPlugins) context.state = "started";
 		if (!this.parent) this.eventStreamTask = this.runEventStream();
 	}
 	getState() {
@@ -543,12 +561,13 @@ and implement the dispose method to clean up resources when the context stops.
 	}
 	async stopInternal() {
 		const errors = [];
-		await this.stopEventStream(errors);
+		this.clearTimers();
 		for (const subContext of [...this.subContexts].reverse()) try {
 			await subContext.stop();
 		} catch (error) {
 			errors.push(error);
 		}
+		await this.stopEventStream(errors);
 		if (this.parent && this.parentEventForwarder) this.parent.eventBus.off("*", this.parentEventForwarder);
 		for (const service of [...this.services.values()].reverse()) {
 			if (!isDisposable(service)) continue;
@@ -561,6 +580,22 @@ and implement the dispose method to clean up resources when the context stops.
 		if (errors.length === 1) throw errors[0];
 		if (errors.length > 1) throw new AggregateError(errors, `Context "${this.name}" failed to stop cleanly.`);
 	}
+	assertCanScheduleTimer() {
+		if (this.state === "stopping") throw new Error(`Context "${this.name}" cannot schedule timers while it is stopping.`);
+		if (this.state === "stopped") throw new Error(`Context "${this.name}" cannot schedule timers after it has stopped.`);
+	}
+	async runTimerCallback(callback) {
+		if (this.state === "stopping" || this.state === "stopped") return;
+		try {
+			await callback();
+		} catch (error) {
+			this.logger.error("Error handling timer callback", error);
+		}
+	}
+	clearTimers() {
+		for (const timer of this.timers) clearTimeout(timer);
+		this.timers.clear();
+	}
 	async stopEventStream(errors) {
 		this.resolveReconnectDelay();
 		const subscription = this.eventSubscription;
@@ -591,6 +626,24 @@ and implement the dispose method to clean up resources when the context stops.
 			for (const service of plugin.provides ?? []) if (!this.services.has(service) || providedBeforeApply.has(service)) throw new Error(`${plugin.name} declares service ${service.name} but did not provide it.`);
 		}
 	}
+	async recursiveApplyPlugins(appliedContextPlugins, startingContexts) {
+		if (this.state === "started") return;
+		if (this.state === "starting" && this.startPromise) {
+			await this.startPromise;
+			return;
+		}
+		if (this.state === "stopping") throw new Error(`Context "${this.name}" cannot be started while it is stopping.`);
+		if (this.state === "stopped") throw new Error(`Context "${this.name}" cannot be restarted after it has been stopped.`);
+		if (this.state === "idle") this.state = "starting";
+		startingContexts.push(this);
+		const sortedPlugins = this.sortPlugins();
+		await this.applyPlugins(sortedPlugins);
+		appliedContextPlugins.push({
+			context: this,
+			sortedPlugins
+		});
+		for (const subContext of this.subContexts) await subContext.recursiveApplyPlugins(appliedContextPlugins, startingContexts);
+	}
 	async startPlugins(sortedPlugins) {
 		for (const installedPlugin of sortedPlugins) {
 			const { plugin } = installedPlugin;
@@ -599,6 +652,9 @@ and implement the dispose method to clean up resources when the context stops.
 			await plugin.start(this.getPluginContext(installedPlugin));
 		}
 	}
+	async recursiveStartPlugins(appliedContextPlugins) {
+		for (const { context, sortedPlugins } of appliedContextPlugins) await context.startPlugins(sortedPlugins);
+	}
 	sortPlugins() {
 		const providers = /* @__PURE__ */ new Map();
 		for (const { plugin } of this.plugins) for (const service of plugin.provides ?? []) {
@@ -664,6 +720,10 @@ and implement the dispose method to clean up resources when the context stops.
 	}
 	createProxyContextForPlugin(plugin) {
 		const proxyLogger = new Logger((message) => this.logHandler?.(message), plugin.name);
+		const proxyProvide = (service, instance) => {
+			this.provide(service, instance);
+			this.logger.debug(`Plugin ${plugin.name} provided ${service.name}`);
+		};
 		let proxyInjections;
 		if (plugin.inject) {
 			proxyInjections = {};
@@ -673,10 +733,11 @@ and implement the dispose method to clean up resources when the context stops.
 			proxyInjections ??= {};
 			for (const [key, service] of Object.entries(plugin.optionalInject)) proxyInjections[key] = this.tryResolve(service);
 		}
-		return new Proxy(this, { get(target, prop) {
+		return new Proxy(this, { get(target, prop, receiver) {
 			if (prop === "logger") return proxyLogger;
+			else if (prop === "provide") return proxyProvide;
 			else if (proxyInjections && prop in proxyInjections) return proxyInjections[prop];
-			else return target[prop];
+			else return Reflect.get(target, prop, receiver);
 		} });
 	}
 	async runEventStream() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fraqjs/fraq",
   "type": "module",
-  "version": "0.6.3",
+  "version": "0.7.0",
   "description": "Milky Bot framework",
   "files": [
     "dist"