@nmtjs/protocol 0.15.0-beta.1 → 0.15.0-beta.2

package/dist/client/format.js

@@ -0,0 +1,2 @@
+export class BaseClientFormat {
+}

package/dist/client/index.js

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,24 @@
+import { concat } from "../common/binary.js";
+export class ProtocolVersionInterface {
+    encode(...chunks) {
+        return concat(...chunks);
+    }
+}
+export class ProtocolError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+    get message() {
+        return `${this.code} ${super.message}`;
+    }
+    toString() {
+        return `${this.code} ${this.message}`;
+    }
+    toJSON() {
+        return { code: this.code, message: this.message, data: this.data };
+    }
+}

package/dist/client/stream.js

@@ -0,0 +1,189 @@
+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;
+    [kBlobKey] = true;
+    #queue;
+    #reader;
+    #sourceReader = null;
+    constructor(source, id, metadata) {
+        let sourceReader = null;
+        super({
+            start: () => {
+                sourceReader = source.getReader();
+            },
+            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) {
+                    return new Uint8Array(chunk);
+                }
+                else if (chunk instanceof Uint8Array) {
+                    return chunk;
+                }
+                else if (typeof chunk === 'string') {
+                    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 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) {
+            const { done, value } = await this.#reader.read();
+            if (done) {
+                if (this.#queue.byteLength > 0) {
+                    const chunk = this.#queue;
+                    this.#queue = new Uint8Array(0);
+                    return chunk;
+                }
+                return null;
+            }
+            const buffer = value;
+            this.#queue = concat(this.#queue, buffer);
+        }
+        const chunk = this.#queue.subarray(0, size);
+        this.#queue = this.#queue.subarray(size);
+        return chunk;
+    }
+}
+export class ProtocolServerStreamInterface extends DuplexStream {
+    async *[Symbol.asyncIterator]() {
+        const reader = this.readable.getReader();
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (!done)
+                    yield value;
+                else
+                    break;
+            }
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}
+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 ProtocolServerStreamInterface {
+    metadata;
+    [kBlobKey] = true;
+    constructor(metadata, options) {
+        super(options);
+        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');
+    }
+}

package/dist/client/versions/v1.js

