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

package/src/server/stream.ts

@@ -0,0 +1,72 @@
+import type { ReadableOptions } from 'node:stream'
+import { PassThrough, Readable } from 'node:stream'
+import { ReadableStream } from 'node:stream/web'
+
+import type { ProtocolBlob, ProtocolBlobMetadata } from '../common/blob.ts'
+
+export class ProtocolClientStream extends PassThrough {
+  readonly #read?: ReadableOptions['read']
+
+  constructor(
+    public readonly id: number,
+    public readonly metadata: ProtocolBlobMetadata,
+    options?: ReadableOptions,
+  ) {
+    const { read, ...rest } = options ?? {}
+    super(rest)
+    this.#read = read
+  }
+
+  override _read(size: number): void {
+    if (this.#read) {
+      this.#read.call(this, size)
+    }
+    super._read(size)
+  }
+}
+
+export class ProtocolServerStream extends PassThrough {
+  public readonly id: number
+  public readonly metadata: ProtocolBlobMetadata
+  readonly #source: Readable
+  #piped = false
+
+  constructor(id: number, blob: ProtocolBlob) {
+    let readable: Readable
+
+    if (blob.source instanceof Readable) {
+      readable = blob.source
+    } else if (blob.source instanceof ReadableStream) {
+      readable = Readable.fromWeb(blob.source as ReadableStream)
+    } else {
+      throw new Error('Invalid source type')
+    }
+
+    super()
+
+    this.pause()
+    this.#source = readable
+    this.#source.on('error', (error) => {
+      this.destroy(error)
+    })
+
+    this.id = id
+    this.metadata = blob.metadata
+  }
+
+  override resume(): this {
+    if (!this.#piped) {
+      this.#piped = true
+      this.#source.pipe(this)
+    }
+    return super.resume()
+  }
+
+  override destroy(error?: Error | null) {
+    if (!this.#piped) {
+      this.#piped = true
+    }
+    this.#source.destroy?.(error ?? undefined)
+    return super.destroy(error ?? undefined)
+  }
+}

package/src/server/types.ts

@@ -0,0 +1,42 @@
+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 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

package/src/server/utils.ts

@@ -0,0 +1,22 @@
+import type { ProtocolFormats } from './format.ts'
+import type { ResolveFormatParams } from './types.ts'
+
+export class UnsupportedFormatError extends Error {}
+
+export class UnsupportedContentTypeError extends UnsupportedFormatError {}
+
+export class UnsupportedAcceptTypeError extends UnsupportedFormatError {}
+
+export const getFormat = (
+  format: ProtocolFormats,
+  { accept, contentType }: ResolveFormatParams,
+) => {
+  const encoder = contentType ? format.supportsEncoder(contentType) : undefined
+  if (!encoder)
+    throw new UnsupportedContentTypeError('Unsupported Content type')
+
+  const decoder = accept ? format.supportsDecoder(accept) : undefined
+  if (!decoder) throw new UnsupportedAcceptTypeError('Unsupported Accept type')
+
+  return { encoder, decoder }
+}

package/src/server/versions/v1.ts

