@irpclib/irpc 1.0.0-beta.22 → 1.0.0-beta.24

package/dist/router.js

@@ -0,0 +1,81 @@
+import { IRPC_BASE_CONTEXT, IRPC_PACKET_TYPE, IRPC_STATUS } from "./enum.js";
+import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { createContextStore, withContext } from "./context.js";
+import { IRPC_STORE } from "./store.js";
+
+//#region src/router.ts
+var IRPCRouter = class {
+	/** Array of middleware functions to be executed */
+	hooks = [];
+	/**
+	* Creates a new Router instance
+	* @param {IRPCPackage} module - The IRPC package module to resolve requests against
+	* @param {IRPCTransport} transport - The transport mechanism to use for resolving requests
+	*/
+	constructor(module, transport) {
+		this.module = module;
+		this.transport = transport;
+		IRPC_STORE.route(this);
+	}
+	/**
+	* Adds a hook function to the router
+	* @param hook - The hook function to add
+	* @returns The current Router instance for chaining
+	*/
+	use(hook) {
+		if (typeof hook !== "function") {
+			const error = new Error(ERROR_MESSAGE[ERROR_CODE.INVALID_HOOK]);
+			IRPC_STORE.error(error);
+			return this;
+		}
+		this.hooks.push(hook);
+		return this;
+	}
+	/**
+	* Run a function within an isolated IRPC Router context.
+	* This make sure any subsequent RPC calls will be seeded with the hooks added to the router.
+	*
+	* @param handler - The handler function to isolate
+	* @param controller - The AbortController to use for cancellation
+	* @param context - Additional context to pass to the handler
+	* @param preHook - A hook function to run before the router hooks
+	* @returns The result of the isolated handler function
+	*/
+	isolate(handler, controller, context = [], preHook) {
+		return withContext(createContextStore([
+			[IRPC_BASE_CONTEXT.ABORT_SIGNAL, controller.signal],
+			[IRPC_BASE_CONTEXT.ABORT_CONTROLLER, controller],
+			...context
+		]), async () => {
+			await preHook?.();
+			for (const hook of this.hooks) await hook();
+			return handler();
+		});
+	}
+	/**
+	* Resolves hook functions for a given request
+	* @param req - The IRPC request to process hook for
+	* @returns An error response if hook fails, undefined otherwise
+	*/
+	async resolveHooks(req) {
+		for (const hook of this.hooks) try {
+			await hook();
+		} catch (error) {
+			IRPC_STORE.error(error, [req.id, req.name]);
+			return {
+				id: req.id,
+				name: req.name,
+				type: IRPC_PACKET_TYPE.CLOSE,
+				status: IRPC_STATUS.ERROR,
+				error: {
+					code: ERROR_CODE.UNKNOWN,
+					message: ERROR_MESSAGE[ERROR_CODE.UNKNOWN]
+				},
+				createdAt: Date.now()
+			};
+		}
+	}
+};
+
+//#endregion
+export { IRPCRouter };

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/server/index.js

@@ -0,0 +1,15 @@
+import { setAsyncScope, setReactive } from "@anchorlib/core";
+import { AsyncLocalStorage } from "node:async_hooks";
+
+//#region src/server/index.ts
+var AnchorASL = class extends AsyncLocalStorage {
+	store = /* @__PURE__ */ new Map();
+	getStore() {
+		return super.getStore() ?? this.store;
+	}
+};
+setAsyncScope(new AnchorASL());
+setReactive(false);
+
+//#endregion
+export {  };

package/dist/state.d.ts

@@ -1,4 +1,4 @@
-import { IRPCReadable, IRPCStatus } from "./types.js";
+import { IRPCReadable, IRPCStatus, StreamConstructor } from "./types.js";
 import * as _anchorlib_core0 from "@anchorlib/core";
 import { StateSubscriber } from "@anchorlib/core";
 