@@ -0,0 +1,127 @@
+import { decodeNumber, decodeText, encodeNumber, encodeText, } from "../../common/binary.js";
+import { ClientMessageType, MessageByteLength, ProtocolVersion, ServerMessageType, } from "../../common/enums.js";
+import { ProtocolVersionInterface } from "../protocol.js";
+export class ProtocolVersion1 extends ProtocolVersionInterface {
+    version = ProtocolVersion.v1;
+    decodeMessage(context, buffer) {
+        const messageType = decodeNumber(buffer, 'Uint8');
+        const payload = buffer.subarray(MessageByteLength.MessageType);
+        switch (messageType) {
+            // case ServerMessageType.Event: {
+            //   const { event, data } = context.decoder.decode(payload)
+            //   return { type: messageType, event, data }
+            // }
+            case ServerMessageType.RpcResponse: {
+                const callId = decodeNumber(payload, 'Uint32');
+                const isError = decodeNumber(payload, 'Uint8', MessageByteLength.CallId);
+                const dataPayload = payload.subarray(MessageByteLength.CallId + MessageByteLength.MessageError);
+                if (isError) {
+                    const error = context.decoder.decode(dataPayload);
+                    return { type: messageType, callId, error };
+                }
+                else {
+                    const result = context.decoder.decodeRPC(dataPayload, {
+                        addStream: (streamId, metadata) => {
+                            return context.addServerStream(streamId, metadata);
+                        },
+                    });
+                    return { type: messageType, callId, result };
+                }
+            }
+            case ServerMessageType.RpcStreamResponse: {
+                const callId = decodeNumber(payload, 'Uint32');
+                const errorPayload = payload.subarray(MessageByteLength.CallId);
+                const error = errorPayload.byteLength > 0
+                    ? context.decoder.decode(errorPayload)
+                    : undefined;
+                return { type: messageType, callId, error };
+            }
+            case ServerMessageType.RpcStreamChunk: {
+                const callId = decodeNumber(payload, 'Uint32');
+                const chunk = payload.subarray(MessageByteLength.CallId);
+                return { type: messageType, callId, chunk };
+            }
+            case ServerMessageType.RpcStreamEnd: {
+                const callId = decodeNumber(payload, 'Uint32');
+                return { type: messageType, callId };
+            }
+            case ServerMessageType.RpcStreamAbort: {
+                const callId = decodeNumber(payload, 'Uint32');
+                const reasonPayload = payload.subarray(MessageByteLength.CallId);
+                const reason = reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined;
+                return { type: messageType, callId, reason };
+            }
+            case ServerMessageType.ClientStreamPull: {
+                const streamId = decodeNumber(payload, 'Uint32');
+                const size = decodeNumber(payload, 'Uint32', MessageByteLength.StreamId);
+                return { type: messageType, streamId, size };
+            }
+            case ServerMessageType.ClientStreamAbort: {
+                const streamId = decodeNumber(payload, 'Uint32');
+                const reasonPayload = payload.subarray(MessageByteLength.StreamId);
+                const reason = reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined;
+                return { type: messageType, streamId, reason };
+            }
+            case ServerMessageType.ServerStreamPush: {
+                const streamId = decodeNumber(payload, 'Uint32');
+                const chunk = payload.subarray(MessageByteLength.StreamId);
+                return { type: messageType, streamId, chunk };
+            }
+            case ServerMessageType.ServerStreamEnd: {
+                const streamId = decodeNumber(payload, 'Uint32');
+                const reasonPayload = payload.subarray(MessageByteLength.StreamId);
+                const reason = reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined;
+                return { type: messageType, streamId, reason };
+            }
+            case ServerMessageType.ServerStreamAbort: {
+                const streamId = decodeNumber(payload, 'Uint32');
+                const reasonPayload = payload.subarray(MessageByteLength.StreamId);
+                const reason = reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined;
+                return { type: messageType, streamId, reason };
+            }
+            default:
+                throw new Error(`Unsupported message type: ${messageType}`);
+        }
+    }
+    encodeMessage(context, messageType, payload) {
+        switch (messageType) {
+            case ClientMessageType.Rpc: {
+                const { callId, procedure, payload: rpcPayload, } = payload;
+                const procedureBuffer = encodeText(procedure);
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'), encodeNumber(procedureBuffer.byteLength, 'Uint16'), procedureBuffer, context.encoder.encodeRPC(rpcPayload, {
+                    addStream: (blob) => context.addClientStream(blob),
+                }));
+            }
+            case ClientMessageType.RpcAbort: {
+                const { callId, reason } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'), reason ? encodeText(reason) : new Uint8Array(0));
+            }
+            case ClientMessageType.RpcPull: {
+                const { callId } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'));
+            }
+            case ClientMessageType.ClientStreamPush: {
+                const { streamId, chunk } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), chunk);
+            }
+            case ClientMessageType.ClientStreamEnd: {
+                const { streamId } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'));
+            }
+            case ClientMessageType.ClientStreamAbort: {
+                const { streamId, reason } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), reason ? encodeText(reason) : new Uint8Array(0));
+            }
+            case ClientMessageType.ServerStreamPull: {
+                const { streamId, size } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), encodeNumber(size, 'Uint32'));
+            }
+            case ClientMessageType.ServerStreamAbort: {
+                const { streamId, reason } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), reason ? encodeText(reason) : new Uint8Array(0));
+            }
+            default:
+                throw new Error(`Unsupported message type: ${messageType}`);
+        }
+    }
+}

package/dist/common/binary.js

