hightjs 0.3.2 → 0.3.4

package/dist/index.js

@@ -236,23 +236,20 @@ function hweb(options) {
                 await hotReloadManager.start();
                 // Adiciona callback para recarregar TUDO quando qualquer arquivo mudar
                 hotReloadManager.onBackendApiChange(() => {
-                    console_1.default.info('🔄 Recarregando backend e dependências...');
                     (0, router_1.loadBackendRoutes)(userBackendRoutesDir);
                     (0, router_1.processWebSocketRoutes)(); // Processa rotas WS após recarregar backend
                 });
                 // Adiciona callback para regenerar entry file quando frontend mudar
                 hotReloadManager.onFrontendChange(() => {
-                    console_1.default.info('🔄 Regenerando frontend...');
                     regenerateEntryFile();
                 });
             }
             const now = Date.now();
-            const timee = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} router ${console_1.Colors.Reset}   Carregando rotas e componentes do frontend e backend`);
+            const timee = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} router ${console_1.Colors.Reset}   Loading routes and components`);
             const spinnerFrames1 = ['|', '/', '-', '\\'];
             let frameIndex1 = 0;
             const spinner1 = setInterval(() => {
-                console_1.default.info('aaaa');
-                timee.update(`   ${console_1.Colors.FgYellow}${spinnerFrames1[frameIndex1]}${console_1.Colors.Reset}  Carregando rotas e componentes...`);
+                timee.update(`   ${console_1.Colors.FgYellow}${spinnerFrames1[frameIndex1]}${console_1.Colors.Reset}  Loading routes and components...`);
                 frameIndex1 = (frameIndex1 + 1) % spinnerFrames1.length;
             }, 100); // muda a cada 100ms
             // ORDEM IMPORTANTE: Carrega TUDO antes de criar o arquivo de entrada
@@ -267,14 +264,14 @@ function hweb(options) {
             fs_1.default.mkdirSync(outDir, { recursive: true });
             entryPoint = createEntryFile(dir, frontendRoutes);
             clearInterval(spinner1);
-            timee.end(`  ${console_1.Colors.BgGreen} router ${console_1.Colors.Reset}   Rotas e componentes carregados em ${Date.now() - now}ms`);
+            timee.end(`  ${console_1.Colors.BgGreen} router ${console_1.Colors.Reset}   Routes and components loaded in ${Date.now() - now}ms`);
             if (isProduction) {
-                const time = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} build ${console_1.Colors.Reset}    Iniciando build do cliente para produção`);
+                const time = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} build ${console_1.Colors.Reset}    Starting client build`);
                 // Spinner
                 const spinnerFrames = ['|', '/', '-', '\\'];
                 let frameIndex = 0;
                 const spinner = setInterval(() => {
-                    time.update(`    ${console_1.Colors.FgYellow}${spinnerFrames[frameIndex]}${console_1.Colors.Reset}  Buildando para produção...`);
+                    time.update(`    ${console_1.Colors.FgYellow}${spinnerFrames[frameIndex]}${console_1.Colors.Reset}  Building...`);
                     frameIndex = (frameIndex + 1) % spinnerFrames.length;
                 }, 100); // muda a cada 100ms
                 const now = Date.now();
@@ -282,14 +279,14 @@ function hweb(options) {
                 const elapsed = Date.now() - now;
                 clearInterval(spinner); // para o spinner
                 time.update(""); // limpa a linha
-                time.end(`  ${console_1.Colors.BgGreen} build ${console_1.Colors.Reset}    Build do cliente concluído em ${elapsed}ms`);
+                time.end(`  ${console_1.Colors.BgGreen} build ${console_1.Colors.Reset}    Client build completed in ${elapsed}ms`);
             }
             else {
-                const time = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} watcher ${console_1.Colors.Reset}  Iniciando watch do cliente`);
+                const time = console_1.default.dynamicLine(`  ${console_1.Colors.BgYellow} watcher ${console_1.Colors.Reset}  Starting client watch`);
                 (0, builder_1.watchWithChunks)(entryPoint, outDir, hotReloadManager).catch(err => {
-                    console_1.default.error(`Erro ao iniciar o watch`, err);
+                    console_1.default.error(`Error starting watch`, err);
                 });
-                time.end(`  ${console_1.Colors.BgGreen} watcher ${console_1.Colors.Reset}  Watch do cliente iniciado`);
+                time.end(`  ${console_1.Colors.BgGreen} watcher ${console_1.Colors.Reset}  Client Watch started`);
             }
         },
         executeInstrumentation: () => {
@@ -303,7 +300,6 @@ function hweb(options) {
                 if (instrumentation.hotReloadListener && typeof instrumentation.hotReloadListener === 'function') {
                     if (hotReloadManager) {
                         hotReloadManager.setHotReloadListener(instrumentation.hotReloadListener);
-                        console_1.default.info('✅ Hot reload listener registrado');
                     }
                 }
                 if (typeof instrumentation === 'function') {
@@ -313,7 +309,7 @@ function hweb(options) {
                     instrumentation.default();
                 }
                 else {
-                    console_1.default.warn(`O arquivo de instrumentação ${instrumentationFile} não exporta uma função padrão.`);
+                    console_1.default.warn(`The instrumentation file ${instrumentationFile} does not export a default function.`);
                 }
             }
         },
@@ -420,8 +416,8 @@ function hweb(options) {
                         }
                     }
                     catch (error) {
-                        console_1.default.error(`Erro na rota de API ${pathname}:`, error);
-                        genericRes.status(500).text('Erro interno do servidor na API');
+                        console_1.default.error(`API route error ${pathname}:`, error);
+                        genericRes.status(500).text('Internal server error in API');
                         return;
                     }
                 }
@@ -446,8 +442,8 @@ function hweb(options) {
                         return;
                     }
                     catch (error) {
-                        console_1.default.error(`Erro ao renderizar página 404:`, error);
-                        genericRes.status(404).text('Página não encontrada');
+                        console_1.default.error(`Error rendering page 404:`, error);
+                        genericRes.status(404).text('Page not found');
                         return;
                     }
                 }
@@ -461,8 +457,8 @@ function hweb(options) {
                     genericRes.status(200).header('Content-Type', 'text/html').send(html);
                 }
                 catch (error) {
-                    console_1.default.error(`Erro ao renderizar a página ${pathname}:`, error);
-                    genericRes.status(500).text('Erro interno do servidor');
+                    console_1.default.error(`Error rendering page ${pathname}:`, error);
+                    genericRes.status(500).text('Internal server error');
                 }
             };
         },
@@ -474,16 +470,6 @@ function hweb(options) {
             // Usa o sistema coordenado de WebSocket upgrade que integra hot-reload e rotas de usuário
             (0, router_1.setupWebSocketUpgrade)(actualServer, hotReloadManager);
         },
-        build: async () => {
-            const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgYellow}●  ${console_1.Colors.Reset}Iniciando build do cliente para produção`);
-            const outDir = path_1.default.join(dir, 'hweb-dist');
-            fs_1.default.mkdirSync(outDir, { recursive: true });
-            const routes = (0, router_1.loadRoutes)(userWebRoutesDir);
-            const entryPoint = createEntryFile(dir, routes);
-            const outfile = path_1.default.join(outDir, 'main.js');
-            await (0, builder_1.build)(entryPoint, outfile, true); // Força produção no build manual
-            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Build do cliente concluído: ${outfile}`);
-        },
         stop: () => {
             if (hotReloadManager) {
                 hotReloadManager.stop();

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,6 +27,48 @@ 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;
+}
+/**
+ * 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;