@hazeljs/core 0.2.0-beta.1

package/dist/middleware/security-headers.middleware.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityHeadersMiddleware = void 0;
+/**
+ * Security Headers Middleware
+ * Adds security headers to HTTP responses
+ */
+class SecurityHeadersMiddleware {
+    constructor(options = {}) {
+        this.options = options;
+        // Set secure defaults
+        this.options = {
+            noSniff: true,
+            frameOptions: 'DENY',
+            xssProtection: true,
+            hsts: {
+                maxAge: 31536000, // 1 year
+                includeSubDomains: true,
+                preload: false,
+            },
+            hidePoweredBy: true,
+            ...options,
+        };
+    }
+    use(req, res, next) {
+        // Remove X-Powered-By header
+        if (this.options.hidePoweredBy) {
+            res.setHeader('X-Powered-By', '');
+        }
+        // X-Content-Type-Options
+        if (this.options.noSniff) {
+            res.setHeader('X-Content-Type-Options', 'nosniff');
+        }
+        // X-Frame-Options
+        if (this.options.frameOptions) {
+            res.setHeader('X-Frame-Options', this.options.frameOptions);
+        }
+        // X-XSS-Protection
+        if (this.options.xssProtection) {
+            res.setHeader('X-XSS-Protection', '1; mode=block');
+        }
+        // Strict-Transport-Security
+        if (this.options.hsts && (req.headers?.['x-forwarded-proto'] === 'https' || process.env.NODE_ENV === 'production')) {
+            const hstsValue = [
+                `max-age=${this.options.hsts.maxAge || 31536000}`,
+                this.options.hsts.includeSubDomains ? 'includeSubDomains' : '',
+                this.options.hsts.preload ? 'preload' : '',
+            ]
+                .filter(Boolean)
+                .join('; ');
+            res.setHeader('Strict-Transport-Security', hstsValue);
+        }
+        // Content-Security-Policy
+        if (this.options.contentSecurityPolicy) {
+            const csp = typeof this.options.contentSecurityPolicy === 'string'
+                ? this.options.contentSecurityPolicy
+                : this.buildCSP(this.options.contentSecurityPolicy);
+            res.setHeader('Content-Security-Policy', csp);
+        }
+        // Referrer-Policy
+        if (this.options.referrerPolicy) {
+            res.setHeader('Referrer-Policy', this.options.referrerPolicy);
+        }
+        // Permissions-Policy
+        if (this.options.permissionsPolicy) {
+            const permissions = Object.entries(this.options.permissionsPolicy)
+                .map(([feature, allowlist]) => {
+                const value = allowlist.length === 0 ? '()' : `(${allowlist.join(' ')})`;
+                return `${feature}=${value}`;
+            })
+                .join(', ');
+            res.setHeader('Permissions-Policy', permissions);
+        }
+        next();
+    }
+    buildCSP(policy) {
+        if (typeof policy === 'string') {
+            return policy;
+        }
+        const directives = [];
+        if (policy.defaultSrc) {
+            directives.push(`default-src ${policy.defaultSrc.join(' ')}`);
+        }
+        if (policy.scriptSrc) {
+            directives.push(`script-src ${policy.scriptSrc.join(' ')}`);
+        }
+        if (policy.styleSrc) {
+            directives.push(`style-src ${policy.styleSrc.join(' ')}`);
+        }
+        if (policy.imgSrc) {
+            directives.push(`img-src ${policy.imgSrc.join(' ')}`);
+        }
+        if (policy.connectSrc) {
+            directives.push(`connect-src ${policy.connectSrc.join(' ')}`);
+        }
+        if (policy.fontSrc) {
+            directives.push(`font-src ${policy.fontSrc.join(' ')}`);
+        }
+        if (policy.objectSrc) {
+            directives.push(`object-src ${policy.objectSrc.join(' ')}`);
+        }
+        if (policy.mediaSrc) {
+            directives.push(`media-src ${policy.mediaSrc.join(' ')}`);
+        }
+        if (policy.frameSrc) {
+            directives.push(`frame-src ${policy.frameSrc.join(' ')}`);
+        }
+        if (policy.baseUri) {
+            directives.push(`base-uri ${policy.baseUri.join(' ')}`);
+        }
+        if (policy.formAction) {
+            directives.push(`form-action ${policy.formAction.join(' ')}`);
+        }
+        if (policy.frameAncestors) {
+            directives.push(`frame-ancestors ${policy.frameAncestors.join(' ')}`);
+        }
+        if (policy.upgradeInsecureRequests) {
+            directives.push('upgrade-insecure-requests');
+        }
+        return directives.join('; ');
+    }
+}
+exports.SecurityHeadersMiddleware = SecurityHeadersMiddleware;