@@ -0,0 +1,198 @@
+import type { ServerMessageTypePayload } from '../protocol.ts'
+import type { MessageContext } from '../types.ts'
+import { decodeText, encodeNumber, encodeText } from '../../common/binary.ts'
+import {
+  ClientMessageType,
+  MessageByteLength,
+  ProtocolVersion,
+  ServerMessageType,
+} from '../../common/enums.ts'
+import { ProtocolVersionInterface } from '../protocol.ts'
+
+export class ProtocolVersion1 extends ProtocolVersionInterface {
+  version = ProtocolVersion.v1
+  decodeMessage(context: MessageContext, buffer: Buffer) {
+    const messageType = buffer.readUint8(0)
+    const messagePayload = buffer.subarray(MessageByteLength.MessageType)
+    switch (messageType) {
+      case ClientMessageType.Rpc: {
+        const callId = messagePayload.readUint32LE(0)
+        const procedureLength = messagePayload.readUInt16LE(
+          MessageByteLength.CallId,
+        )
+        const procedureOffset =
+          MessageByteLength.CallId + MessageByteLength.ProcedureLength
+        const procedure = messagePayload.toString(
+          'utf-8',
+          procedureOffset,
+          procedureOffset + procedureLength,
+        )
+        const formatPayload = messagePayload.subarray(
+          procedureOffset + procedureLength,
+        )
+        const payload = context.decoder.decodeRPC(formatPayload, {
+          addStream: (streamId, metadata) => {
+            return context.addClientStream({ callId, streamId, metadata })
+          },
+        })
+
+        return { type: messageType, rpc: { callId, procedure, payload } }
+      }
+      case ClientMessageType.RpcPull: {
+        const callId = messagePayload.readUInt32LE(0)
+        return { type: messageType, callId }
+      }
+      case ClientMessageType.RpcAbort: {
+        const callId = messagePayload.readUInt32LE(0)
+        const reasonPayload = messagePayload.subarray(MessageByteLength.CallId)
+        const reason =
+          reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
+        return { type: messageType, callId, reason }
+      }
+      case ClientMessageType.ServerStreamAbort: {
+        const streamId = messagePayload.readUInt32LE(0)
+        const reasonPayload = messagePayload.subarray(
+          MessageByteLength.StreamId,
+        )
+        const reason =
+          reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
+        return { type: messageType, streamId, reason }
+      }
+      case ClientMessageType.ServerStreamPull: {
+        const streamId = messagePayload.readUInt32LE(0)
+        const size = messagePayload.readUInt32LE(MessageByteLength.StreamId)
+        return { type: messageType, streamId, size }
+      }
+      case ClientMessageType.ClientStreamAbort: {
+        const streamId = messagePayload.readUInt32LE(0)
+        const reasonPayload = messagePayload.subarray(
+          MessageByteLength.StreamId,
+        )
+        const reason =
+          reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
+        return { type: messageType, streamId, reason }
+      }
+      case ClientMessageType.ClientStreamEnd: {
+        return { type: messageType, streamId: messagePayload.readUInt32LE(0) }
+      }
+      case ClientMessageType.ClientStreamPush: {
+        const streamId = messagePayload.readUInt32LE(0)
+        const chunk = messagePayload.subarray(MessageByteLength.StreamId)
+        return { type: messageType, streamId, chunk }
+      }
+
+      default:
+        throw new Error(`Unsupported message type: ${messageType}`)
+    }
+  }
+
+  encodeMessage<T extends ServerMessageType>(
+    context: MessageContext,
+    messageType: T,
+    payload: ServerMessageTypePayload[T],
+  ) {
+    switch (messageType) {
+      // case ServerMessageType.Event: {
+      //   const { event, data } =
+      //     payload as ServerMessageTypePayload[ServerMessageType.Event]
+      //   return this.encode(
+      //     encodeNumber(messageType, 'Uint8'),
+      //     context.encoder.encode({ event, data }),
+      //   )
+      // }
+      case ServerMessageType.RpcResponse: {
+        const { callId, result, streams, error } =
+          payload as ServerMessageTypePayload[ServerMessageType.RpcResponse]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+          encodeNumber(error ? 1 : 0, 'Uint8'),
+          error
+            ? context.encoder.encode(error)
+            : context.encoder.encodeRPC(result, streams),
+        )
+      }
+      case ServerMessageType.RpcStreamResponse: {
+        const { callId } =
+          payload as ServerMessageTypePayload[ServerMessageType.RpcStreamResponse]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+        )
+      }
+      case ServerMessageType.RpcStreamChunk: {
+        const { callId, chunk } =
+          payload as ServerMessageTypePayload[ServerMessageType.RpcStreamChunk]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+          chunk,
+        )
+      }
+      case ServerMessageType.RpcStreamEnd: {
+        const { callId } =
+          payload as ServerMessageTypePayload[ServerMessageType.RpcStreamEnd]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+        )
+      }
+      case ServerMessageType.RpcStreamAbort: {
+        const { callId, reason } =
+          payload as ServerMessageTypePayload[ServerMessageType.RpcStreamAbort]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(callId, 'Uint32'),
+          reason ? encodeText(reason) : Buffer.alloc(0),
+        )
+      }
+      case ServerMessageType.ClientStreamPull: {
+        const { size, streamId } =
+          payload as ServerMessageTypePayload[ServerMessageType.ClientStreamPull]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          encodeNumber(size, 'Uint32'),
+        )
+      }
+      case ServerMessageType.ClientStreamAbort: {
+        const { streamId, reason } =
+          payload as ServerMessageTypePayload[ServerMessageType.ClientStreamAbort]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          reason ? encodeText(reason) : Buffer.alloc(0),
+        )
+      }
+      case ServerMessageType.ServerStreamPush: {
+        const { streamId, chunk } =
+          payload as ServerMessageTypePayload[ServerMessageType.ServerStreamPush]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          chunk,
+        )
+      }
+      case ServerMessageType.ServerStreamEnd: {
+        const { streamId } =
+          payload as ServerMessageTypePayload[ServerMessageType.ServerStreamEnd]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+        )
+      }
+      case ServerMessageType.ServerStreamAbort: {
+        const { streamId, reason } =
+          payload as ServerMessageTypePayload[ServerMessageType.ServerStreamAbort]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(streamId, 'Uint32'),
+          reason ? encodeText(reason) : Buffer.alloc(0),
+        )
+      }
+
+      default:
+        throw new Error(`Unsupported message type: ${messageType}`)
+    }
+  }
+}

