hightjs 0.5.3 → 0.5.4

package/dist/router.js

@@ -0,0 +1,659 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAllRouteCache = clearAllRouteCache;
+exports.clearFileCache = clearFileCache;
+exports.loadLayout = loadLayout;
+exports.getLayout = getLayout;
+exports.loadRoutes = loadRoutes;
+exports.findMatchingRoute = findMatchingRoute;
+exports.loadBackendRoutes = loadBackendRoutes;
+exports.findMatchingBackendRoute = findMatchingBackendRoute;
+exports.loadNotFound = loadNotFound;
+exports.getNotFound = getNotFound;
+exports.processWebSocketRoutes = processWebSocketRoutes;
+exports.findMatchingWebSocketRoute = findMatchingWebSocketRoute;
+exports.setupWebSocketUpgrade = setupWebSocketUpgrade;
+/*
+ * This file is part of the HightJS Project.
+ * Copyright (c) 2025 itsmuzin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ws_1 = require("ws");
+const url_1 = require("url");
+const console_1 = __importDefault(require("./api/console"));
+const factory_1 = require("./adapters/factory");
+const http_1 = require("./api/http");
+// --- Roteamento do Frontend ---
+// Guarda todas as rotas de PÁGINA (React) encontradas
+// A rota agora também armazena o caminho do arquivo para ser usado como um ID único no cliente
+let allRoutes = [];
+// Guarda o layout se existir
+let layoutComponent = null;
+// Guarda o componente 404 personalizado se existir
+let notFoundComponent = null;
+// Cache de arquivos carregados para limpeza
+let loadedRouteFiles = new Set();
+let loadedLayoutFiles = new Set();
+let loadedNotFoundFiles = new Set();
+/**
+ * Limpa o cache do require para um arquivo específico
+ * @param filePath Caminho do arquivo para limpar
+ */
+function clearRequireCache(filePath) {
+    try {
+        const resolvedPath = require.resolve(filePath);
+        delete require.cache[resolvedPath];
+        // Também limpa arquivos temporários relacionados (apenas se existir no cache)
+        const tempFile = filePath.replace(/\.(tsx|ts|jsx|js)$/, '.temp.$1');
+        const tempResolvedPath = require.cache[require.resolve(tempFile)];
+        if (tempResolvedPath) {
+            delete require.cache[require.resolve(tempFile)];
+        }
+    }
+    catch {
+        // Arquivo pode não estar no cache ou não ser resolvível
+    }
+}
+// Nota: Suporte apenas para TypeScript (.ts, .tsx). Não tratamos .jsx aqui.
+/**
+ * Limpa todo o cache de rotas carregadas
+ */
+function clearAllRouteCache() {
+    // Limpa cache das rotas
+    loadedRouteFiles.forEach(filePath => {
+        clearRequireCache(filePath);
+    });
+    loadedRouteFiles.clear();
+    // Limpa cache do layout
+    loadedLayoutFiles.forEach(filePath => {
+        clearRequireCache(filePath);
+    });
+    loadedLayoutFiles.clear();
+    // Limpa cache do notFound
+    loadedNotFoundFiles.forEach(filePath => {
+        clearRequireCache(filePath);
+    });
+    loadedNotFoundFiles.clear();
+}
+/**
+ * Limpa o cache de um arquivo específico e recarrega as rotas se necessário
+ * @param changedFilePath Caminho do arquivo que foi alterado
+ */
+function clearFileCache(changedFilePath) {
+    const absolutePath = path_1.default.isAbsolute(changedFilePath) ? changedFilePath : path_1.default.resolve(changedFilePath);
+    // Limpa o cache do arquivo específico
+    clearRequireCache(absolutePath);
+    // Remove das listas de arquivos carregados
+    loadedRouteFiles.delete(absolutePath);
+    loadedLayoutFiles.delete(absolutePath);
+    loadedNotFoundFiles.delete(absolutePath);
+}
+/**
+ * Carrega o layout.tsx se existir no diretório web
+ * @param webDir O diretório web onde procurar o layout
+ * @returns O layout carregado ou null se não existir
+ */
+function loadLayout(webDir) {
+    const layoutPath = path_1.default.join(webDir, 'layout.tsx');
+    const layoutPathTs = path_1.default.join(webDir, 'layout.ts');
+    const layoutFile = fs_1.default.existsSync(layoutPath) ? layoutPath :
+        fs_1.default.existsSync(layoutPathTs) ? layoutPathTs : null;
+    if (layoutFile) {
+        const absolutePath = path_1.default.resolve(layoutFile);
+        const componentPath = path_1.default.relative(process.cwd(), layoutFile).replace(/\\/g, '/');
+        try {
+            // 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
+                .replace(/import\s+['"][^'"]*\.css['"];?/g, '// CSS import removido para servidor')
+                .replace(/import\s+['"][^'"]*\.scss['"];?/g, '// SCSS import removido para servidor')
+                .replace(/import\s+['"][^'"]*\.sass['"];?/g, '// SASS import removido para servidor');
+            // Escreve um arquivo temporário .temp.tsx ou .temp.ts sem imports de CSS
+            const ext = path_1.default.extname(layoutFile).toLowerCase();
+            const tempFile = layoutFile.replace(/\.(tsx|ts)$/i, '.temp.$1');
+            fs_1.default.writeFileSync(tempFile, tempContent, 'utf8');
+            // 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
+            try {
+                fs_1.default.unlinkSync(tempFile);
+            }
+            catch { }
+            const metadata = layoutModule.metadata || null;
+            // Registra o arquivo como carregado
+            loadedLayoutFiles.add(absolutePath);
+            layoutComponent = { componentPath, metadata };
+            return layoutComponent;
+        }
+        catch (error) {
+            console_1.default.error(`Error loading layout ${layoutFile}:`, error);
+            layoutComponent = { componentPath };
+            return layoutComponent;
+        }
+    }
+    layoutComponent = null;
+    return null;
+}
+/**
+ * Retorna o layout atual se carregado
+ */
+function getLayout() {
+    return layoutComponent;
+}
+/**
+ * Carrega dinamicamente todas as rotas de frontend do diretório do usuário.
+ * @param routesDir O diretório onde as rotas de página estão localizadas.
+ * @returns A lista de rotas de página que foram carregadas.
+ */
+function loadRoutes(routesDir) {
+    if (!fs_1.default.existsSync(routesDir)) {
+        console_1.default.warn(`Frontend routes directory not found at ${routesDir}. No page will be loaded.`);
+        allRoutes = [];
+        return allRoutes;
+    }
+    // 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);
+        try {
+            // 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?.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 });
+                loadedRouteFiles.add(absolutePath);
+            }
+        }
+        catch (error) {
+            console_1.default.error(`Error loading page route ${filePath}:`, error);
+        }
+    }
+    allRoutes = loaded;
+    return allRoutes;
+}
+/**
+ * Encontra a rota de página correspondente para uma URL.
+ * @param pathname O caminho da URL (ex: "/users/123").
+ * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
+ */
+function findMatchingRoute(pathname) {
+    for (const route of allRoutes) {
+        if (!route.pattern)
+            continue;
+        const regexPattern = route.pattern
+            // [[...param]] → opcional catch-all
+            .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
+            // [...param] → obrigatório catch-all
+            .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
+            // /[[param]] → opcional com barra também opcional
+            .replace(/\/\[\[(\w+)\]\]/g, '(?:/(?<$1>[^/]+))?')
+            // [[param]] → segmento opcional (sem barra anterior)
+            .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
+            // [param] → segmento obrigatório
+            .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+        // permite / opcional no final
+        const regex = new RegExp(`^${regexPattern}/?$`);
+        const match = pathname.match(regex);
+        if (match) {
+            return {
+                route,
+                params: match.groups || {}
+            };
+        }
+    }
+    return null;
+}
+// --- Roteamento do Backend ---
+// Guarda todas as rotas de API encontradas
+let allBackendRoutes = [];
+// Cache de middlewares carregados por diretório
+let loadedMiddlewares = new Map();
+/**
+ * Carrega middlewares de um diretório específico
+ * @param dir O diretório onde procurar por middleware.ts
+ * @returns Array de middlewares encontrados
+ */
+function loadMiddlewareFromDirectory(dir) {
+    const middlewares = [];
+    // Procura por middleware.ts, middleware.tsx
+    const middlewarePath = path_1.default.join(dir, 'middleware.ts');
+    const middlewarePathTsx = path_1.default.join(dir, 'middleware.tsx');
+    const middlewareFile = fs_1.default.existsSync(middlewarePath) ? middlewarePath :
+        fs_1.default.existsSync(middlewarePathTsx) ? middlewarePathTsx : null;
+    if (middlewareFile) {
+        try {
+            const absolutePath = path_1.default.resolve(middlewareFile);
+            clearRequireCache(absolutePath);
+            const middlewareModule = require(middlewareFile);
+            // Suporte para export default (função única) ou export { middleware1, middleware2 }
+            if (typeof middlewareModule.default === 'function') {
+                middlewares.push(middlewareModule.default);
+            }
+            else if (middlewareModule.default && Array.isArray(middlewareModule.default)) {
+                middlewares.push(...middlewareModule.default);
+            }
+            else {
+                // Procura por exports nomeados que sejam funções
+                Object.keys(middlewareModule).forEach(key => {
+                    if (key !== 'default' && typeof middlewareModule[key] === 'function') {
+                        middlewares.push(middlewareModule[key]);
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console_1.default.error(`Error loading middleware ${middlewareFile}:`, error);
+        }
+    }
+    return middlewares;
+}
+/**
+ * Coleta middlewares do diretório específico da rota (não herda dos pais)
+ * @param routeFilePath Caminho completo do arquivo de rota
+ * @param backendRoutesDir Diretório raiz das rotas de backend
+ * @returns Array com middlewares apenas do diretório da rota
+ */
+function collectMiddlewaresForRoute(routeFilePath, backendRoutesDir) {
+    const relativePath = path_1.default.relative(backendRoutesDir, routeFilePath);
+    const routeDir = path_1.default.dirname(path_1.default.join(backendRoutesDir, relativePath));
+    // Carrega middlewares APENAS do diretório específico da rota (não herda dos pais)
+    if (!loadedMiddlewares.has(routeDir)) {
+        const middlewares = loadMiddlewareFromDirectory(routeDir);
+        loadedMiddlewares.set(routeDir, middlewares);
+    }
+    return loadedMiddlewares.get(routeDir) || [];
+}
+/**
+ * Carrega dinamicamente todas as rotas de API do diretório de backend.
+ * @param backendRoutesDir O diretório onde as rotas de API estão localizadas.
+ */
+function loadBackendRoutes(backendRoutesDir) {
+    if (!fs_1.default.existsSync(backendRoutesDir)) {
+        // É opcional ter uma API, então não mostramos um aviso se a pasta não existir.
+        allBackendRoutes = [];
+        return;
+    }
+    // Limpa cache de middlewares para recarregar
+    loadedMiddlewares.clear();
+    // 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 isSupported = entry.name.endsWith('.ts') || entry.name.endsWith('.tsx');
+                if (!isSupported)
+                    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?.pattern) {
+                const routeConfig = { ...routeModule.default };
+                // Se a rota NÃO tem middleware definido, usa os da pasta
+                if (!routeConfig.hasOwnProperty('middleware')) {
+                    const routeDir = path_1.default.dirname(path_1.default.resolve(filePath));
+                    const folderMiddlewares = loadedMiddlewares.get(routeDir);
+                    if (folderMiddlewares && folderMiddlewares.length > 0) {
+                        routeConfig.middleware = folderMiddlewares;
+                    }
+                }
+                loaded.push(routeConfig);
+            }
+        }
+        catch (error) {
+            console_1.default.error(`Error loading API route ${filePath}:`, error);
+        }
+    }
+    allBackendRoutes = loaded;
+}
+/**
+ * Encontra a rota de API correspondente para uma URL e método HTTP.
+ * @param pathname O caminho da URL (ex: "/api/users/123").
+ * @param method O método HTTP da requisição (GET, POST, etc.).
+ * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
+ */
+function findMatchingBackendRoute(pathname, method) {
+    for (const route of allBackendRoutes) {
+        // Verifica se a rota tem um handler para o método HTTP atual
+        if (!route.pattern || !route[method.toUpperCase()])
+            continue;
+        const regexPattern = route.pattern
+            // [[...param]] → opcional catch-all
+            .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
+            // [...param] → obrigatório catch-all
+            .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
+            // [[param]] → segmento opcional
+            .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
+            // [param] → segmento obrigatório
+            .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+        const regex = new RegExp(`^${regexPattern}/?$`);
+        const match = pathname.match(regex);
+        if (match) {
+            return {
+                route,
+                params: match.groups || {}
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Carrega o notFound.tsx se existir no diretório web
+ * @param webDir O diretório web onde procurar o notFound
+ * @returns O notFound carregado ou null se não existir
+ */
+function loadNotFound(webDir) {
+    const notFoundPath = path_1.default.join(webDir, 'notFound.tsx');
+    const notFoundPathTs = path_1.default.join(webDir, 'notFound.ts');
+    const notFoundFile = fs_1.default.existsSync(notFoundPath) ? notFoundPath :
+        fs_1.default.existsSync(notFoundPathTs) ? notFoundPathTs : null;
+    if (notFoundFile) {
+        const absolutePath = path_1.default.resolve(notFoundFile);
+        const componentPath = path_1.default.relative(process.cwd(), notFoundFile).replace(/\\/g, '/');
+        try {
+            // 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(`Error loading notFound ${notFoundFile}:`, error);
+            notFoundComponent = { componentPath };
+            return notFoundComponent;
+        }
+    }
+    notFoundComponent = null;
+    return null;
+}
+/**
+ * Retorna o componente 404 atual se carregado
+ */
+function getNotFound() {
+    return notFoundComponent;
+}
+// --- WebSocket Functions ---
+// Guarda todas as rotas WebSocket encontradas
+let allWebSocketRoutes = [];
+// Conexões WebSocket ativas
+let wsConnections = new Set();
+/**
+ * Processa e registra rotas WebSocket encontradas nas rotas backend
+ */
+function processWebSocketRoutes() {
+    allWebSocketRoutes = [];
+    for (const route of allBackendRoutes) {
+        if (route.WS) {
+            const wsRoute = {
+                pattern: route.pattern,
+                handler: route.WS,
+                middleware: route.middleware
+            };
+            allWebSocketRoutes.push(wsRoute);
+        }
+    }
+}
+/**
+ * Encontra a rota WebSocket correspondente para uma URL
+ */
+function findMatchingWebSocketRoute(pathname) {
+    for (const route of allWebSocketRoutes) {
+        if (!route.pattern)
+            continue;
+        const regexPattern = route.pattern
+            .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
+            .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
+            .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
+            .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+        const regex = new RegExp(`^${regexPattern}/?$`);
+        const match = pathname.match(regex);
+        if (match) {
+            return {
+                route,
+                params: match.groups || {}
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Trata uma nova conexão WebSocket
+ */
+function handleWebSocketConnection(ws, req, hwebReq) {
+    if (!req.url)
+        return;
+    const url = new url_1.URL(req.url, `http://${req.headers.host}`);
+    const pathname = url.pathname;
+    const matchedRoute = findMatchingWebSocketRoute(pathname);
+    if (!matchedRoute) {
+        ws.close(1000, 'Route not found');
+        return;
+    }
+    const params = extractWebSocketParams(pathname, matchedRoute.route.pattern);
+    const query = Object.fromEntries(url.searchParams.entries());
+    const context = {
+        hightReq: hwebReq,
+        ws,
+        req,
+        url,
+        params,
+        query,
+        send: (data) => {
+            if (ws.readyState === ws_1.WebSocket.OPEN) {
+                const message = typeof data === 'string' ? data : JSON.stringify(data);
+                ws.send(message);
+            }
+        },
+        close: (code, reason) => {
+            ws.close(code || 1000, reason);
+        },
+        broadcast: (data, exclude) => {
+            const message = typeof data === 'string' ? data : JSON.stringify(data);
+            const excludeSet = new Set(exclude || []);
+            wsConnections.forEach(connection => {
+                if (connection.readyState === ws_1.WebSocket.OPEN && !excludeSet.has(connection)) {
+                    connection.send(message);
+                }
+            });
+        }
+    };
+    try {
+        matchedRoute.route.handler(context);
+    }
+    catch (error) {
+        console.error('Error in WebSocket handler:', error);
+        ws.close(1011, 'Internal server error');
+    }
+}
+/**
+ * Extrai parâmetros da URL para WebSocket
+ */
+function extractWebSocketParams(pathname, pattern) {
+    const params = {};
+    const regexPattern = pattern
+        .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
+        .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
+        .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
+        .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+    const regex = new RegExp(`^${regexPattern}/?$`);
+    const match = pathname.match(regex);
+    if (match && match.groups) {
+        Object.assign(params, match.groups);
+    }
+    return params;
+}
+/**
+ * Configura WebSocket upgrade no servidor HTTP existente
+ * @param server Servidor HTTP (Express, Fastify ou Native)
+ * @param hotReloadManager Instância do gerenciador de hot-reload para coordenação
+ */
+function setupWebSocketUpgrade(server, hotReloadManager) {
+    // NÃO remove listeners existentes para preservar hot-reload
+    // Em vez disso, coordena com o sistema existente
+    // Verifica se já existe um listener de upgrade
+    const existingListeners = server.listeners('upgrade');
+    // Se não há listeners, ou se o hot-reload ainda não foi configurado, adiciona o nosso
+    if (existingListeners.length === 0) {
+        server.on('upgrade', (request, socket, head) => {
+            handleWebSocketUpgrade(request, socket, head, hotReloadManager);
+        });
+    }
+}
+function handleWebSocketUpgrade(request, socket, head, hotReloadManager) {
+    const adapter = factory_1.FrameworkAdapterFactory.getCurrentAdapter();
+    if (!adapter) {
+        console.error('❌ Framework adapter not detected. Unable to process WebSocket upgrade.');
+        socket.destroy();
+        return;
+    }
+    const genericReq = adapter.parseRequest(request);
+    const hwebReq = new http_1.HightJSRequest(genericReq);
+    const { pathname } = new url_1.URL(request.url, `http://${request.headers.host}`);
+    // Prioridade 1: Hot reload (sistema interno)
+    if (pathname === '/hweb-hotreload/') {
+        if (hotReloadManager) {
+            hotReloadManager.handleUpgrade(request, socket, head);
+        }
+        else {
+            socket.destroy();
+        }
+        return;
+    }
+    // Prioridade 2: Rotas WebSocket do usuário
+    const matchedRoute = findMatchingWebSocketRoute(pathname);
+    if (matchedRoute) {
+        // Faz upgrade para WebSocket usando noServer
+        const wss = new ws_1.WebSocketServer({
+            noServer: true,
+            perMessageDeflate: false, // Melhor performance
+            maxPayload: 1024 * 1024 // Limite de 1MB
+        });
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wsConnections.add(ws);
+            ws.on('close', () => {
+                wsConnections.delete(ws);
+            });
+            ws.on('error', (error) => {
+                wsConnections.delete(ws);
+            });
+            // Processa a conexão
+            handleWebSocketConnection(ws, request, hwebReq);
+        });
+        return;
+    }
+    socket.destroy();
+}

package/dist/types/framework.d.ts

@@ -0,0 +1,37 @@
+export interface GenericRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string | string[]>;
+    body?: any;
+    query?: Record<string, any>;
+    params?: Record<string, string>;
+    cookies?: Record<string, string>;
+    raw?: any;
+}
+export interface GenericResponse {
+    status(code: number): GenericResponse;
+    header(name: string, value: string): GenericResponse;
+    cookie(name: string, value: string, options?: CookieOptions): GenericResponse;
+    clearCookie(name: string, options?: CookieOptions): GenericResponse;
+    json(data: any): void;
+    text(data: string): void;
+    send(data: any): void;
+    redirect(url: string): void;
+    raw?: any;
+}
+export interface CookieOptions {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    signed?: boolean;
+    sameSite?: boolean | 'lax' | 'strict' | 'none';
+}
+export type FrameworkType = 'express' | 'fastify' | 'native';
+export interface FrameworkAdapter {
+    type: FrameworkType;
+    parseRequest(req: any): GenericRequest;
+    createResponse(res: any): GenericResponse;
+}

package/dist/types/framework.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });