hi-secure 1.0.15 → 1.0.17

package/src/managers/SanitizerManager.ts

@@ -1,4 +1,4 @@
-import { SanitizerError } from "../core/errors/SanitizerError.js";
+import { SanitizerError } from "../core/errors/SanitizerError";
 import { logger } from "../logging";
 
 interface SanitizerAdapter {
@@ -12,78 +12,97 @@ export class SanitizerManager {
     constructor(primary: SanitizerAdapter, fallback: SanitizerAdapter | null = null) {
         this.primary = primary;
         this.fallback = fallback;
+
+        logger.info("SanitizerManager initialized", {
+            layer: "sanitizer-manager",
+            fallbackEnabled: !!fallback
+        });
     }
 
     sanitize(value: string, options?: any): string {
-    
-        if (typeof value !== 'string') {
+        if (typeof value !== "string") {
             return value;
         }
 
         try {
             return this.primary.sanitize(value, options);
         } catch (err: any) {
-            logger.warn("Primary sanitizer failed", { error: err?.message });
+            logger.warn("Primary sanitizer failed", {
+                layer: "sanitizer-manager",
+                operation: "sanitize",
+                reason: err?.message
+            });
 
             if (!this.fallback) {
-                throw new SanitizerError("Primary sanitizer failed and no fallback available.");
+                throw new SanitizerError(
+                    "Primary sanitizer failed and no fallback available."
+                );
             }
 
-            logger.info("Using fallback sanitizer");
+            logger.warn("Sanitizer fallback used", {
+                layer: "sanitizer-manager",
+                operation: "sanitize"
+            });
+
             return this.fallback.sanitize(value, options);
         }
     }
 
-   
     middleware(options?: any) {
         return (req: any, _res: any, next: any) => {
             let fallbackTriggered = false;
-            
+
             const safeSanitize = (value: string): string => {
                 if (fallbackTriggered && this.fallback) {
                     return this.fallback.sanitize(value, options);
                 }
-                
+
                 try {
                     return this.primary.sanitize(value, options);
                 } catch (err: any) {
                     if (!this.fallback) {
                         throw err;
                     }
-                    
+
                     fallbackTriggered = true;
-                    logger.warn("Switching to fallback sanitizer for this request");
+
+                    logger.warn("Switching to fallback sanitizer for request", {
+                        layer: "sanitizer-manager",
+                        operation: "middleware"
+                    });
+
                     return this.fallback.sanitize(value, options);
                 }
             };
 
             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 value = originalBody[key];
-                        
+
                         if (typeof value === "string") {
                             sanitizedBody[key] = safeSanitize(value);
                         } else if (Array.isArray(value)) {
-                            sanitizedBody[key] = value.map(item => 
-                                typeof item === "string" ? safeSanitize(item) : item
+                            sanitizedBody[key] = value.map(item =>
+                                typeof item === "string"
+                                    ? safeSanitize(item)
+                                    : item
                             );
-                        } else if (value && typeof value === "object") {
-                            sanitizedBody[key] = value; 
                         } else {
                             sanitizedBody[key] = value;
                         }
                     }
-                    
+
                     req.sanitizedBody = sanitizedBody;
-                    
-                    logger.debug("Request body sanitized", {
-                        originalKeys: Object.keys(originalBody),
-                        sanitizedKeys: Object.keys(sanitizedBody),
+
+                    // ✅ visible + safe info
+                    logger.info("Request body sanitized", {
+                        layer: "sanitizer-manager",
+                        operation: "middleware",
+                        fieldCount: Object.keys(sanitizedBody).length,
                         usedFallback: fallbackTriggered
                     });
                 }
@@ -91,10 +110,13 @@ export class SanitizerManager {
                 next();
             } catch (err: any) {
                 logger.error("Sanitizer middleware failed", {
-                    error: err?.message
+                    layer: "sanitizer-manager",
+                    operation: "middleware",
+                    reason: err?.message
                 });
+
                 next(new SanitizerError("Sanitizer middleware failure"));
             }
         };
     }
-}
+}

package/src/managers/ValidatorManager.ts

@@ -1,5 +1,5 @@
 import { logger } from "../logging";
-import { ValidationError } from "../core/errors/ValidationError.js";
+import { ValidationError } from "../core/errors/ValidationError";
 
 interface ValidatorAdapter {
     validate: (schema?: any) => any;
@@ -12,32 +12,44 @@ export class ValidatorManager {
     constructor(zodAdapter: ValidatorAdapter, expressAdapter: ValidatorAdapter) {
         this.zodAdapter = zodAdapter;
         this.expressAdapter = expressAdapter;
+
+        logger.info("ValidatorManager initialized", {
+            layer: "validator-manager",
+            adapters: ["zod", "express-validator"]
+        });
     }
 
     validate(schema?: any) {
         const isZod =
-    schema &&
-    typeof schema === "object" &&
-    typeof schema._def === "object" && 
-    typeof schema.safeParse === "function";
+            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;
+            let adapterUsed: "zod" | "express-validator" | "none" = "none";
 
             if (isZod) {
-                logger.debug("Using Zod adapter");
+                adapterUsed = "zod";
                 middleware = this.zodAdapter.validate(schema);
-            } 
-            else if (isExpressValidator) {
-                logger.debug(" Using express-validator adapter");
+            } else if (isExpressValidator) {
+                adapterUsed = "express-validator";
                 middleware = this.expressAdapter.validate(schema);
-            } 
-            else {
-                return next(); 
+            } else {
+                return next();
             }
 
+            logger.info("Validation adapter selected", {
+                layer: "validator-manager",
+                operation: "select",
+                adapter: adapterUsed,
+                path: req.path,
+                method: req.method
+            });
+
             // CASE 1 — express-validator returns ARRAY
             if (Array.isArray(middleware)) {
                 let idx = 0;
@@ -46,11 +58,18 @@ export class ValidatorManager {
                     if (err) return next(err);
 
                     const fn = middleware[idx++];
-                    if (!fn) return next(); // done
+                    if (!fn) return next();
 
                     try {
                         fn(req, res, run);
                     } catch (error: any) {
+                        logger.error("Validation middleware execution failed", {
+                            layer: "validator-manager",
+                            operation: "execute",
+                            adapter: adapterUsed,
+                            reason: error?.message
+                        });
+
                         next(new ValidationError(error.message));
                     }
                 };
@@ -58,16 +77,22 @@ export class ValidatorManager {
                 return run();
             }
 
-            // CASE 2 — Zod returns SINGLE MIDDLEWARE
+            // CASE 2 — Zod returns SINGLE middleware
             try {
                 middleware(req, res, (err?: any) => {
                     if (err) return next(err);
                     next();
                 });
             } catch (err: any) {
+                logger.error("Validation middleware execution failed", {
+                    layer: "validator-manager",
+                    operation: "execute",
+                    adapter: adapterUsed,
+                    reason: err?.message
+                });
+
                 next(new ValidationError(err.message));
             }
         };
     }
 }
-