@nmtjs/protocol 0.12.5 → 0.12.6

package/dist/client/events.d.ts

@@ -0,0 +1,17 @@
+import type { Callback } from '@nmtjs/common';
+export type EventMap = {
+    [K: string]: any[];
+};
+/**
+ * Very simple node-like event emitter wrapper around EventTarget
+ *
+ * @todo add errors and promise rejections handling
+ */
+export declare class EventEmitter<Events extends EventMap = EventMap, EventNames extends Extract<keyof Events, string> = Extract<keyof Events, string>> {
+    #private;
+    static once<T extends EventEmitter, E extends T extends EventEmitter<any, infer Event> ? Event : never>(ee: T, event: E): Promise<unknown>;
+    on<E extends EventNames>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
+    once<E extends EventNames>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
+    off(event: EventNames | (Object & string), listener: Callback): void;
+    emit<E extends EventNames | (Object & string)>(event: E, ...args: E extends EventEmitter ? Events[E] : any[]): boolean;
+}

package/dist/client/events.js

@@ -1,33 +1,29 @@
 /**
-* Very simple node-like event emitter wrapper around EventTarget
-*
-* @todo add errors and promise rejections handling
-*/
+ * Very simple node-like event emitter wrapper around EventTarget
+ *
+ * @todo add errors and promise rejections handling
+ */
 export class EventEmitter {
-	static once(ee, event) {
-		return new Promise((resolve) => ee.once(event, resolve));
-	}
-	#target = new EventTarget();
-	#listeners = new Map();
-	on(event, listener, options) {
-		const wrapper = (event) => listener(...event.detail);
-		this.#listeners.set(listener, wrapper);
-		this.#target.addEventListener(event, wrapper, options);
-		return () => this.#target.removeEventListener(event, wrapper);
-	}
-	once(event, listener, options) {
-		return this.on(event, listener, {
-			...options,
-			once: true
-		});
-	}
-	off(event, listener) {
-		const wrapper = this.#listeners.get(listener);
-		if (wrapper) this.#target.removeEventListener(event, wrapper);
-	}
-	emit(event, ...args) {
-		return this.#target.dispatchEvent(new CustomEvent(event, { detail: args }));
-	}
+    static once(ee, event) {
+        return new Promise((resolve) => ee.once(event, resolve));
+    }
+    #target = new EventTarget();
+    #listeners = new Map();
+    on(event, listener, options) {
+        const wrapper = (event) => listener(...event.detail);
+        this.#listeners.set(listener, wrapper);
+        this.#target.addEventListener(event, wrapper, options);
+        return () => this.#target.removeEventListener(event, wrapper);
+    }
+    once(event, listener, options) {
+        return this.on(event, listener, { ...options, once: true });
+    }
+    off(event, listener) {
+        const wrapper = this.#listeners.get(listener);
+        if (wrapper)
+            this.#target.removeEventListener(event, wrapper);
+    }
+    emit(event, ...args) {
+        return this.#target.dispatchEvent(new CustomEvent(event, { detail: args }));
+    }
 }
-
-//# sourceMappingURL=events.js.map

package/dist/client/format.d.ts

@@ -0,0 +1,21 @@
+import type { DecodeRPCContext, EncodeRPCContext, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
+import type { ProtocolClientBlobStream, ProtocolServerBlobStream } from './stream.ts';
+export type ProtocolRPCEncode = {
+    buffer: ArrayBuffer;
+    streams: Record<number, ProtocolClientBlobStream>;
+};
+export interface BaseClientDecoder {
+    decode(buffer: ArrayBuffer): any;
+    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolServerBlobStream>): ProtocolRPCResponse<ProtocolServerBlobStream>;
+}
+export interface BaseClientEncoder {
+    encode(data: any): ArrayBuffer;
+    encodeRPC(rpc: ProtocolRPC, context: EncodeRPCContext<ProtocolClientBlobStream>): ProtocolRPCEncode;
+}
+export declare abstract class BaseClientFormat implements BaseClientDecoder, BaseClientEncoder {
+    abstract contentType: string;
+    abstract encode(data: any): ArrayBuffer;
+    abstract encodeRPC(rpc: ProtocolRPC, context: EncodeRPCContext<ProtocolClientBlobStream>): ProtocolRPCEncode;
+    abstract decode(buffer: ArrayBuffer): any;
+    abstract decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolServerBlobStream>): ProtocolRPCResponse<ProtocolServerBlobStream>;
+}