@@ -0,0 +1,39 @@
+// TODO: get rid of lib DOM somehow...
+/// <reference lib="dom" />
+const utf8decoder = new TextDecoder();
+const utf8encoder = new TextEncoder();
+export const encodeNumber = (value, type, littleEndian = true) => {
+    const bytesNeeded = globalThis[`${type}Array`].BYTES_PER_ELEMENT;
+    const ab = new ArrayBuffer(bytesNeeded);
+    const dv = new DataView(ab);
+    dv[`set${type}`](0, value, littleEndian);
+    return ab;
+};
+export const decodeNumber = (buffer, type, offset = 0, littleEndian = true) => {
+    const ab = buffer instanceof ArrayBuffer ? buffer : buffer.buffer;
+    const baseOffset = buffer instanceof ArrayBuffer ? 0 : buffer.byteOffset;
+    const view = new DataView(ab);
+    return view[`get${type}`](baseOffset + offset, littleEndian);
+};
+export const encodeText = (text) => utf8encoder.encode(text);
+export const decodeText = (buffer) => utf8decoder.decode(buffer);
+export const concat = (...buffers) => {
+    let totalLength = 0;
+    for (const buffer of buffers)
+        totalLength += buffer.byteLength;
+    const view = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const buffer of buffers) {
+        const chunk = buffer instanceof ArrayBuffer
+            ? new Uint8Array(buffer)
+            : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        view.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return view;
+};
+export const UTF8Transform = () => new TransformStream({
+    transform(chunk, controller) {
+        controller.enqueue(encodeText(chunk));
+    },
+});

package/dist/common/blob.js

@@ -0,0 +1,66 @@
+import { kBlobKey } from "./constants.js";
+export class ProtocolBlob {
+    [kBlobKey] = true;
+    source;
+    metadata;
+    encode;
+    toJSON;
+    constructor({ source, encode, size, type = 'application/octet-stream', filename, }) {
+        if (typeof size !== 'undefined' && size <= 0)
+            throw new Error('Blob size is invalid');
+        this.encode = encode;
+        this.source = source;
+        this.metadata = { size, type, filename };
+        if (encode) {
+            Object.defineProperty(this, 'toJSON', {
+                configurable: false,
+                enumerable: false,
+                writable: false,
+                value: encode,
+            });
+        }
+    }
+    static from(_source, _metadata = {}, _encode) {
+        let source;
+        const metadata = { ..._metadata };
+        if (_source instanceof globalThis.ReadableStream) {
+            source = _source;
+        }
+        else if ('File' in globalThis && _source instanceof globalThis.File) {
+            source = _source.stream();
+            metadata.size ??= _source.size;
+            metadata.filename ??= _source.name;
+        }
+        else if (_source instanceof globalThis.Blob) {
+            source = _source.stream();
+            metadata.size ??= _source.size;
+            metadata.type ??= _source.type;
+        }
+        else if (typeof _source === 'string') {
+            const blob = new Blob([_source]);
+            source = blob.stream();
+            metadata.size ??= blob.size;
+            metadata.type ??= 'text/plain';
+        }
+        else if (globalThis.ArrayBuffer.isView(_source)) {
+            const blob = new Blob([_source]);
+            source = blob.stream();
+            metadata.size ??= blob.size;
+        }
+        else if (_source instanceof globalThis.ArrayBuffer) {
+            const blob = new Blob([_source]);
+            source = blob.stream();
+            metadata.size ??= blob.size;
+        }
+        else {
+            source = _source;
+        }
+        return new ProtocolBlob({
+            source,
+            encode: _encode,
+            size: metadata.size,
+            type: metadata.type,
+            filename: metadata.filename,
+        });
+    }
+}

package/dist/common/constants.js

@@ -0,0 +1 @@
+export const kBlobKey = Symbol.for('neemata:blobKey');

package/dist/common/enums.js