package/dist/middleware/timeout.middleware.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Request Timeout Middleware
+ * Prevents requests from hanging indefinitely
+ */
+import { Request, Response } from '../types';
+export interface TimeoutOptions {
+    timeout?: number;
+    message?: string;
+    onTimeout?: (req: Request) => void;
+}
+export declare class TimeoutMiddleware {
+    private timeout;
+    private message;
+    private onTimeout?;
+    constructor(options?: TimeoutOptions);
+    /**
+     * Create timeout handler for a request
+     */
+    handle(req: Request, res: Response, next: () => void): void;
+    /**
+     * Create middleware function
+     */
+    static create(options?: TimeoutOptions): (req: Request, res: Response, next: () => void) => void;
+}
+//# sourceMappingURL=timeout.middleware.d.ts.map

package/dist/middleware/timeout.middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.middleware.d.ts","sourceRoot":"","sources":["../../src/middleware/timeout.middleware.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAG7C,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC;AAED,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAC,CAAyB;gBAE/B,OAAO,GAAE,cAAmB;IAMxC;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,IAAI,GAAG,IAAI;IAmD3D;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,cAAc,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,IAAI,KAAK,IAAI;CAIjG"}

package/dist/middleware/timeout.middleware.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Request Timeout Middleware
+ * Prevents requests from hanging indefinitely
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutMiddleware = void 0;
+const logger_1 = __importDefault(require("../logger"));
+class TimeoutMiddleware {
+    constructor(options = {}) {
+        this.timeout = options.timeout || 30000; // 30 seconds default
+        this.message = options.message || 'Request timeout';
+        this.onTimeout = options.onTimeout;
+    }
+    /**
+     * Create timeout handler for a request
+     */
+    handle(req, res, next) {
+        let timeoutId = null;
+        let timedOut = false;
+        // Set timeout
+        timeoutId = setTimeout(() => {
+            timedOut = true;
+            // Call custom timeout handler if provided
+            if (this.onTimeout) {
+                try {
+                    this.onTimeout(req);
+                }
+                catch (error) {
+                    logger_1.default.error('Error in timeout callback:', error);
+                }
+            }
+            // Log timeout
+            logger_1.default.warn('Request timeout:', {
+                method: req.method,
+                url: req.url,
+                timeout: this.timeout,
+            });
+            // Send timeout response
+            // Note: We can't check headersSent on our Response interface,
+            // but the status/json methods will handle this internally
+            res.status(408).json({
+                statusCode: 408,
+                message: this.message,
+                error: 'Request Timeout',
+            });
+        }, this.timeout);
+        // Clear timeout when response finishes
+        // Store original end method
+        const originalEnd = res.end.bind(res);
+        res.end = function () {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            return originalEnd();
+        };
+        // Continue to next middleware
+        if (!timedOut) {
+            next();
+        }
+    }
+    /**
+     * Create middleware function
+     */
+    static create(options) {
+        const middleware = new TimeoutMiddleware(options);
+        return (req, res, next) => middleware.handle(req, res, next);
+    }
+}
+exports.TimeoutMiddleware = TimeoutMiddleware;

package/dist/middleware.d.ts

