@irpclib/irpc 1.0.0-beta.21 → 1.0.0-beta.23

package/dist/state.js

@@ -1,5 +1,7 @@
 import { IRPC_STATUS } from "./enum.js";
-import { anchor, mutable, subscribe } from "@anchorlib/core";
+import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { getAbortSignal } from "./context.js";
+import { $do, anchor, mutable, onCleanup, subscribe } from "@anchorlib/core";
 
 //#region src/state.ts
 /**
@@ -12,62 +14,95 @@ import { anchor, mutable, subscribe } from "@anchorlib/core";
 * @template T - The type of data held by the state.
 */
 var RemoteState = class extends Promise {
-	state;
-	accept;
-	reject;
+	#state;
+	#accept;
+	#reject;
+	#closed = false;
+	get state() {
+		return this.#state;
+	}
 	/**
 	* The current data payload of the state.
 	*/
 	get data() {
-		return this.state.data;
+		return this.#state.data;
 	}
 	set data(data) {
-		this.state.data = data;
+		if (this.#closed) return;
+		this.#state.data = data;
 	}
 	/**
 	* The current error encountered by the state, if any.
 	*/
 	get error() {
-		return this.state.error;
+		return this.#state.error;
 	}
 	set error(error) {
-		this.state.error = error;
+		if (this.#closed) return;
+		this.#state.error = error;
 	}
 	/**
 	* The execution status of the state (PENDING, SUCCESS, ERROR).
 	* Transitioning to a terminal status (SUCCESS or ERROR) will automatically resolve or reject the underlying Promise.
 	*/
 	get status() {
-		return this.state.status;
+		return this.#state.status;
 	}
 	set status(status) {
+		if (this.#closed) return;
 		this.state.status = status;
-		if (this.status === IRPC_STATUS.ERROR) {
-			this.reject(new Error(this.error.message));
-			this.destroy();
-		} else if (this.status === IRPC_STATUS.SUCCESS) {
-			this.accept(this.data);
-			this.destroy();
-		}
+		if (status === IRPC_STATUS.ERROR) this.reject();
+		else if (status === IRPC_STATUS.SUCCESS) this.accept();
 	}
 	/**
 	* Initializes a new RemoteState with an optional initial payload.
 	*
 	* @param init - An optional starting value for the data payload.
+	* @param status - The initial status of the state (PENDING, SUCCESS, ERROR).
 	*/
-	constructor(init) {
+	constructor(init, status = IRPC_STATUS.PENDING) {
 		let acceptFn;
 		let rejectFn;
 		super((resolve, reject) => {
 			acceptFn = resolve;
 			rejectFn = reject;
 		});
-		this.accept = acceptFn;
-		this.reject = rejectFn;
-		this.state = mutable({
+		this.#accept = acceptFn;
+		this.#reject = rejectFn;
+		this.#state = mutable({
 			data: init,
 			error: void 0,
-			status: IRPC_STATUS.PENDING
+			status
+		});
+		onCleanup(() => this.close());
+	}
+	accept(...args) {
+		$do(() => {
+			if (this.#closed) return;
+			const value = args.length ? args[0] : this.data;
+			this.#closed = true;
+			this.#state.status = IRPC_STATUS.SUCCESS;
+			this.#state.data = value;
+			this.#accept(value);
+			this.destroy();
+		});
+	}
+	reject(...args) {
+		$do(() => {
+			if (this.#closed) return;
+			if (args.length) this.#state.error = args[0];
+			this.#closed = true;
+			this.#state.status = IRPC_STATUS.ERROR;
+			this.#reject(this.error ?? new Error(ERROR_MESSAGE[ERROR_CODE.UNKNOWN]));
+			this.destroy();
+		});
+	}
+	abort() {
+		$do(() => {
+			this.#closed = true;
+			this.#state.status = IRPC_STATUS.ABORTED;
+			this.#accept(this.data);
+			this.destroy();
 		});
 	}
 	/**
@@ -80,6 +115,15 @@ var RemoteState = class extends Promise {
 		return subscribe(this.state, handler);
 	}
 	/**
+	* Closes the reactive state and terminates the underlying Promise.
+	*/
+	close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#accept(this.data);
+		this.destroy();
+	}
+	/**
 	* Destroys the reactive state bindings.
 	*/
 	destroy() {
@@ -105,17 +149,27 @@ var RemoteState = class extends Promise {
 */
 function stream(construct, init) {
 	const state = new RemoteState(init);
+	const abortSignal = getAbortSignal();
 	const accept = ((...values) => {
 		if (values.length > 0) state.data = values[0];
 		state.status = IRPC_STATUS.SUCCESS;
+		abortSignal?.removeEventListener("abort", abort);
 	});
 	const reject = (error) => {
 		state.error = error;
 		state.status = IRPC_STATUS.ERROR;
+		abortSignal?.removeEventListener("abort", abort);
 	};
+	const abort = () => state.abort();
+	abortSignal?.addEventListener("abort", abort, { once: true });
 	try {
-		const result = construct(state.data, accept, reject);
-		if (result instanceof Promise) result.catch(reject);
+		const cleanup = construct(state, accept, reject);
+		if (cleanup instanceof Promise) cleanup.then((futureCleanup) => {
+			if (typeof futureCleanup === "function") if (abortSignal?.aborted || state.status !== IRPC_STATUS.PENDING) $do(futureCleanup);
+			else abortSignal?.addEventListener("abort", () => $do(futureCleanup), { once: true });
+		}).catch(reject);
+		else if (typeof cleanup === "function") if (abortSignal?.aborted || state.status !== IRPC_STATUS.PENDING) $do(cleanup);
+		else abortSignal?.addEventListener("abort", () => $do(cleanup), { once: true });
 	} catch (error) {
 		reject(error);
 	}

package/dist/store.d.ts

@@ -0,0 +1,44 @@
+import { IRPC_STORE_EVENT } from "./enum.js";
+import { IRPCData } from "./types.js";
+import { IRPCPackage } from "./module.js";
+import { IRPCRouter } from "./router.js";
+import { IRPCStream } from "./stream.js";
+
+//#region src/store.d.ts
+type IRPCStoreEvent = {
+  type: typeof IRPC_STORE_EVENT.REGISTER;
+  data: IRPCPackage;
+} | {
+  type: typeof IRPC_STORE_EVENT.ROUTE;
+  data: IRPCRouter;
+} | {
+  type: typeof IRPC_STORE_EVENT.QUEUE;
+  data: IRPCStream<IRPCData>;
+} | {
+  type: typeof IRPC_STORE_EVENT.DEQUEUE;
+  data: IRPCStream<IRPCData>;
+} | {
+  type: typeof IRPC_STORE_EVENT.ERROR;
+  error: Error;
+  data?: unknown[];
+};
+type IRPCStoreSubscriber = (event: IRPCStoreEvent) => void;
+declare class IRPCStore {
+  #private;
+  calls: Set<IRPCStream<IRPCData>>;
+  routers: Set<IRPCRouter>;
+  packages: Set<IRPCPackage>;
+  callCount: number;
+  errorCount: number;
+  register(pkg: IRPCPackage): void;
+  route(router: IRPCRouter): void;
+  queue(call: IRPCStream<IRPCData>): void;
+  dequeue(call: IRPCStream<IRPCData>): void;
+  error(error: Error, data?: unknown[]): void;
+  print(): void;
+  subscribe(handler: IRPCStoreSubscriber): () => boolean;
+  private broadcast;
+}
+declare const IRPC_STORE: IRPCStore;
+//#endregion
+export { IRPCStore, IRPCStoreEvent, IRPCStoreSubscriber, IRPC_STORE };

package/dist/store.js

@@ -0,0 +1,76 @@
+import { IRPC_STORE_EVENT } from "./enum.js";
+import { IRPCPackage } from "./module.js";
+import { IRPCRouter } from "./router.js";
+import { IRPCStream } from "./stream.js";
+
+//#region src/store.ts
+var IRPCStore = class {
+	#subscribers = /* @__PURE__ */ new Set();
+	calls = /* @__PURE__ */ new Set();
+	routers = /* @__PURE__ */ new Set();
+	packages = /* @__PURE__ */ new Set();
+	callCount = 0;
+	errorCount = 0;
+	register(pkg) {
+		if (!(pkg instanceof IRPCPackage)) throw new Error("Invalid package: package must be an instance of IRPCPackage.");
+		this.packages.add(pkg);
+		this.broadcast({
+			type: IRPC_STORE_EVENT.REGISTER,
+			data: pkg
+		});
+	}
+	route(router) {
+		if (!(router instanceof IRPCRouter)) throw new Error("Invalid router: router must be an instance of IRPCRouter.");
+		this.routers.add(router);
+		this.broadcast({
+			type: IRPC_STORE_EVENT.ROUTE,
+			data: router
+		});
+	}
+	queue(call) {
+		if (!(call instanceof IRPCStream)) throw new Error("Invalid call: call must be an instance of IRPCStream.");
+		this.calls.add(call);
+		this.callCount += 1;
+		this.broadcast({
+			type: IRPC_STORE_EVENT.QUEUE,
+			data: call
+		});
+	}
+	dequeue(call) {
+		if (!(call instanceof IRPCStream)) throw new Error("Invalid call: call must be an instance of IRPCStream.");
+		this.calls.delete(call);
+		this.broadcast({
+			type: IRPC_STORE_EVENT.DEQUEUE,
+			data: call
+		});
+	}
+	error(error, data) {
+		this.errorCount += 1;
+		this.broadcast({
+			type: IRPC_STORE_EVENT.ERROR,
+			error,
+			data
+		});
+	}
+	print() {
+		console.table([{
+			Packages: this.packages.size,
+			Routers: this.routers.size,
+			Running: this.calls.size,
+			Calls: this.callCount,
+			Errors: this.errorCount
+		}]);
+	}
+	subscribe(handler) {
+		if (typeof handler !== "function") throw new Error("Invalid handler: handler must be a function.");
+		this.#subscribers.add(handler);
+		return () => this.#subscribers.delete(handler);
+	}
+	broadcast(event) {
+		for (const subscriber of this.#subscribers) subscriber(event);
+	}
+};
+const IRPC_STORE = new IRPCStore();
+
+//#endregion
+export { IRPCStore, IRPC_STORE };

package/dist/stream.d.ts

@@ -1,4 +1,5 @@
-import { IRPCData, IRPCError, IRPCPacketStream, IRPCResponse, IRPCStatus } from "./types.js";
+import { IRPCData, IRPCDataSchema, IRPCError, IRPCInputs, IRPCPacketStream, IRPCResponse, IRPCSpec, IRPCStatus } from "./types.js";
+import { IRPCRouter } from "./router.js";
 
 //#region src/stream.d.ts
 
@@ -14,20 +15,29 @@ declare class IRPCStream<T extends IRPCData> {
   private id;
   private name;
   private initializer;
+  spec?: IRPCSpec<IRPCInputs, IRPCDataSchema> | undefined;
+  router?: IRPCRouter | undefined;
   private pipeHandlers;
   private closeHandlers;
   private errorHandlers;
   value?: T;
   error?: IRPCError;
   status: IRPCStatus;
+  closed: boolean;
+  createdAt: number;
+  startedAt?: number;
+  updatedAt?: number;
+  controller?: AbortController;
   /**
    * Initializes a stream wrapping an asynchronous RPC execution.
    *
    * @param id - The unique identifier of the RPC request.
    * @param name - The name of the specification processing the execution.
    * @param initializer - An execution callback that yields an IRPCResponse.
+   * @param spec - The specification for the RPC execution.
+   * @param router - The router instance managing the stream.
    */
-  constructor(id: string, name: string, initializer: () => Promise<IRPCResponse>);
+  constructor(id: string, name: string, initializer: () => Promise<IRPCResponse>, spec?: IRPCSpec<IRPCInputs, IRPCDataSchema> | undefined, router?: IRPCRouter | undefined);
   /**
    * Evaluates the underlying initializer and propagates standard transport packets
    * to all bound pipe handlers based on the output lifecycle.
@@ -52,6 +62,7 @@ declare class IRPCStream<T extends IRPCData> {
    * @param handler - A callback function invoked at stream completion.
    */
   close(handler: () => void): void;
+  private finish;
 }
 //#endregion
 export { IRPCStream };

package/dist/stream.js

@@ -1,6 +1,8 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE } from "./error.js";
+import { getAbortController, getAbortSignal } from "./context.js";
 import { RemoteState } from "./state.js";
+import { IRPC_STORE } from "./store.js";
 
 //#region src/stream.ts
 /**
@@ -18,28 +20,50 @@ var IRPCStream = class {
 	value;
 	error;
 	status = IRPC_STATUS.IDLE;
+	closed = false;
+	createdAt = Date.now();
+	startedAt;
+	updatedAt;
+	controller;
 	/**
 	* Initializes a stream wrapping an asynchronous RPC execution.
 	*
 	* @param id - The unique identifier of the RPC request.
 	* @param name - The name of the specification processing the execution.
 	* @param initializer - An execution callback that yields an IRPCResponse.
+	* @param spec - The specification for the RPC execution.
+	* @param router - The router instance managing the stream.
 	*/
-	constructor(id, name, initializer) {
+	constructor(id, name, initializer, spec, router) {
 		this.id = id;
 		this.name = name;
 		this.initializer = initializer;
+		this.spec = spec;
+		this.router = router;
+		IRPC_STORE.queue(this);
 	}
 	/**
 	* Evaluates the underlying initializer and propagates standard transport packets
 	* to all bound pipe handlers based on the output lifecycle.
 	*/
 	async start() {
-		if (this.status !== IRPC_STATUS.IDLE) return;
+		if (this.status !== IRPC_STATUS.IDLE || this.closed) return;
+		this.startedAt = Date.now();
+		this.controller = getAbortController();
+		const abortSignal = getAbortSignal();
+		if (abortSignal?.aborted) {
+			this.finish();
+			return;
+		}
 		this.status = IRPC_STATUS.PENDING;
 		const { id, name } = this;
 		try {
-			const { result } = await this.initializer();
+			const response = await this.initializer();
+			if (abortSignal?.aborted) {
+				this.finish();
+				return;
+			}
+			const { result } = response;
 			if (result instanceof RemoteState) {
 				this.value = result.data;
 				if (result.status === IRPC_STATUS.SUCCESS || result.status === IRPC_STATUS.ERROR) {
@@ -60,8 +84,8 @@ var IRPCStream = class {
 						createdAt: Date.now()
 					};
 					this.pipeHandlers.forEach((handler) => handler(packet));
-					this.errorHandlers.forEach((handler) => handler(this.error));
-					this.closeHandlers.forEach((handler) => handler());
+					if (this.error) this.errorHandlers.forEach((handler) => handler(this.error));
+					this.finish();
 					return;
 				}
 				this.pipeHandlers.forEach((handler) => {
@@ -81,13 +105,13 @@ var IRPCStream = class {
 						handler({
 							id,
 							name,
-							type: IRPC_PACKET_TYPE.EVENT,
-							status: state.status,
 							data: {
 								type,
 								keys,
 								value
 							},
+							type: IRPC_PACKET_TYPE.EVENT,
+							status: state.status,
 							createdAt: Date.now()
 						});
 					});
@@ -111,25 +135,43 @@ var IRPCStream = class {
 								createdAt: Date.now()
 							});
 						});
-						this.closeHandlers.forEach((handler) => handler());
+						abortSignal?.removeEventListener("abort", abortStream);
+						this.finish();
 						unsubscribe();
 					}
 				});
+				const abortStream = () => {
+					unsubscribe();
+					this.finish();
+				};
+				abortSignal?.addEventListener("abort", abortStream, { once: true });
 			} else {
 				this.value = result;
-				this.status = IRPC_STATUS.SUCCESS;
+				if (response.error) {
+					this.error = {
+						code: ERROR_CODE.STREAM_ERROR,
+						message: response.error.message
+					};
+					this.status = IRPC_STATUS.ERROR;
+					this.errorHandlers.forEach((handler) => handler(this.error));
+				} else this.status = IRPC_STATUS.SUCCESS;
 				const packet = {
 					id,
 					name,
 					type: IRPC_PACKET_TYPE.ANSWER,
-					status: IRPC_STATUS.SUCCESS,
 					data: this.value,
+					error: this.error,
+					status: this.status,
 					createdAt: Date.now()
 				};
 				this.pipeHandlers.forEach((handler) => handler(packet));
-				this.closeHandlers.forEach((handler) => handler());
+				this.finish();
 			}
 		} catch (error) {
+			IRPC_STORE.error(error, [{
+				id: this.id,
+				name: this.name
+			}]);
 			this.error = {
 				code: ERROR_CODE.STREAM_ERROR,
 				message: error.message
@@ -146,7 +188,7 @@ var IRPCStream = class {
 				});
 			});
 			this.errorHandlers.forEach((handler) => handler(this.error));
-			this.closeHandlers.forEach((handler) => handler());
+			this.finish();
 			return;
 		}
 	}
@@ -169,8 +211,12 @@ var IRPCStream = class {
 			});
 			return;
 		}
+		if (this.closed) return;
 		this.pipeHandlers.add(handler);
-		this.start().catch(() => {});
+		this.start().catch((err) => IRPC_STORE.error(err, [{
+			id: this.id,
+			name: this.name
+		}]));
 	}
 	/**
 	* Binds a handler to trap any internal runtime failures independently.
@@ -182,8 +228,12 @@ var IRPCStream = class {
 			handler(this.error);
 			return;
 		}
+		if (this.closed) return;
 		this.errorHandlers.add(handler);
-		this.start().catch(() => {});
+		this.start().catch((err) => IRPC_STORE.error(err, [{
+			id: this.id,
+			name: this.name
+		}]));
 	}
 	/**
 	* Binds a handler triggered upon terminal completion of the stream process (success or error).
@@ -195,8 +245,21 @@ var IRPCStream = class {
 			handler();
 			return;
 		}
+		if (this.closed) return;
 		this.closeHandlers.add(handler);
-		this.start().catch(() => {});
+		this.start().catch((err) => IRPC_STORE.error(err, [{
+			id: this.id,
+			name: this.name
+		}]));
+	}
+	finish() {
+		this.closed = true;
+		this.closeHandlers.forEach((handler) => handler());
+		this.pipeHandlers.clear();
+		this.errorHandlers.clear();
+		this.closeHandlers.clear();
+		this.updatedAt = Date.now();
+		IRPC_STORE.dequeue(this);
 	}
 };
 

package/dist/transport.d.ts

@@ -21,18 +21,25 @@ declare class IRPCTransport {
   constructor(config?: TransportConfig | undefined);
   /**
    * Initiates an RPC call with the given specification and arguments.
+   * @param reader - The reader instance to attach to the RPC call.
    * @param spec - The RPC specification defining the method to call.
    * @param args - An array of arguments to pass to the RPC method.
    * @param config - Optional call configuration, including timeout, retry settings, and more.
    * @returns A promise that resolves with the RPC response data or rejects with an error.
    */