package/dist/client/format.js

@@ -1,3 +1,2 @@
-export class BaseClientFormat {}
-
-//# sourceMappingURL=format.js.map
+export class BaseClientFormat {
+}

package/dist/client/index.d.ts

@@ -0,0 +1,5 @@
+export * from './events.ts';
+export * from './format.ts';
+export * from './protocol.ts';
+export * from './stream.ts';
+export * from './types.ts';

package/dist/client/index.js

@@ -1,7 +1,6 @@
 export * from "./events.js";
 export * from "./format.js";
 export * from "./protocol.js";
+// export * from './protocolv1.ts'
 export * from "./stream.js";
 export * from "./types.js";
-
-//# sourceMappingURL=index.js.map

package/dist/client/protocol.d.ts

@@ -0,0 +1,149 @@
+import { type InteractivePromise, type OneOf } from '@nmtjs/common';
+import type { ProtocolBlobMetadata } from '../common/blob.ts';
+import { ClientMessageType, ServerMessageType } from '../common/enums.ts';
+import type { BaseProtocolError, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
+import { EventEmitter } from './events.ts';
+import type { BaseClientFormat } from './format.ts';
+import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream } from './stream.ts';
+export declare class ProtocolError extends Error implements BaseProtocolError {
+    code: string;
+    data?: any;
+    constructor(code: string, message?: string, data?: any);
+    get message(): string;
+    toString(): string;
+    toJSON(): {
+        code: string;
+        message: string;
+        data: any;
+    };
+}
+export declare class ProtocolClientStreams {
+    #private;
+    get(streamId: number): ProtocolClientBlobStream;
+    add(source: ReadableStream, streamId: number, metadata: ProtocolBlobMetadata): ProtocolClientBlobStream;
+    remove(streamId: number): void;
+    abort(streamId: number, error?: Error): void;
+    pull(streamId: number, size: number): Promise<ArrayBuffer | null>;
+    end(streamId: number): void;
+    clear(error?: Error): void;
+}
+export declare class ProtocolServerStreams<T extends ProtocolServerStream = ProtocolServerStream> {
+    #private;
+    has(streamId: number): boolean;
+    get(streamId: number): T;
+    add(streamId: number, stream: T): T;
+    remove(streamId: number): void;
+    abort(streamId: number): void;
+    push(streamId: number, chunk: ArrayBuffer): Promise<void>;
+    end(streamId: number): void;
+    clear(error?: Error): void;
+}
+export type ProtocolTransportEventMap = {
+    connected: [];
+    disconnected: [];
+};
+export interface ProtocolSendMetadata {
+    callId?: number;
+    streamId?: number;
+}
+export declare enum ProtocolTransportStatus {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    CONNECTING = "CONNECTING"
+}
+export declare abstract class ProtocolTransport extends EventEmitter<ProtocolTransportEventMap> {
+    status: ProtocolTransportStatus;
+    abstract connect(auth: any, transformer: ProtocolBaseTransformer): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract call(namespace: string, procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): Promise<ProtocolClientCall>;
+    abstract send(messageType: ClientMessageType, buffer: ArrayBuffer, metadata: ProtocolSendMetadata): Promise<void>;
+}
+export declare class ProtocolBaseTransformer {
+    encodeRPC(namespace: string, procedure: string, payload: any): any;
+    decodeRPC(namespace: string, procedure: string, payload: any): any;
+    decodeRPCChunk(namespace: string, procedure: string, payload: any): any;
+    decodeEvent(namespace: string, event: string, payload: any): any;
+}
+export type ProtocolClientCall = InteractivePromise<any> & Pick<ProtocolRPC, 'namespace' | 'procedure'> & {
+    signal: AbortSignal;
+};
+export type ProtocolBaseClientOptions = {
+    transport: ProtocolTransport;
+    format: BaseClientFormat;
+    transformer?: ProtocolBaseTransformer;
+    timeout?: number;
+};
+export type ProtocolBaseClientCallOptions = {
+    signal?: AbortSignal;
+    timeout: number;
+};
+export declare class BaseProtocol<T extends Record<string, Record<string, any>> = Record<string, Record<string, any>>> extends EventEmitter<{
+    [N in keyof T]: {
+        [E in keyof T[N] as `${Extract<N, string>}/${Extract<E, string>}`]: [
+            payload: T[N][E]
+        ];
+    };
+}[keyof T]> {
+    readonly format: BaseClientFormat;
+    protected readonly clientStreams: ProtocolClientStreams;
+    protected readonly serverStreams: ProtocolServerStreams<ProtocolServerBlobStream>;
+    protected readonly rpcStreams: ProtocolServerStreams;
+    protected readonly calls: Map<number, ProtocolClientCall>;
+    protected callId: number;
+    protected streamId: number;
+    constructor(format: BaseClientFormat);
+    get contentType(): string;
+    handleCallResponse(callId: number, call: ProtocolClientCall, response: OneOf<[
+        {
+            error: BaseProtocolError;
+        },
+        {
+            result: any;
+            stream?: any;
+        }
+    ]>, transformer: ProtocolBaseTransformer): void;
+    handleRpcResponse({ callId, error, result, streams }: ProtocolRPCResponse, transformer: ProtocolBaseTransformer, stream?: ProtocolServerStream): ProtocolClientCall;
+    handleRpcStreamResponse(response: ProtocolRPCResponse, stream: ProtocolServerStream, transformer: ProtocolBaseTransformer): ProtocolClientCall;
+    createCall(namespace: string, procedure: string, options: ProtocolBaseClientCallOptions): InteractivePromise<unknown> & {
+        namespace: string;
+        procedure: string;
+        signal: AbortSignal;
+    };
+    createRpc(namespace: string, procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): {
+        callId: number;
+        call: InteractivePromise<unknown> & {
+            namespace: string;
+            procedure: string;
+            signal: AbortSignal;
+        };
+        streams: Record<number, ProtocolClientBlobStream>;
+        buffer: ArrayBuffer;
+    };
+    pushRpcStream(callId: number, chunk: any): void;
+    endRpcStream(callId: number): void;
+    abortRpcStream(callId: number): void;
+    removeClientStream(streamId: number): void;
+    pullClientStream(streamId: number, size: number): Promise<ArrayBuffer | null>;
+    endClientStream(streamId: number): void;
+    abortClientStream(streamId: number, error?: Error): void;
+    addServerStream(stream: ProtocolServerBlobStream): void;
+    removeServerStream(streamId: number): void;
+    pushServerStream(streamId: number, chunk: ArrayBuffer): Promise<void>;
+    endServerStream(streamId: number): void;
+    abortServerStream(streamId: number, error?: Error): void;
+    emitEvent(namespace: string, event: string, payload: string, transformer: ProtocolBaseTransformer): void;
+}
+export declare class Protocol<T extends Record<string, Record<string, any>> = Record<string, Record<string, any>>> extends BaseProtocol<T> {
+    handleServerMessage(buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.Event](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcResponse](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcStreamResponse](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcStreamChunk](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcStreamEnd](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.RpcStreamAbort](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ServerStreamPush](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ServerStreamEnd](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ServerStreamAbort](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ClientStreamPull](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+    protected [ServerMessageType.ClientStreamAbort](buffer: ArrayBuffer, transport: ProtocolTransport, transformer: ProtocolBaseTransformer): void;
+}