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

package/dist/common/types.d.ts

@@ -1,33 +1,14 @@
-import type { OneOf } from '@nmtjs/common';
-import type { ProtocolBlob, ProtocolBlobMetadata } from './blob.ts';
+import type { ProtocolBlobMetadata } from './blob.ts';
 type Stream = any;
 export interface BaseProtocolError {
     code: string;
     message: string;
     data?: any;
 }
-export type ProtocolRPC = {
-    callId: number;
-    procedure: string;
-    payload: any;
-};
-export type ProtocolRPCResponse<T = Stream> = OneOf<[
-    {
-        callId: number;
-        error: BaseProtocolError;
-    },
-    {
-        callId: number;
-        result: any;
-        streams: Record<number, T>;
-    }
-]>;
-export interface EncodeRPCContext<T = Stream> {
-    getStream: (id: number) => T;
-    addStream: (blob: ProtocolBlob) => T;
-}
+export type ProtocolRPCPayload = unknown;
+export type ProtocolRPCResponse = unknown;
+export type EncodeRPCStreams = Record<number, ProtocolBlobMetadata>;
 export interface DecodeRPCContext<T = Stream> {
-    getStream: (id: number, callId: number) => T;
-    addStream: (id: number, callId: number, metadata: ProtocolBlobMetadata) => T;
+    addStream: (id: number, metadata: ProtocolBlobMetadata) => T;
 }
 export {};

package/dist/common/types.js

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

package/dist/common/types.js.map

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

package/dist/common/utils.d.ts

@@ -0,0 +1,2 @@
+import type { ProtocolBlobInterface } from './blob.ts';
+export declare const isBlobInterface: <T extends ProtocolBlobInterface>(value: any) => value is T;

package/dist/common/utils.js

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

package/dist/common/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/common/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AAEzC,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,KAAU,EACE,EAAE,CAAC;IACf,OAAO,CACL,KAAK;QACL,CAAC,OAAO,KAAK,KAAK,QAAQ,IAAI,OAAO,KAAK,KAAK,UAAU,CAAC;QAC1D,QAAQ,IAAI,KAAK,CAClB,CAAA;AAAA,CACF,CAAA"}

package/dist/server/format.d.ts

@@ -1,39 +1,33 @@
-import type { OneOf } from '@nmtjs/common';
-import type { Pattern } from '@nmtjs/core';
-import type { DecodeRPCContext, EncodeRPCContext, ProtocolRPC, ProtocolRPCResponse } from '../common/types.ts';
-import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
+import type { Pattern } from '@nmtjs/common';
+import type { ProtocolBlobMetadata } from '../common/blob.ts';
+import type { DecodeRPCContext, EncodeRPCStreams, ProtocolRPCPayload } from '../common/types.ts';
+import type { ProtocolClientStream } from './stream.ts';
 export interface BaseServerDecoder {
     accept: Pattern[];
-    decode(buffer: ArrayBuffer): any;
-    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
+    decode(buffer: ArrayBufferView): unknown;
+    decodeRPC(buffer: ArrayBufferView, context: DecodeRPCContext<() => ProtocolClientStream>): ProtocolRPCPayload;
 }
 export interface BaseServerEncoder {
     contentType: string;
-    encode(data: any): ArrayBuffer;
-    encodeRPC(rpc: OneOf<[
-        {
-            callId: number;
-            error: any;
-        },
-        {
-            callId: number;
-            result: any;
-        }
-    ]>, context: EncodeRPCContext<ProtocolServerStream>): ArrayBuffer;
+    encode(data: unknown): ArrayBufferView;
+    encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView;
+    encodeBlob(streamId: number, metadata: ProtocolBlobMetadata): unknown;
 }
 export declare abstract class BaseServerFormat implements BaseServerDecoder, BaseServerEncoder {
     abstract accept: Pattern[];
     abstract contentType: string;
-    abstract encode(data: any): ArrayBuffer;
-    abstract encodeRPC(rpc: ProtocolRPCResponse, context: EncodeRPCContext<ProtocolServerStream>): ArrayBuffer;
-    abstract decode(buffer: ArrayBuffer): any;
-    abstract decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
+    abstract encode(data: unknown): ArrayBufferView;
+    abstract encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView;
+    abstract encodeBlob(streamId: number, metadata: ProtocolBlobMetadata): unknown;
+    abstract decode(buffer: ArrayBufferView): any;
+    abstract decodeRPC(buffer: ArrayBufferView, context: DecodeRPCContext<() => ProtocolClientStream>): ProtocolRPCPayload;
 }
 export declare const parseContentTypes: (types: string) => string[];
