@nmtjs/protocol 0.15.0-beta.8 → 0.15.0

package/src/server/format.ts

@@ -1,6 +1,7 @@
 import type { Pattern } from '@nmtjs/common'
 import { match } from '@nmtjs/common'
 
+import type { ProtocolBlobMetadata } from '../common/blob.ts'
 import type {
   DecodeRPCContext,
   EncodeRPCStreams,
@@ -21,7 +22,7 @@ export interface BaseServerEncoder {
   contentType: string
   encode(data: unknown): ArrayBufferView
   encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView
-  encodeBlob(streamId: number): unknown
+  encodeBlob(streamId: number, metadata: ProtocolBlobMetadata): unknown
 }
 
 export abstract class BaseServerFormat
@@ -32,7 +33,7 @@ export abstract class BaseServerFormat
 
   abstract encode(data: unknown): ArrayBufferView
   abstract encodeRPC(data: unknown, streams: EncodeRPCStreams): ArrayBufferView
-  abstract encodeBlob(streamId: number): unknown
+  abstract encodeBlob(streamId: number, metadata: ProtocolBlobMetadata): unknown
   abstract decode(buffer: ArrayBufferView): any
   abstract decodeRPC(
     buffer: ArrayBufferView,
@@ -74,7 +75,10 @@ export class ProtocolFormats {
   decoders = new Map<Pattern, BaseServerDecoder>()
   encoders = new Map<Pattern, BaseServerEncoder>()
 
-  constructor(formats: BaseServerFormat[]) {
+  default: BaseServerFormat
+
+  constructor(formats: [BaseServerFormat, ...BaseServerFormat[]]) {
+    this.default = formats[0]
     for (const format of formats) {
       this.encoders.set(format.contentType, format)
       for (const acceptType of format.accept) {

package/src/server/protocol.ts

@@ -65,6 +65,8 @@ export type ServerMessageTypePayload = {
   [ServerMessageType.RpcStreamEnd]: { callId: number }
   [ServerMessageType.RpcStreamChunk]: { callId: number; chunk: ArrayBufferView }
   [ServerMessageType.RpcStreamResponse]: { callId: number }
+  [ServerMessageType.Pong]: { nonce: number }
+  [ServerMessageType.Ping]: { nonce: number }
   [ServerMessageType.ClientStreamAbort]: { streamId: number; reason?: string }
   [ServerMessageType.ClientStreamPull]: { streamId: number; size: number }
   [ServerMessageType.ServerStreamAbort]: { streamId: number; reason?: string }
@@ -84,8 +86,9 @@ export type ClientMessageTypePayload = {
       streams?: EncodeRPCStreams
     }
   }
-  [ClientMessageType.RpcPull]: { callId: number }
   [ClientMessageType.RpcAbort]: { callId: number; reason?: string }
+  [ClientMessageType.Ping]: { nonce: number }
+  [ClientMessageType.Pong]: { nonce: number }
   [ClientMessageType.ClientStreamPush]: {
     streamId: number
     chunk: ArrayBufferView

package/src/server/stream.ts

@@ -28,6 +28,8 @@ export class ProtocolClientStream extends PassThrough {
 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
@@ -43,9 +45,28 @@ export class ProtocolServerStream extends PassThrough {
     super()
 
     this.pause()
-    readable.pipe(this)
+    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/utils.ts

@@ -11,12 +11,12 @@ export const getFormat = (
   format: ProtocolFormats,
   { accept, contentType }: ResolveFormatParams,
 ) => {
-  const encoder = contentType ? format.supportsEncoder(contentType) : undefined
-  if (!encoder)
-    throw new UnsupportedContentTypeError('Unsupported Content type')
+  const encoder = accept ? format.supportsEncoder(accept) : undefined
+  if (!encoder) throw new UnsupportedAcceptTypeError('Unsupported Accept type')
 
-  const decoder = accept ? format.supportsDecoder(accept) : undefined
-  if (!decoder) throw new UnsupportedAcceptTypeError('Unsupported Accept type')
+  const decoder = contentType ? format.supportsDecoder(contentType) : undefined
+  if (!decoder)
+    throw new UnsupportedContentTypeError('Unsupported Content type')
 
   return { encoder, decoder }
 }

package/src/server/versions/v1.ts

@@ -38,10 +38,6 @@ export class ProtocolVersion1 extends ProtocolVersionInterface {
 
         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)
@@ -49,6 +45,14 @@ export class ProtocolVersion1 extends ProtocolVersionInterface {
           reasonPayload.byteLength > 0 ? decodeText(reasonPayload) : undefined
         return { type: messageType, callId, reason }
       }
+      case ClientMessageType.Ping: {
+        const nonce = messagePayload.readUInt32LE(0)
+        return { type: messageType, nonce }
+      }
+      case ClientMessageType.Pong: {
+        const nonce = messagePayload.readUInt32LE(0)
+        return { type: messageType, nonce }
+      }
       case ClientMessageType.ServerStreamAbort: {
         const streamId = messagePayload.readUInt32LE(0)
         const reasonPayload = messagePayload.subarray(
@@ -146,6 +150,22 @@ export class ProtocolVersion1 extends ProtocolVersionInterface {
           reason ? encodeText(reason) : Buffer.alloc(0),
         )
       }
+      case ServerMessageType.Pong: {
+        const { nonce } =
+          payload as ServerMessageTypePayload[ServerMessageType.Pong]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(nonce, 'Uint32'),
+        )
+      }
+      case ServerMessageType.Ping: {
+        const { nonce } =
+          payload as ServerMessageTypePayload[ServerMessageType.Ping]
+        return this.encode(
+          encodeNumber(messageType, 'Uint8'),
+          encodeNumber(nonce, 'Uint32'),
+        )
+      }
       case ServerMessageType.ClientStreamPull: {
         const { size, streamId } =
           payload as ServerMessageTypePayload[ServerMessageType.ClientStreamPull]