hi-secure 1.0.16 → 1.0.18

package/src/logging/winstonSetup.ts

@@ -1,70 +1,8 @@
-// // import winston from "winston";
-
-// // export const logger = winston.createLogger({
-// //     level: "info",
-// //     format: winston.format.combine(
-// //         winston.format.timestamp(),
-// //         winston.format.json()
-// //     ),
-// //     transports: [
-// //         new winston.transports.Console()
-// //     ]
-// // });
-
-// // // Shortcut helpers
-// // export const logInfo = (msg: string, meta: any = {}) => logger.info(msg, meta);
-// // export const logWarn = (msg: string, meta: any = {}) => logger.warn(msg, meta);
-// // export const logError = (msg: string, meta: any = {}) => logger.error(msg, meta);
-
-
-
-
-// import winston from "winston";
-
-// const { combine, timestamp, printf, colorize, errors } = winston.format;
-
-// const logFormat = printf(({ level, message, timestamp, ...meta }) => {
-//     const metaString =
-//         Object.keys(meta).length > 0 ? ` | ${JSON.stringify(meta)}` : "";
-
-//     return `${timestamp} ${level}: ${message}${metaString}`;
-// });
-
-// export const logger = winston.createLogger({
-//     level: "info",
-//     format: combine(
-//         errors({ stack: true }),
-//         timestamp({ format: "HH:mm:ss" })
-//     ),
-//     transports: [
-//         new winston.transports.Console({
-//             format: combine(
-//                 colorize({ all: true }),
-//                 logFormat
-//             )
-//         })
-//     ]
-// });
-
-// // Shortcut helpers
-// export const logInfo = (msg: string, meta: any = {}) =>
-//     logger.info(msg, meta);
-
-// export const logWarn = (msg: string, meta: any = {}) =>
-//     logger.warn(msg, meta);
-
-// export const logError = (msg: string, meta: any = {}) =>
-//     logger.error(msg, meta);
-
-
-
-
-
 import winston from "winston";
 
 const { combine, timestamp, printf, colorize, errors } = winston.format;
 
