hi-secure 1.0.14 → 1.0.16

package/src/adapters/BcryptAdapter.ts

@@ -1,3 +1,52 @@
+// 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.");
+//         }
+//     }
+// }
+
+
+
+
+
 import bcrypt from "bcryptjs";
 import { AdapterError } from "../core/errors/AdapterError";
 import { logger } from "../logging";
@@ -14,8 +63,10 @@ export class BcryptAdapter {
             return await bcrypt.hash(value, this.saltRounds);
         } catch (err: any) {
             logger.error("Bcrypt hashing failed", {
-                error: err?.message || err,
-                saltRounds: this.saltRounds
+                adapter: "bcrypt",
+                operation: "hash",
+                saltRounds: this.saltRounds,
+                reason: err?.message
             });
 
             throw new AdapterError("Bcrypt hashing failed.");
@@ -35,15 +86,12 @@ export class BcryptAdapter {
             return await bcrypt.compare(value, hashed);
         } catch (err: any) {
             logger.error("Bcrypt verify failed", {
-                error: err?.message || err
+                adapter: "bcrypt",
+                operation: "verify",
+                reason: err?.message
             });
 
             throw new AdapterError("Bcrypt verify failed.");
         }
     }
 }
-
-
-
-
-

package/src/adapters/ExpressRLAdapter.ts

@@ -1,6 +1,54 @@
+// 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, 
+//                 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.");
+//         }
+//     }
+// }
+
+
+
 import rateLimit from "express-rate-limit";