-export declare class ProtocolFormat {
+export declare class ProtocolFormats {
     decoders: Map<Pattern, BaseServerDecoder>;
     encoders: Map<Pattern, BaseServerEncoder>;
-    constructor(formats: BaseServerFormat[]);
+    default: BaseServerFormat;
+    constructor(formats: [BaseServerFormat, ...BaseServerFormat[]]);
     supportsDecoder(contentType: string, throwIfUnsupported?: boolean): BaseServerDecoder | null;
     supportsEncoder(contentType: string, throwIfUnsupported?: boolean): BaseServerEncoder | null;
     private supports;

package/dist/server/format.js

@@ -1,20 +1,22 @@
-import { match } from '@nmtjs/core';
+import { match } from '@nmtjs/common';
 export class BaseServerFormat {
 }
 export const parseContentTypes = (types) => {
-    if (types === '*/*')
+    const normalized = types.trim();
+    if (normalized === '*/*')
         return ['*/*'];
-    return types
+    return normalized
         .split(',')
+        .map((t) => t.trim())
         .map((t) => {
-        const [type, ...rest] = t.split(';');
+        const [rawType, ...rest] = t.split(';');
         const params = new Map(rest.map((p) => p
             .trim()
             .split('=')
             .slice(0, 2)
-            .map((p) => p.trim())));
+            .map((part) => part.trim())));
         return {
-            type,
+            type: rawType.trim(),
             q: params.has('q') ? Number.parseFloat(params.get('q')) : 1,
         };
     })
@@ -23,14 +25,16 @@ export const parseContentTypes = (types) => {
             return 1;
         if (b.type === '*/*')
             return -1;
-        return b.q - a.q ? -1 : 1;
+        return b.q - a.q;
     })
         .map((t) => t.type);
 };
-export class ProtocolFormat {
+export class ProtocolFormats {
     decoders = new Map();
     encoders = new Map();
+    default;
     constructor(formats) {
+        this.default = formats[0];
         for (const format of formats) {
             this.encoders.set(format.contentType, format);
             for (const acceptType of format.accept) {
@@ -58,3 +62,4 @@ export class ProtocolFormat {
         return null;
     }
 }
+//# sourceMappingURL=format.js.map

package/dist/server/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../../src/server/format.ts"],"names":[],"mappings":"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"}

package/dist/server/index.d.ts

@@ -1,11 +1,9 @@
-export * from './api.ts';
-export * from './connection.ts';
-export * from './constants.ts';
 export * from './format.ts';
-export * from './injectables.ts';
 export * from './protocol.ts';
-export * from './registry.ts';
 export * from './stream.ts';
-export * from './transport.ts';
 export * from './types.ts';
 export * from './utils.ts';
+import { ProtocolVersion1 } from './versions/v1.ts';
+export declare const versions: {
+    1: ProtocolVersion1;
+};

package/dist/server/index.js

@@ -1,11 +1,9 @@
-export * from "./api.js";
-export * from "./connection.js";
-export * from "./constants.js";
-export * from "./format.js";
-export * from "./injectables.js";
-export * from "./protocol.js";
-export * from "./registry.js";
-export * from "./stream.js";
-export * from "./transport.js";
-export * from "./types.js";
-export * from "./utils.js";
+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() };
+//# sourceMappingURL=index.js.map

package/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAA;AAC3B,cAAc,eAAe,CAAA;AAC7B,cAAc,aAAa,CAAA;AAC3B,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA;AAE1B,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEnD,MAAM,CAAC,MAAM,QAAQ,GAAG,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,EAAE,IAAI,gBAAgB,EAAE,EAAE,CAAA"}

package/dist/server/protocol.d.ts

@@ -1,16 +1,7 @@
-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 {
+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 {
     code: string;
     data?: any;
     constructor(code: string, message?: string, data?: any);
@@ -22,107 +13,90 @@ export declare class ProtocolError extends Error {
         data: any;
     };
 }
-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 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 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 ProtocolRPCOptions = {
-    signal?: AbortSignal;
-    provides?: [AnyInjectable, any][];
-    validateMetadata?: ProtocolApiCallOptions['validateMetadata'];
+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 Protocol {
-    #private;
-    protected readonly application: {
-        logger: Logger;
-        format: ProtocolFormat;
-        container: Container;
-        registry: ProtocolRegistry;
-        api: ProtocolApi;
-    };
-    protected readonly options?: {
-        persistConnections?: {
-            timeout: number;
-        };
-    } | undefined;
-    constructor(application: {
-        logger: Logger;
-        format: ProtocolFormat;
-        container: Container;
-        registry: ProtocolRegistry;
-        api: ProtocolApi;
-    }, options?: {
-        persistConnections?: {
-            timeout: number;
+export type ClientMessageTypePayload = {
+    [ClientMessageType.Rpc]: {
+        rpc: {
+            callId: number;
+            procedure: string;
+            payload: unknown;
+            streams?: EncodeRPCStreams;
         };
-    } | 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;
-}
+    };
+    [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;
+    };
+};