response-standardizer 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { RestResponseFunctions, RestMiddlewareFunctions, KeycloakFunctions } from "./types.js";
+import { RestResponseFunctions, RestMiddlewareFunctions } from "./types.js";
 declare global {
     namespace Express {
         interface Response {
@@ -15,6 +15,6 @@ export declare const initKeycloak: (config: {
     service?: string;
     realm?: string;
 }) => Promise<void>;
-export declare const Keycloak: KeycloakFunctions;
+export declare const protect: (allowedRoles?: string[]) => (req: any, res: any, next: any) => void;
 export declare const RestResponse: RestResponseFunctions;
 export declare const RestMiddleware: RestMiddlewareFunctions;

package/dist/index.js

@@ -11,45 +11,43 @@ export const initKeycloak = async (config) => {
     const key = resp.data.public_key;
     KEYCLOAK_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----\n${key.match(/.{1,64}/g)?.join("\n")}\n-----END PUBLIC KEY-----`;
 };
-const protect = (req, res, next) => {
-    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.user = decoded;
-        next();
-    }
-    catch (err) {
-        console.error(err);
-        return RestResponse.unauthorized(req, res, "Token is not valid");
-    }
-};
-const role = (allowedRoles) => {
+export const protect = (allowedRoles) => {
     return (req, res, next) => {
-        const user = req.user;
-        if (!user) {
+        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.user = decoded;
+            if (allowedRoles)
+                return role(req, res, next, allowedRoles);
+            next();
         }
-        const realmRoles = (user?.realm_access?.roles ?? []).map((r) => r.toUpperCase());
-        const clientRoles = Object.values(user?.resource_access ?? {})
-            .flatMap((r) => r.roles ?? [])
-            .map((r) => r.toUpperCase());
-        const allowedUpper = allowedRoles.map(r => r.toUpperCase());
-        const allRoles = [...realmRoles, ...clientRoles];
-        const hasAccess = allowedUpper.some((role) => allRoles.includes(role));
-        if (!hasAccess) {
-            return RestResponse.accessDenied(req, res);
+        catch (err) {
+            console.error(err);
+            return RestResponse.unauthorized(req, res, "Token is not valid");
         }
-        next();
     };
 };
-export const Keycloak = {
-    protect,
-    role
+const role = (req, res, next, allowedRoles) => {
+    const user = req.user;
+    if (!user) {
+        return RestResponse.unauthorized(req, res);
+    }
+    const realmRoles = (user?.realm_access?.roles ?? []).map((r) => r.toUpperCase());
+    const clientRoles = Object.values(user?.resource_access ?? {})
+        .flatMap((r) => r.roles ?? [])
+        .map((r) => r.toUpperCase());
+    const allowedUpper = allowedRoles.map(r => r.toUpperCase());
+    const allRoles = [...realmRoles, ...clientRoles];
+    const hasAccess = allowedUpper.some((role) => allRoles.includes(role));
+    if (!hasAccess) {
+        return RestResponse.accessDenied(req, res);
+    }
+    next();
 };
 const success = (req, res, data, message = null) => {
     res.status(200).json({ data, message });

package/dist/types.d.ts

@@ -22,10 +22,6 @@ export type Middleware = (req: Request, res: Response, next: NextFunction) => vo
 export interface RestMiddlewareFunctions {
     responseHandlerMiddleware: <T>(req: Request, res: Response, next: NextFunction) => void;
 }
-export interface KeycloakFunctions {
-    protect: (req: Request, res: Response, next: any) => void;
-    role: (allowedRoles: string[]) => void;
-}
 export interface RestResponseFunctions {
     success: <T>(req: Request, res: Response, data: T, message?: string | null) => void;
     paginate: <T>(req: Request, res: Response, data: T, pagination: PaginationMeta, message?: string | null) => void;

package/package.json

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

package/src/index.ts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from "express";
-import { ErrorFields, PaginationMeta, StandardResponse, RestResponseFunctions, RestMiddlewareFunctions, KeycloakFunctions } from "./types.js";
+import { ErrorFields, PaginationMeta, StandardResponse, RestResponseFunctions, RestMiddlewareFunctions } from "./types.js";
 import { generateRequestId, getTimestamp } from "./utils.js";
 import axios from "axios";
 import jwt from "jsonwebtoken";
@@ -26,27 +26,32 @@ export const initKeycloak = async (config: { service?: string; realm?: string })
   KEYCLOAK_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----\n${key.match(/.{1,64}/g)?.join("\n")}\n-----END PUBLIC KEY-----`;
 };
 
-const protect = (req: Request, res: Response, 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 any).user = decoded;
-    next();
-  } catch (err) {
-    console.error(err)
-    return RestResponse.unauthorized(req, res, "Token is not valid")
-  }
+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 any).user = decoded;
+            if(allowedRoles)
+                return role(req, res, next, allowedRoles);
+            
+            next();
+        } catch (err) {
+            console.error(err)
+            return RestResponse.unauthorized(req, res, "Token is not valid")
+        }
+    }
+  
 }
-const role = (allowedRoles: string[]) => {
-  return (req: any, res: any, next: any) => {
-    const user = req.user;
+const role = (req: any, res: any, next: any, allowedRoles: string[]) => {
+  const user = req.user;
     if (!user) {
       return RestResponse.unauthorized(req, res);
     }
@@ -63,12 +68,6 @@ const role = (allowedRoles: string[]) => {
       return RestResponse.accessDenied(req, res)
     }
     next()
-  }
-  
-}
-export const Keycloak: KeycloakFunctions = {
-    protect,
-    role
 }
 const success = <T>(req: Request, res: Response, data: T, message: string | null = null) => {
     res.status(200).json({ data, message });

package/src/types.ts

@@ -27,10 +27,6 @@ export type Middleware = (req: Request, res: Response, next: NextFunction) => vo
 export interface RestMiddlewareFunctions {
     responseHandlerMiddleware: <T>(req: Request, res: Response, next: NextFunction) => void
 }
-export interface KeycloakFunctions {
-    protect:(req: Request, res: Response, next: any) => void;
-    role: (allowedRoles: string[]) => void;
-}
 export interface RestResponseFunctions {
     success: <T>(req: Request, res: Response, data: T, message?: string | null) => void;
     paginate: <T>(