@hazeljs/core 0.2.0-beta.1

package/dist/health.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Health Check System
+ * Provides /health and /readiness endpoints for monitoring
+ */
+export interface HealthCheck {
+    name: string;
+    check: () => Promise<HealthCheckResult>;
+    critical?: boolean;
+    timeout?: number;
+}
+export interface HealthCheckResult {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    message?: string;
+    details?: Record<string, unknown>;
+    responseTime?: number;
+}
+export interface HealthStatus {
+    status: 'healthy' | 'unhealthy' | 'degraded';
+    timestamp: string;
+    uptime: number;
+    checks: Record<string, HealthCheckResult>;
+    version?: string;
+    environment?: string;
+}
+export declare class HealthCheckManager {
+    private checks;
+    private startTime;
+    /**
+     * Register a health check
+     */
+    registerCheck(check: HealthCheck): void;
+    /**
+     * Run all health checks
+     */
+    runChecks(): Promise<HealthStatus>;
+    /**
+     * Get liveness status (is the service running?)
+     */
+    getLiveness(): Promise<{
+        status: 'alive';
+        timestamp: string;
+    }>;
+    /**
+     * Get readiness status (is the service ready to accept traffic?)
+     */
+    getReadiness(): Promise<HealthStatus>;
+    /**
+     * Get startup status (has the service completed startup?)
+     */
+    getStartup(): Promise<{
+        status: 'started';
+        uptime: number;
+        timestamp: string;
+    }>;
+}
+/**
+ * Built-in health checks
+ */
+export declare class BuiltInHealthChecks {
+    /**
+     * Memory usage check
+     */
+    static memoryCheck(thresholdMB?: number): HealthCheck;
+    /**
+     * Event loop lag check
+     */
+    static eventLoopCheck(thresholdMs?: number): HealthCheck;
+    /**
+     * Disk space check (if applicable)
+     */
+    static diskSpaceCheck(): HealthCheck;
+}
+//# sourceMappingURL=health.d.ts.map

package/dist/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../src/health.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,OAAO,CAAC,iBAAiB,CAAC,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;IAC7C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,UAAU,CAAC;IAC7C,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,MAAM,CAAuC;IACrD,OAAO,CAAC,SAAS,CAAsB;IAEvC;;OAEG;IACH,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAKvC;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,YAAY,CAAC;IAqDxC;;OAEG;IACG,WAAW,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;IAOpE;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,YAAY,CAAC;IAI3C;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC;QAAE,MAAM,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CAOtF;AAED;;GAEG;AACH,qBAAa,mBAAmB;IAC9B;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,WAAW,SAAM,GAAG,WAAW;IA+BlD;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,WAAW,SAAM,GAAG,WAAW;IAyBrD;;OAEG;IACH,MAAM,CAAC,cAAc,IAAI,WAAW;CAcrC"}

