@nmtjs/gateway 0.15.0-beta.1 → 0.15.0-beta.3

package/dist/api.d.ts

@@ -0,0 +1,15 @@
+import type { Container, MetadataStore } from '@nmtjs/core';
+import type { GatewayConnection } from './connections.ts';
+export type GatewayApiCallOptions = {
+    connection: GatewayConnection;
+    procedure: string;
+    container: Container;
+    payload: any;
+    signal: AbortSignal;
+    metadata?: (store: MetadataStore) => void;
+};
+export type GatewayApiCallResult = unknown;
+export interface GatewayApi {
+    call(options: GatewayApiCallOptions): Promise<GatewayApiCallResult>;
+}
+export declare function isAsyncIterable(value: GatewayApiCallResult): value is AsyncIterable<unknown> | Iterable<unknown>;

package/dist/api.js

@@ -0,0 +1,4 @@
+export function isAsyncIterable(value) {
+    return Boolean(value && typeof value === 'object' && Symbol.asyncIterator in value);
+}
+//# sourceMappingURL=api.js.map

package/dist/api.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.js","sourceRoot":"","sources":["../src/api.ts"],"names":[],"mappings":"AAmBA,MAAM,UAAU,eAAe,CAC7B,KAA2B;IAE3B,OAAO,OAAO,CACZ,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,IAAI,KAAK,CACpE,CAAA;AACH,CAAC"}

package/dist/connections.d.ts

@@ -0,0 +1,24 @@
+import type { Container } from '@nmtjs/core';
+import type { ConnectionType } from '@nmtjs/protocol';
+import type { BaseServerDecoder, BaseServerEncoder, ProtocolVersionInterface } from '@nmtjs/protocol/server';
+export interface GatewayConnection {
+    readonly id: string;
+    readonly type: ConnectionType;
+    readonly transport: string;
+    readonly protocol: ProtocolVersionInterface;
+    readonly identity: string;
+    readonly container: Container;
+    readonly encoder: BaseServerEncoder;
+    readonly decoder: BaseServerDecoder;
+    readonly abortController: AbortController;
+}
+export declare class ConnectionManager {
+    readonly connections: Map<string, GatewayConnection>;
+    readonly streamIds: Map<string, number>;
+    add(connection: GatewayConnection): void;
+    get(id: string): GatewayConnection;
+    has(id: string): boolean;
+    remove(id: string): void;
+    getAll(): MapIterator<GatewayConnection>;
+    getStreamId(connectionId: string): number;
+}

package/dist/connections.js

@@ -0,0 +1,30 @@
+import { MAX_UINT32, throwError } from '@nmtjs/common';
+export class ConnectionManager {
+    connections = new Map();
+    streamIds = new Map();
+    add(connection) {
+        this.connections.set(connection.id, connection);
+        this.streamIds.set(connection.id, 0);
+    }
+    get(id) {
+        return this.connections.get(id) ?? throwError('Connection not found');
+    }
+    has(id) {
+        return this.connections.has(id);
+    }
+    remove(id) {
+        this.connections.delete(id);
+        this.streamIds.delete(id);
+    }
+    getAll() {
+        return this.connections.values();
+    }
+    getStreamId(connectionId) {
+        let streamId = this.streamIds.get(connectionId);
+        if (streamId >= MAX_UINT32)
+            streamId = 0;
+        this.streamIds.set(connectionId, streamId + 1);
+        return streamId;
+    }
+}
+//# sourceMappingURL=connections.js.map

package/dist/connections.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections.js","sourceRoot":"","sources":["../src/connections.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AActD,MAAM,OAAO,iBAAiB;IACnB,WAAW,GAAG,IAAI,GAAG,EAA6B,CAAA;IAClD,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAA;IAE9C,GAAG,CAAC,UAA6B;QAC/B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,EAAE,UAAU,CAAC,CAAA;QAC/C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAAA;IACtC,CAAC;IAED,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,sBAAsB,CAAC,CAAA;IACvE,CAAC;IAED,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;IACjC,CAAC;IAED,MAAM,CAAC,EAAU;QACf,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;QAC3B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;IAC3B,CAAC;IAED,MAAM;QACJ,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAA;IAClC,CAAC;IAED,WAAW,CAAC,YAAoB;QAC9B,IAAI,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,CAAE,CAAA;QAChD,IAAI,QAAQ,IAAI,UAAU;YAAE,QAAQ,GAAG,CAAC,CAAA;QACxC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,YAAY,EAAE,QAAQ,GAAG,CAAC,CAAC,CAAA;QAC9C,OAAO,QAAQ,CAAA;IACjB,CAAC;CACF"}

