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

package/src/server/stream.ts

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

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

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

@@ -1,198 +0,0 @@
-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}`)
-    }
-  }
-}