response-standardizer 1.3.3 → 1.3.5

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";
@@ -71,6 +70,9 @@ const created = (req, res, data) => {
 const deleted = (req, res) => {
     res.status(204).send();
 };
+const noContent = (req, res) => {
+    res.status(204).send();
+};
 const validationError = (req, res, errors, message = "Validation error") => {
     res.status(400).json({ errors, message });
 };
@@ -94,6 +96,7 @@ exports.RestResponse = {
     paginate,
     created,
     deleted,
+    noContent,
     validationError,
     exceptionError,
     unauthorized,
@@ -166,68 +169,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/dist/types.d.ts

@@ -28,6 +28,7 @@ export interface RestResponseFunctions {
     paginate: <T>(req: Request, res: Response, data: Pagination<T>) => void;
     created: <T>(req: Request, res: Response, data: T) => void;
     deleted: (req: Request, res: Response) => void;
+    noContent: (req: Request, res: Response) => void;
     validationError: (req: Request, res: Response, errors?: ErrorFields, message?: string) => void;
     exceptionError: (req: Request, res: Response, errors: any, message?: string) => void;
     unauthorized: (req: Request, res: Response, message?: string) => void;

package/package.json

@@ -1,38 +1,38 @@
-{
-  "name": "response-standardizer",
-  "version": "1.3.3",
-  "description": "Express middleware to standardize API responses",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "commonjs",
-  "scripts": {
-    "build": "tsc",
-    "prepare": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://gitlab.com/dezhnevesht-archive-software/response-standardizer.git"
-  },
-  "author": "Hamid Atyabi",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://gitlab.com/dezhnevesht-archive-software/response-standardizer/issues"
-  },
-  "homepage": "https://gitlab.com/dezhnevesht-archive-software/response-standardizer#readme",
-  "peerDependencies": {
-    "express": "^4 || ^5"
-  },
-  "dependencies": {
-    "axios": "^1.13.2",
-    "jsonwebtoken": "^9.0.2",
-    "uuid": "^9.0.1",
-    "zod": "^4.1.12"
-  },
-  "devDependencies": {
-    "@types/express": "^5.0.5",
-    "@types/jsonwebtoken": "^9.0.10",
-    "@types/uuid": "^10.0.0",
-    "ts-node-dev": "^2.0.0",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "response-standardizer",
+  "version": "1.3.5",
+  "description": "Express middleware to standardize API responses",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/dezhnevesht-archive-software/response-standardizer.git"
+  },
+  "author": "Hamid Atyabi",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://gitlab.com/dezhnevesht-archive-software/response-standardizer/issues"
+  },
+  "homepage": "https://gitlab.com/dezhnevesht-archive-software/response-standardizer#readme",
+  "peerDependencies": {
+    "express": "^4 || ^5"
+  },
+  "dependencies": {
+    "axios": "^1.13.2",
+    "jsonwebtoken": "^9.0.2",
+    "uuid": "^9.0.1",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.5",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/uuid": "^10.0.0",
+    "ts-node-dev": "^2.0.0",
+    "typescript": "^5.9.3"
+  }
+}

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

@@ -1,272 +1,219 @@
-import { Request, Response, NextFunction } from "express";
-import { ErrorFields, StandardResponse, RestResponseFunctions, RestMiddlewareFunctions, AuthRequest, Pagination } from "./types";
-import { generateRequestId, getTimestamp } from "./utils";
-import axios from "axios";
-import jwt, { TokenExpiredError } from "jsonwebtoken";
-import path from "path";
-import { ZodError } from "zod";
-declare global {
-  namespace Express {
-    interface Response {
-      json: (data: any) => Response;
-      send: (data?: any) => Response;
-      locals: {
-        requestId: string;
-        [key: string]: any;
-      };
-    }
-  }
-}
-let KEYCLOAK_PUBLIC_KEY: any = null;
-export const initKeycloak = async (config: { service?: string; realm?: string }) => {
-  const KEYCLOAK_SERVICE = config.service ?? "localhost";
-  const KEYCLOAK_REALM = config.realm ?? "master";
-  const realmUrl = `http://${KEYCLOAK_SERVICE}/realms/${KEYCLOAK_REALM}`;
-  info(`Keycloak PublicKey Url: ${realmUrl}`);
-  const resp = await axios.get(realmUrl);
-  const key = resp.data.public_key;
-  KEYCLOAK_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----\n${key.match(/.{1,64}/g)?.join("\n")}\n-----END PUBLIC KEY-----`;
-};
-
-export const protect = (allowedRoles?: string[]) => {
-    return (req: any, res: any, next: any) => {
-        const authHeader = req.headers["authorization"];
-        if (!authHeader)
-            return RestResponse.unauthorized(req, res)
-
-        const token = authHeader.split(" ")[1];
-        if (!token) 
-            return RestResponse.unauthorized(req, res, "Token malformed")
-
-        try {
-            const decoded = jwt.verify(token, KEYCLOAK_PUBLIC_KEY, { algorithms: ["RS256"] });
-            (req as AuthRequest).user = decoded;
-            (req as AuthRequest).token = token;
-            if(allowedRoles)
-                return role(req, res, next, allowedRoles);
-            
-            next();
-        } catch (err) {
-            error((err as any)?.message)
-            return RestResponse.unauthorized(req, res, "Token is not valid")
-        }
-    }
-  
-}
-const role = (req: any, res: any, next: any, allowedRoles: string[]) => {
-  const user = req.user;
-    if (!user) {
-      return RestResponse.unauthorized(req, res);
-    }
-    const realmRoles: string[] = (user?.realm_access?.roles ?? []).map((r: string) => r.toUpperCase());
-    const clientRoles: string[] = Object.values(user?.resource_access ?? {})
-      .flatMap((r: any) => r.roles ?? [])
-      .map((r: string) => r.toUpperCase());
-    const allowedUpper = allowedRoles.map(r => r === "super-admin"?"ADMIN":`DEZH-${r.toUpperCase()}`);
-    const allRoles = [...realmRoles, ...clientRoles];
-    const hasAccess: boolean = allowedUpper.some((role: string) =>
-      allRoles.includes(role)
-    );
-    if (!hasAccess) {
-      return RestResponse.accessDenied(req, res)
-    }
-    next()
-}
-const success = <T>(req: Request, res: Response, data: T) => {
-    res.status(200).json(data);
-};
-
-const paginate = <T>(
-    req: Request,
-    res: Response,
-    data: Pagination<T>
-) => {
-    res.status(200).json(data);
-};
-
-const created = <T>(req: Request, res: Response, data: T) => {
-    res.status(201).json(data);
-};
-
-const deleted = (req: Request, res: Response) => {
-    res.status(204).send();
-};
-
-const validationError = (
-    req: Request,
-    res: Response,
-    errors?: ErrorFields,
-    message = "Validation error"
-) => {
-    res.status(400).json({ errors, message });
-};
-
-const exceptionError = (
-    req: Request,
-    res: Response,
-    errors: any,
-    message = "Internal server error"
-) => {
-    res.status(500).json({
-        message,
-        errors
-    });
-};
-
-const unauthorized = (req: Request, res: Response, message = "Unauthorized") => {
-    res.status(401).json({ message });
-};
-
-const accessDenied = (req: Request, res: Response, message = "Access denied") => {
-    res.status(403).json({ message });
-};
-
-const notFound = (req: Request, res: Response, message = "Not found") => {
-    res.status(404).json({ message });
-};
-
-export const RestResponse: RestResponseFunctions = {
-    success,
-    paginate,
-    created,
-    deleted,
-    validationError,
-    exceptionError,
-    unauthorized,
-    accessDenied,
-    notFound
-};
-
-
-const responseHandlerMiddleware = (
-    req: Request,
-    res: Response,
-    next: NextFunction
-) => {
-
-    const oldJson = res.json.bind(res);
-    const oldSend = res.send.bind(res);
-
-    res.json = function (data: any) {
-        if(res.statusCode > 204){
-            const response: StandardResponse = {
-                code: res.statusCode,
-                message: data?.message || res.locals.message || (res.statusCode < 300 ? "OK" : "Error"),
-                errors: data?.errors ?? null,
-                meta: {
-                    requestId: res.locals.requestId || generateRequestId(),
-                    timestamp: getTimestamp()
-                }
-            };
-
-            return oldJson(response);
-        }
-        return oldJson(data);
-    };
-
-    res.send = function (data: any) {
-        if (res.statusCode === 204) {
-            return oldSend();
-        }
-        return oldSend(data);
-    };
-
-    res.locals.requestId = generateRequestId();
-    next();
-};
-
-
-export const RestMiddleware: RestMiddlewareFunctions = {
-    responseHandlerMiddleware
-}
-
-
-const colors = {
-    RESET: "\x1b[0m",
-    RED: "\x1b[31m",
-    GREEN: "\x1b[32m",
-    YELLOW: "\x1b[33m"
-};
-
-const isProduction = process.env.NODE_ENV === "production";
-export const error = (message: string, meta?: any) => {
-    log("ERROR", message, meta)
-}
-export const warn = (message: string, meta?: any) => {
-    log("WARN", message, meta)
-}
-export const info = (message: string, meta?: any) => {
-    log("INFO", message, meta)
-}
-export const log = (level: "INFO" | "WARN" | "ERROR", message: string, meta?: any) => {
-    const timestamp = new Date().toISOString();
-
-    // انتخاب رنگ فقط در dev
-    let color = colors.RESET;
-    if (!isProduction) {
-        if (level === "INFO") color = colors.GREEN;
-        if (level === "WARN") color = colors.YELLOW;
-        if (level === "ERROR") color = colors.RED;
-    }
-    const metaStr = meta ? `. ${JSON.stringify(meta)}` : "";
-
-    // چاپ لاگ
-    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) {}
-}
+import { Request, Response, NextFunction } from "express";
+import { ErrorFields, StandardResponse, RestResponseFunctions, RestMiddlewareFunctions, AuthRequest, Pagination } from "./types";
+import { generateRequestId, getTimestamp } from "./utils";
+import axios from "axios";
+import jwt, { TokenExpiredError } from "jsonwebtoken";
+import path from "path";
+import { ZodError } from "zod";
+declare global {
+  namespace Express {
+    interface Response {
+      json: (data: any) => Response;
+      send: (data?: any) => Response;
+      locals: {
+        requestId: string;
+        [key: string]: any;
+      };
+    }
+  }
+}
+let KEYCLOAK_PUBLIC_KEY: any = null;
+export const initKeycloak = async (config: { service?: string; realm?: string }) => {
+  const KEYCLOAK_SERVICE = config.service ?? "localhost";
+  const KEYCLOAK_REALM = config.realm ?? "master";
+  const realmUrl = `http://${KEYCLOAK_SERVICE}/realms/${KEYCLOAK_REALM}`;
+  info(`Keycloak PublicKey Url: ${realmUrl}`);
+  const resp = await axios.get(realmUrl);
+  const key = resp.data.public_key;
+  KEYCLOAK_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----\n${key.match(/.{1,64}/g)?.join("\n")}\n-----END PUBLIC KEY-----`;
+};
+
+export const protect = (allowedRoles?: string[]) => {
+    return (req: any, res: any, next: any) => {
+        const authHeader = req.headers["authorization"];
+        if (!authHeader)
+            return RestResponse.unauthorized(req, res)
+
+        const token = authHeader.split(" ")[1];
+        if (!token) 
+            return RestResponse.unauthorized(req, res, "Token malformed")
+
+        try {
+            const decoded = jwt.verify(token, KEYCLOAK_PUBLIC_KEY, { algorithms: ["RS256"] });
+            (req as AuthRequest).user = decoded;
+            (req as AuthRequest).token = token;
+            if(allowedRoles)
+                return role(req, res, next, allowedRoles);
+            
+            next();
+        } catch (err) {
+            error((err as any)?.message)
+            return RestResponse.unauthorized(req, res, "Token is not valid")
+        }
+    }
+  
+}
+const role = (req: any, res: any, next: any, allowedRoles: string[]) => {
+  const user = req.user;
+    if (!user) {
+      return RestResponse.unauthorized(req, res);
+    }
+    const realmRoles: string[] = (user?.realm_access?.roles ?? []).map((r: string) => r.toUpperCase());
+    const clientRoles: string[] = Object.values(user?.resource_access ?? {})
+      .flatMap((r: any) => r.roles ?? [])
+      .map((r: string) => r.toUpperCase());
+    const allowedUpper = allowedRoles.map(r => r === "super-admin"?"ADMIN":`DEZH-${r.toUpperCase()}`);
+    const allRoles = [...realmRoles, ...clientRoles];
+    const hasAccess: boolean = allowedUpper.some((role: string) =>
+      allRoles.includes(role)
+    );
+    if (!hasAccess) {
+      return RestResponse.accessDenied(req, res)
+    }
+    next()
+}
+const success = <T>(req: Request, res: Response, data: T) => {
+    res.status(200).json(data);
+};
+
+const paginate = <T>(
+    req: Request,
+    res: Response,
+    data: Pagination<T>
+) => {
+    res.status(200).json(data);
+};
+
+const created = <T>(req: Request, res: Response, data: T) => {
+    res.status(201).json(data);
+};
+
+const deleted = (req: Request, res: Response) => {
+    res.status(204).send();
+};
+const noContent = (req: Request, res: Response) => {
+    res.status(204).send();
+};
+
+const validationError = (
+    req: Request,
+    res: Response,
+    errors?: ErrorFields,
+    message = "Validation error"
+) => {
+    res.status(400).json({ errors, message });
+};
+
+const exceptionError = (
+    req: Request,
+    res: Response,
+    errors: any,
+    message = "Internal server error"
+) => {
+    res.status(500).json({
+        message,
+        errors
+    });
+};
+
+const unauthorized = (req: Request, res: Response, message = "Unauthorized") => {
+    res.status(401).json({ message });
+};
+
+const accessDenied = (req: Request, res: Response, message = "Access denied") => {
+    res.status(403).json({ message });
+};
+
+const notFound = (req: Request, res: Response, message = "Not found") => {
+    res.status(404).json({ message });
+};
+
+export const RestResponse: RestResponseFunctions = {
+    success,
+    paginate,
+    created,
+    deleted,
+    noContent,
+    validationError,
+    exceptionError,
+    unauthorized,
+    accessDenied,
+    notFound
+};
+
+
+const responseHandlerMiddleware = (
+    req: Request,
+    res: Response,
+    next: NextFunction
+) => {
+
+    const oldJson = res.json.bind(res);
+    const oldSend = res.send.bind(res);
+
+    res.json = function (data: any) {
+        if(res.statusCode > 204){
+            const response: StandardResponse = {
+                code: res.statusCode,
+                message: data?.message || res.locals.message || (res.statusCode < 300 ? "OK" : "Error"),
+                errors: data?.errors ?? null,
+                meta: {
+                    requestId: res.locals.requestId || generateRequestId(),
+                    timestamp: getTimestamp()
+                }
+            };
+
+            return oldJson(response);
+        }
+        return oldJson(data);
+    };
+
+    res.send = function (data: any) {
+        if (res.statusCode === 204) {
+            return oldSend();
+        }
+        return oldSend(data);
+    };
+
+    res.locals.requestId = generateRequestId();
+    next();
+};
+
+
+export const RestMiddleware: RestMiddlewareFunctions = {
+    responseHandlerMiddleware
+}
+
+
+const colors = {
+    RESET: "\x1b[0m",
+    RED: "\x1b[31m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m"
+};
+
+const isProduction = process.env.NODE_ENV === "production";
+export const error = (message: string, meta?: any) => {
+    log("ERROR", message, meta)
+}
+export const warn = (message: string, meta?: any) => {
+    log("WARN", message, meta)
+}
+export const info = (message: string, meta?: any) => {
+    log("INFO", message, meta)
+}
+export const log = (level: "INFO" | "WARN" | "ERROR", message: string, meta?: any) => {
+    const timestamp = new Date().toISOString();
+
+    // انتخاب رنگ فقط در dev
+    let color = colors.RESET;
+    if (!isProduction) {
+        if (level === "INFO") color = colors.GREEN;
+        if (level === "WARN") color = colors.YELLOW;
+        if (level === "ERROR") color = colors.RED;
+    }
+    const metaStr = meta ? `. ${JSON.stringify(meta)}` : "";
+
+    // چاپ لاگ
+    console.log(`${color}[${timestamp}][${level}] ${message}${metaStr}${colors.RESET}`);
+};

package/src/types.ts

@@ -1,60 +1,61 @@
-import { Request, Response, NextFunction } from "express";
-
-export interface StandardResponse<T = any> {
-    code: number;
-    message: string;
-    errors: Record<string, string[]> | null;
-    meta: {
-        requestId: string;
-        timestamp: string;
-    };
-}
-export interface PaginationMeta{
-    total: number;
-    page: number;
-    limit: number;
-    totalPages: number;
-}
-export interface Pagination<T>{
-    data: T[];
-    meta: PaginationMeta
-}
-
-
-export type ErrorFields = Record<string, string[]>;
-
-export type Middleware = (req: Request, res: Response, next: NextFunction) => void;
-
-export interface RestMiddlewareFunctions {
-    responseHandlerMiddleware: <T>(req: Request, res: Response, next: NextFunction) => void
-}
-export interface RestResponseFunctions {
-    success: <T>(req: Request, res: Response, data: T) => void;
-    paginate: <T>(
-        req: Request,
-        res: Response,
-        data: Pagination<T>
-    ) => void;
-    created: <T>(req: Request, res: Response, data: T) => void;
-    deleted: (req: Request, res: Response) => void;
-    validationError: (
-        req: Request,
-        res: Response,
-        errors?: ErrorFields,
-        message?: string
-    ) => void;
-    exceptionError: (
-        req: Request,
-        res: Response,
-        errors: any,
-        message?: string
-    ) => void;
-    unauthorized: (req: Request, res: Response, message?: string) => void;
-    accessDenied: (req: Request, res: Response, message?: string) => void;
-    notFound: (req: Request, res: Response, message?: string) => void;
-}
-
-export interface AuthRequest extends Request {
-    user?: any;
-    token?: string
+import { Request, Response, NextFunction } from "express";
+
+export interface StandardResponse<T = any> {
+    code: number;
+    message: string;
+    errors: Record<string, string[]> | null;
+    meta: {
+        requestId: string;
+        timestamp: string;
+    };
+}
+export interface PaginationMeta{
+    total: number;
+    page: number;
+    limit: number;
+    totalPages: number;
+}
+export interface Pagination<T>{
+    data: T[];
+    meta: PaginationMeta
+}
+
+
+export type ErrorFields = Record<string, string[]>;
+
+export type Middleware = (req: Request, res: Response, next: NextFunction) => void;
+
+export interface RestMiddlewareFunctions {
+    responseHandlerMiddleware: <T>(req: Request, res: Response, next: NextFunction) => void
+}
+export interface RestResponseFunctions {
+    success: <T>(req: Request, res: Response, data: T) => void;
+    paginate: <T>(
+        req: Request,
+        res: Response,
+        data: Pagination<T>
+    ) => void;
+    created: <T>(req: Request, res: Response, data: T) => void;
+    deleted: (req: Request, res: Response) => void;
+    noContent: (req: Request, res: Response) => void;
+    validationError: (
+        req: Request,
+        res: Response,
+        errors?: ErrorFields,
+        message?: string
+    ) => void;
+    exceptionError: (
+        req: Request,
+        res: Response,
+        errors: any,
+        message?: string
+    ) => void;
+    unauthorized: (req: Request, res: Response, message?: string) => void;
+    accessDenied: (req: Request, res: Response, message?: string) => void;
+    notFound: (req: Request, res: Response, message?: string) => void;
+}
+
+export interface AuthRequest extends Request {
+    user?: any;
+    token?: string
 }

package/src/utils.ts

@@ -1,9 +1,9 @@
-import { v4 as uuidv4 } from "uuid";
-
-export const generateRequestId = () => {
-    return uuidv4();
-}
-
-export const getTimestamp = () => {
-    return new Date().toISOString();
-}
+import { v4 as uuidv4 } from "uuid";
+
+export const generateRequestId = () => {
+    return uuidv4();
+}
+
+export const getTimestamp = () => {
+    return new Date().toISOString();
+}

package/tsconfig.json

@@ -1,15 +1,15 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "Node",
-    "rootDir": "src",
-    "outDir": "dist",
-    "strict": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "forceConsistentCasingInFileNames": true,
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*"]
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": true,
+    "declaration": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+  "include": ["src/**/*"]
 }