@nmtjs/protocol 0.14.5 → 0.15.0-beta.2

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/index.js

@@ -1,4 +1,6 @@
-export * from "./events.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() };

package/dist/client/protocol.js

@@ -1,8 +1,9 @@
-import { createPromise } from '@nmtjs/common';
-import { concat, decodeNumber, encodeNumber } from "../common/binary.js";
-import { ClientMessageType, ErrorCode, ServerMessageType, } from "../common/enums.js";
-import { EventEmitter } from "./events.js";
-import { ProtocolClientBlobStream, ProtocolServerBlobStream, ProtocolServerStream, } from "./stream.js";
+import { concat } from "../common/binary.js";
+export class ProtocolVersionInterface {
+    encode(...chunks) {
+        return concat(...chunks);
+    }
+}
 export class ProtocolError extends Error {
     code;
     data;
@@ -21,334 +22,3 @@ export class ProtocolError extends Error {
         return { code: this.code, message: this.message, data: this.data };
     }
 }
-export class ProtocolClientStreams {
-    #collection = new Map();
-    get(streamId) {
-        const stream = this.#collection.get(streamId);
-        if (!stream)
-            throw new Error('Stream not found');
-        return stream;
-    }
-    add(source, streamId, metadata) {
-        const stream = new ProtocolClientBlobStream(source, streamId, metadata);
-        this.#collection.set(streamId, stream);
-        return stream;
-    }
-    remove(streamId) {
-        this.#collection.delete(streamId);
-    }
-    abort(streamId, error) {
-        const stream = this.get(streamId);
-        stream.abort(error);
-        this.remove(streamId);
-    }
-    pull(streamId, size) {
-        const stream = this.get(streamId);
-        return stream.read(size);
-    }
-    end(streamId) {
-        this.get(streamId).end();
-        this.remove(streamId);
-    }
-    clear(error) {
-        if (error) {
-            for (const stream of this.#collection.values()) {
-                stream.abort(error);
-            }
-        }
-        this.#collection.clear();
-    }
-}
-export class ProtocolServerStreams {
-    #collection = new Map();
-    has(streamId) {
-        return this.#collection.has(streamId);
-    }
-    get(streamId) {
-        const stream = this.#collection.get(streamId);
-        if (!stream)
-            throw new Error('Stream not found');
-        return stream;
-    }
-    add(streamId, stream) {
-        this.#collection.set(streamId, stream);
-        return stream;
-    }
-    remove(streamId) {
-        this.#collection.delete(streamId);
-    }
-    abort(streamId) {
-        if (this.has(streamId)) {
-            const stream = this.get(streamId);
-            stream.abort();
-            this.remove(streamId);
-        }
-    }
-    async push(streamId, chunk) {
-        const stream = this.get(streamId);
-        return await stream.push(chunk);
-    }
-    end(streamId) {
-        const stream = this.get(streamId);
-        stream.end();
-        this.remove(streamId);
-    }
-    clear(error) {
-        if (error) {
-            for (const stream of this.#collection.values()) {
-                stream.abort(error);
-            }
-        }
-        this.#collection.clear();
-    }
-}
-export var ProtocolTransportStatus;
-(function (ProtocolTransportStatus) {
-    ProtocolTransportStatus["CONNECTED"] = "CONNECTED";
-    ProtocolTransportStatus["DISCONNECTED"] = "DISCONNECTED";
-    ProtocolTransportStatus["CONNECTING"] = "CONNECTING";
-})(ProtocolTransportStatus || (ProtocolTransportStatus = {}));
-export class ProtocolTransport extends EventEmitter {
-    options;
-    status = ProtocolTransportStatus.DISCONNECTED;
-    constructor(options) {
-        super();
-        this.options = options;
-    }
-}
-export class ProtocolBaseTransformer {
-    encodeRPC(_procedure, payload) {
-        return payload;
-    }
-    decodeRPC(_procedure, payload) {
-        return payload;
-    }
-    decodeRPCChunk(_procedure, payload) {
-        return payload;
-    }
-    decodeEvent(_event, payload) {
-        return payload;
-    }
-}
-export class BaseProtocol extends EventEmitter {
-    format;
-    clientStreams = new ProtocolClientStreams();
-    serverStreams = new ProtocolServerStreams();
-    rpcStreams = new ProtocolServerStreams();
-    calls = new Map();
-    callId = 0;
-    streamId = 0;
-    constructor(format) {
-        super();
-        this.format = format;
-    }
-    get contentType() {
-        return this.format.contentType;
-    }
-    handleCallResponse(callId, call, response, transformer) {
-        if (response.error) {
-            call.reject(new ProtocolError(response.error.code, response.error.message, response.error.data));
-        }
-        else {
-            try {
-                const transformed = transformer.decodeRPC(call.procedure, response.result);
-                if (response.stream)
-                    call.resolve({ result: transformed, stream: response.stream });
-                else
-                    call.resolve(transformed);
-            }
-            catch (error) {
-                call.reject(new ProtocolError(ErrorCode.ClientRequestError, 'Unable to decode response', error));
-            }
-        }
-        this.calls.delete(callId);
-    }
-    handleRpcResponse({ callId, error, result, streams }, transformer, stream) {
-        const call = this.calls.get(callId);
-        if (!call)
-            throw new Error('Call not found');
-        for (const key in streams) {
-            const stream = streams[key];
-            this.serverStreams.add(stream.id, stream);
-        }
-        this.handleCallResponse(callId, call, error ? { error } : { result, stream }, transformer);
-        return call;
-    }
-    handleRpcStreamResponse(response, stream, transformer) {
-        const call = this.handleRpcResponse(response, transformer, stream);
-        this.rpcStreams.add(response.callId, stream);
-        return call;
-    }
-    createCall(procedure, options) {
-        const timeoutSignal = AbortSignal.timeout(options.timeout);
-        const signal = options.signal
-            ? AbortSignal.any([options.signal, timeoutSignal])
-            : timeoutSignal;
-        const call = Object.assign(createPromise(), { procedure, signal });
-        timeoutSignal.addEventListener('abort', () => {
-            const error = new ProtocolError(ErrorCode.RequestTimeout, 'Request timeout');
-            call.reject(error);
-        }, { once: true });
-        return call;
-    }
-    createRpc(procedure, payload, options, transformer) {
-        const callId = ++this.callId;
-        const call = this.createCall(procedure, options);
-        const { buffer, streams } = this.format.encodeRPC({ callId, procedure, payload: transformer.encodeRPC(procedure, payload) }, {
-            addStream: (blob) => {
-                const streamId = ++this.streamId;
-                return this.clientStreams.add(blob.source, streamId, blob.metadata);
-            },
-            getStream: (id) => {
-                const stream = this.clientStreams.get(id);
-                return stream;
-            },
-        });
-        this.calls.set(callId, call);
-        return { callId, call, streams, buffer };
-    }
-    pushRpcStream(callId, chunk) {
-        this.rpcStreams.push(callId, chunk);
-    }
-    endRpcStream(callId) {
-        this.rpcStreams.end(callId);
-    }
-    abortRpcStream(callId) {
-        this.rpcStreams.abort(callId);
-    }
-    removeClientStream(streamId) {
-        this.clientStreams.remove(streamId);
-    }
-    pullClientStream(streamId, size) {
-        return this.clientStreams.pull(streamId, size);
-    }
-    endClientStream(streamId) {
-        this.clientStreams.end(streamId);
-    }
-    abortClientStream(streamId, error) {
-        this.clientStreams.abort(streamId, error);
-    }
-    addServerStream(stream) {
-        this.serverStreams.add(stream.id, stream);
-    }
-    removeServerStream(streamId) {
-        this.serverStreams.remove(streamId);
-    }
-    pushServerStream(streamId, chunk) {
-        return this.serverStreams.push(streamId, chunk);
-    }
-    endServerStream(streamId) {
-        this.serverStreams.end(streamId);
-    }
-    abortServerStream(streamId, _error) {
-        this.serverStreams.abort(streamId);
-    }
-    emitEvent(event, payload, transformer) {
-        const transformed = transformer.decodeEvent(event, payload);
-        this.emit(event, 
-        //@ts-expect-error
-        transformed);
-    }
-}
-export class Protocol extends BaseProtocol {
-    handleServerMessage(buffer, transport, transformer) {
-        const type = decodeNumber(buffer, 'Uint8');
-        const messageBuffer = buffer.slice(Uint8Array.BYTES_PER_ELEMENT);
-        if (type in ServerMessageType) {
-            const messageType = type;
-            if (typeof ServerMessageType[messageType] !== 'undefined') {
-                this[messageType](messageBuffer, transport, transformer);
-            }
-            else {
-                throw new Error(`Unknown message type: ${messageType}`);
-            }
-        }
-    }
-    [ServerMessageType.Event](buffer, _transport, transformer) {
-        const [event, payload] = this.format.decode(buffer);
-        this.emitEvent(event, payload, transformer);
-    }
-    [ServerMessageType.RpcResponse](buffer, transport, transformer) {
-        const response = this.format.decodeRPC(buffer, {
-            addStream: (id, callId, metadata) => {
-                return new ProtocolServerBlobStream(id, metadata, {
-                    start: () => {
-                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
-                    },
-                });
-            },
-            getStream: (id) => {
-                return this.serverStreams.get(id);
-            },
-        });
-        this.handleRpcResponse(response, transformer);
-    }
-    [ServerMessageType.RpcStreamResponse](buffer, transport, transformer) {
-        const response = this.format.decodeRPC(buffer, {
-            addStream: (id, callId, metadata) => {
-                return new ProtocolServerBlobStream(id, metadata, {
-                    start: () => {
-                        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(id, 'Uint32'), { callId, streamId: id });
-                    },
-                });
-            },
-            getStream: (id) => {
-                return this.serverStreams.get(id);
-            },
-        });
-        const stream = new ProtocolServerStream({
-            transform: (chunk, controller) => {
-                const transformed = transformer.decodeRPCChunk(call.procedure, chunk);
-                controller.enqueue(transformed);
-            },
-        });
-        const call = this.handleRpcStreamResponse(response, stream, transformer);
-    }
-    [ServerMessageType.RpcStreamChunk](buffer, _transport, _transformer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
-        const payload = this.format.decode(chunk);
-        this.pushRpcStream(callId, payload);
-    }
-    [ServerMessageType.RpcStreamEnd](buffer, _transport, _transformer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        this.endRpcStream(callId);
-    }
-    [ServerMessageType.RpcStreamAbort](buffer, _transport, _transformer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        this.abortRpcStream(callId);
-    }
-    [ServerMessageType.ServerStreamPush](buffer, transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        const chunk = buffer.slice(Uint32Array.BYTES_PER_ELEMENT);
-        this.pushServerStream(streamId, chunk);
-        transport.send(ClientMessageType.ServerStreamPull, encodeNumber(streamId, 'Uint32'), { streamId });
-    }
-    [ServerMessageType.ServerStreamEnd](buffer, _transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        this.endServerStream(streamId);
-    }
-    [ServerMessageType.ServerStreamAbort](buffer, _transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        this.abortServerStream(streamId);
-    }
-    [ServerMessageType.ClientStreamPull](buffer, transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        const size = decodeNumber(buffer, 'Uint32', Uint32Array.BYTES_PER_ELEMENT);
-        this.pullClientStream(streamId, size).then((chunk) => {
-            if (chunk) {
-                transport.send(ClientMessageType.ClientStreamPush, concat(encodeNumber(streamId, 'Uint32'), chunk), { streamId });
-            }
-            else {
-                transport.send(ClientMessageType.ClientStreamEnd, encodeNumber(streamId, 'Uint32'), { streamId });
-                this.endClientStream(streamId);
-            }
-        }, () => {
-            transport.send(ClientMessageType.ClientStreamAbort, encodeNumber(streamId, 'Uint32'), { streamId });
-        });
-    }
-    [ServerMessageType.ClientStreamAbort](buffer, _transport, _transformer) {
-        const streamId = decodeNumber(buffer, 'Uint32');
-        this.abortClientStream(streamId);
-    }
-}

