[feat] adding typescript to the package

Author: rohittiwari-dev

index.d.ts

@@ -0,0 +1,7 @@
+import RPCClient from "./lib/client";
+import RPCServer from "./lib/server";
+export { createRPCError } from "./lib/util";
+export { createValidator } from "./lib/validator";
+export { NOREPLY } from "./lib/symbols";
+export { RPCError, RPCFormatViolationError, RPCFormationViolationError, RPCFrameworkError, RPCGenericError, RPCInternalError, RPCMessageTypeNotSupportedError, RPCNotImplementedError, RPCNotSupportedError, RPCOccurenceConstraintViolationError, RPCOccurrenceConstraintViolationError, RPCPropertyConstraintViolationError, RPCProtocolError, RPCSecurityError, RPCTypeConstraintViolationError, TimeoutError, UnexpectedHttpResponse, WebsocketUpgradeError, } from "./lib/errors";
+export { RPCServer, RPCClient };

lib/client.d.ts

@@ -0,0 +1,161 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import EventEmitter from "events";
+import { Validator } from "./validator";
+import Queue from "./queue";
+import WebSocket from "ws";
+import { ExponentialStrategy } from "backoff";
+import EventBuffer from "./event-buffer";
+export interface RPC_ClientOptions {
+    identity: string;
+    reconnect: boolean;
+    callTimeoutMs: number;
+    pingIntervalMs: number;
+    deferPingsOnActivity: boolean;
+    respondWithDetailedErrors: boolean;
+    callConcurrency: number;
+    strictMode: boolean | string[];
+    strictModeValidators: Validator[];
+    maxBadMessages: number;
+    protocols: string[];
+    endpoint?: string;
+    password: string | null;
+    wsOpts: any;
+    headers: any;
+    maxReconnects: number;
+    query?: string | Record<string, any>;
+    backoff: {
+        initialDelay: number;
+        maxDelay: number;
+        factor: number;
+        randomisationFactor: number;
+    };
+}
+declare class RPC_Client extends EventEmitter {
+    _identity?: string;
+    _wildcardHandler: Function | null;
+    _handlers: Map<string, Function>;
+    _state: number;
+    _callQueue: Queue;
+    _ws?: WebSocket;
+    _wsAbortController?: AbortController;
+    _keepAliveAbortController?: AbortController;
+    _pendingPingResponse: boolean;
+    _lastPingTime: number;
+    _closePromise?: Promise<{
+        code: number;
+        reason: string;
+    }>;
+    _protocolOptions: string[];
+    _protocol?: string;
+    _strictProtocols: string[];
+    _strictValidators?: Map<string, Validator>;
+    _pendingCalls: Map<string, Record<string, any>>;
+    _pendingResponses: Map<string, {
+        abort: {
+            (reason?: any): void;
+            (reason?: any): void;
+        };
+        promise: Promise<any>;
+    }>;
+    _outboundMsgBuffer: string[];
+    _connectedOnce: boolean;
+    _backoffStrategy?: ExponentialStrategy;
+    _badMessagesCount: number;
+    _reconnectAttempt: number;
+    _options: RPC_ClientOptions;
+    _connectionUrl: string;
+    _connectPromise: Promise<{
+        response: any;
+    }>;
+    _nextPingTimeout: NodeJS.Timeout;
+    static OPEN: number;
+    static CONNECTING: number;
+    static CLOSING: number;
+    static CLOSED: number;
+    constructor({ ...options }: RPC_ClientOptions);
+    get identity(): string | undefined;
+    get protocol(): string | undefined;
+    get state(): number;
+    reconfigure(options: RPC_ClientOptions): void;
+    /**
+     * Attempt to connect to the RPCServer.
+     * @returns {Promise<undefined>} Resolves when connected, rejects on failure
+     */
+    connect(): Promise<any>;
+    _keepAlive(): Promise<void>;
+    _tryReconnect(): Promise<void>;
+    _beginConnect(): Promise<{
+        response: any;
+    }>;
+    /**
+     * Start consuming from a WebSocket
+     * @param {WebSocket} ws - A WebSocket instance
+     * @param {EventBuffer} leadMsgBuffer - A buffer which traps all 'message' events
+     */
+    _attachWebsocket(ws: WebSocket, leadMsgBuffer?: EventBuffer): void;
+    _handleDisconnect({ code, reason }: {
+        code: number;
+        reason: Buffer;
+    }): void;
+    _rejectPendingCalls(abortReason: string): void;
+    /**
+     * Call a method on a remote RPCClient or RPCServerClient.
+     * @param {string} method - The RPC method to call.
+     * @param {*} params - A value to be passed as params to the remote handler.
+     * @param {Object} options - Call options
+     * @param {number} options.callTimeoutMs - Call timeout (in milliseconds)
+     * @param {AbortSignal} options.signal - AbortSignal to cancel the call.
+     * @param {boolean} options.noReply - If set to true, the call will return immediately.
+     * @returns Promise<*> - Response value from the remote handler.
+     */
+    call(method: any, params?: any, options?: Record<string, any>): Promise<unknown>;
+    _call(method: any, params: any, options?: Record<string, any>): Promise<any>;
+    /**
+     * Closes the RPCClient.
+     * @param {Object} options - Close options
+     * @param {number} options.code - The websocket CloseEvent code.
+     * @param {string} options.reason - The websocket CloseEvent reason.
+     * @param {boolean} options.awaitPending - Wait for in-flight calls & responses to complete before closing.
+     * @param {boolean} options.force - Terminate websocket immediately without passing code, reason, or waiting.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code CloseEvent codes}
+     * @returns Promise<Object> - The CloseEvent (code & reason) for closure. May be different from requested code & reason.
+     */
+    close({ code, reason, awaitPending, force, }: {
+        code?: number;
+        reason?: string;
+        awaitPending?: any;
+        force?: any;
+    }): Promise<{
+        code: number | undefined;
+        reason: string | undefined;
+    } | undefined>;
+    _awaitUntilPendingSettled(): Promise<PromiseSettledResult<any>[]>;
+    _deferNextPing(): void;
+    _onMessage(buffer: Buffer): void;
+    _onCall(msgId: string, method: string, params: any): Promise<void>;
+    _onCallResult(msgId: string, result: any): any;
+    _onCallError(msgId: string, errorCode: string, errorDescription: string, errorDetails: Record<string, any>): void;
+    /**
+     * Send a message to the RPCServer. While socket is connecting, the message is queued and send when open.
+     * @param {Buffer|String} message - String to send via websocket
+     */
+    sendRaw(message: string): void;
+    /**
+     *
+     * @param {string} [method] - The name of the handled method.
+     */
+    removeHandler(method: string): void;
+    removeAllHandlers(): void;
+    /**
+     *
+     * @param {string} [method] - The name of the RPC method to handle.
+     * @param {Function} handler - A function that can handle incoming calls for this method.
+     */
+    handle(method: string | Function, handler?: ({ params, signal }: {
+        params: any;
+        signal: any;
+    }) => void): void;
+}
+export default RPC_Client;

