fix: guard ctx.create() against ended context after client disconnect

Add isEnded() checks in wrapMiddleware and wrapRouteHandler to prevent
crashes when middleware or route handlers run after the client disconnects
and the original context is already ended.

Author: melikhov-dev

src/router.ts

@@ -23,6 +23,9 @@ function isAllowedMethod(method: string): method is Lowercase<HttpMethod> | 'mou
 function wrapMiddleware(fn: AppMiddleware, i?: number): AppMiddleware {
     const result: AppMiddleware = async (req, res, next) => {
         const reqCtx = req.ctx;
+        if (reqCtx.isEnded()) {
+            return next();
+        }
         const ctx = reqCtx.create(`${fn.name || `noname-${i}`} middleware`);
 
         let ended = false;
@@ -54,6 +57,9 @@ function wrapRouteHandler(fn: AppRouteHandler, handlerName?: string) {
     const handlerNameLocal = handlerName || fn.name || UNNAMED_CONTROLLER;
 
     const handler: AppMiddleware = async (req, res, next) => {
+        if (req.originalContext.isEnded()) {
+            return;
+        }
         req.ctx = req.originalContext.create(handlerNameLocal);
         if (req.routeInfo.handlerName !== handlerNameLocal) {
             if (req.routeInfo.handlerName === UNNAMED_CONTROLLER) {

src/tests/context-lifecycle.test.ts

@@ -326,4 +326,69 @@ describe('Context Lifecycle', () => {
             expect(middlewareOriginalCtx!.abortSignal.aborted).toBe(true);
         });
     });
+
+    describe('Client Disconnect Handling', () => {
+        it('should not throw when middleware runs after client disconnect', async () => {
+            let slowMiddlewareCalled = false;
+
+            const slowMiddleware = async (req: Request, _res: Response, next: NextFunction) => {
+                slowMiddlewareCalled = true;
+                // Simulate client disconnect by destroying the socket
+                req.socket.destroy();
+                // Wait for the close event handler's setImmediate to end the context
+                await new Promise<void>((resolve) => {
+                    setImmediate(() => setImmediate(() => setImmediate(resolve)));
+                });
+                next();
+            };
+
+            const nodekit = new NodeKit();
+            const app = new ExpressKit(nodekit, {
+                'GET /test': {
+                    beforeAuth: [slowMiddleware],
+                    handler: (_req: Request, res: Response) => {
+                        res.json({ok: true});
+                    },
+                },
+            });
+
+            await request
+                .agent(app.express)
+                .get('/test')
+                .catch(() => {});
+
+            expect(slowMiddlewareCalled).toBe(true);
+        });
+
+        it('should not throw when route handler runs after client disconnect', async () => {
+            const disconnectMiddleware = async (
+                req: Request,
+                _res: Response,
+                next: NextFunction,
+            ) => {
+                // Simulate client disconnect by destroying the socket
+                req.socket.destroy();
+                // Wait for the close event handler's setImmediate to end the context
+                await new Promise<void>((resolve) => {
+                    setImmediate(() => setImmediate(() => setImmediate(resolve)));
+                });
+                next();
+            };
+
+            const nodekit = new NodeKit();
+            const app = new ExpressKit(nodekit, {
+                'GET /test': {
+                    beforeAuth: [disconnectMiddleware],
+                    handler: (_req: Request, res: Response) => {
+                        res.json({ok: true});
+                    },
+                },
+            });
+
+            await request
+                .agent(app.express)
+                .get('/test')
+                .catch(() => {});
+        });
+    });
 });