hi-secure 1.0.0

package/src/core/config.ts

@@ -0,0 +1,156 @@
+
+
+// export interface HiSecureConfig {
+//     enableHelmet: boolean;
+//     enableHPP: boolean;
+//     enableCORS: boolean;
+//     enableSanitizer: boolean;
+//     enableRateLimiter: boolean;
+//     enableValidation: boolean;
+
+//     hashing: {
+//         primary: "argon2" | "bcrypt";
+//         fallback: "bcrypt" | null;
+//         saltRounds: number;
+//     };
+
+//     rateLimiter: {
+//         windowMs: number;
+//         maxRequests: number;
+//         message: string;
+//         useAdaptiveMode: boolean;
+//     };
+
+//     validation: {
+//         mode: "zod" | "express-validator";
+//         fallback: "express-validator" | null;
+//     };
+
+//     sanitizer: {
+//         allowedTags: string[];
+//         allowedAttributes: Record<string, string[]>;
+//     };
+
+//     logging: {
+//         enabled: boolean;
+//         level: "info" | "warn" | "error" | "debug";
+//     };
+
+//     /** 🔥 ADD THIS */
+//     auth: {
+//         enabled: boolean;
+//         jwtExpiresIn: string | number | undefined;
+//     };
+
+//     /** 🔥 optional configs for dynamic JSON/CORS */
+//     json?: any;
+//     urlencoded?: any;
+//     cors?: any;
+// }
+
+
+
+
+// export const defaultConfig: HiSecureConfig = {
+//     enableHelmet: true,
+//     enableHPP: true,
+//     enableCORS: true,
+//     enableSanitizer: true,
+//     enableRateLimiter: true,
+//     enableValidation: true,
+
+//     hashing: {
+//         primary: "argon2",
+//         fallback: "bcrypt",
+//         saltRounds: 10,
+//     },
+
+//     rateLimiter: {
+//         windowMs: 15 * 60 * 1000,
+//         maxRequests: 100,
+//         message: "Too many requests, please try again later.",
+//         useAdaptiveMode: false,
+//     },
+
+//     validation: {
+//         mode: "zod",
+//         fallback: "express-validator",
+//     },
+
+//     sanitizer: {
+//         allowedTags: ["b", "i", "em", "strong", "a"],
+//         allowedAttributes: { a: ["href"] },
+//     },
+
+//     logging: {
+//         enabled: true,
+//         level: "info",
+//     },
+
+//     /** 🔥 NEW AUTH CONFIG */
+//     auth: {
+//         enabled: false,            // user enables manually
+//         jwtExpiresIn: "1d",        // default value
+//     },
+
+//     /** Optional parser configs */
+//     json: {},
+//     urlencoded: { extended: true },
+//     cors: {},
+// };
+
+
+
+
+// src/core/config.ts
+import { HiSecureConfig } from "./types/HiSecureConfig";
+
+export const defaultConfig: HiSecureConfig = {
+    enableHelmet: true,
+    enableHPP: true,
+    enableCORS: true,
+    enableSanitizer: true,
+    enableRateLimiter: true,
+    enableValidation: true,
+    enableCompression: true,
+    
+    hashing: {
+        primary: "argon2",
+        fallback: "bcrypt",
+        saltRounds: 10,
+    },
+    
+    rateLimiter: {
+        windowMs: 15 * 60 * 1000,
+        maxRequests: 100,
+        message: "Too many requests, please try again later.",
+        useAdaptiveMode: false,
+    },
+    
+    validation: {
+        mode: "zod",
+        fallback: "express-validator",
+    },
+    
+    sanitizer: {
+        allowedTags: ["b", "i", "em", "strong", "a"],
+        allowedAttributes: { a: ["href"] },
+        fallback: 'escape',
+        primary: 'sanitize-html'
+    },
+    
+    logging: {
+        enabled: true,
+        level: "info",
+        maxSize: 5 * 1024 * 1024,
+    },
+    
+    auth: {
+        enabled: false,
+    },
+    
+    json: { limit: '1mb' },
+    urlencoded: { extended: true },
+    cors: {},
+    compression: {},
+};

package/src/core/constants.ts