@@ -0,0 +1,58 @@
+export var ProtocolVersion;
+(function (ProtocolVersion) {
+    ProtocolVersion[ProtocolVersion["v1"] = 1] = "v1";
+})(ProtocolVersion || (ProtocolVersion = {}));
+export var ClientMessageType;
+(function (ClientMessageType) {
+    ClientMessageType[ClientMessageType["Rpc"] = 10] = "Rpc";
+    ClientMessageType[ClientMessageType["RpcAbort"] = 11] = "RpcAbort";
+    ClientMessageType[ClientMessageType["RpcPull"] = 12] = "RpcPull";
+    ClientMessageType[ClientMessageType["ClientStreamPush"] = 20] = "ClientStreamPush";
+    ClientMessageType[ClientMessageType["ClientStreamEnd"] = 21] = "ClientStreamEnd";
+    ClientMessageType[ClientMessageType["ClientStreamAbort"] = 22] = "ClientStreamAbort";
+    ClientMessageType[ClientMessageType["ServerStreamAbort"] = 33] = "ServerStreamAbort";
+    ClientMessageType[ClientMessageType["ServerStreamPull"] = 34] = "ServerStreamPull";
+})(ClientMessageType || (ClientMessageType = {}));
+export var ServerMessageType;
+(function (ServerMessageType) {
+    // Event = 1,
+    ServerMessageType[ServerMessageType["RpcResponse"] = 10] = "RpcResponse";
+    ServerMessageType[ServerMessageType["RpcStreamResponse"] = 11] = "RpcStreamResponse";
+    ServerMessageType[ServerMessageType["RpcStreamChunk"] = 12] = "RpcStreamChunk";
+    ServerMessageType[ServerMessageType["RpcStreamEnd"] = 13] = "RpcStreamEnd";
+    ServerMessageType[ServerMessageType["RpcStreamAbort"] = 14] = "RpcStreamAbort";
+    ServerMessageType[ServerMessageType["ServerStreamPush"] = 20] = "ServerStreamPush";
+    ServerMessageType[ServerMessageType["ServerStreamEnd"] = 21] = "ServerStreamEnd";
+    ServerMessageType[ServerMessageType["ServerStreamAbort"] = 22] = "ServerStreamAbort";
+    ServerMessageType[ServerMessageType["ClientStreamAbort"] = 33] = "ClientStreamAbort";
+    ServerMessageType[ServerMessageType["ClientStreamPull"] = 34] = "ClientStreamPull";
+})(ServerMessageType || (ServerMessageType = {}));
+export var ConnectionType;
+(function (ConnectionType) {
+    ConnectionType["Bidirectional"] = "Bidirectional";
+    ConnectionType["Unidirectional"] = "Unidirectional";
+})(ConnectionType || (ConnectionType = {}));
+export var ErrorCode;
+(function (ErrorCode) {
+    ErrorCode["ValidationError"] = "ValidationError";
+    ErrorCode["BadRequest"] = "BadRequest";
+    ErrorCode["NotFound"] = "NotFound";
+    ErrorCode["Forbidden"] = "Forbidden";
+    ErrorCode["Unauthorized"] = "Unauthorized";
+    ErrorCode["InternalServerError"] = "InternalServerError";
+    ErrorCode["NotAcceptable"] = "NotAcceptable";
+    ErrorCode["RequestTimeout"] = "RequestTimeout";
+    ErrorCode["GatewayTimeout"] = "GatewayTimeout";
+    ErrorCode["ServiceUnavailable"] = "ServiceUnavailable";
+    ErrorCode["ClientRequestError"] = "ClientRequestError";
+    ErrorCode["ConnectionError"] = "ConnectionError";
+})(ErrorCode || (ErrorCode = {}));
+export var MessageByteLength;
+(function (MessageByteLength) {
+    MessageByteLength[MessageByteLength["MessageType"] = 1] = "MessageType";
+    MessageByteLength[MessageByteLength["MessageError"] = 1] = "MessageError";
+    MessageByteLength[MessageByteLength["ProcedureLength"] = 2] = "ProcedureLength";
+    MessageByteLength[MessageByteLength["CallId"] = 4] = "CallId";
+    MessageByteLength[MessageByteLength["StreamId"] = 4] = "StreamId";
+    MessageByteLength[MessageByteLength["ChunkSize"] = 4] = "ChunkSize";
+})(MessageByteLength || (MessageByteLength = {}));

