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

package/dist/server/injectables.js

@@ -0,0 +1,22 @@
+import { createFactoryInjectable, createLazyInjectable, Scope, } from '@nmtjs/core';
+const connection = createLazyInjectable(Scope.Connection, 'RPC connection');
+const connectionData = createLazyInjectable(Scope.Connection, "RPC connection's data");
+const connectionAbortSignal = createLazyInjectable(Scope.Connection, 'Connection abort signal');
+const rpcClientAbortSignal = createLazyInjectable(Scope.Call, 'RPC client abort signal');
+const rpcTimeoutSignal = createLazyInjectable(Scope.Call, 'RPC timeout signal');
+const rpcAbortSignal = createFactoryInjectable({
+    dependencies: {
+        rpcTimeoutSignal,
+        rpcClientAbortSignal,
+        connectionAbortSignal,
+    },
+    factory: (ctx) => AbortSignal.any(Object.values(ctx)),
+}, 'Any RPC abort signal');
+export const ProtocolInjectables = {
+    connection,
+    connectionData,
+    connectionAbortSignal,
+    rpcClientAbortSignal,
+    rpcTimeoutSignal,
+    rpcAbortSignal,
+};

package/dist/server/protocol.d.ts

@@ -1,7 +1,16 @@
-import type { ClientMessageType, ProtocolVersion, ServerMessageType } from '../common/enums.ts';
-import type { BaseProtocolError, EncodeRPCStreams } from '../common/types.ts';
-import type { MessageContext } from './types.ts';
-export declare class ProtocolError extends Error implements BaseProtocolError {
+import type { Callback } from '@nmtjs/common';
+import type { AnyInjectable, Container, Logger } from '@nmtjs/core';
+import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
+import type { ProtocolRPC } from '../common/types.ts';
+import type { ProtocolApi, ProtocolApiCallOptions } from './api.ts';
+import type { ConnectionOptions } from './connection.ts';
+import type { ProtocolFormat } from './format.ts';
+import type { ProtocolRegistry } from './registry.ts';
+import type { Transport } from './transport.ts';
+import type { ResolveFormatParams } from './utils.ts';
+import { Connection, ConnectionContext } from './connection.ts';
+import { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
+export declare class ProtocolError extends Error {
     code: string;
     data?: any;
     constructor(code: string, message?: string, data?: any);
@@ -13,90 +22,107 @@ export declare class ProtocolError extends Error implements BaseProtocolError {
         data: any;
     };
 }
-export declare abstract class ProtocolVersionInterface {
-    abstract version: ProtocolVersion;
-    abstract decodeMessage(context: MessageContext, buffer: ArrayBufferView): {
-        [K in keyof ClientMessageTypePayload]: {
-            type: K;
-        } & ClientMessageTypePayload[K];
-    }[keyof ClientMessageTypePayload];
-    abstract encodeMessage<T extends ServerMessageType = ServerMessageType>(context: MessageContext, messageType: T, payload: ServerMessageTypePayload[T]): ArrayBufferView;
-    protected encode(...chunks: (ArrayBuffer | ArrayBufferView)[]): ArrayBufferView;
+export type ProtocolConnectionTransport = {
+    send: Transport<any>['send'];
+};
+export declare class ProtocolConnections {
+    #private;
+    private readonly application;
+    constructor(application: {
+        logger: Logger;
+        registry: ProtocolRegistry;
+        format: ProtocolFormat;
+        container: Container;
+    });
+    get(connectionId: string): {
+        connection: Connection;
+        context: ConnectionContext;
+        transport: ProtocolConnectionTransport;
+    };
+    add<T>(transport: ProtocolConnectionTransport, options: ConnectionOptions<T>, params: ResolveFormatParams): Promise<{
+        connection: Connection<T>;
+        context: ConnectionContext;
+    }>;
+    remove(connectionId: string): Promise<void>;
+    initialize(connection: Connection): Promise<void>;
 }
-export type ServerMessageTypePayload = {
-    [ServerMessageType.RpcResponse]: {
-        callId: number;
-        result: any;
-        streams: EncodeRPCStreams;
-        error: any | null;
-    };
-    [ServerMessageType.RpcStreamAbort]: {
-        callId: number;
-        reason?: string;
-    };
-    [ServerMessageType.RpcStreamEnd]: {
-        callId: number;
-    };
-    [ServerMessageType.RpcStreamChunk]: {
-        callId: number;
-        chunk: ArrayBufferView;
-    };
-    [ServerMessageType.RpcStreamResponse]: {
-        callId: number;
-    };
-    [ServerMessageType.ClientStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-    [ServerMessageType.ClientStreamPull]: {
-        streamId: number;
-        size: number;
-    };
-    [ServerMessageType.ServerStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-    [ServerMessageType.ServerStreamEnd]: {
-        streamId: number;
-    };
-    [ServerMessageType.ServerStreamPush]: {
-        streamId: number;
-        chunk: ArrayBufferView;
-    };
+export declare class ProtocolClientStreams {
+    private readonly connections;
+    constructor(connections: ProtocolConnections);
+    get(connectionId: string, streamId: number): ProtocolClientStream;
+    remove(connectionId: string, streamId: number): void;
+    add(connectionId: string, streamId: number, metadata: ProtocolBlobMetadata, read: Callback): ProtocolClientStream;
+    push(connectionId: string, streamId: number, chunk: ArrayBuffer): void;
+    end(connectionId: string, streamId: number): void;
+    abort(connectionId: string, streamId: number, error?: Error): void;
+}
+export declare class ProtocolServerStreams {
+    private readonly connections;
+    constructor(connections: ProtocolConnections);
+    get(connectionId: string, streamId: number): ProtocolServerStream;
+    add(connectionId: string, streamId: number, blob: ProtocolBlob): ProtocolServerStream;
+    remove(connectionId: string, streamId: number): void;
+    pull(connectionId: string, streamId: number): void;
+    abort(connectionId: string, streamId: number, error?: Error): void;
+}
+export type ProtocolRPCOptions = {
+    signal?: AbortSignal;
+    provides?: [AnyInjectable, any][];
+    validateMetadata?: ProtocolApiCallOptions['validateMetadata'];
 };
-export type ClientMessageTypePayload = {
-    [ClientMessageType.Rpc]: {
-        rpc: {
-            callId: number;
-            procedure: string;
-            payload: unknown;
-            streams?: EncodeRPCStreams;
+export declare class Protocol {
+    #private;
+    protected readonly application: {
+        logger: Logger;
+        format: ProtocolFormat;
+        container: Container;
+        registry: ProtocolRegistry;
+        api: ProtocolApi;
+    };
+    protected readonly options?: {
+        persistConnections?: {
+            timeout: number;
         };
-    };
-    [ClientMessageType.RpcPull]: {
-        callId: number;
-    };
-    [ClientMessageType.RpcAbort]: {
-        callId: number;
-        reason?: string;
-    };
-    [ClientMessageType.ClientStreamPush]: {
-        streamId: number;
-        chunk: ArrayBufferView;
-    };
-    [ClientMessageType.ClientStreamEnd]: {
-        streamId: number;
-    };
-    [ClientMessageType.ClientStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-    [ClientMessageType.ServerStreamPull]: {
-        streamId: number;
-        size: number;
-    };
-    [ClientMessageType.ServerStreamAbort]: {
-        streamId: number;
-        reason?: string;
-    };
-};
+    } | undefined;
+    constructor(application: {
+        logger: Logger;
+        format: ProtocolFormat;
+        container: Container;
+        registry: ProtocolRegistry;
+        api: ProtocolApi;
+    }, options?: {
+        persistConnections?: {
+            timeout: number;
+        };
+    } | undefined);
+    call(options: ProtocolApiCallOptions): Promise<import("./api.ts").ProtocolApiCallResult>;
+    rpc(connectionId: string, rpc: ProtocolRPC, params?: ProtocolRPCOptions): Promise<void>;
+    rpcRaw(connectionId: string, buffer: ArrayBuffer, params?: ProtocolRPCOptions): Promise<void>;
+    rpcAbort(connectionId: string, callId: number): void;
+    rpcAbortRaw(connectionId: string, buffer: ArrayBuffer): void;
+    rpcStreamAbort(connectionId: string, callId: number): void;
+    rpcStreamAbortRaw(connectionId: string, buffer: ArrayBuffer): void;
+    notify(): void;
+    addConnection(transport: ProtocolConnectionTransport, options: ConnectionOptions, params: ResolveFormatParams): Promise<{
+        connection: Connection<unknown>;
+        context: ConnectionContext;
+    }>;
+    removeConnection(connectionId: string): Promise<void>;
+    getConnection(connectionId: string): {
+        connection: Connection;
+        context: ConnectionContext;
+        transport: ProtocolConnectionTransport;
+    };
+    initializeConnection(connection: Connection): Promise<void>;
+    getClientStream(connectionId: string, streamId: number): ProtocolClientStream;
+    addClientStream(connectionId: string, streamId: number, metadata: ProtocolBlobMetadata, read: Callback): ProtocolClientStream;
+    removeClientStream(connectionId: string, streamId: number): void;
+    pushClientStream(connectionId: string, streamId: number, chunk: ArrayBuffer): void;
+    endClientStream(connectionId: string, streamId: number): void;
+    abortClientStream(connectionId: string, streamId: number, error?: Error): void;
+    getServerStream(connectionId: string, streamId: number): ProtocolServerStream;
+    addServerStream(connectionId: string, streamId: number, blob: ProtocolBlob): ProtocolServerStream;
+    removeServerStream(connectionId: string, streamId: number): void;
+    pullServerStream(connectionId: string, streamId: number): void;
+    abortServerStream(connectionId: string, streamId: number, error?: Error): void;
+}

package/dist/server/protocol.js

@@ -1,4 +1,12 @@
-import { concat } from '../common/binary.js';
+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";
 export class ProtocolError extends Error {
     code;
     data;
@@ -17,9 +25,350 @@ export class ProtocolError extends Error {
         return { code: this.code, message: this.message, data: this.data };
     }
 }
-export class ProtocolVersionInterface {
-    encode(...chunks) {
-        return concat(...chunks);
+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);
     }
 }
-//# sourceMappingURL=protocol.js.map

package/dist/server/registry.d.ts

@@ -0,0 +1,3 @@
+import { Registry } from '@nmtjs/core';
+export declare class ProtocolRegistry extends Registry {
+}

package/dist/server/registry.js

@@ -0,0 +1,3 @@
+import { Registry } from '@nmtjs/core';
+export class ProtocolRegistry extends Registry {
+}

package/dist/server/stream.d.ts

@@ -2,17 +2,12 @@ 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;
 }