package/dist/enums.d.ts

@@ -0,0 +1,13 @@
+export declare enum GatewayHook {
+    Connect = "Connect",
+    Disconnect = "Disconnect"
+}
+export declare enum ProxyableTransportType {
+    WebSocket = "WebSocket",
+    HTTP = "HTTP"
+}
+export declare enum StreamTimeout {
+    Pull = "Pull",
+    Consume = "Consume",
+    Finish = "Finish"
+}

package/dist/enums.js

@@ -0,0 +1,17 @@
+export var GatewayHook;
+(function (GatewayHook) {
+    GatewayHook["Connect"] = "Connect";
+    GatewayHook["Disconnect"] = "Disconnect";
+})(GatewayHook || (GatewayHook = {}));
+export var ProxyableTransportType;
+(function (ProxyableTransportType) {
+    ProxyableTransportType["WebSocket"] = "WebSocket";
+    ProxyableTransportType["HTTP"] = "HTTP";
+})(ProxyableTransportType || (ProxyableTransportType = {}));
+export var StreamTimeout;
+(function (StreamTimeout) {
+    StreamTimeout["Pull"] = "Pull";
+    StreamTimeout["Consume"] = "Consume";
+    StreamTimeout["Finish"] = "Finish";
+})(StreamTimeout || (StreamTimeout = {}));
+//# sourceMappingURL=enums.js.map

package/dist/enums.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.js","sourceRoot":"","sources":["../src/enums.ts"],"names":[],"mappings":"AAAA,MAAM,CAAN,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,kCAAmB,CAAA;IACnB,wCAAyB,CAAA;AAC3B,CAAC,EAHW,WAAW,KAAX,WAAW,QAGtB;AAED,MAAM,CAAN,IAAY,sBAGX;AAHD,WAAY,sBAAsB;IAChC,iDAAuB,CAAA;IACvB,uCAAa,CAAA;AACf,CAAC,EAHW,sBAAsB,KAAtB,sBAAsB,QAGjC;AAED,MAAM,CAAN,IAAY,aAIX;AAJD,WAAY,aAAa;IACvB,8BAAa,CAAA;IACb,oCAAmB,CAAA;IACnB,kCAAiB,CAAA;AACnB,CAAC,EAJW,aAAa,KAAb,aAAa,QAIxB"}

package/dist/gateway.d.ts

@@ -0,0 +1,66 @@
+import type { Container, Hooks, Logger, ResolveInjectableType } from '@nmtjs/core';
+import type { ClientStreamConsumer, ProtocolFormats } from '@nmtjs/protocol/server';
+import type { GatewayApi } from './api.ts';
+import type { GatewayConnection } from './connections.ts';
+import type { ProxyableTransportType } from './enums.ts';
+import type { StreamConfig } from './streams.ts';
+import type { TransportWorker, TransportWorkerParams } from './transport.ts';
+import type { ConnectionIdentity, GatewayRpc, GatewayRpcContext } from './types.ts';
+import { ConnectionManager } from './connections.ts';
+import * as injectables from './injectables.ts';
+import { RpcManager } from './rpcs.ts';
+import { BlobStreamsManager } from './streams.ts';
+export interface GatewayOptions {
+    logger: Logger;
+    container: Container;
+    hooks: Hooks;
+    formats: ProtocolFormats;
+    api: GatewayApi;
+    transports: {
+        [key: string]: {
+            transport: TransportWorker;
+            proxyable?: ProxyableTransportType;
+        };
+    };
+    identity?: ConnectionIdentity;
+    rpcStreamConsumeTimeout?: number;
+    streamTimeouts?: Partial<StreamConfig['timeouts']>;
+}
+export declare class Gateway {
+    readonly logger: Logger;
+    readonly connections: ConnectionManager;
+    readonly rpcs: RpcManager;
+    readonly blobStreams: BlobStreamsManager;
+    options: Required<Omit<GatewayOptions, 'streamTimeouts'> & {
+        streamTimeouts: Required<Exclude<GatewayOptions['streamTimeouts'], undefined>>;
+    }>;
+    constructor(options: GatewayOptions);
+    start(): Promise<{
+        url: string;
+        type: ProxyableTransportType;
+    }[]>;
+    stop(): Promise<void>;
+    send(transport: string, connectionId: string, data: ArrayBufferView): boolean | null | undefined;
+    reload(): Promise<void>;
+    protected createRpcContext(connection: GatewayConnection, messageContext: ReturnType<typeof this.createMessageContext>, logger: Logger, gatewayRpc: GatewayRpc, signal?: AbortSignal): GatewayRpcContext;
+    protected createMessageContext(connection: GatewayConnection, transportKey: string): {
+        connectionId: string;
+        protocol: import("@nmtjs/protocol/server").ProtocolVersionInterface;
+        encoder: import("@nmtjs/protocol/server").BaseServerEncoder;
+        decoder: import("@nmtjs/protocol/server").BaseServerDecoder;
+        transport: TransportWorker<import("@nmtjs/protocol").ConnectionType>;
+        streamId: () => number;
+        addClientStream: ({ streamId, callId, metadata }: {
+            streamId: number;
+            metadata: import("@nmtjs/protocol").ProtocolBlobMetadata;
+            callId: number;
+        }) => ClientStreamConsumer;
+    };
+    protected onConnect(transport: string): TransportWorkerParams['onConnect'];
+    protected onDisconnect(transport: string): TransportWorkerParams['onDisconnect'];
+    protected onMessage(transport: string): TransportWorkerParams['onMessage'];
+    protected onRpc(transport: string): TransportWorkerParams['onRpc'];
+    protected handleRpcMessage(connection: GatewayConnection, context: GatewayRpcContext): Promise<void>;
+    protected closeConnection(connectionId: string): Promise<void>;
+    protected createBlobFunction(context: GatewayRpcContext): ResolveInjectableType<typeof injectables.createBlob>;
+}

