hightjs 0.2.41 → 0.2.43

package/dist/index.js

@@ -60,7 +60,6 @@ Object.defineProperty(exports, "FrameworkAdapterFactory", { enumerable: true, ge
 // Exporta os helpers para facilitar integração
 var helpers_1 = require("./helpers");
 Object.defineProperty(exports, "app", { enumerable: true, get: function () { return helpers_1.app; } });
-// Exporta o sistema de autenticação
 // Função para verificar se o projeto é grande o suficiente para se beneficiar de chunks
 function isLargeProject(projectDir) {
     try {
@@ -210,25 +209,30 @@ function hweb(options) {
         // Regenera o entry file
         entryPoint = createEntryFile(dir, frontendRoutes);
     };
-    const app = {
+    return {
         prepare: async () => {
             const isProduction = !dev;
             if (!isProduction) {
-                // Inicia hot reload apenas em desenvolvimento (sem logs)
+                // Inicia hot reload apenas em desenvolvimento (com suporte ao main)
                 hotReloadManager = new hotReload_1.HotReloadManager(dir);
                 await hotReloadManager.start();
-                // Adiciona callback para recarregar rotas de backend quando mudarem
+                // 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();
                 });
             }
             // ORDEM IMPORTANTE: Carrega TUDO antes de criar o arquivo de entrada
             frontendRoutes = (0, router_1.loadRoutes)(userWebRoutesDir);
             (0, router_1.loadBackendRoutes)(userBackendRoutesDir);
+            // Processa rotas WebSocket após carregar backend
+            (0, router_1.processWebSocketRoutes)();
             // Carrega layout.tsx ANTES de criar o entry file
             const layout = (0, router_1.loadLayout)(userWebDir);
             const notFound = (0, router_1.loadNotFound)(userWebDir);
@@ -269,6 +273,13 @@ function hweb(options) {
                 const instrumentationPath = path_1.default.join(dir, 'src', instrumentationFile);
                 // dar require, e executar a função principal do arquivo
                 const instrumentation = require(instrumentationPath);
+                // Registra o listener de hot reload se existir
+                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') {
                     instrumentation();
                 }
@@ -431,34 +442,11 @@ function hweb(options) {
         },
         // Método para configurar WebSocket upgrade nos servidores Express e Fastify
         setupWebSocket: (server) => {
-            if (hotReloadManager) {
-                // Detecta se é um servidor Express ou Fastify
-                const isExpressServer = factory_1.FrameworkAdapterFactory.getCurrentAdapter() instanceof express_1.ExpressAdapter;
-                if (isExpressServer) {
-                    server.on('upgrade', (request, socket, head) => {
-                        const { pathname } = new URL(request.url, `http://${request.headers.host}`);
-                        if (pathname === '/hweb-hotreload/') {
-                            hotReloadManager.handleUpgrade(request, socket, head);
-                        }
-                        else {
-                            socket.destroy();
-                        }
-                    });
-                }
-                else {
-                    // Fastify usa um approach diferente para WebSockets
-                    const actualServer = server.server || server;
-                    actualServer.on('upgrade', (request, socket, head) => {
-                        const { pathname } = new URL(request.url, `http://${request.headers.host}`);
-                        if (pathname === '/hweb-hotreload/') {
-                            hotReloadManager.handleUpgrade(request, socket, head);
-                        }
-                        else {
-                            socket.destroy();
-                        }
-                    });
-                }
-            }
+            // Detecta se é um servidor Express ou Fastify
+            const isExpressServer = factory_1.FrameworkAdapterFactory.getCurrentAdapter() instanceof express_1.ExpressAdapter;
+            const actualServer = isExpressServer ? server : (server.server || server);
+            // 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`);
@@ -476,5 +464,4 @@ function hweb(options) {
             }
         }
     };
-    return app;
 }

package/dist/renderer.js

@@ -16,7 +16,7 @@ function encodeInitialData(data) {
 }
 function createDecodeScript() {
     return `
-    const process = { env: { NODE_ENV: '${process.env.NODE_ENV || 'development'}' } };
+    
     window.__HWEB_DECODE__ = function(encoded) { const base64 = encoded.replace('hweb_', '').replace('_config', ''); const jsonStr = atob(base64); return JSON.parse(jsonStr); };
     `;
 }

package/dist/router.d.ts

@@ -1,4 +1,4 @@
-import { RouteConfig, BackendRouteConfig } from './types';
+import { RouteConfig, BackendRouteConfig, HightMiddleware, WebSocketHandler } from './types';
 /**
  * Limpa todo o cache de rotas carregadas
  */
@@ -76,3 +76,26 @@ export declare function loadNotFound(webDir: string): {
 export declare function getNotFound(): {
     componentPath: string;
 } | null;
+/**
+ * Processa e registra rotas WebSocket encontradas nas rotas backend
+ */
+export declare function processWebSocketRoutes(): void;
+/**
+ * Encontra a rota WebSocket correspondente para uma URL
+ */
+export declare function findMatchingWebSocketRoute(pathname: string): {
+    route: {
+        pattern: string;
+        handler: WebSocketHandler;
+        middleware?: HightMiddleware[];
+    };
+    params: {
+        [key: string]: string;
+    };
+} | null;
+/**
+ * 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
+ */
+export declare function setupWebSocketUpgrade(server: any, hotReloadManager?: any): void;

package/dist/router.js

@@ -13,9 +13,16 @@ exports.loadBackendRoutes = loadBackendRoutes;
 exports.findMatchingBackendRoute = findMatchingBackendRoute;
 exports.loadNotFound = loadNotFound;
 exports.getNotFound = getNotFound;
+exports.processWebSocketRoutes = processWebSocketRoutes;
+exports.findMatchingWebSocketRoute = findMatchingWebSocketRoute;
+exports.setupWebSocketUpgrade = setupWebSocketUpgrade;
 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
@@ -183,8 +190,18 @@ function findMatchingRoute(pathname) {
     for (const route of allRoutes) {
         if (!route.pattern)
             continue;
-        // Converte o padrão da rota (ex: /users/[id]) em uma RegExp
-        const regexPattern = route.pattern.replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+        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) {
@@ -365,3 +382,186 @@ function loadNotFound(webDir) {
 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);
+            console_1.default.info(`WebSocket route registered: ${route.pattern}`);
+        }
+    }
+}
+/**
+ * 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, 'Rota não encontrada');
+        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('Erro no handler WebSocket:', error);
+        ws.close(1011, 'Erro interno do servidor');
+    }
+}
+/**
+ * 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);
+        });
+    }
+    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.');
+        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 {
+            console.warn('⚠️ Hot-reload manager não disponível para:', pathname);
+            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);
+            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
+            handleWebSocketConnection(ws, request, hwebReq);
+        });
+        return;
+    }
+    // Nenhuma rota encontrada - rejeita conexão
+    console.log(`🚫 Nenhuma rota WebSocket encontrada para: ${pathname}`);
+    socket.destroy();
+}

package/dist/ssl/selfSigned.js

@@ -0,0 +1 @@
+"use strict";

package/dist/types/websocket.d.ts

@@ -0,0 +1,27 @@
+import { IncomingMessage } from 'http';
+import { WebSocket } from 'ws';
+export interface WebSocketContext {
+    ws: WebSocket;
+    req: IncomingMessage;
+    url: URL;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    send: (data: any) => void;
+    close: (code?: number, reason?: string) => void;
+    broadcast: (data: any, exclude?: WebSocket[]) => void;
+}
+export interface WebSocketHandler {
+    (ctx: WebSocketContext): void | Promise<void>;
+}
+export interface WebSocketRoute {
+    path: string;
+    handler: WebSocketHandler;
+    pathPattern?: RegExp;
+    paramNames?: string[];
+}
+export interface WebSocketServer {
+    route: (path: string, handler: WebSocketHandler) => void;
+    start: (port?: number) => void;
+    broadcast: (data: any) => void;
+    getConnections: () => WebSocket[];
+}

package/dist/types/websocket.js

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

package/dist/types.d.ts

@@ -1,6 +1,19 @@
 import type { ComponentType } from 'react';
 import type { GenericRequest } from './types/framework';
 import { HightJSRequest, HightJSResponse } from "./api/http";
+import { WebSocket } from 'ws';
+import { IncomingMessage } from 'http';
+export interface WebSocketContext {
+    ws: WebSocket;
+    req: IncomingMessage;
+    hightReq: HightJSRequest;
+    url: URL;
+    params: Record<string, string>;
+    query: Record<string, string>;
+    send: (data: any) => void;
+    close: (code?: number, reason?: string) => void;
+    broadcast: (data: any, exclude?: WebSocket[]) => void;
+}
 export interface HightJSOptions {
     dev?: boolean;
     hostname?: string;
@@ -31,7 +44,11 @@ params: {
     [key: string]: string;
 }, next: () => Promise<HightJSResponse>) => Promise<HightJSResponse> | HightJSResponse;
 /**
- * Define a estrutura de cada rota da API, com suporte para métodos HTTP.
+ * Define o formato de uma função que manipula uma rota WebSocket.
+ */
+export type WebSocketHandler = (context: WebSocketContext) => Promise<void> | void;
+/**
+ * Define a estrutura de cada rota da API, com suporte para métodos HTTP e WebSocket.
  */
 export interface BackendRouteConfig {
     pattern: string;
@@ -39,5 +56,6 @@ export interface BackendRouteConfig {
     POST?: BackendHandler;
     PUT?: BackendHandler;
     DELETE?: BackendHandler;
+    WS?: WebSocketHandler;
     middleware?: HightMiddleware[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hightjs",
-  "version": "0.2.41",
+  "version": "0.2.43",
   "description": "HightJS is a high-level framework for building web applications with ease and speed. It provides a robust set of tools and features to streamline development and enhance productivity.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/auth/core.ts

@@ -70,7 +70,7 @@ export class HWebAuth {
 
             // Callback de sessão se definido
             if (this.config.callbacks?.session) {
-                sessionResult.session = await this.config.callbacks.session(sessionResult.session, user);
+                sessionResult.session = await this.config.callbacks.session({session: sessionResult.session, user, provider: providerId});
             }
 
             return sessionResult;
@@ -103,7 +103,7 @@ export class HWebAuth {
             .clearCookie('hweb-auth-token', {
                 path: '/',
                 httpOnly: true,
-                secure: true,
+                secure: this.config.secureCookies || false,
                 sameSite: 'strict'
             });
     }
@@ -168,7 +168,7 @@ export class HWebAuth {
             .json(data)
             .cookie('hweb-auth-token', token, {
                 httpOnly: true,
-                secure: true, // Always secure, even in development
+                secure: this.config.secureCookies || false, // Always secure, even in development
                 sameSite: 'strict', // Prevent CSRF attacks
                 maxAge: (this.config.session?.maxAge || 86400) * 1000,
                 path: '/',

package/src/auth/index.ts

@@ -5,6 +5,5 @@ export * from './core';
 export * from './routes';
 export * from './jwt';
 
-export { CredentialsProvider, DiscordProvider } from './providers';
-export { createAuthRoutes } from './routes';
-
+export { CredentialsProvider, DiscordProvider, GoogleProvider } from './providers';
+export { createAuthRoutes } from './routes';