-import { logger } from "../logging/index.js";
-import { AdapterError } from "../core/errors/AdapterError.js";
+import { logger } from "../logging";
+import { AdapterError } from "../core/errors/AdapterError";
 
 export interface RateLimitOptions {
     windowMs?: number;
@@ -16,7 +64,7 @@ export class ExpressRLAdapter {
     getMiddleware(options: RateLimitOptions = {}) {
         try {
             const defaultOptions = {
-                windowMs: 15 * 60 * 1000, 
+                windowMs: 15 * 60 * 1000,
                 max: 100,
                 message: { error: "Too many requests" },
                 standardHeaders: true,
@@ -25,21 +73,26 @@ export class ExpressRLAdapter {
             };
 
             const finalOptions = { ...defaultOptions, ...options };
-            
+
             const limiter = rateLimit(finalOptions);
+
             
-            logger.debug("Express rate limiter configured", {
+            logger.info("Express rate limiter configured", {
+                adapter: "express-rate-limit",
+                operation: "configure",
                 windowMs: finalOptions.windowMs,
                 max: finalOptions.max
             });
 
             return limiter;
-
         } catch (err: any) {
-            logger.error("ExpressRLAdapter: failed to create limiter", {
-                error: err?.message || err
+            logger.error("Express rate limiter setup failed", {
+                adapter: "express-rate-limit",
+                operation: "configure",
+                reason: err?.message
             });
+
             throw new AdapterError("Express rate limiter creation failed.");
         }
     }
-}
+}

package/src/adapters/ExpressValidatorAdapter.ts

@@ -1,6 +1,56 @@
+// import { validationResult } from "express-validator";
+// import { ValidationError } from "../core/errors/ValidationError.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();
+//             }
+//         ];
+//     }
+// }
+
+
+
+
 import { validationResult } from "express-validator";
-import { ValidationError } from "../core/errors/ValidationError.js"; 
-import { logger } from "../logging/index.js";
+import { ValidationError } from "../core/errors/ValidationError";
+import { logger } from "../logging";
 
 export class ExpressValidatorAdapter {
     private globalSchema?: any[];
@@ -23,24 +73,30 @@ export class ExpressValidatorAdapter {
                 const errors = validationResult(req);
 
                 if (!errors.isEmpty()) {
-                    const formatted = errors.array().map(err => ({
+                    const formattedErrors = errors.array().map(err => ({
                         message: err.msg,
-                        // param: err.param ,
-                        // location: err.location
+                        field: err.type
                     }));
 
-                    logger.warn("express-validator failed", {
-                        path: req.path,
+                    logger.warn("Request validation failed", {
+                        adapter: "express-validator",
+                        operation: "validate",
                         method: req.method,
-                        errors: formatted,
-                        preview: JSON.stringify(req.body).slice(0, 200)
+                        path: req.path,
+                        errorCount: formattedErrors.length,
+                        errors: formattedErrors,
+                        bodyPreview: req.body
+                            ? JSON.stringify(req.body).slice(0, 150)
+                            : undefined
                     });
 
-                    return next(new ValidationError("Validation failed.", formatted as any));
+                    return next(
+                        new ValidationError("Validation failed.", formattedErrors as any)
+                    );
                 }
 
                 next();
             }
         ];
     }
-}
+}

package/src/adapters/GoogleAdapter.ts

@@ -1,7 +1,88 @@
-import { OAuth2Client, LoginTicket } from "google-auth-library";
-import { AdapterError } from "../core/errors/AdapterError.js";
+// import { OAuth2Client, LoginTicket } from "google-auth-library";
+// import { AdapterError } from "../core/errors/AdapterError.js";
+
+// import {logger} from '../logging';
+
+// 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 
+//             };
+
+//             // 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) {
+//                 logger.warn("GoogleAdapter: Empty payload");
+//                 throw new AdapterError("Invalid Google ID token payload.");
+//             }
+
+//             // result object
+//             const result: GoogleTokenPayload = {
+//                 sub: payload.sub,
+//                 email: payload.email || '',
+//                 email_verified: payload.email_verified || false,
+//                 name: payload.name,
+//                 picture: payload.picture
+//             };
+
+//             // remaining properties from payload 
+//             const { sub, email, email_verified, name, picture, ...rest } = payload;
+//             Object.assign(result, rest);
+
+//             return result;
+
+//         } catch (err: any) {
+//             logger.error("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");
+//         }
+//     }
+// }
+
+
 
-import {logger} from '../logging';
+import { OAuth2Client, LoginTicket } from "google-auth-library";
+import { AdapterError } from "../core/errors/AdapterError";
+import { logger } from "../logging";
 
 export interface GoogleTokenPayload {
     sub: string;
@@ -20,60 +101,64 @@ export class GoogleAdapter {
         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') {
+            if (!idToken || typeof idToken !== "string") {
                 throw new AdapterError("Invalid ID token provided");
             }
 
-            const options: { idToken: string; audience?: string | string[] } = { 
-                idToken 
+            const options: { idToken: string; audience?: string | string[] } = {
+                idToken
             };
 
-            // 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) {
-                logger.warn("GoogleAdapter: Empty payload");
+                logger.warn("Google ID token payload empty", {
+                    adapter: "google-auth",
+                    operation: "verifyIdToken",
+                    hasClientId: !!this.clientId
+                });
+
                 throw new AdapterError("Invalid Google ID token payload.");
             }
 
-            // result object
             const result: GoogleTokenPayload = {
                 sub: payload.sub,
-                email: payload.email || '',
+                email: payload.email || "",
                 email_verified: payload.email_verified || false,
                 name: payload.name,
                 picture: payload.picture
             };
 
-            // remaining properties from payload 
             const { sub, email, email_verified, name, picture, ...rest } = payload;
             Object.assign(result, rest);
 
             return result;
 
         } catch (err: any) {
-            logger.error("GoogleAdapter.verifyIdToken failed", { 
-                error: err?.message,
-                hasClientId: !!this.clientId 
+            logger.error("Google ID token verification failed", {
+                adapter: "google-auth",
+                operation: "verifyIdToken",
+                hasClientId: !!this.clientId,
+                reason: err?.message
             });
-            
-            if (err.message?.includes('audience')) {
+
+            if (err?.message?.includes("audience")) {
                 throw new AdapterError("Invalid Google client ID configured.");
             }
-            
-            throw new AdapterError(err?.message || "Google token verification failed");
+
+            throw new AdapterError("Google token verification failed.");
         }
     }
-}
+}

package/src/adapters/JWTAdapter.ts

@@ -1,7 +1,102 @@
+// import jwt from "jsonwebtoken";
+// import { randomUUID } from "crypto"; 
+// import { AdapterError } from "../core/errors/AdapterError.js";
+// import { logError } from "../logging/index.js";
+// import { logger } from "../logging";
+
+// export interface JWTAdapterOptions {
+//     secret: string;
+//     expiresIn?: string | number;
+//     algorithm?: jwt.Algorithm;
+//     issuer?: string;
+//     audience?: string | string[];
+// }
+
+// export interface SignOptions {
+//     expiresIn?: string | number;
+//     jti?: string; 
+//     subject?: string;
+//     issuer?: string;
+//     audience?: string | string[];
+// }
+
+// export class JWTAdapter {
+//     private secret: string;
+//     private expiresIn?: string | number;
+//     private algorithm: jwt.Algorithm;
+//     private issuer?: string;
+//     private audience?: string | string[];
+
+//     constructor(options: JWTAdapterOptions) {
+//         if (!options.secret) {
+//             throw new AdapterError("JWT secret is required");
+//         }
+
+//         if (options.secret.length < 32) {
+//             logger.warn("JWT secret shorter than 32 chars. Consider using stronger secret.");
+//             // logError("JWT secret is too short (minimum 32 characters recommended)");
+//         }
+
+//         this.secret = options.secret;
+//         this.expiresIn = options.expiresIn;
+//         this.algorithm = options.algorithm || 'HS256'; // Default algorithm 
+//         this.issuer = options.issuer;
+//         this.audience = options.audience;
+//     }
+
+//     sign(payload: object, options?: SignOptions) {
+//         try {
+//             const jwtOptions: jwt.SignOptions = {
+//                 algorithm: this.algorithm,
+//                 issuer: options?.issuer || this.issuer,
+//                 audience: options?.audience || this.audience,
+//                 jwtid: options?.jti || randomUUID(), 
+//                 subject: options?.subject
+//             };
+
+//             if (options?.expiresIn !== undefined) {
+//                 jwtOptions.expiresIn = options.expiresIn as number;
+//             } else if (this.expiresIn !== undefined) {
+//                 jwtOptions.expiresIn = this.expiresIn as number;
+//             }
+
+//             return jwt.sign(payload, this.secret, jwtOptions);
+
+//         } catch (err: any) {
+//             logError("JWTAdapter.sign failed", { error: err?.message });
+//             throw new AdapterError(err?.message || "JWT sign failed");
+//         }
+//     }
+
+//     verify(token: string, options?: { audience?: string | string[] }) {
+//         try {
+//             const verifyOptions: jwt.VerifyOptions = {
+//                 algorithms: [this.algorithm],
+//                 issuer: this.issuer,
+//                 audience: options?.audience as string || this.audience as string
+//             };
+
+//             return jwt.verify(token, this.secret, verifyOptions);
+//         } catch (err: any) {
+//             logError("JWTAdapter.verify failed", { error: err?.message });
+            
+           
+//             if (err.name === 'TokenExpiredError') {
+//                 throw new AdapterError("JWT token has expired");
+//             }
+//             if (err.name === 'JsonWebTokenError') {
+//                 throw new AdapterError("Invalid JWT token");
+//             }
+            
+//             throw new AdapterError(err?.message || "JWT verification failed");
+//         }
+//     }
+// }
+
+
 import jwt from "jsonwebtoken";
-import { randomUUID } from "crypto"; 
-import { AdapterError } from "../core/errors/AdapterError.js";
-import { logError } from "../logging/index.js";
+import { randomUUID } from "crypto";
+import { AdapterError } from "../core/errors/AdapterError";
 import { logger } from "../logging";
 
 export interface JWTAdapterOptions {
@@ -14,7 +109,7 @@ export interface JWTAdapterOptions {
 
 export interface SignOptions {
     expiresIn?: string | number;
-    jti?: string; 
+    jti?: string;
     subject?: string;
     issuer?: string;
     audience?: string | string[];
@@ -33,13 +128,16 @@ export class JWTAdapter {
         }
 
         if (options.secret.length < 32) {
-            logger.warn("JWT secret shorter than 32 chars. Consider using stronger secret.");
-            // logError("JWT secret is too short (minimum 32 characters recommended)");
+            logger.warn("Weak JWT secret detected", {
+                adapter: "jwt",
+                operation: "init",
+                secretLength: options.secret.length
+            });
         }
 
         this.secret = options.secret;
         this.expiresIn = options.expiresIn;
-        this.algorithm = options.algorithm || 'HS256'; // Default algorithm 
+        this.algorithm = options.algorithm || "HS256";
         this.issuer = options.issuer;
         this.audience = options.audience;
     }
@@ -50,21 +148,26 @@ export class JWTAdapter {
                 algorithm: this.algorithm,
                 issuer: options?.issuer || this.issuer,
                 audience: options?.audience || this.audience,
-                jwtid: options?.jti || randomUUID(), 
+                jwtid: options?.jti || randomUUID(),
                 subject: options?.subject
             };
 
             if (options?.expiresIn !== undefined) {
-                jwtOptions.expiresIn = options.expiresIn as number;
+                jwtOptions.expiresIn = options.expiresIn as any;
             } else if (this.expiresIn !== undefined) {
-                jwtOptions.expiresIn = this.expiresIn as number;
+                jwtOptions.expiresIn = this.expiresIn as any;
             }
 
             return jwt.sign(payload, this.secret, jwtOptions);
 
         } catch (err: any) {
-            logError("JWTAdapter.sign failed", { error: err?.message });
-            throw new AdapterError(err?.message || "JWT sign failed");
+            logger.error("JWT signing failed", {
+                adapter: "jwt",
+                operation: "sign",
+                reason: err?.message
+            });
+
+            throw new AdapterError("JWT sign failed");
         }
     }
 
@@ -73,22 +176,27 @@ export class JWTAdapter {
             const verifyOptions: jwt.VerifyOptions = {
                 algorithms: [this.algorithm],
                 issuer: this.issuer,
-                audience: options?.audience as string || this.audience as string
+                audience: (options?.audience || this.audience) as string
             };
 
             return jwt.verify(token, this.secret, verifyOptions);
+
         } catch (err: any) {
-            logError("JWTAdapter.verify failed", { error: err?.message });
-            
-           
-            if (err.name === 'TokenExpiredError') {
+            logger.error("JWT verification failed", {
+                adapter: "jwt",
+                operation: "verify",
+                reason: err?.message
+            });
+
+            if (err?.name === "TokenExpiredError") {
                 throw new AdapterError("JWT token has expired");
             }
-            if (err.name === 'JsonWebTokenError') {
+
+            if (err?.name === "JsonWebTokenError") {
                 throw new AdapterError("Invalid JWT token");
             }
-            
-            throw new AdapterError(err?.message || "JWT verification failed");
+
+            throw new AdapterError("JWT verification failed");
         }
     }
-}
+}