hi-secure 1.0.0

package/src/middlewares/errorHandler.ts

@@ -0,0 +1,265 @@
+// import { Request, Response, NextFunction } from "express";
+// import { logger } from "../logging";
+// import { AdapterError } from "../core/errors/AdapterError";
+// import { ValidationError } from "../core/errors/ValidationError";
+// import { SanitizerError } from "../core/errors/SanitizerError";
+// import { SecurityError } from "../core/errors/SecurityError";
+
+// export function errorHandler(
+//     err: any,
+//     req: Request,
+//     res: Response,
+//     _next: NextFunction
+// ) {
+//     // Normalize unknown errors
+//     const errorMessage =
+//         typeof err === "string"
+//             ? err
+//             : err?.message || "Unknown error occurred";
+
+//     const errorStack =
+//         err instanceof Error && err.stack
+//             ? err.stack.split("\n").slice(0, 2).join(" | ")
+//             : undefined;
+
+//     // Log error centrally
+//     logger.error("❌ HiSecure Error Captured", {
+//         message: errorMessage,
+//         path: req.path,
+//         method: req.method,
+//         stack: errorStack,
+//         raw: err
+//     });
+
+//     // ------------------------------
+//     // CLASSIFIED ERROR RESPONSES
+//     // ------------------------------
+
+//     if (err instanceof ValidationError) {
+//         return res.status(400).json({
+//             success: false,
+//             error: "VALIDATION_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     if (err instanceof SanitizerError) {
+//         return res.status(400).json({
+//             success: false,
+//             error: "SANITIZER_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     if (err instanceof AdapterError) {
+//         return res.status(500).json({
+//             success: false,
+//             error: "ADAPTER_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     if (err instanceof SecurityError) {
+//         return res.status(500).json({
+//             success: false,
+//             error: "SECURITY_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     // ------------------------------
+//     // UNEXPECTED ERROR
+//     // ------------------------------
+//     return res.status(500).json({
+//         success: false,
+//         error: "INTERNAL_SERVER_ERROR",
+//         message: "An unexpected error occurred in HiSecure middleware."
+//     });
+// }
+
+
+
+
+// import { Request, Response, NextFunction } from "express";
+// import { logger } from "../logging";
+// import { AdapterError } from "../core/errors/AdapterError";
+// import { ValidationError } from "../core/errors/ValidationError";
+// import { SanitizerError } from "../core/errors/SanitizerError";
+// import { SecurityError } from "../core/errors/SecurityError";
+
+// export function errorHandler(
+//     err: any,
+//     req: Request,
+//     res: Response,
+//     _next: NextFunction
+// ) {
+//     // Normalize unknown errors
+//     const errorMessage =
+//         typeof err === "string"
+//             ? err
+//             : err?.message || "Unknown error occurred";
+
+//     const errorStack =
+//         err instanceof Error && err.stack
+//             ? err.stack.split("\n").slice(0, 2).join(" | ")
+//             : undefined;
+
+//     // Log error centrally
+//     logger.error("❌ HiSecure Error Captured", {
+//         message: errorMessage,
+//         path: req.path,
+//         method: req.method,
+//         stack: errorStack,
+//         raw: err
+//     });
+
+//     // ------------------------------
+//     // CLASSIFIED ERROR RESPONSES
+//     // ------------------------------
+
+//     if (err instanceof ValidationError) {
+//         return res.status(400).json({
+//             success: false,
+//             error: "VALIDATION_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     if (err instanceof SanitizerError) {
+//         return res.status(400).json({
+//             success: false,
+//             error: "SANITIZER_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     if (err instanceof AdapterError) {
+//         return res.status(500).json({
+//             success: false,
+//             error: "ADAPTER_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     if (err instanceof SecurityError) {
+//         return res.status(500).json({
+//             success: false,
+//             error: "SECURITY_ERROR",
+//             message: errorMessage
+//         });
+//     }
+
+//     // ------------------------------
+//     // UNEXPECTED ERROR
+//     // ------------------------------
+//     return res.status(500).json({
+//         success: false,
+//         error: "INTERNAL_SERVER_ERROR",
+//         message: "An unexpected error occurred in HiSecure middleware."
+//     });
+// }
+
+
+
+import { Request, Response, NextFunction } from "express";
+import { logger } from "../logging";
+
+import { AdapterError } from "../core/errors/AdapterError.js";
+import { ValidationError } from "../core/errors/ValidationError.js";
+import { SanitizerError } from "../core/errors/SanitizerError.js";
+import { SecurityError } from "../core/errors/SecurityError.js";
+import { HttpError } from "../core/errors/HttpErrror.js";
+
+export function errorHandler(
+    err: any,
+    req: Request,
+    res: Response,
+    _next: NextFunction
+) {
+    const message =
+        typeof err === "string"
+            ? err
+            : err?.message || "Unknown error";
+
+    const stack =
+        err instanceof Error && err.stack
+            ? err.stack.split("\n").slice(0, 2).join(" | ")
+            : undefined;
+
+    // Unified logging
+    logger.error("❌ HiSecure Error", {
+        type: err?.name || "UnknownError",
+        message,
+        status: err?.status,
+        code: err?.code,
+        path: req.path,
+        method: req.method,
+        stack,
+        raw: err,
+    });
+
+    // ---------------------------------------------------
+    // 1. HttpError (developer thrown)
+    // ---------------------------------------------------
+    if (err instanceof HttpError) {
+        return res.status(err.status).json({
+            success: false,
+            error: err.code,
+            message: err.message,
+            details: err.details || undefined,
+        });
+    }
+
+    // ---------------------------------------------------
+    // 2. Validation Errors
+    // ---------------------------------------------------
+    if (err instanceof ValidationError) {
+        return res.status(400).json({
+            success: false,
+            error: "VALIDATION_ERROR",
+            message,
+        });
+    }
+
+    // ---------------------------------------------------
+    // 3. Sanitizer Errors
+    // ---------------------------------------------------
+    if (err instanceof SanitizerError) {
+        return res.status(400).json({
+            success: false,
+            error: "SANITIZER_ERROR",
+            message,
+        });
+    }
+
+    // ---------------------------------------------------
+    // 4. Adapter Errors (hashing, rate-limit, sanitizer, validator ...)
+    // ---------------------------------------------------
+    if (err instanceof AdapterError) {
+        return res.status(500).json({
+            success: false,
+            error: "ADAPTER_ERROR",
+            message,
+        });
+    }
+
+    // ---------------------------------------------------
+    // 5. Security Errors (internal library security logic)
+    // ---------------------------------------------------
+    if (err instanceof SecurityError) {
+        return res.status(500).json({
+            success: false,
+            error: "SECURITY_ERROR",
+            message,
+        });
+    }
+
+    // ---------------------------------------------------
+    // 6. Fallback → Unexpected
+    // ---------------------------------------------------
+    return res.status(500).json({
+        success: false,
+        error: "INTERNAL_SERVER_ERROR",
+        message: "An unexpected error occurred in HiSecure.",
+    });
+}

