Update boot modules and remove unused code

Author: Bruno Castro

package.json

@@ -14,8 +14,10 @@
   },
   "dependencies": {
     "awilix": "^4.3.4",
+    "cors": "^2.8.5",
     "dotenv": "^10.0.0",
     "express": "^4.17.1",
+    "helmet": "^5.1.1",
     "joi": "^17.4.1",
     "lodash.template": "^4.5.0",
     "mongodb": "^4.0.0",
@@ -29,6 +31,7 @@
     "uuid-mongodb": "^2.4.4"
   },
   "devDependencies": {
+    "@types/cors": "^2.8.12",
     "@types/express": "^4.17.13",
     "@types/jest": "^26.0.24",
     "@types/lodash.template": "^4.5.0",

src/_boot/appModules.ts

@@ -1,14 +1,12 @@
 import { articleModule, ArticleRegistry } from '@/article';
-import { ArticleMessages } from '@/article/messages';
 import { commentModule, CommentRegistry } from '@/comment';
 
-type AppModulesMessages = ArticleMessages;
-
+// eslint-disable-next-line @typescript-eslint/ban-types
 type AppModulesConfig = {};
 
 const appModules = [articleModule, commentModule];
 
 type AppModulesRegistry = ArticleRegistry & CommentRegistry;
 
 export { appModules };
-export type { AppModulesMessages, AppModulesConfig, AppModulesRegistry };
+export type { AppModulesConfig, AppModulesRegistry };

src/_boot/repl.ts

@@ -1,10 +1,16 @@
 import { makeModule } from '@/context';
-import { makeREPL, REPLConfigType } from '@/_lib/repl';
+import { makeREPL } from '@/_lib/repl';
 
-type REPLConfig = REPLConfigType<{ appName: string; cli: boolean; repl: { port: number } }>;
+type REPLConfig = { appName: string; environment: string; cli: boolean; repl: { port: number } };
 
 const repl = makeModule('repl', async ({ app: { onReady, terminate }, container, config, logger }) => {
-  const repl = makeREPL({ container, config, logger });
+  const repl = makeREPL({
+    context: { registry: container.cradle, container },
+    cli: config.cli,
+    prompt: config.appName,
+    remote: !['production', 'test'].includes(config.environment) && config.repl,
+    logger,
+  });
 
   onReady(async () => {
     await repl.start({ terminate });

src/_boot/server.ts

@@ -1,18 +1,26 @@
-import express, { Router, Application, json, urlencoded } from 'express';
-import { asValue } from 'awilix';
-import httpLogger from 'pino-http';
-import { createServer } from 'http';
-import { requestId } from '@/_lib/http/middlewares/requestId';
-import { requestContainer } from '@/_lib/http/middlewares/requestContainer';
-import { errorHandler } from '@/_lib/http/middlewares/errorHandler';
 import { makeModule } from '@/context';
+import { errorHandler } from '@/_lib/http/middlewares/errorHandler';
 import { gracefulShutdown } from '@/_lib/http/middlewares/gracefulShutdown';
+import { httpLogger, reqStartTimeKey } from '@/_lib/http/middlewares/httpLogger';
+import { requestContainer } from '@/_lib/http/middlewares/requestContainer';
+import { requestId } from '@/_lib/http/middlewares/requestId';
+import { statusHandler } from '@/_lib/http/middlewares/statusHandler';
 import { errorConverters } from '@/_sharedKernel/interface/http/ErrorConverters';
+import { asValue } from 'awilix';
+import cors from 'cors';
+import express, { Application, json, Router, urlencoded } from 'express';
+import helmet from 'helmet';
+import { createServer, Server } from 'http';
 
 type ServerConfig = {
   http: {
     host: string;
     port: number;
+    cors?:
+      | boolean
+      | {
+          allowedOrigins: string | string[];
+        };
   };
 };
 
@@ -26,22 +34,43 @@ const server = makeModule(
 
     const { shutdownHook, shutdownHandler } = gracefulShutdown(httpServer);
 
+    server.use((req, res, next) => {
+      res[reqStartTimeKey] = Date.now();
+
+      next();
+    });
+
     server.use(shutdownHandler());
+
+    if (http.cors) {
+      server.use((req, res, next) => {
+        return cors({
+          allowedHeaders:
+            'accept, accept-encoding, origin, referer, sec-fetch-*, user-agent, content-type, authorization',
+          credentials: true,
+          origin: typeof http.cors === 'boolean' ? req.get('origin') : http.cors?.allowedOrigins,
+          methods: '*',
+        })(req, res, next);
+      });
+    }
+
     server.use(requestId());
     server.use(requestContainer(container));
     server.use(httpLogger());
+    server.use(helmet());
     server.use(json());
     server.use(urlencoded({ extended: false }));
 
     const rootRouter = Router();
     const apiRouter = Router();
 
+    rootRouter.get('/status', statusHandler);
     rootRouter.use('/api', apiRouter);
 
     server.use(rootRouter);
 
     onBooted(async () => {
-      server.use((req, res) => {
+      server.use((_, res) => {
         res.sendStatus(404);
       });
 
@@ -61,7 +90,9 @@ const server = makeModule(
     }
 
     register({
+      requestId: asValue(undefined),
       server: asValue(server),
+      httpServer: asValue(httpServer),
       rootRouter: asValue(rootRouter),
       apiRouter: asValue(apiRouter),
     });
@@ -75,6 +106,7 @@ const server = makeModule(
 type ServerRegistry = {
   requestId?: string;
   server: Application;
+  httpServer: Server;
   rootRouter: Router;
   apiRouter: Router;
 };

src/_lib/http/middlewares/httpLogger.ts

@@ -0,0 +1,48 @@
+import { Request, RequestHandler } from 'express';
+import logger, { Options, startTime } from 'pino-http';
+import { randomUUID } from 'crypto';
+
+type LoggerOptions = Options & { customProps?: (req: Request, res: Response) => any };
+
+const httpLoggerOptions = (): LoggerOptions => {
+  const getReqId = (req: Request) => `[req:${req.id}]`;
+
+  return {
+    genReqId: () => randomUUID(),
+    autoLogging: { ignorePaths: ['/status', '/favicon.ico'] },
+    customSuccessMessage: function (res) {
+      const req = res.req as Request;
+
+      const reqId = getReqId(req);
+
+      return `${reqId} ${res.statusCode} - ${req.method} ${req.originalUrl} ${Date.now() - res[startTime]}ms`;
+    },
+    customErrorMessage: function (error, res) {
+      const req = res.req as Request;
+
+      const reqId = getReqId(req);
+
+      return `${reqId} ${res.statusCode} - ${req.method} ${req.originalUrl} - [${error.name}] ${error.message} ${
+        Date.now() - res[startTime]
+      }ms`;
+    },
+    customLogLevel: function (res, err) {
+      if (res.statusCode >= 400 && res.statusCode < 500) {
+        return 'warn';
+      } else if (res.statusCode >= 500 || err) {
+        return 'error';
+      } else if (res.statusCode >= 300 && res.statusCode < 400) {
+        return 'trace';
+      }
+      return 'info';
+    },
+  };
+};
+
+const httpLogger = (opts: LoggerOptions = httpLoggerOptions()): RequestHandler =>
+  logger({
+    ...opts,
+  });
+
+export { httpLogger, httpLoggerOptions, startTime as reqStartTimeKey };
+export type { LoggerOptions };

src/_lib/http/middlewares/statusHandler.ts

@@ -0,0 +1,17 @@
+import { handler } from '@/_lib/http/handler';
+import { HttpStatus } from '@/_lib/http/HttpStatus';
+
+type Dependencies = {
+  startedAt: Date;
+};
+
+const statusHandler = handler(({ startedAt }: Dependencies) => async (_, res) => {
+  const uptime = Math.round((Date.now() - startedAt.getTime()) / 10) / 100;
+
+  res.status(HttpStatus.OK).json({
+    startedAt,
+    uptime,
+  });
+});
+
+export { statusHandler };

src/_lib/repl/index.ts

@@ -1,26 +1,16 @@
 import REPL, { REPLEval, ReplOptions, REPLServer } from 'repl';
 import vm from 'vm';
 import { createServer, Server } from 'net';
-import { AwilixContainer } from 'awilix';
-import { Logger } from 'pino';
-import { EnvironmentConfig } from '../Environment';
 
-type REPLConfigType<T> = {
-  [key in keyof T]: T[key];
+type REPLProps = {
+  context: Record<string, any>;
+  prompt: string;
+  cli: boolean;
+  remote: false | { port: number };
+  logger: Pick<Console, 'error'>;
 };
 
-type ReplParameters = {
-  container: AwilixContainer;
-  config: REPLConfigType<{
-    appName: string;
-    cli: boolean;
-    repl: { port: number };
-    environment: EnvironmentConfig['environment'];
-  }>;
-  logger: Logger;
-};
-
-type REPL = {
+type REPLInstance = {
   create: (config: Partial<ReplOptions>) => REPLServer;
   start: ({ terminate }) => Promise<void>;
   close: () => Promise<void>;
@@ -38,46 +28,41 @@ const promisableEval: REPLEval = (cmd, context, filename, callback) => {
   return callback(null, result);
 };
 
-const makeREPL = ({
-  container,
-  config: {
-    appName,
-    cli,
-    environment,
-    repl: { port },
-  },
-  logger,
-}: ReplParameters): REPL => {
+const makeREPL = ({ context, prompt, cli, remote, logger }: REPLProps): REPLInstance => {
   let server: Server;
 
   const create = (config: Partial<ReplOptions> = { input: process.stdin, output: process.stdout }): REPLServer => {
     const repl = REPL.start({
       eval: promisableEval,
-      prompt: `${appName}$ `,
+      prompt: `${prompt}$ `,
       ignoreUndefined: true,
       ...config,
     });
 
-    Object.assign(repl.context, { registry: container.cradle, container });
+    Object.assign(repl.context, context);
 
     return repl;
   };
 
+  let destroySocket: (...args: any) => void = () => null;
+
   return {
     create,
     start: async ({ terminate }) => {
       if (cli) {
         const repl = create();
 
         repl.on('close', terminate);
-      } else if (!['production', 'test'].includes(environment)) {
+      } else if (remote) {
         server = createServer((socket) => {
           const repl = create({
             input: socket,
             output: socket,
             terminal: true,
           });
 
+          destroySocket = socket.destroy.bind(socket);
+
           repl.on('close', () => {
             socket.end();
           });
@@ -87,21 +72,22 @@ const makeREPL = ({
             logger.error(err);
             socket.end();
           });
-        }).listen(port);
+        }).listen(remote.port);
       }
     },
     close: async () => {
       if (server && server.listening) {
-        await new Promise<void>((resolve, reject) =>
+        await new Promise<void>((resolve, reject) => {
+          destroySocket();
+
           server.close((err) => {
             if (err) return reject(err);
             resolve();
-          })
-        );
+          });
+        });
       }
     },
   };
 };
 
 export { makeREPL };
-export type { REPLConfigType };