fix: support default error handler (#2)

fix #1

Author: azu

src/express-lazy-router.ts

@@ -27,25 +27,28 @@ export function createLazyRouter(options: createLazyLoaderOptions = {}) {
      */
     return function lazyRouter(resolver: () => Promise<{ default: express.Router } | express.Router>) {
         const lazyRouter = express.Router();
-        let alreadyLoaded = false;
+        // Preserve loading order of router for default error handler
+        // https://github.com/azu/express-lazy-router/issues/1
+        let loadedRouter: express.Router;
         const resolveResolver = () => {
             return resolver().then((router) => {
-                alreadyLoaded = true;
                 if ("default" in router) {
-                    lazyRouter.use(router.default);
+                    loadedRouter = router.default;
                 } else {
-                    lazyRouter.use(router);
+                    loadedRouter = router;
                 }
             });
         };
-        lazyRouter.use((_req, _res, next) => {
-            if (alreadyLoaded) {
-                return next();
+        lazyRouter.use((req, res, next) => {
+            if (loadedRouter) {
+                // @ts-expect-error: Router#handle is not public?
+                return loadedRouter.handle(req, res, next);
             } else {
                 // first request handler
                 resolveResolver()
                     .then(() => {
-                        next();
+                        // @ts-expect-error: Router#handle is not public?
+                        return loadedRouter.handle(req, res, next);
                     })
                     .catch((error) => {
                         next(error);

test/express-lazy-router.test.ts

@@ -1,4 +1,4 @@
-import express, { RequestHandler } from "express";
+import express, { ErrorRequestHandler, RequestHandler } from "express";
 import request from "supertest";
 
 import { createLazyRouter } from "../src/express-lazy-router";
@@ -65,6 +65,37 @@ describe("express-lazy-router", function () {
                     requestTracker.verify();
                 });
         });
+        it("should work with default(last) error handing ", async () => {
+            const app = express();
+            const expectedError = new Error("ERROR IN REQUEST HANDLER");
+            const requestTracker = new assert.CallTracker();
+            const defaultErrorTracker = new assert.CallTracker();
+            const shouldBeCalled = defaultErrorTracker.calls(() => {}, 1);
+            const requestHandler: RequestHandler = requestTracker.calls((_, _res, next) => {
+                next(expectedError);
+            }, 1);
+            app.use(
+                "/test",
+                lazyLoad(async () => createMockRouter(requestHandler))
+            );
+            app.use(((err, _req, res, _next) => {
+                shouldBeCalled();
+                assert.strictEqual(err.message, expectedError.message);
+                res.status(400).json({
+                    ok: false
+                });
+            }) as ErrorRequestHandler);
+            return request(app)
+                .get("/test")
+                .set("Accept", "application/json")
+                .expect("Content-Type", /json/)
+                .expect(400)
+                .then((res) => {
+                    assert.deepStrictEqual(res.body, { ok: false });
+                    requestTracker.verify();
+                    defaultErrorTracker.verify();
+                });
+        });
         it("should lazy load router when receive request", () => {
             const app = express();
             const requestTracker = new assert.CallTracker();