@fraqjs/fraq 0.6.4 → 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,12 +5701,17 @@ 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;

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;
@@ -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;
@@ -685,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 = {};
@@ -694,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.4",
+  "version": "0.7.0",
   "description": "Milky Bot framework",
   "files": [
     "dist"