@irpclib/irpc 0.0.1 → 1.0.0-beta.16

package/dist/cache.d.ts

@@ -0,0 +1,20 @@
+//#region src/cache.d.ts
+type IRPCCacheEntry = {
+  key: string;
+  value: unknown;
+  expires: number;
+};
+declare class IRPCCacher {
+  caches: Map<string, IRPCCacheEntry>;
+  queues: Map<string, number | NodeJS.Timeout>;
+  get size(): number;
+  has(key: string): boolean;
+  get(key: string): IRPCCacheEntry | undefined;
+  values(): MapIterator<IRPCCacheEntry>;
+  entries(): MapIterator<[string, IRPCCacheEntry]>;
+  set(key: string, value: unknown, maxAge: number): void;
+  delete(key: string): void;
+  clear(): void;
+}
+//#endregion
+export { IRPCCacheEntry, IRPCCacher };

package/dist/cache.js

@@ -0,0 +1,55 @@
+//#region src/cache.ts
+var IRPCCacher = class {
+	caches = /* @__PURE__ */ new Map();
+	queues = /* @__PURE__ */ new Map();
+	get size() {
+		return this.caches.size;
+	}
+	has(key) {
+		return this.caches.has(key);
+	}
+	get(key) {
+		const entry = this.caches.get(key);
+		if (!entry) return void 0;
+		if (entry.expires < Date.now()) {
+			this.caches.delete(key);
+			return;
+		}
+		return entry;
+	}
+	values() {
+		return this.caches.values();
+	}
+	entries() {
+		return this.caches.entries();
+	}
+	set(key, value, maxAge) {
+		if (!maxAge || maxAge < 0) throw new Error("Max age must be a positive number.");
+		const queue = this.queues.get(key);
+		if (queue) clearTimeout(queue);
+		const expires = Date.now() + maxAge;
+		const nextQueue = setTimeout(() => {
+			this.caches.delete(key);
+			this.queues.delete(key);
+		}, maxAge);
+		this.caches.set(key, {
+			key,
+			value,
+			expires
+		});
+		this.queues.set(key, nextQueue);
+	}
+	delete(key) {
+		clearTimeout(this.queues.get(key));
+		this.caches.delete(key);
+		this.queues.delete(key);
+	}
+	clear() {
+		for (const queue of this.queues.values()) clearTimeout(queue);
+		this.caches.clear();
+		this.queues.clear();
+	}
+};
+
+//#endregion
+export { IRPCCacher };

package/dist/call.d.ts