package/dist/common/index.js

@@ -0,0 +1,6 @@
+export * from "./binary.js";
+export * from "./blob.js";
+export * from "./constants.js";
+export * from "./enums.js";
+export * from "./types.js";
+export * from "./utils.js";

package/dist/common/types.js

@@ -0,0 +1 @@
+export {};

package/dist/common/utils.js

@@ -0,0 +1,6 @@
+import { kBlobKey } from "./constants.js";
+export const isBlobInterface = (value) => {
+    return (value &&
+        (typeof value === 'object' || typeof value === 'function') &&
+        kBlobKey in value);
+};

package/dist/server/format.js

@@ -0,0 +1,62 @@
+import { match } from '@nmtjs/common';
+export class BaseServerFormat {
+}
+export const parseContentTypes = (types) => {
+    const normalized = types.trim();
+    if (normalized === '*/*')
+        return ['*/*'];
+    return normalized
+        .split(',')
+        .map((t) => t.trim())
+        .map((t) => {
+        const [rawType, ...rest] = t.split(';');
+        const params = new Map(rest.map((p) => p
+            .trim()
+            .split('=')
+            .slice(0, 2)
+            .map((part) => part.trim())));
+        return {
+            type: rawType.trim(),
+            q: params.has('q') ? Number.parseFloat(params.get('q')) : 1,
+        };
+    })
+        .sort((a, b) => {
+        if (a.type === '*/*')
+            return 1;
+        if (b.type === '*/*')
+            return -1;
+        return b.q - a.q;
+    })
+        .map((t) => t.type);
+};
+export class ProtocolFormats {
+    decoders = new Map();
+    encoders = new Map();
+    constructor(formats) {
+        for (const format of formats) {
+            this.encoders.set(format.contentType, format);
+            for (const acceptType of format.accept) {
+                this.decoders.set(acceptType, format);
+            }
+        }
+    }
+    supportsDecoder(contentType, throwIfUnsupported = false) {
+        return this.supports(this.decoders, contentType, throwIfUnsupported);
+    }
+    supportsEncoder(contentType, throwIfUnsupported = false) {
+        return this.supports(this.encoders, contentType, throwIfUnsupported);
+    }
+    supports(formats, contentType, throwIfUnsupported = false) {
+        // TODO: Use node:utils.MIMEType (not implemented yet in Deno and Bun yet)
+        const types = parseContentTypes(contentType);
+        for (const type of types) {
+            for (const [pattern, format] of formats) {
+                if (type === '*/*' || match(type, pattern))
+                    return format;
+            }
+        }
+        if (throwIfUnsupported)
+            throw new Error(`No supported format found: ${contentType}`);
+        return null;
+    }
+}

package/dist/server/index.js

@@ -0,0 +1,8 @@
+export * from "./format.js";
+export * from "./protocol.js";
+export * from "./stream.js";
+export * from "./types.js";
+export * from "./utils.js";
+import { ProtocolVersion } from "../common/enums.js";
+import { ProtocolVersion1 } from "./versions/v1.js";
+export const versions = { [ProtocolVersion.v1]: new ProtocolVersion1() };

package/dist/server/protocol.js

@@ -0,0 +1,24 @@
+import { concat } from "../common/binary.js";
+export class ProtocolError extends Error {
+    code;
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+    }
+    get message() {
+        return `${this.code} ${super.message}`;
+    }
+    toString() {
+        return `${this.code} ${this.message}`;
+    }
+    toJSON() {
+        return { code: this.code, message: this.message, data: this.data };
+    }
+}
+export class ProtocolVersionInterface {
+    encode(...chunks) {
+        return concat(...chunks);
+    }
+}

package/dist/server/stream.js

