@hazeljs/core 0.2.0-beta.1

package/dist/hazel-app.js

@@ -0,0 +1,453 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HazelApp = void 0;
+const hazel_module_1 = require("./hazel-module");
+const container_1 = require("./container");
+const router_1 = require("./router");
+const request_parser_1 = require("./request-parser");
+const http_1 = require("http");
+const logger_1 = __importDefault(require("./logger"));
+require("reflect-metadata");
+const http_error_1 = require("./errors/http.error");
+const os_1 = __importDefault(require("os"));
+const chalk_1 = __importDefault(require("chalk"));
+const shutdown_1 = require("./shutdown");
+const health_1 = require("./health");
+const timeout_middleware_1 = require("./middleware/timeout.middleware");
+const MODULE_METADATA_KEY = 'hazel:module';
+class HttpResponse {
+    constructor(res) {
+        this.res = res;
+        this.statusCode = 200;
+        this.headers = { 'Content-Type': 'application/json' };
+        this.headersSent = false;
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    json(data) {
+        if (this.headersSent)
+            return;
+        this.headersSent = true;
+        this.res.writeHead(this.statusCode, this.headers);
+        this.res.end(JSON.stringify(data));
+    }
+    send(data) {
+        if (!this.headersSent) {
+            this.headersSent = true;
+            this.res.writeHead(this.statusCode, this.headers);
+        }
+        this.res.write(data);
+    }
+    end() {
+        if (!this.headersSent) {
+            this.headersSent = true;
+            this.res.writeHead(this.statusCode, this.headers);
+        }
+        this.res.end();
+    }
+    setHeader(name, value) {
+        if (!this.headersSent) {
+            this.headers[name] = value;
+        }
+    }
+}
+class HazelApp {
+    constructor(moduleType) {
+        this.moduleType = moduleType;
+        this.server = null;
+        this.requestTimeout = 30000; // 30 seconds default
+        this.corsEnabled = false;
+        logger_1.default.info('Initializing HazelApp');
+        this.container = container_1.Container.getInstance();
+        this.router = new router_1.Router(this.container);
+        this.requestParser = new request_parser_1.RequestParser();
+        this.module = new hazel_module_1.HazelModuleInstance(this.moduleType);
+        this.shutdownManager = new shutdown_1.ShutdownManager();
+        this.healthManager = new health_1.HealthCheckManager();
+        // Register built-in health checks
+        this.healthManager.registerCheck(health_1.BuiltInHealthChecks.memoryCheck());
+        this.healthManager.registerCheck(health_1.BuiltInHealthChecks.eventLoopCheck());
+        this.initialize();
+    }
+    initialize() {
+        logger_1.default.info('Initializing module:', { moduleName: this.moduleType.name });
+        const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, this.moduleType) || {};
+        logger_1.default.debug('Module metadata:', metadata);
+        // Collect all controllers from the module tree (root + imports, recursively)
+        const allControllers = this.collectControllers(this.moduleType);
+        // Register all controllers with the router
+        if (allControllers.length > 0) {
+            logger_1.default.info('Registering controllers:', {
+                controllers: allControllers.map((c) => c.name),
+            });
+            allControllers.forEach((controller) => {
+                this.router.registerController(controller);
+            });
+        }
+    }
+    collectControllers(moduleType, visited = new Set()) {
+        if (visited.has(moduleType))
+            return [];
+        visited.add(moduleType);
+        const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, moduleType) || {};
+        const controllers = [];
+        // Collect from imported modules first
+        if (metadata.imports) {
+            for (const importedModule of metadata.imports) {
+                controllers.push(...this.collectControllers(importedModule, visited));
+            }
+        }
+        // Then collect from this module
+        if (metadata.controllers) {
+            controllers.push(...metadata.controllers);
+        }
+        return controllers;
+    }
+    register(component) {
+        const instance = new component();
+        this.container.register(component, instance);
+        return this;
+    }
+    get(path, ...handlers) {
+        this.router.get(path, handlers);
+        return this;
+    }
+    post(path, ...handlers) {
+        this.router.post(path, handlers);
+        return this;
+    }
+    put(path, ...handlers) {
+        this.router.put(path, handlers);
+        return this;
+    }
+    delete(path, ...handlers) {
+        this.router.delete(path, handlers);
+        return this;
+    }
+    async listen(port) {
+        return new Promise((resolve) => {
+            this.server = new http_1.Server(async (req, res) => {
+                try {
+                    if (!req.url) {
+                        logger_1.default.warn('Invalid URL received');
+                        res.writeHead(400);
+                        res.end(JSON.stringify({ error: 'Invalid URL' }));
+                        return;
+                    }
+                    // Health check endpoints
+                    if (req.url === '/health' && req.method === 'GET') {
+                        const liveness = await this.healthManager.getLiveness();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(liveness));
+                        return;
+                    }
+                    if (req.url === '/ready' && req.method === 'GET') {
+                        const readiness = await this.healthManager.getReadiness();
+                        const statusCode = readiness.status === 'healthy' ? 200 : 503;
+                        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(readiness));
+                        return;
+                    }
+                    if (req.url === '/startup' && req.method === 'GET') {
+                        const startup = await this.healthManager.getStartup();
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify(startup));
+                        return;
+                    }
+                    const { method, url, headers } = req;
+                    logger_1.default.info('Incoming request:', { method, url, headers });
+                    // Handle CORS
+                    if (this.corsEnabled) {
+                        const origin = headers['origin'] || '*';
+                        const allowedOrigin = this.corsOptions?.origin
+                            ? (typeof this.corsOptions.origin === 'string' ? this.corsOptions.origin : origin)
+                            : '*';
+                        res.setHeader('Access-Control-Allow-Origin', allowedOrigin);
+                        res.setHeader('Access-Control-Allow-Methods', this.corsOptions?.methods?.join(', ') || 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+                        res.setHeader('Access-Control-Allow-Headers', this.corsOptions?.allowedHeaders?.join(', ') || 'Content-Type, Authorization');
+                        if (this.corsOptions?.credentials) {
+                            res.setHeader('Access-Control-Allow-Credentials', 'true');
+                        }
+                        if (this.corsOptions?.maxAge) {
+                            res.setHeader('Access-Control-Max-Age', String(this.corsOptions.maxAge));
+                        }
+                        // Handle preflight
+                        if (method === 'OPTIONS') {
+                            res.writeHead(204);
+                            res.end();
+                            return;
+                        }
+                    }
+                    // Parse request body for POST/PUT/PATCH requests
+                    let body = undefined;
+                    if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+                        try {
+                            const chunks = [];
+                            req.on('data', (chunk) => chunks.push(chunk));
+                            await new Promise((resolve, reject) => {
+                                req.on('end', () => {
+                                    try {
+                                        const bodyStr = Buffer.concat(chunks).toString();
+                                        if (bodyStr) {
+                                            const contentType = headers['content-type'] || '';
+                                            if (contentType.includes('application/json')) {
+                                                body = JSON.parse(bodyStr);
+                                            }
+                                            else if (contentType.includes('application/x-www-form-urlencoded')) {
+                                                const params = new URLSearchParams(bodyStr);
+                                                body = Object.fromEntries(params.entries());
+                                            }
+                                            else {
+                                                body = bodyStr;
+                                            }
+                                        }
+                                        resolve();
+                                    }
+                                    catch (error) {
+                                        reject(error);
+                                    }
+                                });
+                                req.on('error', reject);
+                            });
+                        }
+                        catch (error) {
+                            logger_1.default.error('Error parsing request body:', error);
+                            res.writeHead(400);
+                            res.end(JSON.stringify({ error: 'Invalid request body' }));
+                            return;
+                        }
+                    }
+                    // Extend the original request object
+                    Object.assign(req, {
+                        body,
+                        params: {},
+                        query: {},
+                    });
+                    let context;
+                    try {
+                        context = await request_parser_1.RequestParser.parseRequest(req);
+                        logger_1.default.debug('Parsed request context:', context);
+                    }
+                    catch (error) {
+                        if (error instanceof http_error_1.HttpError) {
+                            logger_1.default.error(`[${req.method}] ${req.url} - Request parsing error: ${error.message} (status: ${error.statusCode})`);
+                            if (process.env.NODE_ENV === 'development' && error.stack) {
+                                logger_1.default.debug(error.stack);
+                            }
+                            res.writeHead(error.statusCode, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({
+                                statusCode: error.statusCode,
+                                message: error.message,
+                                ...(error.errors && { errors: error.errors }),
+                            }));
+                            return;
+                        }
+                        throw error;
+                    }
+                    // Apply timeout middleware if configured
+                    if (this.timeoutMiddleware) {
+                        const timeoutPromise = new Promise((_, reject) => {
+                            setTimeout(() => {
+                                reject(new http_error_1.HttpError(408, 'Request Timeout'));
+                            }, this.requestTimeout);
+                        });
+                        // Wrap remaining logic in a race against timeout
+                        try {
+                            await Promise.race([this.handleRoute(req, res, context), timeoutPromise]);
+                        }
+                        catch (timeoutError) {
+                            if (timeoutError instanceof http_error_1.HttpError && timeoutError.statusCode === 408) {
+                                res.writeHead(408, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ statusCode: 408, message: 'Request Timeout' }));
+                            }
+                            else {
+                                throw timeoutError;
+                            }
+                        }
+                        return;
+                    }
+                    await this.handleRoute(req, res, context);
+                }
+                catch (error) {
+                    logger_1.default.error('Unhandled error:', error);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        statusCode: 500,
+                        message: 'Internal Server Error',
+                    }));
+                }
+            });
+            this.server.listen(port, () => {
+                const localIp = getLocalIp();
+                logger_1.default.info(chalk_1.default.green.bold('Server listening on:'));
+                logger_1.default.info('');
+                logger_1.default.info(chalk_1.default.green('  → Local:    ') + chalk_1.default.cyan.underline(`http://localhost:${port}`));
+                logger_1.default.info(chalk_1.default.green('  → Network:  ') + chalk_1.default.cyan.underline(`http://${localIp}:${port}`));
+                logger_1.default.info('');
+                logger_1.default.info(chalk_1.default.gray('Health endpoints:'));
+                logger_1.default.info(chalk_1.default.gray(`  → /health  - Liveness probe`));
+                logger_1.default.info(chalk_1.default.gray(`  → /ready   - Readiness probe`));
+                logger_1.default.info(chalk_1.default.gray(`  → /startup - Startup probe`));
+                logger_1.default.info('');
+                // Setup graceful shutdown
+                this.shutdownManager.setupSignalHandlers();
+                // Register server shutdown handler
+                this.shutdownManager.registerHandler({
+                    name: 'http-server',
+                    handler: async () => {
+                        logger_1.default.info('Closing HTTP server...');
+                        await this.close();
+                        logger_1.default.info('HTTP server closed');
+                    },
+                    timeout: 10000,
+                });
+                resolve();
+            });
+        });
+    }
+    async handleRoute(req, res, context) {
+        let route;
+        try {
+            route = await this.router.match(req.method || 'GET', req.url || '/', context);
+            if (!route) {
+                if (req.url === '/.well-known/appspecific/com.chrome.devtools.json') {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                throw new Error('Route not found');
+            }
+        }
+        catch (error) {
+            const httpError = error;
+            logger_1.default.error(`[${req.method}] ${req.url} - Route matching error: ${httpError.message} (status: ${httpError.statusCode || 404})`);
+            if (process.env.NODE_ENV === 'development' && httpError.stack) {
+                logger_1.default.debug(httpError.stack);
+            }
+            const status = httpError.statusCode || 404;
+            res.writeHead(status, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                statusCode: status,
+                message: httpError.message,
+            }));
+            return;
+        }
+        logger_1.default.info('Matched route:', {
+            method: req.method,
+            url: req.url,
+            params: context.params,
+        });
+        try {
+            const response = new HttpResponse(res);
+            const result = await route.handler(req, response);
+            logger_1.default.debug('Request handled successfully:', result);
+            if (result !== undefined) {
+                response.json(result);
+            }
+        }
+        catch (error) {
+            logger_1.default.error('Error in route handler:', error instanceof http_error_1.HttpError);
+            if (error instanceof http_error_1.HttpError) {
+                logger_1.default.error('Error in route handler:', error.message);
+                res.writeHead(error.statusCode, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({
+                    statusCode: error.statusCode,
+                    message: error.message,
+                    ...(error.errors && { errors: error.errors }),
+                }));
+                return;
+            }
+            res.writeHead(500, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                statusCode: 500,
+                message: 'Internal Server Error',
+            }));
+        }
+    }
+    async close() {
+        if (this.server) {
+            return new Promise((resolve, reject) => {
+                this.server?.close((err) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        logger_1.default.info('Server closed successfully');
+                        resolve();
+                    }
+                });
+            });
+        }
+    }
+    /**
+     * Register a custom shutdown handler
+     */
+    registerShutdownHandler(handler) {
+        this.shutdownManager.registerHandler(handler);
+    }
+    /**
+     * Register a custom health check
+     */
+    registerHealthCheck(check) {
+        this.healthManager.registerCheck(check);
+    }
+    /**
+     * Set request timeout
+     */
+    setRequestTimeout(timeout, options) {
+        this.requestTimeout = timeout;
+        this.timeoutMiddleware = new timeout_middleware_1.TimeoutMiddleware({ ...options, timeout });
+        logger_1.default.info(`Request timeout set to ${timeout}ms`);
+    }
+    /**
+     * Enable CORS
+     */
+    enableCors(options) {
+        this.corsEnabled = true;
+        this.corsOptions = options;
+        logger_1.default.info('CORS enabled', options);
+    }
+    /**
+     * Disable CORS
+     */
+    disableCors() {
+        this.corsEnabled = false;
+        this.corsOptions = undefined;
+        logger_1.default.info('CORS disabled');
+    }
+    /**
+     * Get health check manager
+     */
+    getHealthManager() {
+        return this.healthManager;
+    }
+    /**
+     * Get shutdown manager
+     */
+    getShutdownManager() {
+        return this.shutdownManager;
+    }
+    getContainer() {
+        return this.container;
+    }
+    getRouter() {
+        return this.router;
+    }
+}
+exports.HazelApp = HazelApp;
+function getLocalIp() {
+    const interfaces = os_1.default.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name] || []) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return 'localhost';
+}