package/src/middlewares/index.ts

@@ -0,0 +1,2 @@
+export * from "./requestLogger.js";
+export * from "./errorHandler.js";

package/src/middlewares/requestLogger.ts

@@ -0,0 +1,5 @@
+import { requestLogger } from "../logging";
+
+export function httpLogger() {
+    return requestLogger;
+}

package/src/test/t1.ts

@@ -0,0 +1 @@
+// dekhete hai baad mein

package/src/utils/deepFreeze.ts

@@ -0,0 +1,76 @@
+// export function deepFreeze<T>(obj: T): T {
+//     // Freeze the top level object
+//     Object.freeze(obj);
+
+//     // Now recursively freeze nested objects
+//     Object.getOwnPropertyNames(obj).forEach((prop) => {
+//         // @ts-ignore
+//         const value = obj[prop];
+
+//         if (
+//             value &&
+//             (typeof value === "object" || typeof value === "function") &&
+//             !Object.isFrozen(value)
+//         ) {
+//             deepFreeze(value); // recursive freeze
+//         }
+//     });
+
+//     return obj;
+// }
+
+
+
+
+export function deepFreeze<T>(obj: T, visited = new WeakSet()): T {
+    // Handle primitives and null/undefined
+    if (obj === null || obj === undefined) return obj;
+    if (typeof obj !== 'object' && typeof obj !== 'function') return obj;
+    
+    // Handle circular references
+    if (visited.has(obj)) return obj;
+    visited.add(obj);
+    
+    // Don't freeze built-in objects that shouldn't be frozen
+    const constructor = obj.constructor;
+    const builtIns = [Date, RegExp, Map, Set, WeakMap, WeakSet, Promise];
+    if (builtIns.some(builtIn => obj instanceof builtIn)) {
+        return obj;
+    }
+    
+    // Don't freeze functions
+    if (typeof obj === 'function') return obj;
+    
+    // Freeze the object itself
+    Object.freeze(obj);
+    
+    // Freeze array elements
+    if (Array.isArray(obj)) {
+        for (const item of obj) {
+            if (item && typeof item === 'object') {
+                deepFreeze(item, visited);
+            }
+        }
+        return obj;
+    }
+    
+    // Freeze object properties
+    const props = Object.getOwnPropertyNames(obj);
+    for (const prop of props) {
+        const value = (obj as any)[prop];
+        if (value && typeof value === 'object') {
+            deepFreeze(value, visited);
+        }
+    }
+    
+    // Freeze symbol properties
+    const symbols = Object.getOwnPropertySymbols(obj);
+    for (const sym of symbols) {
+        const value = (obj as any)[sym];
+        if (value && typeof value === 'object') {
+            deepFreeze(value, visited);
+        }
+    }
+    
+    return obj;
+}