@@ -0,0 +1,13 @@
+import { Type } from './types';
+import { RequestContext } from './types';
+import { Container } from './container';
+export interface Middleware {
+    use(context: RequestContext, next: () => Promise<unknown>): Promise<unknown>;
+}
+export type MiddlewareFunction = (context: RequestContext, next: () => Promise<unknown>) => Promise<unknown>;
+export declare class MiddlewareHandler {
+    private container;
+    constructor(container: Container);
+    executeMiddlewareChain(middlewares: Type<Middleware>[], context: RequestContext, finalHandler: () => Promise<unknown>): Promise<unknown>;
+}
+//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.d.ts","sourceRoot":"","sources":["../src/middleware.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC9E;AAED,MAAM,MAAM,kBAAkB,GAAG,CAC/B,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,KACzB,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,qBAAa,iBAAiB;IAChB,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,SAAS;IAElC,sBAAsB,CAC1B,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,EAC/B,OAAO,EAAE,cAAc,EACvB,YAAY,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GACnC,OAAO,CAAC,OAAO,CAAC;CAwCpB"}

package/dist/middleware.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MiddlewareHandler = void 0;
+class MiddlewareHandler {
+    constructor(container) {
+        this.container = container;
+    }
+    async executeMiddlewareChain(middlewares, context, finalHandler) {
+        const next = async () => {
+            if (!middlewares || middlewares.length === 0) {
+                try {
+                    return await finalHandler();
+                }
+                catch (error) {
+                    const err = error;
+                    if (!err.status) {
+                        err.status = 500;
+                    }
+                    throw error;
+                }
+            }
+            const middleware = this.container.resolve(middlewares[0]);
+            const remainingMiddlewares = middlewares.slice(1);
+            try {
+                return await middleware.use(context, () => this.executeMiddlewareChain(remainingMiddlewares, context, finalHandler));
+            }
+            catch (error) {
+                const err = error;
+                if (!err.status) {
+                    err.status = 500;
+                }
+                throw error;
+            }
+        };
+        try {
+            return await next();
+        }
+        catch (error) {
+            const err = error;
+            if (!err.status) {
+                err.status = 500;
+            }
+            throw error;
+        }
+    }
+}
+exports.MiddlewareHandler = MiddlewareHandler;

package/dist/pipes/pipe.d.ts

@@ -0,0 +1,50 @@
+import { RequestContext } from '../request-context';
+export interface PipeTransform<T = unknown, R = unknown> {
+    transform(value: T, context: RequestContext): R | Promise<R>;
+}
+export interface PipeMetadata {
+    type: Type<PipeTransform>;
+    options?: unknown;
+}
+export interface ValidationPipeOptions {
+    whitelist?: boolean;
+    forbidNonWhitelisted?: boolean;
+    transform?: boolean;
+    validateCustomDecorators?: boolean;
+}
+export declare class ValidationError extends Error {
+    errors: Array<{
+        property: string;
+        constraints: Record<string, string>;
+        value?: unknown;
+    }>;
+    constructor(message: string, errors: Array<{
+        property: string;
+        constraints: Record<string, string>;
+        value?: unknown;
+    }>);
+    toJSON(): {
+        message: string;
+        errors: Array<{
+            field: string;
+            messages: string[];
+            value: unknown;
+        }>;
+    };
+}
+export declare class ParseIntPipe implements PipeTransform<string, number> {
+    transform(value: string, context: RequestContext): number;
+}
+export declare class ParseFloatPipe implements PipeTransform<string, number> {
+    transform(value: string, context: RequestContext): number;
+}
+export declare class ParseBoolPipe implements PipeTransform<string, boolean> {
+    transform(value: string, context: RequestContext): boolean;
+}
+export declare class DefaultValuePipe<T = unknown> implements PipeTransform<T | undefined, T> {
+    private defaultValue;
+    constructor(defaultValue: T);
+    transform(value: T | undefined): T;
+}
+export type Type<T = unknown> = new (...args: unknown[]) => T;
+//# sourceMappingURL=pipe.d.ts.map

