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

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

Add abortSignal?.aborted 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.

* chore: bump @gravity-ui/nodekit devDependency to ^2.10.1

Author: melikhov-dev

package-lock.json

@@ -30,7 +30,7 @@
     "@commitlint/cli": "^17.7.1",
     "@commitlint/config-conventional": "^17.7.0",
     "@gravity-ui/eslint-config": "^3.2.0",
-    "@gravity-ui/nodekit": "^2.7.0",
+    "@gravity-ui/nodekit": "^2.10.1",
     "@gravity-ui/prettier-config": "^1.1.0",
     "@gravity-ui/tsconfig": "^1.0.0",
     "@types/accept-language-parser": "^1.5.6",

package.json

@@ -23,6 +23,11 @@ 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;
+        // Skip creating child context if parent is already ended (e.g. client disconnected).
+        // Optional chaining for backward compatibility with nodekit < 2.5.0 (no abortSignal).
+        if (reqCtx.abortSignal?.aborted) {
+            return next();
+        }
         const ctx = reqCtx.create(`${fn.name || `noname-${i}`} middleware`);
 
         let ended = false;
@@ -54,6 +59,11 @@ function wrapRouteHandler(fn: AppRouteHandler, handlerName?: string) {
     const handlerNameLocal = handlerName || fn.name || UNNAMED_CONTROLLER;
 
     const handler: AppMiddleware = async (req, res, next) => {
+        // Skip creating child context if parent is already ended (e.g. client disconnected).
+        // Optional chaining for backward compatibility with nodekit < 2.5.0 (no abortSignal).
+        if (req.originalContext.abortSignal?.aborted) {
+            return;
+        }
         req.ctx = req.originalContext.create(handlerNameLocal);
         if (req.routeInfo.handlerName !== handlerNameLocal) {
             if (req.routeInfo.handlerName === UNNAMED_CONTROLLER) {

src/router.ts

@@ -326,4 +326,76 @@ describe('Context Lifecycle', () => {
             expect(middlewareOriginalCtx!.abortSignal.aborted).toBe(true);
         });
     });
+
+    describe('Client Disconnect Handling', () => {
+        it('should skip next middleware when context is already ended', async () => {
+            let slowMiddlewareCalled = false;
+            let nextMiddlewareCalled = 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 nextMiddleware = (_req: Request, _res: Response, next: NextFunction) => {
+                nextMiddlewareCalled = true;
+                next();
+            };
+
+            const nodekit = new NodeKit();
+            const app = new ExpressKit(nodekit, {
+                'GET /test': {
+                    beforeAuth: [slowMiddleware, nextMiddleware],
+                    handler: (_req: Request, res: Response) => {
+                        res.json({ok: true});
+                    },
+                },
+            });
+
+            await request
+                .agent(app.express)
+                .get('/test')
+                .catch(() => {});
+
+            expect(slowMiddlewareCalled).toBe(true);
+            expect(nextMiddlewareCalled).toBe(false);
+        });
+
+        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(() => {});
+        });
+    });
 });