package/dist/client/events.d.ts

@@ -1,15 +0,0 @@
-import type { Callback } from '@nmtjs/common';
-export type EventMap = {
-    [K: string]: any[];
-};
-/**
- * Very simple node-like event emitter wrapper around EventTarget
- */
-export declare class EventEmitter<Events extends EventMap = EventMap, EventName extends Extract<keyof Events, string> = Extract<keyof Events, string>> {
-    #private;
-    static once<T extends EventEmitter, E extends T extends EventEmitter<any, infer Event> ? Event : never>(ee: T, event: E): Promise<unknown>;
-    on<E extends EventName>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
-    once<E extends EventName>(event: E | (Object & string), listener: (...args: Events[E]) => void, options?: AddEventListenerOptions): () => void;
-    off(event: EventName | (Object & string), listener: Callback): void;
-    emit<E extends EventName | (Object & string)>(event: E, ...args: E extends EventName ? Events[E] : any[]): boolean;
-}

package/dist/client/events.js

@@ -1,28 +0,0 @@
-// TODO: add errors and promise rejections handling
-/**
- * Very simple node-like event emitter wrapper around EventTarget
- */
-export class EventEmitter {
-    static once(ee, event) {
-        return new Promise((resolve) => ee.once(event, resolve));
-    }
-    #target = new EventTarget();
-    #listeners = new Map();
-    on(event, listener, options) {
-        const wrapper = (event) => listener(...event.detail);
-        this.#listeners.set(listener, wrapper);
-        this.#target.addEventListener(event, wrapper, { ...options, once: false });
-        return () => this.#target.removeEventListener(event, wrapper);
-    }
-    once(event, listener, options) {
-        return this.on(event, listener, { ...options, once: true });
-    }
-    off(event, listener) {
-        const wrapper = this.#listeners.get(listener);
-        if (wrapper)
-            this.#target.removeEventListener(event, wrapper);
-    }
-    emit(event, ...args) {
-        return this.#target.dispatchEvent(new CustomEvent(event, { detail: args }));
-    }
-}

package/dist/server/api.d.ts