-  call(spec: IRPCSpec<IRPCInputs, IRPCOutput>, args: IRPCData[], config?: IRPCCallConfig): IRPCReader<IRPCData>;
+  call(spec: IRPCSpec<IRPCInputs, IRPCOutput>, args: IRPCData[], config?: IRPCCallConfig, reader?: IRPCReader<IRPCData>): IRPCReader<IRPCData>;
   /**
    * Schedules an RPC call for execution, implementing debouncing logic.
    * Queued calls will be dispatched after the configured debounce delay.
    * @param call - The RPC call to schedule.
    */
   schedule(call: IRPCCall): void;
+  /**
+   * Closes an RPC call. This base implementation does nothing.
+   * Subclasses should override this method to provide closing logic.
+   * @param call - The RPC call to cancel.
+   */
+  close(call: IRPCCall): void;
   /**
    * Dispatches a batch of RPC calls. This base implementation rejects all calls
    * with a "not implemented" error. Subclasses should override this method to

package/dist/transport.js

@@ -1,6 +1,9 @@
 import { IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
 import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { IRPCReader } from "./reader.js";
+import { IRPC_STORE } from "./store.js";
 import { IRPCCall } from "./call.js";
+import { onCleanup, uuid } from "@anchorlib/core";
 
 //#region src/transport.ts
 /**
@@ -21,12 +24,13 @@ var IRPCTransport = class {
 	}
 	/**
 	* Initiates an RPC call with the given specification and arguments.
+	* @param reader - The reader instance to attach to the RPC call.
 	* @param spec - The RPC specification defining the method to call.
 	* @param args - An array of arguments to pass to the RPC method.
 	* @param config - Optional call configuration, including timeout, retry settings, and more.
 	* @returns A promise that resolves with the RPC response data or rejects with an error.
 	*/
