hi-secure 1.0.7 → 1.0.11

package/src/core/HiSecure.ts

@@ -1,4 +1,3 @@
-// src/core/HiSecure.ts - COMPLETELY FIXED
 import { HiSecureConfig } from "./types/HiSecureConfig.js";
 import { defaultConfig } from "./config.js";
 import { LIB_NAME, LIB_VERSION } from "./constants.js";
@@ -32,7 +31,7 @@ import compression from "compression";
 import { errorHandler } from "../middlewares/errorHandler.js";
 
 // Types
-import { SecureOptions, ValidationSchema, RateLimitOptions } from "./types/SecureOptions.js";
+import { SecureOptions, ValidationSchema} from "./types/SecureOptions.js";
 
 export class HiSecure {
     private static instance: HiSecure | null = null;
@@ -53,8 +52,6 @@ export class HiSecure {
     private hashingFallback: any;
     private rateLimiterPrimary: any;
     private rateLimiterFallback: any;
-    private validatorPrimary: any;
-    private validatorFallback: any;
     private sanitizerPrimary: any;
     private sanitizerFallback: any;
 
@@ -63,9 +60,7 @@ export class HiSecure {
         this.config = deepMerge(defaultConfig, userConfig);
     }
 
-    // =====================================================
     // SINGLETON & INITIALIZATION
-    // =====================================================
     
     static getInstance(config?: Partial<HiSecureConfig>): HiSecure {
         if (!HiSecure.instance) {
@@ -91,7 +86,6 @@ export class HiSecure {
         this.setupManagers();
         this.setupDynamicManagers();
 
-        // Make everything immutable
         deepFreeze(this.config);
         // deepFreeze(this.hashManager);
         // deepFreeze(this.rateLimitManager);
@@ -109,9 +103,7 @@ export class HiSecure {
         return this.initialized;
     }
 
-    // =====================================================
     // FLUENT API METHODS (Route-level security)
-    // =====================================================
     
     static auth(options?: { required?: boolean; roles?: string[] }) {
         const instance = this.getInstance();
@@ -156,9 +148,7 @@ export class HiSecure {
         return chain;
     }
 
-    // =====================================================
     // UTILITY METHODS (Direct usage)
-    // =====================================================
     
     static async hash(password: string): Promise<string> {
         const instance = this.getInstance();
@@ -198,9 +188,7 @@ export class HiSecure {
         }
     };
 
-    // =====================================================
     // GLOBAL MIDDLEWARE (app.use())
-    // =====================================================
     
     static middleware(options?: SecureOptions | "api" | "strict" | "public") {
         const instance = this.getInstance();
@@ -222,9 +210,8 @@ export class HiSecure {
         return instance.createMiddlewareChain(options || {});
     }
 
-    // =====================================================
-    // INTERNAL METHODS
-    // =====================================================
+   
+    // Internal Methods
     
     private setupAdapters(): void {
         logger.info("🧩 Setting up adapters...");
@@ -244,13 +231,16 @@ export class HiSecure {
             : new ExpressRLAdapter();
         this.rateLimiterFallback = new ExpressRLAdapter();
 
-        // Validation
-        this.validatorPrimary = this.config.validation.mode === "zod"
-            ? new ZodAdapter()
-            : new ExpressValidatorAdapter();
-        this.validatorFallback = this.config.validation.fallback === "express-validator"
-            ? new ExpressValidatorAdapter()
-            : null;
+
+
+        // // Validation
+        // this.validatorPrimary = this.config.validation.mode === "zod"
+        //     ? new ZodAdapter()
+        //     : new ExpressValidatorAdapter();
+        // this.validatorFallback = this.config.validation.fallback === "express-validator"
+        //     ? new ExpressValidatorAdapter()
+        //     : null;
+
 
         // Sanitization
         this.sanitizerPrimary = new SanitizeHtmlAdapter(this.config.sanitizer);
@@ -301,7 +291,6 @@ export class HiSecure {
                 jwtSecret,
                 jwtExpiresIn: this.config.auth.jwtExpiresIn,
                 googleClientId: process.env.GOOGLE_CLIENT_ID || this.config.auth.googleClientId
-                // Removed algorithm - handled in AuthManager
             });
         }
     }

package/src/core/useSecure.ts

@@ -1,21 +1,19 @@
-// src/core/useSecure.ts - SIMPLER VERSION
-// This is now optional since HiSecure class has fluent API
-
-
 import { HiSecure } from "./HiSecure.js";
 import { SecureOptions } from "./types/SecureOptions.js";
 
 /**
  * @deprecated Use HiSecure.middleware() or fluent API instead
  */
+
 export function useSecure(options?: SecureOptions | "api" | "strict" | "public") {
     console.warn("⚠ useSecure() is deprecated. Use HiSecure.middleware() or fluent API methods.");
     return HiSecure.middleware(options);
 }
 
-/**
- * Legacy support - route-level security
- */
+
+//  Legacy support - route-level security
+
+
 export function secureRoute(options?: SecureOptions) {
     const chain: any[] = [];
     

package/src/index.ts

@@ -1,14 +1,13 @@
-// src/index.ts - MAIN ENTRY POINT
 import { HiSecure } from "./core/HiSecure.js";
 import { useSecure, secureRoute } from "./core/useSecure.js";
 
 const hiSecure = HiSecure.getInstance();
 
 export { 
-    HiSecure,        // Class for advanced usage
-    hiSecure,        // Singleton instance
-    useSecure,       // Legacy function (deprecated)
-    secureRoute      // Route-level security helper
+    HiSecure,        
+    hiSecure,        
+    useSecure,       
+    secureRoute      
 };
 
 export default hiSecure;

package/src/managers/AuthManager.ts

@@ -1,113 +1,8 @@
-// import { JWTAdapter } from "../adapters/JWTAdapter.js";
-// import { GoogleAdapter } from "../adapters/GoggleAdapter.js";
-// import { AdapterError } from "../core/errors/AdapterError.js";
-// import { HttpError } from "../core/errors/HttpErrror.js";
-// import { Request, Response, NextFunction } from "express";
-// import { logError, logWarn, logInfo } from "../logging";
-
-// export interface AuthOptions {
-//     jwtSecret: string;
-//     jwtExpiresIn?: string | number | undefined;
-//     googleClientId?: string | undefined;
-// }
-
-// export class AuthManager {
-//     private jwtAdapter: JWTAdapter;
-//     private googleAdapter?: GoogleAdapter;
-
-//     constructor(opts: AuthOptions) {
-//         if (!opts.jwtSecret)
-//             throw new AdapterError("jwtSecret required in AuthOptions");
-
-//         logInfo("AuthManager initialized");
-
-//         this.jwtAdapter = new JWTAdapter({
-//             secret: opts.jwtSecret,
-//             expiresIn: opts.jwtExpiresIn ?? undefined,
-//         });
-
-//         if (opts.googleClientId) {
-//             this.googleAdapter = new GoogleAdapter(opts.googleClientId);
-//             logInfo("GoogleAdapter enabled");
-//         }
-//     }
-
-//     sign(payload: object, options?: { expiresIn?: string | number }) {
-//         logInfo("JWT Sign called");
-//         return this.jwtAdapter.sign(payload, options);
-//     }
-
-//     verify(token: string) {
-//         logInfo("JWT Verify called");
-//         return this.jwtAdapter.verify(token);
-//     }
-
-//     async verifyGoogleIdToken(idToken: string) {
-//         if (!this.googleAdapter)
-//             throw new AdapterError("GoogleAdapter not configured.");
-
-//         logInfo("Google ID Token verify called");
-
-//         try {
-//             return await this.googleAdapter.verifyIdToken(idToken);
-//         } catch (err: any) {
-//             logError("Google ID Token verification failed", { error: err?.message });
-//             throw HttpError.Unauthorized("Invalid Google ID token");
-//         }
-//     }
-
-//     protect(options?: { required?: boolean }) {
-//         const required = options?.required ?? true;
-
-//         return (req: Request, res: Response, next: NextFunction) => {
-//             const header = req.headers["authorization"] || req.headers["Authorization"];
-
-//             if (!header) {
-//                 if (required) {
-//                     logWarn("Missing Authorization header", {
-//                         path: req.path,
-//                         method: req.method
-//                     });
-//                     return next(HttpError.Unauthorized("Missing Authorization header"));
-//                 }
-//                 return next();
-//             }
-
-//             const [type, token] = String(header).split(" ");
-
-//             if (type !== "Bearer" || !token) {
-//                 logWarn("Invalid Authorization header", {
-//                     path: req.path,
-//                     method: req.method
-//                 });
-//                 return next(HttpError.Unauthorized("Invalid Authorization header"));
-//             }
-
-//             try {
-//                 const decoded = this.verify(token);
-//                 (req as any).auth = decoded;
-//                 return next();
-//             } catch (err: any) {
-//                 logError("JWT verify failed", {
-//                     error: err?.message,
-//                     path: req.path,
-//                     method: req.method
-//                 });
-//                 return next(HttpError.Unauthorized("Invalid or expired token"));
-//             }
-//         };
-//     }
-// }
-
-
-
-// src/managers/AuthManager.ts - FIXED
 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 { logError, logWarn, logInfo } from "../logging";
 import { logger } from "../logging";
 
 
@@ -180,12 +75,12 @@ export class AuthManager {
         return (req: Request, res: Response, next: NextFunction) => {
             const header = req.headers["authorization"];
 
-            // If auth is not required, skip authentication
+            
             if (!required && !header) {
                 return next();
             }
 
-            // If auth is required but no header
+           
             if (!header) {
                 logger.warn("Missing Authorization header", {
                     path: req.path,
@@ -194,7 +89,7 @@ export class AuthManager {
                 return next(HttpError.Unauthorized("Missing Authorization header"));
             }
 
-            // Parse Bearer token
+          
             const [type, token] = String(header).split(" ");
             if (type !== "Bearer" || !token) {
                 logger.warn("Invalid Authorization header", {
@@ -205,12 +100,13 @@ export class AuthManager {
             }
 
             try {
+
                 // Verify JWT
                 const decoded = this.verify(token);
                 
                 // Attach to request
                 (req as any).auth = decoded;
-                (req as any).user = decoded; // Common pattern
+                (req as any).user = decoded; 
                 
                 // Role-based authorization
                 if (roles && roles.length > 0) {

package/src/managers/CorsManager.ts

@@ -1,27 +1,3 @@
-// import cors from "cors";
-// import { logger } from "../logging";
-// import { AdapterError } from "../core/errors/AdapterError.js";
-
-// export class CorsManager {
-
-//     middleware(options?: any) {
-//         try {
-//             // options = undefined → use default CORS
-//             return options ? cors(options) : cors();
-
-//         } catch (err: any) {
-//             logger.error("❌ CORS Manager: failed to create CORS middleware", {
-//                 error: err?.message || err,
-//                 options
-//             });
-//             throw new AdapterError("CORS middleware initialization failed.");
-//         }
-//     }
-// }
-
-
-
-// src/managers/CorsManager.ts - IMPROVED
 import cors from "cors";
 import { logger } from "../logging";
 import { AdapterError } from "../core/errors/AdapterError.js";
@@ -35,7 +11,7 @@ export class CorsManager {
                 methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
                 allowedHeaders: ['Content-Type', 'Authorization'],
                 credentials: false,
-                maxAge: 86400 // 24 hours
+                maxAge: 86400
             };
             
             const finalOptions = options ? { ...defaultOptions, ...options } : defaultOptions;

package/src/managers/HashManager.ts

@@ -1,288 +1,3 @@
-// // // import { AdapterError } from "../core/errors/AdapterError";
-// // // import { HiSecureConfig } from "../core/config";
-// // // import { logger } from "../logging";
-
-// // // export class HashManager {
-// // //     private config: HiSecureConfig["hashing"];
-// // //     private primaryAdapter: {
-// // //         hash: (value: string) => Promise<string>;
-// // //         verify: (value: string, hashed: string) => Promise<boolean>;
-// // //     };
-// // //     private fallbackAdapter: {
-// // //         hash: (value: string) => Promise<string>;
-// // //         verify: (value: string, hashed: string) => Promise<boolean>;
-// // //     } | null;
-
-// // //     constructor(
-// // //         config: HiSecureConfig["hashing"],
-// // //         primaryAdapter: any,
-// // //         fallbackAdapter: any
-// // //     ) {
-// // //         this.config = config;
-// // //         this.primaryAdapter = primaryAdapter;
-// // //         this.fallbackAdapter = fallbackAdapter;
-// // //     }
-
-// // //     /**
-// // //      * Hash a password using primary adapter (Argon2)
-// // //      * If it fails → fallback (Bcrypt)
-// // //      */
-// // //     async hash(value: string): Promise<string> {
-// // //         try {
-// // //             return await this.primaryAdapter.hash(value);
-// // //         } catch (err: any) {
-// // //             logger.warn("⚠ Primary hashing failed — switching to fallback", {
-// // //                 error: err?.message,
-// // //             });
-
-// // //             if (!this.fallbackAdapter) {
-// // //                 throw new AdapterError(
-// // //                     "Primary hashing failed and no fallback adapter is configured."
-// // //                 );
-// // //             }
-
-// // //             try {
-// // //                 return await this.fallbackAdapter.hash(value);
-// // //             } catch (fallbackErr: any) {
-// // //                 logger.error("❌ Fallback hashing failed", {
-// // //                     error: fallbackErr?.message,
-// // //                 });
-// // //                 throw new AdapterError(
-// // //                     "Both primary and fallback hashing failed."
-// // //                 );
-// // //             }
-// // //         }
-// // //     }
-
-// // //     /**
-// // //      * Verify using primary hashing method.
-// // //      * If mismatch OR failure → use fallback.
-// // //      */
-// // //     async verify(value: string, hashed: string): Promise<boolean> {
-// // //         try {
-// // //             return await this.primaryAdapter.verify(value, hashed);
-// // //         } catch (err: any) {
-// // //             logger.warn("⚠ Primary verify failed — trying fallback", {
-// // //                 error: err?.message,
-// // //             });
-
-// // //             if (!this.fallbackAdapter) {
-// // //                 throw new AdapterError(
-// // //                     "Primary verify failed and no fallback adapter is configured."
-// // //                 );
-// // //             }
-
-// // //             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."
-// // //                 );
-// // //             }
-// // //         }
-// // //     }
-// // // }
-
-
-
-
-
-
-
-// // import { AdapterError } from "../core/errors/AdapterError.js";
-// // import { HiSecureConfig } from "../core/config.js";
-// // import { logger } from "../logging";
-
-// // interface HashAdapter {
-// //     hash(value: string): Promise<string>;
-// //     verify(value: string, hashed: string): Promise<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): Promise<string> {
-// //         try {
-// //             return await this.primaryAdapter.hash(value);
-// //         } catch (err: any) {
-// //             logger.warn("⚠ Primary hashing failed — trying fallback", {
-// //                 error: err?.message,
-// //             });
-
-// //             if (!this.fallbackAdapter) {
-// //                 throw new AdapterError(
-// //                     "Primary hashing failed and no fallback adapter configured."
-// //                 );
-// //             }
-
-// //             try {
-// //                 return await this.fallbackAdapter.hash(value);
-// //             } 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> {
-// //         try {
-// //             return await this.primaryAdapter.verify(value, hashed);
-// //         } catch (err: any) {
-// //             logger.warn("⚠ Primary verify failed — trying fallback", {
-// //                 error: err?.message,
-// //             });
-
-// //             if (!this.fallbackAdapter) {
-// //                 throw new AdapterError(
-// //                     "Primary verify failed and no fallback adapter configured."
-// //                 );
-// //             }
-
-// //             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."
-// //                 );
-// //             }
-// //         }
-// //     }
-// // }
-
-
-
-// // src/managers/HashManager.ts - FIXED
-// 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>;
-//     getAlgorithm(): string;
-// }
-
-// 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> {
-//         // Try primary adapter first
-//         try {
-//             return await this.primaryAdapter.verify(value, hashed);
-//         } catch (primaryErr: any) {
-//             logger.warn("⚠ Primary verify failed", {
-//                 error: primaryErr?.message,
-//             });
-
-//             // If 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."
-//             );
-//         }
-//     }
-// }
-
-
-// src/managers/HashManager.ts - COMPLETE FIXED
 import { AdapterError } from "../core/errors/AdapterError.js";
 import { HiSecureConfig } from "../core/types/HiSecureConfig.js";
 import { logger } from "../logging";
@@ -290,7 +5,6 @@ import { logger } from "../logging";
 interface HashAdapter {
     hash(value: string): Promise<string>;
     verify(value: string, hashed: string): Promise<boolean>;
-    // ❌ getAlgorithm() REMOVED - Not needed in adapters
 }
 
 export interface HashResult {