fix: pass user middleware chain when calling their error handler

Author: gregorygaines

src/middleware/propagate_error_to_client_error_handle.ts

@@ -49,6 +49,8 @@ export const createPropagateErrorToClientErrorHandleMiddleware = (
 ): ErrorHandle => {
   const userFunctionErrorHandle =
     getFirstUserFunctionErrorHandleMiddleware(userFunction);
+  const nextMiddlewareAfterErrorHandleMiddleware =
+    getNextMiddlewareAfterErrorMiddleware(userFunction);
 
   return function (
     err: Error,
@@ -58,6 +60,16 @@ export const createPropagateErrorToClientErrorHandleMiddleware = (
   ) {
     // Propagate error to user function error handle.
     if (userFunctionErrorHandle) {
+      // If the user has a further middleware stack after the error handle middleware,
+      // continue the chain, otherwise, propagate to the default error handle.
+      if (nextMiddlewareAfterErrorHandleMiddleware) {
+        return userFunctionErrorHandle(
+          err,
+          req,
+          res,
+          nextMiddlewareAfterErrorHandleMiddleware
+        );
+      }
       return userFunctionErrorHandle(err, req, res, next);
     }
 
@@ -73,17 +85,50 @@ export const createPropagateErrorToClientErrorHandleMiddleware = (
 const getFirstUserFunctionErrorHandleMiddleware = (
   userFunction: HandlerFunction
 ): ErrorHandle | null => {
+  const errorHandleMiddlewareIndex =
+    getFirstUserFunctionErrorHandleMiddlewareIndex(userFunction);
+  if (!errorHandleMiddlewareIndex) {
+    return null;
+  }
+
+  return (userFunction as Express)._router.stack[errorHandleMiddlewareIndex]
+    .handle as unknown as ErrorHandle;
+};
+
+const getNextMiddlewareAfterErrorMiddleware = (
+  userFunction: HandlerFunction
+): NextFunction | null => {
+  const errorHandleMiddlewareIndex =
+    getFirstUserFunctionErrorHandleMiddlewareIndex(userFunction);
+  if (!errorHandleMiddlewareIndex) {
+    return null;
+  }
+
+  const nextMiddlewareAfterErrorHandleIndex = errorHandleMiddlewareIndex + 1;
+  const middlewares: ILayer[] = (userFunction as Express)._router.stack;
+  if (middlewares.length - 1 < nextMiddlewareAfterErrorHandleIndex) {
+    return null;
+  }
+
+  return middlewares[nextMiddlewareAfterErrorHandleIndex]
+    .handle as NextFunction;
+};
+
+const getFirstUserFunctionErrorHandleMiddlewareIndex = (
+  userFunction: HandlerFunction
+): number | null => {
   if (!isExpressApp(userFunction)) {
     return null;
   }
 
   const middlewares: ILayer[] = (userFunction as Express)._router.stack;
-  for (const middleware of middlewares) {
+  for (let index = 0; index < middlewares.length; index++) {
+    const middleware = middlewares[index];
     if (
       middleware.handle &&
       middleware.handle.length === EXPRESS_ERROR_HANDLE_PARAM_LENGTH
     ) {
-      return middleware.handle as unknown as ErrorHandle;
+      return index;
     }
   }
 

test/middleware/propagate_error_to_client_error_handle.ts

@@ -49,6 +49,46 @@ describe('propagateErrorToClientErrorHandleMiddleware', () => {
     assert.strictEqual((next as sinon.SinonSpy).called, false);
   });
 
+  it('user express app with error handle calls user function app error handle and subsequent middleware', () => {
+    const app = express();
+    app.use(
+      (
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _err: Error,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _req: Request,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _res: Response,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        next: NextFunction
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ): any => {
+        next();
+      }
+    );
+    app.use(
+      (
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _err: Error,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _req: Request,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _res: Response,
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        _next: NextFunction
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      ): any => {
+        errListener();
+      }
+    );
+
+    const middleware = createPropagateErrorToClientErrorHandleMiddleware(app);
+    middleware(error, request, response, next);
+
+    assert.strictEqual((errListener as sinon.SinonSpy).called, true);
+    assert.strictEqual((next as sinon.SinonSpy).called, false);
+  });
+
   it('user express app without error handle calls default express error handle', () => {
     const app = express();