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

package/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Denis Ilchyshyn
+Copyright (c) 2025 Denys 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/format.d.ts

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

package/dist/client/format.js

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

package/dist/client/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/client/format.ts"],"names":[],"mappings":"AA+BA,MAAM,OAAgB,gBAAgB;CAiBrC"}

package/dist/client/index.d.ts

@@ -1,4 +1,7 @@
-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,4 +1,7 @@
-export * from "./events.js";
-export * from "./format.js";
-export * from "./protocol.js";
-export * from "./stream.js";
+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

package/dist/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/client/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAE3B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEnD,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,EAAE,IAAI,gBAAgB,EAAE,EAAE,CAAA"}

package/dist/client/protocol.d.ts

@@ -1,10 +1,105 @@
-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';
+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>;
+}
 export declare class ProtocolError extends Error implements BaseProtocolError {
     code: string;
     data?: any;
@@ -17,134 +112,3 @@ 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;
-}