hi-secure 1.0.15 → 1.0.17

package/src/adapters/ExpressValidatorAdapter.ts

@@ -1,6 +1,6 @@
 import { validationResult } from "express-validator";
-import { ValidationError } from "../core/errors/ValidationError.js"; 
-import { logger } from "../logging/index.js";
+import { ValidationError } from "../core/errors/ValidationError";
+import { logger } from "../logging";
 
 export class ExpressValidatorAdapter {
     private globalSchema?: any[];
@@ -23,24 +23,30 @@ export class ExpressValidatorAdapter {
                 const errors = validationResult(req);
 
                 if (!errors.isEmpty()) {
-                    const formatted = errors.array().map(err => ({
+                    const formattedErrors = errors.array().map(err => ({
                         message: err.msg,
-                        // param: err.param ,
-                        // location: err.location
+                        field: err.type
                     }));
 
-                    logger.warn("express-validator failed", {
-                        path: req.path,
+                    logger.warn("Request validation failed", {
+                        adapter: "express-validator",
+                        operation: "validate",
                         method: req.method,
-                        errors: formatted,
-                        preview: JSON.stringify(req.body).slice(0, 200)
+                        path: req.path,
+                        errorCount: formattedErrors.length,
+                        errors: formattedErrors,
+                        bodyPreview: req.body
+                            ? JSON.stringify(req.body).slice(0, 150)
+                            : undefined
                     });
 
-                    return next(new ValidationError("Validation failed.", formatted as any));
+                    return next(
+                        new ValidationError("Validation failed.", formattedErrors as any)
+                    );
                 }
 
                 next();
             }
         ];
     }
-}
+}

package/src/adapters/GoogleAdapter.ts

@@ -1,7 +1,6 @@
 import { OAuth2Client, LoginTicket } from "google-auth-library";
-import { AdapterError } from "../core/errors/AdapterError.js";
-
-import {logger} from '../logging';
+import { AdapterError } from "../core/errors/AdapterError";
+import { logger } from "../logging";
 
 export interface GoogleTokenPayload {
     sub: string;
@@ -20,60 +19,64 @@ export class GoogleAdapter {
         if (clientId && clientId.trim().length === 0) {
             throw new AdapterError("Google clientId cannot be empty string");
         }
-        
+
         this.client = new OAuth2Client(clientId);
         this.clientId = clientId;
     }
 
     async verifyIdToken(idToken: string): Promise<GoogleTokenPayload> {
         try {
-            if (!idToken || typeof idToken !== 'string') {
+            if (!idToken || typeof idToken !== "string") {
                 throw new AdapterError("Invalid ID token provided");
             }
 
-            const options: { idToken: string; audience?: string | string[] } = { 
-                idToken 
+            const options: { idToken: string; audience?: string | string[] } = {
+                idToken
             };
 
-            // audience only if clientId is provided and not empty
             if (this.clientId && this.clientId.trim().length > 0) {
                 options.audience = this.clientId;
             }
 
             const ticket: LoginTicket = await this.client.verifyIdToken(options);
             const payload = ticket.getPayload();
-            
+
             if (!payload) {
-                logger.warn("GoogleAdapter: Empty payload");
+                logger.warn("Google ID token payload empty", {
+                    adapter: "google-auth",
+                    operation: "verifyIdToken",
+                    hasClientId: !!this.clientId
+                });
+
                 throw new AdapterError("Invalid Google ID token payload.");
             }
 
-            // result object
             const result: GoogleTokenPayload = {
                 sub: payload.sub,
-                email: payload.email || '',
+                email: payload.email || "",
                 email_verified: payload.email_verified || false,
                 name: payload.name,
                 picture: payload.picture
             };
 
-            // remaining properties from payload 
             const { sub, email, email_verified, name, picture, ...rest } = payload;
             Object.assign(result, rest);
 
             return result;
 
         } catch (err: any) {
-            logger.error("GoogleAdapter.verifyIdToken failed", { 
-                error: err?.message,
-                hasClientId: !!this.clientId 
+            logger.error("Google ID token verification failed", {
+                adapter: "google-auth",
+                operation: "verifyIdToken",
+                hasClientId: !!this.clientId,
+                reason: err?.message
             });
-            
-            if (err.message?.includes('audience')) {
+
+            if (err?.message?.includes("audience")) {
                 throw new AdapterError("Invalid Google client ID configured.");
             }
-            
-            throw new AdapterError(err?.message || "Google token verification failed");
+
+            throw new AdapterError("Google token verification failed.");
         }
     }
-}
+}

package/src/adapters/JWTAdapter.ts

@@ -1,7 +1,6 @@
 import jwt from "jsonwebtoken";
-import { randomUUID } from "crypto"; 
-import { AdapterError } from "../core/errors/AdapterError.js";
-import { logError } from "../logging/index.js";
+import { randomUUID } from "crypto";
+import { AdapterError } from "../core/errors/AdapterError";
 import { logger } from "../logging";
 
 export interface JWTAdapterOptions {
@@ -14,7 +13,7 @@ export interface JWTAdapterOptions {
 
 export interface SignOptions {
     expiresIn?: string | number;
-    jti?: string; 
+    jti?: string;
     subject?: string;
     issuer?: string;
     audience?: string | string[];
@@ -33,13 +32,16 @@ export class JWTAdapter {
         }
 
         if (options.secret.length < 32) {
-            logger.warn("JWT secret shorter than 32 chars. Consider using stronger secret.");
-            // logError("JWT secret is too short (minimum 32 characters recommended)");
+            logger.warn("Weak JWT secret detected", {
+                adapter: "jwt",
+                operation: "init",
+                secretLength: options.secret.length
+            });
         }
 
         this.secret = options.secret;
         this.expiresIn = options.expiresIn;
-        this.algorithm = options.algorithm || 'HS256'; // Default algorithm 
+        this.algorithm = options.algorithm || "HS256";
         this.issuer = options.issuer;
         this.audience = options.audience;
     }
@@ -50,21 +52,26 @@ export class JWTAdapter {
                 algorithm: this.algorithm,
                 issuer: options?.issuer || this.issuer,
                 audience: options?.audience || this.audience,
-                jwtid: options?.jti || randomUUID(), 
+                jwtid: options?.jti || randomUUID(),
                 subject: options?.subject
             };
 
             if (options?.expiresIn !== undefined) {
-                jwtOptions.expiresIn = options.expiresIn as number;
+                jwtOptions.expiresIn = options.expiresIn as any;
             } else if (this.expiresIn !== undefined) {
-                jwtOptions.expiresIn = this.expiresIn as number;
+                jwtOptions.expiresIn = this.expiresIn as any;
             }
 
             return jwt.sign(payload, this.secret, jwtOptions);
 
         } catch (err: any) {
-            logError("JWTAdapter.sign failed", { error: err?.message });
-            throw new AdapterError(err?.message || "JWT sign failed");
+            logger.error("JWT signing failed", {
+                adapter: "jwt",
+                operation: "sign",
+                reason: err?.message
+            });
+
+            throw new AdapterError("JWT sign failed");
         }
     }
 
@@ -73,22 +80,27 @@ export class JWTAdapter {
             const verifyOptions: jwt.VerifyOptions = {
                 algorithms: [this.algorithm],
                 issuer: this.issuer,
-                audience: options?.audience as string || this.audience as string
+                audience: (options?.audience || this.audience) as string
             };
 
             return jwt.verify(token, this.secret, verifyOptions);
+
         } catch (err: any) {
-            logError("JWTAdapter.verify failed", { error: err?.message });
-            
-           
-            if (err.name === 'TokenExpiredError') {
+            logger.error("JWT verification failed", {
+                adapter: "jwt",
+                operation: "verify",
+                reason: err?.message
+            });
+
+            if (err?.name === "TokenExpiredError") {
                 throw new AdapterError("JWT token has expired");
             }
-            if (err.name === 'JsonWebTokenError') {
+
+            if (err?.name === "JsonWebTokenError") {
                 throw new AdapterError("Invalid JWT token");
             }
-            
-            throw new AdapterError(err?.message || "JWT verification failed");
+
+            throw new AdapterError("JWT verification failed");
         }
     }
-}
+}

package/src/adapters/RLFlexibleAdapter.ts

@@ -1,10 +1,10 @@
 import { RateLimiterMemory, RateLimiterRes } from "rate-limiter-flexible";
-import { logger } from "../logging/index.js";
-import { AdapterError } from "../core/errors/AdapterError.js";
+import { logger } from "../logging";
+import { AdapterError } from "../core/errors/AdapterError";
 
 export interface RLOptions {
     points?: number;
-    duration?: number; 
+    duration?: number;
     message?: any;
     blockDuration?: number;
 }
@@ -27,8 +27,16 @@ export class RLFlexibleAdapter {
                 blockDuration: finalOptions.blockDuration
             });
 
+            
+            logger.info("Rate limiter initialized", {
+                adapter: "rate-limiter-flexible",
+                operation: "init",
+                points: finalOptions.points,
+                duration: finalOptions.duration,
+                blockDuration: finalOptions.blockDuration
+            });
+
             return async (req: any, res: any, next: any) => {
-               
                 const ip = this.extractIP(req);
 
                 try {
@@ -37,15 +45,20 @@ export class RLFlexibleAdapter {
                 } catch (err: any) {
                     const rlErr = err as RateLimiterRes;
 
-                    logger.warn("RLFlexibleAdapter: rate limit exceeded", {
+                    logger.warn("Rate limit exceeded", {
+                        adapter: "rate-limiter-flexible",
+                        operation: "consume",
                         ip,
-                        path: req.path,
                         method: req.method,
-                        retryAfter: rlErr.msBeforeNext
+                        path: req.path,
+                        retryAfterMs: rlErr.msBeforeNext
                     });
 
-                    res.setHeader('Retry-After', Math.ceil(rlErr.msBeforeNext / 1000));
-                    
+                    res.setHeader(
+                        "Retry-After",
+                        Math.ceil(rlErr.msBeforeNext / 1000)
+                    );
+
                     return res.status(429).json({
                         success: false,
                         error: "RATE_LIMIT_EXCEEDED",
@@ -54,23 +67,25 @@ export class RLFlexibleAdapter {
                     });
                 }
             };
-
         } catch (err: any) {
-            logger.error("RLFlexibleAdapter: failed to initialize limiter", {
-                error: err?.message || err
+            logger.error("Rate limiter initialization failed", {
+                adapter: "rate-limiter-flexible",
+                operation: "init",
+                reason: err?.message
             });
+
             throw new AdapterError("RateLimiterFlexible creation failed.");
         }
     }
 
     private extractIP(req: any): string {
         return (
-            req.headers['x-real-ip'] ||
-            req.headers['x-forwarded-for']?.split(',')[0]?.trim() ||
+            req.headers["x-real-ip"] ||
+            req.headers["x-forwarded-for"]?.split(",")[0]?.trim() ||
             req.ip ||
             req.connection?.remoteAddress ||
             req.socket?.remoteAddress ||
-            'unknown'
+            "unknown"
         );
     }
-}
+}

package/src/adapters/SanitizeHtmlAdapter.ts

@@ -1,6 +1,6 @@
 import sanitizeHtml from "sanitize-html";
-import { AdapterError } from "../core/errors/AdapterError.js";
-import { logger } from "../logging/index.js";
+import { AdapterError } from "../core/errors/AdapterError";
+import { logger } from "../logging";
 
 export class SanitizeHtmlAdapter {
     private globalOptions: sanitizeHtml.IOptions;
@@ -12,27 +12,25 @@ export class SanitizeHtmlAdapter {
     sanitize(input: string, dynamicOptions?: any): string {
         try {
             const opts = { ...this.globalOptions, ...(dynamicOptions || {}) };
-
             const clean = sanitizeHtml(input, opts);
+
             return typeof clean === "string" ? clean : String(clean);
 
         } catch (err: any) {
-            logger.error("sanitize-html failed", {
-                error: err?.message || err,
-                preview: typeof input === "string" ? input.slice(0, 100) : undefined
+            logger.error("HTML sanitization failed", {
+                adapter: "sanitize-html",
+                operation: "sanitize",
+                reason: err?.message
             });
 
             throw new AdapterError("sanitize-html adapter failed.");
         }
     }
 
-    // Deep Sanitization - Recursively 
+    // Deep Sanitization - recursively
     private deepSanitize(obj: any, dynamicOptions?: any, visited = new WeakSet()): any {
-        
         if (obj && typeof obj === "object") {
-            if (visited.has(obj)) {
-                return obj; 
-            }
+            if (visited.has(obj)) return obj;
             visited.add(obj);
         }
 
@@ -41,13 +39,19 @@ export class SanitizeHtmlAdapter {
         }
 
         if (Array.isArray(obj)) {
-            return obj.map((item) => this.deepSanitize(item, dynamicOptions, visited));
+            return obj.map(item =>
+                this.deepSanitize(item, dynamicOptions, visited)
+            );
         }
 
         if (obj && typeof obj === "object") {
             const result: any = {};
             for (const key of Object.keys(obj)) {
-                result[key] = this.deepSanitize(obj[key], dynamicOptions, visited);
+                result[key] = this.deepSanitize(
+                    obj[key],
+                    dynamicOptions,
+                    visited
+                );
             }
             return result;
         }
@@ -61,18 +65,24 @@ export class SanitizeHtmlAdapter {
                 if (req.body) {
                     req.body = this.deepSanitize(req.body, dynamicOptions);
 
-                    logger.debug("sanitize-html applied", {
+                    
+                    logger.info("HTML sanitization applied", {
+                        adapter: "sanitize-html",
+                        operation: "middleware",
                         keys: Object.keys(req.body)
                     });
                 }
-                next();
 
+                next();
             } catch (err: any) {
-                logger.error("sanitize-html middleware failed", {
-                    error: err?.message || err
+                logger.error("HTML sanitization middleware failed", {
+                    adapter: "sanitize-html",
+                    operation: "middleware",
+                    reason: err?.message
                 });
+
                 next(err);
             }
         };
     }
-}
+}

package/src/adapters/XSSAdapter.ts

@@ -1,6 +1,6 @@
-import { FilterXSS, getDefaultWhiteList, whiteList } from 'xss';
-import { AdapterError } from "../core/errors/AdapterError.js";
-import { logger } from "../logging/index.js";
+import { FilterXSS, getDefaultWhiteList, whiteList } from "xss";
+import { AdapterError } from "../core/errors/AdapterError";
+import { logger } from "../logging";
 
 export interface XSSOptions {
     whiteList?: typeof whiteList;
@@ -20,18 +20,19 @@ export class XSSAdapter {
 
     constructor(options: XSSOptions = {}) {
         this.globalOptions = options;
-        
-        // Default safe configuration
+
         const defaultOptions: XSSOptions = {
             whiteList: getDefaultWhiteList(),
-            stripIgnoreTag: true, 
-            stripIgnoreTagBody: ['script', 'style', 'iframe', 'object', 'embed'],
+            stripIgnoreTag: true,
+            stripIgnoreTagBody: ["script", "style", "iframe", "object", "embed"],
             allowCommentTag: false,
-            css: false, 
-            onTag: (tag, html, options) => {
-               
-                if (tag === 'a') {
-                    return html.replace(/<a /i, '<a target="_blank" rel="noopener noreferrer" ');
+            css: false,
+            onTag: (tag, html) => {
+                if (tag === "a") {
+                    return html.replace(
+                        /<a /i,
+                        '<a target="_blank" rel="noopener noreferrer" '
+                    );
                 }
                 return html;
             }
@@ -41,86 +42,80 @@ export class XSSAdapter {
         this.defaultFilter = new FilterXSS(finalOptions);
     }
 
-   
     sanitize(input: string, dynamicOptions?: XSSOptions): string {
         try {
-            if (typeof input !== "string") {
-                return input as any;
-            }
+            if (typeof input !== "string") return input as any;
 
-           
             if (!dynamicOptions || Object.keys(dynamicOptions).length === 0) {
                 return this.defaultFilter.process(input);
             }
 
-            
             const mergedOptions = { ...this.globalOptions, ...dynamicOptions };
             const customFilter = new FilterXSS(mergedOptions);
-            
+
             return customFilter.process(input);
 
         } catch (err: any) {
-            logger.error("XSS sanitizer failed", {
-                error: err?.message,
-                preview: input?.slice?.(0, 80)
+            logger.error("XSS sanitization failed", {
+                adapter: "xss",
+                operation: "sanitize",
+                reason: err?.message
             });
+
             throw new AdapterError("XSS sanitizer failed.");
         }
     }
 
-   
     middleware(dynamicOptions?: XSSOptions) {
         return (req: any, _res: any, next: any) => {
             try {
                 if (req.body && typeof req.body === "object") {
                     const originalBody = req.body;
                     const sanitizedBody: any = Array.isArray(originalBody) ? [] : {};
-                    
+
                     for (const key of Object.keys(originalBody)) {
                         const val = originalBody[key];
 
                         if (typeof val === "string") {
                             sanitizedBody[key] = this.sanitize(val, dynamicOptions);
                         } else if (Array.isArray(val)) {
-                            sanitizedBody[key] = val.map((v) =>
+                            sanitizedBody[key] = val.map(v =>
                                 typeof v === "string"
                                     ? this.sanitize(v, dynamicOptions)
                                     : v
                             );
                         } else if (val && typeof val === "object") {
-                            
                             sanitizedBody[key] = this.deepSanitize(val, dynamicOptions);
                         } else {
                             sanitizedBody[key] = val;
                         }
                     }
-                    
-                   
+
                     req.sanitizedBody = sanitizedBody;
+
                     
-                    logger.debug("XSS sanitizer applied", {
-                        originalKeys: Object.keys(originalBody),
-                        sanitizedKeys: Object.keys(sanitizedBody)
+                    logger.info("XSS sanitization applied", {
+                        adapter: "xss",
+                        operation: "middleware",
+                        keys: Object.keys(sanitizedBody)
                     });
                 }
 
                 next();
             } catch (err: any) {
                 logger.error("XSS middleware failed", {
-                    error: err?.message || err
+                    adapter: "xss",
+                    operation: "middleware",
+                    reason: err?.message
                 });
                 next(err);
             }
         };
     }
 
-   
     private deepSanitize(obj: any, options?: XSSOptions, visited = new WeakSet()): any {
-       
         if (obj && typeof obj === "object") {
-            if (visited.has(obj)) {
-                return obj;
-            }
+            if (visited.has(obj)) return obj;
             visited.add(obj);
         }
 
@@ -142,4 +137,4 @@ export class XSSAdapter {
 
         return obj;
     }
-}
+}

package/src/adapters/ZodAdapter.ts

@@ -1,6 +1,6 @@
 import { ZodSchema, ZodError } from "zod";
-import { ValidationError } from "../core/errors/ValidationError.js"; 
-import { logger } from "../logging/index.js";
+import { ValidationError } from "../core/errors/ValidationError";
+import { logger } from "../logging";
 
 export class ZodAdapter {
     private globalSchema?: ZodSchema;
@@ -10,13 +10,11 @@ export class ZodAdapter {
     }
 
     validate(dynamicSchema?: ZodSchema) {
-        return (req: any, res: any, next: any) => {
+        return (req: any, _res: any, next: any) => {
             const schema = dynamicSchema || this.globalSchema;
-
             if (!schema) return next();
 
             const result = schema.safeParse(req.body);
-
             if (result.success) return next();
 
             const zodErr: ZodError = result.error;
@@ -28,15 +26,17 @@ export class ZodAdapter {
             }));
 
             logger.warn("Zod validation failed", {
-                path: req.path,
+                adapter: "zod",
+                operation: "validate",
                 method: req.method,
-                issues,
-                preview: JSON.stringify(req.body).slice(0, 200)
+                path: req.path,
+                issueCount: issues.length,
+                issues
             });
 
             return next(
-                new ValidationError("Validation failed.", issues as any) 
+                new ValidationError("Validation failed.", issues as any)
             );
         };
     }
-}
+}