package/dist/gateway.js

@@ -0,0 +1,457 @@
+import { randomUUID } from 'node:crypto';
+import { isTypedArray } from 'node:util/types';
+import { anyAbortSignal, isAbortError } from '@nmtjs/common';
+import { createFactoryInjectable, provide, Scope } from '@nmtjs/core';
+import { ClientMessageType, isBlobInterface, kBlobKey, ProtocolBlob, ServerMessageType, } from '@nmtjs/protocol';
+import { getFormat, ProtocolError, versions } from '@nmtjs/protocol/server';
+import { ConnectionManager } from "./connections.js";
+import { StreamTimeout } from "./enums.js";
+import * as injectables from "./injectables.js";
+import { RpcManager } from "./rpcs.js";
+import { BlobStreamsManager } from "./streams.js";
+export class Gateway {
+    logger;
+    connections;
+    rpcs;
+    blobStreams;
+    options;
+    constructor(options) {
+        this.options = {
+            rpcStreamConsumeTimeout: 5000,
+            streamTimeouts: {
+                //@ts-expect-error
+                [StreamTimeout.Pull]: options.streamTimeouts?.[StreamTimeout.Pull] ?? 5000,
+                //@ts-expect-error
+                [StreamTimeout.Consume]: options.streamTimeouts?.[StreamTimeout.Consume] ?? 5000,
+                //@ts-expect-error
+                [StreamTimeout.Finish]: options.streamTimeouts?.[StreamTimeout.Finish] ?? 10000,
+            },
+            ...options,
+            identity: options.identity ??
+                createFactoryInjectable({
+                    dependencies: { connectionId: injectables.connectionId },
+                    factory: ({ connectionId }) => connectionId,
+                }),
+        };
+        this.logger = options.logger.child({}, gatewayLoggerOptions);
+        this.connections = new ConnectionManager();
+        this.rpcs = new RpcManager();
+        this.blobStreams = new BlobStreamsManager({
+            timeouts: this.options.streamTimeouts,
+        });
+    }
+    async start() {
+        const hosts = [];
+        for (const key in this.options.transports) {
+            const { transport, proxyable } = this.options.transports[key];
+            const url = await transport.start({
+                formats: this.options.formats,
+                onConnect: this.onConnect(key),
+                onDisconnect: this.onDisconnect(key),
+                onMessage: this.onMessage(key),
+                onRpc: this.onRpc(key),
+            });
+            this.logger.info(`Transport [${key}] started on [${url}]`);
+            if (proxyable)
+                hosts.push({ url, type: proxyable });
+        }
+        return hosts;
+    }
+    async stop() {
+        // Close all connections
+        for (const connection of this.connections.getAll()) {
+            await this.closeConnection(connection.id);
+        }
+        for (const key in this.options.transports) {
+            const { transport } = this.options.transports[key];
+            await transport.stop({ formats: this.options.formats });
+            this.logger.debug(`Transport [${key}] stopped`);
+        }
+    }
+    send(transport, connectionId, data) {
+        if (transport in this.options.transports) {
+            const transportInstance = this.options.transports[transport].transport;
+            if (transportInstance.send) {
+                return transportInstance.send(connectionId, data);
+            }
+        }
+    }
+    async reload() {
+        for (const connections of this.connections.connections.values()) {
+            await connections.container.dispose();
+        }
+    }
+    createRpcContext(connection, messageContext, logger, gatewayRpc, signal) {
+        const { callId, payload, procedure, metadata } = gatewayRpc;
+        const controller = new AbortController();
+        this.rpcs.set(connection.id, callId, controller);
+        signal = signal
+            ? anyAbortSignal(signal, controller.signal)
+            : controller.signal;
+        const container = connection.container.fork(Scope.Call);
+        const dispose = async () => {
+            const streamAbortReason = 'Stream is not consumed by a user';
+            // Abort streams related to this call
+            this.blobStreams.abortClientCallStreams(connection.id, callId, streamAbortReason);
+            this.rpcs.delete(connection.id, callId);
+            this.rpcs.releasePull(connection.id, callId);
+            await container.dispose();
+        };
+        return {
+            ...messageContext,
+            callId,
+            payload,
+            procedure,
+            metadata,
+            container,
+            signal,
+            logger: logger.child({ callId, procedure }),
+            [Symbol.asyncDispose]: dispose,
+        };
+    }
+    createMessageContext(connection, transportKey) {
+        const transport = this.options.transports[transportKey].transport;
+        const { id: connectionId, protocol, decoder, encoder } = connection;
+        const streamId = this.connections.getStreamId.bind(this.connections, connectionId);
+        return {
+            connectionId,
+            protocol,
+            encoder,
+            decoder,
+            transport,
+            streamId,
+            addClientStream: ({ streamId, callId, metadata }) => {
+                const stream = this.blobStreams.createClientStream(connectionId, callId, streamId, metadata, {
+                    read: (size) => {
+                        transport.send(connectionId, protocol.encodeMessage(this.createMessageContext(connection, transportKey), ServerMessageType.ClientStreamPull, { streamId, size: size || 65535 }));
+                    },
+                });
+                stream.once('error', () => {
+                    this.send(transportKey, connectionId, protocol.encodeMessage(this.createMessageContext(connection, transportKey), ServerMessageType.ClientStreamAbort, { streamId }));
+                });
+                const consume = () => {
+                    this.blobStreams.consumeClientStream(connectionId, callId, streamId);
+                    return stream;
+                };
+                const consumer = Object.defineProperties(consume, {
+                    [kBlobKey]: {
+                        enumerable: false,
+                        configurable: false,
+                        writable: false,
+                        value: true,
+                    },
+                    metadata: {
+                        value: metadata,
+                        enumerable: true,
+                        configurable: false,
+                        writable: false,
+                    },
+                });
+                return consumer;
+            },
+        };
+    }
+    onConnect(transport) {
+        const logger = this.logger.child({ transport });
+        return async (options, ...injections) => {
+            logger.debug('Initiating new connection');
+            const protocol = versions[options.protocolVersion];
+            if (!protocol)
+                throw new Error('Unsupported protocol version');
+            const id = randomUUID();
+            const container = this.options.container.fork(Scope.Connection);
+            try {
+                await container.provide([
+                    provide(injectables.connectionData, options.data),
+                    provide(injectables.connectionId, id),
+                ]);
+                await container.provide(injections);
+                const identity = await container.resolve(this.options.identity);
+                const { accept, contentType, type } = options;
+                const { decoder, encoder } = getFormat(this.options.formats, {
+                    accept,
+                    contentType,
+                });
+                const connection = {
+                    id,
+                    type,
+                    identity,
+                    transport,
+                    protocol,
+                    container,
+                    encoder,
+                    decoder,
+                    abortController: new AbortController(),
+                };
+                this.connections.add(connection);
+                await container.provide(injectables.connectionAbortSignal, connection.abortController.signal);
+                logger.debug({
+                    id,
+                    protocol: options.protocolVersion,
+                    type,
+                    accept,
+                    contentType,
+                    identity,
+                    transportData: options.data,
+                }, 'Connection established');
+                return Object.assign(connection, {
+                    [Symbol.asyncDispose]: async () => {
+                        await this.onDisconnect(transport)(connection.id);
+                    },
+                });
+            }
+            catch (error) {
+                logger.debug({ error }, 'Error establishing connection');
+                container.dispose();
+                throw error;
+            }
+        };
+    }
+    onDisconnect(transport) {
+        const logger = this.logger.child({ transport });
+        return async (connectionId) => {
+            logger.debug({ connectionId }, 'Disconnecting connection');
+            await this.closeConnection(connectionId);
+        };
+    }
+    onMessage(transport) {
+        const _logger = this.logger.child({ transport });
+        return async ({ connectionId, data }, ...injections) => {
+            const logger = _logger.child({ connectionId });
+            try {
+                const connection = this.connections.get(connectionId);
+                const messageContext = this.createMessageContext(connection, transport);
+                const message = connection.protocol.decodeMessage(messageContext, Buffer.from(data));
+                logger.trace(message, 'Received message');
+                switch (message.type) {
+                    case ClientMessageType.Rpc: {
+                        const rpcContext = this.createRpcContext(connection, messageContext, logger, message.rpc);
+                        try {
+                            await rpcContext.container.provide([
+                                ...injections,
+                                provide(injectables.createBlob, this.createBlobFunction(rpcContext)),
+                            ]);
+                            await this.handleRpcMessage(connection, rpcContext);
+                        }
+                        finally {
+                            await rpcContext[Symbol.asyncDispose]();
+                        }
+                        break;
+                    }
+                    case ClientMessageType.RpcPull: {
+                        this.rpcs.releasePull(connectionId, message.callId);
+                        break;
+                    }
+                    case ClientMessageType.RpcAbort: {
+                        this.rpcs.abort(connectionId, message.callId);
+                        break;
+                    }
+                    case ClientMessageType.ClientStreamAbort: {
+                        this.blobStreams.abortClientStream(connectionId, message.streamId, message.reason);
+                        break;
+                    }
+                    case ClientMessageType.ClientStreamPush: {
+                        this.blobStreams.pushToClientStream(connectionId, message.streamId, message.chunk);
+                        break;
+                    }
+                    case ClientMessageType.ClientStreamEnd: {
+                        this.blobStreams.endClientStream(connectionId, message.streamId);
+                        break;
+                    }
+                    case ClientMessageType.ServerStreamAbort: {
+                        this.blobStreams.abortServerStream(connectionId, message.streamId, message.reason);
+                        break;
+                    }
+                    case ClientMessageType.ServerStreamPull: {
+                        this.blobStreams.pullServerStream(connectionId, message.streamId);
+                        break;
+                    }
+                    default:
+                        throw new Error('Unknown message type');
+                }
+            }
+            catch (error) {
+                logger.trace({ error }, 'Error handling message');
+                throw error;
+            }
+        };
+    }
+    onRpc(transport) {
+        const _logger = this.logger.child({ transport });
+        return async (connection, rpc, signal, ...injections) => {
+            const logger = _logger.child({ connectionId: connection.id });
+            const messageContext = this.createMessageContext(connection, connection.transport);
+            const rpcContext = this.createRpcContext(connection, messageContext, logger, rpc, signal);
+            try {
+                await rpcContext.container.provide([
+                    ...injections,
+                    provide(injectables.rpcAbortSignal, signal),
+                    provide(injectables.createBlob, this.createBlobFunction(rpcContext)),
+                ]);
+                const result = await this.options.api.call({
+                    connection,
+                    payload: rpc.payload,
+                    procedure: rpc.procedure,
+                    metadata: rpc.metadata,
+                    container: rpcContext.container,
+                    signal: rpcContext.signal,
+                });
+                if (typeof result === 'function') {
+                    return result(async () => {
+                        await rpcContext[Symbol.asyncDispose]();
+                    });
+                }
+                else {
+                    await rpcContext[Symbol.asyncDispose]();
+                    return result;
+                }
+            }
+            catch (error) {
+                await rpcContext[Symbol.asyncDispose]();
+                throw error;
+            }
+        };
+    }
+    async handleRpcMessage(connection, context) {
+        const { container, connectionId, transport, protocol, signal, callId, procedure, payload, encoder, } = context;
+        try {
+            await container.provide(injectables.rpcAbortSignal, signal);
+            const response = await this.options.api.call({
+                connection: connection,
+                container,
+                payload,
+                procedure,
+                signal,
+            });
+            if (typeof response === 'function') {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamResponse, {
+                    callId,
+                }));
+                try {
+                    const consumeTimeoutSignal = this.options.rpcStreamConsumeTimeout
+                        ? AbortSignal.timeout(this.options.rpcStreamConsumeTimeout)
+                        : undefined;
+                    const streamSignal = consumeTimeoutSignal
+                        ? anyAbortSignal(signal, consumeTimeoutSignal)
+                        : signal;
+                    await this.rpcs.awaitPull(connectionId, callId, streamSignal);
+                    for await (const chunk of response()) {
+                        signal.throwIfAborted();
+                        const chunkEncoded = encoder.encode(chunk);
+                        transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamChunk, { callId, chunk: chunkEncoded }));
+                        await this.rpcs.awaitPull(connectionId, callId);
+                    }
+                    transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamEnd, {
+                        callId,
+                    }));
+                }
+                catch (error) {
+                    if (!isAbortError(error)) {
+                        this.logger.error(error);
+                    }
+                    transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcStreamAbort, {
+                        callId,
+                    }));
+                }
+            }
+            else {
+                const streams = this.blobStreams.getServerStreamsMetadata(connectionId, callId);
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcResponse, {
+                    callId,
+                    result: response,
+                    streams,
+                    error: null,
+                }));
+            }
+        }
+        catch (error) {
+            transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.RpcResponse, {
+                callId,
+                result: null,
+                streams: {},
+                error,
+            }));
+            const level = error instanceof ProtocolError ? 'trace' : 'error';
+            this.logger[level](error);
+        }
+    }
+    async closeConnection(connectionId) {
+        if (this.connections.has(connectionId)) {
+            const connection = this.connections.get(connectionId);
+            connection.abortController.abort();
+            connection.container.dispose();
+        }
+        this.rpcs.close(connectionId);
+        this.blobStreams.cleanupConnection(connectionId);
+        this.connections.remove(connectionId);
+    }
+    createBlobFunction(context) {
+        const { streamId: getStreamId, transport, protocol, connectionId, callId, encoder, } = context;
+        return (source, metadata) => {
+            const streamId = getStreamId();
+            const blob = ProtocolBlob.from(source, metadata, () => {
+                return encoder.encodeBlob(streamId);
+            });
+            const stream = this.blobStreams.createServerStream(connectionId, callId, streamId, blob);
+            stream.on('data', (chunk) => {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.ServerStreamPush, {
+                    streamId: streamId,
+                    chunk: Buffer.from(chunk),
+                }));
+            });
+            stream.on('error', (error) => {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.ServerStreamAbort, {
+                    streamId: streamId,
+                    reason: error.message,
+                }));
+            });
+            stream.once('finish', () => {
+                transport.send(connectionId, protocol.encodeMessage(context, ServerMessageType.ServerStreamEnd, {
+                    streamId: streamId,
+                }));
+            });
+            stream.once('close', () => {
+                this.blobStreams.removeServerStream(connectionId, streamId);
+            });
+            return blob;
+        };
+    }
+}
+const gatewayLoggerOptions = {
+    serializers: {
+        chunk: (chunk) => isTypedArray(chunk) ? `<Buffer length=${chunk.byteLength}>` : chunk,
+        payload: (payload) => {
+            function traverseObject(obj) {
+                if (Array.isArray(obj)) {
+                    return obj.map(traverseObject);
+                }
+                else if (isTypedArray(obj)) {
+                    return `<${obj.constructor.name} length=${obj.byteLength}>`;
+                }
+                else if (typeof obj === 'object' && obj !== null) {
+                    const result = {};
+                    for (const [key, value] of Object.entries(obj)) {
+                        result[key] = traverseObject(value);
+                    }
+                    return result;
+                }
+                else if (isBlobInterface(obj)) {
+                    return `<ClientBlobStream metadata=${JSON.stringify(obj.metadata)}>`;
+                }
+                return obj;
+            }
+            return traverseObject(payload);
+        },
+        headers: (value) => {
+            if (value instanceof Headers) {
+                const obj = {};
+                value.forEach((v, k) => {
+                    obj[k] = v;
+                });
+                return obj;
+            }
+            return value;
+        },
+    },
+};
+//# sourceMappingURL=gateway.js.map