lib/errors.d.ts

@@ -0,0 +1,92 @@
+export declare class TimeoutError extends Error {
+}
+export declare class UnexpectedHttpResponse extends Error {
+    code: any;
+    request: any;
+    response: any;
+}
+export declare class RPCError extends Error {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCGenericError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCNotImplementedError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCNotSupportedError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCInternalError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCProtocolError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCSecurityError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCFormatViolationError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCFormationViolationError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCPropertyConstraintViolationError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCOccurenceConstraintViolationError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCOccurrenceConstraintViolationError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCTypeConstraintViolationError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCMessageTypeNotSupportedError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class RPCFrameworkError extends RPCError {
+    rpcErrorMessage: string;
+    rpcErrorCode: string;
+}
+export declare class WebsocketUpgradeError extends Error {
+    code: any;
+    constructor(code: any, message: string | undefined);
+}
+declare const _default: {
+    WebsocketUpgradeError: typeof WebsocketUpgradeError;
+    TimeoutError: typeof TimeoutError;
+    UnexpectedHttpResponse: typeof UnexpectedHttpResponse;
+    RPCError: typeof RPCError;
+    RPCGenericError: typeof RPCGenericError;
+    RPCNotImplementedError: typeof RPCNotImplementedError;
+    RPCNotSupportedError: typeof RPCNotSupportedError;
+    RPCInternalError: typeof RPCInternalError;
+    RPCProtocolError: typeof RPCProtocolError;
+    RPCSecurityError: typeof RPCSecurityError;
+    RPCFormatViolationError: typeof RPCFormatViolationError;
+    RPCFormationViolationError: typeof RPCFormationViolationError;
+    RPCPropertyConstraintViolationError: typeof RPCPropertyConstraintViolationError;
+    RPCOccurrenceConstraintViolationError: typeof RPCOccurrenceConstraintViolationError;
+    RPCOccurenceConstraintViolationError: typeof RPCOccurenceConstraintViolationError;
+    RPCTypeConstraintViolationError: typeof RPCTypeConstraintViolationError;
+    RPCMessageTypeNotSupportedError: typeof RPCMessageTypeNotSupportedError;
+    RPCFrameworkError: typeof RPCFrameworkError;
+};
+export default _default;

lib/event-buffer.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from "stream";
+declare class EventBuffer {
+    _emitter: EventEmitter;
+    _event: string | symbol;
+    _collector: (...args: any) => void;
+    _buffer: any;
+    constructor(emitter: EventEmitter, event: string | symbol);
+    condense(): any;
+}
+export default EventBuffer;

lib/queue.d.ts

@@ -0,0 +1,10 @@
+declare class Queue {
+    _pending: number;
+    _concurrency: number;
+    _queue: any[];
+    constructor();
+    setConcurrency(concurrency: number): void;
+    push(fn: any): Promise<unknown>;
+    _next(): Promise<false | undefined>;
+}
+export default Queue;

lib/server.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage, Server } from "http";
+import { ServerOptions, WebSocket, WebSocketServer } from "ws";
+import { EventEmitter } from "stream";
+import { Validator } from "./validator";
+import RpcServerClient, { IHandshakeInterface } from "./serverClient";
+import { Socket } from "net";
+interface IOccpServiceOptions {
+    wssOptions?: ServerOptions;
+    protocols?: string[];
+    callTimeoutMs?: number;
+    pingIntervalMs?: number;
+    deferPingsOnActivity?: boolean;
+    respondWithDetailedErrors?: boolean;
+    callConcurrency?: number;
+    maxBadMessages?: number;
+    strictMode?: boolean | string[];
+    strictModeValidators?: Validator[];
+}
+interface TPendingUpgrades {
+    session: Record<string, any>;
+    protocol: string;
+    handshake: IHandshakeInterface;
+}
+declare class RPCServer extends EventEmitter {
+    _httpServerAbortControllers: Set<AbortController>;
+    _state: number;
+    _clients: Set<RpcServerClient>;
+    _pendingUpgrades: WeakMap<IncomingMessage, TPendingUpgrades>;
+    _options: IOccpServiceOptions;
+    _wss: WebSocketServer;
+    _strictValidators: Map<string, Validator>;
+    authCallback: (accept: (session?: Record<string, any>, protocol?: string | false) => void, reject: (code: number, message: string) => void, handshake: IHandshakeInterface, signal: AbortSignal) => void;
+    constructor({ ...options }: IOccpServiceOptions, _callback?: () => void);
+    reconfigure(options: any): void;
+    _onConnection(websocket: WebSocket, request: IncomingMessage): Promise<void>;
+    get handleUpgrade(): (request: IncomingMessage, socket: Socket, head: Buffer) => Promise<void>;
+    auth(cb: (accept: (session?: Record<string, any>, protocol?: string | false) => void, reject: (code: number, message: string) => void, handshake: IHandshakeInterface, signal?: AbortSignal) => void): void;
+    listen(port: any, host?: any, options?: Record<string, any>): Promise<Server<typeof IncomingMessage, typeof import("http").ServerResponse>>;
+    close({ code, reason, awaitPending, force }: Record<string, any>): Promise<void>;
+}
+export default RPCServer;