package/src/utils/deepMerge.ts

@@ -0,0 +1,87 @@
+// export function deepMerge<T>(target: T, source: Partial<T>): T {
+//   if (!source) return target;
+
+//   const output: any = Array.isArray(target) ? [...(target as any)] : { ...(target as any) };
+
+//   for (const key of Object.keys(source) as Array<keyof typeof source>) {
+//     const sourceValue = (source as any)[key];
+//     const targetValue = (target as any)[key];
+
+//     const shouldRecurse =
+//       sourceValue &&
+//       typeof sourceValue === "object" &&
+//       !Array.isArray(sourceValue) &&
+//       targetValue &&
+//       typeof targetValue === "object";
+
+//     if (shouldRecurse) {
+//       output[key] = deepMerge(targetValue, sourceValue);
+//     } else {
+//       output[key] = sourceValue;
+//     }
+//   }
+
+//   return output;
+// }
+
+
+
+
+export function deepMerge<T extends object, U extends Partial<T>>(
+    target: T,
+    source: U,
+    options: { mergeArrays?: boolean; skipUndefined?: boolean } = {}
+): T & U {
+    const { mergeArrays = false, skipUndefined = true } = options;
+    
+    if (!source || typeof source !== 'object') {
+        return target as T & U;
+    }
+    
+    const output: any = Array.isArray(target) 
+        ? [...target] 
+        : { ...target };
+    
+    for (const key in source) {
+        if (!source.hasOwnProperty(key)) continue;
+        
+        const sourceValue = (source as any)[key];
+        const targetValue = (target as any)[key];
+        
+        // Skip undefined values if configured
+        if (skipUndefined && sourceValue === undefined) continue;
+        
+        // Handle null explicitly
+        if (sourceValue === null) {
+            output[key] = null;
+            continue;
+        }
+        
+        // Merge arrays if option enabled
+        if (mergeArrays && Array.isArray(targetValue) && Array.isArray(sourceValue)) {
+            output[key] = [...targetValue, ...sourceValue];
+            continue;
+        }
+        
+        // Recursive merge for plain objects
+        if (sourceValue && typeof sourceValue === 'object' &&
+            targetValue && typeof targetValue === 'object' &&
+            !Array.isArray(sourceValue) && !Array.isArray(targetValue) &&
+            sourceValue.constructor === Object && targetValue.constructor === Object) {
+            
+            output[key] = deepMerge(targetValue, sourceValue, options);
+            continue;
+        }
+        
+        // Overwrite for everything else
+        output[key] = sourceValue;
+    }
+    
+    // Handle symbol properties
+    const symbols = Object.getOwnPropertySymbols(source);
+    for (const sym of symbols) {
+        output[sym] = (source as any)[sym];
+    }
+    
+    return output as T & U;
+}