hightjs 0.3.3 → 0.3.5

package/dist/router.js

@@ -59,18 +59,15 @@ function clearRequireCache(filePath) {
     try {
         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
     }
 }
 /**
@@ -117,11 +114,9 @@ function loadLayout(webDir) {
     const layoutFile = fs_1.default.existsSync(layoutPath) ? layoutPath :
         fs_1.default.existsSync(layoutPathJs) ? layoutPathJs : null;
     if (layoutFile) {
-        const componentPath = path_1.default.relative(process.cwd(), layoutFile).replace(/\\/g, '/');
         const absolutePath = path_1.default.resolve(layoutFile);
+        const componentPath = path_1.default.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_1.default.readFileSync(layoutFile, 'utf8');
             const tempContent = layoutContent
@@ -130,8 +125,14 @@ function loadLayout(webDir) {
                 .replace(/import\s+['"][^'"]*\.sass['"];?/g, '// SASS import removido para servidor');
             const tempFile = layoutFile.replace(/\.(tsx|ts)$/, '.temp.$1');
             fs_1.default.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
             fs_1.default.unlinkSync(tempFile);
@@ -142,7 +143,7 @@ function loadLayout(webDir) {
             return layoutComponent;
         }
         catch (error) {
-            console_1.default.error(`Erro ao carregar layout ${layoutFile}:`, error);
+            console_1.default.error(`Error loading layout ${layoutFile}:`, error);
             layoutComponent = { componentPath };
             return layoutComponent;
         }
@@ -163,35 +164,53 @@ function getLayout() {
  */
 function loadRoutes(routesDir) {
     if (!fs_1.default.existsSync(routesDir)) {
-        console_1.default.warn(`Diretório de rotas de frontend não encontrado em ${routesDir}. Nenhuma página será carregada.`);
+        console_1.default.warn(`Frontend routes directory not found at ${routesDir}. No page will be loaded.`);
         allRoutes = [];
         return allRoutes;
     }
-    const files = fs_1.default.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_1.default.sep) && !file.includes('backend/');
-        return isTypeScriptFile && isNotBackend;
-    });
+    // Otimização: usa função recursiva manual para evitar overhead do recursive: true
+    const routeFiles = [];
+    const scanDirectory = (dir, baseDir = '') => {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const relativePath = baseDir ? path_1.default.join(baseDir, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                // Pula diretório backend inteiro
+                if (entry.name === 'backend')
+                    continue;
+                scanDirectory(path_1.default.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 = [];
+    const cwdPath = process.cwd();
+    // Otimização: processa arquivos em lote
     for (const file of routeFiles) {
         const filePath = path_1.default.join(routesDir, file);
         const absolutePath = path_1.default.resolve(filePath);
-        // Usamos um caminho relativo ao CWD como um ID estável para o componente.
-        const componentPath = path_1.default.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_1.default.relative(cwdPath, filePath).replace(/\\/g, '/');
                 loaded.push({ ...routeModule.default, componentPath });
-                // Registra o arquivo como carregado
                 loadedRouteFiles.add(absolutePath);
             }
         }
         catch (error) {
-            console_1.default.error(`Erro ao carregar a rota de página ${filePath}:`, error);
+            console_1.default.error(`Error loading page route ${filePath}:`, error);
         }
     }
     allRoutes = loaded;
@@ -268,7 +287,7 @@ function loadMiddlewareFromDirectory(dir) {
             }
         }
         catch (error) {
-            console_1.default.error(`Erro ao carregar middleware ${middlewareFile}:`, error);
+            console_1.default.error(`Error loading middleware ${middlewareFile}:`, error);
         }
     }
     return middlewares;
@@ -301,32 +320,89 @@ function loadBackendRoutes(backendRoutesDir) {
     }
     // Limpa cache de middlewares para recarregar
     loadedMiddlewares.clear();