package/dist/hazel-module.d.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+import { Type } from './types';
+import { Container } from './container';
+export interface ModuleOptions {
+    imports?: Type<unknown>[];
+    controllers?: Type<unknown>[];
+    providers?: Type<unknown>[];
+    exports?: Type<unknown>[];
+}
+export declare function HazelModule(options: ModuleOptions): ClassDecorator;
+export declare const Module: typeof HazelModule;
+export declare function getModuleMetadata(target: object): ModuleOptions | undefined;
+export declare class HazelModuleInstance {
+    private readonly moduleType;
+    private container;
+    constructor(moduleType: Type<unknown>);
+    private initialize;
+    getContainer(): Container;
+}
+//# sourceMappingURL=hazel-module.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hazel-module.d.ts","sourceRoot":"","sources":["../src/hazel-module.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAC1B,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAS,MAAM,aAAa,CAAC;AAM/C,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IAC1B,WAAW,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9B,SAAS,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IAC5B,OAAO,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;CAC3B;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,cAAc,CAIlE;AAGD,eAAO,MAAM,MAAM,oBAAc,CAAC;AAElC,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAE3E;AAED,qBAAa,mBAAmB;IAGlB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,OAAO,CAAC,SAAS,CAAY;gBAEA,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC;IAMtD,OAAO,CAAC,UAAU;IA8FlB,YAAY,IAAI,SAAS;CAG1B"}

