@hazeljs/core 0.2.0-alpha.1

package/dist/hazel-module.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HazelModuleInstance = exports.Module = void 0;
+exports.HazelModule = HazelModule;
+exports.getModuleMetadata = getModuleMetadata;
+require("reflect-metadata");
+const container_1 = require("./container");
+const logger_1 = __importDefault(require("./logger"));
+const MODULE_METADATA_KEY = 'hazel:module';
+const ROUTE_METADATA_KEY = 'hazel:route';
+function HazelModule(options) {
+    return (target) => {
+        Reflect.defineMetadata(MODULE_METADATA_KEY, options, target);
+    };
+}
+// Alias for backward compatibility
+exports.Module = HazelModule;
+function getModuleMetadata(target) {
+    const fromDecorator = Reflect.getMetadata(MODULE_METADATA_KEY, target);
+    if (fromDecorator)
+        return fromDecorator;
+    // Support dynamic modules: { module, providers?, controllers?, imports? }
+    if (target && typeof target === 'object' && 'module' in target) {
+        const dyn = target;
+        return {
+            providers: dyn.providers,
+            controllers: dyn.controllers,
+            imports: dyn.imports,
+        };
+    }
+    return undefined;
+}
+class HazelModuleInstance {
+    constructor(moduleType) {
+        this.moduleType = moduleType;
+        const name = moduleType?.name ?? moduleType?.module?.name ?? 'DynamicModule';
+        logger_1.default.debug(`Initializing HazelModule: ${name}`);
+        this.container = container_1.Container.getInstance();
+        this.initialize();
+    }
+    initialize() {
+        const metadata = getModuleMetadata(this.moduleType) || {};
+        logger_1.default.debug('Module metadata:', metadata);
+        // Initialize imported modules first (so their providers are available)
+        if (metadata.imports) {
+            logger_1.default.debug('Initializing imported modules:', metadata.imports.map((m) => (m && typeof m === 'object' && 'module' in m ? m.module?.name : m?.name)));
+            metadata.imports.forEach((moduleType) => {
+                new HazelModuleInstance(moduleType);
+            });
+        }
+        // Register providers
+        if (metadata.providers) {
+            logger_1.default.debug('Registering providers:', metadata.providers.map((p) => {
+                const val = p && typeof p === 'object' && 'provide' in p ? p.provide : p?.name;
+                return typeof val === 'symbol' ? val.toString() : val;
+            }));
+            metadata.providers.forEach((provider) => {
+                // Dynamic module provider: { provide, useFactory?, useClass?, useValue? } (NestJS-style)
+                if (provider && typeof provider === 'object' && ('provide' in provider || 'token' in provider)) {
+                    const p = provider;
+                    const token = p.token ?? p.provide;
+                    logger_1.default.debug(`Registering provider config for: ${typeof token === 'symbol' ? token.toString() : token}`);
+                    this.container.registerProvider({
+                        token,
+                        useFactory: p.useFactory,
+                        useClass: p.useClass,
+                        useValue: p.useValue,
+                        inject: p.inject,
+                    });
+                    return;
+                }
+                const cls = provider;
+                logger_1.default.debug(`Registering provider: ${cls?.name}`);
+                // Check if provider is request-scoped
+                const scope = Reflect.getMetadata('hazel:scope', cls);
+                if (scope === 'request') {
+                    // Don't eagerly resolve request-scoped providers
+                    this.container.registerProvider({
+                        token: cls,
+                        useClass: cls,
+                        scope: container_1.Scope.REQUEST,
+                    });
+                }
+                else {
+                    // Eagerly resolve singleton and transient providers
+                    this.container.register(cls, this.container.resolve(cls));
+                }
+            });
+        }
+        // Register controllers
+        if (metadata.controllers) {
+            logger_1.default.debug('Registering controllers:', metadata.controllers.map((c) => c?.name));
+            metadata.controllers.forEach((controller) => {
+                logger_1.default.debug(`Registering controller: ${controller.name}`);
+                // Check if controller has request-scoped dependencies
+                const paramTypes = Reflect.getMetadata('design:paramtypes', controller) || [];
+                const hasRequestScopedDeps = paramTypes.some((paramType) => {
+                    if (!paramType)
+                        return false;
+                    const scope = Reflect.getMetadata('hazel:scope', paramType);
+                    return scope === 'request';
+                });
+                if (hasRequestScopedDeps) {
+                    // Don't eagerly resolve controllers with request-scoped dependencies
+                    logger_1.default.debug(`Skipping eager resolution for controller with request-scoped deps: ${controller.name}`);
+                    // Register as a class provider so it gets resolved per-request
+                    this.container.registerProvider({
+                        token: controller,
+                        useClass: controller,
+                        scope: container_1.Scope.SINGLETON, // Controller itself is singleton, but deps are request-scoped
+                    });
+                }
+                else {
+                    // Eagerly resolve controllers without request-scoped dependencies
+                    const instance = this.container.resolve(controller);
+                    this.container.register(controller, instance);
+                }
+                // Register controller routes
+                const prototype = controller.prototype;
+                const methodNames = Object.getOwnPropertyNames(prototype).filter((name) => name !== 'constructor' && typeof prototype[name] === 'function');
+                methodNames.forEach((methodName) => {
+                    const route = Reflect.getMetadata(ROUTE_METADATA_KEY, prototype, methodName);
+                    if (route) {
+                        logger_1.default.debug(`Registering route: ${route.method} ${route.path}`);
+                    }
+                });
+            });
+        }
+    }
+    getContainer() {
+        return this.container;
+    }
+}
+exports.HazelModuleInstance = HazelModuleInstance;