@@ -14,9 +14,9 @@ import { StateSubscriber } from "@anchorlib/core";
  * @template T - The type of data held by the state.
  */
 declare class RemoteState<T> extends Promise<T> {
-  protected readonly state: IRPCReadable<T>;
-  protected readonly accept: (value: T) => void;
-  protected readonly reject: (error: Error) => void;
+  #private;
+  private resumable?;
+  get state(): IRPCReadable<T>;
   /**
    * The current data payload of the state.
    */
@@ -37,8 +37,13 @@ declare class RemoteState<T> extends Promise<T> {
    * 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).
+   * @param resumable - Whether the state should be resumable after being closed.
    */
-  constructor(init?: T);
+  constructor(init?: T, status?: IRPCStatus, resumable?: boolean | undefined);
+  accept(value?: T): void;
+  reject(error?: Error): void;
+  abort(): void;
   /**
    * Subscribes to changes emitted by the internal state.
    *
@@ -46,6 +51,13 @@ declare class RemoteState<T> extends Promise<T> {
    * @returns An unsubscribe function to terminate the listener.
    */
   subscribe(handler: StateSubscriber<IRPCReadable<T>>): _anchorlib_core0.StateUnsubscribe;
+  /**
+   * Closes the reactive state and terminates the underlying Promise.
+   */
+  close(): void;
+  protected resume(): void;
+  pipe(): this;
+  unpipe(): this;
   /**
    * Destroys the reactive state bindings.
    */
@@ -56,17 +68,6 @@ declare class RemoteState<T> extends Promise<T> {
    */
   static get [Symbol.species](): PromiseConstructor;
 }
-/**
- * A callback function type used to natively construct and drive a reactive stream.
- * It provides the initial reactive data reference and terminal resolution hooks
- * without forcing strict async/await boundaries, securely yielding stream operations.
- *
- * @template T - The type of data yielded globally by the stream.
- * @param data - The mutable data payload natively tracked by RemoteState.
- * @param resolve - Callback to statically mark the stream as successfully completed, optionally with a resolved value.
- * @param reject - Callback to forcefully throw a runtime error into the stream structure.
- */
-type StreamConstructor<T> = (data: T, resolve: (value?: T) => void, reject: (error: Error) => void) => void | Promise<void>;
 /**
  * A utility factory to structurally instantiate an active `RemoteState` pipeline natively
  * decoupled from standard Promise chains. This elegantly captures constructor functions
@@ -79,4 +80,4 @@ type StreamConstructor<T> = (data: T, resolve: (value?: T) => void, reject: (err
  */
 declare function stream<T>(construct: StreamConstructor<T>, init?: T): RemoteState<T>;
 //#endregion
-export { RemoteState, StreamConstructor, stream };
+export { RemoteState, stream };

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,99 @@ 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;
+	#locked;
+	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).
+	* @param resumable - Whether the state should be resumable after being closed.
 	*/
-	constructor(init) {
+	constructor(init, status = IRPC_STATUS.PENDING, resumable) {
 		let acceptFn;
 		let rejectFn;
 		super((resolve, reject) => {
+			if (resumable) resolve(init);
 			acceptFn = resolve;
 			rejectFn = reject;
 		});
-		this.accept = acceptFn;
-		this.reject = rejectFn;
-		this.state = mutable({
+		this.resumable = resumable;
+		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,9 +119,33 @@ 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();
+	}
+	resume() {
+		this.#closed = false;
+	}
+	pipe() {
+		this.#locked = this.then;
+		this.then = void 0;
+		return this;
+	}
+	unpipe() {
+		if (!this.#locked) return this;
+		this.then = this.#locked;
+		this.#locked = void 0;
+		return this;
+	}
+	/**
 	* Destroys the reactive state bindings.
 	*/
 	destroy() {
+		if (this.resumable) return;
 		anchor.destroy(this.state);
 	}
 	/**
@@ -105,17 +168,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 { IRPCPackage } from "./module.js";
+import { IRPCData } from "./types.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 };