-    const files = fs_1.default.readdirSync(backendRoutesDir, { recursive: true, encoding: 'utf-8' });
-    const routeFiles = files.filter(file => {
-        const isTypeScript = file.endsWith('.ts') || file.endsWith('.tsx');
-        const isNotMiddleware = !path_1.default.basename(file).startsWith('middleware');
-        return isTypeScript && isNotMiddleware;
-    });
+    // Otimização: usa função recursiva manual e coleta middlewares durante o scan
+    const routeFiles = [];
+    const middlewareFiles = new Map(); // dir -> filepath
+    const scanDirectory = (dir, baseDir = '') => {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const relativePath = baseDir ? path_1.default.join(baseDir, entry.name) : entry.name;
+            if (entry.isDirectory()) {
+                scanDirectory(path_1.default.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_1.default.dirname(path_1.default.join(backendRoutesDir, relativePath));
+                    middlewareFiles.set(dirPath, path_1.default.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 = [];
+            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_1.default.error(`Error loading middleware ${middlewarePath}:`, error);
+        }
+    }
+    // Otimização: processa rotas com cache já limpo
     const loaded = [];
     for (const file of routeFiles) {
         const filePath = path_1.default.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_1.default.dirname(path_1.default.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_1.default.error(`Erro ao carregar a rota de API ${filePath}:`, error);
+            console_1.default.error(`Error loading API route ${filePath}:`, error);
         }
     }
     allBackendRoutes = loaded;
@@ -373,18 +449,24 @@ function loadNotFound(webDir) {
     const notFoundFile = fs_1.default.existsSync(notFoundPath) ? notFoundPath :
         fs_1.default.existsSync(notFoundPathJs) ? notFoundPathJs : null;
     if (notFoundFile) {
-        const componentPath = path_1.default.relative(process.cwd(), notFoundFile).replace(/\\/g, '/');
         const absolutePath = path_1.default.resolve(notFoundFile);
+        const componentPath = path_1.default.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);
             notFoundComponent = { componentPath };
             return notFoundComponent;
         }
         catch (error) {
-            console_1.default.error(`Erro ao carregar notFound ${notFoundFile}:`, error);
+            console_1.default.error(`Error loading notFound ${notFoundFile}:`, error);
             notFoundComponent = { componentPath };
             return notFoundComponent;
         }
@@ -416,7 +498,6 @@ function processWebSocketRoutes() {
                 middleware: route.middleware
             };
             allWebSocketRoutes.push(wsRoute);
-            console_1.default.info(`WebSocket route registered: ${route.pattern}`);
         }
     }
 }
