http: add req.signal to IncomingMessage

PR-URL: #62541Fixes: #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

@@ -2966,6 +2966,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
+importhttpfrom'node:http';
+
+http.createServer(async (req, res) => {
+try {
+constdata=awaitfetch('https://example.com/api', { signal:req.signal });
+res.end(JSON.stringify(awaitdata.json()));
+ } catch (err) {
+if (err.name==='AbortError') return;
+res.statusCode=500;
+res.end('Internal Server Error');
+ }
+}).listen(3000);
+```
+
+```cjs
+consthttp=require('node:http');
+
+http.createServer(async (req, res) => {
+try {
+constdata=awaitfetch('https://example.com/api', { signal:req.signal });
+res.end(JSON.stringify(awaitdata.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');
+
 constkHeaders=Symbol('kHeaders');
 constkHeadersDistinct=Symbol('kHeadersDistinct');
 constkHeadersCount=Symbol('kHeadersCount');
 constkTrailers=Symbol('kTrailers');
 constkTrailersDistinct=Symbol('kTrailersDistinct');
 constkTrailersCount=Symbol('kTrailersCount');
+constkAbortController=Symbol('kAbortController');
 
 functionreadStart(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){
+constac=newAbortController();
+this[kAbortController]=ac;
+if(this.destroyed){
+ac.abort();
+}else{
+this.once('close',function(){
+ac.abort();
+});
+}
+}
+returnthis[kAbortController].signal;
+},
+});
+
 IncomingMessage.prototype.setTimeout=functionsetTimeout(msecs,callback){
 if(callback)
 this.on('timeout',callback);

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

@@ -0,0 +1,85 @@
+'use strict';
+
+constcommon=require('../common');
+constassert=require('assert');
+consthttp=require('http');
+
+// Test 1: req.signal is an AbortSignal and aborts on 'close'
+{
+constserver=http.createServer(common.mustCall((req,res)=>{
+assert.ok(req.signalinstanceofAbortSignal);
+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
+{
+constreq=newhttp.IncomingMessage(null);
+req.destroy();
+assert.strictEqual(req.signal.aborted,true);
+}
+
+// Test 3: Multiple accesses return the same signal
+{
+constreq=newhttp.IncomingMessage(null);
+assert.strictEqual(req.signal,req.signal);
+}
+
+
+// Test 4: res.signal on a client-side http.request() response (IncomingMessage).
+{
+constserver=http.createServer(common.mustCall((req,res)=>{
+res.writeHead(200);
+res.write('partial');
+}));
+
+server.listen(0,common.mustCall(()=>{
+constclientReq=http.request(
+{port: server.address().port},
+common.mustCall((res)=>{
+assert.ok(res.signalinstanceofAbortSignal);
+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.
+{
+constserver=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(()=>{
+constclientReq=http.request(
+{port: server.address().port},
+common.mustCall((res)=>{
+res.on('error',()=>{});
+clientReq.destroy();
+}),
+);
+clientReq.on('error',()=>{});
+clientReq.end();
+}));
+}