hi-secure 1.0.7 → 1.0.10

package/src/managers/SanitizerManager.ts

@@ -1,254 +1,3 @@
-// // // import { SanitizerError } from "../core/errors/SanitizerError";
-// // // import { logger } from "../logging";
-
-// // // interface SanitizerAdapter {
-// // //     sanitize: (value: string) => string;
-// // //     middleware?: () => any;
-// // // }
-
-// // // export class SanitizerManager {
-// // //     private primary: SanitizerAdapter;
-// // //     private fallback: SanitizerAdapter | null;
-
-// // //     constructor(primary: SanitizerAdapter, fallback: SanitizerAdapter | null = null) {
-// // //         this.primary = primary;
-// // //         this.fallback = fallback;
-// // //     }
-
-// // //     sanitize(value: string): string {
-// // //         try {
-// // //             return this.primary.sanitize(value);
-// // //         } catch (err: any) {
-// // //             logger.warn("⚠ Sanitizer primary adapter failed", { error: err?.message });
-
-// // //             if (!this.fallback) {
-// // //                 throw new SanitizerError("Primary sanitizer failed, no fallback available.");
-// // //             }
-
-// // //             try {
-// // //                 logger.info("📌 Using fallback sanitizer");
-// // //                 return this.fallback.sanitize(value);
-// // //             } catch (fallbackErr: any) {
-// // //                 logger.error("❌ Fallback sanitizer failed", {
-// // //                     error: fallbackErr?.message
-// // //                 });
-// // //                 throw new SanitizerError("Both primary and fallback sanitizers failed.");
-// // //             }
-// // //         }
-// // //     }
-
-// // //     middleware() {
-// // //         return (req: any, _res: any, next: any) => {
-// // //             try {
-// // //                 if (req.body && typeof req.body === "object") {
-// // //                     for (const key of Object.keys(req.body)) {
-// // //                         const value = req.body[key];
-
-// // //                         if (typeof value === "string") {
-// // //                             const clean = this.sanitize(value);
-
-// // //                             logger.debug("🧼 Sanitized field", {
-// // //                                 field: key,
-// // //                                 before: value.slice(0, 80),
-// // //                                 after: clean.slice(0, 80),
-// // //                             });
-
-// // //                             req.body[key] = clean;
-// // //                         }
-// // //                     }
-// // //                 }
-
-// // //                 next();
-// // //             } catch (err: any) {
-// // //                 logger.error("❌ Sanitizer middleware failed", { error: err?.message });
-// // //                 next(new SanitizerError("Sanitizer middleware failure"));
-// // //             }
-// // //         };
-// // //     }
-// // // }
-
-
-
-// // // src/managers/SanitizerManager.ts
-// // import { SanitizerError } from "../core/errors/SanitizerError.js";
-// // import { logger } from "../logging";
-
-// // interface SanitizerAdapter {
-// //     sanitize: (value: string, options?: any) => string;
-// // }
-
-// // export class SanitizerManager {
-// //     private primary: SanitizerAdapter;
-// //     private fallback: SanitizerAdapter | null;
-
-// //     constructor(primary: SanitizerAdapter, fallback: SanitizerAdapter | null = null) {
-// //         this.primary = primary;
-// //         this.fallback = fallback;
-// //     }
-
-// //     /**
-// //      * Sanitize a single value with optional dynamic options.
-// //      */
-// //     sanitize(value: string, options?: any): string {
-// //         try {
-// //             return this.primary.sanitize(value, options);
-
-// //         } catch (err: any) {
-// //             logger.warn("⚠ Primary sanitizer failed", { error: err?.message });
-
-// //             if (!this.fallback) {
-// //                 throw new SanitizerError("Primary sanitizer failed and no fallback available.");
-// //             }
-
-// //             try {
-// //                 logger.info("📌 Using fallback sanitizer");
-// //                 return this.fallback.sanitize(value, options);
-
-// //             } catch (fallbackErr: any) {
-// //                 logger.error("❌ Fallback sanitizer failed", {
-// //                     error: fallbackErr?.message
-// //                 });
-
-// //                 throw new SanitizerError("Both primary and fallback sanitizers failed.");
-// //             }
-// //         }
-// //     }
-
-// //     /**
-// //      * Dynamic express middleware for sanitizing body.
-// //      * Options can override global config on each route.
-// //      */
-// //     middleware(options?: any) {
-// //         return (req: any, _res: any, next: any) => {
-// //             try {
-// //                 if (req.body && typeof req.body === "object") {
-// //                     for (const key of Object.keys(req.body)) {
-// //                         const original = req.body[key];
-
-// //                         if (typeof original === "string") {
-// //                             const sanitized = this.sanitize(original, options);
-
-// //                             logger.debug("🧼 Sanitized field", {
-// //                                 field: key,
-// //                                 before: original.slice(0, 80),
-// //                                 after: sanitized.slice(0, 80)
-// //                             });
-
-// //                             req.body[key] = sanitized;
-// //                         }
-// //                     }
-// //                 }
-
-// //                 next();
-
-// //             } catch (err: any) {
-// //                 logger.error("❌ Sanitizer middleware failed", {
-// //                     error: err?.message
-// //                 });
-
-// //                 next(new SanitizerError("Sanitizer middleware failure"));
-// //             }
-// //         };
-// //     }
-// // }
-
-
-
-// // src/managers/SanitizerManager.ts - FIXED
-// import { SanitizerError } from "../core/errors/SanitizerError.js";
-// import { logger } from "../logging";
-
-// interface SanitizerAdapter {
-//     sanitize: (value: string, options?: any) => string;
-// }
-
-// export class SanitizerManager {
-//     private primary: SanitizerAdapter;
-//     private fallback: SanitizerAdapter | null;
-//     private useFallbackOnly: boolean = false;
-
-//     constructor(primary: SanitizerAdapter, fallback: SanitizerAdapter | null = null) {
-//         this.primary = primary;
-//         this.fallback = fallback;
-//     }
-
-//     /**
-//      * Sanitize a single value
-//      */
-//     sanitize(value: string, options?: any): string {
-//         // Don't process non-strings
-//         if (typeof value !== 'string') {
-//             return value;
-//         }
-
-//         // Use only one sanitizer, not both
-//         if (this.useFallbackOnly && this.fallback) {
-//             return this.fallback.sanitize(value, options);
-//         }
-
-//         try {
-//             return this.primary.sanitize(value, options);
-//         } catch (err: any) {
-//             logger.warn("⚠ Primary sanitizer failed", { error: err?.message });
-
-//             if (!this.fallback) {
-//                 throw new SanitizerError("Primary sanitizer failed and no fallback available.");
-//             }
-
-//             logger.info("📌 Using fallback sanitizer");
-//             this.useFallbackOnly = true; // Use fallback for subsequent calls
-            
-//             return this.fallback.sanitize(value, options);
-//         }
-//     }
-
-//     /**
-//      * Middleware that doesn't mutate original request
-//      */
-//     middleware(options?: any) {
-//         return (req: any, _res: any, next: any) => {
-//             try {
-//                 // Create a sanitized copy of body instead of mutating
-//                 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 value = originalBody[key];
-                        
-//                         if (typeof value === "string") {
-//                             sanitizedBody[key] = this.sanitize(value, options);
-//                         } else if (Array.isArray(value)) {
-//                             sanitizedBody[key] = value.map(item => 
-//                                 typeof item === "string" ? this.sanitize(item, options) : item
-//                             );
-//                         } else {
-//                             sanitizedBody[key] = value;
-//                         }
-//                     }
-                    
-//                     // Store sanitized version separately
-//                     req.sanitizedBody = sanitizedBody;
-//                     logger.debug("🧼 Request body sanitized", {
-//                         originalKeys: Object.keys(originalBody),
-//                         sanitizedKeys: Object.keys(sanitizedBody)
-//                     });
-//                 }
-
-//                 next();
-//             } catch (err: any) {
-//                 logger.error("❌ Sanitizer middleware failed", {
-//                     error: err?.message
-//                 });
-//                 next(new SanitizerError("Sanitizer middleware failure"));
-//             }
-//         };
-//     }
-// }
-
-
-
-// src/managers/SanitizerManager.ts - COMPLETE FIXED
 import { SanitizerError } from "../core/errors/SanitizerError.js";
 import { logger } from "../logging";
 