@@ -0,0 +1,73 @@
+// export const LIB_NAME = "HiSecure";
+// export const LIB_VERSION = "1.0.0";
+
+// // Adapter Names
+// export const ADAPTERS = {
+//     HASHING_PRIMARY: "HASHING_PRIMARY",
+//     HASHING_FALLBACK: "HASHING_FALLBACK",
+//     RATE_LIMITER: "RATE_LIMITER",
+//     VALIDATOR: "VALIDATOR",
+//     SANITIZER: "SANITIZER"
+// } as const;
+
+// // Manager Names
+// export const MANAGERS = {
+//     HASH_MANAGER: "HASH_MANAGER",
+//     RATE_LIMIT_MANAGER: "RATE_LIMIT_MANAGER",
+//     VALIDATION_MANAGER: "VALIDATION_MANAGER",
+//     SANITIZER_MANAGER:"SANITIZER_MANAGER"
+// } as const;
+
+// // Error Codes
+// export const ERROR_CODES = {
+//     ADAPTER_FAILURE: "ADAPTER_FAILURE",
+//     VALIDATION_ERROR: "VALIDATION_ERROR",
+//     RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+//     SANITIZER_ERROR:"SANITIZER_ERROR",
+//     CONFIG_ERROR: "CONFIG_ERROR",
+//     UNKNOWN: "UNKNOWN"
+// } as const;
+
+
+
+// src/core/constants.ts
+export const LIB_NAME = "HiSecure";
+export const LIB_VERSION = "1.0.0";
+
+export const ADAPTERS = {
+    HASHING_PRIMARY: "HASHING_PRIMARY",
+    HASHING_FALLBACK: "HASHING_FALLBACK",
+    RATE_LIMITER: "RATE_LIMITER",
+    VALIDATOR: "VALIDATOR",
+    SANITIZER: "SANITIZER",
+    COMPRESSION: "COMPRESSION"
+} as const;
+
+export const MANAGERS = {
+    HASH_MANAGER: "HASH_MANAGER",
+    RATE_LIMIT_MANAGER: "RATE_LIMIT_MANAGER",
+    VALIDATION_MANAGER: "VALIDATION_MANAGER",
+    SANITIZER_MANAGER: "SANITIZER_MANAGER",
+    CORS_MANAGER: "CORS_MANAGER",
+    JSON_MANAGER: "JSON_MANAGER",
+    AUTH_MANAGER: "AUTH_MANAGER",
+    COMPRESSION_MANAGER: "COMPRESSION_MANAGER"
+} as const;
+
+export const ERROR_CODES = {
+    ADAPTER_FAILURE: "ADAPTER_FAILURE",
+    VALIDATION_ERROR: "VALIDATION_ERROR",
+    RATE_LIMIT_EXCEEDED: "RATE_LIMIT_EXCEEDED",
+    SANITIZER_ERROR: "SANITIZER_ERROR",
+    AUTH_ERROR: "AUTH_ERROR",
+    CONFIG_ERROR: "CONFIG_ERROR",
+    SECURITY_ERROR: "SECURITY_ERROR",
+    UNKNOWN: "UNKNOWN"
+} as const;
+
+export const PRESETS = {
+    API: 'api',
+    STRICT: 'strict',
+    PUBLIC: 'public',
+    DEFAULT: 'default'
+} as const;

package/src/core/errors/AdapterError.ts

@@ -0,0 +1,14 @@
+import { ERROR_CODES } from "../constants.js";
+
+export class AdapterError extends Error {
+    code: string;
+
+    constructor(message: string, code: string = ERROR_CODES.ADAPTER_FAILURE) {
+        super(message);
+        this.code = code;
+        this.name = "AdapterError";
+
+        // Capture stack trace properly
+        Error.captureStackTrace?.(this, AdapterError);
+    }
+}

package/src/core/errors/HttpErrror.ts

@@ -0,0 +1,46 @@
+export class HttpError extends Error {
+    status: number;
+    code?: string;
+    details?: any;
+
+    constructor(
+        status: number,
+        message: string,
+        options?: { code?:string; details?: any }
+    ) {
+        super(message);
+        this.status = status;
+        this.code = options?.code as string;
+        this.details = options?.details;
+        this.name = "HttpError";
+    }
+
+    // ---------- STATIC HELPERS ----------
+    static BadRequest(message = "Bad Request", details?: any) {
+        return new HttpError(400, message, { code: "BAD_REQUEST", details });
+    }
+
+    static Unauthorized(message = "Unauthorized", details?: any) {
+        return new HttpError(401, message, { code: "UNAUTHORIZED", details });
+    }
+
+    static Forbidden(message = "Forbidden", details?: any) {
+        return new HttpError(403, message, { code: "FORBIDDEN", details });
+    }
+
+    static NotFound(message = "Not Found", details?: any) {
+        return new HttpError(404, message, { code: "NOT_FOUND", details });
+    }
+
+    static Conflict(message = "Conflict", details?: any) {
+        return new HttpError(409, message, { code: "CONFLICT", details });
+    }
+
+    static TooManyRequests(message = "Too Many Requests", details?: any) {
+        return new HttpError(429, message, { code: "RATE_LIMIT", details });
+    }
+
+    static Internal(message = "Internal Server Error", details?: any) {
+        return new HttpError(500, message, { code: "INTERNAL_ERROR", details });
+    }
+}

