hi-secure 1.0.0

package/src/adapters/ArgonAdapter.ts

@@ -0,0 +1,41 @@
+import argon2 from "argon2";
+import { AdapterError } from "../core/errors/AdapterError";
+import { logger } from "../logging";
+
+export class ArgonAdapter {
+    private options: argon2.Options | undefined;
+
+    constructor(options?: argon2.Options) {
+        if (options) {
+            this.options = options;
+        }
+    }
+
+    async hash(value: string): Promise<string> {
+        try {
+            return this.options
+                ? await argon2.hash(value, this.options)
+                : await argon2.hash(value); // avoid passing undefined
+        } catch (err: any) {
+            logger.error("❌ Argon2 hashing failed", {
+                error: err?.message || err
+            });
+            throw new AdapterError("Argon2 hashing failed.");
+        }
+    }
+
+    async verify(value: string, hashed: string): Promise<boolean> {
+        try {
+            if (!hashed || typeof hashed !== "string") {
+                throw new AdapterError("Invalid hash provided for verification.");
+            }
+
+            return await argon2.verify(hashed, value);
+        } catch (err: any) {
+            logger.error("❌ Argon2 verify failed", {
+                error: err?.message || err
+            });
+            throw new AdapterError("Argon2 verify failed.");
+        }
+    }
+}

package/src/adapters/BcryptAdapter.ts

@@ -0,0 +1,49 @@
+import bcrypt from "bcryptjs";
+import { AdapterError } from "../core/errors/AdapterError";
+import { logger } from "../logging";
+
+export class BcryptAdapter {
+    constructor(private saltRounds: number = 10) {}
+
+    async hash(value: string): Promise<string> {
+        try {
+            if (typeof value !== "string") {
+                throw new AdapterError("Value to hash must be a string.");
+            }
+
+            return await bcrypt.hash(value, this.saltRounds);
+        } catch (err: any) {
+            logger.error("❌ Bcrypt hashing failed", {
+                error: err?.message || err,
+                saltRounds: this.saltRounds
+            });
+
+            throw new AdapterError("Bcrypt hashing failed.");
+        }
+    }
+
+    async verify(value: string, hashed: string): Promise<boolean> {
+        try {
+            if (typeof value !== "string") {
+                throw new AdapterError("Value to verify must be a string.");
+            }
+
+            if (!hashed || typeof hashed !== "string") {
+                throw new AdapterError("Invalid hashed string provided.");
+            }
+
+            return await bcrypt.compare(value, hashed);
+        } catch (err: any) {
+            logger.error("❌ Bcrypt verify failed", {
+                error: err?.message || err
+            });
+
+            throw new AdapterError("Bcrypt verify failed.");
+        }
+    }
+}
+
+
+
+
+

package/src/adapters/ExpressRLAdapter.ts

@@ -0,0 +1,84 @@
+// import rateLimit from "express-rate-limit";
+// import { logger } from "../logging";
+// import { AdapterError } from "../core/errors/AdapterError";
+
+// export class ExpressRLAdapter {
+
+//     /**
+//      * Create express rate-limit middleware dynamically
+//      */
+//     getMiddleware(options: {
+//         windowMs?: number;
+//         max?: number;
+//         message?: any;
+//     } = {}) {
+
+//         try {
+//             const limiter = rateLimit({
+//                 windowMs: options.windowMs ?? 15 * 60 * 1000, // default
+//                 max: options.max ?? 100,
+//                 message: options.message ?? { error: "Too many requests" },
+//                 standardHeaders: true,
+//                 legacyHeaders: false,
+//             });
+
+//             return limiter;
+
+//         } catch (err: any) {
+//             logger.error("❌ ExpressRLAdapter: failed to create limiter", {
+//                 error: err?.message || err
+//             });
+//             throw new AdapterError("Express rate limiter creation failed.");
+//         }
+//     }
+// }
+
+
+
+
+// src/adapters/ExpressRLAdapter.ts - IMPROVED
+import rateLimit from "express-rate-limit";
+import { logger } from "../logging/index.js";
+import { AdapterError } from "../core/errors/AdapterError.js";
+
+export interface RateLimitOptions {
+    windowMs?: number;
+    max?: number;
+    message?: any;
+    skipFailedRequests?: boolean;
+    standardHeaders?: boolean;
+    legacyHeaders?: boolean;
+    [key: string]: any;
+}
+
+export class ExpressRLAdapter {
+    getMiddleware(options: RateLimitOptions = {}) {
+        try {
+            const defaultOptions = {
+                windowMs: 15 * 60 * 1000, // 15 minutes
+                max: 100,
+                message: { error: "Too many requests" },
+                standardHeaders: true,
+                legacyHeaders: false,
+                skipFailedRequests: false
+            };
+
+            const finalOptions = { ...defaultOptions, ...options };
+            
+            const limiter = rateLimit(finalOptions);
+            
+            logger.debug("📌 Express rate limiter configured", {
+                windowMs: finalOptions.windowMs,
+                max: finalOptions.max
+            });
+
+            return limiter;
+
+        } catch (err: any) {
+            logger.error("❌ ExpressRLAdapter: failed to create limiter", {
+                error: err?.message || err
+            });
+            throw new AdapterError("Express rate limiter creation failed.");
+        }
+    }
+}