-	call(spec, args, config) {
+	call(spec, args, config, reader = new IRPCReader(uuid())) {
 		const payload = {
 			name: spec.name,
 			args
@@ -40,8 +44,15 @@ var IRPCTransport = class {
 			maxRetries,
 			retryMode,
 			retryDelay
-		});
-		this.schedule(call);
+		}, reader);
+		if (spec.stream) {
+			this.dispatch([call]).finally(() => {}).catch((err) => IRPC_STORE.error(err, [{
+				id: call.id,
+				name: call.payload.name
+			}]));
+			return call.reader;
+		} else this.schedule(call);
+		onCleanup(() => this.close(call));
 		return call.reader;
 	}
 	/**
@@ -52,12 +63,16 @@ var IRPCTransport = class {
 	schedule(call) {
 		const { debounce } = this.config ?? {};
 		if (debounce === false) {
-			this.dispatch([call]).finally(() => {}).catch(() => {});
+			this.dispatch([call]).finally(() => {}).catch((err) => IRPC_STORE.error(err, [{
+				id: call.id,
+				name: call.payload.name
+			}]));
 			return;
 		}
 		const timeout = typeof debounce === "number" && !Number.isNaN(debounce) ? debounce : 0;
 		const dispatch = () => {
-			this.dispatch(Array.from(this.queue)).finally(() => {}).catch(() => {});
+			const pending = Array.from(this.queue);
+			this.dispatch(pending);
 			this.queue.clear();
 		};
 		if (!this.queue.size) if (timeout === 0) queueMicrotask(dispatch);
@@ -65,6 +80,14 @@ var IRPCTransport = class {
 		this.queue.add(call);
 	}
 	/**
+	* Closes an RPC call. This base implementation does nothing.
+	* Subclasses should override this method to provide closing logic.
+	* @param call - The RPC call to cancel.
+	*/
+	close(call) {
+		console.log("[irpc] Closing call", call);
+	}
+	/**
 	* Dispatches a batch of RPC calls. This base implementation rejects all calls
 	* with a "not implemented" error. Subclasses should override this method to
 	* provide actual transport mechanism.