node:http: hand a pipelined Upgrade request to 'upgrade' and keep its writes behind the responses ahead

packages/bun-uws/src/HttpContext.h

@@ -820,10 +820,6 @@ struct HttpContext {
 
         auto *httpContextData = getSocketContextDataS(s);
 
-
-        if (httpResponseData->isConnectRequest && httpResponseData->socketData && httpContextData->onSocketDrain) {
-            httpContextData->onSocketDrain(httpResponseData->socketData, SSL, (struct us_socket_t *) s);
-        }
         /* Ask the developer to write data and return success (true) or failure (false), OR skip sending anything and return success (true). */
         if (httpResponseData->onWritable) {
             /* We are now writable, so hang timeout again, the user does not have to do anything so we should hang until end or tryEnd rearms timeout */
@@ -862,6 +858,15 @@ struct HttpContext {
         /* Drain any socket buffer, this might empty our backpressure and thus finish the request */
         asyncSocket->flush();
 
+        /* node:http compat: a tunnel's own writes go out once the responses ahead owe nothing more. */
+        if constexpr (IsNodeHttp) {
+            bool tunnel = httpResponseData->isConnectRequest || (httpResponseData->state & HttpResponseData<SSL>::HTTP_NODE_TUNNEL_AFTER_BODY);
+            if (tunnel && httpResponseData->socketData && httpContextData->onSocketDrain
+                && httpResponseData->onWritable == nullptr && asyncSocket->getBufferedAmount() == 0) {
+                httpContextData->onSocketDrain(httpResponseData->socketData, SSL, (struct us_socket_t *) s);
+            }
+        }
+
         /* node:http compat: reads were paused while pipelined responses were
          * queued and stayed paused because the socket still had outgoing
          * backpressure when the queue drained; now that it has flushed, read

packages/bun-uws/src/HttpResponseData.h

@@ -233,6 +233,10 @@ struct HttpResponseData : AsyncSocketData<SSL>, HttpParser {
     /* Whether the connection should be torn down once the in-flight response (if
      * any) has completed and all buffered outgoing data has been flushed. */
     bool shouldCloseConnection() const {
+        /* node:http: a tunnel queued behind this response ends the connection itself, after its parked bytes. */
+        if ((isConnectRequest || (state & HTTP_NODE_TUNNEL_AFTER_BODY)) && nodeHttpQueuedPipelinedCount > 0) {
+            return false;
+        }
         return (state & HTTP_CONNECTION_CLOSE)
             || ((state & HTTP_NODE_RECEIVED_FIN) && nodeHttpQueuedPipelinedCount == 0)
             || ((state & HTTP_CLOSE_WHEN_IDLE) && this->isIdle);

src/js/internal/http.ts

@@ -41,6 +41,8 @@ const kPendingCallbacks = Symbol("pendingCallbacks");
 const kRequest = Symbol("request");
 // Set on a server socket at the 'connect'/'upgrade' handoff: the native response of that request.
 const kHandoffResponse = Symbol("kHandoffResponse");
+// Server socket method: run a callback once the 'connect'/'upgrade' hand-off owns the connection.
+const kOnHandoffActive = Symbol("kOnHandoffActive");
 const kCloseCallback = Symbol("closeCallback");
 
 // node:_http_server registers its pipelined-response machinery here at module
@@ -526,6 +528,7 @@ export {
   kHandoffResponse,
   kInternalSocketData,
   kNeedDrain,
+  kOnHandoffActive,
   kOutHeaders,
   kPendingCallbacks,
   kPerRequestCheckServerIdentity,