package/dist/hazel-response.d.ts

@@ -0,0 +1,25 @@
+import { Response } from './types';
+export interface HazelResponse {
+    setHeader(name: string, value: string): void;
+    write(chunk: string): void;
+    end(): void;
+    status(code: number): HazelResponse;
+    json(data: unknown): void;
+    redirect(url: string, statusCode?: number): void;
+    /** Send a Buffer as binary (e.g. audio, PDF). Sets Content-Type if provided. */
+    sendBuffer?(buffer: Buffer, contentType?: string): void;
+}
+export declare class HazelExpressResponse implements HazelResponse {
+    private res;
+    private isStreaming;
+    private headersSent;
+    constructor(res: Response);
+    setHeader(name: string, value: string): void;
+    write(chunk: string): void;
+    end(): void;
+    status(code: number): HazelResponse;
+    redirect(url: string, statusCode?: number): void;
+    sendBuffer(buffer: Buffer, contentType?: string): void;
+    json(data: unknown): void;
+}
+//# sourceMappingURL=hazel-response.d.ts.map

package/dist/hazel-response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hazel-response.d.ts","sourceRoot":"","sources":["../src/hazel-response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEnC,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,GAAG,IAAI,IAAI,CAAC;IACZ,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,CAAC;IACpC,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjD,gFAAgF;IAChF,UAAU,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzD;AAED,qBAAa,oBAAqB,YAAW,aAAa;IAI5C,OAAO,CAAC,GAAG;IAHvB,OAAO,CAAC,WAAW,CAAkB;IACrC,OAAO,CAAC,WAAW,CAAkB;gBAEjB,GAAG,EAAE,QAAQ;IAEjC,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAM5C,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAY1B,GAAG,IAAI,IAAI;IAMX,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa;IAOnC,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,UAAU,GAAE,MAAY,GAAG,IAAI;IAWrD,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAWtD,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;CA+B1B"}

package/dist/hazel-response.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HazelExpressResponse = void 0;
+class HazelExpressResponse {
+    constructor(res) {
+        this.res = res;
+        this.isStreaming = false;
+        this.headersSent = false;
+    }
+    setHeader(name, value) {
+        if (!this.headersSent) {
+            this.res.setHeader(name, value);
+        }
+    }
+    write(chunk) {
+        if (!this.isStreaming) {
+            this.isStreaming = true;
+            this.headersSent = true;
+            this.res.setHeader('Content-Type', 'text/plain');
+            this.res.setHeader('Transfer-Encoding', 'chunked');
+            this.res.send(chunk);
+        }
+        else {
+            this.res.send(chunk);
+        }
+    }
+    end() {
+        if (this.isStreaming) {
+            this.res.end();
+        }
+    }
+    status(code) {
+        if (!this.headersSent) {
+            this.res.status(code);
+        }
+        return this;
+    }
+    redirect(url, statusCode = 302) {
+        if (this.headersSent)
+            return;
+        if (typeof this.res.redirect === 'function') {
+            this.res.redirect(url, statusCode);
+            return;
+        }
+        this.headersSent = true;
+        this.res.writeHead(statusCode, { Location: url });
+        this.res.end();
+    }
+    sendBuffer(buffer, contentType) {
+        if (this.isStreaming || this.headersSent) {
+            return;
+        }
+        if (contentType) {
+            this.res.setHeader('Content-Type', contentType);
+        }
+        this.res.send(buffer);
+        this.headersSent = true;
+    }
+    json(data) {
+        if (this.isStreaming || this.headersSent) {
+            return; // Don't try to send JSON if we're already streaming or headers are sent
+        }
+        try {
+            if (data && typeof data === 'object') {
+                // Handle error responses specially
+                if ('error' in data) {
+                    this.res.json({ error: data.error });
+                    return;
+                }
+                // For other objects, use a safe replacer
+                const safeData = JSON.parse(JSON.stringify(data, (key, value) => {
+                    if (key === 'res' || value === this.res) {
+                        return '[Response Object]';
+                    }
+                    return value;
+                }));
+                this.res.json(safeData);
+            }
+            else {
+                this.res.json(data);
+            }
+        }
+        catch {
+            // If JSON stringify fails, send a simple error message
+            this.res.json({ error: 'Failed to serialize response' });
+        }
+    }
+}
+exports.HazelExpressResponse = HazelExpressResponse;

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.debug(`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, type EarlyHttpHandler, type ProxyHandler } from './hazel-app';
+export { HazelModule, Module, HazelModuleInstance, getModuleMetadata } from './hazel-module';
+export type { ModuleOptions, DynamicModule } 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, Ip, Host, Headers, HttpCode, Header, Redirect, Inject, UsePipes, UseInterceptors, UseGuards, Public, SkipAuth, AITask, Timeout, Optional, Session, Retry, ApiTags, ApiOperation, SetMetadata, getMetadata, createParamDecorator, CUSTOM_METADATA_PREFIX, type ControllerMetadata, type RouteMetadata, type ControllerOptions, type RouteOptions, type ServiceOptions, type InjectableOptions, type RepositoryOptions, type OnModuleInit, type OnModuleDestroy, type ExecutionContext, type CanActivate, type RetryDecoratorOptions, type ApiOperationOptions, type ParamDecoratorContext, } 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, RequestTimeoutError, } from './errors/http.error';
+export { PipeTransform, ValidationError, ParseIntPipe, type PipeMetadata } from './pipes/pipe';
+export { ValidationPipe } from './pipes/validation.pipe';
+export { Interceptor, RetryInterceptor, type InterceptorMetadata, type RetryOptions, } 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":"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"}