@@ -453,7 +534,7 @@ function handleWebSocketConnection(ws, req, hwebReq) {
     const pathname = url.pathname;
     const matchedRoute = findMatchingWebSocketRoute(pathname);
     if (!matchedRoute) {
-        ws.close(1000, 'Rota não encontrada');
+        ws.close(1000, 'Route not found');
         return;
     }
     const params = extractWebSocketParams(pathname, matchedRoute.route.pattern);
@@ -488,8 +569,8 @@ function handleWebSocketConnection(ws, req, hwebReq) {
         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');
     }
 }
 /**
@@ -525,16 +606,11 @@ function setupWebSocketUpgrade(server, hotReloadManager) {
             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, socket, head, hotReloadManager) {
     const adapter = factory_1.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;
     }
@@ -562,13 +638,10 @@ function handleWebSocketUpgrade(request, socket, head, hotReloadManager) {
         });
         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);
             });
             // Processa a conexão
@@ -576,7 +649,5 @@ function handleWebSocketUpgrade(request, socket, head, hotReloadManager) {
         });
         return;
     }
-    // Nenhuma rota encontrada - rejeita conexão
-    console.log(`🚫 Nenhuma rota WebSocket encontrada para: ${pathname}`);
     socket.destroy();
 }

package/dist/types.d.ts

@@ -27,10 +27,91 @@ export interface HightJSOptions {
         ca?: string;
     };
 }
+/**
+ * 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;
+    /**
+     * Habilita o log de acesso HTTP (ex: GET /api/users 200 15ms).
+     * Padrão: false
+     */
+    accessLogging?: boolean;
+}
+/**
+ * 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;
+    keywords?: string | string[];
+    author?: string;
     favicon?: string;
+    viewport?: string;
+    themeColor?: string;
+    canonical?: string;
+    robots?: string;
+    openGraph?: {
+        title?: string;
+        description?: string;
+        type?: string;
+        url?: string;
+        image?: string | {
+            url: string;
+            width?: number;
+            height?: number;
+            alt?: string;
+        };
+        siteName?: string;
+        locale?: string;
+    };
+    twitter?: {
+        card?: 'summary' | 'summary_large_image' | 'app' | 'player';
+        site?: string;
+        creator?: string;
+        title?: string;
+        description?: string;
+        image?: string;
+        imageAlt?: string;
+    };
+    language?: string;
+    charset?: string;
+    appleTouchIcon?: string;
+    manifest?: string;
+    other?: Record<string, string>;
 }
 export interface RouteConfig {
     pattern: string;

package/docs/config.md

@@ -0,0 +1,216 @@
+# HightJS Configuration (hightjs.config.ts)
+
+O HightJS permite que você personalize as configurações do servidor através de um arquivo `hightjs.config.ts` (ou `.js`) na raiz do seu projeto.
+
+## 📝 Estrutura Básica
+
+### Opção 1: Função de Configuração (Recomendado)
+
+```typescript
+import type { HightConfig, HightConfigFunction } from 'hightjs';
+
+const hightConfig: HightConfigFunction = (phase, { defaultConfig }) => {
+    const config: HightConfig = {
+        maxHeadersCount: 100,
+        headersTimeout: 60000,
+        requestTimeout: 30000,
+        serverTimeout: 35000,
+        individualRequestTimeout: 30000,
+        maxUrlLength: 2048,
+    };
+
+    // Personalize baseado no ambiente
+    if (phase === 'development') {
+        config.requestTimeout = 60000;
+        config.individualRequestTimeout = 60000;
+    }
+
+    if (phase === 'production') {
+        config.maxHeadersCount = 50;
+        config.maxUrlLength = 1024;
+    }
+
+    return config;
+};
+
+export default hightConfig;
+```
+
+### Opção 2: Objeto Estático
+
+```typescript
+import type { HightConfig } from 'hightjs';
+
+const config: HightConfig = {
+    maxHeadersCount: 100,
+    headersTimeout: 60000,
+    requestTimeout: 30000,
+    serverTimeout: 35000,
+    individualRequestTimeout: 30000,
+    maxUrlLength: 2048,
+};
+
+export default config;
+```
+
+## ⚙️ Configurações Disponíveis
+
+| Propriedade | Tipo | Padrão | Descrição |
+|------------|------|--------|-----------|
+| `maxHeadersCount` | `number` | `100` | Número máximo de headers HTTP permitidos por requisição |
+| `headersTimeout` | `number` | `60000` | Timeout em ms para receber os headers HTTP |
+| `requestTimeout` | `number` | `30000` | Timeout em ms para uma requisição completa |
+| `serverTimeout` | `number` | `35000` | Timeout geral do servidor em ms |
+| `individualRequestTimeout` | `number` | `30000` | Timeout por requisição individual em ms |
+| `maxUrlLength` | `number` | `2048` | Tamanho máximo da URL em caracteres |
+| `accessLogging` | `boolean` | `false` | Habilita logs de acesso HTTP (ex: `GET /api/users 200 15ms`) |
+
+## 🎯 Casos de Uso
+
+### Habilitar Logs de Acesso
+
+```typescript
+const config: HightConfig = {
+    accessLogging: true, // Mostra: GET /api/users 200 15ms
+};
+```
+
+### Aumentar Timeouts para Debugging
+
+```typescript
+const config: HightConfig = {
+    requestTimeout: 120000, // 2 minutos
+    individualRequestTimeout: 120000,
+};
+```
+
+### Aumentar Limites para APIs com Muitos Headers
+
+```typescript
+const config: HightConfig = {
+    maxHeadersCount: 200, // Dobro do padrão
+};
+```
+
+### Configuração Rigorosa para Produção
+
+```typescript
+const hightConfig: HightConfigFunction = (phase) => {
+    if (phase === 'production') {
+        return {
+            maxHeadersCount: 50,
+            maxUrlLength: 1024,
+            requestTimeout: 15000, // Mais restritivo
+            individualRequestTimeout: 15000,
+        };
+    }
+    
+    // Valores padrão para desenvolvimento
+    return {};
+};
+```
+
+### Suporte a URLs Muito Longas
+
+```typescript
+const config: HightConfig = {
+    maxUrlLength: 4096, // Dobro do padrão
+};
+```
+
+## 🔄 Hot Reload
+
+Em modo de desenvolvimento (`dev: true`), o arquivo de configuração é recarregado automaticamente quando modificado, permitindo ajustes sem reiniciar o servidor.
+
+## 📦 TypeScript vs JavaScript
+
+### TypeScript (Recomendado)
+- Arquivo: `hightjs.config.ts`
+- Benefícios: Autocomplete, validação de tipos, detecção de erros
+
+### JavaScript
+- Arquivo: `hightjs.config.js`
+- Use JSDoc para ter intellisense:
+
+```javascript
+/**
+ * @type {import('hightjs').HightConfigFunction}
+ */
+const hightConfig = (phase, { defaultConfig }) => {
+    /** @type {import('hightjs').HightConfig} */
+    const config = {
+        maxHeadersCount: 100,
+    };
+    
+    return config;
+};
+
+module.exports = hightConfig;
+```
+
+## 🚀 Exemplo Completo
+
+```typescript
+import type { HightConfig, HightConfigFunction } from 'hightjs';
+
+const hightConfig: HightConfigFunction = (phase, { defaultConfig }) => {
+    // Começa com valores padrão
+    const config: HightConfig = { ...defaultConfig };
+
+    // Configurações comuns
+    config.maxHeadersCount = 150;
+
+    // Ajustes por ambiente
+    if (phase === 'development') {
+        // Habilita logs de acesso em dev
+        config.accessLogging = true;
+        
+        // Timeouts maiores para debugging
+        config.requestTimeout = 120000;
+        config.individualRequestTimeout = 120000;
+        
+        // URLs longas para testes
+        config.maxUrlLength = 4096;
+    } else if (phase === 'production') {
+        // Logs de acesso também podem ser úteis em produção
+        config.accessLogging = true;
+        
+        // Mais restritivo em produção
+        config.maxHeadersCount = 50;
+        config.maxUrlLength = 1024;
+        config.requestTimeout = 20000;
+        config.individualRequestTimeout = 20000;
+        
+        // Timeouts mais curtos para headers
+        config.headersTimeout = 30000;
+        config.serverTimeout = 25000;
+    }
+
+    return config;
+};
+
+export default hightConfig;
+```
+
+## 📍 Localização do Arquivo
+
+O arquivo `hightjs.config.ts` (ou `.js`) deve estar na **raiz do seu projeto**, no mesmo nível do `package.json`.
+
+```
+seu-projeto/
+├── hightjs.config.ts  ← Aqui
+├── package.json
+├── tsconfig.json
+└── src/
+    └── web/
+        └── ...
+```
+
+## ⚠️ Notas Importantes
+
+1. **Prioridade**: `.ts` tem prioridade sobre `.js` se ambos existirem
+2. **Fallback**: Se o arquivo não existir, valores padrão serão usados
+3. **Validação**: Valores inválidos serão ignorados e substituídos pelos padrões
+4. **Performance**: Use valores apropriados para evitar timeouts desnecessários ou aberturas de segurança
+5. **Segurança**: Não exponha valores muito altos em produção (ex: `maxUrlLength` muito grande pode facilitar ataques DoS)
+