@gati-framework/runtime/dist/module-rpc.d.ts

Gati runtime execution engine for running handler-based applications

/**
 * @module runtime/module-rpc
 * @description Module RPC adapters with automatic serialization, retry logic, and connection pooling
 */
/**
 * RPC call options
 */
export interface RPCCallOptions {
    /**
     * Timeout in milliseconds
     * Default: 5000 (5 seconds)
     */
    timeout?: number;
    /**
     * Maximum number of retry attempts
     * Default: 3
     */
    maxRetries?: number;
    /**
     * Initial retry delay in milliseconds
     * Default: 100
     */
    retryDelay?: number;
    /**
     * Exponential backoff multiplier
     * Default: 2
     */
    backoffMultiplier?: number;
    /**
     * Maximum retry delay in milliseconds
     * Default: 5000
     */
    maxRetryDelay?: number;
    /**
     * Whether to retry on timeout
     * Default: true
     */
    retryOnTimeout?: boolean;
}
/**
 * RPC error types
 */
export declare class RPCError extends Error {
    readonly moduleName: string;
    readonly method: string;
    readonly cause?: Error;
    constructor(message: string, moduleName: string, method: string, cause?: Error);
}
export declare class RPCTimeoutError extends RPCError {
    constructor(moduleName: string, method: string, timeout: number);
}
export declare class RPCSerializationError extends RPCError {
    constructor(moduleName: string, method: string, cause: Error);
}
/**
 * Connection pool for module RPC calls
 */
export declare class ConnectionPool {
    private connections;
    private config;
    constructor(config?: ConnectionPoolConfig);
    /**
     * Get or create a connection for a module
     */
    acquire(moduleName: string): Promise<Connection>;
    /**
     * Release a connection back to the pool
     */
    release(connection: Connection): void;
    /**
     * Create a new connection
     */
    private createConnection;
    /**
     * Wait for a connection to become available
     */
    private waitForConnection;
    /**
     * Close idle connections
     */
    closeIdleConnections(): void;
    /**
     * Close all connections for a module
     */
    closeModule(moduleName: string): void;
    /**
     * Close all connections
     */
    closeAll(): void;
    /**
     * Get pool statistics
     */
    getStatistics(): Map<string, PoolStats>;
}
/**
 * Connection pool configuration
 */
export interface ConnectionPoolConfig {
    /**
     * Maximum number of connections per module
     * Default: 10
     */
    maxConnections?: number;
    /**
     * Minimum number of connections to maintain
     * Default: 1
     */
    minConnections?: number;
    /**
     * Idle timeout in milliseconds
     * Default: 60000 (1 minute)
     */
    idleTimeout?: number;
    /**
     * Connection timeout in milliseconds
     * Default: 5000 (5 seconds)
     */
    connectionTimeout?: number;
}
/**
 * Connection interface
 */
export interface Connection {
    id: string;
    moduleName: string;
    inUse: boolean;
    closed: boolean;
    createdAt: number;
    lastUsed: number;
}
/**
 * Pool statistics
 */
export interface PoolStats {
    total: number;
    inUse: number;
    idle: number;
    closed: number;
}
/**
 * Module RPC client with automatic serialization, retry logic, and connection pooling
 */
export declare class ModuleRPCClient<T = unknown> {
    private moduleName;
    private moduleExports;
    private pool;
    private defaultOptions;
    constructor(moduleName: string, moduleExports: T, pool?: ConnectionPool, options?: RPCCallOptions);
    /**
     * Call a module method with automatic serialization, retry, and timeout
     */
    call<TResult = unknown>(method: string, args?: unknown[], options?: RPCCallOptions): Promise<TResult>;
    /**
     * Execute a single RPC call
     */
    private executeCall;
    /**
     * Execute a promise with timeout
     */
    private withTimeout;
    /**
     * Serialize arguments for RPC call
     */
    private serialize;
    /**
     * Deserialize result from RPC call
     */
    private deserialize;
    /**
     * Create a typed proxy for the module
     */
    createProxy(): T;
}
/**
 * Create a module RPC client
 */
export declare function createModuleRPCClient<T = unknown>(moduleName: string, moduleExports: T, pool?: ConnectionPool, options?: RPCCallOptions): ModuleRPCClient<T>;
/**
 * Create a typed module client proxy
 */
export declare function createModuleClient<T extends object = object>(moduleName: string, moduleExports: T, pool?: ConnectionPool, options?: RPCCallOptions): T;
/**
 * Get or create the global connection pool
 */
export declare function getGlobalConnectionPool(): ConnectionPool;
/**
 * Set the global connection pool
 */
export declare function setGlobalConnectionPool(pool: ConnectionPool): void;
/**
 * Close the global connection pool
 */
export declare function closeGlobalConnectionPool(): void;
//# sourceMappingURL=module-rpc.d.ts.map