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

package/dist/server/protocol.js

@@ -1,12 +1,4 @@
-import { defer, isAbortError, throwError } from '@nmtjs/common';
-import { Hook, Scope } from '@nmtjs/core';
-import { concat, decodeNumber, encodeNumber } from "../common/binary.js";
-import { ErrorCode, ServerMessageType } from "../common/enums.js";
-import { isIterableResult } from "./api.js";
-import { Connection, ConnectionContext } from "./connection.js";
-import { ProtocolInjectables } from "./injectables.js";
-import { ProtocolClientStream, ProtocolServerStream } from "./stream.js";
-import { getFormat } from "./utils.js";
+import { concat } from '../common/binary.js';
 export class ProtocolError extends Error {
     code;
     data;
@@ -25,350 +17,9 @@ export class ProtocolError extends Error {
         return { code: this.code, message: this.message, data: this.data };
     }
 }
-export class ProtocolConnections {
-    application;
-    #collection = new Map();
-    constructor(application) {
-        this.application = application;
-    }
-    get(connectionId) {
-        const connection = this.#collection.get(connectionId);
-        if (!connection)
-            throwError('Connection not found');
-        return connection;
-    }
-    async add(transport, options, params) {
-        const connection = new Connection(options);
-        const format = getFormat(this.application.format, params);
-        const container = this.application.container.fork(Scope.Connection);
-        const context = new ConnectionContext(container, format);
-        container.provide(ProtocolInjectables.connection, connection);
-        try {
-            await this.initialize(connection);
-            this.#collection.set(connection.id, { connection, context, transport });
-            return { connection, context };
-        }
-        catch (error) {
-            container.dispose().catch((error) => {
-                this.application.logger.error({ error, connection }, 'Error during disposing connection');
-            });
-            throw error;
-        }
-    }
-    async remove(connectionId) {
-        const { connection, context } = this.get(connectionId);
-        this.application.registry.hooks.call(Hook.OnDisconnect, { concurrent: true }, connection);
-        this.#collection.delete(connectionId);
-        const { rpcs, serverStreams, clientStreams, rpcStreams, container } = context;
-        for (const call of rpcs.values()) {
-            call.abort(new Error('Connection closed'));
-        }
-        for (const stream of clientStreams.values()) {
-            stream.destroy(new Error('Connection closed'));
-        }
-        for (const stream of serverStreams.values()) {
-            stream.destroy(new Error('Connection closed'));
-        }
-        for (const stream of rpcStreams.values()) {
-            stream.abort(new Error('Connection closed'));
-        }
-        try {
-            await container.dispose();
-        }
-        catch (error) {
-            this.application.logger.error({ error, connection }, 'Error during closing connection');
-        }
-    }
-    async initialize(connection) {
-        await this.application.registry.hooks.call(Hook.OnConnect, { concurrent: false }, connection);
-    }
-}
-export class ProtocolClientStreams {
-    connections;
-    constructor(connections) {
-        this.connections = connections;
-    }
-    get(connectionId, streamId) {
-        const { context } = this.connections.get(connectionId);
-        const { clientStreams } = context;
-        const stream = clientStreams.get(streamId) ?? throwError('Stream not found');
-        return stream;
-    }
-    remove(connectionId, streamId) {
-        const { context } = this.connections.get(connectionId);
-        const { clientStreams } = context;
-        clientStreams.get(streamId) || throwError('Stream not found');
-        clientStreams.delete(streamId);
-    }
-    add(connectionId, streamId, metadata, read) {
-        const { context } = this.connections.get(connectionId);
-        const { clientStreams } = context;
-        const stream = new ProtocolClientStream(streamId, metadata, { read });
-        clientStreams.set(streamId, stream);
-        return stream;
-    }
-    push(connectionId, streamId, chunk) {
-        const stream = this.get(connectionId, streamId);
-        stream.write(Buffer.from(chunk));
-    }
-    end(connectionId, streamId) {
-        const stream = this.get(connectionId, streamId);
-        stream.end(null);
-        this.remove(connectionId, streamId);
-    }
-    abort(connectionId, streamId, error = new Error('Aborted')) {
-        const stream = this.get(connectionId, streamId);
-        stream.destroy(error);
-        this.remove(connectionId, streamId);
-    }
-}
-export class ProtocolServerStreams {
-    connections;
-    constructor(connections) {
-        this.connections = connections;
-    }
-    get(connectionId, streamId) {
-        const { context } = this.connections.get(connectionId);
-        const { serverStreams } = context;
-        const stream = serverStreams.get(streamId) ?? throwError('Stream not found');
-        return stream;
-    }
-    add(connectionId, streamId, blob) {
-        const { context } = this.connections.get(connectionId);
-        const { serverStreams } = context;
-        const stream = new ProtocolServerStream(streamId, blob);
-        serverStreams.set(streamId, stream);
-        return stream;
-    }
-    remove(connectionId, streamId) {
-        const { context } = this.connections.get(connectionId);
-        const { serverStreams } = context;
-        serverStreams.has(streamId) || throwError('Stream not found');
-        serverStreams.delete(streamId);
-    }
-    pull(connectionId, streamId) {
-        const stream = this.get(connectionId, streamId);
-        stream.resume();
-    }
-    abort(connectionId, streamId, error = new Error('Aborted')) {
-        const stream = this.get(connectionId, streamId);
-        stream.destroy(error);
-        this.remove(connectionId, streamId);
-    }
-}
-export class Protocol {
-    application;
-    options;
-    #connections;
-    #clientStreams;
-    #serverStreams;
-    constructor(application, options) {
-        this.application = application;
-        this.options = options;
-        this.#connections = new ProtocolConnections(this.application);
-        this.#clientStreams = new ProtocolClientStreams(this.#connections);
-        this.#serverStreams = new ProtocolServerStreams(this.#connections);
-    }
-    async call(options) {
-        const { container, connection } = options;
-        try {
-            return await this.application.api.call(options);
-        }
-        catch (error) {
-            if (error instanceof ProtocolError === false) {
-                this.application.logger.error({ error, connection }, 'Error during RPC call');
-                throw new ProtocolError(ErrorCode.InternalServerError, 'Internal server error');
-            }
-            throw error;
-        }
-        finally {
-            container.dispose().catch((error) => {
-                this.application.logger.error({ error, connection }, "Error during disposing connection's container");
-            });
-        }
-    }
-    async rpc(connectionId, rpc, params = {}) {
-        const { connection, context, transport } = this.#connections.get(connectionId);
-        const { rpcs, format } = context;
-        const { callId, procedure, payload } = rpc;
-        const abortController = new AbortController();
-        const signal = params.signal
-            ? AbortSignal.any([params.signal, abortController.signal])
-            : abortController.signal;
-        rpcs.set(callId, abortController);
-        const callIdEncoded = encodeNumber(callId, 'Uint32');
-        const container = context.container.fork(Scope.Call);
-        if (params.provides) {
-            for (const [key, value] of params.provides) {
-                container.provide(key, value);
-            }
-        }
-        try {
-            const response = await this.call({
-                connection,
-                container,
-                payload,
-                procedure,
-                signal,
-                validateMetadata: params.validateMetadata,
-            });
-            const responseEncoded = format.encoder.encodeRPC({ callId, result: response.output }, {
-                addStream: (blob) => {
-                    const streamId = context.streamId++;
-                    const stream = this.#serverStreams.add(connectionId, streamId, blob);
-                    stream.on('data', (chunk) => {
-                        stream.pause();
-                        const buf = Buffer.from(chunk);
-                        transport.send(connection, ServerMessageType.ServerStreamPush, concat(encodeNumber(streamId, 'Uint32'), buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)), { callId, streamId });
-                    });
-                    stream.on('error', () => {
-                        transport.send(connection, ServerMessageType.ServerStreamAbort, encodeNumber(streamId, 'Uint32'), { callId, streamId });
-                    });
-                    stream.on('end', () => {
-                        transport.send(connection, ServerMessageType.ServerStreamEnd, encodeNumber(streamId, 'Uint32'), { callId, streamId });
-                    });
-                    return stream;
-                },
-                getStream: (id) => {
-                    return this.#serverStreams.get(connectionId, id);
-                },
-            });
-            if (isIterableResult(response)) {
-                transport.send(connection, ServerMessageType.RpcStreamResponse, responseEncoded, { callId });
-                try {
-                    const controller = new AbortController();
-                    context.rpcStreams.set(callId, controller);
-                    const iterable = typeof response.iterable === 'function'
-                        ? await response.iterable(controller.signal)
-                        : response.iterable;
-                    try {
-                        for await (const chunk of iterable) {
-                            controller.signal.throwIfAborted();
-                            const chunkEncoded = format.encoder.encode(chunk);
-                            transport.send(connection, ServerMessageType.RpcStreamChunk, concat(callIdEncoded, chunkEncoded), { callId });
-                        }
-                        transport.send(connection, ServerMessageType.RpcStreamEnd, callIdEncoded, { callId });
-                    }
-                    catch (error) {
-                        // do not re-throw AbortError errors, they are expected
-                        if (!isAbortError(error)) {
-                            throw error;
-                        }
-                    }
-                }
-                catch (error) {
-                    this.application.logger.error(error);
-                    transport.send(connection, ServerMessageType.RpcStreamAbort, callIdEncoded, { callId });
-                }
-                finally {
-                    context.rpcStreams.delete(callId);
-                    response.onFinish && defer(response.onFinish);
-                }
-            }
-            else {
-                transport.send(connection, ServerMessageType.RpcResponse, responseEncoded, { callId });
-            }
-        }
-        catch (error) {
-            const payload = format.encoder.encodeRPC({ callId, error }, {
-                addStream() {
-                    throwError('Cannot handle stream for error response');
-                },
-                getStream() {
-                    throwError('Cannot handle stream for error response');
-                },
-            });
-            transport.send(connection, ServerMessageType.RpcResponse, payload, {
-                error,
-                callId,
-            });
-        }
-        finally {
-            rpcs.delete(callId);
-            container.dispose().catch((error) => {
-                this.application.logger.error({ error, connection }, 'Error during disposing connection');
-            });
-        }
-    }
-    async rpcRaw(connectionId, buffer, params = {}) {
-        const { connection, context, transport } = this.#connections.get(connectionId);
-        const { format } = context;
-        const rpc = format.decoder.decodeRPC(buffer, {
-            addStream: (streamId, callId, metadata) => {
-                return this.#clientStreams.add(connectionId, streamId, metadata, (size) => {
-                    transport.send(connection, ServerMessageType.ClientStreamPull, concat(encodeNumber(streamId, 'Uint32'), encodeNumber(size, 'Uint32')), { callId, streamId });
-                });
-            },
-            getStream: (id) => {
-                return this.#clientStreams.get(connectionId, id);
-            },
-        });
-        return await this.rpc(connectionId, rpc, params);
-    }
-    rpcAbort(connectionId, callId) {
-        const { context } = this.#connections.get(connectionId);
-        const call = context.rpcs.get(callId) ?? throwError('Call not found');
-        call.abort();
-    }
-    rpcAbortRaw(connectionId, buffer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        return this.rpcAbort(connectionId, callId);
-    }
-    rpcStreamAbort(connectionId, callId) {
-        const { context } = this.#connections.get(connectionId);
-        const ab = context.rpcStreams.get(callId) ?? throwError('Call stream not found');
-        ab.abort();
-    }
-    rpcStreamAbortRaw(connectionId, buffer) {
-        const callId = decodeNumber(buffer, 'Uint32');
-        return this.rpcStreamAbort(connectionId, callId);
-    }
-    notify() {
-        throw Error('Unimplemented');
-    }
-    addConnection(transport, options, params) {
-        return this.#connections.add(transport, options, params);
-    }
-    removeConnection(connectionId) {
-        return this.#connections.remove(connectionId);
-    }
-    getConnection(connectionId) {
-        return this.#connections.get(connectionId);
-    }
-    initializeConnection(connection) {
-        return this.#connections.initialize(connection);
-    }
-    getClientStream(connectionId, streamId) {
-        return this.#clientStreams.get(connectionId, streamId);
-    }
-    addClientStream(connectionId, streamId, metadata, read) {
-        return this.#clientStreams.add(connectionId, streamId, metadata, read);
-    }
-    removeClientStream(connectionId, streamId) {
-        return this.#clientStreams.remove(connectionId, streamId);
-    }
-    pushClientStream(connectionId, streamId, chunk) {
-        return this.#clientStreams.push(connectionId, streamId, chunk);
-    }
-    endClientStream(connectionId, streamId) {
-        return this.#clientStreams.end(connectionId, streamId);
-    }
-    abortClientStream(connectionId, streamId, error) {
-        return this.#clientStreams.abort(connectionId, streamId, error);
-    }
-    getServerStream(connectionId, streamId) {
-        return this.#serverStreams.get(connectionId, streamId);
-    }
-    addServerStream(connectionId, streamId, blob) {
-        return this.#serverStreams.add(connectionId, streamId, blob);
-    }
-    removeServerStream(connectionId, streamId) {
-        return this.#serverStreams.remove(connectionId, streamId);
-    }
-    pullServerStream(connectionId, streamId) {
-        return this.#serverStreams.pull(connectionId, streamId);
-    }
-    abortServerStream(connectionId, streamId, error) {
-        return this.#serverStreams.abort(connectionId, streamId, error);
+export class ProtocolVersionInterface {
+    encode(...chunks) {
+        return concat(...chunks);
     }
 }
+//# sourceMappingURL=protocol.js.map

package/dist/server/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/server/protocol.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAE5C,MAAM,OAAO,aAAc,SAAQ,KAAK;IACtC,IAAI,CAAQ;IACZ,IAAI,CAAM;IAEV,YAAY,IAAY,EAAE,OAAgB,EAAE,IAAU,EAAE;QACtD,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;QAChB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAAA,CACjB;IAED,IAAI,OAAO,GAAG;QACZ,OAAO,GAAG,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,OAAO,EAAE,CAAA;IAAA,CACvC;IAED,QAAQ,GAAG;QACT,OAAO,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,EAAE,CAAA;IAAA,CACtC;IAED,MAAM,GAAG;QACP,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAA;IAAA,CACnE;CACF;AAED,MAAM,OAAgB,wBAAwB;IAgBlC,MAAM,CACd,GAAG,MAAyC,EAC3B;QACjB,OAAO,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;IAAA,CACzB;CACF"}

package/dist/server/stream.d.ts

@@ -2,12 +2,17 @@ import type { ReadableOptions } from 'node:stream';
 import { PassThrough } from 'node:stream';
 import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
 export declare class ProtocolClientStream extends PassThrough {
+    #private;
     readonly id: number;
     readonly metadata: ProtocolBlobMetadata;
     constructor(id: number, metadata: ProtocolBlobMetadata, options?: ReadableOptions);
+    _read(size: number): void;
 }
 export declare class ProtocolServerStream extends PassThrough {
+    #private;
     readonly id: number;
     readonly metadata: ProtocolBlobMetadata;
     constructor(id: number, blob: ProtocolBlob);
+    resume(): this;
+    destroy(error?: Error | null): this;
 }

package/dist/server/stream.js

@@ -3,15 +3,26 @@ import { ReadableStream } from 'node:stream/web';
 export class ProtocolClientStream extends PassThrough {
     id;
     metadata;
+    #read;
     constructor(id, metadata, options) {
-        super(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;
+    #source;
+    #piped = false;
     constructor(id, blob) {
         let readable;
         if (blob.source instanceof Readable) {
@@ -25,8 +36,26 @@ export class ProtocolServerStream extends PassThrough {
         }
         super();
         this.pause();
-        readable.pipe(this);
+        this.#source = readable;
+        this.#source.on('error', (error) => {
+            this.destroy(error);
+        });
         this.id = id;
         this.metadata = blob.metadata;
     }
+    resume() {
+        if (!this.#piped) {
+            this.#piped = true;
+            this.#source.pipe(this);
+        }
+        return super.resume();
+    }
+    destroy(error) {
+        if (!this.#piped) {
+            this.#piped = true;
+        }
+        this.#source.destroy?.(error ?? undefined);
+        return super.destroy(error ?? undefined);
+    }
 }
+//# sourceMappingURL=stream.js.map

package/dist/server/stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream.js","sourceRoot":"","sources":["../../src/server/stream.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAIhD,MAAM,OAAO,oBAAqB,SAAQ,WAAW;IAIjC,EAAE;IACF,QAAQ;IAJjB,KAAK,CAA0B;IAExC,YACkB,EAAU,EACV,QAA8B,EAC9C,OAAyB,EACzB;QACA,MAAM,EAAE,IAAI,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,IAAI,EAAE,CAAA;QACvC,KAAK,CAAC,IAAI,CAAC,CAAA;kBALK,EAAE;wBACF,QAAQ;QAKxB,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;IAAA,CAClB;IAEQ,KAAK,CAAC,IAAY,EAAQ;QACjC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QAC7B,CAAC;QACD,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IAAA,CAClB;CACF;AAED,MAAM,OAAO,oBAAqB,SAAQ,WAAW;IACnC,EAAE,CAAQ;IACV,QAAQ,CAAsB;IACrC,OAAO,CAAU;IAC1B,MAAM,GAAG,KAAK,CAAA;IAEd,YAAY,EAAU,EAAE,IAAkB,EAAE;QAC1C,IAAI,QAAkB,CAAA;QAEtB,IAAI,IAAI,CAAC,MAAM,YAAY,QAAQ,EAAE,CAAC;YACpC,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAA;QACxB,CAAC;aAAM,IAAI,IAAI,CAAC,MAAM,YAAY,cAAc,EAAE,CAAC;YACjD,QAAQ,GAAG,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,MAAwB,CAAC,CAAA;QAC5D,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAA;QACxC,CAAC;QAED,KAAK,EAAE,CAAA;QAEP,IAAI,CAAC,KAAK,EAAE,CAAA;QACZ,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAA;QACvB,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC;YAClC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAAA,CACpB,CAAC,CAAA;QAEF,IAAI,CAAC,EAAE,GAAG,EAAE,CAAA;QACZ,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAA;IAAA,CAC9B;IAEQ,MAAM,GAAS;QACtB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;YAClB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACzB,CAAC;QACD,OAAO,KAAK,CAAC,MAAM,EAAE,CAAA;IAAA,CACtB;IAEQ,OAAO,CAAC,KAAoB,EAAE;QACrC,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAA;QACpB,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,SAAS,CAAC,CAAA;QAC1C,OAAO,KAAK,CAAC,OAAO,CAAC,KAAK,IAAI,SAAS,CAAC,CAAA;IAAA,CACzC;CACF"}

package/dist/server/types.d.ts

@@ -1,13 +1,34 @@
-import type { PlainType } from '@nmtjs/type/_plain';
-import type { ProtocolBlobInterface } from '../common/blob.ts';
+import type { PlainType } from '@nmtjs/type';
+import type { ProtocolBlobInterface, ProtocolBlobMetadata } from '../common/blob.ts';
+import type { kBlobKey } from '../common/constants.ts';
+import type { BaseServerDecoder, BaseServerEncoder } from './format.ts';
+import type { ProtocolVersionInterface } from './protocol.ts';
 import type { ProtocolClientStream } from './stream.ts';
-export type InputType<T> = T extends ProtocolBlobInterface ? ProtocolClientStream : T extends {
+export type ClientStreamConsumer = (() => ProtocolClientStream) & {
+    readonly [kBlobKey]: any;
+    readonly metadata: ProtocolBlobMetadata;
+};
+export type MessageContext = {
+    protocol: ProtocolVersionInterface;
+    connectionId: string;
+    streamId: () => number;
+    decoder: BaseServerDecoder;
+    encoder: BaseServerEncoder;
+    addClientStream: (options: {
+        streamId: number;
+        metadata: ProtocolBlobMetadata;
+        callId: number;
+    }) => ClientStreamConsumer;
+    transport: {
+        send?: (connectionId: string, buffer: ArrayBufferView) => boolean | null;
+    };
+};
+export type ResolveFormatParams = {
+    contentType?: string | null;
+    accept?: string | null;
+};
+export type InputType<T> = T extends ProtocolBlobInterface ? ClientStreamConsumer : T extends {
     [PlainType]?: true;
 } ? {
     [K in keyof Omit<T, PlainType>]: InputType<T[K]>;
 } : T;
-export type ProtocolSendMetadata = {
-    streamId?: number;
-    callId?: number;
-    error?: any;
-};

package/dist/server/types.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=types.js.map

package/dist/server/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/server/types.ts"],"names":[],"mappings":""}

package/dist/server/utils.d.ts

@@ -1,15 +1,12 @@
-import type { ProtocolFormat } from './format.ts';
-export type ResolveFormatParams = {
-    contentType?: string | null;
-    acceptType?: string | null;
-};
+import type { ProtocolFormats } from './format.ts';
+import type { ResolveFormatParams } from './types.ts';
 export declare class UnsupportedFormatError extends Error {
 }
 export declare class UnsupportedContentTypeError extends UnsupportedFormatError {
 }
 export declare class UnsupportedAcceptTypeError extends UnsupportedFormatError {
 }
-export declare const getFormat: (format: ProtocolFormat, { acceptType, contentType }: ResolveFormatParams) => {
+export declare const getFormat: (format: ProtocolFormats, { accept, contentType }: ResolveFormatParams) => {
     encoder: import("./format.ts").BaseServerEncoder;
     decoder: import("./format.ts").BaseServerDecoder;
 };

package/dist/server/utils.js

@@ -4,12 +4,13 @@ export class UnsupportedContentTypeError extends UnsupportedFormatError {
 }
 export class UnsupportedAcceptTypeError extends UnsupportedFormatError {
 }
-export const getFormat = (format, { acceptType, contentType }) => {
+export const getFormat = (format, { accept, contentType }) => {
     const encoder = contentType ? format.supportsEncoder(contentType) : undefined;
     if (!encoder)
-        throw new UnsupportedContentTypeError('Unsupported Content-Type');
-    const decoder = acceptType ? format.supportsDecoder(acceptType) : undefined;
+        throw new UnsupportedContentTypeError('Unsupported Content type');
+    const decoder = accept ? format.supportsDecoder(accept) : undefined;
     if (!decoder)
-        throw new UnsupportedAcceptTypeError('Unsupported Accept-Type');
+        throw new UnsupportedAcceptTypeError('Unsupported Accept type');
     return { encoder, decoder };
 };
+//# sourceMappingURL=utils.js.map

package/dist/server/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/server/utils.ts"],"names":[],"mappings":"AAGA,MAAM,OAAO,sBAAuB,SAAQ,KAAK;CAAG;AAEpD,MAAM,OAAO,2BAA4B,SAAQ,sBAAsB;CAAG;AAE1E,MAAM,OAAO,0BAA2B,SAAQ,sBAAsB;CAAG;AAEzE,MAAM,CAAC,MAAM,SAAS,GAAG,CACvB,MAAuB,EACvB,EAAE,MAAM,EAAE,WAAW,EAAuB,EAC5C,EAAE,CAAC;IACH,MAAM,OAAO,GAAG,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IAC7E,IAAI,CAAC,OAAO;QACV,MAAM,IAAI,2BAA2B,CAAC,0BAA0B,CAAC,CAAA;IAEnE,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IACnE,IAAI,CAAC,OAAO;QAAE,MAAM,IAAI,0BAA0B,CAAC,yBAAyB,CAAC,CAAA;IAE7E,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA;AAAA,CAC5B,CAAA"}

package/dist/server/versions/v1.d.ts

@@ -0,0 +1,77 @@
+import type { ServerMessageTypePayload } from '../protocol.ts';
+import type { MessageContext } from '../types.ts';
+import { ClientMessageType, ProtocolVersion, ServerMessageType } from '../../common/enums.ts';
+import { ProtocolVersionInterface } from '../protocol.ts';
+export declare class ProtocolVersion1 extends ProtocolVersionInterface {
+    version: ProtocolVersion;
+    decodeMessage(context: MessageContext, buffer: Buffer): {
+        callId?: undefined;
+        size?: undefined;
+        chunk?: undefined;
+        streamId?: undefined;
+        reason?: undefined;
+        type: ClientMessageType.Rpc;
+        rpc: {
+            callId: number;
+            procedure: string;
+            payload: unknown;
+        };
+    } | {
+        size?: undefined;
+        chunk?: undefined;
+        streamId?: undefined;
+        reason?: undefined;
+        rpc?: undefined;
+        type: ClientMessageType.RpcPull;
+        callId: number;
+    } | {
+        size?: undefined;
+        chunk?: undefined;
+        streamId?: undefined;
+        rpc?: undefined;
+        type: ClientMessageType.RpcAbort;
+        callId: number;
+        reason: string | undefined;
+    } | {
+        callId?: undefined;
+        size?: undefined;
+        chunk?: undefined;
+        rpc?: undefined;
+        type: ClientMessageType.ServerStreamAbort;
+        streamId: number;
+        reason: string | undefined;
+    } | {
+        callId?: undefined;
+        chunk?: undefined;
+        reason?: undefined;
+        rpc?: undefined;
+        type: ClientMessageType.ServerStreamPull;
+        streamId: number;
+        size: number;
+    } | {
+        callId?: undefined;
+        size?: undefined;
+        chunk?: undefined;
+        rpc?: undefined;
+        type: ClientMessageType.ClientStreamAbort;
+        streamId: number;
+        reason: string | undefined;
+    } | {
+        callId?: undefined;
+        size?: undefined;
+        chunk?: undefined;
+        reason?: undefined;
+        rpc?: undefined;
+        type: ClientMessageType.ClientStreamEnd;
+        streamId: number;
+    } | {
+        callId?: undefined;
+        size?: undefined;
+        reason?: undefined;
+        rpc?: undefined;
+        type: ClientMessageType.ClientStreamPush;
+        streamId: number;
+        chunk: Buffer<ArrayBufferLike>;
+    };
+    encodeMessage<T extends ServerMessageType>(context: MessageContext, messageType: T, payload: ServerMessageTypePayload[T]): ArrayBufferView<ArrayBufferLike>;
+}