Merge pull request #225 from sliit-foss/feature/async-handler-generics

Feat(functions): added generic support to async handlers

Author: Akalanka47000

packages/functions/package.json

@@ -20,7 +20,7 @@
     "express": "*"
   },
   "devDependencies": {
-    "@types/express": "*"
+    "express": "*"
   },
   "repository": {
     "type": "git",

packages/functions/src/async.ts

@@ -6,7 +6,7 @@ import { _traced } from "./traced";
 const logger = moduleLogger("tracer");
 
 const _asyncHandler =
-  (fn: RequestHandler, trace = false) =>
+  (fn, trace = false) =>
   async (req: Request, res: Response & Record<string, any>, next: NextFunction) => {
     let fnName: string;
     try {
@@ -34,44 +34,42 @@ const _asyncHandler =
  * @description Creates a function which invokes the given function asynchronously and calls the `next` function in case of an error thereby preventing the application from crashing.
  * @param fn The function to be invoked asynchronously
  */
-export const asyncHandler = (fn: RequestHandler): RequestHandler => _asyncHandler(fn);
+export const asyncHandler = <P = RequestHandler>(fn: P) => _asyncHandler(fn) as P;
 
 /**
  * @description Creates a function which invokes the given function asynchronously with tracing and calls the `next` function in case of an error thereby preventing the application from crashing.
  * @param fn The function to be invoked asynchronously
  */
-export const tracedAsyncHandler = (fn: RequestHandler): RequestHandler => _asyncHandler(fn, true);
+export const tracedAsyncHandler = <P = RequestHandler>(fn: P) => _asyncHandler(fn, true) as P;
 
 /**
  * @description Same as the `tracedAsyncHandler` but the log upon failure is a warning log
  * @param fn The function to be invoked asynchronously
  */
-export const fallibleAsyncHandler =
-  (fn: RequestHandler): RequestHandler =>
-  async (req, res: Response & Record<string, any>, next) => {
+export const fallibleAsyncHandler = <P extends RequestHandler>(fn: P) =>
+  (async (req, res: Response & Record<string, any>, next) => {
     try {
       await _traced(fn.bind(this, req, res, next), {}, _fnName(fn), null, true);
       if (!res.headersSent) next();
     } catch (err) {
       res.errorLogged = true;
       if (!res.headersSent) next(err);
     }
-  };
+  }) as P;
 
 /**
  * @description A more stripped down version of asyncHandler without any logs
  * @param fn The function to be invoked asynchronously
  */
-export const plainAsyncHandler =
-  (fn: RequestHandler): RequestHandler =>
-  async (req, res, next) => {
+export const plainAsyncHandler = <P extends RequestHandler>(fn: P) =>
+  (async (req, res, next) => {
     try {
       const result = fn(req, res, next) as any;
       if (result instanceof Promise) await result;
     } catch (e) {
       next(e);
     }
-  };
+  }) as P;
 
 export default {
   asyncHandler,

packages/functions/test/async.test.ts

@@ -1,6 +1,6 @@
 const { mockLogger } = require("./__mocks__");
 
-import { Request, Response } from "express";
+import { Request, Response, NextFunction } from "express";
 import { asyncHandler, tracedAsyncHandler, fallibleAsyncHandler, plainAsyncHandler } from "../src";
 import { coloredFnName } from "../src/utils";
 
@@ -14,43 +14,43 @@ describe("asyncHandler", () => {
   const mockNext = jest.fn();
 
   test("test async handler", async () => {
-    function testFunction() {
+    function testFunction(_: Request, __: Response, ___: NextFunction) {
       return "test";
     }
     await asyncHandler(testFunction)(mockReq, mockRes, mockNext);
     expect(mockLogger.info).not.toHaveBeenCalled();
     expect(mockNext).toHaveBeenCalled();
   });
   test("test async handler with error", async () => {
-    function testFunction() {
+    function testFunction(_: Request, __: Response, ___: NextFunction) {
       throw new Error("test error");
     }
     await asyncHandler(testFunction)(mockReq, mockRes, mockNext);
     expect(mockLogger.error).toHaveBeenCalled();
     expect(mockNext).toHaveBeenCalled();
   });
   test("test traced async handler", async () => {
-    await tracedAsyncHandler(function testTracedFunction() {
+    await tracedAsyncHandler(function testTracedFunction(_: Request, __: Response, ___: NextFunction) {
       return "test";
     })(mockReq, mockRes, mockNext);
     expect(mockLogger.info).toHaveBeenCalledWith(`${coloredFnName("testTracedFunction")} execution initiated`, {});
     expect(mockNext).toHaveBeenCalled();
   });
   test("test fallible async handler", async () => {
-    await fallibleAsyncHandler(function testTracedFunction() {
+    await fallibleAsyncHandler(function testTracedFunction(_: Request, __: Response, ___: NextFunction) {
       throw new Error("test error");
     })(mockReq, mockRes, mockNext);
     expect(mockLogger.warn).toHaveBeenCalled();
     expect(mockNext).toHaveBeenCalled();
   });
   test("test plain async handler with async function", async () => {
-    await plainAsyncHandler(async () => {
+    await plainAsyncHandler(async (_: Request, __: Response, ___: NextFunction) => {
       throw new Error("test");
     })(mockReq, mockRes, mockNext);
     expect(mockNext).toHaveBeenCalled();
   });
   test("test plain async handler with normal function", async () => {
-    await plainAsyncHandler(() => {
+    await plainAsyncHandler((_: Request, __: Response, ___: NextFunction) => {
       throw new Error("test");
     })(mockReq, mockRes, mockNext);
     expect(mockNext).toHaveBeenCalled();