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>;
@@ -75,6 +75,16 @@ export interface CommonConfig<TAG extends string = string> {
   tags?: TagsConfig<TAG>;
 }
 
+export type BeforeUpload = (params: {
+  request: Request;
+  logger: AbstractLogger;
+}) => void | Promise<void>;
+
+type BeforeRouting = (params: {
+  app: IRouter;
+  logger: AbstractLogger;
+}) => void | Promise<void>;
+
 type UploadOptions = Pick<
   fileUpload.Options,
   | "createParentPath"
@@ -95,24 +105,18 @@ 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 handler to execute before uploading — it can be used for restrictions by throwing an error.
    * @default undefined
-   * @example ({ app }) => { app.use( ... ); }
+   * @example ({request}) => { throw createHttpError(403, "Not authorized"); }
    * */
-  beforeUpload?: AppExtension;
+  beforeUpload?: BeforeUpload;
 };
 
 type CompressionOptions = Pick<
   compression.CompressionOptions,
   "threshold" | "level" | "strategy" | "chunkSize" | "memLevel"
 >;
 
-type AppExtension = (params: {
-  app: IRouter;
-  logger: AbstractLogger;
-}) => void | Promise<void>;
-
 export interface ServerConfig<TAG extends string = string>
   extends CommonConfig<TAG> {
   /** @desc Server configuration. */
@@ -127,13 +131,13 @@ export interface ServerConfig<TAG extends string = string>
     jsonParser?: RequestHandler;
     /**
      * @desc Enable or configure uploads handling.
-     * @default false
+     * @default undefined
      * @requires express-fileupload
      * */
     upload?: boolean | UploadOptions;
     /**
      * @desc Enable or configure response compression.
-     * @default false
+     * @default undefined
      * @requires compression
      */
     compression?: boolean | CompressionOptions;
@@ -152,7 +156,7 @@ export interface ServerConfig<TAG extends string = string>
      * @default undefined
      * @example ({ app }) => { app.use('/docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument)); }
      * */
-    beforeRouting?: AppExtension;
+    beforeRouting?: BeforeRouting;
   };
   /** @desc Enables HTTPS server as well. */
   https?: {

src/routing.ts

@@ -1,10 +1,13 @@
-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 { metaSymbol } from "./metadata";
 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 +18,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[metaSymbol]?.logger || rootLogger,
           config,
           siblingMethods,
         });

src/server-helpers.ts

@@ -1,7 +1,9 @@
+import type fileUpload from "express-fileupload";
+import { metaSymbol } from "./metadata";
 import { AnyResultHandlerDefinition } from "./result-handler";
 import { AbstractLogger } from "./logger";
-import { CommonConfig } from "./config-type";
-import { ErrorRequestHandler, RequestHandler } from "express";
+import { BeforeUpload, CommonConfig } from "./config-type";
+import { ErrorRequestHandler, RequestHandler, Response } from "express";
 import createHttpError, { isHttpError } from "http-errors";
 import { lastResortHandler } from "./last-resort";
 import { ResultHandlerError } from "./errors";
@@ -10,16 +12,16 @@ import { makeErrorFromAnything } from "./common-helpers";
 interface HandlerCreatorParams {
   errorHandler: AnyResultHandlerDefinition;
   rootLogger: AbstractLogger;
-  getChildLogger: CommonConfig["childLoggerProvider"];
 }
 
+export type LocalResponse = Response<
+  unknown,
+  { [metaSymbol]?: { 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 +34,18 @@ export const createParserFailureHandler =
       input: null,
       output: null,
       options: {},
-      logger: getChildLogger
-        ? await getChildLogger({ request, parent: rootLogger })
-        : rootLogger,
+      logger: response.locals[metaSymbol]?.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[metaSymbol]?.logger || rootLogger;
     try {
       errorHandler.handler({
         request,
@@ -86,9 +80,57 @@ 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 createUploadMiddleware =
+  ({
+    options,
+    uploader,
+    rootLogger,
+    beforeUpload,
+  }: {
+    options: fileUpload.Options;
+    uploader: typeof fileUpload;
+    rootLogger: AbstractLogger;
+    beforeUpload?: BeforeUpload;
+  }): RequestHandler =>
+  async (request, response: LocalResponse, next) => {
+    const logger = response.locals[metaSymbol]?.logger || rootLogger;
+    try {
+      await beforeUpload?.({ request, logger });
+    } catch (error) {
+      return next(error);
+    }
+    uploader({
+      ...options,
+      abortOnLimit: false,
+      parseNested: true,
+      logger: createUploadLogger(logger),
+    })(request, response, next);
+  };
+
+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[metaSymbol] = { logger };
+    next();
+  };

src/server.ts

@@ -1,18 +1,21 @@
-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 {
+  createLoggingMiddleware,
   createNotFoundHandler,
   createParserFailureHandler,
   createUploadFailueHandler,
-  createUploadLogger,
+  createUploadMiddleware,
+  rawMover,
 } from "./server-helpers";
 import { getStartupLogo } from "./startup-logo";
 
@@ -25,8 +28,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 };
@@ -40,6 +42,10 @@ export const attachRouting = (config: AppConfig, routing: Routing) => {
 
 export const createServer = async (config: ServerConfig, routing: Routing) => {
   const app = express().disable("x-powered-by");
+  const { rootLogger, notFoundHandler, parserFailureHandler } =
+    makeCommonEntities(config);
+  app.use(createLoggingMiddleware({ rootLogger, config }));
+
   if (config.server.compression) {
     const compressor = await loadPeer<typeof compression>("compression");
     app.use(
@@ -50,46 +56,40 @@ export const createServer = async (config: ServerConfig, routing: Routing) => {
       ),
     );
   }
-  app.use(config.server.jsonParser || express.json());
 
-  const { rootLogger, notFoundHandler, parserFailureHandler } =
-    makeCommonEntities(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 } = {
+    const { limitError, beforeUpload, ...options } = {
       ...(typeof config.server.upload === "object" && config.server.upload),
     };
-    if (beforeUpload) {
-      beforeUpload({ app, logger: rootLogger });
-    }
-    app.use(
-      uploader({
-        ...derivedConfig,
-        abortOnLimit: false,
-        parseNested: true,
-        logger: createUploadLogger(rootLogger),
-      }),
+    parsers.upload.push(
+      createUploadMiddleware({ uploader, options, rootLogger, beforeUpload }),
     );
     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 });
-  app.use(notFoundHandler);
+
+  initRouting({
+    app,
+    routing,
+    rootLogger,
+    config,
+    parsers,
+  });
+  app.use(parserFailureHandler, notFoundHandler);
 
   const starter = <T extends http.Server | https.Server>(
     server: T,

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();
     });