@nmtjs/protocol 0.15.0-beta.35 → 0.15.0-beta.37

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2025 Denys Ilchyshyn
+Copyright (c) 2024 Denis Ilchyshyn
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -6,4 +6,4 @@
 - binary data streaming and event subscriptions
 - contract-based API
 - end-to-end type safety
-- CPU-intensive task execution on separate workers
+- CPU-intensive task execution on separate workers

package/dist/client/events.d.ts

@@ -0,0 +1,15 @@
+import type { Callback } from '@nmtjs/common';
+export type EventMap = {
+    [K: string]: any[];
+};
+/**
+ * Very simple node-like event emitter wrapper around EventTarget
+ */
+export declare class EventEmitter<Events extends EventMap = EventMap, EventName 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 EventName>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
+    once<E extends EventName>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
+    off(event: EventName | (Object & string), listener: Callback): void;
+    emit<E extends EventName | (Object & string)>(event: E, ...args: E extends EventName ? Events[E] : any[]): boolean;
+}

package/dist/client/events.js

@@ -0,0 +1,28 @@
+// TODO: add errors and promise rejections handling
+/**
+ * Very simple node-like event emitter wrapper around EventTarget
+ */
+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, once: false });
+        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 }));
+    }
+}

package/dist/client/format.d.ts

@@ -1,26 +1,21 @@
-import type { ProtocolBlob } from '../common/blob.ts';
-import type { DecodeRPCContext } from '../common/types.ts';
+import type { DecodeRPCContext, EncodeRPCContext, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
 import type { ProtocolClientBlobStream, ProtocolServerBlobStream } from './stream.ts';
-export interface EncodeRPCContext<T = any> {
-    addStream: (blob: ProtocolBlob) => T;
-}
-export type ProtocolRPCEncode = ArrayBufferView;
+export type ProtocolRPCEncode = {
+    buffer: ArrayBuffer;
+    streams: Record<number, ProtocolClientBlobStream>;
+};
 export interface BaseClientDecoder {
-    decode(buffer: ArrayBufferView): unknown;
-    decodeRPC(buffer: ArrayBufferView, context: DecodeRPCContext<(options?: {
-        signal?: AbortSignal;
-    }) => ProtocolServerBlobStream>): unknown;
+    decode(buffer: ArrayBuffer): any;
+    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolServerBlobStream>): ProtocolRPCResponse<ProtocolServerBlobStream>;
 }
 export interface BaseClientEncoder {
-    encode(data: unknown): ArrayBufferView;
-    encodeRPC(data: unknown, context: EncodeRPCContext<ProtocolClientBlobStream>): ProtocolRPCEncode;
+    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: unknown): ArrayBufferView;
-    abstract encodeRPC(data: unknown, context: EncodeRPCContext): ProtocolRPCEncode;
-    abstract decode(buffer: ArrayBufferView): unknown;
-    abstract decodeRPC(buffer: ArrayBufferView, context: DecodeRPCContext<(options?: {
-        signal?: AbortSignal;
-    }) => ProtocolServerBlobStream>): unknown;
+    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

package/dist/client/index.d.ts

@@ -1,7 +1,4 @@
+export * from './events.ts';
 export * from './format.ts';
 export * from './protocol.ts';
 export * from './stream.ts';
-import { ProtocolVersion1 } from './versions/v1.ts';
-export declare const versions: {
-    1: ProtocolVersion1;
-};

package/dist/client/index.js

@@ -1,7 +1,4 @@
-export * from './format.js';
-export * from './protocol.js';
-export * from './stream.js';
-import { ProtocolVersion } from '../common/enums.js';
-import { ProtocolVersion1 } from './versions/v1.js';
-export const versions = { [ProtocolVersion.v1]: new ProtocolVersion1() };
-//# sourceMappingURL=index.js.map
+export * from "./events.js";
+export * from "./format.js";
+export * from "./protocol.js";
+export * from "./stream.js";

package/dist/client/protocol.d.ts

