@hazeljs/core 0.2.0-alpha.1

package/dist/hazel-app.js

@@ -0,0 +1,516 @@
+"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;
+        }
+    }
+    redirect(url, statusCode = 302) {
+        if (this.headersSent)
+            return;
+        this.headersSent = true;
+        this.res.writeHead(statusCode, { ...this.headers, Location: url });
+        this.res.end();
+    }
+}
+class HazelApp {
+    constructor(moduleType) {
+        this.moduleType = moduleType;
+        this.server = null;
+        this.requestTimeout = 30000; // 30 seconds default
+        this.corsEnabled = false;
+        this.earlyHandlers = [];
+        this.proxyHandlers = [];
+        logger_1.default.debug('Initializing HazelApp');
+        this.container = container_1.Container.getInstance();
+        this.container.register(HazelApp, this);
+        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.debug('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.debug('Registering controllers:', {
+                controllers: allControllers.map((c) => c.name),
+            });
+            allControllers.forEach((controller) => {
+                this.router.registerController(controller);
+            });
+        }
+    }
+    collectControllers(moduleRef, visited = new Set()) {
+        if (visited.has(moduleRef))
+            return [];
+        visited.add(moduleRef);
+        const metadata = (0, hazel_module_1.getModuleMetadata)(moduleRef) || {};
+        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) => {
+                const startTime = Date.now();
+                const method = req.method || 'GET';
+                const url = req.url || '/';
+                const path = url.split('?')[0];
+                res.once('finish', () => {
+                    if (process.env.LOG_HTTP === 'false')
+                        return;
+                    const duration = Date.now() - startTime;
+                    const status = res.statusCode || 0;
+                    const statusColor = status >= 500 ? chalk_1.default.red : status >= 400 ? chalk_1.default.yellow : chalk_1.default.green;
+                    logger_1.default.info(`${chalk_1.default.bold(method)} ${path} ${statusColor(String(status))} ${chalk_1.default.gray(duration + 'ms')}`);
+                });
+                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;
+                    }
+                    // Early handlers (e.g. GraphQL) - must run before body parsing
+                    for (const { path, handler } of this.earlyHandlers) {
+                        const pathname = req.url?.split('?')[0] ?? '';
+                        if (pathname === path || pathname.startsWith(path + '/')) {
+                            await handler(req, res);
+                            return;
+                        }
+                    }
+                    const { method, url, headers } = req;
+                    logger_1.default.debug('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 (skip multipart - let route handle it)
+                    let body = undefined;
+                    let rawBody = '';
+                    const contentType = headers['content-type'] || '';
+                    const isMultipart = contentType.includes('multipart/form-data');
+                    if ((method === 'POST' || method === 'PUT' || method === 'PATCH') && !isMultipart) {
+                        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();
+                                        rawBody = bodyStr;
+                                        if (bodyStr) {
+                                            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) {
+                            const err = error;
+                            const msg = err?.message ?? (err && typeof err.message === 'string' ? err.message : '');
+                            const isClientAbort = err?.code === 'ECONNRESET' ||
+                                err?.code === 'EPIPE' ||
+                                (typeof msg === 'string' && (msg === 'aborted' || msg.includes('aborted')));
+                            if (isClientAbort) {
+                                logger_1.default.debug('Client disconnected while sending request body');
+                                return;
+                            }
+                            logger_1.default.error('Error parsing request body:', error);
+                            if (!res.writableEnded) {
+                                res.writeHead(400);
+                                res.end(JSON.stringify({ error: 'Invalid request body' }));
+                            }
+                            return;
+                        }
+                    }
+                    // Extend the original request object
+                    Object.assign(req, {
+                        body,
+                        rawBody: rawBody || undefined,
+                        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;
+                    }
+                    // Proxy handlers (e.g. API gateway) - run before router
+                    const pathname = (req.url || '/').split('?')[0];
+                    for (const { pathPrefix, handler } of this.proxyHandlers) {
+                        if (pathname === pathPrefix || pathname.startsWith(pathPrefix + '/')) {
+                            const handled = await handler(req, res, context);
+                            if (handled)
+                                return;
+                        }
+                    }
+                    // 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.debug('Closing HTTP server...');
+                        await this.close();
+                        logger_1.default.debug('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;
+            if (process.env.NODE_ENV === 'development' && httpError.stack) {
+                logger_1.default.debug(`Route not found: ${req.method} ${req.url}`, httpError.stack);
+            }
+            const status = httpError.statusCode || 404;
+            res.writeHead(status, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({
+                statusCode: status,
+                message: httpError.message,
+            }));
+            return;
+        }
+        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.debug(`Request timeout set to ${timeout}ms`);
+    }
+    /**
+     * Enable CORS
+     */
+    enableCors(options) {
+        this.corsEnabled = true;
+        this.corsOptions = options;
+        logger_1.default.debug('CORS enabled', options);
+    }
+    /**
+     * Disable CORS
+     */
+    disableCors() {
+        this.corsEnabled = false;
+        this.corsOptions = undefined;
+        logger_1.default.debug('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;
+    }
+    /**
+     * Add an early HTTP handler (runs before body parsing, for GraphQL etc.)
+     */
+    addEarlyHandler(path, handler) {
+        this.earlyHandlers.push({ path, handler });
+        logger_1.default.debug('Early handler registered', { path });
+    }
+    /**
+     * Add a proxy handler (runs after body parsing, before router).
+     * Use with @hazeljs/gateway: app.addProxyHandler('/api', createGatewayHandler(gateway))
+     */
+    addProxyHandler(pathPrefix, handler) {
+        this.proxyHandlers.push({ pathPrefix, handler });
+        logger_1.default.debug('Proxy handler registered', { pathPrefix });
+    }
+}
+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,29 @@
+import 'reflect-metadata';
+import { Type } from './types';
+import { Container } from './container';
+/** Dynamic module returned by forRoot() / forRootAsync() */
+export interface DynamicModule {
+    module: Type<unknown>;
+    providers?: unknown[];
+    controllers?: Type<unknown>[];
+    imports?: (Type<unknown> | DynamicModule)[];
+    exports?: unknown[];
+    global?: boolean;
+}
+export interface ModuleOptions {
+    imports?: (Type<unknown> | DynamicModule)[];
+    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> | DynamicModule);
+    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,4DAA4D;AAC5D,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,EAAE,CAAC;IACtB,WAAW,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;IAC9B,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC;IAC5C,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,aAAa,CAAC,EAAE,CAAC;IAC5C,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,CAa3E;AAED,qBAAa,mBAAmB;IAGlB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAFvC,OAAO,CAAC,SAAS,CAAY;gBAEA,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,GAAG,aAAa;IAOtE,OAAO,CAAC,UAAU;IA6GlB,YAAY,IAAI,SAAS;CAG1B"}