Self-diagnosis disabled on production

README.md

@@ -895,6 +895,7 @@ origins of errors that could happen in runtime and be handled the following way:
 Consider enabling production mode by setting `NODE_ENV` environment variable to `production` for your deployment:
 
 - Express activates some [performance optimizations](https://expressjs.com/en/advanced/best-practice-performance.html);
+- Self-diagnosis for potential problems is disabled to ensure faster startup;
 - The `defaultResultHandler`, `defaultEndpointsFactory` and `LastResortHandler` generalize server-side error messages
   in negative responses in order to improve the security of your API by not disclosing the exact causes of errors:
   - Throwing errors that have or imply `5XX` status codes become just `Internal Server Error` message in response;

src/diagnostics.ts

@@ -0,0 +1,41 @@
+import { FlatObject } from "./common-helpers";
+import { contentTypes } from "./content-type";
+import { assertJsonCompatible } from "./deep-checks";
+import { AbstractEndpoint } from "./endpoint";
+import { ActualLogger } from "./logger-helpers";
+
+export class Diagnostics {
+  #verified = new WeakSet<AbstractEndpoint>();
+
+  public check(
+    endpoint: AbstractEndpoint,
+    logger: ActualLogger,
+    ctx: FlatObject,
+  ): void {
+    if (!this.#verified.has(endpoint)) {
+      if (endpoint.getRequestType() === "json") {
+        try {
+          assertJsonCompatible(endpoint.getSchema("input"), "in");
+        } catch (reason) {
+          logger.warn(
+            "The final input schema of the endpoint contains an unsupported JSON payload type.",
+            Object.assign(ctx, { reason }),
+          );
+        }
+      }
+      for (const variant of ["positive", "negative"] as const) {
+        if (endpoint.getMimeTypes(variant).includes(contentTypes.json)) {
+          try {
+            assertJsonCompatible(endpoint.getSchema(variant), "out");
+          } catch (reason) {
+            logger.warn(
+              `The final ${variant} response schema of the endpoint contains an unsupported JSON payload type.`,
+              Object.assign(ctx, { reason }),
+            );
+          }
+        }
+      }
+      this.#verified.add(endpoint);
+    }
+  }
+}

src/routing.ts

@@ -1,8 +1,9 @@
 import { IRouter, RequestHandler } from "express";
+import { isProduction } from "./common-helpers";
 import { CommonConfig } from "./config-type";
-import { ContentType, contentTypes } from "./content-type";
-import { assertJsonCompatible } from "./deep-checks";
+import { ContentType } from "./content-type";
 import { DependsOnMethod } from "./depends-on-method";
+import { Diagnostics } from "./diagnostics";
 import { AbstractEndpoint } from "./endpoint";
 import { ActualLogger } from "./logger-helpers";
 import { walkRouting } from "./routing-walker";
@@ -30,40 +31,15 @@ export const initRouting = ({
   routing: Routing;
   parsers?: Parsers;
 }) => {
-  const verified = new WeakSet<AbstractEndpoint>();
+  const doc = new Diagnostics();
   walkRouting({
     routing,
     hasCors: !!config.cors,
     onEndpoint: (endpoint, path, method, siblingMethods) => {
-      const requestType = endpoint.getRequestType();
-      if (!verified.has(endpoint)) {
-        if (requestType === "json") {
-          try {
-            assertJsonCompatible(endpoint.getSchema("input"), "in");
-          } catch (reason) {
-            rootLogger.warn(
-              "The final input schema of the endpoint contains an unsupported JSON payload type.",
-              { path, method, reason },
-            );
-          }
-        }
-        for (const variant of ["positive", "negative"] as const) {
-          if (endpoint.getMimeTypes(variant).includes(contentTypes.json)) {
-            try {
-              assertJsonCompatible(endpoint.getSchema(variant), "out");
-            } catch (reason) {
-              rootLogger.warn(
-                `The final ${variant} response schema of the endpoint contains an unsupported JSON payload type.`,
-                { path, method, reason },
-              );
-            }
-          }
-        }
-        verified.add(endpoint);
-      }
+      if (!isProduction()) doc.check(endpoint, rootLogger, { path, method });
       app[method](
         path,
-        ...(parsers?.[requestType] || []),
+        ...(parsers?.[endpoint.getRequestType()] || []),
         async (request, response) =>
           endpoint.execute({
             request,