package/src/adapters/ExpressValidatorAdapter.ts

@@ -0,0 +1,99 @@
+// import { validationResult } from "express-validator";
+// import { ValidationError } from "../core/errors/ValidationError";
+// import { logger } from "../logging";
+
+// export class ExpressValidatorAdapter {
+//     private globalSchema?: any[];
+
+//     constructor(globalSchema?: any[]) {
+//         this.globalSchema = globalSchema as any;;
+//     }
+
+//     /**
+//      * Dynamic schema override
+//      */
+//     validate(dynamicSchema?: any[]) {
+//         const schema = dynamicSchema || this.globalSchema;
+
+//         if (!schema || !Array.isArray(schema)) {
+//             return (req: any, res: any, next: any) => next();
+//         }
+
+//         return [
+//             ...schema,
+
+//             (req: any, res: any, next: any) => {
+//                 const errors = validationResult(req);
+
+//                 if (!errors.isEmpty()) {
+//                     const formatted = errors.array().map(err => ({
+//                         message: err.msg,
+//                     }));
+
+//                     logger.warn("⚠ express-validator failed", {
+//                         path: req.path,
+//                         method: req.method,
+//                         errors: formatted,
+//                         preview: JSON.stringify(req.body).slice(0, 200)
+//                     });
+
+//                     return next(new ValidationError("Validation failed."));
+//                 }
+
+//                 next();
+//             }
+//         ];
+//     }
+// }
+
+
+
+
+
+// src/adapters/ExpressValidatorAdapter.ts - FIXED
+import { validationResult } from "express-validator";
+import { ValidationError } from "../core/errors/ValidationError.js"; // ✅ Add .js
+import { logger } from "../logging/index.js";
+
+export class ExpressValidatorAdapter {
+    private globalSchema?: any[];
+
+    constructor(globalSchema?: any[]) {
+        this.globalSchema = globalSchema;
+    }
+
+    validate(dynamicSchema?: any[]) {
+        const schema = dynamicSchema || this.globalSchema;
+
+        if (!schema || !Array.isArray(schema)) {
+            return (req: any, res: any, next: any) => next();
+        }
+
+        return [
+            ...schema,
+
+            (req: any, res: any, next: any) => {
+                const errors = validationResult(req);
+
+                if (!errors.isEmpty()) {
+                    const formatted = errors.array().map(err => ({
+                        message: err.msg,
+                        // param: err.param ,
+                        // location: err.location
+                    }));
+
+                    logger.warn("⚠ express-validator failed", {
+                        path: req.path,
+                        method: req.method,
+                        errors: formatted,
+                        preview: JSON.stringify(req.body).slice(0, 200)
+                    });
+
+                    return next(new ValidationError("Validation failed.", formatted as any));
+                }
+
+                next();
+            }
+        ];
+    }
+}

package/src/adapters/GoogleAdapter.ts

