@nmtjs/protocol 0.15.0-beta.3 → 0.15.0-beta.31

package/src/server/stream.ts

@@ -0,0 +1,51 @@
+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
+
+  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()
+    readable.pipe(this)
+
+    this.id = id
+    this.metadata = blob.metadata
+  }
+}

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}`)
+    }
+  }
+}