hightjs 0.3.3 → 0.3.4

package/src/router.ts

@@ -50,16 +50,14 @@ function clearRequireCache(filePath: string) {
         const resolvedPath = require.resolve(filePath);
         delete require.cache[resolvedPath];
 
-        // Também limpa arquivos temporários relacionados
+        // Também limpa arquivos temporários relacionados (apenas se existir no cache)
         const tempFile = filePath.replace(/\.(tsx|ts)$/, '.temp.$1');
-        try {
-            const tempResolvedPath = require.resolve(tempFile);
-            delete require.cache[tempResolvedPath];
-        } catch {
-            // Arquivo temporário pode não existir
+        const tempResolvedPath = require.cache[require.resolve(tempFile)];
+        if (tempResolvedPath) {
+            delete require.cache[require.resolve(tempFile)];
         }
-    } catch (error) {
-        // Arquivo pode não estar no cache
+    } catch {
+        // Arquivo pode não estar no cache ou não ser resolvível
     }
 }
 
@@ -115,13 +113,10 @@ export function loadLayout(webDir: string): { componentPath: string; metadata?:
         fs.existsSync(layoutPathJs) ? layoutPathJs : null;
 
     if (layoutFile) {
-        const componentPath = path.relative(process.cwd(), layoutFile).replace(/\\/g, '/');
         const absolutePath = path.resolve(layoutFile);
+        const componentPath = path.relative(process.cwd(), layoutFile).replace(/\\/g, '/');
 
         try {
-            // Limpa o cache antes de recarregar
-            clearRequireCache(absolutePath);
-
             // HACK: Cria uma versão temporária do layout SEM imports de CSS para carregar no servidor
             const layoutContent = fs.readFileSync(layoutFile, 'utf8');
             const tempContent = layoutContent
@@ -132,8 +127,14 @@ export function loadLayout(webDir: string): { componentPath: string; metadata?:
             const tempFile = layoutFile.replace(/\.(tsx|ts)$/, '.temp.$1');
             fs.writeFileSync(tempFile, tempContent);
 
-            // Carrega o arquivo temporário sem CSS
-            delete require.cache[require.resolve(tempFile)];
+            // Otimização: limpa cache apenas se existir
+            try {
+                const resolvedPath = require.resolve(tempFile);
+                if (require.cache[resolvedPath]) {
+                    delete require.cache[resolvedPath];
+                }
+            } catch {}
+
             const layoutModule = require(tempFile);
 
             // Remove o arquivo temporário
@@ -147,7 +148,7 @@ export function loadLayout(webDir: string): { componentPath: string; metadata?:
             layoutComponent = { componentPath, metadata };
             return layoutComponent;
         } catch (error) {
-            Console.error(`Erro ao carregar layout ${layoutFile}:`, error);
+            Console.error(`Error loading layout ${layoutFile}:`, error);
             layoutComponent = { componentPath };
             return layoutComponent;
         }
@@ -171,41 +172,60 @@ export function getLayout(): { componentPath: string; metadata?: any } | null {
  */
 export function loadRoutes(routesDir: string): (RouteConfig & { componentPath: string })[] {
     if (!fs.existsSync(routesDir)) {
-        Console.warn(`Diretório de rotas de frontend não encontrado em ${routesDir}. Nenhuma página será carregada.`);
+        Console.warn(`Frontend routes directory not found at ${routesDir}. No page will be loaded.`);
         allRoutes = [];
         return allRoutes;
     }
 
-    const files = fs.readdirSync(routesDir, { recursive: true, encoding: 'utf-8' });
-    // Corrigindo o filtro para excluir corretamente o diretório backend
-    const routeFiles = files.filter(file => {
-        const isTypeScriptFile = file.endsWith('.ts') || file.endsWith('.tsx');
-        const isNotBackend = !file.includes('backend' + path.sep) && !file.includes('backend/');
-        return isTypeScriptFile && isNotBackend;
-    });
+    // Otimização: usa função recursiva manual para evitar overhead do recursive: true
+    const routeFiles: string[] = [];
+    const scanDirectory = (dir: string, baseDir: string = '') => {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const relativePath = baseDir ? path.join(baseDir, entry.name) : entry.name;
+
+            if (entry.isDirectory()) {
+                // Pula diretório backend inteiro
+                if (entry.name === 'backend') continue;
+                scanDirectory(path.join(dir, entry.name), relativePath);
+            } else if (entry.isFile()) {
+                // Filtra apenas arquivos .ts/.tsx
+                if (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx')) {
+                    routeFiles.push(relativePath);
+                }
+            }
+        }
+    };
+
+    scanDirectory(routesDir);
 
     const loaded: (RouteConfig & { componentPath: string })[] = [];
+    const cwdPath = process.cwd();
+
+    // Otimização: processa arquivos em lote
     for (const file of routeFiles) {
         const filePath = path.join(routesDir, file);
         const absolutePath = path.resolve(filePath);
-        // Usamos um caminho relativo ao CWD como um ID estável para o componente.
-        const componentPath = path.relative(process.cwd(), filePath).replace(/\\/g, '/');
 
         try {
-            // Limpa o cache antes de recarregar para pegar alterações nos metadados
-            clearRequireCache(absolutePath);
+            // Otimização: limpa cache apenas se já existir
+            const resolvedPath = require.resolve(filePath);
+            if (require.cache[resolvedPath]) {
+                delete require.cache[resolvedPath];
+            }
 
             const routeModule = require(filePath);
-            if (routeModule.default && routeModule.default.pattern && routeModule.default.component) {
+            if (routeModule.default?.pattern && routeModule.default?.component) {
+                // Otimização: calcula componentPath apenas uma vez
+                const componentPath = path.relative(cwdPath, filePath).replace(/\\/g, '/');
                 loaded.push({ ...routeModule.default, componentPath });
-
-                // Registra o arquivo como carregado
                 loadedRouteFiles.add(absolutePath);
             }
         } catch (error) {
-            Console.error(`Erro ao carregar a rota de página ${filePath}:`, error);
+            Console.error(`Error loading page route ${filePath}:`, error);
         }
     }
+
     allRoutes = loaded;
     return allRoutes;
 }
@@ -292,7 +312,7 @@ function loadMiddlewareFromDirectory(dir: string): HightMiddleware[] {
             }
 
         } catch (error) {
-            Console.error(`Erro ao carregar middleware ${middlewareFile}:`, error);
+            Console.error(`Error loading middleware ${middlewareFile}:`, error);
         }
     }
 
@@ -332,36 +352,98 @@ export function loadBackendRoutes(backendRoutesDir: string) {
     // Limpa cache de middlewares para recarregar
     loadedMiddlewares.clear();
 
-    const files = fs.readdirSync(backendRoutesDir, { recursive: true, encoding: 'utf-8' });
-    const routeFiles = files.filter(file => {
-        const isTypeScript = file.endsWith('.ts') || file.endsWith('.tsx');
-        const isNotMiddleware = !path.basename(file).startsWith('middleware');
-        return isTypeScript && isNotMiddleware;
-    });
+    // Otimização: usa função recursiva manual e coleta middlewares durante o scan
+    const routeFiles: string[] = [];
+    const middlewareFiles: Map<string, string> = new Map(); // dir -> filepath
+
+    const scanDirectory = (dir: string, baseDir: string = '') => {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+        for (const entry of entries) {
+            const relativePath = baseDir ? path.join(baseDir, entry.name) : entry.name;
+
+            if (entry.isDirectory()) {
+                scanDirectory(path.join(dir, entry.name), relativePath);
+            } else if (entry.isFile()) {
+                const isTypeScript = entry.name.endsWith('.ts') || entry.name.endsWith('.tsx');
+                if (!isTypeScript) continue;
+
+                // Identifica middlewares durante o scan
+                if (entry.name.startsWith('middleware')) {
+                    const dirPath = path.dirname(path.join(backendRoutesDir, relativePath));
+                    middlewareFiles.set(dirPath, path.join(backendRoutesDir, relativePath));
+                } else {
+                    routeFiles.push(relativePath);
+                }
+            }
+        }
+    };
 
+    scanDirectory(backendRoutesDir);
+
+    // Otimização: pré-carrega todos os middlewares em um único passe
+    for (const [dirPath, middlewarePath] of middlewareFiles) {
+        try {
+            const resolvedPath = require.resolve(middlewarePath);
+            if (require.cache[resolvedPath]) {
+                delete require.cache[resolvedPath];
+            }
+
+            const middlewareModule = require(middlewarePath);
+            const middlewares: HightMiddleware[] = [];
+
+            if (typeof middlewareModule.default === 'function') {
+                middlewares.push(middlewareModule.default);
+            } else if (Array.isArray(middlewareModule.default)) {
+                middlewares.push(...middlewareModule.default);
+            } else {
+                // Exports nomeados
+                for (const key in middlewareModule) {
+                    if (key !== 'default' && typeof middlewareModule[key] === 'function') {
+                        middlewares.push(middlewareModule[key]);
+                    }
+                }
+            }
+
+            if (middlewares.length > 0) {
+                loadedMiddlewares.set(dirPath, middlewares);
+            }
+        } catch (error) {
+            Console.error(`Error loading middleware ${middlewarePath}:`, error);
+        }
+    }
+
+    // Otimização: processa rotas com cache já limpo
     const loaded: BackendRouteConfig[] = [];
     for (const file of routeFiles) {
         const filePath = path.join(backendRoutesDir, file);
+
         try {
+            // Otimização: limpa cache apenas se existir
+            const resolvedPath = require.resolve(filePath);
+            if (require.cache[resolvedPath]) {
+                delete require.cache[resolvedPath];
+            }
+
             const routeModule = require(filePath);
-            if (routeModule.default && routeModule.default.pattern) {
+            if (routeModule.default?.pattern) {
                 const routeConfig = { ...routeModule.default };
-
-                // Se a rota NÃO tem a propriedade middleware definida, carrega os da pasta
+                // Se a rota NÃO tem middleware definido, usa os da pasta
                 if (!routeConfig.hasOwnProperty('middleware')) {
-                    const folderMiddlewares = collectMiddlewaresForRoute(filePath, backendRoutesDir);
-                    if (folderMiddlewares.length > 0) {
+                    const routeDir = path.dirname(path.resolve(filePath));
+                    const folderMiddlewares = loadedMiddlewares.get(routeDir);
+                    if (folderMiddlewares && folderMiddlewares.length > 0) {
                         routeConfig.middleware = folderMiddlewares;
                     }
                 }
-                // Se tem middleware definido (mesmo que seja []), usa só esses (não adiciona os da pasta)
 
                 loaded.push(routeConfig);
             }
         } catch (error) {
-            Console.error(`Erro ao carregar a rota de API ${filePath}:`, error);
+            Console.error(`Error loading API route ${filePath}:`, error);
         }
     }
+
     allBackendRoutes = loaded;
 }
 
@@ -411,12 +493,17 @@ export function loadNotFound(webDir: string): { componentPath: string } | null {
         fs.existsSync(notFoundPathJs) ? notFoundPathJs : null;
 
     if (notFoundFile) {
-        const componentPath = path.relative(process.cwd(), notFoundFile).replace(/\\/g, '/');
         const absolutePath = path.resolve(notFoundFile);
+        const componentPath = path.relative(process.cwd(), notFoundFile).replace(/\\/g, '/');
 
         try {
-            // Limpa o cache antes de recarregar
-            clearRequireCache(absolutePath);
+            // Otimização: limpa cache apenas se existir
+            try {
+                const resolvedPath = require.resolve(notFoundFile);
+                if (require.cache[resolvedPath]) {
+                    delete require.cache[resolvedPath];
+                }
+            } catch {}
 
             // Registra o arquivo como carregado
             loadedNotFoundFiles.add(absolutePath);
@@ -424,7 +511,7 @@ export function loadNotFound(webDir: string): { componentPath: string } | null {
             notFoundComponent = { componentPath };
             return notFoundComponent;
         } catch (error) {
-            Console.error(`Erro ao carregar notFound ${notFoundFile}:`, error);
+            Console.error(`Error loading notFound ${notFoundFile}:`, error);
             notFoundComponent = { componentPath };
             return notFoundComponent;
         }
@@ -464,7 +551,6 @@ export function processWebSocketRoutes() {
             };
 
             allWebSocketRoutes.push(wsRoute);
-            Console.info(`WebSocket route registered: ${route.pattern}`);
         }
     }
 }
@@ -506,7 +592,7 @@ function handleWebSocketConnection(ws: WebSocket, req: IncomingMessage, hwebReq:
 
     const matchedRoute = findMatchingWebSocketRoute(pathname);
     if (!matchedRoute) {
-        ws.close(1000, 'Rota não encontrada');
+        ws.close(1000, 'Route not found');
         return;
     }
 
@@ -543,8 +629,8 @@ function handleWebSocketConnection(ws: WebSocket, req: IncomingMessage, hwebReq:
     try {
         matchedRoute.route.handler(context);
     } catch (error) {
-        console.error('Erro no handler WebSocket:', error);
-        ws.close(1011, 'Erro interno do servidor');
+        console.error('Error in WebSocket handler:', error);
+        ws.close(1011, 'Internal server error');
     }
 }
 
@@ -587,17 +673,13 @@ export function setupWebSocketUpgrade(server: any, hotReloadManager?: any) {
         server.on('upgrade', (request: any, socket: any, head: Buffer) => {
             handleWebSocketUpgrade(request, socket, head, hotReloadManager);
         });
-    } else {
-        // Se já existe um listener (provavelmente do hot-reload),
-        // vamos interceptar e coordenar
-        console.log('🔧 Coordenando WebSocket upgrade com sistema existente');
     }
 }
 
 function handleWebSocketUpgrade(request: any, socket: any, head: Buffer, hotReloadManager?: any) {
     const adapter = FrameworkAdapterFactory.getCurrentAdapter()
     if (!adapter) {
-        console.error('❌ Framework adapter não detectado. Não é possível processar upgrade WebSocket.');
+        console.error('❌ Framework adapter not detected. Unable to process WebSocket upgrade.');
         socket.destroy();
         return;
     }
@@ -627,15 +709,12 @@ function handleWebSocketUpgrade(request: any, socket: any, head: Buffer, hotRelo
 
         wss.handleUpgrade(request, socket, head, (ws) => {
             wsConnections.add(ws);
-            console.log(`✅ WebSocket conectado em ${pathname}`);
 
             ws.on('close', () => {
                 wsConnections.delete(ws);
-                console.log(`❌ WebSocket desconectado de ${pathname}`);
             });
 
             ws.on('error', (error) => {
-                console.error(`💥 Erro WebSocket em ${pathname}:`, error);
                 wsConnections.delete(ws);
             });
 
@@ -645,7 +724,5 @@ function handleWebSocketUpgrade(request: any, socket: any, head: Buffer, hotRelo
         return;
     }
 
-    // Nenhuma rota encontrada - rejeita conexão
-    console.log(`🚫 Nenhuma rota WebSocket encontrada para: ${pathname}`);
     socket.destroy();
 }

package/src/types.ts

@@ -47,6 +47,58 @@ export interface HightJSOptions {
         ca?: string;
     };
 }
+
+// --- Tipos de Configuração ---
+
+/**
+ * Interface para as configurações avançadas do servidor HightJS.
+ * Essas configurações podem ser definidas no arquivo hightjs.config.js
+ */
+export interface HightConfig {
+    /**
+     * Limita o número máximo de headers HTTP permitidos por requisição.
+     * Padrão: 100
+     */
+    maxHeadersCount?: number;
+
+    /**
+     * Timeout em milissegundos para receber os headers HTTP.
+     * Padrão: 60000 (60 segundos)
+     */
+    headersTimeout?: number;
+
+    /**
+     * Timeout em milissegundos para uma requisição completa.
+     * Padrão: 30000 (30 segundos)
+     */
+    requestTimeout?: number;
+
+    /**
+     * Timeout geral do servidor em milissegundos.
+     * Padrão: 35000 (35 segundos)
+     */
+    serverTimeout?: number;
+
+    /**
+     * Timeout por requisição individual em milissegundos.
+     * Padrão: 30000 (30 segundos)
+     */
+    individualRequestTimeout?: number;
+
+    /**
+     * Tamanho máximo permitido para a URL em caracteres.
+     * Padrão: 2048
+     */
+    maxUrlLength?: number;
+}
+
+/**
+ * Tipo da função de configuração que pode ser exportada no hightjs.config.js
+ */
+export type HightConfigFunction = (
+    phase: string,
+    context: { defaultConfig: HightConfig }
+) => HightConfig | Promise<HightConfig>;
 export interface Metadata {
     title?: string;
     description?: string;

package/example/.hweb/entry.client.js

@@ -1,24 +0,0 @@
-// Arquivo gerado automaticamente pelo hweb
-import route0 from '../src/web/routes/index.tsx';
-import route1 from '../src/web/routes/login.tsx';
-import LayoutComponent from '../src/web/layout.tsx';
-
-import DefaultNotFound from '../node_modules/hightjs/src/client/DefaultNotFound.tsx';
-
-// Registra os componentes para o cliente
-window.__HWEB_COMPONENTS__ = {
-  'src/web/routes/index.tsx': route0.component || route0.default?.component,
-  'src/web/routes/login.tsx': route1.component || route1.default?.component,
-};
-
-// Registra o layout se existir
-window.__HWEB_LAYOUT__ = LayoutComponent.default || LayoutComponent;
-
-// Registra o notFound se existir
-window.__HWEB_NOT_FOUND__ = null;
-
-// Registra o DefaultNotFound do hweb
-window.__HWEB_DEFAULT_NOT_FOUND__ = DefaultNotFound;
-
-// Importa e executa o entry.client.tsx
-import '../node_modules/hightjs/src/client/entry.client.tsx';