@nmtjs/protocol 0.12.4 → 0.12.6

package/dist/server/connection.d.ts

@@ -0,0 +1,25 @@
+import type { Container } from '@nmtjs/core';
+import type { BaseServerDecoder, BaseServerEncoder } from './format.ts';
+import type { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
+export type ConnectionOptions<Data = unknown> = {
+    id?: string;
+    data: Data;
+};
+export declare class Connection<Data = unknown> {
+    readonly id: string;
+    readonly data: Data;
+    constructor(options: ConnectionOptions<Data>);
+}
+export declare class ConnectionContext {
+    streamId: number;
+    rpcs: Map<number, AbortController>;
+    clientStreams: Map<number, ProtocolClientStream>;
+    serverStreams: Map<number, ProtocolServerStream>;
+    rpcStreams: Map<number, AbortController>;
+    container: Container;
+    format: {
+        encoder: BaseServerEncoder;
+        decoder: BaseServerDecoder;
+    };
+    constructor(container: ConnectionContext['container'], format: ConnectionContext['format']);
+}

package/dist/server/connection.js

@@ -1,24 +1,22 @@
-import { randomUUID } from "node:crypto";
+import { randomUUID } from 'node:crypto';
 export class Connection {
-	id;
-	data;
-	constructor(options) {
-		this.id = options.id ?? randomUUID();
-		this.data = options.data;
-	}
+    id;
+    data;
+    constructor(options) {
+        this.id = options.id ?? randomUUID();
+        this.data = options.data;
+    }
 }
 export class ConnectionContext {
-	streamId = 1;
-	rpcs = new Map();
-	clientStreams = new Map();
-	serverStreams = new Map();
-	rpcStreams = new Map();
-	container;
-	format;
-	constructor(container, format) {
-		this.container = container;
-		this.format = format;
-	}
+    streamId = 1;
+    rpcs = new Map();
+    clientStreams = new Map();
+    serverStreams = new Map();
+    rpcStreams = new Map();
+    container;
+    format;
+    constructor(container, format) {
+        this.container = container;
+        this.format = format;
+    }
 }
-
-//# sourceMappingURL=connection.js.map

package/dist/server/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const kTransportPlugin: unique symbol;
+export type kTransportPlugin = typeof kTransportPlugin;
+export declare const kIterableResponse: unique symbol;
+export type kIterableResponse = typeof kIterableResponse;

package/dist/server/constants.js

@@ -1,4 +1,2 @@
-export const kTransportPlugin = Symbol.for("neemata:TransportPluginKey");
-export const kIterableResponse = Symbol.for("neemata:IterableResponseKey");
-
-//# sourceMappingURL=constants.js.map
+export const kTransportPlugin = Symbol.for('neemata:TransportPluginKey');
+export const kIterableResponse = Symbol.for('neemata:IterableResponseKey');

package/dist/server/format.d.ts

@@ -0,0 +1,40 @@
+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';
+export interface BaseServerDecoder {
+    accept: Pattern[];
+    decode(buffer: ArrayBuffer): any;
+    decodeRPC(buffer: ArrayBuffer, context: DecodeRPCContext<ProtocolClientStream>): ProtocolRPC;
+}
+export interface BaseServerEncoder {
+    contentType: string;
+    encode(data: any): ArrayBuffer;
+    encodeRPC(rpc: OneOf<[
+        {
+            callId: number;
+            error: any;
+        },
+        {
+            callId: number;
+            result: any;
+        }
+    ]>, context: EncodeRPCContext<ProtocolServerStream>): ArrayBuffer;
+}
+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;
+}
+export declare const parseContentTypes: (types: string) => string[];
+export declare class Format {
+    decoders: Map<Pattern, BaseServerDecoder>;
+    encoders: Map<Pattern, BaseServerEncoder>;
+    constructor(formats: BaseServerFormat[]);
+    supportsDecoder(contentType: string, throwIfUnsupported?: boolean): BaseServerDecoder | null;
+    supportsEncoder(contentType: string, throwIfUnsupported?: boolean): BaseServerEncoder | null;
+    private supports;
+}

package/dist/server/format.js

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