-// Explicit colors (best practice)
+//colors added 
 winston.addColors({
     error: "red",
     warn: "yellow",
@@ -80,7 +18,7 @@ const logFormat = printf(({ level, message, timestamp, ...meta }) => {
 });
 
 export const logger = winston.createLogger({
-    level: "http", // 🔴 MOST IMPORTANT FIX
+    level: "http", 
     format: combine(
         errors({ stack: true }),
         timestamp({ format: "HH:mm:ss" })

package/src/managers/AuthManager.ts

@@ -1,144 +1,3 @@
-// import { JWTAdapter } from "../adapters/JWTAdapter.js";
-// import { GoogleAdapter } from "../adapters/GoogleAdapter.js";
-// import { AdapterError } from "../core/errors/AdapterError.js";
-// import { HttpError } from "../core/errors/HttpError.js";
-// import { Request, Response, NextFunction } from "express";
-// import { logger } from "../logging";
-
-
-// export interface AuthOptions {
-//     jwtSecret: string;
-//     jwtExpiresIn?: string | number;
-//     googleClientId?: string;
-// }
-
-// export interface ProtectOptions {
-//     required?: boolean;
-//     roles?: string[];
-// }
-
-// export class AuthManager {
-//     private jwtAdapter: JWTAdapter;
-//     private googleAdapter?: GoogleAdapter;
-
-//     constructor(opts: AuthOptions) {
-//         if (!opts.jwtSecret) {
-//             throw new AdapterError("jwtSecret required in AuthOptions");
-//         }
-
-//         if (opts.jwtSecret.length < 32) {
-//             logger.warn(" JWT secret is less than 32 characters - consider using a stronger secret");
-//         }
-
-//         logger.info("AuthManager initialized");
-
-//         this.jwtAdapter = new JWTAdapter({
-//             secret: opts.jwtSecret,
-//             expiresIn: opts.jwtExpiresIn ?? "1d",
-//         });
-
-//         if (opts.googleClientId) {
-//             this.googleAdapter = new GoogleAdapter(opts.googleClientId);
-//             logger.info("GoogleAdapter enabled");
-//         }
-//     }
-
-//     sign(payload: object, options?: { expiresIn?: string | number, jti?: string }) {
-//         logger.info("JWT Sign called");
-//         return this.jwtAdapter.sign(payload, options);
-//     }
-
-//     verify(token: string) {
-//         logger.info("JWT Verify called");
-//         return this.jwtAdapter.verify(token);
-//     }
-
-//     async verifyGoogleIdToken(idToken: string) {
-//         if (!this.googleAdapter) {
-//             throw new AdapterError("GoogleAdapter not configured.");
-//         }
-
-//         logger.info("Google ID Token verify called");
-
-//         try {
-//             return await this.googleAdapter.verifyIdToken(idToken);
-//         } catch (err: any) {
-//             logger.error("Google ID Token verification failed", { error: err?.message });
-//             throw HttpError.Unauthorized("Invalid Google ID token");
-//         }
-//     }
-
-//     protect(options?: ProtectOptions) {
-//         const required = options?.required ?? true;
-//         const roles = options?.roles;
-
-//         return (req: Request, res: Response, next: NextFunction) => {
-//             const header = req.headers["authorization"];
-
-            
-//             if (!required && !header) {
-//                 return next();
-//             }
-
-           
-//             if (!header) {
-//                 logger.warn("Missing Authorization header", {
-//                     path: req.path,
-//                     method: req.method
-//                 });
-//                 return next(HttpError.Unauthorized("Missing Authorization header"));
-//             }
-
-          
-//             const [type, token] = String(header).split(" ");
-//             if (type !== "Bearer" || !token) {
-//                 logger.warn("Invalid Authorization header", {
-//                     path: req.path,
-//                     method: req.method
-//                 });
-//                 return next(HttpError.Unauthorized("Invalid Authorization header"));
-//             }
-
-//             try {
-
-//                 // Verify JWT
-//                 const decoded = this.verify(token);
-                
-//                 // Attach to request
-//                 (req as any).auth = decoded;
-//                 (req as any).user = decoded; 
-                
-//                 // Role-based authorization - role added Middleware
-//                 if (roles && roles.length > 0) {
-//                     const userRole = (decoded as any).role || (decoded as any).roles?.[0];
-//                     if (!userRole || !roles.includes(userRole)) {
-//                         logger.warn("Insufficient permissions", {
-//                             path: req.path,
-//                             requiredRoles: roles,
-//                             userRole
-//                         });
-//                         return next(HttpError.Forbidden("Insufficient permissions"));
-//                     }
-//                 }
-                
-//                 return next();
-//             } catch (err: any) {
-//                 logger.error("JWT verify failed", {
-//                     error: err?.message,
-//                     path: req.path,
-//                     method: req.method
-//                 });
-//                 return next(HttpError.Unauthorized("Invalid or expired token"));
-//             }
-//         };
-//     }
-// }
-
-
-
-
-
-
 import { JWTAdapter } from "../adapters/JWTAdapter";
 import { GoogleAdapter } from "../adapters/GoogleAdapter";
 import { AdapterError } from "../core/errors/AdapterError";

package/src/managers/CorsManager.ts

@@ -1,43 +1,3 @@
-// import cors from "cors";
-// import { logger } from "../logging";
-// import { AdapterError } from "../core/errors/AdapterError.js";
-
-// export class CorsManager {
-    
-//     middleware(options?: any) {
-//         try {
-//             const defaultOptions = {
-//                 origin: '*',
-//                 methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
-//                 allowedHeaders: ['Content-Type', 'Authorization'],
-//                 credentials: false,
-//                 maxAge: 86400
-//             };
-            
-//             const finalOptions = options ? { ...defaultOptions, ...options } : defaultOptions;
-            
-//             logger.debug("CORS configured", {
-//                 origin: finalOptions.origin,
-//                 methods: finalOptions.methods
-//             });
-            
-//             return cors(finalOptions);
-            
-//         } catch (err: any) {
-//             logger.error(" CORS Manager: failed to create CORS middleware", {
-//                 error: err?.message || err,
-//                 options
-//             });
-//             throw new AdapterError("CORS middleware initialization failed.");
-//         }
-//     }
-// }
-
-
-
-
-
-
 import cors from "cors";
 import { logger } from "../logging";
 import { AdapterError } from "../core/errors/AdapterError";

package/src/managers/HashManager.ts

@@ -1,111 +1,3 @@
-// import { AdapterError } from "../core/errors/AdapterError.js";
-// import { HiSecureConfig } from "../core/types/HiSecureConfig.js";
-// import { logger } from "../logging";
-
-// interface HashAdapter {
-//     hash(value: string): Promise<string>;
-//     verify(value: string, hashed: string): Promise<boolean>;
-// }
-
-// export interface HashResult {
-//     hash: string;
-//     algorithm: string;
-//     usedFallback: boolean;
-// }
-
-// export class HashManager {
-//     private config: HiSecureConfig["hashing"];
-//     private primaryAdapter: HashAdapter;
-//     private fallbackAdapter: HashAdapter | null;
-
-//     constructor(
-//         config: HiSecureConfig["hashing"],
-//         primaryAdapter: HashAdapter,
-//         fallbackAdapter: HashAdapter | null
-//     ) {
-//         this.config = config;
-//         this.primaryAdapter = primaryAdapter;
-//         this.fallbackAdapter = fallbackAdapter;
-//     }
-
-//     async hash(value: string, options?: { allowFallback?: boolean }): Promise<HashResult> {
-//         try {
-//             const hash = await this.primaryAdapter.hash(value);
-//             return {
-//                 hash,
-//                 algorithm: this.config.primary,
-//                 usedFallback: false
-//             };
-//         } catch (err: any) {
-//             logger.warn("Primary hashing failed", {
-//                 error: err.message,
-//                 algorithm: this.config.primary
-//             });
-
-//             if (!options?.allowFallback || !this.fallbackAdapter) {
-//                 throw new AdapterError(
-//                     `Primary hashing (${this.config.primary}) failed. Fallback not allowed.`
-//                 );
-//             }
-
-//             try {
-//                 const hash = await this.fallbackAdapter.hash(value);
-                
-//                 // Log security downgrade warning
-//                 logger.warn("SECURITY DOWNGRADE: Using fallback hashing", {
-//                     from: this.config.primary,
-//                     to: this.config.fallback
-//                 });
-                
-//                 return {
-//                     hash,
-//                     algorithm: this.config.fallback || 'bcrypt',
-//                     usedFallback: true
-//                 };
-//             } catch (fallbackErr: any) {
-//                 logger.error("Fallback hashing failed", {
-//                     error: fallbackErr?.message,
-//                 });
-//                 throw new AdapterError(
-//                     "Both primary and fallback hashing failed."
-//                 );
-//             }
-//         }
-//     }
-
-//     async verify(value: string, hashed: string): Promise<boolean> {
-//         //  primary adapter - first
-//         try {
-//             return await this.primaryAdapter.verify(value, hashed);
-//         } catch (primaryErr: any) {
-//             logger.warn("Primary verify failed", {
-//                 error: primaryErr?.message,
-//             });
-
-//             //  fallback exists -  try it
-//             if (this.fallbackAdapter) {
-//                 try {
-//                     return await this.fallbackAdapter.verify(value, hashed);
-//                 } catch (fallbackErr: any) {
-//                     logger.error(" Fallback verify failed", {
-//                         error: fallbackErr?.message,
-//                     });
-//                     throw new AdapterError(
-//                         "Both primary and fallback verify failed."
-//                     );
-//                 }
-//             }
-            
-//             throw new AdapterError(
-//                 "Primary verify failed and no fallback adapter configured."
-//             );
-//         }
-//     }
-// }
-
-
-
-
 import { AdapterError } from "../core/errors/AdapterError";
 import { HiSecureConfig } from "../core/types/HiSecureConfig";
 import { logger } from "../logging";

package/src/managers/JsonManager.ts

@@ -1,65 +1,3 @@
-// import express from "express";
-// import qs from "qs";
-// import { logger } from "../logging";
-// import { AdapterError } from "../core/errors/AdapterError.js";
-
-// export class JsonManager {
-//     middleware(options?: any) {
-//         try {
-//             const defaultOptions = {
-//                 limit: '1mb',
-//                 inflate: true,
-//                 strict: true
-//             };
-//             return express.json({ ...defaultOptions, ...(options || {}) });
-//         } catch (err: any) {
-//             logger.error("JSON Manager: failed to create JSON parser");
-//             throw new AdapterError("JSON parser initialization failed.");
-//         }
-//     }
-
-//     urlencoded(options?: any) {
-//         try {
-//             const defaultOptions = {
-//                 extended: true,
-//                 limit: '1mb',
-//                 parameterLimit: 1000
-//             };
-//             const opts = { ...defaultOptions, ...(options || {}) };
-//             return express.urlencoded(opts);
-//         } catch (err: any) {
-//             logger.error("URL-encoded parser failed");
-//             throw new AdapterError("URL-encoded parser initialization failed.");
-//         }
-//     }
-
-//     queryParser(options?: any) {
-//         return (req: any, res: any, next: any) => {
-//             try {
-//                 if (!req.parsedQuery && req.url.includes('?')) {
-//                     const queryString = req.url.split("?")[1] || "";
-//                     const parsed = qs.parse(queryString, {
-//                         depth: 5,
-//                         parameterLimit: 100,
-//                         ...options
-//                     });
-                    
-//                     req.parsedQuery = parsed;
-//                     logger.debug(" Query parsed", {
-//                         keys: Object.keys(parsed)
-//                     });
-//                 }
-//                 next();
-//             } catch (err: any) {
-//                 logger.error("Failed to parse query", { error: err?.message });
-//                 next(new AdapterError("Query parsing failed."));
-//             }
-//         };
-//     }
-// }
-
-
-
 import express from "express";
 import qs from "qs";
 import { logger } from "../logging";

package/src/managers/RateLimitManager.ts

@@ -1,116 +1,3 @@
-// import { HiSecureConfig } from "../core/types/HiSecureConfig.js";
-// import { AdapterError } from "../core/errors/AdapterError.js";
-// import { logger } from "../logging";
-
-// interface RateLimiterAdapter {
-//     getMiddleware: (options?: any) => any;
-// }
-
-// export class RateLimitManager {
-//     private config: HiSecureConfig["rateLimiter"];
-//     private primaryAdapter: RateLimiterAdapter;
-//     private fallbackAdapter: RateLimiterAdapter | null;
-
-//     constructor(
-//         config: HiSecureConfig["rateLimiter"],
-//         primaryAdapter: RateLimiterAdapter,
-//         fallbackAdapter: RateLimiterAdapter | null
-//     ) {
-//         this.config = config;
-//         this.primaryAdapter = primaryAdapter;
-//         this.fallbackAdapter = fallbackAdapter;
-//     }
-
-//     middleware(opts?: { mode?: "strict" | "relaxed" | "api"; options?: any }) {
-//         let finalOptions: any = {};
-
-//         if (opts?.mode === "strict") {
-//             finalOptions = {
-//                 windowMs: 10_000,
-//                 max: 5,
-//                 message: "Too many requests, please slow down."
-//             };
-//         } else if (opts?.mode === "relaxed") {
-//             finalOptions = {
-//                 windowMs: 60_000,
-//                 max: 100,
-//                 message: "Rate limit exceeded."
-//             };
-//         } else if (opts?.mode === "api") {
-//             finalOptions = {
-//                 windowMs: 15 * 60 * 1000, 
-//                 max: 100,
-//                 message: "API rate limit exceeded."
-//             };
-//         } else {
-//             finalOptions = {
-//                 windowMs: this.config.windowMs,
-//                 max: this.config.maxRequests,
-//                 message: this.config.message,
-//                 standardHeaders: true,      
-//                 legacyHeaders: false        
-//             };
-//         }
-
-//         if (opts?.options) {
-//             const allowedOverrides = ['message', 'skipFailedRequests', 'standardHeaders', 'legacyHeaders'];
-//             for (const key of allowedOverrides) {
-//                 if (opts.options[key] !== undefined) {
-//                     finalOptions[key] = opts.options[key];
-//                 }
-//             }
-            
-//             const attemptedOverrides = Object.keys(opts.options).filter(
-//                 k => !allowedOverrides.includes(k) && k !== 'mode'
-//             );
-//             if (attemptedOverrides.length > 0) {
-//                 logger.warn("Rate limit overrides ignored", {
-//                     preset: opts?.mode || 'default',
-//                     ignoredOptions: attemptedOverrides
-//                 });
-//             }
-//         }
-
-//         if (finalOptions.standardHeaders === undefined) {
-//             finalOptions.standardHeaders = true;
-//         }
-//         if (finalOptions.legacyHeaders === undefined) {
-//             finalOptions.legacyHeaders = false;
-//         }
-
-//         try {
-//             logger.info("Applying rate limiting", {
-//                 mode: opts?.mode || 'default',
-//                 windowMs: finalOptions.windowMs,
-//                 max: finalOptions.max
-//             });
-            
-//             return this.primaryAdapter.getMiddleware(finalOptions);
-//         } catch (err: any) {
-//             logger.warn("Primary rate limiter failed → fallback", {
-//                 error: err?.message
-//             });
-
-//             if (!this.fallbackAdapter) {
-//                 throw new AdapterError("Rate limiters failed; no fallback adapter.");
-//             }
-
-//             try {
-//                 logger.info("Using fallback rate limiter");
-//                 return this.fallbackAdapter.getMiddleware(finalOptions);
-//             } catch (fallbackErr: any) {
-//                 logger.error("Fallback limiter also failed", {
-//                     error: fallbackErr?.message
-//                 });
-//                 throw new AdapterError("Both primary and fallback limiters failed.");
-//             }
-//         }
-//     }
-// }
-
-
-
-
 import { HiSecureConfig } from "../core/types/HiSecureConfig";
 import { AdapterError } from "../core/errors/AdapterError";
 import { logger } from "../logging";

package/src/managers/SanitizerManager.ts

@@ -1,106 +1,3 @@
-// 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(value: string, options?: any): 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 });
-
-//             if (!this.fallback) {
-//                 throw new SanitizerError("Primary sanitizer failed and no fallback available.");
-//             }
-
-//             logger.info("Using fallback sanitizer");
-//             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");
-//                     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
-//                             );
-//                         } 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),
-//                         usedFallback: fallbackTriggered
-//                     });
-//                 }
-
-//                 next();
-//             } catch (err: any) {
-//                 logger.error("Sanitizer middleware failed", {
-//                     error: err?.message
-//                 });
-//                 next(new SanitizerError("Sanitizer middleware failure"));
-//             }
-//         };
-//     }
-// }
-
-
-
 import { SanitizerError } from "../core/errors/SanitizerError";
 import { logger } from "../logging";