@@ -10,6 +10,7 @@ declare class IRPCCall {
   payload: IRPCPayload;
   resolver: (value: unknown) => void;
   rejector: (reason?: Error) => void;
+  timeout?: number | undefined;
   /**
    * Unique identifier for this RPC call, generated using shortId().
    */
@@ -25,7 +26,7 @@ declare class IRPCCall {
    * @param resolver - Function to resolve the associated promise with a value
    * @param rejector - Function to reject the associated promise with an error
    */
-  constructor(payload: IRPCPayload, resolver: (value: unknown) => void, rejector: (reason?: Error) => void);
+  constructor(payload: IRPCPayload, resolver: (value: unknown) => void, rejector: (reason?: Error) => void, timeout?: number | undefined);
   /**
    * Resolves the RPC call with the provided value.
    * If the call is already resolved, this method does nothing.

package/dist/call.js

@@ -1,4 +1,4 @@
-import { shortId } from "./utils.js";
+import { uuid } from "./uuid.js";
 
 //#region src/call.ts
 /**
@@ -9,7 +9,7 @@ var IRPCCall = class {
 	/**
 	* Unique identifier for this RPC call, generated using shortId().
 	*/
-	id = shortId();
+	id = uuid();
 	/**
 	* Flag indicating whether this call has been resolved or rejected.
 	* Prevents multiple resolutions of the same call.
@@ -21,10 +21,11 @@ var IRPCCall = class {
 	* @param resolver - Function to resolve the associated promise with a value
 	* @param rejector - Function to reject the associated promise with an error
 	*/
-	constructor(payload, resolver, rejector) {
+	constructor(payload, resolver, rejector, timeout) {
 		this.payload = payload;
 		this.resolver = resolver;
 		this.rejector = rejector;
+		this.timeout = timeout;
 	}
 	/**
 	* Resolves the RPC call with the provided value.

package/dist/error.d.ts

@@ -0,0 +1,50 @@
+//#region src/error.d.ts
+declare const ERROR_CODE: {
+  UNKNOWN: string;
+  TIMEOUT: string;
+  NOT_FOUND: string;
+  NOT_SUPPORTED: string;
+  INVALID_TYPE: string;
+  INVALID_STATE: string;
+  INVALID_VALUE: string;
+  INVALID_INPUT: string;
+  INVALID_OUTPUT: string;
+  NOT_IMPLEMENTED: string;
+  INVALID_HANDLER: string;
+  INVALID_OPERATION: string;
+  TRANSPORT_MISSING: string;
+  TRANSPORT_INVALID: string;
+  TRANSPORT_NOT_IMPLEMENTED: string;
+  STUB_MISSING: string;
+  STUB_INVALID: string;
+  STUB_NOT_IMPLEMENTED: string;
+  RESOLVER_MISSING: string;
+  RESOLVER_NOT_IMPLEMENTED: string;
+  RESOLVER_NOT_FOUND: string;
+  RESOLVER_NOT_SUPPORTED: string;
+};
+type ErrorCode = (typeof ERROR_CODE)[keyof typeof ERROR_CODE];
+declare const ERROR_MESSAGE: {
+  [ERROR_CODE.UNKNOWN]: string;
+  [ERROR_CODE.TIMEOUT]: string;
+  [ERROR_CODE.NOT_FOUND]: string;
+  [ERROR_CODE.NOT_SUPPORTED]: string;
+  [ERROR_CODE.INVALID_TYPE]: string;
+  [ERROR_CODE.INVALID_STATE]: string;
+  [ERROR_CODE.INVALID_VALUE]: string;
+  [ERROR_CODE.INVALID_INPUT]: string;
+  [ERROR_CODE.INVALID_OUTPUT]: string;
+  [ERROR_CODE.NOT_IMPLEMENTED]: string;
+  [ERROR_CODE.INVALID_HANDLER]: string;
+  [ERROR_CODE.INVALID_OPERATION]: string;
+  [ERROR_CODE.TRANSPORT_MISSING]: string;
+  [ERROR_CODE.TRANSPORT_INVALID]: string;
+  [ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]: string;
+  [ERROR_CODE.STUB_INVALID]: string;
+  [ERROR_CODE.STUB_NOT_IMPLEMENTED]: string;
+  [ERROR_CODE.RESOLVER_MISSING]: string;
+  [ERROR_CODE.RESOLVER_NOT_IMPLEMENTED]: string;
+  [ERROR_CODE.RESOLVER_NOT_FOUND]: string;
+};
+//#endregion
+export { ERROR_CODE, ERROR_MESSAGE, ErrorCode };

package/dist/error.js

@@ -0,0 +1,50 @@
+//#region src/error.ts
+const ERROR_CODE = {
+	UNKNOWN: "unknown",
+	TIMEOUT: "timeout",
+	NOT_FOUND: "not_found",
+	NOT_SUPPORTED: "not_supported",
+	INVALID_TYPE: "invalid_type",
+	INVALID_STATE: "invalid_state",
+	INVALID_VALUE: "invalid_value",
+	INVALID_INPUT: "invalid_argument",
+	INVALID_OUTPUT: "invalid_argument",
+	NOT_IMPLEMENTED: "not_implemented",
+	INVALID_HANDLER: "invalid_handler",
+	INVALID_OPERATION: "invalid_operation",
+	TRANSPORT_MISSING: "transport_missing",
+	TRANSPORT_INVALID: "transport_invalid",
+	TRANSPORT_NOT_IMPLEMENTED: "transport_not_implemented",
+	STUB_MISSING: "stub_missing",
+	STUB_INVALID: "stub_invalid",
+	STUB_NOT_IMPLEMENTED: "stub_not_implemented",
+	RESOLVER_MISSING: "resolver_missing",
+	RESOLVER_NOT_IMPLEMENTED: "resolver_not_implemented",
+	RESOLVER_NOT_FOUND: "resolver_not_found",
+	RESOLVER_NOT_SUPPORTED: "resolver_not_supported"
+};
+const ERROR_MESSAGE = {
+	[ERROR_CODE.UNKNOWN]: "IRPC: Unknown error",
+	[ERROR_CODE.TIMEOUT]: "IRPC: Timeout error",
+	[ERROR_CODE.NOT_FOUND]: "IRPC: Not found error",
+	[ERROR_CODE.NOT_SUPPORTED]: "IRPC: Not supported error",
+	[ERROR_CODE.INVALID_TYPE]: "IRPC: Invalid type error",
+	[ERROR_CODE.INVALID_STATE]: "IRPC: Invalid state error",
+	[ERROR_CODE.INVALID_VALUE]: "IRPC: Invalid value error",
+	[ERROR_CODE.INVALID_INPUT]: "IRPC: Invalid input error",
+	[ERROR_CODE.INVALID_OUTPUT]: "IRPC: Invalid output error",
+	[ERROR_CODE.NOT_IMPLEMENTED]: "IRPC: Not implemented error",
+	[ERROR_CODE.INVALID_HANDLER]: "IRPC: Invalid handler error",
+	[ERROR_CODE.INVALID_OPERATION]: "IRPC: Invalid operation error",
+	[ERROR_CODE.TRANSPORT_MISSING]: "IRPC: Transport missing error",
+	[ERROR_CODE.TRANSPORT_INVALID]: "IRPC: Transport invalid error",
+	[ERROR_CODE.TRANSPORT_NOT_IMPLEMENTED]: "IRPC: Transport not implemented error",
+	[ERROR_CODE.STUB_INVALID]: "IRPC: Stub invalid error",
+	[ERROR_CODE.STUB_NOT_IMPLEMENTED]: "IRPC: Stub not implemented error",
+	[ERROR_CODE.RESOLVER_MISSING]: "IRPC: Resolver missing error",
+	[ERROR_CODE.RESOLVER_NOT_IMPLEMENTED]: "IRPC: Resolver not implemented error",
+	[ERROR_CODE.RESOLVER_NOT_FOUND]: "IRPC: Resolver not found error"
+};
+
+//#endregion
+export { ERROR_CODE, ERROR_MESSAGE };

package/dist/index.d.ts

@@ -1,7 +1,9 @@
-import { IRPCArraySchema, IRPCAuthorizer, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCFactory, IRPCHandler, IRPCHost, IRPCInputs, IRPCModule, IRPCNamespace, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRegistry, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCStore, IRPCTransport } from "./types.js";
+import { IRPCCacheEntry, IRPCCacher } from "./cache.js";
+import { ERROR_CODE, ERROR_MESSAGE, ErrorCode } from "./error.js";
+import { IRPCTransport } from "./transport.js";
+import { IRPCArraySchema, IRPCCache, IRPCCaches, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCError, IRPCHandler, IRPCInit, IRPCInputs, IRPCModule, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStubStore, TransportConfig } from "./types.js";
 import { IRPCCall } from "./call.js";
-import { batch } from "./batch.js";
 import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
-import { createModule } from "./module.js";
-import { shortId } from "./utils.js";
-export { IRPCArraySchema, IRPCAuthorizer, IRPCCall, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCFactory, IRPCHandler, IRPCHost, IRPCInputs, IRPCModule, IRPCNamespace, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRegistry, IRPCRequest, IRPCResponse, IRPCSchema, IRPCSpec, IRPCStore, IRPCTransport, batch, createContext, createModule, getContext, setContext, setContextProvider, shortId, withContext };
+import { IRPCPackage, createPackage } from "./module.js";
+import { IRPCResolver } from "./resolver.js";
+export { ERROR_CODE, ERROR_MESSAGE, ErrorCode, IRPCArraySchema, IRPCCache, IRPCCacheEntry, IRPCCacher, IRPCCaches, IRPCCall, IRPCContext, IRPCContextProvider, IRPCData, IRPCDataSchema, IRPCError, IRPCHandler, IRPCInit, IRPCInputs, IRPCModule, IRPCObject, IRPCObjectSchema, IRPCOutput, IRPCPackage, IRPCPackageConfig, IRPCPackageInfo, IRPCParseResult, IRPCPayload, IRPCPrimitive, IRPCPrimitiveSchema, IRPCRequest, IRPCResolver, IRPCResponse, IRPCSchema, IRPCSpec, IRPCSpecStore, IRPCStubStore, IRPCTransport, TransportConfig, createContext, createPackage, getContext, setContext, setContextProvider, withContext };

package/dist/index.js

@@ -1,8 +1,9 @@
-import { batch } from "./batch.js";
-import { shortId } from "./utils.js";
+import { IRPCCacher } from "./cache.js";
 import { IRPCCall } from "./call.js";
 import { createContext, getContext, setContext, setContextProvider, withContext } from "./context.js";
-import { IRPCTransport } from "./types.js";
-import { createModule } from "./module.js";
+import { ERROR_CODE, ERROR_MESSAGE } from "./error.js";
+import { IRPCTransport } from "./transport.js";
+import { IRPCPackage, createPackage } from "./module.js";
+import { IRPCResolver } from "./resolver.js";
 
-export { IRPCCall, IRPCTransport, batch, createContext, createModule, getContext, setContext, setContextProvider, shortId, withContext };
+export { ERROR_CODE, ERROR_MESSAGE, IRPCCacher, IRPCCall, IRPCPackage, IRPCResolver, IRPCTransport, createContext, createPackage, getContext, setContext, setContextProvider, withContext };

package/dist/module.d.ts

@@ -1,17 +1,103 @@
-import { IRPCFactory, IRPCModule } from "./types.js";
+import { IRPCCacher } from "./cache.js";
+import { IRPCTransport } from "./transport.js";
+import { IRPCData, IRPCHandler, IRPCInit, IRPCInputs, IRPCOutput, IRPCPackageConfig, IRPCPackageInfo, IRPCRequest, IRPCSpec, IRPCSpecStore, IRPCStubStore } from "./types.js";
 
 //#region src/module.d.ts
 
 /**
- * Creates an IRPC module with the given configuration.
- *
- * This function initializes a new IRPC module with a store for tracking RPC calls,
- * a registry for mapping functions to their specifications, and various methods
- * for managing and executing remote procedure calls.
- *
- * @param config - Optional partial configuration for the IRPC module, excluding 'submit' and 'transport'
- * @returns An IRPC factory function with attached utility methods
+ * IRPCPackage represents a package containing multiple IRPC (Isomorphic-RPC) specifications
+ * and their corresponding stubs. It manages the configuration, transport, and execution
+ * of remote procedure calls.
  */
-declare function createModule(config?: Partial<Omit<IRPCModule, 'submit' | 'transport'>>): IRPCFactory;
+declare class IRPCPackage {
+  /**
+   * A map storing all IRPC specifications by their names
+   */
+  specs: IRPCSpecStore;
+  /**
+   * A weak map linking stub functions to their corresponding specifications
+   */
+  stubs: IRPCStubStore;
+  /**
+   * A map storing caches for each IRPC Entry
+   */
+  cache: WeakMap<Function, IRPCCacher>;
+  /**
+   * Configuration object for the IRPC package
+   */
+  config: IRPCPackageConfig;
+  /**
+   * Gets the href URL for this package in the format "name/version"
+   */
+  get href(): string;
+  /**
+   * Gets the package information (name, version, and optional description)
+   */
+  get info(): IRPCPackageInfo;
+  /**
+   * Gets the transport mechanism used for remote calls
+   */
+  get transport(): IRPCTransport | undefined;
+  /**
+   * Creates a new IRPCPackage instance
+   * @param config - Optional partial configuration for the package
+   * @throws Error if the package name or version doesn't match the required format
+   */
+  constructor(config?: Partial<IRPCPackageConfig>);
+  /**
+   * Declares a new IRPC specification and creates a corresponding stub function
+   * @param init - The initialization object containing the IRPC specification
+   * @returns A stub function that can be used to call the IRPC
+   * @throws Error if an IRPC with the same name already exists
+   */
+  declare<F, I extends IRPCInputs = IRPCInputs, O extends IRPCOutput = IRPCOutput>(init: IRPCInit<I, O>): F;
+  /**
+   * Resolves and executes an IRPC call based on a request object
+   * @param req - The request containing the IRPC name and arguments
+   * @returns The result of the IRPC execution
+   * @throws Error if the IRPC doesn't exist or doesn't have an implementation
+   */
+  resolve(req: IRPCRequest): Promise<IRPCData>;
+  /**
+   * Associates a handler function with a stub function
+   * @param stub - The stub function created by declare()
+   * @param handler - The actual implementation function
+   * @returns This IRPCPackage instance for chaining
+   * @throws Error if the stub or handler is invalid, or if no IRPC exists for the stub
+   */
+  construct<F extends IRPCHandler>(stub: F, handler: F): this;
+  /**
+   * Sets the transport mechanism for this package
+   * @param transport - The transport instance to use for remote calls
+   * @returns This IRPCPackage instance for chaining
+   * @throws Error if the transport is not a valid Transport instance
+   */
+  use(transport: IRPCTransport): this;
+  /**
+   * Retrieves an IRPC specification by name or request object
+   * @param query - Either a string name or an IRPCRequest object
+   * @returns The IRPC specification or undefined if not found
+   */
+  get(query: string | IRPCRequest): IRPCSpec<IRPCInputs, IRPCOutput> | undefined;
+  /**
+   * Updates the package configuration
+   * @param config - Partial configuration object with properties to update
+   * @returns This IRPCPackage instance for chaining
+   * @throws Error if the provided name or version is invalid
+   */
+  configure(config: Partial<IRPCPackageConfig>): this;
+  /**
+   * Invalidates the cache for a specific stub and arguments combination
+   * @param stub - The IRPC stub function whose cache needs to be invalidated
+   * @param args - The arguments array used as cache key
+   */
+  invalidate(stub: IRPCHandler, ...args: IRPCData[]): void;
+}
+/**
+ * Creates a new IRPCPackage instance with the given configuration
+ * @param config - Optional partial configuration for the package
+ * @returns A new IRPCPackage instance
+ */
+declare function createPackage(config?: Partial<IRPCPackageConfig>): IRPCPackage;
 //#endregion
-export { createModule };
+export { IRPCPackage, createPackage };