[feature] add pagination, validation, and response middleware

Author: DeanRTaylor1

.env.example

@@ -12,3 +12,5 @@ DB_DATABASE=dev_db
 DB_HOST=postgres
 DB_DIALECT=postgres
 DB_PORT=5432
+
+SNAKE_CASE=true

.github/workflows/test.yml

@@ -43,29 +43,30 @@ jobs:
       - name: Setup Database
         run: yarn db:setup
         env:
-            DB_USERNAME: user 
-            DB_PASSWORD: password 
-            DB_DATABASE: testdb
-            DB_HOST: localhost
-            DB_DIALECT: postgres
-            DB_PORT: 5432
-            NODE_ENV: test
-            LOG_DIR: logs/
-            LOG_FORMAT: dev
-            LOG_LEVEL: debug
-            PORT: 3000
+          DB_USERNAME: user
+          DB_PASSWORD: password
+          DB_DATABASE: testdb
+          DB_HOST: localhost
+          DB_DIALECT: postgres
+          DB_PORT: 5432
+          NODE_ENV: test
+          LOG_DIR: logs/
+          LOG_FORMAT: dev
+          LOG_LEVEL: debug
+          PORT: 3000
 
       - name: Run tests
         run: yarn test-jest
         env:
-            DB_USERNAME: user 
-            DB_PASSWORD: password 
-            DB_DATABASE: testdb
-            DB_HOST: localhost
-            DB_DIALECT: postgres
-            DB_PORT: 5432
-            NODE_ENV: test
-            LOG_DIR: logs/
-            LOG_FORMAT: dev
-            LOG_LEVEL: debug
-            PORT: 3000
+          DB_USERNAME: user
+          DB_PASSWORD: password
+          DB_DATABASE: testdb
+          DB_HOST: localhost
+          DB_DIALECT: postgres
+          DB_PORT: 5432
+          NODE_ENV: test
+          LOG_DIR: logs/
+          LOG_FORMAT: dev
+          LOG_LEVEL: debug
+          PORT: 3000
+          SNAKE_CASE: true

package.json

@@ -16,7 +16,8 @@
     "dropdb": "docker exec -it postgres14 dropdb --username=root test_db",
     "test-jest": "jest --ci --passWithNoTests --runInBand",
     "cleanup": "docker stop postgres14 && docker rm postgres14",
