@morojs/moro 1.6.0 → 1.6.1

package/dist/core/http/http-server.js

@@ -1,19 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.middleware = exports.MoroHttpServer = void 0;
 // src/core/http-server.ts
-import { createServer } from 'http';
-import * as zlib from 'zlib';
-import { createReadStream } from 'fs';
-import * as crypto from 'crypto';
-import { promisify } from 'util';
-import { createFrameworkLogger } from '../logger/index.js';
-const gzip = promisify(zlib.gzip);
-const deflate = promisify(zlib.deflate);
-export class MoroHttpServer {
+const http_1 = require("http");
+const zlib = __importStar(require("zlib"));
+const util_1 = require("util");
+const logger_1 = require("../logger");
+const gzip = (0, util_1.promisify)(zlib.gzip);
+const deflate = (0, util_1.promisify)(zlib.deflate);
+class MoroHttpServer {
     server;
     routes = [];
     globalMiddleware = [];
     compressionEnabled = true;
     compressionThreshold = 1024;
-    logger = createFrameworkLogger('HttpServer');
+    logger = (0, logger_1.createFrameworkLogger)('HttpServer');
     hookManager;
     requestCounter = 0;
     // Efficient object pooling with minimal overhead
@@ -22,10 +56,6 @@ export class MoroHttpServer {
     maxPoolSize = 50;
     // Request handler pooling to avoid function creation overhead
     middlewareExecutionCache = new Map();
-    // Response caching for ultra-fast common responses
-    responseCache = new Map();
-    responseCacheHits = 0;
-    responseCacheMisses = 0;
     // String interning for common values (massive memory savings)
     static INTERNED_METHODS = new Map([
         ['GET', 'GET'],
@@ -90,7 +120,7 @@ export class MoroHttpServer {
         }
     }
     constructor() {
-        this.server = createServer(this.handleRequest.bind(this));
+        this.server = (0, http_1.createServer)(this.handleRequest.bind(this));
         // Optimize server for high performance (conservative settings for compatibility)
         this.server.keepAliveTimeout = 5000; // 5 seconds
         this.server.headersTimeout = 6000; // 6 seconds
@@ -241,13 +271,12 @@ export class MoroHttpServer {
         }
         catch (error) {
             // Debug: Log the actual error and where it came from
-            this.logger.debug('Request error details', 'RequestHandler', {
-                errorType: typeof error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                errorStack: error instanceof Error ? error.stack : 'No stack trace',
-                requestPath: req.url,
-                requestMethod: req.method,
-            });
+            this.logger.debug('🚨 MoroJS Request Error Details:', 'RequestHandler');
+            this.logger.debug(`📍 Error type: ${typeof error}`, 'RequestHandler');
+            this.logger.debug(`📍 Error message: ${error instanceof Error ? error.message : String(error)}`, 'RequestHandler');
+            this.logger.debug(`📍 Error stack: ${error instanceof Error ? error.stack : 'No stack trace'}`, 'RequestHandler');
+            this.logger.debug(`📍 Request path: ${req.url}`, 'RequestHandler');
+            this.logger.debug(`📍 Request method: ${req.method}`, 'RequestHandler');
             this.logger.error('Request error', 'RequestHandler', {
                 error: error instanceof Error ? error.message : String(error),
                 requestId: httpReq.requestId,
@@ -271,7 +300,7 @@ export class MoroHttpServer {
                     }
                     else {
                         // Even setHeader doesn't exist - object is completely wrong
-                        this.logger.error('Response object is not a proper ServerResponse', 'RequestHandler', {
+                        this.logger.error('❌ Response object is not a proper ServerResponse:', 'RequestHandler', {
                             responseType: typeof httpRes,
                             responseKeys: Object.keys(httpRes),
                         });
@@ -284,7 +313,7 @@ export class MoroHttpServer {
                         }));
                     }
                     else {
-                        this.logger.error('Cannot send error response - end() method missing', 'RequestHandler');
+                        this.logger.error('❌ Cannot send error response - end() method missing', 'RequestHandler');
                     }
                 }
             }
@@ -422,19 +451,6 @@ export class MoroHttpServer {
         httpRes.json = async (data) => {
             if (httpRes.headersSent)
                 return;
-            // PERFORMANCE OPTIMIZATION: Check response cache for common patterns
-            const cacheKey = this.getResponseCacheKey(data);
-            if (cacheKey) {
-                const cachedBuffer = this.responseCache.get(cacheKey);
-                if (cachedBuffer) {
-                    this.responseCacheHits++;
-                    httpRes.setHeader('Content-Type', 'application/json; charset=utf-8');
-                    httpRes.setHeader('Content-Length', cachedBuffer.length);
-                    httpRes.end(cachedBuffer);
-                    return;
-                }
-                this.responseCacheMisses++;
-            }
             // Ultra-fast JSON serialization with zero-copy buffers
             let jsonString;
             // Enhanced JSON optimization for common API patterns
@@ -512,10 +528,6 @@ export class MoroHttpServer {
                 httpRes.setHeader(key, value);
             });
             httpRes.end(finalBuffer);
-            // PERFORMANCE OPTIMIZATION: Cache small, common responses
-            if (cacheKey && finalBuffer.length < 1024 && this.responseCache.size < 100) {
-                this.responseCache.set(cacheKey, Buffer.from(finalBuffer));
-            }
             // Return buffer to pool after response (zero-copy achievement!)
             process.nextTick(() => MoroHttpServer.returnBuffer(buffer));
         };
@@ -543,24 +555,6 @@ export class MoroHttpServer {
             httpRes.end(data);
         };
         httpRes.cookie = (name, value, options = {}) => {
-            if (httpRes.headersSent) {
-                const isCritical = options.critical ||
-                    name.includes('session') ||
-                    name.includes('auth') ||
-                    name.includes('csrf');
-                const message = `Cookie '${name}' could not be set - headers already sent`;
-                if (isCritical || options.throwOnLateSet) {
-                    throw new Error(`${message}. This may cause authentication or security issues.`);
-                }
-                else {
-                    this.logger.warn(message, 'CookieWarning', {
-                        cookieName: name,
-                        critical: isCritical,
-                        stackTrace: new Error().stack,
-                    });
-                }
-                return httpRes;
-            }
             const cookieValue = encodeURIComponent(value);
             let cookieString = `${name}=${cookieValue}`;
             if (options.maxAge)
@@ -600,8 +594,8 @@ export class MoroHttpServer {
             if (httpRes.headersSent)
                 return;
             try {
-                const fs = await import('fs/promises');
-                const path = await import('path');
+                const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                const path = await Promise.resolve().then(() => __importStar(require('path')));
                 const extension = path.extname(filePath);
                 const mime = await this.getMimeType(extension);
                 const stats = await fs.stat(filePath);
@@ -621,52 +615,6 @@ export class MoroHttpServer {
                 httpRes.status(404).json({ success: false, error: 'File not found' });
             }
         };
-        // Header management utilities
-        httpRes.hasHeader = (name) => {
-            return httpRes.getHeader(name) !== undefined;
-        };
-        // Note: removeHeader is inherited from ServerResponse, we don't override it
-        httpRes.setBulkHeaders = (headers) => {
-            if (httpRes.headersSent) {
-                this.logger.warn('Cannot set headers - headers already sent', 'HeaderWarning', {
-                    attemptedHeaders: Object.keys(headers),
-                });
-                return httpRes;
-            }
-            Object.entries(headers).forEach(([key, value]) => {
-                httpRes.setHeader(key, value);
-            });
-            return httpRes;
-        };
-        httpRes.appendHeader = (name, value) => {
-            if (httpRes.headersSent) {
-                this.logger.warn(`Cannot append to header '${name}' - headers already sent`, 'HeaderWarning');
-                return httpRes;
-            }
-            const existing = httpRes.getHeader(name);
-            if (existing) {
-                const values = Array.isArray(existing) ? existing : [existing.toString()];
-                const newValues = Array.isArray(value) ? value : [value];
-                httpRes.setHeader(name, [...values, ...newValues]);
-            }
-            else {
-                httpRes.setHeader(name, value);
-            }
-            return httpRes;
-        };
-        // Response state utilities
-        httpRes.canSetHeaders = () => {
-            return !httpRes.headersSent;
-        };
-        httpRes.getResponseState = () => {
-            return {
-                headersSent: httpRes.headersSent,
-                statusCode: httpRes.statusCode,
-                headers: httpRes.getHeaders ? httpRes.getHeaders() : {},
-                finished: httpRes.finished || false,
-                writable: httpRes.writable,
-            };
-        };
         return httpRes;
     }
     async getMimeType(ext) {
@@ -876,9 +824,7 @@ export class MoroHttpServer {
                             if (!nextCalled)
                                 next();
                         })
-                            .catch(error => {
-                            reject(error);
-                        });
+                            .catch(reject);
                     }
                 }
                 catch (error) {
@@ -912,44 +858,10 @@ export class MoroHttpServer {
     getServer() {
         return this.server;
     }
-    // PERFORMANCE OPTIMIZATION: Generate cache key for common response patterns
-    getResponseCacheKey(data) {
-        // Only cache simple, common responses
-        if (!data || typeof data !== 'object') {
-            // Simple primitives or strings - generate key
-            const key = JSON.stringify(data);
-            return key.length < 100 ? key : null;
-        }
-        // Common API response patterns
-        if ('hello' in data && Object.keys(data).length <= 2) {
-            // Hello world type responses
-            return `hello:${JSON.stringify(data)}`;
-        }
-        if ('status' in data && Object.keys(data).length <= 3) {
-            // Status responses like {status: "ok", version: "1.0.0"}
-            return `status:${JSON.stringify(data)}`;
-        }
-        if ('success' in data && 'message' in data && Object.keys(data).length <= 3) {
-            // Simple success/error responses
-            return `msg:${data.success}:${data.message}`;
-        }
-        // Don't cache complex objects
-        return null;
-    }
-    // Performance statistics
-    getPerformanceStats() {
-        return {
-            responseCacheHits: this.responseCacheHits,
-            responseCacheMisses: this.responseCacheMisses,
-            responseCacheSize: this.responseCache.size,
-            paramObjectPoolSize: this.paramObjectPool.length,
-            bufferPoolSize: this.bufferPool.length,
-            middlewareExecutionCacheSize: this.middlewareExecutionCache.size,
-        };
-    }
 }
+exports.MoroHttpServer = MoroHttpServer;
 // Built-in middleware
-export const middleware = {
+exports.middleware = {
     cors: (options = {}) => {
         return (req, res, next) => {
             res.setHeader('Access-Control-Allow-Origin', options.origin || '*');
@@ -977,6 +889,7 @@ export const middleware = {
         };
     },
     compression: (options = {}) => {
+        const zlib = require('zlib');
         const threshold = options.threshold || 1024;
         const level = options.level || 6;
         return (req, res, next) => {
@@ -991,26 +904,24 @@ export const middleware = {
                     return isJson ? originalJson.call(res, data) : originalSend.call(res, data);
                 }
                 if (acceptEncoding.includes('gzip')) {
+                    res.setHeader('Content-Encoding', 'gzip');
                     zlib.gzip(buffer, { level }, (err, compressed) => {
                         if (err) {
                             return isJson ? originalJson.call(res, data) : originalSend.call(res, data);
                         }
-                        if (!res.headersSent) {
-                            res.setHeader('Content-Encoding', 'gzip');
-                            res.setHeader('Content-Length', compressed.length);
-                        }
+                        res.setHeader('Content-Length', compressed.length);
+                        res.writeHead(res.statusCode || 200, res.getHeaders());
                         res.end(compressed);
                     });
                 }
                 else if (acceptEncoding.includes('deflate')) {
+                    res.setHeader('Content-Encoding', 'deflate');
                     zlib.deflate(buffer, { level }, (err, compressed) => {
                         if (err) {
                             return isJson ? originalJson.call(res, data) : originalSend.call(res, data);
                         }
-                        if (!res.headersSent) {
-                            res.setHeader('Content-Encoding', 'deflate');
-                            res.setHeader('Content-Length', compressed.length);
-                        }
+                        res.setHeader('Content-Length', compressed.length);
+                        res.writeHead(res.statusCode || 200, res.getHeaders());
                         res.end(compressed);
                     });
                 }
@@ -1065,9 +976,9 @@ export const middleware = {
                 return;
             }
             try {
-                const fs = await import('fs/promises');
-                const path = await import('path');
-                const crypto = await import('crypto');
+                const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                const path = await Promise.resolve().then(() => __importStar(require('path')));
+                const crypto = await Promise.resolve().then(() => __importStar(require('crypto')));
                 let filePath = path.join(options.root, req.path);
                 // Security: prevent directory traversal
                 if (!filePath.startsWith(path.resolve(options.root))) {
@@ -1235,8 +1146,8 @@ export const middleware = {
             // Add render method to response
             res.render = async (template, data = {}) => {
                 try {
-                    const fs = await import('fs/promises');
-                    const path = await import('path');
+                    const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                    const path = await Promise.resolve().then(() => __importStar(require('path')));
                     const templatePath = path.join(options.views, `${template}.html`);
                     let templateContent;
                     // Check cache first
@@ -1354,15 +1265,13 @@ export const middleware = {
             // Only handle SSE requests
             if (req.headers.accept?.includes('text/event-stream')) {
                 // Set SSE headers
-                if (!res.headersSent) {
-                    res.writeHead(200, {
-                        'Content-Type': 'text/event-stream',
-                        'Cache-Control': 'no-cache',
-                        Connection: 'keep-alive',
-                        'Access-Control-Allow-Origin': options.cors ? '*' : undefined,
-                        'Access-Control-Allow-Headers': options.cors ? 'Cache-Control' : undefined,
-                    });
-                }
+                res.writeHead(200, {
+                    'Content-Type': 'text/event-stream',
+                    'Cache-Control': 'no-cache',
+                    Connection: 'keep-alive',
+                    'Access-Control-Allow-Origin': options.cors ? '*' : undefined,
+                    'Access-Control-Allow-Headers': options.cors ? 'Cache-Control' : undefined,
+                });
                 // Add SSE methods to response
                 res.sendEvent = (data, event, id) => {
                     if (id)
@@ -1406,8 +1315,8 @@ export const middleware = {
             // Add range support to response
             res.sendRange = async (filePath, stats) => {
                 try {
-                    const fs = await import('fs/promises');
-                    const path = await import('path');
+                    const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+                    const path = await Promise.resolve().then(() => __importStar(require('path')));
                     if (!stats) {
                         stats = await fs.stat(filePath);
                     }
@@ -1443,8 +1352,7 @@ export const middleware = {
                         const { start, end } = ranges[0];
                         const chunkSize = end - start + 1;
                         if (start >= fileSize || end >= fileSize) {
-                            res.status(416);
-                            res.setHeader('Content-Range', `bytes */${fileSize}`);
+                            res.status(416).setHeader('Content-Range', `bytes */${fileSize}`);
                             res.json({ success: false, error: 'Range not satisfiable' });
                             return;
                         }
@@ -1452,7 +1360,7 @@ export const middleware = {
                         res.setHeader('Content-Range', `bytes ${start}-${end}/${fileSize}`);
                         res.setHeader('Content-Length', chunkSize);
                         // Stream the range
-                        const stream = createReadStream(filePath, {
+                        const stream = require('fs').createReadStream(filePath, {
                             start,
                             end,
                         });
@@ -1469,12 +1377,12 @@ export const middleware = {
                             const chunkSize = end - start + 1;
                             res.write(`\r\n--${boundary}\r\n`);
                             res.write(`Content-Range: bytes ${start}-${end}/${fileSize}\r\n\r\n`);
-                            const stream = createReadStream(filePath, {
+                            const stream = require('fs').createReadStream(filePath, {
                                 start,
                                 end,
                             });
                             await new Promise(resolve => {
-                                stream.on('end', () => resolve());
+                                stream.on('end', resolve);
                                 stream.pipe(res, { end: false });
                             });
                         }
@@ -1497,6 +1405,7 @@ export const middleware = {
         const headerName = options.headerName || 'x-csrf-token';
         const ignoreMethods = options.ignoreMethods || ['GET', 'HEAD', 'OPTIONS'];
         const generateToken = () => {
+            const crypto = require('crypto');
             return crypto.randomBytes(tokenLength).toString('hex');
         };
         const verifyToken = (token, sessionToken) => {
@@ -1553,6 +1462,7 @@ export const middleware = {
             // Generate nonce if requested
             let nonce;
             if (options.nonce) {
+                const crypto = require('crypto');
                 nonce = crypto.randomBytes(16).toString('base64');
                 req.cspNonce = nonce;
             }