package/src/core/errors/SanitizerError.ts

@@ -0,0 +1,13 @@
+import { ERROR_CODES } from "../constants.js";
+
+export class SanitizerError extends Error {
+    code: string;
+
+    constructor(message: string, code: string = ERROR_CODES.SANITIZER_ERROR) {
+        super(message);
+        this.code = code;
+        this.name = "SanitizerError";
+
+        Error.captureStackTrace?.(this, SanitizerError);
+    }
+}

package/src/core/errors/SecurityError.ts

@@ -0,0 +1,13 @@
+import { ERROR_CODES } from "../constants.js";
+
+export class SecurityError extends Error {
+    code: string;
+
+    constructor(message: string, code: string = ERROR_CODES.CONFIG_ERROR) {
+        super(message);
+        this.code = code;
+        this.name = "SecurityError";
+
+        Error.captureStackTrace?.(this, SecurityError);
+    }
+}

package/src/core/errors/ValidationError.ts

@@ -0,0 +1,13 @@
+import { ERROR_CODES } from "../constants.js";
+
+export class ValidationError extends Error {
+    code: string;
+
+    constructor(message: string, code: string = ERROR_CODES.VALIDATION_ERROR) {
+        super(message);
+        this.code = code;
+        this.name = "ValidationError";
+
+        Error.captureStackTrace?.(this, ValidationError);
+    }
+}

package/src/core/types/HiSecureConfig.ts

@@ -0,0 +1,62 @@
+// src/core/types/HiSecureConfig.ts
+export interface HiSecureConfig {
+    // Core security features
+    enableHelmet: boolean;
+    enableHPP: boolean;
+    enableCORS: boolean;
+    enableSanitizer: boolean;
+    enableRateLimiter: boolean;
+    enableValidation: boolean;
+    enableCompression: boolean;
+    
+    // Hashing configuration
+    hashing: {
+        primary: "argon2" | "bcrypt";
+        fallback: "bcrypt" | null;
+        saltRounds: number;
+    };
+    
+    // Rate limiting
+    rateLimiter: {
+        windowMs: number;
+        maxRequests: number;
+        message: string;
+        useAdaptiveMode: boolean;
+    };
+    
+    // Validation
+    validation: {
+        mode: "zod" | "express-validator";
+        fallback: "express-validator" | null;
+    };
+    
+    // Sanitization
+    sanitizer: {
+        allowedTags: string[];
+        allowedAttributes: Record<string, string[]>;
+        fallback: 'escape' | 'xss' | 'none';
+        primary: 'sanitize-html' | 'xss';
+    };
+    
+    // Logging
+    logging: {
+        enabled: boolean;
+        level: "info" | "warn" | "error" | "debug";
+        file?: string;
+        maxSize?: number;
+    };
+    
+    // Authentication
+    auth: {
+        enabled: boolean;
+        jwtSecret?: string;
+        jwtExpiresIn?: string | number;
+        googleClientId?: string;
+    };
+    
+    // Optional parsers
+    json?: object;
+    urlencoded?: object;
+    cors?: object;
+    compression?: object;
+}

package/src/core/types/SecureOptions.ts

