@fraqjs/fraq 0.3.2 → 0.4.0

package/dist/index.d.mts

@@ -5540,23 +5540,26 @@ declare namespace filter {
 }
 //#endregion
 //#region src/core/logging.d.ts
+type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 interface LogMessage {
-  level: 'debug' | 'info' | 'warn' | 'error';
+  level: LogLevel;
   module: string;
   message: string;
   error?: unknown;
   time: number;
 }
+type LogHandler = (message: LogMessage) => void;
 declare class Logger {
   private readonly logHandler;
   private readonly module;
-  constructor(logHandler: (message: LogMessage) => void, module: string);
+  constructor(logHandler: LogHandler, module: string);
   private log;
   debug(message: string): void;
   info(message: string): void;
   warn(message: string, error?: unknown): void;
   error(message: string, error?: unknown): void;
 }
+declare function combineLogHandlers(...handlers: LogHandler[]): LogHandler;
 //#endregion
 //#region src/core/service.d.ts
 /** biome-ignore-all lint/suspicious/noExplicitAny: Service constructors may accept any arguments. */
@@ -5564,13 +5567,31 @@ type ServiceClass<T extends object = object> = abstract new (...args: any[]) =>
 //#endregion
 //#region src/core/plugin.d.ts
 type ParameterList = Array<any>;