@@ -1,33 +0,0 @@
-import type { Async } from '@nmtjs/common';
-import type { Container, Hook, MetadataStore } from '@nmtjs/core';
-import type { Connection } from './connection.ts';
-import { kIterableResponse } from './constants.ts';
-export type ProtocolApiCallOptions = {
-    connection: Connection;
-    procedure: string;
-    container: Container;
-    payload: any;
-    signal: AbortSignal;
-    validateMetadata?: (metadata: MetadataStore) => void;
-};
-export type ProtocolAnyIterable<T> = ((signal: AbortSignal) => Async<AsyncIterable<T>>) | AsyncIterable<T>;
-export interface ProtocolApiCallBaseResult<T = unknown> {
-    output: T;
-}
-export interface ProtocolApiCallIterableResult<Y = unknown, O = unknown> extends ProtocolApiCallBaseResult<O> {
-    [kIterableResponse]: true;
-    iterable: ProtocolAnyIterable<Y>;
-    onFinish?: () => void;
-}
-export type ProtocolApiCallResult = ProtocolApiCallBaseResult | ProtocolApiCallIterableResult;
-export interface ProtocolApi {
-    call(options: ProtocolApiCallOptions): Promise<ProtocolApiCallResult>;
-}
-export declare function isIterableResult(value: ProtocolApiCallResult): value is ProtocolApiCallIterableResult;
-export declare function createStreamResponse<Y, O>(iterable: ProtocolAnyIterable<Y>, output?: O, onFinish?: () => void): ProtocolApiCallIterableResult<Y, O>;
-declare module '@nmtjs/core' {
-    interface HookType {
-        [Hook.OnConnect]: (connection: Connection) => any;
-        [Hook.OnDisconnect]: (connection: Connection) => any;
-    }
-}

package/dist/server/api.js

@@ -1,7 +0,0 @@
-import { kIterableResponse } from "./constants.js";
-export function isIterableResult(value) {
-    return value && value[kIterableResponse] === true;
-}
-export function createStreamResponse(iterable, output = undefined, onFinish) {
-    return { [kIterableResponse]: true, iterable, output, onFinish };
-}

package/dist/server/connection.d.ts

@@ -1,25 +0,0 @@
-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,22 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export class Connection {
-    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;
-    }
-}

package/dist/server/constants.d.ts

@@ -1,4 +0,0 @@
-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,2 +0,0 @@
-export const kTransportPlugin = Symbol.for('neemata:TransportPluginKey');
-export const kIterableResponse = Symbol.for('neemata:IterableResponseKey');

package/dist/server/injectables.d.ts

@@ -1,14 +0,0 @@
-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,22 +0,0 @@
-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/registry.d.ts

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

package/dist/server/registry.js

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

package/dist/server/transport.d.ts

@@ -1,23 +0,0 @@
-import type { BasePlugin, PluginContext } from '@nmtjs/core';
-import type { ServerMessageType } from '../common/enums.ts';
-import type { Connection } from './connection.ts';
-import type { ProtocolFormat } from './format.ts';
-import type { Protocol } from './protocol.ts';
-import type { ProtocolRegistry } from './registry.ts';
-import type { ProtocolSendMetadata } from './types.ts';
-import { kTransportPlugin } from './constants.ts';
-export interface Transport<T = unknown> {
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-    send: (connection: Connection<T>, messageType: ServerMessageType, buffer: ArrayBuffer, metadata: ProtocolSendMetadata) => any;
-}
-export interface TransportPluginContext extends PluginContext {
-    protocol: Protocol;
-    registry: ProtocolRegistry;
-    format: ProtocolFormat;
-}
-export interface TransportPlugin<Type = unknown, Options = unknown> extends BasePlugin<Transport<Type>, Options, TransportPluginContext> {
-    [kTransportPlugin]: any;
-}
-export declare const createTransport: <Type = unknown, Options = unknown>(name: string, init: TransportPlugin<Type, Options>["init"]) => TransportPlugin<Type, Options>;
-export declare const isTransportPlugin: (plugin: BasePlugin<any, any, any>) => plugin is TransportPlugin;

package/dist/server/transport.js

@@ -1,3 +0,0 @@
-import { kTransportPlugin } from "./constants.js";
-export const createTransport = (name, init) => ({ name, init, [kTransportPlugin]: true });
-export const isTransportPlugin = (plugin) => kTransportPlugin in plugin;