undici 6.19.8 → 7.0.0-alpha.1

package/lib/web/websocket/receiver.js

@@ -3,7 +3,6 @@
 const { Writable } = require('node:stream')
 const assert = require('node:assert')
 const { parserStates, opcodes, states, emptyBuffer, sentCloseFrameState } = require('./constants')
-const { kReadyState, kSentClose, kResponse, kReceivedClose } = require('./symbols')
 const { channels } = require('../../core/diagnostics')
 const {
   isValidStatusCode,
@@ -37,10 +36,13 @@ class ByteParser extends Writable {
   /** @type {Map<string, PerMessageDeflate>} */
   #extensions
 
-  constructor (ws, extensions) {
+  /** @type {import('./websocket').Handler} */
+  #handler
+
+  constructor (handler, extensions) {
     super()
 
-    this.ws = ws
+    this.#handler = handler
     this.#extensions = extensions == null ? new Map() : extensions
 
     if (this.#extensions.has('permessage-deflate')) {
@@ -86,12 +88,12 @@ class ByteParser extends Writable {
         const rsv3 = buffer[0] & 0x10
 
         if (!isValidOpcode(opcode)) {
-          failWebsocketConnection(this.ws, 'Invalid opcode received')
+          failWebsocketConnection(this.#handler, 'Invalid opcode received')
           return callback()
         }
 
         if (masked) {
-          failWebsocketConnection(this.ws, 'Frame cannot be masked')
+          failWebsocketConnection(this.#handler, 'Frame cannot be masked')
           return callback()
         }
 
@@ -105,43 +107,43 @@ class ByteParser extends Writable {
         // WebSocket connection where a PMCE is in use, this bit indicates
         // whether a message is compressed or not.
         if (rsv1 !== 0 && !this.#extensions.has('permessage-deflate')) {
-          failWebsocketConnection(this.ws, 'Expected RSV1 to be clear.')
+          failWebsocketConnection(this.#handler, 'Expected RSV1 to be clear.')
           return
         }
 
         if (rsv2 !== 0 || rsv3 !== 0) {
-          failWebsocketConnection(this.ws, 'RSV1, RSV2, RSV3 must be clear')
+          failWebsocketConnection(this.#handler, 'RSV1, RSV2, RSV3 must be clear')
           return
         }
 
         if (fragmented && !isTextBinaryFrame(opcode)) {
           // Only text and binary frames can be fragmented
-          failWebsocketConnection(this.ws, 'Invalid frame type was fragmented.')
+          failWebsocketConnection(this.#handler, 'Invalid frame type was fragmented.')
           return
         }
 
         // If we are already parsing a text/binary frame and do not receive either
         // a continuation frame or close frame, fail the connection.
         if (isTextBinaryFrame(opcode) && this.#fragments.length > 0) {
-          failWebsocketConnection(this.ws, 'Expected continuation frame')
+          failWebsocketConnection(this.#handler, 'Expected continuation frame')
           return
         }
 
         if (this.#info.fragmented && fragmented) {
           // A fragmented frame can't be fragmented itself
-          failWebsocketConnection(this.ws, 'Fragmented frame exceeded 125 bytes.')
+          failWebsocketConnection(this.#handler, 'Fragmented frame exceeded 125 bytes.')
           return
         }
 
         // "All control frames MUST have a payload length of 125 bytes or less
         // and MUST NOT be fragmented."
         if ((payloadLength > 125 || fragmented) && isControlFrame(opcode)) {
-          failWebsocketConnection(this.ws, 'Control frame either too large or fragmented')
+          failWebsocketConnection(this.#handler, 'Control frame either too large or fragmented')
           return
         }
 
         if (isContinuationFrame(opcode) && this.#fragments.length === 0 && !this.#info.compressed) {
-          failWebsocketConnection(this.ws, 'Unexpected continuation frame')
+          failWebsocketConnection(this.#handler, 'Unexpected continuation frame')
           return
         }
 
@@ -187,7 +189,7 @@ class ByteParser extends Writable {
         // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/common/globals.h;drc=1946212ac0100668f14eb9e2843bdd846e510a1e;bpv=1;bpt=1;l=1275
         // https://source.chromium.org/chromium/chromium/src/+/main:v8/src/objects/js-array-buffer.h;l=34;drc=1946212ac0100668f14eb9e2843bdd846e510a1e
         if (upper > 2 ** 31 - 1) {
-          failWebsocketConnection(this.ws, 'Received payload length > 2^31 bytes.')
+          failWebsocketConnection(this.#handler, 'Received payload length > 2^31 bytes.')
           return
         }
 
@@ -215,7 +217,7 @@ class ByteParser extends Writable {
             // parsing continuation frames, not here.
             if (!this.#info.fragmented && this.#info.fin) {
               const fullMessage = Buffer.concat(this.#fragments)
-              websocketMessageReceived(this.ws, this.#info.binaryType, fullMessage)
+              websocketMessageReceived(this.#handler, this.#info.binaryType, fullMessage)
               this.#fragments.length = 0
             }
 
@@ -223,7 +225,7 @@ class ByteParser extends Writable {
           } else {
             this.#extensions.get('permessage-deflate').decompress(body, this.#info.fin, (error, data) => {
               if (error) {
-                closeWebSocketConnection(this.ws, 1007, error.message, error.message.length)
+                closeWebSocketConnection(this.#handler, 1007, error.message, error.message.length)
                 return
               }
 
@@ -236,7 +238,7 @@ class ByteParser extends Writable {
                 return
               }
 
-              websocketMessageReceived(this.ws, this.#info.binaryType, Buffer.concat(this.#fragments))
+              websocketMessageReceived(this.#handler, this.#info.binaryType, Buffer.concat(this.#fragments))
 
               this.#loop = true
               this.#state = parserStates.INFO
@@ -339,7 +341,7 @@ class ByteParser extends Writable {
 
     if (opcode === opcodes.CLOSE) {
       if (payloadLength === 1) {
-        failWebsocketConnection(this.ws, 'Received close frame with a 1-byte body.')
+        failWebsocketConnection(this.#handler, 'Received close frame with a 1-byte body.')
         return false
       }
 
@@ -348,12 +350,12 @@ class ByteParser extends Writable {
       if (this.#info.closeInfo.error) {
         const { code, reason } = this.#info.closeInfo
 
-        closeWebSocketConnection(this.ws, code, reason, reason.length)
-        failWebsocketConnection(this.ws, reason)
+        closeWebSocketConnection(this.#handler, code, reason, reason.length)
+        failWebsocketConnection(this.#handler, reason)
         return false
       }
 
-      if (this.ws[kSentClose] !== sentCloseFrameState.SENT) {
+      if (this.#handler.closeState !== sentCloseFrameState.SENT) {
         // If an endpoint receives a Close frame and did not previously send a
         // Close frame, the endpoint MUST send a Close frame in response.  (When
         // sending a Close frame in response, the endpoint typically echos the
@@ -365,11 +367,11 @@ class ByteParser extends Writable {
         }
         const closeFrame = new WebsocketFrameSend(body)
 
-        this.ws[kResponse].socket.write(
+        this.#handler.socket.write(
           closeFrame.createFrame(opcodes.CLOSE),
           (err) => {
             if (!err) {
-              this.ws[kSentClose] = sentCloseFrameState.SENT
+              this.#handler.closeState = sentCloseFrameState.SENT
             }
           }
         )
@@ -378,8 +380,8 @@ class ByteParser extends Writable {
       // Upon either sending or receiving a Close control frame, it is said
       // that _The WebSocket Closing Handshake is Started_ and that the
       // WebSocket connection is in the CLOSING state.
-      this.ws[kReadyState] = states.CLOSING
-      this.ws[kReceivedClose] = true
+      this.#handler.readyState = states.CLOSING
+      this.#handler.receivedClose = true
 
       return false
     } else if (opcode === opcodes.PING) {
@@ -388,10 +390,10 @@ class ByteParser extends Writable {
       // A Pong frame sent in response to a Ping frame must have identical
       // "Application data"
 
-      if (!this.ws[kReceivedClose]) {
+      if (!this.#handler.receivedClose) {
         const frame = new WebsocketFrameSend(body)
 
-        this.ws[kResponse].socket.write(frame.createFrame(opcodes.PONG))
+        this.#handler.socket.write(frame.createFrame(opcodes.PONG))
 
         if (channels.ping.hasSubscribers) {
           channels.ping.publish({

package/lib/web/websocket/sender.js

@@ -4,9 +4,6 @@ const { WebsocketFrameSend } = require('./frame')
 const { opcodes, sendHints } = require('./constants')
 const FixedQueue = require('../../dispatcher/fixed-queue')
 
-/** @type {typeof Uint8Array} */
-const FastBuffer = Buffer[Symbol.species]
-
 /**
  * @typedef {object} SendQueueNode
  * @property {Promise<void> | null} promise
@@ -34,16 +31,25 @@ class SendQueue {
 
   add (item, cb, hint) {
     if (hint !== sendHints.blob) {
-      const frame = createFrame(item, hint)
       if (!this.#running) {
-        // fast-path
-        this.#socket.write(frame, cb)
+        // TODO(@tsctx): support fast-path for string on running
+        if (hint === sendHints.text) {
+          // special fast-path for string
+          const { 0: head, 1: body } = WebsocketFrameSend.createFastTextFrame(item)
+          this.#socket.cork()
+          this.#socket.write(head)
+          this.#socket.write(body, cb)
+          this.#socket.uncork()
+        } else {
+          // direct writing
+          this.#socket.write(createFrame(item, hint), cb)
+        }
       } else {
         /** @type {SendQueueNode} */
         const node = {
           promise: null,
           callback: cb,
-          frame
+          frame: createFrame(item, hint)
         }
         this.#queue.push(node)
       }
@@ -86,18 +92,17 @@ class SendQueue {
 }
 
 function createFrame (data, hint) {
-  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.string ? opcodes.TEXT : opcodes.BINARY)
+  return new WebsocketFrameSend(toBuffer(data, hint)).createFrame(hint === sendHints.text ? opcodes.TEXT : opcodes.BINARY)
 }
 
 function toBuffer (data, hint) {
   switch (hint) {
-    case sendHints.string:
-      return Buffer.from(data)
+    case sendHints.text:
+    case sendHints.typedArray:
+      return new Uint8Array(data.buffer, data.byteOffset, data.byteLength)
     case sendHints.arrayBuffer:
     case sendHints.blob:
-      return new FastBuffer(data)
-    case sendHints.typedArray:
-      return new FastBuffer(data.buffer, data.byteOffset, data.byteLength)
+      return new Uint8Array(data)
   }
 }
 

package/lib/web/websocket/util.js

@@ -1,51 +1,47 @@
 'use strict'
 
-const { kReadyState, kController, kResponse, kBinaryType, kWebSocketURL } = require('./symbols')
 const { states, opcodes } = require('./constants')
-const { ErrorEvent, createFastMessageEvent } = require('./events')
 const { isUtf8 } = require('node:buffer')
 const { collectASequenceOfCodePointsFast, removeHTTPWhitespace } = require('../fetch/data-url')
 
-/* globals Blob */
-
 /**
- * @param {import('./websocket').WebSocket} ws
+ * @param {number} readyState
  * @returns {boolean}
  */
-function isConnecting (ws) {
+function isConnecting (readyState) {
   // If the WebSocket connection is not yet established, and the connection
   // is not yet closed, then the WebSocket connection is in the CONNECTING state.
-  return ws[kReadyState] === states.CONNECTING
+  return readyState === states.CONNECTING
 }
 
 /**
- * @param {import('./websocket').WebSocket} ws
+ * @param {number} readyState
  * @returns {boolean}
  */
-function isEstablished (ws) {
+function isEstablished (readyState) {
   // If the server's response is validated as provided for above, it is
   // said that _The WebSocket Connection is Established_ and that the
   // WebSocket Connection is in the OPEN state.
-  return ws[kReadyState] === states.OPEN
+  return readyState === states.OPEN
 }
 
 /**
- * @param {import('./websocket').WebSocket} ws
+ * @param {number} readyState
  * @returns {boolean}
  */
-function isClosing (ws) {
+function isClosing (readyState) {
   // Upon either sending or receiving a Close control frame, it is said
   // that _The WebSocket Closing Handshake is Started_ and that the
   // WebSocket connection is in the CLOSING state.
-  return ws[kReadyState] === states.CLOSING
+  return readyState === states.CLOSING
 }
 
 /**
- * @param {import('./websocket').WebSocket} ws
+ * @param {number} readyState
  * @returns {boolean}
  */
-function isClosed (ws) {
-  return ws[kReadyState] === states.CLOSED
+function isClosed (readyState) {
+  return readyState === states.CLOSED
 }
 
 /**
@@ -73,49 +69,12 @@ function fireEvent (e, target, eventFactory = (type, init) => new Event(type, in
 
 /**
  * @see https://websockets.spec.whatwg.org/#feedback-from-the-protocol
- * @param {import('./websocket').WebSocket} ws
+ * @param {import('./websocket').Handler} handler
  * @param {number} type Opcode
  * @param {Buffer} data application data
  */
-function websocketMessageReceived (ws, type, data) {
-  // 1. If ready state is not OPEN (1), then return.
-  if (ws[kReadyState] !== states.OPEN) {
-    return
-  }
-
-  // 2. Let dataForEvent be determined by switching on type and binary type:
-  let dataForEvent
-
-  if (type === opcodes.TEXT) {
-    // -> type indicates that the data is Text
-    //      a new DOMString containing data
-    try {
-      dataForEvent = utf8Decode(data)
-    } catch {
-      failWebsocketConnection(ws, 'Received invalid UTF-8 in text frame.')
-      return
-    }
-  } else if (type === opcodes.BINARY) {
-    if (ws[kBinaryType] === 'blob') {
-      // -> type indicates that the data is Binary and binary type is "blob"
-      //      a new Blob object, created in the relevant Realm of the WebSocket
-      //      object, that represents data as its raw data
-      dataForEvent = new Blob([data])
-    } else {
-      // -> type indicates that the data is Binary and binary type is "arraybuffer"
-      //      a new ArrayBuffer object, created in the relevant Realm of the
-      //      WebSocket object, whose contents are data
-      dataForEvent = toArrayBuffer(data)
-    }
-  }
-
-  // 3. Fire an event named message at the WebSocket object, using MessageEvent,
-  //    with the origin attribute initialized to the serialization of the WebSocket
-  //    object’s url's origin, and the data attribute initialized to dataForEvent.
-  fireEvent('message', ws, createFastMessageEvent, {
-    origin: ws[kWebSocketURL].origin,
-    data: dataForEvent
-  })
+function websocketMessageReceived (handler, type, data) {
+  handler.onMessage(type, data)
 }
 
 function toArrayBuffer (buffer) {
@@ -190,25 +149,11 @@ function isValidStatusCode (code) {
 }
 
 /**
- * @param {import('./websocket').WebSocket} ws
+ * @param {import('./websocket').Handler} handler
  * @param {string|undefined} reason
  */
-function failWebsocketConnection (ws, reason) {
-  const { [kController]: controller, [kResponse]: response } = ws
-
-  controller.abort()
-
-  if (response?.socket && !response.socket.destroyed) {
-    response.socket.destroy()
-  }
-
-  if (reason) {
-    // TODO: process.nextTick
-    fireEvent('error', ws, (type, init) => new ErrorEvent(type, init), {
-      error: new Error(reason),
-      message: reason
-    })
-  }
+function failWebsocketConnection (handler, reason) {
+  handler.onFail(reason)
 }
 
 /**
@@ -310,5 +255,6 @@ module.exports = {
   isTextBinaryFrame,
   isValidOpcode,
   parseExtensions,
-  isValidClientWindowBits
+  isValidClientWindowBits,
+  toArrayBuffer
 }