@hastehaul/common 1.0.17 → 1.0.19

package/build/connections-wrappers/redis-connection-wrapper.d.ts

@@ -1,6 +1,7 @@
 import IORedis from "ioredis";
 /**
- * A wrapper class for the Redis client to manage connections and provide a centralized client instance.
+ * A wrapper class for the Redis client. This class manages connections and provides
+ * a centralized client instance for a Redis database.
  */
 export declare class RedisWrapper {
     private _redisClient?;
@@ -14,11 +15,14 @@ export declare class RedisWrapper {
      */
     get client(): IORedis;
     /**
-     * Connect to the Redis server using the specified host and port.
-     *
-     * The client instance will be stored in the `_redisClient` property for later access.
-     */
-    connect(): void;
+      * Connect to the Redis server using the specified host and port.
+      *
+      * The client instance will be stored in the `_redisClient` property for later access.
+      *
+      * @param {string} host - The Redis server host address (default is "customer-redis-srv").
+      * @param {number} port - The Redis server port number (default is 6379).
+      */
+    connect(host?: string, port?: number): void;
 }
 /**
  * Singleton instance of the RedisWrapper class to provide a centralized Redis client connection.

package/build/connections-wrappers/redis-connection-wrapper.js

@@ -6,7 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.redisWrapper = exports.RedisWrapper = void 0;
 const ioredis_1 = __importDefault(require("ioredis"));
 /**
- * A wrapper class for the Redis client to manage connections and provide a centralized client instance.
+ * A wrapper class for the Redis client. This class manages connections and provides
+ * a centralized client instance for a Redis database.
  */
 class RedisWrapper {
     constructor() {
@@ -25,12 +26,15 @@ class RedisWrapper {
         return this._redisClient;
     }
     /**
-     * Connect to the Redis server using the specified host and port.
-     *
-     * The client instance will be stored in the `_redisClient` property for later access.
-     */
-    connect() {
-        this._redisClient = new ioredis_1.default({ host: this.host, port: this.port, maxRetriesPerRequest: null });
+      * Connect to the Redis server using the specified host and port.
+      *
+      * The client instance will be stored in the `_redisClient` property for later access.
+      *
+      * @param {string} host - The Redis server host address (default is "customer-redis-srv").
+      * @param {number} port - The Redis server port number (default is 6379).
+      */
+    connect(host, port) {
+        this._redisClient = new ioredis_1.default({ host: host || this.host, port: port || this.port, maxRetriesPerRequest: null });
         this._redisClient.on("connect", function () {
             console.info("Redis Server Connected!");
         });

package/build/errors/not-authorized-error.d.ts

@@ -0,0 +1,30 @@
+import { StatusCodes } from '../utils/enums';
+import { CustomError } from './custom-error';
+/**
+ * Custom error class representing a "Not Authorized" error.
+ *
+ * The "NotAuthorizedError" class extends the base "CustomError" class to handle errors related to unauthorized access to a resource or action.
+ * It sets the HTTP status code to 401 (UNAUTHORIZED) and provides a default error message of "Not Authorized".
+ * Subclasses can customize the error message or additional fields as needed by overriding the "serializeErrors" method.
+ */
+export declare class NotAuthorizedError extends CustomError {
+    /**
+     * HTTP status code for the "Not Authorized" error.
+     */
+    statusCode: StatusCodes;
+    /**
+     * Creates a new instance of the "NotAuthorizedError" class with a default error message of "Not Authorized".
+     */
+    constructor();
+    /**
+     * Serializes the error to be sent as a response to the client.
+     *
+     * The "serializeErrors" method returns an array containing an object with the error message for the "Not Authorized" error.
+     * Subclasses can override this method to provide custom error serialization.
+     *
+     * @returns An array containing an object with the error message for the "Not Authorized" error.
+     */
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/not-authorized-error.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const enums_1 = require("../utils/enums");
+const custom_error_1 = require("./custom-error");
+/**
+ * Custom error class representing a "Not Authorized" error.
+ *
+ * The "NotAuthorizedError" class extends the base "CustomError" class to handle errors related to unauthorized access to a resource or action.
+ * It sets the HTTP status code to 401 (UNAUTHORIZED) and provides a default error message of "Not Authorized".
+ * Subclasses can customize the error message or additional fields as needed by overriding the "serializeErrors" method.
+ */
+class NotAuthorizedError extends custom_error_1.CustomError {
+    /**
+     * Creates a new instance of the "NotAuthorizedError" class with a default error message of "Not Authorized".
+     */
+    constructor() {
+        super('Not Authorized');
+        /**
+         * HTTP status code for the "Not Authorized" error.
+         */
+        this.statusCode = enums_1.StatusCodes.UNAUTHORIZED;
+        // Ensures correct prototype chain for subclassing.
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    /**
+     * Serializes the error to be sent as a response to the client.
+     *
+     * The "serializeErrors" method returns an array containing an object with the error message for the "Not Authorized" error.
+     * Subclasses can override this method to provide custom error serialization.
+     *
+     * @returns An array containing an object with the error message for the "Not Authorized" error.
+     */
+    serializeErrors() {
+        return [{ message: 'Not authorized' }];
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/build/errors/resource-not-found.d.ts

@@ -0,0 +1,30 @@
+import { StatusCodes } from '../utils/enums';
+import { CustomError } from './custom-error';
+/**
+ * Custom error class representing a "Resource Not Found" error.
+ *
+ * The "ResourceNotFound" class extends the base "CustomError" class to handle errors related to resources that cannot be found.
+ * It sets the HTTP status code to 404 (NOT_FOUND) and provides a default error message of "Resource not found".
+ * Subclasses can customize the error message or additional fields as needed by overriding the "serializeErrors" method.
+ */
+export declare class ResourceNotFound extends CustomError {
+    /**
+     * HTTP status code for the "Resource Not Found" error.
+     */
+    statusCode: StatusCodes;
+    /**
+     * Creates a new instance of the "ResourceNotFound" class with a default error message of "Resource not found".
+     */
+    constructor();
+    /**
+     * Serializes the error to be sent as a response to the client.
+     *
+     * The "serializeErrors" method returns an array containing an object with the error message for the "Resource Not Found" error.
+     * Subclasses can override this method to provide custom error serialization.
+     *
+     * @returns An array containing an object with the error message for the "Resource Not Found" error.
+     */
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/resource-not-found.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceNotFound = void 0;
+const enums_1 = require("../utils/enums");
+const custom_error_1 = require("./custom-error");
+/**
+ * Custom error class representing a "Resource Not Found" error.
+ *
+ * The "ResourceNotFound" class extends the base "CustomError" class to handle errors related to resources that cannot be found.
+ * It sets the HTTP status code to 404 (NOT_FOUND) and provides a default error message of "Resource not found".
+ * Subclasses can customize the error message or additional fields as needed by overriding the "serializeErrors" method.
+ */
+class ResourceNotFound extends custom_error_1.CustomError {
+    /**
+     * Creates a new instance of the "ResourceNotFound" class with a default error message of "Resource not found".
+     */
+    constructor() {
+        super('Resource not found');
+        /**
+         * HTTP status code for the "Resource Not Found" error.
+         */
+        this.statusCode = enums_1.StatusCodes.NOT_FOUND;
+        Object.setPrototypeOf(this, ResourceNotFound.prototype);
+    }
+    /**
+     * Serializes the error to be sent as a response to the client.
+     *
+     * The "serializeErrors" method returns an array containing an object with the error message for the "Resource Not Found" error.
+     * Subclasses can override this method to provide custom error serialization.
+     *
+     * @returns An array containing an object with the error message for the "Resource Not Found" error.
+     */
+    serializeErrors() {
+        return [{ message: 'Resource Not Found' }];
+    }
+}
+exports.ResourceNotFound = ResourceNotFound;

package/build/errors/too-many-request-error.d.ts

@@ -0,0 +1,33 @@
+import { CustomError } from './custom-error';
+/**
+ * Custom error class representing a "Too Many Requests" error.
+ *
+ * The "TooManyRequestError" class extends the base "CustomError" class to handle errors related to receiving too many requests from a client within a specific time frame.
+ * It sets the HTTP status code to 429 (TOO_MANY_REQUESTS) and provides a default error message of "Too Many Requests".
+ * The class also includes a `retrySec` property to specify the number of seconds after which the client can retry the request.
+ * Subclasses can customize the error message or additional fields as needed by overriding the "serializeErrors" method.
+ */
+export declare class TooManyRequestError extends CustomError {
+    retrySec: string;
+    /**
+     * HTTP status code for the "Too Many Requests" error.
+     */
+    statusCode: number;
+    /**
+     * Creates a new instance of the "TooManyRequestError" class with a default error message of "Too Many Requests".
+     *
+     * @param retrySec The number of seconds after which the client can retry the request.
+     */
+    constructor(retrySec: string);
+    /**
+     * Serializes the error to be sent as a response to the client.
+     *
+     * The "serializeErrors" method returns an array containing an object with the error message for the "Too Many Requests" error.
+     * Subclasses can override this method to provide custom error serialization.
+     *
+     * @returns An array containing an object with the error message for the "Too Many Requests" error.
+     */
+    serializeErrors(): {
+        message: string;
+    }[];
+}

package/build/errors/too-many-request-error.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TooManyRequestError = void 0;
+const enums_1 = require("../utils/enums");
+const custom_error_1 = require("./custom-error");
+/**
+ * Custom error class representing a "Too Many Requests" error.
+ *
+ * The "TooManyRequestError" class extends the base "CustomError" class to handle errors related to receiving too many requests from a client within a specific time frame.
+ * It sets the HTTP status code to 429 (TOO_MANY_REQUESTS) and provides a default error message of "Too Many Requests".
+ * The class also includes a `retrySec` property to specify the number of seconds after which the client can retry the request.
+ * Subclasses can customize the error message or additional fields as needed by overriding the "serializeErrors" method.
+ */
+class TooManyRequestError extends custom_error_1.CustomError {
+    /**
+     * Creates a new instance of the "TooManyRequestError" class with a default error message of "Too Many Requests".
+     *
+     * @param retrySec The number of seconds after which the client can retry the request.
+     */
+    constructor(retrySec) {
+        super('Too Many Requests');
+        this.retrySec = retrySec;
+        /**
+         * HTTP status code for the "Too Many Requests" error.
+         */
+        this.statusCode = enums_1.StatusCodes.TOO_MANY_REQUEST;
+        Object.setPrototypeOf(this, TooManyRequestError.prototype);
+    }
+    /**
+     * Serializes the error to be sent as a response to the client.
+     *
+     * The "serializeErrors" method returns an array containing an object with the error message for the "Too Many Requests" error.
+     * Subclasses can override this method to provide custom error serialization.
+     *
+     * @returns An array containing an object with the error message for the "Too Many Requests" error.
+     */
+    serializeErrors() {
+        return [
+            { message: `Too Many Requests. Try again later` }
+        ];
+    }
+}
+exports.TooManyRequestError = TooManyRequestError;

package/build/index.d.ts

@@ -49,6 +49,9 @@ export * from "./errors/not-found-error";
  * The "SystemError" class represents a specific "System Error" that can occur due to unexpected issues in the system.
  */
 export * from "./errors/system-error";
+export * from "./errors/too-many-request-error";
+export * from "./errors/resource-not-found";
+export * from "./errors/not-authorized-error";
 /**
  * Re-exports the "currentUser" middleware from the "current-user" module.
  *
@@ -65,6 +68,9 @@ export * from "./middlewares/current-user";
  * If the error is not a custom error, a generic error response is sent with a 500 status code and a default error message.
  */
 export * from "./middlewares/error-handler";
+export * from "./middlewares/is-allowed";
+export * from "./middlewares/validate-body";
+export * from "./middlewares/require-auth";
 /**
  *? Re-exports all the enums from the "enums" module.
  *
@@ -79,6 +85,7 @@ export * from "./utils/enums";
  * These functions are used for dynamic loading, configuration, and other file-related operations.
  */
 export * from "./utils/read-dir";
+export * from "./utils/schemas";
 /**
  *? Re-exports all the contents from the "base-producers" module.
  *

package/build/index.js

@@ -67,6 +67,12 @@ __exportStar(require("./errors/not-found-error"), exports);
  * The "SystemError" class represents a specific "System Error" that can occur due to unexpected issues in the system.
  */
 __exportStar(require("./errors/system-error"), exports);
+//TODO: DOCUMENT
+__exportStar(require("./errors/too-many-request-error"), exports);
+//TODO: DOCUMENT
+__exportStar(require("./errors/resource-not-found"), exports);
+//TODO: DOCUMENT
+__exportStar(require("./errors/not-authorized-error"), exports);
 //* Import and re-export multiple middleware modules.
 /**
  * Re-exports the "currentUser" middleware from the "current-user" module.
@@ -84,6 +90,12 @@ __exportStar(require("./middlewares/current-user"), exports);
  * If the error is not a custom error, a generic error response is sent with a 500 status code and a default error message.
  */
 __exportStar(require("./middlewares/error-handler"), exports);
+//TODO: DOCUMENT
+__exportStar(require("./middlewares/is-allowed"), exports);
+//TODO: DOCUMENT
+__exportStar(require("./middlewares/validate-body"), exports);
+//TODO: DOCUMENT
+__exportStar(require("./middlewares/require-auth"), exports);
 //* Import and re-export multiple modules for enums, base classes, and read-dir functionality.
 /**
  *? Re-exports all the enums from the "enums" module.
@@ -99,6 +111,8 @@ __exportStar(require("./utils/enums"), exports);
  * These functions are used for dynamic loading, configuration, and other file-related operations.
  */
 __exportStar(require("./utils/read-dir"), exports);
+//TODO: DOCUMENT
+__exportStar(require("./utils/schemas"), exports);
 /**
  *? Re-exports all the contents from the "base-producers" module.
  *

package/build/middlewares/current-user.js

@@ -64,7 +64,6 @@ const currentUser = (req, res, next) => __awaiter(void 0, void 0, void 0, functi
             // If the token is expired, you may consider refreshing the token or taking appropriate actions.
             // Uncomment the following line if you want to handle token expiration using the AuthController.
             // await AuthController.refreshToken(req, res);
-            // await AuthController.refreshToken(req, res)
         }
         else {
             // If any other error occurs during token verification, set currentUser to null.

package/build/middlewares/error-handler.js

@@ -15,8 +15,6 @@ const errorHandler = (err, req, res, next) => {
     if (err instanceof custom_error_1.CustomError) {
         return res.status(err.statusCode).send({ errors: err.serializeErrors() });
     }
-    res
-        .status(enums_1.StatusCodes.BAD_REQUEST)
-        .send({ errors: [{ message: "Something went wrong" }] });
+    res.status(enums_1.StatusCodes.BAD_REQUEST).send({ errors: [{ message: "Something went wrong" }] });
 };
 exports.errorHandler = errorHandler;

package/build/middlewares/is-allowed.d.ts

@@ -0,0 +1,24 @@
+import { Request, Response, NextFunction } from "express";
+/**
+ * Middleware to check if a user is allowed to perform a specific action on a resource based on their role and permissions.
+ * If the user is not authorized, it throws a NotAuthorizedError to indicate access denied.
+ *
+ * @param req - The Express request object.
+ * @param res - The Express response object.
+ * @param next - The next middleware function.
+ * @param hasVersion - Set to true if the API path includes the version (e.g., /api/v1/...). Default is false.
+ *
+ * @throws BadRequestError - If the action is not supported or if the session has expired.
+ * @throws ResourceNotFound - If the requested resource is not found.
+ * @throws NotAuthorizedError - If the user is not authorized to perform the action on the resource.
+ *
+ * @example
+ * ```js
+ * // Route that requires authorization based on user role and permissions
+ * router.get("/resource/:id", isAllowed, (req, res) => {
+ *   // Only authorized users with the appropriate permissions can access this route
+ *   res.send("You are authorized!");
+ * });
+ * ```
+ */
+export declare const isAllowed: (req: Request, res: Response, next: NextFunction, hasVersion?: boolean) => void;

package/build/middlewares/is-allowed.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAllowed = void 0;
+const accesscontrol_1 = __importDefault(require("@vsky/accesscontrol"));
+const resource_not_found_1 = require("../errors/resource-not-found");
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+const bad_request_error_1 = require("../errors/bad-request-error");
+// Mapping object for HTTP method to action
+const methodToAction = {
+    GET: "view",
+    POST: "create",
+    DELETE: "delete",
+    PUT: "update",
+    PATCH: "update",
+};
+/**
+ * Middleware to check if a user is allowed to perform a specific action on a resource based on their role and permissions.
+ * If the user is not authorized, it throws a NotAuthorizedError to indicate access denied.
+ *
+ * @param req - The Express request object.
+ * @param res - The Express response object.
+ * @param next - The next middleware function.
+ * @param hasVersion - Set to true if the API path includes the version (e.g., /api/v1/...). Default is false.
+ *
+ * @throws BadRequestError - If the action is not supported or if the session has expired.
+ * @throws ResourceNotFound - If the requested resource is not found.
+ * @throws NotAuthorizedError - If the user is not authorized to perform the action on the resource.
+ *
+ * @example
+ * ```js
+ * // Route that requires authorization based on user role and permissions
+ * router.get("/resource/:id", isAllowed, (req, res) => {
+ *   // Only authorized users with the appropriate permissions can access this route
+ *   res.send("You are authorized!");
+ * });
+ * ```
+ */
+const isAllowed = (req, res, next, hasVersion = false) => {
+    var _a, _b;
+    let STABLEVERSION = `${process.env.STABLE_VERSION}`;
+    if (!STABLEVERSION) {
+        STABLEVERSION = "v1";
+    }
+    // Regular expression to match the route path and extract the resource
+    const regexString = `^\\/api\\/${hasVersion ? `${STABLEVERSION}\\/` : ""}(\\w+)(\\/.*)?$`;
+    const regex = new RegExp(regexString);
+    const path = req.originalUrl;
+    const match = path.match(regex);
+    const resource = match && match[1];
+    // Determine the action based on the HTTP method
+    const action = methodToAction[req.method.toUpperCase()];
+    if (!action) {
+        throw new bad_request_error_1.BadRequestError("Session expired. Please relogin.");
+    }
+    if (!resource) {
+        throw new resource_not_found_1.ResourceNotFound();
+    }
+    // Get the roles and role of the current user from the session
+    const roles = ((_a = req.currentUser) === null || _a === void 0 ? void 0 : _a.role_permission) || [];
+    const role = (_b = req.currentUser) === null || _b === void 0 ? void 0 : _b.role;
+    // Check if the user can perform the action on the resource
+    const canPerform = new accesscontrol_1.default(roles).canPerformAction(role, resource, action);
+    if (!canPerform) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    next();
+};
+exports.isAllowed = isAllowed;

package/build/middlewares/require-auth.d.ts

@@ -0,0 +1,18 @@
+import { Request, Response, NextFunction } from 'express';
+/**
+ * Middleware to check if a user is authenticated before allowing access to certain routes.
+ * If the user is not authenticated, it throws a NotAuthorizedError to indicate access denied.
+ * @param req The Express request object.
+ * @param res The Express response object.
+ * @param next The next middleware function.
+ * @throws NotAuthorizedError if the user is not authenticated.
+ * @example
+*    ```js
+  // Route that requires authentication
+  router.get('/protected', requireAuth, (req, res) => {
+    // Only authenticated users can access this route
+    res.send('You are authorized!');
+  });
+* ```
+ */
+export declare const requireAuth: (req: Request, res: Response, next: NextFunction) => void;

package/build/middlewares/require-auth.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAuth = void 0;
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+/**
+ * Middleware to check if a user is authenticated before allowing access to certain routes.
+ * If the user is not authenticated, it throws a NotAuthorizedError to indicate access denied.
+ * @param req The Express request object.
+ * @param res The Express response object.
+ * @param next The next middleware function.
+ * @throws NotAuthorizedError if the user is not authenticated.
+ * @example
+*    ```js
+  // Route that requires authentication
+  router.get('/protected', requireAuth, (req, res) => {
+    // Only authenticated users can access this route
+    res.send('You are authorized!');
+  });
+* ```
+ */
+const requireAuth = (req, res, next) => {
+    if (!req.currentUser) {
+        throw new not_authorized_error_1.NotAuthorizedError();
+    }
+    next();
+};
+exports.requireAuth = requireAuth;

package/build/middlewares/validate-body.d.ts

@@ -0,0 +1,57 @@
+import { Request, Response, NextFunction } from "express";
+/**
+ * Represents the required fields for each HTTP method.
+ * MethodRequiredProps is a mapping between HTTP methods ("POST", "DELETE", "PATCH", "PUT", "GET")
+ * and an object containing an array of required fields for that method.
+ */
+type MethodRequiredProps = {
+    [key in "POST" | "DELETE" | "PATCH" | "PUT" | "GET"]: {
+        required: string[];
+    };
+};
+/**
+ * Represents the schema for validating request body parameters.
+ * - `fields`: An object mapping each parameter name to its expected type.
+ * - `required`: An optional array of parameter names that are required in the request body.
+ * - `optional`: An optional array of parameter names that are allowed but not required in the request body.
+ */
+export type Schema = {
+    fields: {
+        [key: string]: string;
+    };
+    required?: string[] | MethodRequiredProps;
+    optional?: string[];
+};
+/**
+ * Class providing request body validation middleware.
+ */
+export declare class RequestValidator {
+    private model;
+    /**
+     * Constructor for the RequestValidator class.
+     * @param model The schema defining the expected fields and types in the request body.
+     */
+    constructor(model: Schema);
+    /**
+     * Private method to validate required fields in the request body.
+     * @param obj The request body object.
+     * @param required The required fields or required fields for specific HTTP methods.
+     * @param method The HTTP method of the request.
+     * @returns An object containing the validation status and the element that caused the validation failure (if any).
+     */
+    private required;
+    /**
+     * Private method to check if the fields in the request body match the defined schema.
+     * @param obj The request body object.
+     */
+    private check;
+    /**
+     * Middleware function to validate the request body against the provided schema.
+     * @param req The Express request object.
+     * @param res The Express response object.
+     * @param next The next middleware function.
+     * @throws BadRequestError if any validation fails.
+     */
+    validateReqBody: (req: Request, res: Response, next: NextFunction) => Promise<void>;
+}
+export {};

package/build/middlewares/validate-body.js

@@ -0,0 +1,102 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidator = void 0;
+const bad_request_error_1 = require("../errors/bad-request-error");
+/**
+ * Class providing request body validation middleware.
+ */
+class RequestValidator {
+    /**
+     * Constructor for the RequestValidator class.
+     * @param model The schema defining the expected fields and types in the request body.
+     */
+    constructor(model) {
+        /**
+         * Middleware function to validate the request body against the provided schema.
+         * @param req The Express request object.
+         * @param res The Express response object.
+         * @param next The next middleware function.
+         * @throws BadRequestError if any validation fails.
+         */
+        this.validateReqBody = (req, res, next) => __awaiter(this, void 0, void 0, function* () {
+            const paramsLength = Object.keys(req.params).length;
+            const bodyLength = Object.keys(req.body).length;
+            const method = req.method;
+            const methods = ["POST", "PUT", "DELETE", "PATCH", "GET"];
+            const obj = paramsLength > 0 && bodyLength > 0 ? Object.assign(Object.assign({}, req.params), req.body) : bodyLength > 0 ? req.body : req.params;
+            if (methods.includes(method)) {
+                if (this.model.required) {
+                    const { status, element } = this.required(obj, this.model.required, method);
+                    if (!status) {
+                        throw new bad_request_error_1.BadRequestError(`Required field: ${element}`);
+                    }
+                }
+            }
+            if (!obj.multiadd) {
+                this.check(obj);
+            }
+            else {
+                for (const element of obj.multiadd) {
+                    this.check(element);
+                }
+            }
+            next();
+        });
+        this.model = model;
+    }
+    /**
+     * Private method to validate required fields in the request body.
+     * @param obj The request body object.
+     * @param required The required fields or required fields for specific HTTP methods.
+     * @param method The HTTP method of the request.
+     * @returns An object containing the validation status and the element that caused the validation failure (if any).
+     */
+    required(obj, required, method) {
+        const isArray = Array.isArray(required);
+        if (!obj.multiadd) {
+            const data = !isArray ? required[method]['required'] : required;
+            for (const requiredKey of data) {
+                if (!obj[requiredKey] || (typeof obj[requiredKey] === 'string' && !obj[requiredKey].trim())) {
+                    return { status: false, element: requiredKey };
+                }
+            }
+        }
+        else {
+            if (isArray) {
+                for (const requiredKey of required) {
+                    for (const element of obj.multiadd) {
+                        if (!element[requiredKey]) {
+                            return { status: false, element: requiredKey };
+                        }
+                    }
+                }
+            }
+        }
+        return { status: true, element: '' };
+    }
+    /**
+     * Private method to check if the fields in the request body match the defined schema.
+     * @param obj The request body object.
+     */
+    check(obj) {
+        var _a, _b;
+        for (const key of Object.keys(obj)) {
+            if (!this.model.fields[key] && !((_a = this.model.optional) === null || _a === void 0 ? void 0 : _a.includes(key))) {
+                throw new bad_request_error_1.BadRequestError(`Invalid parameter: ${key}`);
+            }
+            if (typeof obj[key] !== this.model.fields[key] && !((_b = this.model.optional) === null || _b === void 0 ? void 0 : _b.includes(key))) {
+                throw new bad_request_error_1.BadRequestError(`Parameter type mismatch: ${key}`);
+            }
+        }
+    }
+}
+exports.RequestValidator = RequestValidator;

package/build/utils/schemas.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from '../middlewares/validate-body';
+export declare const RegisterSchema: Schema;
+export declare const SigninSchema: Schema;
+export declare const BranchSchema: Schema;
+export declare const DenominationSchema: Schema;
+export declare const CategorySchema: Schema;
+export declare const WardSchema: Schema;
+export declare const UserTypeSchema: Schema;
+export declare const DelegateSchema: Schema;
+export declare const CandidateSchema: Schema;
+export declare const UserSchema: Schema;

package/build/utils/schemas.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserSchema = exports.CandidateSchema = exports.DelegateSchema = exports.UserTypeSchema = exports.WardSchema = exports.CategorySchema = exports.DenominationSchema = exports.BranchSchema = exports.SigninSchema = exports.RegisterSchema = void 0;
+exports.RegisterSchema = {
+    fields: {
+        user_name: 'string',
+        user_type: 'string',
+        password: 'string',
+        email: 'string',
+        contact: 'string',
+        address: 'string',
+    },
+    required: ['user_name', 'user_type', 'password']
+};
+exports.SigninSchema = {
+    fields: {
+        password: 'string',
+        user_name: 'string',
+    },
+    required: ['password', 'user_name']
+};
+exports.BranchSchema = {
+    fields: {
+        id: 'string',
+        name: 'string',
+        ward_id: 'string',
+        include: 'string',
+        code: 'string',
+        status: 'boolean',
+    },
+    required: {
+        'POST': { required: ['name', 'status', 'ward_id', 'code'] },
+        'PUT': { required: ['id', 'ward_id'] },
+        'PATCH': { required: [] },
+        'DELETE': { required: ['id'] },
+        'GET': { required: ['id'] },
+    },
+    optional: ['include', 'ward_id']
+};
+exports.DenominationSchema = {
+    fields: {
+        id: 'string',
+        include: 'string',
+        name: 'string',
+        status: 'boolean',
+    },
+    required: {
+        'POST': { required: ['name', 'status'] },
+        'PUT': { required: ['id'] },
+        'PATCH': { required: [] },
+        'DELETE': { required: ['id'] },
+        'GET': { required: ['id'] },
+    },
+    optional: ['include']
+};
+exports.CategorySchema = {
+    fields: {
+        id: 'string',
+        name: 'string',
+        status: 'boolean',
+    },
+    required: {
+        'POST': { required: ['name', 'status'] },
+        'PUT': { required: ['id'] },
+        'PATCH': { required: [] },
+        'DELETE': { required: ['id'] },
+        'GET': { required: ['id'] },
+    }
+};
+exports.WardSchema = {
+    fields: {
+        id: 'string',
+        name: 'string',
+        status: 'boolean',
+    },
+    required: {
+        'POST': { required: ['name', 'status'] },
+        'PUT': { required: ['id'] },
+        'PATCH': { required: [] },
+        'DELETE': { required: ['id'] },
+        'GET': { required: ['id'] },
+    }
+};
+exports.UserTypeSchema = {
+    fields: {
+        id: 'string',
+        name: 'string',
+        status: 'boolean',
+    },
+    required: {
+        'POST': { required: ['name', 'status'] },
+        'PUT': { required: ['id'] },
+        'PATCH': { required: [] },
+        'DELETE': { required: ['id'] },
+        'GET': { required: ['id'] },
+    }
+};
+exports.DelegateSchema = {
+    fields: {
+        id: 'string',
+        include: 'string',
+        name: 'string',
+        position: 'string',
+        voter_id_nnumber: 'string',
+        membership_number: 'string',
+        contact: 'string',
+        denomination_id: 'string',
+        status: 'boolean',
+        branch_id: 'string',
+        category_id: 'string',
+        is_potential_for: 'string',
+        multi_update: 'boolean'
+    },
+    required: {
+        'POST': { required: ['name', 'status', 'category_id'] },
+        'PUT': { required: ['id'] },
+        'PATCH': { required: [] },
+        'DELETE': { required: ['id'] },
+        'GET': { required: ['id'] },
+    },
+    optional: ['include']
+};
+exports.CandidateSchema = {
+    fields: {
+        id: 'string',
+        include: 'string',
+        name: 'string',
+        position: 'string',
+        voter_id_nnumber: 'string',
+        membership_number: 'string',
+        contact: 'string',
+        address: 'string',
+        denomination: 'string',
+        email: 'string',
+        status: 'boolean',
+        branch_id: 'string',
+        delegate_id: 'string',
+    },
+    required: {
+        'POST': { required: ['name', 'status', 'branch_id'] },
+        'PUT': { required: ['id'] },
+        'PATCH': { required: [] },
+        'DELETE': { required: ['id'] },
+        'GET': { required: ['id'] },
+    },
+    optional: ['include']
+};
+exports.UserSchema = {
+    fields: {
+        role: 'string',
+        password: 'string',
+        password_tries: 'number',
+        status: 'number',
+        ip_address: 'string',
+        employee_id: 'string',
+        company_id: 'string',
+        branch_id: 'string',
+        multiadd: 'object'
+    },
+    required: ['role', 'password', 'employee_id', 'company_id'],
+    optional: ['branch_id', 'multiadd']
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hastehaul/common",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -23,6 +23,7 @@
     "typescript": "^5.1.6"
   },
   "dependencies": {
+    "@vsky/accesscontrol": "^3.0.14",
     "bullmq": "^4.6.3",
     "express": "^4.18.2",
     "ioredis": "^5.3.2",