package/dist/client/stream.js

@@ -1,38 +1,71 @@
-import { defer } from '@nmtjs/common';
-import { concat, encodeText } from "../common/binary.js";
-import { BlobKey } from "../common/blob.js";
-export class ProtocolClientBlobStream extends TransformStream {
+import { DuplexStream } from '@nmtjs/common';
+import { concat, decodeText, encodeText } from "../common/binary.js";
+import { kBlobKey } from "../common/constants.js";
+export class ProtocolClientBlobStream extends DuplexStream {
     source;
     id;
     metadata;
-    [BlobKey] = true;
+    [kBlobKey] = true;
     #queue;
     #reader;
+    #sourceReader = null;
     constructor(source, id, metadata) {
+        let sourceReader = null;
         super({
             start: () => {
-                defer(() => source.pipeThrough(this));
+                sourceReader = source.getReader();
             },
-            transform: (chunk, controller) => {
+            pull: async (controller) => {
+                const { done, value } = await sourceReader.read();
+                if (done) {
+                    controller.close();
+                    return;
+                }
+                const chunk = value;
+                controller.enqueue(chunk instanceof Uint8Array
+                    ? chunk
+                    : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+            },
+            transform: (chunk) => {
                 if (chunk instanceof ArrayBuffer) {
-                    controller.enqueue(chunk);
+                    return new Uint8Array(chunk);
                 }
                 else if (chunk instanceof Uint8Array) {
-                    controller.enqueue(chunk.buffer);
+                    return chunk;
                 }
                 else if (typeof chunk === 'string') {
-                    controller.enqueue(encodeText(chunk));
+                    return encodeText(chunk);
                 }
                 else {
                     throw new Error('Invalid chunk data type. Expected ArrayBuffer, Uint8Array, or string.');
                 }
             },
+            cancel: (reason) => {
+                // Use reader.cancel() if reader exists (stream is locked), otherwise source.cancel()
+                if (sourceReader) {
+                    sourceReader.cancel(reason);
+                }
+                else {
+                    source.cancel(reason);
+                }
+            },
         });
         this.source = source;
         this.id = id;
         this.metadata = metadata;
-        this.#queue = new ArrayBuffer(0);
+        this.#queue = new Uint8Array(0);
         this.#reader = this.readable.getReader();
+        this.#sourceReader = sourceReader;
+    }
+    async abort(reason = 'Stream aborted') {
+        await this.#reader.cancel(reason);
+        this.#reader.releaseLock();
+        this.#sourceReader?.releaseLock();
+    }
+    async end() {
+        // Release the reader lock when the stream is finished
+        this.#reader.releaseLock();
+        this.#sourceReader?.releaseLock();
     }
     async read(size) {
         while (this.#queue.byteLength < size) {
@@ -40,7 +73,7 @@ export class ProtocolClientBlobStream extends TransformStream {
             if (done) {
                 if (this.#queue.byteLength > 0) {
                     const chunk = this.#queue;
-                    this.#queue = new ArrayBuffer(0);
+                    this.#queue = new Uint8Array(0);
                     return chunk;
                 }
                 return null;
@@ -48,51 +81,109 @@ export class ProtocolClientBlobStream extends TransformStream {
             const buffer = value;
             this.#queue = concat(this.#queue, buffer);
         }
-        const chunk = this.#queue.slice(0, size);
-        this.#queue = this.#queue.slice(size);
+        const chunk = this.#queue.subarray(0, size);
+        this.#queue = this.#queue.subarray(size);
         return chunk;
     }
-    abort(error = new Error('Stream aborted')) {
-        this.#reader.cancel(error);
-        this.source.cancel(error);
-    }
-    end() {
-        return this.source.cancel('Stream ended');
-    }
 }
-export class ProtocolServerStream extends TransformStream {
-    #writer;
-    constructor(options) {
-        super(options);
-        this.#writer = this.writable.getWriter();
-    }
+export class ProtocolServerStreamInterface extends DuplexStream {
     async *[Symbol.asyncIterator]() {
         const reader = this.readable.getReader();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (!done)
-                yield value;
-            else
-                break;
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (!done)
+                    yield value;
+                else
+                    break;
+            }
+        }
+        finally {
+            reader.releaseLock();
         }
     }
-    async push(chunk) {
-        await this.#writer.write(chunk);
-    }
-    async end() {
-        await this.#writer.close();
-    }
-    async abort(error = new Error('Stream aborted')) {
-        await this.#writer.abort(error);
+}
+export class ProtocolServerStream extends ProtocolServerStreamInterface {
+}
+export class ProtocolServerRPCStream extends ProtocolServerStream {
+    createAsyncIterable(onDone) {
+        return {
+            [Symbol.asyncIterator]: () => {
+                const iterator = this[Symbol.asyncIterator]();
+                return {
+                    async next() {
+                        const result = await iterator.next();
+                        if (result.done)
+                            onDone();
+                        return result;
+                    },
+                    async return(value) {
+                        onDone();
+                        return iterator.return?.(value) ?? { done: true, value };
+                    },
+                    async throw(error) {
+                        onDone();
+                        return iterator.throw?.(error) ?? Promise.reject(error);
+                    },
+                };
+            },
+        };
     }
 }
-export class ProtocolServerBlobStream extends ProtocolServerStream {
-    id;
+export class ProtocolServerBlobStream extends ProtocolServerStreamInterface {
     metadata;
-    [BlobKey] = true;
-    constructor(id, metadata, options) {
+    [kBlobKey] = true;
+    constructor(metadata, options) {
         super(options);
-        this.id = id;
         this.metadata = metadata;
     }
+    get size() {
+        return this.metadata.size || Number.NaN;
+    }
+    get type() {
+        return this.metadata.type || 'application/octet-stream';
+    }
+    async text() {
+        const chunks = [];
+        for await (const chunk of this)
+            chunks.push(chunk);
+        return decodeText(concat(...chunks));
+    }
+    async bytes() {
+        const chunks = [];
+        for await (const chunk of this)
+            chunks.push(chunk);
+        return concat(...chunks);
+    }
+    async arrayBuffer() {
+        const bytes = await this.bytes();
+        return bytes.buffer;
+    }
+    async json() {
+        const text = await this.text();
+        return JSON.parse(text);
+    }
+    stream() {
+        const transform = new TransformStream({
+            transform: (chunk, controller) => {
+                controller.enqueue(chunk instanceof Uint8Array
+                    ? chunk
+                    : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+            },
+        });
+        this.readable.pipeThrough(transform);
+        return transform.readable;
+    }
+    /**
+     * Throws an error
+     */
+    async formData() {
+        throw new Error('Method not implemented.');
+    }
+    /**
+     * Throws an error
+     */
+    slice() {
+        throw new Error('Unable to slice');
+    }
 }