response-standardizer 1.0.3 → 1.0.4

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 | ((req: any, res: any, next: any) => void);
 export declare const RestResponse: RestResponseFunctions;
 export declare const RestMiddleware: RestMiddlewareFunctions;

package/dist/index.js

@@ -11,22 +11,26 @@ 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");
-    }
+export const protect = (allowedRoles) => {
+    return (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;
+            if (allowedRoles)
+                return role(allowedRoles);
+            next();
+        }
+        catch (err) {
+            console.error(err);
+            return RestResponse.unauthorized(req, res, "Token is not valid");
+        }
+    };
 };
 const role = (allowedRoles) => {
     return (req, res, next) => {
@@ -47,10 +51,6 @@ const role = (allowedRoles) => {
         next();
     };
 };
-export const Keycloak = {
-    protect,
-    role
-};
 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.4",
   "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,23 +26,29 @@ 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(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) => {
@@ -66,10 +72,6 @@ const role = (allowedRoles: string[]) => {
   }
   
 }
-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>(