lib/serverClient.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import WebSocket from "ws";
+import RPC_Client, { RPC_ClientOptions } from "./client";
+import { IncomingHttpHeaders, IncomingMessage } from "http";
+export interface IHandshakeInterface {
+    remoteAddress: string | undefined;
+    headers: IncomingHttpHeaders;
+    protocols: Set<string>;
+    endpoint: string;
+    identity: string;
+    query: URLSearchParams;
+    request: IncomingMessage;
+    password: Buffer | undefined;
+}
+declare class RpcServerClient extends RPC_Client {
+    _session: Record<string, any>;
+    _handshake: IHandshakeInterface;
+    constructor({ ...options }: RPC_ClientOptions, { ws, handshake, session, }: {
+        ws: WebSocket;
+        session: Record<string, any>;
+        handshake: IHandshakeInterface;
+    });
+    get handshake(): IHandshakeInterface;
+    get session(): Record<string, any>;
+    connect(): Promise<void>;
+}
+export default RpcServerClient;

lib/standard-validators.d.ts

@@ -0,0 +1,2 @@
+declare const _default: readonly [import("./validator").Validator, import("./validator").Validator];
+export default _default;

lib/symbols.d.ts

@@ -0,0 +1,4 @@
+export declare const NOREPLY: {
+    NOREPLY: symbol;
+};
+export default NOREPLY;

lib/util.d.ts

@@ -0,0 +1,9 @@
+export declare function getPackageIdent(): string;
+export declare function getErrorPlainObject(err: Error): any;
+export declare function createRPCError(type: string, message?: any, details?: {}): Record<string, any>;
+declare const _default: {
+    getErrorPlainObject: typeof getErrorPlainObject;
+    createRPCError: typeof createRPCError;
+    getPackageIdent: typeof getPackageIdent;
+};
+export default _default;

lib/validator.d.ts

@@ -0,0 +1,9 @@
+import Ajv, { AnySchema, AsyncSchema, SchemaObject } from "ajv";
+export declare class Validator {
+    _subprotocol: string;
+    _ajv: Ajv;
+    constructor(subprotocol: string, ajv: Ajv);
+    get subprotocol(): string;
+    validate(schemaId: string, params: any): boolean | Promise<unknown>;
+}
+export declare function createValidator(subprotocol: string, json: boolean | SchemaObject | AsyncSchema | AnySchema[]): Validator;