Feat: Selective parsers with child logger

CHANGELOG.md

@@ -12,6 +12,47 @@
 - Several public methods and properties exposing arrays from class instances made readonly and frozen:
   - On `Endpoint`: `.getMethods()`, `.getMimeTypes()`, `.getResponses()`, `.getScopes()`, `.getTags()`,
   - On `DependsOnMethod`: `.pairs`, `.siblingMethods`.
+- The config option `server.upload.beforeUpload` changed:
+  - The assigned function now accepts `request` instead of `app` and being called only for eligible requests;
+  - Restricting upload can be achieved now by throwing an error from within.
+- Request logging now reflects the actual path requested rather than the configured route:
+  - It is also placed in front of parsing.
+- Featuring selective parsers with child loggers:
+  - There are three types of endpoints depending on their input schema: those with upload, those with raw, and others;
+  - Depending on the type, only the parsers needed for certain endpoint are processed;
+  - This reverts changes on muting uploader logs related to non-eligible requests made in v18.5.2 (all eligible now).
+
+```ts
+import createHttpError from "http-errors";
+import { createConfig } from "express-zod-api";
+
+const before = createConfig({
+  server: {
+    upload: {
+      beforeUpload: ({ app, logger }) => {
+        app.use((req, res, next) => {
+          if (req.is("multipart/form-data") && !canUpload(req)) {
+            return next(createHttpError(403, "Not authorized"));
+          }
+          next();
+        });
+      },
+    },
+  },
+});
+
+const after = createConfig({
+  server: {
+    upload: {
+      beforeUpload: ({ request, logger }) => {
+        if (!canUpload(request)) {
+          throw createHttpError(403, "Not authorized");
+        }
+      },
+    },
+  },
+});
+```
 
 ## Version 18
 

src/config-type.ts

@@ -75,6 +75,11 @@ export interface CommonConfig<TAG extends string = string> {
   tags?: TagsConfig<TAG>;
 }
 
+type BeforeUpload = (params: {
+  request: Request;
+  logger: AbstractLogger;
+}) => void | Promise<void>;
+
 type UploadOptions = Pick<
   fileUpload.Options,
   | "createParentPath"
@@ -95,20 +100,19 @@ 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: {
+type BeforeRouting = (params: {
   app: IRouter;
   logger: AbstractLogger;
 }) => void | Promise<void>;
@@ -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,43 +1,49 @@
-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;
 }
 
+export type Parsers = Record<ContentType, RequestHandler[]>;
+
 export const initRouting = ({
   app,
   rootLogger,
   config,
   routing,
+  parsers,
 }: {
   app: IRouter;
   rootLogger: AbstractLogger;
   config: CommonConfig;
   routing: Routing;
+  parsers?: Parsers;
 }) =>
   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}`);
-        await endpoint.execute({
-          request,
-          response,
-          logger,
-          config,
-          siblingMethods,
-        });
-      });
+      app[method](
+        path,
+        ...(parsers?.[endpoint.getRequestType()] || []),
+        async (request, response: LocalResponse) =>
+          endpoint.execute({
+            request,
+            response,
+            logger: response.locals[metaSymbol]?.logger || rootLogger,
+            config,
+            siblingMethods,
+          }),
+      );
     },
     onStatic: (path, handler) => {
       app.use(path, handler);

src/server-helpers.ts

@@ -1,7 +1,10 @@
+import type fileUpload from "express-fileupload";
+import { metaSymbol } from "./metadata";
+import { loadPeer } from "./peer-helpers";
 import { AnyResultHandlerDefinition } from "./result-handler";
 import { AbstractLogger } from "./logger";
-import { CommonConfig } from "./config-type";
-import { ErrorRequestHandler, RequestHandler } from "express";
+import { ServerConfig } 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 +13,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 +35,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 +81,62 @@ 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 createUploadParsers = async ({
+  rootLogger,
+  config,
+}: {
+  rootLogger: AbstractLogger;
+  config: ServerConfig;
+}): Promise<RequestHandler[]> => {
+  const uploader = await loadPeer<typeof fileUpload>("express-fileupload");
+  const { limitError, beforeUpload, ...options } = {
+    ...(typeof config.server.upload === "object" && config.server.upload),
+  };
+  const parsers: RequestHandler[] = [];
+  parsers.push(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);
+  });
+  if (limitError) {
+    parsers.push(createUploadFailueHandler(limitError));
+  }
+  return parsers;
+};
+
+export const moveRaw: 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: ServerConfig;
+  }): 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();
+  };