-interface Plugin<T extends ParameterList> {
+type Injection = Record<string, ServiceClass>;
+type InjectedServices<I extends Injection | undefined> = I extends Injection
+  ? { [K in keyof I]: InstanceType<I[K]> }
+  : {};
+type OptionalInjectedServices<I extends Injection | undefined> = I extends Injection
+  ? { [K in keyof I]: InstanceType<I[K]> | undefined }
+  : {};
+interface Plugin<
+  T extends ParameterList,
+  I extends Injection | undefined,
+  OI extends Injection | undefined = undefined,
+> {
   name: string;
   requires?: readonly ServiceClass[];
+  inject?: I;
+  optionalRequires?: readonly ServiceClass[];
+  optionalInject?: OI;
   provides?: readonly ServiceClass[];
-  apply(ctx: Context, ...args: T): void | Promise<void>;
+  apply(ctx: Context & InjectedServices<I> & OptionalInjectedServices<OI>, ...args: T): void | Promise<void>;
 }
-declare function definePlugin<T extends ParameterList>(plugin: Plugin<T>): Plugin<T>;
+declare function definePlugin<
+  T extends ParameterList,
+  I extends Injection | undefined,
+  OI extends Injection | undefined,
+>(plugin: Plugin<T, I, OI>): Plugin<T, I, OI>;
 //#endregion
 //#region src/core/context.d.ts
 interface ContextOptions {
@@ -5578,7 +5599,7 @@ interface ContextOptions {
     initialDelayMs?: number;
     maxDelayMs?: number;
   };
-  logHandler?: (message: LogMessage) => void;
+  logHandler?: LogHandler;
 }
 interface ContextUrlOptions {
   accessToken?: string;
@@ -5600,7 +5621,10 @@ declare class Context {
   private isStarted;
   private constructor();
   on<K extends keyof EventMap>(type: K, handler: (event: EventMap[K]) => void | Promise<void>): void;
-  install<T extends ParameterList>(plugin: Plugin<T>, ...args: T): void;
+  install<T extends ParameterList, I extends Injection | undefined, OI extends Injection | undefined>(
+    plugin: Plugin<T, I, OI>,
+    ...args: T
+  ): void;
   provide<T extends object>(service: ServiceClass<T>, instance: T): void;
   resolve<T extends object>(service: ServiceClass<T>): T;
   tryResolve<T extends object>(service: ServiceClass<T>): T | undefined;
@@ -5610,6 +5634,9 @@ declare class Context {
   private acceptsParentEvent;
   private applyPlugins;
   private sortPlugins;
+  private collectPendingProvidedServices;
+  private areRequiredServicesAvailable;
+  private areOptionalServicesReady;
   private collectAvailableServices;
   private createUnresolvablePluginError;
   private createProxyContextForPlugin;
@@ -5666,6 +5693,9 @@ export {
   ContextUrlOptions,
   EventMap,
   Filter,
+  Injection,
+  LogHandler,
+  LogLevel,
   LogMessage,
   Logger,
   MilkyClient,
@@ -5676,6 +5706,7 @@ export {
   Router,
   type ServiceClass,
   Session,
+  combineLogHandlers,
   createMilkyClient,
   definePlugin,
   filter,

package/dist/index.mjs

@@ -300,6 +300,11 @@ var Logger = class {
 		this.log("error", message, error);
 	}
 };
+function combineLogHandlers(...handlers) {
+	return (message) => {
+		for (const handler of handlers) handler(message);
+	};
+}
 //#endregion
 //#region src/core/service.ts
 function getServiceName(service) {
@@ -414,7 +419,10 @@ var Context = class Context {
 		const available = /* @__PURE__ */ new Set();
 		for (const service of this.collectAvailableServices()) available.add(service);
 		while (pending.length > 0) {
-			const nextIndex = pending.findIndex(({ plugin }) => (plugin.requires ?? []).every((service) => available.has(service)));
+			const availableByPendingPlugins = this.collectPendingProvidedServices(pending);
+			const requiredReadyIndex = pending.findIndex(({ plugin }) => this.areRequiredServicesAvailable(plugin, available));
+			const optionalReadyIndex = pending.findIndex(({ plugin }) => this.areRequiredServicesAvailable(plugin, available) && this.areOptionalServicesReady(plugin, available, availableByPendingPlugins));
+			const nextIndex = optionalReadyIndex === -1 ? requiredReadyIndex : optionalReadyIndex;
 			if (nextIndex === -1) throw this.createUnresolvablePluginError(pending, available);
 			const [next] = pending.splice(nextIndex, 1);
 			sorted.push(next);
@@ -422,6 +430,21 @@ var Context = class Context {
 		}
 		return sorted;
 	}
+	collectPendingProvidedServices(pending) {
+		const providedServices = /* @__PURE__ */ new Map();
+		for (const installedPlugin of pending) for (const service of installedPlugin.plugin.provides ?? []) providedServices.set(service, installedPlugin);
+		return providedServices;
+	}
+	areRequiredServicesAvailable(plugin, available) {
+		return (plugin.requires ?? []).every((service) => available.has(service));
+	}
+	areOptionalServicesReady(plugin, available, pendingProviders) {
+		return (plugin.optionalRequires ?? []).every((service) => {
+			if (available.has(service)) return true;
+			const pendingProvider = pendingProviders.get(service);
+			return pendingProvider === void 0 || pendingProvider.plugin === plugin;
+		});
+	}
 	collectAvailableServices() {
 		const services = [...this.services.keys()];
 		if (this.parent) services.push(...this.parent.collectAvailableServices());
@@ -445,15 +468,27 @@ var Context = class Context {
 	}
 	createProxyContextForPlugin(plugin) {
 		const proxyLogger = new Logger((message) => this.logHandler?.(message), plugin.name);
+		let proxyInjections;
+		if (plugin.inject) {
+			proxyInjections = {};
+			for (const [key, service] of Object.entries(plugin.inject)) proxyInjections[key] = this.resolve(service);
+		}
+		if (plugin.optionalInject) {
+			proxyInjections ??= {};
+			for (const [key, service] of Object.entries(plugin.optionalInject)) proxyInjections[key] = this.tryResolve(service);
+		}
 		return new Proxy(this, { get(target, prop) {
 			if (prop === "logger") return proxyLogger;
+			else if (proxyInjections && prop in proxyInjections) return proxyInjections[prop];
 			else return target[prop];
 		} });
 	}
 	async runEventStream() {
 		let reconnectDelay = this.initialReconnectDelayMs;
+		let reconnectAttempt = 1;
 		while (this.isStarted) {
 			try {
+				this.logger.debug(`Connecting event stream (attempt=${reconnectAttempt})`);
 				const subscription = await this.client.startEvents((event) => {
 					try {
 						this.eventBus.emit(event.event_type, event);
@@ -461,13 +496,17 @@ var Context = class Context {
 						this.logger.error("Error handling event stream event", error);
 					}
 				});
+				this.logger.info("Event stream connected");
 				reconnectDelay = this.initialReconnectDelayMs;
+				reconnectAttempt = 1;
 				await subscription.closed;
+				this.logger.warn(`Event stream disconnected; reconnecting in ${reconnectDelay}ms`);
 			} catch (error) {
-				this.logger.error("Error connecting event stream", error);
+				this.logger.error(`Error connecting event stream; reconnecting in ${reconnectDelay}ms`, error);
 			}
 			await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
 			reconnectDelay = Math.min(reconnectDelay * 2, this.maxReconnectDelayMs);
+			reconnectAttempt += 1;
 		}
 	}
 	createSession(message) {
@@ -604,6 +643,14 @@ let filter;
 //#endregion
 //#region src/core/plugin.ts
 function definePlugin(plugin) {
+	if (plugin.inject) {
+		if (plugin.requires) throw new Error(`Plugin "${plugin.name}" cannot have both "requires" and "inject" properties.`);
+		plugin.requires = Object.values(plugin.inject);
+	}
+	if (plugin.optionalInject) {
+		if (plugin.optionalRequires) throw new Error(`Plugin "${plugin.name}" cannot have both "optionalRequires" and "optionalInject" properties.`);
+		plugin.optionalRequires = Object.values(plugin.optionalInject);
+	}
 	return plugin;
 }
 //#endregion
@@ -866,4 +913,4 @@ let param;
 	_param.segment = segment;
 })(param || (param = {}));
 //#endregion
-export { Context, Logger, Parameter, Router, createMilkyClient, definePlugin, filter, milkyPackageVersion, milkyVersion, msg, param, seg };
+export { Context, Logger, Parameter, Router, combineLogHandlers, createMilkyClient, definePlugin, filter, milkyPackageVersion, milkyVersion, msg, param, seg };

package/package.json

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