package/dist/server/index.d.ts

@@ -0,0 +1,11 @@
+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';

package/dist/server/index.js

@@ -9,5 +9,3 @@ export * from "./stream.js";
 export * from "./transport.js";
 export * from "./types.js";
 export * from "./utils.js";
-
-//# sourceMappingURL=index.js.map

package/dist/server/injectables.d.ts

@@ -0,0 +1,14 @@
+import { Scope } from '@nmtjs/core';
+import type { Connection } from './connection.ts';
+export declare const ProtocolInjectables: {
+    readonly connection: import("@nmtjs/core").LazyInjectable<Connection<unknown>, Scope.Connection>;
+    readonly connectionData: import("@nmtjs/core").LazyInjectable<any, Scope.Connection>;
+    readonly connectionAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Connection>;
+    readonly rpcClientAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+    readonly rpcTimeoutSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+    readonly rpcAbortSignal: import("@nmtjs/core").FactoryInjectable<AbortSignal, {
+        rpcTimeoutSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+        rpcClientAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Call>;
+        connectionAbortSignal: import("@nmtjs/core").LazyInjectable<AbortSignal, Scope.Connection>;
+    }, Scope.Global, AbortSignal>;
+};

package/dist/server/injectables.js

@@ -1,24 +1,22 @@
-import { createFactoryInjectable, createLazyInjectable, Scope } from "@nmtjs/core";
-const connection = createLazyInjectable(Scope.Connection, "RPC connection");
+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 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");
+    dependencies: {
+        rpcTimeoutSignal,
+        rpcClientAbortSignal,
+        connectionAbortSignal,
+    },
+    factory: (ctx) => AbortSignal.any(Object.values(ctx)),
+}, 'Any RPC abort signal');
 export const ProtocolInjectables = {
-	connection,
-	connectionData,
-	connectionAbortSignal,
-	rpcClientAbortSignal,
-	rpcTimeoutSignal,
-	rpcAbortSignal
+    connection,
+    connectionData,
+    connectionAbortSignal,
+    rpcClientAbortSignal,
+    rpcTimeoutSignal,
+    rpcAbortSignal,
 };
-
-//# sourceMappingURL=injectables.js.map

package/dist/server/protocol.d.ts

@@ -0,0 +1,118 @@
+import { type Callback } from '@nmtjs/common';
+import { type AnyInjectable, type Container, type Logger } from '@nmtjs/core';
+import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts';
+import type { ProtocolRPC } from '../common/types.ts';
+import { type ProtocolApi, type ProtocolApiCallOptions } from './api.ts';
+import { Connection, ConnectionContext, type ConnectionOptions } from './connection.ts';
+import type { Format } from './format.ts';
+import type { ProtocolRegistry } from './registry.ts';
+import { ProtocolClientStream, ProtocolServerStream } from './stream.ts';
+import type { Transport } from './transport.ts';
+import { type ResolveFormatParams } from './utils.ts';
+export declare class ProtocolError extends Error {
+    code: string;
+    data?: any;
+    constructor(code: string, message?: string, data?: any);
+    get message(): string;
+    toString(): string;
+    toJSON(): {
+        code: string;
+        message: string;
+        data: any;
+    };
+}
+export type ProtocolConnectionTransport = {
+    send: Transport<any>['send'];
+};
+export declare class ProtocolConnections {
+    #private;
+    private readonly application;
+    constructor(application: {
+        logger: Logger;
+        registry: ProtocolRegistry;
+        format: Format;
+        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 type ProtocolRPCOptions = {
+    signal?: AbortSignal;
+    provides?: [AnyInjectable, any][];
+    metadata?: ProtocolApiCallOptions['metadata'];
+};
+export declare class Protocol {
+    #private;
+    protected readonly application: {
+        logger: Logger;
+        format: Format;
+        container: Container;
+        registry: ProtocolRegistry;
+        api: ProtocolApi;
+    };
+    constructor(application: {
+        logger: Logger;
+        format: Format;
+        container: Container;
+        registry: ProtocolRegistry;
+        api: ProtocolApi;
+    });
+    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(connectionId: string, event: any, payload: any): 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;
+}