@@ -0,0 +1,61 @@
+// // src/core/types/SecureOptions.ts
+
+// export interface SecureOptions {
+//     /** Enable/override CORS for this route */
+//     cors?: boolean | object;
+
+//     /** Per-route rate limit */
+//     rateLimit?: boolean | "strict" | "relaxed" | object;
+
+//     /** Sanitize request body */
+//     sanitize?: boolean;
+
+//     /** Validation schema (Zod or express-validator) */
+//     validate?: any;
+
+//     /** Auto-JSON parsing (express.json) options */
+//     json?: boolean | object;
+
+//     /** NEW: Per-route authentication (JWT protect) */
+//     auth?: boolean | { required?: boolean };
+// }
+
+
+
+
+
+// src/core/types/SecureOptions.ts
+import { z, ZodSchema } from 'zod';
+import { ValidationChain } from 'express-validator';
+
+export type ValidationSchema = ZodSchema | ValidationChain[];
+
+export interface RateLimitOptions {
+    windowMs?: number;
+    max?: number;
+    message?: string;
+    skipFailedRequests?: boolean;
+    [key: string]: any;
+}
+
+export interface SanitizeOptions {
+    allowedTags?: string[];
+    allowedAttributes?: Record<string, string[]>;
+    [key: string]: any;
+}
+
+export interface AuthOptions {
+    required?: boolean;
+    roles?: string[];
+}
+
+export interface SecureOptions {
+    cors?: boolean | object;
+    rateLimit?: boolean | "strict" | "relaxed" | RateLimitOptions;
+    sanitize?: boolean | SanitizeOptions;
+    validate?: ValidationSchema;
+    json?: boolean | object;
+    auth?: boolean | AuthOptions;
+    compression?: boolean | object;
+    headers?: boolean | object;
+}

package/src/core/useSecure.ts

@@ -0,0 +1,111 @@
+// import { normalizeOptions } from "../utils/normalizeOptions.js";
+// import { HiSecure } from "./HiSecure.js";
+
+// export function useSecure(engine: HiSecure, input?: any) {
+//     if (!engine.isInitialized()) {
+//         throw new Error("HiSecure must be initialized before using .use()");
+//     }
+
+//     const options = normalizeOptions(input);
+//     const chain: any[] = [];
+
+//     // JSON
+//     if (options.json.enabled) {
+//         chain.push(engine.jsonManager.middleware(options.json.options));
+//         chain.push(engine.jsonManager.urlencoded());
+//     }
+
+//     // CORS
+//     if (options.cors.enabled) {
+//         chain.push(engine.corsManager.middleware(options.cors.options));
+//     }
+
+//     // Sanitize
+//     if (options.sanitize.enabled) {
+//         chain.push(engine.sanitizerManager.middleware());
+//     }
+
+//     // Validate
+//     if (options.validate.enabled && options.validate.schema) {
+//         chain.push(engine.validatorManager.validate(options.validate.schema));
+//     }
+
+//     // Rate Limit
+//     if (options.rateLimit.enabled) {
+//         chain.push(
+//             engine.rateLimitManager.middleware({
+//                 mode: options.rateLimit.mode ?? undefined,
+//                 options: options.rateLimit.options ?? undefined
+//             })
+//         );
+//     }
+
+//     // AUTH
+//     if (options.auth.enabled) {
+//         if (!engine.authManager) {
+//             throw new Error("AuthManager not initialized. Enable auth in config.");
+//         }
+
+//         chain.push(
+//             engine.authManager.protect({
+//                 required: options.auth.required
+//             })
+//         );
+//     }
+
+//     return chain;
+// }
+
+
+
+// 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
+ */
+export function secureRoute(options?: SecureOptions) {
+    const chain: any[] = [];
+    
+    if (options?.cors) {
+        chain.push(HiSecure.cors(
+            typeof options.cors === 'object' ? options.cors : undefined
+        ));
+    }
+    
+    if (options?.rateLimit) {
+        chain.push(HiSecure.rateLimit(
+            typeof options.rateLimit === 'object' ? options.rateLimit : 
+            options.rateLimit === "strict" ? "strict" : "relaxed"
+        ));
+    }
+    
+    if (options?.sanitize) {
+        chain.push(HiSecure.sanitize(
+            typeof options.sanitize === 'object' ? options.sanitize : undefined
+        ));
+    }
+    
+    if (options?.validate) {
+        chain.push(HiSecure.validate(options.validate));
+    }
+    
+    if (options?.auth) {
+        chain.push(HiSecure.auth(
+            typeof options.auth === 'object' ? options.auth : undefined
+        ));
+    }
+    
+    return chain;
+}

package/src/examples/e1.ts

@@ -0,0 +1 @@
+// baad mein krte hai ise 

package/src/index.ts

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

package/src/logging/index.ts

@@ -0,0 +1,2 @@
+export * from "./winstonSetup.js";
+export * from "./morganSetup.js";

package/src/logging/morganSetup.ts

@@ -0,0 +1,3 @@
+import morgan from "morgan";
+
+export const requestLogger = morgan("combined");

package/src/logging/winstonSetup.ts

@@ -0,0 +1,17 @@
+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);