@@ -1,105 +1,10 @@
-import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
-import type { ClientMessageType, ProtocolVersion, ServerMessageType } from '../common/enums.ts';
-import type { BaseProtocolError, EncodeRPCStreams } from '../common/types.ts';
-import type { BaseClientDecoder, BaseClientEncoder } from './format.ts';
-import type { ProtocolClientBlobStream, ProtocolServerBlobStream } from './stream.ts';
-export type MessageContext = {
-    decoder: BaseClientDecoder;
-    encoder: BaseClientEncoder;
-    addClientStream: (blob: ProtocolBlob) => ProtocolClientBlobStream;
-    addServerStream: (streamId: number, metadata: ProtocolBlobMetadata) => (options?: {
-        signal?: AbortSignal;
-    }) => ProtocolServerBlobStream;
-    transport: {
-        send: (buffer: ArrayBufferView) => void;
-    };
-    streamId: () => number;
-};
-export type ClientMessageTypePayload = {
-    [ClientMessageType.Rpc]: {
-        callId: number;
-        procedure: string;
-        payload: any;
-    };
-    [ClientMessageType.RpcAbort]: {
-        callId: number;
-        reason?: string;
-    };
-    [ClientMessageType.RpcPull]: {
-        callId: number;
-    };
-    [ClientMessageType.ClientStreamPush]: {
-        streamId: number;
-        chunk: ArrayBufferView;
-    };
-    [ClientMessageType.ClientStreamEnd]: {
-        streamId: number;
-    };
-    [ClientMessageType.ClientStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-    [ClientMessageType.ServerStreamPull]: {
-        streamId: number;
-        size: number;
-    };
-    [ClientMessageType.ServerStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-};
-export type ServerMessageTypePayload = {
-    [ServerMessageType.RpcResponse]: {
-        callId: number;
-        result?: any;
-        error?: BaseProtocolError;
-        streams?: EncodeRPCStreams;
-    };
-    [ServerMessageType.RpcStreamResponse]: {
-        callId: number;
-        error?: BaseProtocolError;
-    };
-    [ServerMessageType.RpcStreamChunk]: {
-        callId: number;
-        chunk: ArrayBufferView;
-    };
-    [ServerMessageType.RpcStreamEnd]: {
-        callId: number;
-    };
-    [ServerMessageType.RpcStreamAbort]: {
-        callId: number;
-        reason?: string;
-    };
-    [ServerMessageType.ServerStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-    [ServerMessageType.ServerStreamEnd]: {
-        streamId: number;
-    };
-    [ServerMessageType.ServerStreamPush]: {
-        streamId: number;
-        chunk: ArrayBufferView;
-    };
-    [ServerMessageType.ClientStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-    [ServerMessageType.ClientStreamPull]: {
-        streamId: number;
-        size: number;
-    };
-};
-export declare abstract class ProtocolVersionInterface {
-    abstract version: ProtocolVersion;
-    abstract decodeMessage(context: MessageContext, buffer: ArrayBufferView): {
-        [K in keyof ServerMessageTypePayload]: {
-            type: K;
-        } & ServerMessageTypePayload[K];
-    }[keyof ServerMessageTypePayload];
-    abstract encodeMessage<T extends ClientMessageType>(context: MessageContext, messageType: T, payload: ClientMessageTypePayload[T]): any;
-    protected encode(...chunks: (ArrayBuffer | ArrayBufferView)[]): Uint8Array<ArrayBuffer>;
-}
+import type { InteractivePromise, OneOf } from '@nmtjs/common';
+import type { ProtocolBlobMetadata } from '../common/blob.ts';
+import type { BaseProtocolError, ProtocolRPCResponse } from '../common/types.ts';
+import type { BaseClientFormat } from './format.ts';
+import { ClientMessageType, ServerMessageType } from '../common/enums.ts';
+import { EventEmitter } from './events.ts';
+import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream } from './stream.ts';
 export declare class ProtocolError extends Error implements BaseProtocolError {
     code: string;
     data?: any;
@@ -112,3 +17,134 @@ export declare class ProtocolError extends Error implements BaseProtocolError {
         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: [reason: 'server' | 'client' | 'error'];
+};
+export interface ProtocolSendMetadata {
+    callId?: number;
+    streamId?: number;
+}
+export declare enum ProtocolTransportStatus {
+    CONNECTED = "CONNECTED",
+    DISCONNECTED = "DISCONNECTED",
+    CONNECTING = "CONNECTING"
+}
+export declare abstract class ProtocolTransport<Options = unknown> extends EventEmitter<ProtocolTransportEventMap> {
+    protected options?: Options | undefined;
+    status: ProtocolTransportStatus;
+    constructor(options?: Options | undefined);
+    abstract connect(auth: any, transformer: ProtocolBaseTransformer): Promise<void>;
+    abstract disconnect(): Promise<void>;
+    abstract call(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(_procedure: string, payload: any): any;
+    decodeRPC(_procedure: string, payload: any): any;
+    decodeRPCChunk(_procedure: string, payload: any): any;
+    decodeEvent(_event: string, payload: any): any;
+}
+export type ProtocolClientCall = InteractivePromise<any> & {
+    procedure: string;
+    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(procedure: string, options: ProtocolBaseClientCallOptions): InteractivePromise<unknown> & {
+        procedure: string;
+        signal: AbortSignal;
+    };
+    createRpc(procedure: string, payload: any, options: ProtocolBaseClientCallOptions, transformer: ProtocolBaseTransformer): {
+        callId: number;
+        call: InteractivePromise<unknown> & {
+            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(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;
+}