hi-secure 1.0.15 → 1.0.16

package/src/adapters/RLFlexibleAdapter.ts

@@ -1,10 +1,92 @@
+// import { RateLimiterMemory, RateLimiterRes } from "rate-limiter-flexible";
+// import { logger } from "../logging/index.js";
+// import { AdapterError } from "../core/errors/AdapterError.js";
+
+// export interface RLOptions {
+//     points?: number;
+//     duration?: number; 
+//     message?: any;
+//     blockDuration?: number;
+// }
+
+// export class RLFlexibleAdapter {
+//     getMiddleware(options: RLOptions = {}) {
+//         try {
+//             const defaultOptions = {
+//                 points: 100,
+//                 duration: 60,
+//                 message: "Too many requests, slow down.",
+//                 blockDuration: 0
+//             };
+
+//             const finalOptions = { ...defaultOptions, ...options };
+
+//             const limiter = new RateLimiterMemory({
+//                 points: finalOptions.points,
+//                 duration: finalOptions.duration,
+//                 blockDuration: finalOptions.blockDuration
+//             });
+
+//             return async (req: any, res: any, next: any) => {
+               
+//                 const ip = this.extractIP(req);
+
+//                 try {
+//                     await limiter.consume(ip);
+//                     next();
+//                 } catch (err: any) {
+//                     const rlErr = err as RateLimiterRes;
+
+//                     logger.warn("RLFlexibleAdapter: rate limit exceeded", {
+//                         ip,
+//                         path: req.path,
+//                         method: req.method,
+//                         retryAfter: rlErr.msBeforeNext
+//                     });
+
+//                     res.setHeader('Retry-After', Math.ceil(rlErr.msBeforeNext / 1000));
+                    
+//                     return res.status(429).json({
+//                         success: false,
+//                         error: "RATE_LIMIT_EXCEEDED",
+//                         retryAfter: Math.ceil(rlErr.msBeforeNext / 1000),
+//                         message: finalOptions.message
+//                     });
+//                 }
+//             };
+
+//         } catch (err: any) {
+//             logger.error("RLFlexibleAdapter: failed to initialize limiter", {
+//                 error: err?.message || err
+//             });
+//             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.ip ||
+//             req.connection?.remoteAddress ||
+//             req.socket?.remoteAddress ||
+//             'unknown'
+//         );
+//     }
+// }
+
+
+
+
+
+
 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 +109,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 +127,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 +149,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,89 @@
+// import sanitizeHtml from "sanitize-html";
+// import { AdapterError } from "../core/errors/AdapterError.js";
+// import { logger } from "../logging/index.js";
+
+// export class SanitizeHtmlAdapter {
+//     private globalOptions: sanitizeHtml.IOptions;
+
+//     constructor(options: sanitizeHtml.IOptions = {}) {
+//         this.globalOptions = options;
+//     }
+
+//     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
+//             });
+
+//             throw new AdapterError("sanitize-html adapter failed.");
+//         }
+//     }
+
+//     // Deep Sanitization - Recursively 
+//     private deepSanitize(obj: any, dynamicOptions?: any, visited = new WeakSet()): any {
+        
+//         if (obj && typeof obj === "object") {
+//             if (visited.has(obj)) {
+//                 return obj; 
+//             }
+//             visited.add(obj);
+//         }
+
+//         if (typeof obj === "string") {
+//             return this.sanitize(obj, dynamicOptions);
+//         }
+
+//         if (Array.isArray(obj)) {
+//             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);
+//             }
+//             return result;
+//         }
+
+//         return obj;
+//     }
+
+//     middleware(dynamicOptions?: any) {
+//         return (req: any, _res: any, next: any) => {
+//             try {
+//                 if (req.body) {
+//                     req.body = this.deepSanitize(req.body, dynamicOptions);
+
+//                     logger.debug("sanitize-html applied", {
+//                         keys: Object.keys(req.body)
+//                     });
+//                 }
+//                 next();
+
+//             } catch (err: any) {
+//                 logger.error("sanitize-html middleware failed", {
+//                     error: err?.message || err
+//                 });
+//                 next(err);
+//             }
+//         };
+//     }
+// }
+
+
+
+
+
 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 +95,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 +122,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 +148,24 @@ export class SanitizeHtmlAdapter {
                 if (req.body) {
                     req.body = this.deepSanitize(req.body, dynamicOptions);
 
-                    logger.debug("sanitize-html applied", {
+                    // ✅ visible + safe info log
+                    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,155 @@
-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.js";
+// import { logger } from "../logging/index.js";
+
+// export interface XSSOptions {
+//     whiteList?: typeof whiteList;
+//     stripIgnoreTag?: boolean;
+//     stripIgnoreTagBody?: string[];
+//     allowCommentTag?: boolean;
+//     css?: boolean | { [key: string]: boolean };
+//     onTag?: (tag: string, html: string, options: any) => string;
+//     onTagAttr?: (tag: string, name: string, value: string, isWhiteAttr: boolean) => string;
+//     onIgnoreTag?: (tag: string, html: string, options: any) => string;
+//     [key: string]: any;
+// }
+
+// export class XSSAdapter {
+//     private globalOptions: XSSOptions;
+//     private defaultFilter: FilterXSS;
+
+//     constructor(options: XSSOptions = {}) {
+//         this.globalOptions = options;
+        
+//         // Default safe configuration
+//         const defaultOptions: XSSOptions = {
+//             whiteList: getDefaultWhiteList(),
+//             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" ');
+//                 }
+//                 return html;
+//             }
+//         };
+
+//         const finalOptions = { ...defaultOptions, ...options };
+//         this.defaultFilter = new FilterXSS(finalOptions);
+//     }
+
+   
+//     sanitize(input: string, dynamicOptions?: XSSOptions): string {
+//         try {
+//             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)
+//             });
+//             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) =>
+//                                 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)
+//                     });
+//                 }
+
+//                 next();
+//             } catch (err: any) {
+//                 logger.error("XSS middleware failed", {
+//                     error: err?.message || err
+//                 });
+//                 next(err);
+//             }
+//         };
+//     }
+
+   
+//     private deepSanitize(obj: any, options?: XSSOptions, visited = new WeakSet()): any {
+       
+//         if (obj && typeof obj === "object") {
+//             if (visited.has(obj)) {
+//                 return obj;
+//             }
+//             visited.add(obj);
+//         }
+
+//         if (typeof obj === "string") {
+//             return this.sanitize(obj, options);
+//         }
+
+//         if (Array.isArray(obj)) {
+//             return obj.map(item => this.deepSanitize(item, options, visited));
+//         }
+
+//         if (obj && typeof obj === "object") {
+//             const result: any = {};
+//             for (const key of Object.keys(obj)) {
+//                 result[key] = this.deepSanitize(obj[key], options, visited);
+//             }
+//             return result;
+//         }
+
+//         return obj;
+//     }
+// }
+
+
+
+
+import { FilterXSS, getDefaultWhiteList, whiteList } from "xss";
+import { AdapterError } from "../core/errors/AdapterError";
+import { logger } from "../logging";
 
 export interface XSSOptions {
     whiteList?: typeof whiteList;
@@ -20,18 +169,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 +191,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)
+
+                    // ✅ visible + safe info log
+                    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 +286,4 @@ export class XSSAdapter {
 
         return obj;
     }
-}
+}