package/dist/pipes/pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe.d.ts","sourceRoot":"","sources":["../../src/pipes/pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC,GAAG,OAAO;IACrD,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,cAAc,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CAC9D;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,IAAI,CAAC,aAAa,CAAC,CAAC;IAC1B,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,qBAAa,eAAgB,SAAQ,KAAK;IAG/B,MAAM,EAAE,KAAK,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;gBALF,OAAO,EAAE,MAAM,EACR,MAAM,EAAE,KAAK,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACpC,KAAK,CAAC,EAAE,OAAO,CAAC;KACjB,CAAC;IAMJ,MAAM,IAAI;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,KAAK,CAAC;YACZ,KAAK,EAAE,MAAM,CAAC;YACd,QAAQ,EAAE,MAAM,EAAE,CAAC;YACnB,KAAK,EAAE,OAAO,CAAC;SAChB,CAAC,CAAC;KACJ;CAUF;AAED,qBAAa,YAAa,YAAW,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC;IAChE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;CAwB1D;AAED,qBAAa,cAAe,YAAW,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC;IAClE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;CAc1D;AAED,qBAAa,aAAc,YAAW,aAAa,CAAC,MAAM,EAAE,OAAO,CAAC;IAClE,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;CAY3D;AAED,qBAAa,gBAAgB,CAAC,CAAC,GAAG,OAAO,CAAE,YAAW,aAAa,CAAC,CAAC,GAAG,SAAS,EAAE,CAAC,CAAC;IACvE,OAAO,CAAC,YAAY;gBAAZ,YAAY,EAAE,CAAC;IAEnC,SAAS,CAAC,KAAK,EAAE,CAAC,GAAG,SAAS,GAAG,CAAC;CAInC;AAED,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC"}

package/dist/pipes/pipe.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultValuePipe = exports.ParseBoolPipe = exports.ParseFloatPipe = exports.ParseIntPipe = exports.ValidationError = void 0;
+const logger_1 = __importDefault(require("../logger"));
+class ValidationError extends Error {
+    constructor(message, errors) {
+        super(message);
+        this.errors = errors;
+        this.name = 'ValidationError';
+    }
+    toJSON() {
+        return {
+            message: this.message,
+            errors: this.errors.map((error) => ({
+                field: error.property,
+                messages: Object.values(error.constraints),
+                value: error.value,
+            })),
+        };
+    }
+}
+exports.ValidationError = ValidationError;
+class ParseIntPipe {
+    transform(value, context) {
+        logger_1.default.debug(`ParseIntPipe received value: ${value}`);
+        if (!value) {
+            throw new ValidationError('Value is required', [
+                {
+                    value,
+                    property: context.params?.id ? 'id' : 'value',
+                    constraints: { isNotEmpty: 'value must not be empty' },
+                },
+            ]);
+        }
+        const parsed = parseInt(value, 10);
+        logger_1.default.debug(`ParseIntPipe parsed value: ${parsed}`);
+        if (isNaN(parsed)) {
+            throw new ValidationError('Invalid integer value', [
+                {
+                    value,
+                    property: context.params?.id ? 'id' : 'value',
+                    constraints: { isInt: 'value must be an integer' },
+                },
+            ]);
+        }
+        return parsed;
+    }
+}
+exports.ParseIntPipe = ParseIntPipe;
+class ParseFloatPipe {
+    transform(value, context) {
+        logger_1.default.debug('Parsing float:', value);
+        const parsed = parseFloat(value);
+        if (isNaN(parsed)) {
+            throw new ValidationError('Invalid float value', [
+                {
+                    value,
+                    property: context.params?.id ? 'id' : 'value',
+                    constraints: { isFloat: 'value must be a float' },
+                },
+            ]);
+        }
+        return parsed;
+    }
+}
+exports.ParseFloatPipe = ParseFloatPipe;
+class ParseBoolPipe {
+    transform(value, context) {
+        logger_1.default.debug('Parsing boolean:', value);
+        if (value === 'true')
+            return true;
+        if (value === 'false')
+            return false;
+        throw new ValidationError('Invalid boolean value', [
+            {
+                value,
+                property: context.params?.id ? 'id' : 'value',
+                constraints: { isBoolean: 'value must be a boolean' },
+            },
+        ]);
+    }
+}
+exports.ParseBoolPipe = ParseBoolPipe;
+class DefaultValuePipe {
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    transform(value) {
+        logger_1.default.debug('Applying default value:', { value, defaultValue: this.defaultValue });
+        return value === undefined ? this.defaultValue : value;
+    }
+}
+exports.DefaultValuePipe = DefaultValuePipe;

package/dist/pipes/validation.pipe.d.ts

