Feat: Selective parsers with child logger

src/config-type.ts

@@ -28,7 +28,7 @@ export type TagsConfig<TAG extends string> = Record<
   string | { description: string; url?: string }
 >;
 
-type ChildLoggerProvider = (params: {
+export type ChildLoggerProvider = (params: {
   request: Request;
   parent: AbstractLogger;
 }) => AbstractLogger | Promise<AbstractLogger>;
@@ -95,12 +95,13 @@ type UploadOptions = Pick<
    * */
   limitError?: Error;
   /**
-   * @desc A code to execute before connecting the upload middleware.
-   * @desc It can be used to connect a middleware that restricts the ability to upload.
+   * @desc A middleware to execute before processing uploads.
+   * @desc It can be used to restrict the ability to upload.
+   * @since v19 must call next() or next(err) within
    * @default undefined
-   * @example ({ app }) => { app.use( ... ); }
+   * @example (req, res, next) => next(createHttpError(403, "Not authorized")
    * */
-  beforeUpload?: AppExtension;
+  beforeUpload?: RequestHandler;
 };
 
 type CompressionOptions = Pick<

src/routing.ts

@@ -1,10 +1,12 @@
-import { IRouter } from "express";
+import { IRouter, RequestHandler } from "express";
 import { CommonConfig } from "./config-type";
+import { ContentType } from "./content-type";
 import { DependsOnMethod } from "./depends-on-method";
 import { AbstractEndpoint } from "./endpoint";
 import { AbstractLogger } from "./logger";
 import { walkRouting } from "./routing-walker";
 import { ServeStatic } from "./serve-static";
+import { LocalResponse } from "./server-helpers";
 
 export interface Routing {
   [SEGMENT: string]: Routing | DependsOnMethod | AbstractEndpoint | ServeStatic;
@@ -15,25 +17,27 @@ export const initRouting = ({
   rootLogger,
   config,
   routing,
+  parsers,
 }: {
   app: IRouter;
   rootLogger: AbstractLogger;
   config: CommonConfig;
   routing: Routing;
+  parsers?: Record<ContentType, RequestHandler[]>;
 }) =>
   walkRouting({
     routing,
     hasCors: !!config.cors,
     onEndpoint: (endpoint, path, method, siblingMethods) => {
-      app[method](path, async (request, response) => {
-        const logger = config.childLoggerProvider
-          ? await config.childLoggerProvider({ request, parent: rootLogger })
-          : rootLogger;
-        logger.info(`${request.method}: ${path}`);
+      const middlewares = parsers?.[endpoint.getRequestType()] || [];
+      if (middlewares.length) {
+        app.use(path, middlewares);
+      }
+      app[method](path, async (request, response: LocalResponse) => {
         await endpoint.execute({
           request,
           response,
-          logger,
+          logger: response.locals.logger || rootLogger,
           config,
           siblingMethods,
         });

src/server-helpers.ts

@@ -1,7 +1,7 @@
 import { AnyResultHandlerDefinition } from "./result-handler";
 import { AbstractLogger } from "./logger";
 import { CommonConfig } from "./config-type";
-import { ErrorRequestHandler, RequestHandler } from "express";
+import { ErrorRequestHandler, RequestHandler, Response } from "express";
 import createHttpError, { isHttpError } from "http-errors";
 import { lastResortHandler } from "./last-resort";
 import { ResultHandlerError } from "./errors";
@@ -10,16 +10,13 @@ import { makeErrorFromAnything } from "./common-helpers";
 interface HandlerCreatorParams {
   errorHandler: AnyResultHandlerDefinition;
   rootLogger: AbstractLogger;
-  getChildLogger: CommonConfig["childLoggerProvider"];
 }
 
+export type LocalResponse = Response<unknown, { logger?: AbstractLogger }>;
+
 export const createParserFailureHandler =
-  ({
-    errorHandler,
-    rootLogger,
-    getChildLogger,
-  }: HandlerCreatorParams): ErrorRequestHandler =>
-  async (error, request, response, next) => {
+  ({ errorHandler, rootLogger }: HandlerCreatorParams): ErrorRequestHandler =>
+  async (error, request, response: LocalResponse, next) => {
     if (!error) {
       return next();
     }
@@ -32,26 +29,18 @@ export const createParserFailureHandler =
       input: null,
       output: null,
       options: {},
-      logger: getChildLogger
-        ? await getChildLogger({ request, parent: rootLogger })
-        : rootLogger,
+      logger: response.locals.logger || rootLogger,
     });
   };
 
 export const createNotFoundHandler =
-  ({
-    errorHandler,
-    getChildLogger,
-    rootLogger,
-  }: HandlerCreatorParams): RequestHandler =>
-  async (request, response) => {
+  ({ errorHandler, rootLogger }: HandlerCreatorParams): RequestHandler =>
+  async (request, response: LocalResponse) => {
     const error = createHttpError(
       404,
       `Can not ${request.method} ${request.path}`,
     );
-    const logger = getChildLogger
-      ? await getChildLogger({ request, parent: rootLogger })
-      : rootLogger;
+    const logger = response.locals.logger || rootLogger;
     try {
       errorHandler.handler({
         request,
@@ -86,9 +75,30 @@ export const createUploadFailueHandler =
 export const createUploadLogger = (
   logger: AbstractLogger,
 ): Pick<Console, "log"> => ({
-  log: (message, ...rest) => {
-    if (!/not eligible/.test(message)) {
-      logger.debug(message, ...rest);
-    }
-  },
+  log: logger.debug.bind(logger),
 });
+
+export const rawMover: RequestHandler = (req, {}, next) => {
+  if (Buffer.isBuffer(req.body)) {
+    req.body = { raw: req.body };
+  }
+  next();
+};
+
+/** @since v19 prints the actual path of the request, not a configured route */
+export const createLoggingMiddleware =
+  ({
+    rootLogger,
+    config,
+  }: {
+    rootLogger: AbstractLogger;
+    config: CommonConfig;
+  }): RequestHandler =>
+  async (request, response: LocalResponse, next) => {
+    const logger = config.childLoggerProvider
+      ? await config.childLoggerProvider({ request, parent: rootLogger })
+      : rootLogger;
+    logger.info(`${request.method}: ${request.path}`);
+    response.locals.logger = logger;
+    next();
+  };

src/server.ts

@@ -1,18 +1,22 @@
-import express from "express";
+import express, { RequestHandler } from "express";
 import type compression from "compression";
 import type fileUpload from "express-fileupload";
 import http from "node:http";
 import https from "node:https";
 import { AppConfig, CommonConfig, ServerConfig } from "./config-type";
+import { ContentType } from "./content-type";
 import { AbstractLogger, createLogger, isBuiltinLoggerConfig } from "./logger";
 import { loadPeer } from "./peer-helpers";
 import { defaultResultHandler } from "./result-handler";
 import { Routing, initRouting } from "./routing";
 import {
+  LocalResponse,
+  createLoggingMiddleware,
   createNotFoundHandler,
   createParserFailureHandler,
   createUploadFailueHandler,
   createUploadLogger,
+  rawMover,
 } from "./server-helpers";
 import { getStartupLogo } from "./startup-logo";
 
@@ -25,8 +29,7 @@ const makeCommonEntities = (config: CommonConfig) => {
     : config.logger;
   rootLogger.debug("Running", process.env.TSUP_BUILD || "from sources");
   const errorHandler = config.errorHandler || defaultResultHandler;
-  const { childLoggerProvider: getChildLogger } = config;
-  const creatorParams = { errorHandler, rootLogger, getChildLogger };
+  const creatorParams = { errorHandler, rootLogger };
   const notFoundHandler = createNotFoundHandler(creatorParams);
   const parserFailureHandler = createParserFailureHandler(creatorParams);
   return { rootLogger, errorHandler, notFoundHandler, parserFailureHandler };
@@ -50,45 +53,52 @@ export const createServer = async (config: ServerConfig, routing: Routing) => {
       ),
     );
   }
-  app.use(config.server.jsonParser || express.json());
 
   const { rootLogger, notFoundHandler, parserFailureHandler } =
     makeCommonEntities(config);
 
+  app.use(createLoggingMiddleware({ rootLogger, config }));
+
+  const parsers: Record<ContentType, RequestHandler[]> = {
+    json: [config.server.jsonParser || express.json()],
+    upload: [],
+    raw: [],
+  };
+
   if (config.server.upload) {
     const uploader = await loadPeer<typeof fileUpload>("express-fileupload");
     const { limitError, beforeUpload, ...derivedConfig } = {
       ...(typeof config.server.upload === "object" && config.server.upload),
     };
     if (beforeUpload) {
-      beforeUpload({ app, logger: rootLogger });
+      parsers.upload.push(beforeUpload);
     }
-    app.use(
+    parsers.upload.push((req, res: LocalResponse, next) =>
       uploader({
         ...derivedConfig,
         abortOnLimit: false,
         parseNested: true,
-        logger: createUploadLogger(rootLogger),
-      }),
+        logger: createUploadLogger(res.locals.logger || rootLogger),
+      })(req, res, next),
     );
     if (limitError) {
-      app.use(createUploadFailueHandler(limitError));
+      parsers.upload.push(createUploadFailueHandler(limitError));
     }
   }
   if (config.server.rawParser) {
-    app.use(config.server.rawParser);
-    app.use((req, {}, next) => {
-      if (Buffer.isBuffer(req.body)) {
-        req.body = { raw: req.body };
-      }
-      next();
-    });
+    parsers.raw.push(config.server.rawParser, rawMover);
   }
-  app.use(parserFailureHandler);
   if (config.server.beforeRouting) {
     await config.server.beforeRouting({ app, logger: rootLogger });
   }
-  initRouting({ app, routing, rootLogger, config });
+  initRouting({
+    app,
+    routing,
+    rootLogger,
+    config,
+    parsers,
+  });
+  app.use(parserFailureHandler);
   app.use(notFoundHandler);
 
   const starter = <T extends http.Server | https.Server>(

src/testing.ts

@@ -5,6 +5,7 @@ import { AbstractEndpoint } from "./endpoint";
 import { AbstractLogger } from "./logger";
 import { contentTypes } from "./content-type";
 import { loadAlternativePeer } from "./peer-helpers";
+import { LocalResponse } from "./server-helpers";
 
 /**
  * @desc Using module augmentation approach you can set the Mock type of your actual testing framework.
@@ -54,11 +55,13 @@ export const makeResponseMock = <RES extends Record<string, any>>({
       responseMock.writableEnded = true;
       return responseMock;
     }),
+    locals: {},
     ...responseProps,
   } as {
     writableEnded: boolean;
     statusCode: number;
     statusMessage: string;
+    locals: LocalResponse["locals"];
   } & Record<
     "set" | "setHeader" | "header" | "status" | "json" | "send" | "end",
     MockOverrides

tests/system/example.spec.ts

@@ -88,7 +88,7 @@ describe("Example", async () => {
           createdAt: "2022-01-22T00:00:00.000Z",
         },
       });
-      await waitFor(() => /v1\/user\/:id/.test(out));
+      await waitFor(() => /v1\/user\/50/.test(out));
       await waitFor(() => /50, 123, 456/.test(out));
       expect(true).toBeTruthy();
     });

tests/unit/routing.spec.ts

@@ -382,7 +382,6 @@ describe("Routing", () => {
       );
       expect(nextMock).toHaveBeenCalledTimes(0);
       expect(handlerMock).toHaveBeenCalledTimes(1);
-      expect(loggerMock.info).toHaveBeenCalledWith("POST: /v1/user/set");
       expect(loggerMock.error).toHaveBeenCalledTimes(0);
       expect(handlerMock).toHaveBeenCalledWith({
         input: {
@@ -400,7 +399,7 @@ describe("Routing", () => {
       });
     });
 
-    test("should override the logger with a child logger if provider is specified in config", async () => {
+    test("should override the logger with a child logger if present in response.locals", async () => {
       const loggerMock = makeLoggerMock({ fnMethod: vi.fn });
       const config: CommonConfig = {
         cors: false,
@@ -425,7 +424,12 @@ describe("Routing", () => {
       expect(appMock.get).toHaveBeenCalledTimes(1);
       const routeHandler = appMock.get.mock.calls[0][1] as RequestHandler;
       const requestMock = makeRequestMock({ fnMethod: vi.fn });
-      const responseMock = makeResponseMock({ fnMethod: vi.fn });
+      const responseMock = makeResponseMock({
+        fnMethod: vi.fn,
+        responseProps: {
+          locals: { logger: { ...loggerMock, isChild: true } },
+        },
+      });
       await routeHandler(
         requestMock as unknown as Request,
         responseMock as unknown as Response,