http: add req.signal to IncomingMessage

PR-URL: #62541
Fixes: #62481
Reviewed-By: Robert Nagy <ronagy@icloud.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Tim Perry <pimterry@gmail.com>

Author: akshatsrivastava11

doc/api/http.md

@@ -2989,6 +2989,51 @@ added: v0.5.9
 
 Calls `message.socket.setTimeout(msecs, callback)`.
 
+### `message.signal`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* Type: {AbortSignal}
+
+An {AbortSignal} that is aborted when the underlying socket closes or the
+request is destroyed. The signal is created lazily on first access — no
+{AbortController} is allocated for requests that never use this property.
+
+This is useful for cancelling downstream asynchronous work such as database
+queries or `fetch` calls when a client disconnects mid-request.
+
+```mjs
+import http from 'node:http';
+
+http.createServer(async (req, res) => {
+  try {
+    const data = await fetch('https://example.com/api', { signal: req.signal });
+    res.end(JSON.stringify(await data.json()));
+  } catch (err) {
+    if (err.name === 'AbortError') return;
+    res.statusCode = 500;
+    res.end('Internal Server Error');
+  }
+}).listen(3000);
+```
+
+```cjs
+const http = require('node:http');
+
+http.createServer(async (req, res) => {
+  try {
+    const data = await fetch('https://example.com/api', { signal: req.signal });
+    res.end(JSON.stringify(await data.json()));
+  } catch (err) {
+    if (err.name === 'AbortError') return;
+    res.statusCode = 500;
+    res.end('Internal Server Error');
+  }
+}).listen(3000);
+```
+
 ### `message.socket`
 
 <!-- YAML

lib/_http_incoming.js

@@ -29,12 +29,15 @@ const {
 
 const { Readable, finished } = require('stream');
 
+const { AbortController } = require('internal/abort_controller');
+
 const kHeaders = Symbol('kHeaders');
 const kHeadersDistinct = Symbol('kHeadersDistinct');
 const kHeadersCount = Symbol('kHeadersCount');
 const kTrailers = Symbol('kTrailers');
 const kTrailersDistinct = Symbol('kTrailersDistinct');
 const kTrailersCount = Symbol('kTrailersCount');
+const kAbortController = Symbol('kAbortController');
 
 function readStart(socket) {
   if (socket && !socket._paused && socket.readable)
@@ -90,6 +93,7 @@ function IncomingMessage(socket) {
   // Flag for when we decide that this message cannot possibly be
   // read by the user, so there's no point continuing to handle it.
   this._dumped = false;
+  this[kAbortController] = null;
 }
 ObjectSetPrototypeOf(IncomingMessage.prototype, Readable.prototype);
 ObjectSetPrototypeOf(IncomingMessage, Readable);
@@ -184,6 +188,25 @@ ObjectDefineProperty(IncomingMessage.prototype, 'trailersDistinct', {
   },
 });
 
+ObjectDefineProperty(IncomingMessage.prototype, 'signal', {
+  __proto__: null,
+  configurable: true,
+  get: function() {
+    if (this[kAbortController] === null) {
+      const ac = new AbortController();
+      this[kAbortController] = ac;
+      if (this.destroyed) {
+        ac.abort();
+      } else {
+        this.once('close', function() {
+          ac.abort();
+        });
+      }
+    }
+    return this[kAbortController].signal;
+  },
+});
+
 IncomingMessage.prototype.setTimeout = function setTimeout(msecs, callback) {
   if (callback)
     this.on('timeout', callback);

test/parallel/test-http-request-signal.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const http = require('http');
+
+// Test 1: req.signal is an AbortSignal and aborts on 'close'
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    assert.ok(req.signal instanceof AbortSignal);
+    assert.strictEqual(req.signal.aborted, false);
+    req.signal.onabort = common.mustCall(() => {
+      assert.strictEqual(req.signal.aborted, true);
+    });
+    res.destroy();
+  }));
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, () => {}).on('error', () => {
+      server.close();
+    });
+  }));
+}
+
+// Test 2: req.signal is aborted if accessed after destroy
+{
+  const req = new http.IncomingMessage(null);
+  req.destroy();
+  assert.strictEqual(req.signal.aborted, true);
+}
+
+// Test 3: Multiple accesses return the same signal
+{
+  const req = new http.IncomingMessage(null);
+  assert.strictEqual(req.signal, req.signal);
+}
+
+
+// Test 4: res.signal on a client-side http.request() response (IncomingMessage).
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.writeHead(200);
+    res.write('partial');
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const clientReq = http.request(
+      { port: server.address().port },
+      common.mustCall((res) => {
+        assert.ok(res.signal instanceof AbortSignal);
+        assert.strictEqual(res.signal.aborted, false);
+
+        res.signal.onabort = common.mustCall(() => {
+          assert.strictEqual(res.signal.aborted, true);
+          server.close();
+        });
+        clientReq.destroy();
+      }),
+    );
+    clientReq.on('error', () => {});
+    clientReq.end();
+  }));
+}
+
+// Test 5: Client cancels a pending request.
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    req.signal.onabort = common.mustCall(() => {
+      assert.strictEqual(req.signal.aborted, true);
+      server.close();
+    });
+    res.flushHeaders();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    const clientReq = http.request(
+      { port: server.address().port },
+      common.mustCall((res) => {
+        res.on('error', () => {});
+        clientReq.destroy();
+      }),
+    );
+    clientReq.on('error', () => {});
+    clientReq.end();
+  }));
+}