@@ -0,0 +1,6 @@
+import { PipeTransform } from './pipe';
+import { RequestContext } from '../request-context';
+export declare class ValidationPipe implements PipeTransform {
+    transform(value: unknown, context: RequestContext): Promise<unknown>;
+}
+//# sourceMappingURL=validation.pipe.d.ts.map

package/dist/pipes/validation.pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.pipe.d.ts","sourceRoot":"","sources":["../../src/pipes/validation.pipe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAmB,MAAM,QAAQ,CAAC;AAIxD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAMpD,qBAAa,cAAe,YAAW,aAAa;IAC5C,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,OAAO,CAAC;CAkD3E"}

package/dist/pipes/validation.pipe.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationPipe = void 0;
+const pipe_1 = require("./pipe");
+const logger_1 = __importDefault(require("../logger"));
+const class_transformer_1 = require("class-transformer");
+const class_validator_1 = require("class-validator");
+function isConstructor(f) {
+    return typeof f === 'function';
+}
+class ValidationPipe {
+    async transform(value, context) {
+        logger_1.default.debug('ValidationPipe.transform - Input value:', value);
+        logger_1.default.debug('ValidationPipe.transform - Context:', context);
+        // Get DTO type from context
+        const dtoType = context.dtoType;
+        logger_1.default.debug('ValidationPipe.transform - DTO type:', dtoType?.name);
+        if (!isConstructor(dtoType)) {
+            logger_1.default.debug('ValidationPipe.transform - No valid DTO type provided, returning value as is');
+            return value;
+        }
+        try {
+            // Ensure value is an object before transformation
+            if (typeof value !== 'object' || value === null) {
+                throw new pipe_1.ValidationError('Invalid input: expected an object', [
+                    {
+                        property: 'body',
+                        constraints: { isObject: 'Input must be an object' },
+                        value,
+                    },
+                ]);
+            }
+            // Transform plain object to class instance
+            const instance = (0, class_transformer_1.plainToClass)(dtoType, value);
+            logger_1.default.debug('ValidationPipe.transform - Transformed instance:', instance);
+            // Validate instance
+            const errors = await (0, class_validator_1.validate)(instance);
+            if (errors.length > 0) {
+                logger_1.default.error('ValidationPipe.transform - Validation failed:', errors);
+                const formattedErrors = errors.map((error) => ({
+                    property: error.property,
+                    constraints: error.constraints || {},
+                    value: error.value,
+                }));
+                const validationError = new pipe_1.ValidationError('Validation failed', formattedErrors);
+                logger_1.default.error('ValidationPipe.transform - Throwing validation error:', validationError);
+                throw validationError;
+            }
+            logger_1.default.debug('ValidationPipe.transform - Validation successful');
+            return instance;
+        }
+        catch (error) {
+            logger_1.default.error('ValidationPipe.transform - Error during transformation:', error);
+            throw error;
+        }
+    }
+}
+exports.ValidationPipe = ValidationPipe;

package/dist/request-context.d.ts

@@ -0,0 +1,17 @@
+import { Type } from './types';
+export interface RequestContext {
+    method: string;
+    url: string;
+    headers: Record<string, string>;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    body: unknown;
+    dtoType?: Type<unknown>;
+    user?: {
+        id: string | number;
+        username?: string;
+        role: string;
+        [key: string]: unknown;
+    };
+}
+//# sourceMappingURL=request-context.d.ts.map

package/dist/request-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-context.d.ts","sourceRoot":"","sources":["../src/request-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAE/B,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACxB,IAAI,CAAC,EAAE;QACL,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;QACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;QACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;KACxB,CAAC;CACH"}

package/dist/request-context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/request-parser.d.ts

@@ -0,0 +1,7 @@
+import { RequestContext, Request } from './types';
+export declare class RequestParser {
+    static parseRequest(req: Request): Promise<RequestContext>;
+    private static normalizeHeaders;
+    private static parseQueryString;
+}
+//# sourceMappingURL=request-parser.d.ts.map

package/dist/request-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-parser.d.ts","sourceRoot":"","sources":["../src/request-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAIlD,qBAAa,aAAa;WACX,YAAY,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAAC,cAAc,CAAC;IAqChE,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAW/B,OAAO,CAAC,MAAM,CAAC,gBAAgB;CAQhC"}