@@ -0,0 +1,206 @@
+// // import { OAuth2Client, LoginTicket } from "google-auth-library";
+// // import { AdapterError } from "../core/errors/AdapterError";
+// // import { logWarn, logError } from "../logging";
+
+// // export class GoogleAdapter {
+// //     private client: OAuth2Client;
+// //     private clientId?: string;
+
+// //     constructor(clientId?: string) {
+// //         this.client = new OAuth2Client(clientId);
+// //         this.clientId = clientId as any;
+// //     }
+
+// //     async verifyIdToken(idToken: string) {
+// //         try {
+// //             const options: {
+// //                 idToken: string;
+// //                 audience?: string | string[];
+// //             } = { idToken };
+
+// //             // ADD ONLY IF DEFINED → FIXES TS ERROR
+// //             if (this.clientId !== undefined) {
+// //                 options.audience = this.clientId;
+// //             }
+
+// //             const ticket: LoginTicket = await this.client.verifyIdToken(options);
+
+// //             const payload = ticket.getPayload();
+// //             if (!payload) {
+// //                 logWarn("GoogleAdapter: Empty payload");
+// //                 throw new AdapterError("Invalid Google ID token payload.");
+// //             }
+
+// //             return {
+// //                 sub: payload.sub,
+// //                 email: payload.email,
+// //                 email_verified: payload.email_verified,
+// //                 name: payload.name,
+// //                 picture: payload.picture,
+// //             };
+
+// //         } catch (err: any) {
+// //             logError("GoogleAdapter.verifyIdToken failed", { error: err?.message });
+// //             throw new AdapterError(err?.message || "Google token verification failed");
+// //         }
+// //     }
+// // }
+
+
+
+
+// // src/adapters/GoogleAdapter.ts - IMPROVED
+// import { OAuth2Client, LoginTicket } from "google-auth-library";
+// import { AdapterError } from "../core/errors/AdapterError.js";
+// import { logWarn, logError } from "../logging/index.js";
+
+// export interface GoogleTokenPayload {
+//     sub: string;
+//     email: string;
+//     email_verified: boolean;
+//     name?: string;
+//     picture?: string;
+//     [key: string]: any;
+// }
+
+// export class GoogleAdapter {
+//     private client: OAuth2Client;
+//     private clientId?: string;
+
+//     constructor(clientId?: string) {
+//         if (clientId && clientId.trim().length === 0) {
+//             throw new AdapterError("Google clientId cannot be empty string");
+//         }
+        
+//         this.client = new OAuth2Client(clientId);
+//         this.clientId = clientId;
+//     }
+
+//     async verifyIdToken(idToken: string): Promise<GoogleTokenPayload> {
+//         try {
+//             if (!idToken || typeof idToken !== 'string') {
+//                 throw new AdapterError("Invalid ID token provided");
+//             }
+
+//             const options: { idToken: string; audience?: string | string[] } = { 
+//                 idToken 
+//             };
+
+//             // Add audience only if clientId is provided and not empty
+//             if (this.clientId && this.clientId.trim().length > 0) {
+//                 options.audience = this.clientId;
+//             }
+
+//             const ticket: LoginTicket = await this.client.verifyIdToken(options);
+//             const payload = ticket.getPayload();
+            
+//             if (!payload) {
+//                 logWarn("GoogleAdapter: Empty payload");
+//                 throw new AdapterError("Invalid Google ID token payload.");
+//             }
+
+//             return {
+//                 sub: payload.sub,
+//                 email: payload.email || '',
+//                 email_verified: payload.email_verified || false,
+//                 name: payload.name,
+//                 picture: payload.picture,
+//                 ...payload
+//             };
+
+//         } catch (err: any) {
+//             logError("GoogleAdapter.verifyIdToken failed", { 
+//                 error: err?.message,
+//                 hasClientId: !!this.clientId 
+//             });
+            
+//             if (err.message?.includes('audience')) {
+//                 throw new AdapterError("Invalid Google client ID configured.");
+//             }
+            
+//             throw new AdapterError(err?.message || "Google token verification failed");
+//         }
+//     }
+// }
+
+
+
+// src/adapters/GoogleAdapter.ts - FIXED
+import { OAuth2Client, LoginTicket } from "google-auth-library";
+import { AdapterError } from "../core/errors/AdapterError.js";
+import { logWarn, logError } from "../logging/index.js";
+
+export interface GoogleTokenPayload {
+    sub: string;
+    email: string;
+    email_verified: boolean;
+    name?: string;
+    picture?: string;
+    [key: string]: any;
+}
+
+export class GoogleAdapter {
+    private client: OAuth2Client;
+    private clientId?: string;
+
+    constructor(clientId?: string) {
+        if (clientId && clientId.trim().length === 0) {
+            throw new AdapterError("Google clientId cannot be empty string");
+        }
+        
+        this.client = new OAuth2Client(clientId);
+        this.clientId = clientId;
+    }
+
+    async verifyIdToken(idToken: string): Promise<GoogleTokenPayload> {
+        try {
+            if (!idToken || typeof idToken !== 'string') {
+                throw new AdapterError("Invalid ID token provided");
+            }
+
+            const options: { idToken: string; audience?: string | string[] } = { 
+                idToken 
+            };
+
+            // Add audience only if clientId is provided and not empty
+            if (this.clientId && this.clientId.trim().length > 0) {
+                options.audience = this.clientId;
+            }
+
+            const ticket: LoginTicket = await this.client.verifyIdToken(options);
+            const payload = ticket.getPayload();
+            
+            if (!payload) {
+                logWarn("GoogleAdapter: Empty payload");
+                throw new AdapterError("Invalid Google ID token payload.");
+            }
+
+            // Create result object
+            const result: GoogleTokenPayload = {
+                sub: payload.sub,
+                email: payload.email || '',
+                email_verified: payload.email_verified || false,
+                name: payload.name,
+                picture: payload.picture
+            };
+
+            // Add remaining properties from payload (excluding duplicates)
+            const { sub, email, email_verified, name, picture, ...rest } = payload;
+            Object.assign(result, rest);
+
+            return result;
+
+        } catch (err: any) {
+            logError("GoogleAdapter.verifyIdToken failed", { 
+                error: err?.message,
+                hasClientId: !!this.clientId 
+            });
+            
+            if (err.message?.includes('audience')) {
+                throw new AdapterError("Invalid Google client ID configured.");
+            }
+            
+            throw new AdapterError(err?.message || "Google token verification failed");
+        }
+    }
+}