response-standardizer 1.3.3 → 1.3.4

package/dist/exceptions.d.ts

@@ -0,0 +1,26 @@
+import { Request, Response } from "express";
+import { ErrorFields } from "./types";
+export declare class ServiceException extends Error {
+    statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+export declare class UnknownException extends ServiceException {
+    constructor(statusCode: number, message: string);
+}
+export declare class NotFoundException extends ServiceException {
+    constructor(message: string);
+}
+export declare class UnauthorizedException extends ServiceException {
+    constructor(message: string);
+}
+export declare class AccessDeniedException extends ServiceException {
+    constructor(message: string);
+}
+export declare class InternalServerException extends ServiceException {
+    constructor(message: string);
+}
+export declare class ValidationException extends ServiceException {
+    errors?: ErrorFields;
+    constructor(message: string, errors?: ErrorFields);
+}
+export declare const handleControllerException: (req: Request, res: Response, err: Error) => void;

package/dist/exceptions.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleControllerException = exports.ValidationException = exports.InternalServerException = exports.AccessDeniedException = exports.UnauthorizedException = exports.NotFoundException = exports.UnknownException = exports.ServiceException = void 0;
+const _1 = require(".");
+class ServiceException extends Error {
+    constructor(statusCode, message) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+exports.ServiceException = ServiceException;
+class UnknownException extends ServiceException {
+    constructor(statusCode, message) {
+        super(statusCode, message);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.UnknownException = UnknownException;
+class NotFoundException extends ServiceException {
+    constructor(message) {
+        super(404, message);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.NotFoundException = NotFoundException;
+class UnauthorizedException extends ServiceException {
+    constructor(message) {
+        super(401, message);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.UnauthorizedException = UnauthorizedException;
+class AccessDeniedException extends ServiceException {
+    constructor(message) {
+        super(403, message);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.AccessDeniedException = AccessDeniedException;
+class InternalServerException extends ServiceException {
+    constructor(message) {
+        super(500, message);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.InternalServerException = InternalServerException;
+class ValidationException extends ServiceException {
+    constructor(message, errors) {
+        super(400, message);
+        this.errors = errors;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+exports.ValidationException = ValidationException;
+const handleControllerException = (req, res, err) => {
+    if (err instanceof UnauthorizedException) {
+        return _1.RestResponse.unauthorized(req, res, err.message);
+    }
+    else if (err instanceof AccessDeniedException) {
+        return _1.RestResponse.accessDenied(req, res, err.message);
+    }
+    else if (err instanceof ValidationException) {
+        return _1.RestResponse.validationError(req, res, err?.errors, err?.message);
+    }
+    else if (err instanceof InternalServerException) {
+        return _1.RestResponse.exceptionError(req, res, err.message);
+    }
+    else if (err instanceof NotFoundException) {
+        return _1.RestResponse.notFound(req, res, err.message);
+    }
+    return _1.RestResponse.exceptionError(req, res, err.message);
+};
+exports.handleControllerException = handleControllerException;

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-import { Request, Response } from "express";
-import { ErrorFields, RestResponseFunctions, RestMiddlewareFunctions } from "./types";
+import { RestResponseFunctions, RestMiddlewareFunctions } from "./types";
 declare global {
     namespace Express {
         interface Response {
@@ -23,17 +22,3 @@ export declare const error: (message: string, meta?: any) => void;
 export declare const warn: (message: string, meta?: any) => void;
 export declare const info: (message: string, meta?: any) => void;
 export declare const log: (level: "INFO" | "WARN" | "ERROR", message: string, meta?: any) => void;
-export declare const response: (req: Request, res: Response, response: ServiceResponse, handler?: (eq: Request, res: Response, data?: any) => void) => void;
-export declare const handleServiceException: (message: string, err: any) => ServiceResponse;
-export interface ServiceResponse {
-}
-export declare class ServiceException implements ServiceResponse {
-    code: number;
-    message: string;
-    errors?: ErrorFields | undefined;
-    constructor(code: number, message: string, errors?: ErrorFields | undefined);
-}
-export declare class ServiceResponseSuccess implements ServiceResponse {
-    entity: any;
-    constructor(entity?: any);
-}

package/dist/index.js

@@ -3,11 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceResponseSuccess = exports.ServiceException = exports.handleServiceException = exports.response = exports.log = exports.info = exports.warn = exports.error = exports.RestMiddleware = exports.RestResponse = exports.protect = exports.initKeycloak = void 0;
+exports.log = exports.info = exports.warn = exports.error = exports.RestMiddleware = exports.RestResponse = exports.protect = exports.initKeycloak = void 0;
 const utils_1 = require("./utils");
 const axios_1 = __importDefault(require("axios"));
 const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const zod_1 = require("zod");
 let KEYCLOAK_PUBLIC_KEY = null;
 const initKeycloak = async (config) => {
     const KEYCLOAK_SERVICE = config.service ?? "localhost";
@@ -166,68 +165,3 @@ const log = (level, message, meta) => {
     console.log(`${color}[${timestamp}][${level}] ${message}${metaStr}${colors.RESET}`);
 };
 exports.log = log;
-const response = (req, res, response, handler = (eq, res, data = null) => { }) => {
-    if (response instanceof ServiceException) {
-        if (response?.code === 401) {
-            return exports.RestResponse.unauthorized(req, res, response?.message);
-        }
-        else if (response?.code === 403) {
-            return exports.RestResponse.accessDenied(req, res, response?.message);
-        }
-        else if (response?.code === 400) {
-            return exports.RestResponse.validationError(req, res, response?.errors);
-        }
-        else if (response?.code === 500) {
-            return exports.RestResponse.exceptionError(req, res, response.message);
-        }
-        else if (response?.code === 404) {
-            return exports.RestResponse.notFound(req, res, response.message);
-        }
-        return exports.RestResponse.exceptionError(req, res, response.message);
-    }
-    return handler(req, res, response.entity);
-};
-exports.response = response;
-const handleServiceException = (message, err) => {
-    if (err instanceof zod_1.ZodError) {
-        const zodError = err;
-        if (zodError.issues) {
-            const validationErrors = {};
-            zodError.issues.forEach((i) => {
-                const key = i.path[0];
-                if (!validationErrors[key])
-                    validationErrors[key] = [];
-                validationErrors[key].push(i.message);
-            });
-            return new ServiceException(400, "Validation error", validationErrors);
-        }
-    }
-    else if (err?.isAxiosError && err?.response && err.response.status) {
-        (0, exports.error)(message, {
-            status: err.response.status,
-            statusText: err.response.statusText,
-            error: err.response.data
-        });
-        return new ServiceException(err.response.status, err.response.data?.error_description);
-    }
-    else if (err instanceof Error) {
-        (0, exports.error)(message, { error: err });
-        return new ServiceException(500, err?.message);
-    }
-    return new ServiceException(500, "Internal server error");
-};
-exports.handleServiceException = handleServiceException;
-class ServiceException {
-    constructor(code, message, errors) {
-        this.code = code;
-        this.message = message;
-        this.errors = errors;
-    }
-}
-exports.ServiceException = ServiceException;
-class ServiceResponseSuccess {
-    constructor(entity = null) {
-        this.entity = entity;
-    }
-}
-exports.ServiceResponseSuccess = ServiceResponseSuccess;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "response-standardizer",
-  "version": "1.3.3",
+  "version": "1.3.4",
   "description": "Express middleware to standardize API responses",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/exceptions.ts

@@ -0,0 +1,65 @@
+import { Request, Response } from "express";
+import { RestResponse } from ".";
+import { ErrorFields } from "./types";
+export class ServiceException extends Error{
+    statusCode: number;  
+    constructor(statusCode: number, message: string) {
+        super(message);
+        this.statusCode = statusCode;
+    }
+}
+export class UnknownException extends ServiceException {
+  constructor(statusCode: number, message: string) {
+    super(statusCode, message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class NotFoundException extends ServiceException {
+  constructor(message: string) {
+    super(404, message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class UnauthorizedException extends ServiceException {
+  constructor(message: string) {
+    super(401, message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class AccessDeniedException extends ServiceException {
+  constructor(message: string) {
+    super(403, message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class InternalServerException extends ServiceException {
+  constructor(message: string) {
+    super(500, message);
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class ValidationException extends ServiceException {
+  errors?: ErrorFields
+
+  constructor(message: string, errors?: ErrorFields) {
+    super(400, message);
+    this.errors = errors;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export const handleControllerException = (req: Request, res: Response, err: Error) => {
+    if(err instanceof UnauthorizedException){
+        return RestResponse.unauthorized(req, res, err.message);
+    }else if(err instanceof AccessDeniedException){
+        return RestResponse.accessDenied(req, res, err.message);
+    }else if(err instanceof ValidationException){
+        return RestResponse.validationError(req, res, (err as any)?.errors, (err as any)?.message);
+    }else if(err instanceof InternalServerException){
+        return RestResponse.exceptionError(req, res, err.message);
+    }else if(err instanceof NotFoundException){
+        return RestResponse.notFound(req, res, err.message);
+    }
+    
+    return RestResponse.exceptionError(req, res, err.message);
+}

package/src/index.ts

@@ -212,61 +212,4 @@ export const log = (level: "INFO" | "WARN" | "ERROR", message: string, meta?: an
 
     // چاپ لاگ
     console.log(`${color}[${timestamp}][${level}] ${message}${metaStr}${colors.RESET}`);
-};
-export const response = (
-    req: Request, 
-    res: Response, 
-    response: ServiceResponse, 
-    handler = (eq: Request, res: Response, data: any = null) => {}
-) => {
-    if(response instanceof ServiceException){
-        if(response?.code === 401){
-            return RestResponse.unauthorized(req, res, response?.message)
-        }else if(response?.code === 403){
-            return RestResponse.accessDenied(req, res, response?.message)
-        }else if(response?.code === 400){
-            return RestResponse.validationError(req, res, response?.errors)
-        }else if(response?.code === 500){
-            return RestResponse.exceptionError(req, res, response.message)
-        }else if(response?.code === 404){
-            return RestResponse.notFound(req, res, response.message)
-        }
-        return RestResponse.exceptionError(req, res, response.message)
-    }
-    return handler(req, res, (response as ServiceResponseSuccess).entity)
-}
-export const handleServiceException = (message: string, err: any) : ServiceResponse => {
-    if(err instanceof ZodError){
-        const zodError = err as ZodError;
-        if (zodError.issues) {
-            const validationErrors: any = {};
-            zodError.issues.forEach((i) => {
-                const key = i.path[0];
-                if (!validationErrors[key]) validationErrors[key] = [];
-                validationErrors[key].push(i.message);
-            });
-            return new ServiceException(400, "Validation error", validationErrors)
-        }
-    }else if((err as any)?.isAxiosError && (err as any)?.response && (err as any).response.status){
-        error(message, {
-            status: (err as any).response.status,
-            statusText: (err as any).response.statusText,
-            error: (err as any).response.data
-        })
-        return new ServiceException((err as any).response.status, (err as any).response.data?.error_description);
-    }else if(err instanceof Error){
-        error(message, { error: err })
-        return new ServiceException(500, err?.message);
-    }
-    return new ServiceException(500, "Internal server error");
-}
-
-export interface ServiceResponse{
-
-}
-export class ServiceException implements ServiceResponse {
-    constructor(public code: number, public message: string, public errors?: ErrorFields) {}
-}
-export class ServiceResponseSuccess implements ServiceResponse {
-    constructor(public entity: any = null) {}
-}
+};