@@ -0,0 +1,41 @@
+import { PassThrough, Readable } from 'node:stream';
+import { ReadableStream } from 'node:stream/web';
+export class ProtocolClientStream extends PassThrough {
+    id;
+    metadata;
+    #read;
+    constructor(id, metadata, options) {
+        const { read, ...rest } = options ?? {};
+        super(rest);
+        this.id = id;
+        this.metadata = metadata;
+        this.#read = read;
+    }
+    _read(size) {
+        if (this.#read) {
+            this.#read.call(this, size);
+        }
+        super._read(size);
+    }
+}
+export class ProtocolServerStream extends PassThrough {
+    id;
+    metadata;
+    constructor(id, blob) {
+        let readable;
+        if (blob.source instanceof Readable) {
+            readable = blob.source;
+        }
+        else if (blob.source instanceof ReadableStream) {
+            readable = Readable.fromWeb(blob.source);
+        }
+        else {
+            throw new Error('Invalid source type');
+        }
+        super();
+        this.pause();
+        readable.pipe(this);
+        this.id = id;
+        this.metadata = blob.metadata;
+    }
+}

package/dist/server/types.js

@@ -0,0 +1 @@
+export {};

package/dist/server/utils.js

@@ -0,0 +1,15 @@
+export class UnsupportedFormatError extends Error {
+}
+export class UnsupportedContentTypeError extends UnsupportedFormatError {
+}
+export class UnsupportedAcceptTypeError extends UnsupportedFormatError {
+}
+export const getFormat = (format, { accept, contentType }) => {
+    const encoder = contentType ? format.supportsEncoder(contentType) : undefined;
+    if (!encoder)
+        throw new UnsupportedContentTypeError('Unsupported Content type');
+    const decoder = accept ? format.supportsDecoder(accept) : undefined;
+    if (!decoder)
+        throw new UnsupportedAcceptTypeError('Unsupported Accept type');
+    return { encoder, decoder };
+};

package/dist/server/versions/v1.js