@@ -265,11 +14,8 @@ export class SanitizerManager {
         this.fallback = fallback;
     }
 
-    /**
-     * Sanitize a single value (public API)
-     */
     sanitize(value: string, options?: any): string {
-        // Don't process non-strings
+    
         if (typeof value !== 'string') {
             return value;
         }
@@ -288,14 +34,11 @@ export class SanitizerManager {
         }
     }
 
-    /**
-     * Middleware - Per-request fallback logic
-     */
+   
     middleware(options?: any) {
         return (req: any, _res: any, next: any) => {
             let fallbackTriggered = false;
             
-            // Helper function with per-request fallback logic
             const safeSanitize = (value: string): string => {
                 if (fallbackTriggered && this.fallback) {
                     return this.fallback.sanitize(value, options);
@@ -315,7 +58,7 @@ export class SanitizerManager {
             };
 
             try {
-                // Create a sanitized copy of body instead of mutating
+                
                 if (req.body && typeof req.body === "object") {
                     const originalBody = req.body;
                     const sanitizedBody: any = Array.isArray(originalBody) ? [] : {};
@@ -330,14 +73,12 @@ export class SanitizerManager {
                                 typeof item === "string" ? safeSanitize(item) : item
                             );
                         } else if (value && typeof value === "object") {
-                            // Recursive sanitization for nested objects (optional)
-                            sanitizedBody[key] = value; // Keep as-is for now
+                            sanitizedBody[key] = value; 
                         } else {
                             sanitizedBody[key] = value;
                         }
                     }
                     
-                    // Store sanitized version separately
                     req.sanitizedBody = sanitizedBody;
                     
                     logger.debug("🧼 Request body sanitized", {

package/src/managers/ValidatorManager.ts

@@ -1,136 +1,3 @@
-// // src/managers/ValidatorManager.ts - COMPLETE FIXED
-// import { logger } from "../logging";
-// import { ValidationError } from "../core/errors/ValidationError.js";
-// import { HiSecureConfig } from "../core/types/HiSecureConfig.js"; // ✅ FIXED IMPORT
-
-// interface ValidatorAdapter {
-//     validate: (schema?: any) => any;
-// }
-
-// export class ValidatorManager {
-//     private config: HiSecureConfig["validation"];
-//     private primaryAdapter: ValidatorAdapter;
-//     private fallbackAdapter: ValidatorAdapter | null;
-
-//     constructor(
-//         config: HiSecureConfig["validation"],
-//         primaryAdapter: ValidatorAdapter,
-//         fallbackAdapter: ValidatorAdapter | null
-//     ) {
-//         this.config = config;
-//         this.primaryAdapter = primaryAdapter;
-//         this.fallbackAdapter = fallbackAdapter;
-//     }
-
-//     validate(schema?: any) {
-//         return (req: any, res: any, next: any) => {
-//             // Execute primary adapter middleware
-//             const primaryMiddleware = this.primaryAdapter.validate(schema);
-            
-//             // Run middleware and handle errors properly
-//             primaryMiddleware(req, res, (err?: any) => {
-//                 if (!err) {
-//                     return next(); // Validation passed
-//                 }
-                
-//                 // If error is a ValidationError, pass it through (don't fallback!)
-//                 if (err instanceof ValidationError) {
-//                     logger.warn("⚠ Validation failed", {
-//                         path: req.path,
-//                         method: req.method,
-//                         error: err.message
-//                     });
-//                     return next(err);
-//                 }
-                
-//                 // Only use fallback for ADAPTER errors, not validation errors
-//                 logger.warn("⚠ Primary validator adapter failed", {
-//                     error: err?.message,
-//                     path: req.path,
-//                     method: req.method
-//                 });
-
-//                 if (!this.fallbackAdapter) {
-//                     return next(new ValidationError("Validation system error"));
-//                 }
-
-//                 // Try fallback adapter
-//                 const fallbackMiddleware = this.fallbackAdapter.validate(schema);
-//                 fallbackMiddleware(req, res, (fallbackErr?: any) => {
-//                     if (fallbackErr) {
-//                         logger.error("❌ Fallback validator also failed", {
-//                             error: fallbackErr?.message
-//                         });
-//                         return next(new ValidationError("Validation system unavailable"));
-//                     }
-//                     next(); // Fallback validation passed
-//                 });
-//             });
-//         };
-//     }
-// }
-
-
-
-
-// // src/managers/ValidatorManager.ts
-// import { logger } from "../logging";
-// import { ValidationError } from "../core/errors/ValidationError.js";
-
-// interface ValidatorAdapter {
-//     validate: (schema?: any) => any;
-// }
-
-// export class ValidatorManager {
-//     private primaryAdapter: ValidatorAdapter;
-//     private fallbackAdapter: ValidatorAdapter | null;
-
-//     constructor(primaryAdapter: ValidatorAdapter, fallbackAdapter: ValidatorAdapter | null) {
-//         this.primaryAdapter = primaryAdapter;
-//         this.fallbackAdapter = fallbackAdapter;
-//     }
-
-//     validate(schema?: any) {
-//         return (req: any, res: any, next: any) => {
-//             const isZod = schema && typeof schema === "object" && typeof schema.safeParse === "function";
-//             const isExpressValidator = Array.isArray(schema);
-
-//             let adapter: ValidatorAdapter;
-
-//             if (isZod) {
-//                 adapter = this.primaryAdapter; // ZodAdapter
-//                 logger.debug("📌 Using Zod adapter for validation");
-//             } 
-//             else if (isExpressValidator) {
-//                 adapter = this.fallbackAdapter!; // ExpressValidatorAdapter
-//                 logger.debug("📌 Using express-validator adapter for validation");
-//             } 
-//             else {
-//                 return next(); // nothing to validate
-//             }
-
-//             const middleware = adapter.validate(schema);
-
-//             // Execute validation chain
-//             middleware(req, res, (err?: any) => {
-//                 if (err instanceof ValidationError) {
-//                     return next(err);
-//                 }
-//                 if (err) {
-//                     logger.error("❌ Validator internal error", { error: err.message });
-//                     return next(new ValidationError("Validation failed internally."));
-//                 }
-//                 next();
-//             });
-//         };
-//     }
-// }
-
-
-
-
-
-// src/managers/ValidatorManager.ts
 import { logger } from "../logging";
 import { ValidationError } from "../core/errors/ValidationError.js";
 
@@ -148,7 +15,6 @@ export class ValidatorManager {
     }
 
     validate(schema?: any) {
-        // const isZod = schema && typeof schema.safeParse === "function";
         const isZod =
     schema &&
     typeof schema === "object" &&
@@ -169,7 +35,7 @@ export class ValidatorManager {
                 middleware = this.expressAdapter.validate(schema);
             } 
             else {
-                return next(); // no schema found
+                return next(); 
             }
 
             // CASE 1 — express-validator returns ARRAY