package/dist/hazel-module.js

@@ -0,0 +1,109 @@
+"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) {
+    return Reflect.getMetadata(MODULE_METADATA_KEY, target);
+}
+class HazelModuleInstance {
+    constructor(moduleType) {
+        this.moduleType = moduleType;
+        logger_1.default.debug(`Initializing HazelModule: ${moduleType.name}`);
+        this.container = container_1.Container.getInstance();
+        this.initialize();
+    }
+    initialize() {
+        const metadata = getModuleMetadata(this.moduleType) || {};
+        logger_1.default.debug('Module metadata:', metadata);
+        // Register providers
+        if (metadata.providers) {
+            logger_1.default.debug('Registering providers:', metadata.providers.map((p) => p.name));
+            metadata.providers.forEach((provider) => {
+                logger_1.default.debug(`Registering provider: ${provider.name}`);
+                // Check if provider is request-scoped
+                const scope = Reflect.getMetadata('hazel:scope', provider);
+                if (scope === 'request') {
+                    // Don't eagerly resolve request-scoped providers
+                    // They will be resolved per-request by the container
+                    logger_1.default.debug(`Skipping eager resolution for request-scoped provider: ${provider.name}`);
+                    // Just register the class itself, not an instance
+                    this.container.registerProvider({
+                        token: provider,
+                        useClass: provider,
+                        scope: container_1.Scope.REQUEST,
+                    });
+                }
+                else {
+                    // Eagerly resolve singleton and transient providers
+                    this.container.register(provider, this.container.resolve(provider));
+                }
+            });
+        }
+        // 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}`);
+                    }
+                });
+            });
+        }
+        // Initialize imported modules
+        if (metadata.imports) {
+            logger_1.default.debug('Initializing imported modules:', metadata.imports.map((m) => m.name));
+            metadata.imports.forEach((moduleType) => {
+                new HazelModuleInstance(moduleType);
+            });
+        }
+    }
+    getContainer() {
+        return this.container;
+    }
+}
+exports.HazelModuleInstance = HazelModuleInstance;

package/dist/hazel-response.d.ts

@@ -0,0 +1,20 @@
+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;
+}
+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;
+    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;CAC3B;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,IAAI,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;CA+B1B"}

package/dist/hazel-response.js

@@ -0,0 +1,68 @@
+"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;
+    }
+    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;