-    "test": "yarn postgres && yarn createdb && cross-env NODE_ENV=test yarn db:setup && yarn test-jest; yarn cleanup"
+    "test": "yarn postgres && yarn createdb && cross-env NODE_ENV=test yarn db:setup && yarn test-jest; yarn cleanup",
+    "build": "tsc && tsc-alias"
   },
   "dependencies": {
     "body-parser": "^1.20.2",
@@ -34,6 +35,7 @@
     "routing-controllers": "^0.10.4",
     "sequelize": "^6.33.0",
     "sequelize-typescript": "^2.1.5",
+    "tsc-alias": "^1.8.8",
     "typedi": "^0.10.0",
     "winston": "^3.11.0",
     "winston-daily-rotate-file": "^4.7.1"
@@ -45,12 +47,12 @@
     "@types/multer": "^1.4.9",
     "@typescript-eslint/eslint-plugin": "^6.8.0",
     "@typescript-eslint/parser": "^6.8.0",
-    "jest": "^29.7.0",
     "cross-env": "^7.0.3",
     "eslint-config-prettier": "^9.0.0",
     "eslint-loader": "^4.0.2",
     "eslint-plugin-import": "^2.28.1",
     "eslint-plugin-prettier": "^5.0.1",
+    "jest": "^29.7.0",
     "nodemon": "^3.0.1",
     "prettier": "^3.0.3",
     "sequelize-cli": "^6.6.1",

src/api/controllers/base.controller.ts

@@ -1,34 +1,23 @@
 import { API_RES, StatusCodeEnum } from "api/enum/api.enum";
 import { ApiResponse } from "api/types/response.interface";
-import { HttpError } from "routing-controllers";
 import { Response } from "express";
 import BaseEntity from "api/models/entities/types/Base.entity";
-import { SnakeCaseObj } from "@lib/validation/types";
+import { env } from "@env";
 
 export class BaseController {
   protected code: StatusCodeEnum = StatusCodeEnum.OK;
   protected data: unknown;
-  protected message: string = "Success.";
+  protected message: string = "Success";
   protected typeRes: API_RES = API_RES.JSON;
-  protected exception: HttpError;
+  protected enableSnakeCase: boolean = env.config.enableSnakeCase;
 
   public setCode(code: StatusCodeEnum): this {
     this.code = code;
     return this;
   }
 
-  public setData<T>(data: T): this {
-    if (data instanceof Array) {
-      this.data = data.map((item) => {
-        return this.isBaseEntity(item) ? this.getSnakeEntity(item) : item;
-      });
-      return this;
-    }
-    if (this.isBaseEntity<T>(data)) {
-      this.data = this.getSnakeEntity(data);
-      return this;
-    }
-    this.data = data;
+  public setData<T>(data: T | BaseEntity<T>[]): this {
+    this.data = this.transformData(data);
     return this;
   }
 
@@ -37,49 +26,60 @@ export class BaseController {
     return this;
   }
 
+  public setTypeRes(type: API_RES): this {
+    this.typeRes = type;
+    return this;
+  }
+
   protected getResponse<T>(res: Response, status: boolean): Response {
     const result: ApiResponse<T> = {
-      status: status ? true : false,
+      status,
       code: this.code,
       data: this.data as T,
       message: this.message,
     };
 
-    if (this.typeRes === API_RES.JSON) {
-      return res.status(this.code).json(result);
+    switch (this.typeRes) {
+      case API_RES.JSON:
+        return res.status(this.code).json(result);
+      case API_RES.SEND:
+        return res.status(this.code).send(result);
+      default:
+        throw new Error(`Unsupported response type: ${this.typeRes}`);
     }
-
-    if (this.typeRes === API_RES.SEND) {
-      return res.status(this.code).send(result);
-    }
-
-    // Default to JSON response if type is not recognized
-    return res.status(this.code).json(result);
   }
 
   public responseSuccess<T>(data: T, message: string, res: Response): Response {
-    this.setCode(StatusCodeEnum.OK);
-    this.setData(data);
-    this.setMessage(message);
-    return this.getResponse(res, true);
+    return this.setCode(StatusCodeEnum.OK)
+      .setData(data)
+      .setMessage(message)
+      .getResponse<T>(res, true);
   }
 
-  public responseErrors(
+  public responseError(
     res: Response,
     message: string = "An error occurred",
     statusCode: StatusCodeEnum = StatusCodeEnum.INTERNAL_SERVER_ERROR
   ): Response {
-    this.setCode(statusCode);
-    this.setData(null);
-    this.setMessage(message);
-    return this.getResponse<null>(res, false);
+    return this.setCode(statusCode)
+      .setData(null)
+      .setMessage(message)
+      .getResponse<null>(res, false);
   }
 
-  private getSnakeEntity<T>(data: BaseEntity<T>): SnakeCaseObj<T> {
-    return data.toSnake();
+  private transformData<T>(data: T | BaseEntity<T>[]): unknown {
+    if (!this.enableSnakeCase) return data;
+
+    if (Array.isArray(data)) {
+      return data.map((item) =>
+        this.isBaseEntity(item) ? item.toSnake() : item
+      );
+    }
+
+    return this.isBaseEntity(data) ? data.toSnake() : data;
   }
 
   private isBaseEntity<T>(object: unknown): object is BaseEntity<T> {
-    return (object as BaseEntity<T>).toSnake !== undefined;
+    return (object as BaseEntity<T>)?.toSnake !== undefined;
   }
 }

src/api/controllers/users.controller.ts

@@ -5,9 +5,6 @@ import { BodyToCamelCase } from "@decorators/SnakeToCamel.decorator";
 import { CreateUserDTO } from "api/validation/DTO/user.dto";
 import validationMiddleware from "middlewares/validation.middleware";
 import { CamelCaseObj } from "@lib/validation/types";
-import { logger } from "@lib/debug/logger";
-import { HttpException } from "api/errors/HttpException";
-import { StatusCodeEnum } from "api/enum/api.enum";
 
 import { Request, Response } from "express";
 import {
@@ -19,6 +16,8 @@ import {
   UseBefore,
 } from "routing-controllers";
 import { Service } from "typedi";
+import { HandleErrors } from "@decorators/errorHandler.decorator";
+import { GetPagination, Pagination } from "@decorators/pagination.decorator";
 
 @JsonController("/users")
 @Service()
@@ -28,34 +27,28 @@ class UsersController extends BaseController {
   }
 
   @Get("/")
+  @HandleErrors
   public async getUsers(
+    @GetPagination() { skip, limit }: Pagination,
     @Req() _: Request,
     @Res() res: Response
   ): Promise<Response> {
-    const users = await this.usersService.getAllUsers();
+    const users = await this.usersService.getAllUsers({ skip, limit });
 
     return this.responseSuccess<Array<User>>(users, "Success", res);
   }
 
   @Post("/")
   @UseBefore(validationMiddleware(CreateUserDTO))
+  @HandleErrors
   public async createUser(
     @BodyToCamelCase() body: CamelCaseObj<CreateUserDTO>,
     @Req() _: Request,
     @Res() res: Response
   ): Promise<Response> {
-    try {
-      const user = await this.usersService.createUser(body);
+    const user = await this.usersService.createUser(body);
 
-      return this.responseSuccess<User>(user, "Success", res);
-    } catch (error: unknown) {
-      logger.error(error);
-
-      throw new HttpException(
-        StatusCodeEnum.INTERNAL_SERVER_ERROR,
-        "Something went wrong."
-      );
-    }
+    return this.responseSuccess<User>(user, "Success", res);
   }
 }
 

src/api/decorators/errorHandler.decorator.ts

@@ -0,0 +1,31 @@
+import { logger } from "@lib/debug/logger";
+import { StatusCodeEnum } from "api/enum/api.enum";
+import { HttpException } from "api/errors/HttpException";
+
+export function HandleErrors<T>(
+  target: T,
+  propertyName: string,
+  descriptor: PropertyDescriptor
+) {
+  const originalMethod = descriptor.value;
+
+  if (!originalMethod) {
+    throw new Error("Expected method not found on descriptor");
+  }
+
+  descriptor.value = async function (...args: unknown[]) {
+    try {
+      return await originalMethod.apply(this as T, args);
+    } catch (error: unknown) {
+      if (error instanceof HttpException) {
+        throw error;
+      } else {
+        logger.error(error);
+        throw new HttpException(
+          StatusCodeEnum.INTERNAL_SERVER_ERROR,
+          "Something went wrong."
+        );
+      }
+    }
+  };
+}

src/api/decorators/pagination.decorator.ts

@@ -0,0 +1,49 @@
+import { createParamDecorator, Action } from "routing-controllers";
+
+export interface Pagination {
+  skip: number;
+  limit: number;
+  sort?: Array<SortItem>;
+  search?: Record<string, string>;
+}
+type SortItem = { field: string; by: "ASC" | "DESC" };
+type SearchItem = `${string}:${string}`;
+
+export function GetPagination(options?: { required?: boolean }) {
+  return createParamDecorator({
+    required: options?.required ?? false,
+    value: (action: Action): Pagination => {
+      const query = action.request.query;
+      const paginationParams: Pagination = {
+        skip: parseInt(query.skip?.toString()) || 0,
+        limit: parseInt(query.limit?.toString()) || 10,
+      };
+
+      if (query.sort) {
+        const sortArray = query.sort.toString().split(",");
+        paginationParams.sort = sortArray.map((sortItem: string): SortItem => {
+          const trimmedItem = sortItem.trim();
+          return {
+            field: trimmedItem.startsWith("-")
+              ? trimmedItem.slice(1)
+              : trimmedItem,
+            by: trimmedItem.startsWith("-") ? "ASC" : "DESC",
+          };
+        });
+      }
+
+      if (query.search) {
+        const searchArray = query.search.toString().split(",");
+        paginationParams.search = {};
+        searchArray.forEach((searchItem: SearchItem) => {
+          const [field, value] = searchItem.split(":");
+          if (field && value) {
+            paginationParams.search[field.trim()] = value.trim();
+          }
+        });
+      }
+
+      return paginationParams;
+    },
+  });
+}

src/api/errors/HttpException.ts

@@ -5,9 +5,10 @@ export class HttpException<T> extends HttpError {
   public data?: T;
 
   constructor(status: number, message: string, data?: T) {
-    super(status);
+    super(status, message);
     this.status = status;
     this.message = message;
     this.data = data;
+    Object.setPrototypeOf(this, HttpException.prototype);
   }
 }

src/api/models/entities/User.entity.ts

@@ -6,16 +6,13 @@ import {
   Table,
   Default,
   DataType,
-  Model,
 } from "sequelize-typescript";
 import BaseEntity from "./types/Base.entity";
-import { convertKeysToSnakeCase } from "@lib/validation/utils";
-import { SnakeCaseObj } from "@lib/validation/types";
 
 @Table({
   tableName: "users",
 })
-export default class User extends Model<User> implements BaseEntity<User> {
+export default class User extends BaseEntity<User> {
   @PrimaryKey
   @AutoIncrement
   @Column(DataType.INTEGER)
@@ -49,8 +46,4 @@ export default class User extends Model<User> implements BaseEntity<User> {
 
   @Column(DataType.DATE)
   updatedAt: Date;
-
-  toSnake() {
-    return convertKeysToSnakeCase(this.get()) as SnakeCaseObj<this>;
-  }
 }