package/dist/health.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * Health Check System
+ * Provides /health and /readiness endpoints for monitoring
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInHealthChecks = exports.HealthCheckManager = void 0;
+const logger_1 = __importDefault(require("./logger"));
+class HealthCheckManager {
+    constructor() {
+        this.checks = new Map();
+        this.startTime = Date.now();
+    }
+    /**
+     * Register a health check
+     */
+    registerCheck(check) {
+        this.checks.set(check.name, check);
+        logger_1.default.info(`Registered health check: ${check.name}`);
+    }
+    /**
+     * Run all health checks
+     */
+    async runChecks() {
+        const results = {};
+        let overallStatus = 'healthy';
+        for (const [name, check] of this.checks) {
+            try {
+                const startTime = Date.now();
+                // Run check with timeout
+                const result = await Promise.race([
+                    check.check(),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Health check ${name} timeout`)), check.timeout || 5000)),
+                ]);
+                result.responseTime = Date.now() - startTime;
+                results[name] = result;
+                // Update overall status
+                if (result.status === 'unhealthy' && check.critical) {
+                    overallStatus = 'unhealthy';
+                }
+                else if (result.status === 'degraded' && overallStatus === 'healthy') {
+                    overallStatus = 'degraded';
+                }
+            }
+            catch (error) {
+                const errorResult = {
+                    status: 'unhealthy',
+                    message: error instanceof Error ? error.message : 'Unknown error',
+                };
+                results[name] = errorResult;
+                if (check.critical) {
+                    overallStatus = 'unhealthy';
+                }
+                logger_1.default.error(`Health check failed: ${name}`, error);
+            }
+        }
+        return {
+            status: overallStatus,
+            timestamp: new Date().toISOString(),
+            uptime: Date.now() - this.startTime,
+            checks: results,
+            version: process.env.APP_VERSION,
+            environment: process.env.NODE_ENV,
+        };
+    }
+    /**
+     * Get liveness status (is the service running?)
+     */
+    async getLiveness() {
+        return {
+            status: 'alive',
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Get readiness status (is the service ready to accept traffic?)
+     */
+    async getReadiness() {
+        return this.runChecks();
+    }
+    /**
+     * Get startup status (has the service completed startup?)
+     */
+    async getStartup() {
+        return {
+            status: 'started',
+            uptime: Date.now() - this.startTime,
+            timestamp: new Date().toISOString(),
+        };
+    }
+}
+exports.HealthCheckManager = HealthCheckManager;
+/**
+ * Built-in health checks
+ */
+class BuiltInHealthChecks {
+    /**
+     * Memory usage check
+     */
+    static memoryCheck(thresholdMB = 500) {
+        return {
+            name: 'memory',
+            check: async () => {
+                const memUsage = process.memoryUsage();
+                const heapUsedMB = memUsage.heapUsed / 1024 / 1024;
+                if (heapUsedMB > thresholdMB) {
+                    return {
+                        status: 'degraded',
+                        message: `High memory usage: ${heapUsedMB.toFixed(2)}MB`,
+                        details: {
+                            heapUsed: `${heapUsedMB.toFixed(2)}MB`,
+                            heapTotal: `${(memUsage.heapTotal / 1024 / 1024).toFixed(2)}MB`,
+                            rss: `${(memUsage.rss / 1024 / 1024).toFixed(2)}MB`,
+                        },
+                    };
+                }
+                return {
+                    status: 'healthy',
+                    details: {
+                        heapUsed: `${heapUsedMB.toFixed(2)}MB`,
+                        heapTotal: `${(memUsage.heapTotal / 1024 / 1024).toFixed(2)}MB`,
+                    },
+                };
+            },
+            critical: false,
+        };
+    }
+    /**
+     * Event loop lag check
+     */
+    static eventLoopCheck(thresholdMs = 100) {
+        return {
+            name: 'eventLoop',
+            check: async () => {
+                const start = Date.now();
+                await new Promise((resolve) => setImmediate(resolve));
+                const lag = Date.now() - start;
+                if (lag > thresholdMs) {
+                    return {
+                        status: 'degraded',
+                        message: `High event loop lag: ${lag}ms`,
+                        details: { lag: `${lag}ms` },
+                    };
+                }
+                return {
+                    status: 'healthy',
+                    details: { lag: `${lag}ms` },
+                };
+            },
+            critical: false,
+        };
+    }
+    /**
+     * Disk space check (if applicable)
+     */
+    static diskSpaceCheck() {
+        return {
+            name: 'diskSpace',
+            check: async () => {
+                // This is a placeholder - actual implementation would check disk space
+                // using a library like 'check-disk-space'
+                return {
+                    status: 'healthy',
+                    message: 'Disk space check not implemented',
+                };
+            },
+            critical: false,
+        };
+    }
+}
+exports.BuiltInHealthChecks = BuiltInHealthChecks;

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * HazelJS Core Framework
+ * A modern, modular Node.js framework with TypeScript support
+ */
+import 'reflect-metadata';
+export { HazelApp } from './hazel-app';
+export { HazelModule, Module, HazelModuleInstance, getModuleMetadata } from './hazel-module';
+export type { ModuleOptions } from './hazel-module';
+export { ShutdownManager } from './shutdown';
+export type { ShutdownHandler } from './shutdown';
+export { HealthCheckManager, BuiltInHealthChecks } from './health';
+export type { HealthCheck, HealthCheckResult, HealthStatus } from './health';
+export { TimeoutMiddleware } from './middleware/timeout.middleware';
+export type { TimeoutOptions } from './middleware/timeout.middleware';
+export { Controller, Injectable, Service, Get, Post, Put, Delete, Patch, Body, Param, Query, Req, Res, Headers, HttpCode, Header, Redirect, Inject, UsePipes, UseInterceptors, UseGuards, type ControllerMetadata, type RouteMetadata, type ControllerOptions, type RouteOptions, type ServiceOptions, type InjectableOptions, type RepositoryOptions, type OnModuleInit, type OnModuleDestroy, type ExecutionContext, type CanActivate, } from './decorators';
+export { Container, Scope, type InjectionToken, type Provider } from './container';
+export type { Type, Request, Response, RequestContext, ValidationSchema } from './types';
+export { HttpError, BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, InternalServerError, HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException, ConflictException, InternalServerErrorException, } from './errors/http.error';
+export { PipeTransform, ValidationError, ParseIntPipe, type PipeMetadata } from './pipes/pipe';
+export { ValidationPipe } from './pipes/validation.pipe';
+export { Interceptor, type InterceptorMetadata } from './interceptors/interceptor';
+export { type ExceptionFilter, type ArgumentsHost, ArgumentsHostImpl, Catch, getFilterExceptions, } from './filters/exception-filter';
+export { HttpExceptionFilter } from './filters/http-exception.filter';
+export { Test, TestingModule, TestingModuleBuilder, type TestingModuleMetadata, } from './testing/testing.module';
+export { RouteMatcher, type RouteMatch } from './routing/route-matcher';
+export { Version, VersioningType, type VersioningOptions, getVersionMetadata, matchVersion, extractVersion, } from './routing/version.decorator';
+export { GlobalMiddlewareManager, CorsMiddleware, LoggerMiddleware, type MiddlewareFunction, type MiddlewareClass, type MiddlewareConsumer, type MiddlewareConfigProxy, type RouteInfo, type NextFunction, type CorsOptions, } from './middleware/global-middleware';
+export { Middleware, type MiddlewareHandler } from './middleware';
+export { SecurityHeadersMiddleware, type SecurityHeadersOptions, } from './middleware/security-headers.middleware';
+export { RateLimitMiddleware, type RateLimitOptions, } from './middleware/rate-limit.middleware';
+export { CsrfMiddleware, type CsrfOptions, } from './middleware/csrf.middleware';
+export { FileUploadInterceptor, UploadedFileDecorator as UploadedFile, UploadedFilesDecorator as UploadedFiles, type UploadedFile as UploadedFileType, type FileUploadOptions, } from './upload/file-upload';
+export { default as logger } from './logger';
+export { default } from './logger';
+export { Validator } from './validator';
+export { Router } from './router';
+export { RequestParser } from './request-parser';
+export { RequestContext as RequestContextClass } from './request-context';
+export { HazelResponse } from './hazel-response';
+export { sanitizeHtml, sanitizeString, sanitizeUrl, sanitizeEmail, sanitizeSql, sanitizeObject, escapeHtml, } from './utils/sanitize';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,kBAAkB,CAAC;AAG1B,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC7F,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpD,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAC7C,YAAY,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AACnE,YAAY,EAAE,WAAW,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAG7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,YAAY,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAGtE,OAAO,EACL,UAAU,EACV,UAAU,EACV,OAAO,EACP,GAAG,EACH,IAAI,EACJ,GAAG,EACH,MAAM,EACN,KAAK,EACL,IAAI,EACJ,KAAK,EACL,KAAK,EACL,GAAG,EACH,GAAG,EACH,OAAO,EACP,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,eAAe,EACf,SAAS,EACT,KAAK,kBAAkB,EACvB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,WAAW,GACjB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGnF,YAAY,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGzF,OAAO,EACL,SAAS,EACT,eAAe,EACf,iBAAiB,EACjB,cAAc,EACd,aAAa,EACb,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,qBAAqB,EACrB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,4BAA4B,GAC7B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,cAAc,CAAC;AAC/F,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGzD,OAAO,EAAE,WAAW,EAAE,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAGnF,OAAO,EACL,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,iBAAiB,EACjB,KAAK,EACL,mBAAmB,GACpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAGtE,OAAO,EACL,IAAI,EACJ,aAAa,EACb,oBAAoB,EACpB,KAAK,qBAAqB,GAC3B,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAAE,YAAY,EAAE,KAAK,UAAU,EAAE,MAAM,yBAAyB,CAAC;AACxE,OAAO,EACL,OAAO,EACP,cAAc,EACd,KAAK,iBAAiB,EACtB,kBAAkB,EAClB,YAAY,EACZ,cAAc,GACf,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,gBAAgB,EAChB,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,kBAAkB,EACvB,KAAK,qBAAqB,EAC1B,KAAK,SAAS,EACd,KAAK,YAAY,EACjB,KAAK,WAAW,GACjB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAClE,OAAO,EACL,yBAAyB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,oCAAoC,CAAC;AAC5C,OAAO,EACL,cAAc,EACd,KAAK,WAAW,GACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,qBAAqB,EACrB,qBAAqB,IAAI,YAAY,EACrC,sBAAsB,IAAI,aAAa,EACvC,KAAK,YAAY,IAAI,gBAAgB,EACrC,KAAK,iBAAiB,GACvB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AAGnC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAGxC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAGlC,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,cAAc,IAAI,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGjD,OAAO,EACL,YAAY,EACZ,cAAc,EACd,WAAW,EACX,aAAa,EACb,WAAW,EACX,cAAc,EACd,UAAU,GACX,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,140 @@
+"use strict";
+/**
+ * HazelJS Core Framework
+ * A modern, modular Node.js framework with TypeScript support
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgumentsHostImpl = exports.ValidationPipe = exports.ParseIntPipe = exports.ValidationError = exports.InternalServerErrorException = exports.ConflictException = exports.NotFoundException = exports.ForbiddenException = exports.UnauthorizedException = exports.BadRequestException = exports.HttpException = exports.InternalServerError = exports.ConflictError = exports.NotFoundError = exports.ForbiddenError = exports.UnauthorizedError = exports.BadRequestError = exports.HttpError = exports.Scope = exports.Container = exports.UseGuards = exports.UseInterceptors = exports.UsePipes = exports.Inject = exports.Redirect = exports.Header = exports.HttpCode = exports.Headers = exports.Res = exports.Req = exports.Query = exports.Param = exports.Body = exports.Patch = exports.Delete = exports.Put = exports.Post = exports.Get = exports.Service = exports.Injectable = exports.Controller = exports.TimeoutMiddleware = exports.BuiltInHealthChecks = exports.HealthCheckManager = exports.ShutdownManager = exports.getModuleMetadata = exports.HazelModuleInstance = exports.Module = exports.HazelModule = exports.HazelApp = void 0;
+exports.escapeHtml = exports.sanitizeObject = exports.sanitizeSql = exports.sanitizeEmail = exports.sanitizeUrl = exports.sanitizeString = exports.sanitizeHtml = exports.RequestParser = exports.Router = exports.Validator = exports.default = exports.logger = exports.UploadedFiles = exports.UploadedFile = exports.FileUploadInterceptor = exports.CsrfMiddleware = exports.RateLimitMiddleware = exports.SecurityHeadersMiddleware = exports.LoggerMiddleware = exports.CorsMiddleware = exports.GlobalMiddlewareManager = exports.extractVersion = exports.matchVersion = exports.getVersionMetadata = exports.VersioningType = exports.Version = exports.RouteMatcher = exports.TestingModuleBuilder = exports.TestingModule = exports.Test = exports.HttpExceptionFilter = exports.getFilterExceptions = exports.Catch = void 0;
+// Import reflect-metadata to enable decorator metadata
+// Users don't need to import this manually
+require("reflect-metadata");
+// Core exports
+var hazel_app_1 = require("./hazel-app");
+Object.defineProperty(exports, "HazelApp", { enumerable: true, get: function () { return hazel_app_1.HazelApp; } });
+var hazel_module_1 = require("./hazel-module");
+Object.defineProperty(exports, "HazelModule", { enumerable: true, get: function () { return hazel_module_1.HazelModule; } });
+Object.defineProperty(exports, "Module", { enumerable: true, get: function () { return hazel_module_1.Module; } });
+Object.defineProperty(exports, "HazelModuleInstance", { enumerable: true, get: function () { return hazel_module_1.HazelModuleInstance; } });
+Object.defineProperty(exports, "getModuleMetadata", { enumerable: true, get: function () { return hazel_module_1.getModuleMetadata; } });
+// Shutdown & Health
+var shutdown_1 = require("./shutdown");
+Object.defineProperty(exports, "ShutdownManager", { enumerable: true, get: function () { return shutdown_1.ShutdownManager; } });
+var health_1 = require("./health");
+Object.defineProperty(exports, "HealthCheckManager", { enumerable: true, get: function () { return health_1.HealthCheckManager; } });
+Object.defineProperty(exports, "BuiltInHealthChecks", { enumerable: true, get: function () { return health_1.BuiltInHealthChecks; } });
+// Timeout Middleware (new)
+var timeout_middleware_1 = require("./middleware/timeout.middleware");
+Object.defineProperty(exports, "TimeoutMiddleware", { enumerable: true, get: function () { return timeout_middleware_1.TimeoutMiddleware; } });
+// Decorators
+var decorators_1 = require("./decorators");
+Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return decorators_1.Controller; } });
+Object.defineProperty(exports, "Injectable", { enumerable: true, get: function () { return decorators_1.Injectable; } });
+Object.defineProperty(exports, "Service", { enumerable: true, get: function () { return decorators_1.Service; } });
+Object.defineProperty(exports, "Get", { enumerable: true, get: function () { return decorators_1.Get; } });
+Object.defineProperty(exports, "Post", { enumerable: true, get: function () { return decorators_1.Post; } });
+Object.defineProperty(exports, "Put", { enumerable: true, get: function () { return decorators_1.Put; } });
+Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return decorators_1.Delete; } });
+Object.defineProperty(exports, "Patch", { enumerable: true, get: function () { return decorators_1.Patch; } });
+Object.defineProperty(exports, "Body", { enumerable: true, get: function () { return decorators_1.Body; } });
+Object.defineProperty(exports, "Param", { enumerable: true, get: function () { return decorators_1.Param; } });
+Object.defineProperty(exports, "Query", { enumerable: true, get: function () { return decorators_1.Query; } });
+Object.defineProperty(exports, "Req", { enumerable: true, get: function () { return decorators_1.Req; } });
+Object.defineProperty(exports, "Res", { enumerable: true, get: function () { return decorators_1.Res; } });
+Object.defineProperty(exports, "Headers", { enumerable: true, get: function () { return decorators_1.Headers; } });
+Object.defineProperty(exports, "HttpCode", { enumerable: true, get: function () { return decorators_1.HttpCode; } });
+Object.defineProperty(exports, "Header", { enumerable: true, get: function () { return decorators_1.Header; } });
+Object.defineProperty(exports, "Redirect", { enumerable: true, get: function () { return decorators_1.Redirect; } });
+Object.defineProperty(exports, "Inject", { enumerable: true, get: function () { return decorators_1.Inject; } });
+Object.defineProperty(exports, "UsePipes", { enumerable: true, get: function () { return decorators_1.UsePipes; } });
+Object.defineProperty(exports, "UseInterceptors", { enumerable: true, get: function () { return decorators_1.UseInterceptors; } });
+Object.defineProperty(exports, "UseGuards", { enumerable: true, get: function () { return decorators_1.UseGuards; } });
+// Container & DI
+var container_1 = require("./container");
+Object.defineProperty(exports, "Container", { enumerable: true, get: function () { return container_1.Container; } });
+Object.defineProperty(exports, "Scope", { enumerable: true, get: function () { return container_1.Scope; } });
+// Errors
+var http_error_1 = require("./errors/http.error");
+Object.defineProperty(exports, "HttpError", { enumerable: true, get: function () { return http_error_1.HttpError; } });
+Object.defineProperty(exports, "BadRequestError", { enumerable: true, get: function () { return http_error_1.BadRequestError; } });
+Object.defineProperty(exports, "UnauthorizedError", { enumerable: true, get: function () { return http_error_1.UnauthorizedError; } });
+Object.defineProperty(exports, "ForbiddenError", { enumerable: true, get: function () { return http_error_1.ForbiddenError; } });
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return http_error_1.NotFoundError; } });
+Object.defineProperty(exports, "ConflictError", { enumerable: true, get: function () { return http_error_1.ConflictError; } });
+Object.defineProperty(exports, "InternalServerError", { enumerable: true, get: function () { return http_error_1.InternalServerError; } });
+Object.defineProperty(exports, "HttpException", { enumerable: true, get: function () { return http_error_1.HttpException; } });
+Object.defineProperty(exports, "BadRequestException", { enumerable: true, get: function () { return http_error_1.BadRequestException; } });
+Object.defineProperty(exports, "UnauthorizedException", { enumerable: true, get: function () { return http_error_1.UnauthorizedException; } });
+Object.defineProperty(exports, "ForbiddenException", { enumerable: true, get: function () { return http_error_1.ForbiddenException; } });
+Object.defineProperty(exports, "NotFoundException", { enumerable: true, get: function () { return http_error_1.NotFoundException; } });
+Object.defineProperty(exports, "ConflictException", { enumerable: true, get: function () { return http_error_1.ConflictException; } });
+Object.defineProperty(exports, "InternalServerErrorException", { enumerable: true, get: function () { return http_error_1.InternalServerErrorException; } });
+// Pipes
+var pipe_1 = require("./pipes/pipe");
+Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function () { return pipe_1.ValidationError; } });
+Object.defineProperty(exports, "ParseIntPipe", { enumerable: true, get: function () { return pipe_1.ParseIntPipe; } });
+var validation_pipe_1 = require("./pipes/validation.pipe");
+Object.defineProperty(exports, "ValidationPipe", { enumerable: true, get: function () { return validation_pipe_1.ValidationPipe; } });
+// Filters
+var exception_filter_1 = require("./filters/exception-filter");
+Object.defineProperty(exports, "ArgumentsHostImpl", { enumerable: true, get: function () { return exception_filter_1.ArgumentsHostImpl; } });
+Object.defineProperty(exports, "Catch", { enumerable: true, get: function () { return exception_filter_1.Catch; } });
+Object.defineProperty(exports, "getFilterExceptions", { enumerable: true, get: function () { return exception_filter_1.getFilterExceptions; } });
+var http_exception_filter_1 = require("./filters/http-exception.filter");
+Object.defineProperty(exports, "HttpExceptionFilter", { enumerable: true, get: function () { return http_exception_filter_1.HttpExceptionFilter; } });
+// Testing
+var testing_module_1 = require("./testing/testing.module");
+Object.defineProperty(exports, "Test", { enumerable: true, get: function () { return testing_module_1.Test; } });
+Object.defineProperty(exports, "TestingModule", { enumerable: true, get: function () { return testing_module_1.TestingModule; } });
+Object.defineProperty(exports, "TestingModuleBuilder", { enumerable: true, get: function () { return testing_module_1.TestingModuleBuilder; } });
+// Routing
+var route_matcher_1 = require("./routing/route-matcher");
+Object.defineProperty(exports, "RouteMatcher", { enumerable: true, get: function () { return route_matcher_1.RouteMatcher; } });
+var version_decorator_1 = require("./routing/version.decorator");
+Object.defineProperty(exports, "Version", { enumerable: true, get: function () { return version_decorator_1.Version; } });
+Object.defineProperty(exports, "VersioningType", { enumerable: true, get: function () { return version_decorator_1.VersioningType; } });
+Object.defineProperty(exports, "getVersionMetadata", { enumerable: true, get: function () { return version_decorator_1.getVersionMetadata; } });
+Object.defineProperty(exports, "matchVersion", { enumerable: true, get: function () { return version_decorator_1.matchVersion; } });
+Object.defineProperty(exports, "extractVersion", { enumerable: true, get: function () { return version_decorator_1.extractVersion; } });
+// Middleware
+var global_middleware_1 = require("./middleware/global-middleware");
+Object.defineProperty(exports, "GlobalMiddlewareManager", { enumerable: true, get: function () { return global_middleware_1.GlobalMiddlewareManager; } });
+Object.defineProperty(exports, "CorsMiddleware", { enumerable: true, get: function () { return global_middleware_1.CorsMiddleware; } });
+Object.defineProperty(exports, "LoggerMiddleware", { enumerable: true, get: function () { return global_middleware_1.LoggerMiddleware; } });
+var security_headers_middleware_1 = require("./middleware/security-headers.middleware");
+Object.defineProperty(exports, "SecurityHeadersMiddleware", { enumerable: true, get: function () { return security_headers_middleware_1.SecurityHeadersMiddleware; } });
+var rate_limit_middleware_1 = require("./middleware/rate-limit.middleware");
+Object.defineProperty(exports, "RateLimitMiddleware", { enumerable: true, get: function () { return rate_limit_middleware_1.RateLimitMiddleware; } });
+var csrf_middleware_1 = require("./middleware/csrf.middleware");
+Object.defineProperty(exports, "CsrfMiddleware", { enumerable: true, get: function () { return csrf_middleware_1.CsrfMiddleware; } });
+// File Upload
+var file_upload_1 = require("./upload/file-upload");
+Object.defineProperty(exports, "FileUploadInterceptor", { enumerable: true, get: function () { return file_upload_1.FileUploadInterceptor; } });
+Object.defineProperty(exports, "UploadedFile", { enumerable: true, get: function () { return file_upload_1.UploadedFileDecorator; } });
+Object.defineProperty(exports, "UploadedFiles", { enumerable: true, get: function () { return file_upload_1.UploadedFilesDecorator; } });
+// Logger
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "logger", { enumerable: true, get: function () { return __importDefault(logger_1).default; } });
+var logger_2 = require("./logger");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(logger_2).default; } });
+// Validator
+var validator_1 = require("./validator");
+Object.defineProperty(exports, "Validator", { enumerable: true, get: function () { return validator_1.Validator; } });
+// Router
+var router_1 = require("./router");
+Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return router_1.Router; } });
+// Request utilities
+var request_parser_1 = require("./request-parser");
+Object.defineProperty(exports, "RequestParser", { enumerable: true, get: function () { return request_parser_1.RequestParser; } });
+// Security utilities
+var sanitize_1 = require("./utils/sanitize");
+Object.defineProperty(exports, "sanitizeHtml", { enumerable: true, get: function () { return sanitize_1.sanitizeHtml; } });
+Object.defineProperty(exports, "sanitizeString", { enumerable: true, get: function () { return sanitize_1.sanitizeString; } });
+Object.defineProperty(exports, "sanitizeUrl", { enumerable: true, get: function () { return sanitize_1.sanitizeUrl; } });
+Object.defineProperty(exports, "sanitizeEmail", { enumerable: true, get: function () { return sanitize_1.sanitizeEmail; } });
+Object.defineProperty(exports, "sanitizeSql", { enumerable: true, get: function () { return sanitize_1.sanitizeSql; } });
+Object.defineProperty(exports, "sanitizeObject", { enumerable: true, get: function () { return sanitize_1.sanitizeObject; } });
+Object.defineProperty(exports, "escapeHtml", { enumerable: true, get: function () { return sanitize_1.escapeHtml; } });

package/dist/interceptors/interceptor.d.ts

@@ -0,0 +1,22 @@
+import { RequestContext } from '../request-context';
+export interface Interceptor {
+    intercept(context: RequestContext, next: () => Promise<unknown>): Promise<unknown>;
+}
+export interface InterceptorMetadata {
+    type: Type<Interceptor>;
+    options?: unknown;
+}
+export interface CacheOptions {
+    ttl?: number;
+}
+export declare class LoggingInterceptor implements Interceptor {
+    intercept(context: RequestContext, next: () => Promise<unknown>): Promise<unknown>;
+}
+export declare class CacheInterceptor implements Interceptor {
+    private static cache;
+    private readonly ttl;
+    constructor(options?: CacheOptions);
+    intercept(context: RequestContext, next: () => Promise<unknown>): Promise<unknown>;
+}
+export type Type<T = unknown> = new (...args: unknown[]) => T;
+//# sourceMappingURL=interceptor.d.ts.map

package/dist/interceptors/interceptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptor.d.ts","sourceRoot":"","sources":["../../src/interceptors/interceptor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGpD,MAAM,WAAW,WAAW;IAC1B,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACpF;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,qBAAa,kBAAmB,YAAW,WAAW;IAC9C,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;CAgBzF;AAED,qBAAa,gBAAiB,YAAW,WAAW;IAClD,OAAO,CAAC,MAAM,CAAC,KAAK,CAA2D;IAC/E,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAEjB,OAAO,CAAC,EAAE,YAAY;IAI5B,SAAS,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;CAgBzF;AAED,MAAM,MAAM,IAAI,CAAC,CAAC,GAAG,OAAO,IAAI,KAAK,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC"}

package/dist/interceptors/interceptor.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheInterceptor = exports.LoggingInterceptor = void 0;
+const logger_1 = __importDefault(require("../logger"));
+class LoggingInterceptor {
+    async intercept(context, next) {
+        const startTime = Date.now();
+        logger_1.default.info(`[${context.method}] ${context.url}`);
+        try {
+            const result = await next();
+            const duration = Date.now() - startTime;
+            logger_1.default.info(`[${context.method}] ${context.url} - ${duration}ms`);
+            return result;
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const err = error;
+            logger_1.default.error(`[${context.method}] ${context.url} - ${err.message} (${duration}ms)`);
+            throw error;
+        }
+    }
+}
+exports.LoggingInterceptor = LoggingInterceptor;
+class CacheInterceptor {
+    constructor(options) {
+        this.ttl = options?.ttl || 60000;
+    }
+    async intercept(context, next) {
+        if (context.method !== 'GET') {
+            return next();
+        }
+        const cacheKey = `${context.method}:${context.url}`;
+        const cached = CacheInterceptor.cache.get(cacheKey);
+        if (cached && Date.now() - cached.timestamp < this.ttl) {
+            return cached.data;
+        }
+        const result = await next();
+        CacheInterceptor.cache.set(cacheKey, { data: result, timestamp: Date.now() });
+        return result;
+    }
+}
+exports.CacheInterceptor = CacheInterceptor;
+CacheInterceptor.cache = new Map();

package/dist/logger.d.ts

@@ -0,0 +1,8 @@
+import winston from 'winston';
+import { IncomingMessage, ServerResponse } from 'http';
+export declare const requestLogger: (req: IncomingMessage, res: ServerResponse, next: () => void) => void;
+declare const enhancedLogger: winston.Logger & {
+    isDebugEnabled: () => boolean;
+};
+export default enhancedLogger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,SAAS,CAAC;AAK9B,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAuOvD,eAAO,MAAM,aAAa,GACxB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,MAAM,MAAM,IAAI,KACf,IAuBF,CAAC;AAQF,QAAA,MAAM,cAAc;0BALO,OAAO;CAOhC,CAAC;AAGH,eAAe,cAAc,CAAC"}