package/dist/request-parser.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestParser = void 0;
+const logger_1 = __importDefault(require("./logger"));
+class RequestParser {
+    static async parseRequest(req) {
+        try {
+            const { method, url, headers } = req;
+            const context = {
+                method: method || 'GET',
+                url: url || '/',
+                headers: this.normalizeHeaders(headers),
+                params: { ...req.params },
+                query: {},
+                body: req.body || {},
+            };
+            // Parse query parameters
+            if (url) {
+                const queryString = url.split('?')[1];
+                if (queryString) {
+                    context.query = this.parseQueryString(queryString);
+                }
+            }
+            logger_1.default.debug('Parsed request context:', context);
+            return context;
+        }
+        catch (error) {
+            const err = error;
+            logger_1.default.error(`[${req.method}] ${req.url} - Request parsing error: ${err.message} (status: ${err.status || 400})`);
+            if (process.env.NODE_ENV === 'development' && err.stack) {
+                logger_1.default.debug(err.stack);
+            }
+            if (!err.status) {
+                err.status = 500;
+            }
+            throw error;
+        }
+    }
+    static normalizeHeaders(headers) {
+        const normalized = {};
+        if (!headers)
+            return normalized;
+        for (const [key, value] of Object.entries(headers)) {
+            normalized[key.toLowerCase()] = Array.isArray(value) ? value.join(', ') : value || '';
+        }
+        return normalized;
+    }
+    static parseQueryString(queryString) {
+        const params = {};
+        const searchParams = new URLSearchParams(queryString);
+        for (const [key, value] of searchParams.entries()) {
+            params[key] = value;
+        }
+        return params;
+    }
+}
+exports.RequestParser = RequestParser;

package/dist/router.d.ts

@@ -0,0 +1,33 @@
+import { Type } from './types';
+import { RequestContext, Request, Response } from './types';
+import { Container } from './container';
+import 'reflect-metadata';
+interface RouteMatch {
+    handler: RouteHandler;
+    context: RequestContext;
+}
+type RouteHandler = (req: Request, res: Response, context?: RequestContext) => void;
+export declare class Router {
+    private container;
+    private routes;
+    private routesByMethod;
+    private middlewareHandler;
+    constructor(container: Container);
+    registerController(controller: Type<unknown>): void;
+    private applyPipes;
+    private applyInterceptors;
+    private createRouteHandler;
+    private extractParams;
+    private matchPath;
+    private createRoutePattern;
+    private normalizePath;
+    match(method: string, url: string, context: RequestContext): Promise<RouteMatch | null>;
+    get(path: string, handlers: RouteHandler[]): void;
+    post(path: string, handlers: RouteHandler[]): void;
+    put(path: string, handlers: RouteHandler[]): void;
+    delete(path: string, handlers: RouteHandler[]): void;
+    private addRoute;
+    handleRequest(req: Request, res: Response): Promise<void>;
+}
+export {};
+//# sourceMappingURL=router.d.ts.map

package/dist/router.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.d.ts","sourceRoot":"","sources":["../src/router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAKxC,OAAO,kBAAkB,CAAC;AAY1B,UAAU,UAAU;IAClB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,cAAc,CAAC;CACzB;AAED,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,OAAO,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;AAEpF,qBAAa,MAAM;IAKL,OAAO,CAAC,SAAS;IAJ7B,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,cAAc,CAAuD;IAC7E,OAAO,CAAC,iBAAiB,CAAoB;gBAEzB,SAAS,EAAE,SAAS;IAUxC,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,IAAI;YA4DrC,UAAU;YAsBV,iBAAiB;IAe/B,OAAO,CAAC,kBAAkB;IA+N1B,OAAO,CAAC,aAAa;IAiBrB,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,kBAAkB;IAW1B,OAAO,CAAC,aAAa;IAOf,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IA0C7F,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIlD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIjD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIpD,OAAO,CAAC,QAAQ;IAKV,aAAa,CAAC,GAAG,EAAE,OAAO,EAAE,GAAG,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;CAkChE"}