@@ -0,0 +1,118 @@
+import { decodeText, encodeNumber, encodeText } from "../../common/binary.js";
+import { ClientMessageType, MessageByteLength, ProtocolVersion, ServerMessageType, } from "../../common/enums.js";
+import { ProtocolVersionInterface } from "../protocol.js";
+export class ProtocolVersion1 extends ProtocolVersionInterface {
+    version = ProtocolVersion.v1;
+    decodeMessage(context, buffer) {
+        const messageType = buffer.readUint8(0);
+        const messagePayload = buffer.subarray(MessageByteLength.MessageType);
+        switch (messageType) {
+            case ClientMessageType.Rpc: {
+                const callId = messagePayload.readUint32LE(0);
+                const procedureLength = messagePayload.readUInt16LE(MessageByteLength.CallId);
+                const procedureOffset = MessageByteLength.CallId + MessageByteLength.ProcedureLength;
+                const procedure = messagePayload.toString('utf-8', procedureOffset, procedureOffset + procedureLength);
+                const formatPayload = messagePayload.subarray(procedureOffset + procedureLength);
+                const payload = context.decoder.decodeRPC(formatPayload, {
+                    addStream: (streamId, metadata) => {
+                        return context.addClientStream({ callId, streamId, metadata });
+                    },
+                });
+                return { type: messageType, rpc: { callId, procedure, payload } };
+            }
+            case ClientMessageType.RpcPull: {
+                const callId = messagePayload.readUInt32LE(0);
+                return { type: messageType, callId };
+            }
+            case ClientMessageType.RpcAbort: {
+                const callId = messagePayload.readUInt32LE(0);
+                const reasonPayload = messagePayload.subarray(MessageByteLength.CallId);
+                const reason = reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined;
+                return { type: messageType, callId, reason };
+            }
+            case ClientMessageType.ServerStreamAbort: {
+                const streamId = messagePayload.readUInt32LE(0);
+                const reasonPayload = messagePayload.subarray(MessageByteLength.StreamId);
+                const reason = reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined;
+                return { type: messageType, streamId, reason };
+            }
+            case ClientMessageType.ServerStreamPull: {
+                const streamId = messagePayload.readUInt32LE(0);
+                const size = messagePayload.readUInt32LE(MessageByteLength.StreamId);
+                return { type: messageType, streamId, size };
+            }
+            case ClientMessageType.ClientStreamAbort: {
+                const streamId = messagePayload.readUInt32LE(0);
+                const reasonPayload = messagePayload.subarray(MessageByteLength.StreamId);
+                const reason = reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined;
+                return { type: messageType, streamId, reason };
+            }
+            case ClientMessageType.ClientStreamEnd: {
+                return { type: messageType, streamId: messagePayload.readUInt32LE(0) };
+            }
+            case ClientMessageType.ClientStreamPush: {
+                const streamId = messagePayload.readUInt32LE(0);
+                const chunk = messagePayload.subarray(MessageByteLength.StreamId);
+                return { type: messageType, streamId, chunk };
+            }
+            default:
+                throw new Error(`Unsupported message type: ${messageType}`);
+        }
+    }
+    encodeMessage(context, messageType, payload) {
+        switch (messageType) {
+            // case ServerMessageType.Event: {
+            //   const { event, data } =
+            //     payload as ServerMessageTypePayload[ServerMessageType.Event]
+            //   return this.encode(
+            //     encodeNumber(messageType, 'Uint8'),
+            //     context.encoder.encode({ event, data }),
+            //   )
+            // }
+            case ServerMessageType.RpcResponse: {
+                const { callId, result, streams, error } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'), encodeNumber(error ? 1 : 0, 'Uint8'), error
+                    ? context.encoder.encode(error)
+                    : context.encoder.encodeRPC(result, streams));
+            }
+            case ServerMessageType.RpcStreamResponse: {
+                const { callId } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'));
+            }
+            case ServerMessageType.RpcStreamChunk: {
+                const { callId, chunk } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'), chunk);
+            }
+            case ServerMessageType.RpcStreamEnd: {
+                const { callId } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'));
+            }
+            case ServerMessageType.RpcStreamAbort: {
+                const { callId, reason } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(callId, 'Uint32'), reason ? encodeText(reason) : Buffer.alloc(0));
+            }
+            case ServerMessageType.ClientStreamPull: {
+                const { size, streamId } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), encodeNumber(size, 'Uint32'));
+            }
+            case ServerMessageType.ClientStreamAbort: {
+                const { streamId, reason } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), reason ? encodeText(reason) : Buffer.alloc(0));
+            }
+            case ServerMessageType.ServerStreamPush: {
+                const { streamId, chunk } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), chunk);
+            }
+            case ServerMessageType.ServerStreamEnd: {
+                const { streamId } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'));
+            }
+            case ServerMessageType.ServerStreamAbort: {
+                const { streamId, reason } = payload;
+                return this.encode(encodeNumber(messageType, 'Uint8'), encodeNumber(streamId, 'Uint32'), reason ? encodeText(reason) : Buffer.alloc(0));
+            }
+            default:
+                throw new Error(`Unsupported message type: ${messageType}`);
+        }
+    }
+}

package/package.json

@@ -8,25 +8,25 @@
   },
   "dependencies": {
     "hookable": "6.0.0-rc.1",
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/contract": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1"
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/contract": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2"
   },
   "devDependencies": {
-    "@nmtjs/core": "0.15.0-beta.1"
+    "@nmtjs/core": "0.15.0-beta.2"
   },
   "peerDependencies": {
-    "@nmtjs/common": "0.15.0-beta.1",
-    "@nmtjs/core": "0.15.0-beta.1",
-    "@nmtjs/type": "0.15.0-beta.1",
-    "@nmtjs/contract": "0.15.0-beta.1"
+    "@nmtjs/core": "0.15.0-beta.2",
+    "@nmtjs/common": "0.15.0-beta.2",
+    "@nmtjs/type": "0.15.0-beta.2",
+    "@nmtjs/contract": "0.15.0-beta.2"
   },
   "files": [
     "dist",
     "LICENSE.md",
     "README.md"
   ],
-  "version": "0.15.0-beta.1",
+  "version": "0.15.0-beta.2",
   "scripts": {
     "clean-build": "rm -rf ./dist",
     "build": "tsc",