hi-secure 1.0.6 → 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,207 +1,73 @@
-// 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;
+    private zodAdapter: ValidatorAdapter;
+    private expressAdapter: ValidatorAdapter;
 
-    constructor(
-        config: HiSecureConfig["validation"],
-        primaryAdapter: ValidatorAdapter,
-        fallbackAdapter: ValidatorAdapter | null
-    ) {
-        this.config = config;
-        this.primaryAdapter = primaryAdapter;
-        this.fallbackAdapter = fallbackAdapter;
+    constructor(zodAdapter: ValidatorAdapter, expressAdapter: ValidatorAdapter) {
+        this.zodAdapter = zodAdapter;
+        this.expressAdapter = expressAdapter;
     }
 
     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
-                });
+        const isZod =
+    schema &&
+    typeof schema === "object" &&
+    typeof schema._def === "object" && 
+    typeof schema.safeParse === "function";
 
-                if (!this.fallbackAdapter) {
-                    return next(new ValidationError("Validation system error"));
-                }
+        const isExpressValidator = Array.isArray(schema);
 
-                // 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"));
+        return (req: any, res: any, next: any) => {
+            let middleware;
+
+            if (isZod) {
+                logger.debug("📌 Using Zod adapter");
+                middleware = this.zodAdapter.validate(schema);
+            } 
+            else if (isExpressValidator) {
+                logger.debug("📌 Using express-validator adapter");
+                middleware = this.expressAdapter.validate(schema);
+            } 
+            else {
+                return next(); 
+            }
+
+            // CASE 1 — express-validator returns ARRAY
+            if (Array.isArray(middleware)) {
+                let idx = 0;
+
+                const run = (err?: any) => {
+                    if (err) return next(err);
+
+                    const fn = middleware[idx++];
+                    if (!fn) return next(); // done
+
+                    try {
+                        fn(req, res, run);
+                    } catch (error: any) {
+                        next(new ValidationError(error.message));
                     }
-                    next(); // Fallback validation passed
+                };
+
+                return run();
+            }
+
+            // CASE 2 — Zod returns SINGLE MIDDLEWARE
+            try {
+                middleware(req, res, (err?: any) => {
+                    if (err) return next(err);
+                    next();
                 });
-            });
+            } catch (err: any) {
+                next(new ValidationError(err.message));
+            }
         };
     }
 }
 
-
-
-
-// // 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";
-
-// // interface ValidatorAdapter {
-// //     validate: (schema?: any) => any;
-// // }
-
-// // export class ValidatorManager {
-// //     private zodAdapter: ValidatorAdapter;
-// //     private expressAdapter: ValidatorAdapter;
-
-// //     constructor(zodAdapter: ValidatorAdapter, expressAdapter: ValidatorAdapter) {
-// //         this.zodAdapter = zodAdapter;
-// //         this.expressAdapter = expressAdapter;
-// //     }
-
-// //     validate(schema?: any) {
-// //         // const isZod = schema && typeof schema.safeParse === "function";
-// //         const isZod =
-// //     schema &&
-// //     typeof schema === "object" &&
-// //     typeof schema._def === "object" && 
-// //     typeof schema.safeParse === "function";
-
-// //         const isExpressValidator = Array.isArray(schema);
-
-// //         return (req: any, res: any, next: any) => {
-// //             let middleware;
-
-// //             if (isZod) {
-// //                 logger.debug("📌 Using Zod adapter");
-// //                 middleware = this.zodAdapter.validate(schema);
-// //             } 
-// //             else if (isExpressValidator) {
-// //                 logger.debug("📌 Using express-validator adapter");
-// //                 middleware = this.expressAdapter.validate(schema);
-// //             } 
-// //             else {
-// //                 return next(); // no schema found
-// //             }
-
-// //             // CASE 1 — express-validator returns ARRAY
-// //             if (Array.isArray(middleware)) {
-// //                 let idx = 0;
-
-// //                 const run = (err?: any) => {
-// //                     if (err) return next(err);
-
-// //                     const fn = middleware[idx++];
-// //                     if (!fn) return next(); // done
-
-// //                     try {
-// //                         fn(req, res, run);
-// //                     } catch (error: any) {
-// //                         next(new ValidationError(error.message));
-// //                     }
-// //                 };
-
-// //                 return run();
-// //             }
-
-// //             // CASE 2 — Zod returns SINGLE MIDDLEWARE
-// //             try {
-// //                 middleware(req, res, (err?: any) => {
-// //                     if (err) return next(err);
-// //                     next();
-// //                 });
-// //             } catch (err: any) {
-// //                 next(new ValidationError(err.message));
-// //             }
-// //         };
-// //     }
-// // }
-