hightjs 0.1.1

package/src/helpers.ts

@@ -0,0 +1,316 @@
+// Helpers para integração com diferentes frameworks
+import hweb, { FrameworkAdapterFactory } from './index';
+import type { HightJSOptions } from './types';
+import os from 'os';
+import Console, {Colors} from "./api/console";
+
+
+
+
+function getLocalExternalIp() {
+
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name]!) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return 'localhost';
+}
+
+const sendBox = (options:HightJSOptions) => {
+    const isDev = options.dev ? "Rodando em modo de desenvolvimento" : null;
+    const messages = [
+        ` ${Colors.FgMagenta}●  ${Colors.Reset}Local: ${Colors.FgGreen}http://localhost:${options.port}${Colors.Reset}`,
+        ` ${Colors.FgMagenta}●  ${Colors.Reset}Rede: ${Colors.FgGreen}http://${getLocalExternalIp()}:${options.port}${Colors.Reset}`,
+    ]
+    if(isDev) {
+        messages.push(` ${Colors.FgMagenta}●  ${Colors.Reset}${isDev}`)
+    }
+    Console.box(messages.join("\n"), {title: "Acesse o HightJS em:"})
+}
+
+
+export default app
+export function app(options: HightJSOptions = {}) {
+    const framework = options.framework || 'native'; // Mudando o padrão para 'native'
+    FrameworkAdapterFactory.setFramework(framework)
+
+    const hwebApp = hweb(options);
+    return {
+        ...hwebApp,
+
+        /**
+         * Integra com uma aplicação de qualquer framework (Express, Fastify, etc)
+         */
+        integrate: async (serverApp: any) => {
+            await hwebApp.prepare();
+            const handler = hwebApp.getRequestHandler();
+
+            if (framework === 'express') {
+                // Express integration
+                serverApp.use(handler);
+                hwebApp.setupWebSocket(serverApp);
+            } else if (framework === 'fastify') {
+                // Fastify integration
+                await serverApp.register(async (fastify: any) => {
+                    fastify.all('*', handler);
+                });
+                hwebApp.setupWebSocket(serverApp);
+            } else {
+                // Generic integration - assume Express-like
+                serverApp.use(handler);
+                hwebApp.setupWebSocket(serverApp);
+            }
+
+            hwebApp.executeInstrumentation();
+            return serverApp;
+        },
+
+        /**
+         * Inicia um servidor HightJS fechado (o usuário não tem acesso ao framework)
+         */
+        init: async () => {
+            console.log(`${Colors.FgMagenta}
+     _    _ _       _     _          _  _____ 
+    | |  | (_)     | |   | |        | |/ ____|
+    | |__| |_  __ _| |__ | |_       | | (___  
+    |  __  | |/ _\` | '_ \\| __|  _   | |\\___ \\ 
+    | |  | | | (_| | | | | |_  | |__| |____) |
+    |_|  |_|_|\\__, |_| |_|\\__|  \\____/|_____/ 
+               __/ |                          
+              |___/                           ${Colors.Reset}`)
+            const actualPort = options.port || 3000;
+            const actualHostname = options.hostname || "0.0.0.0";
+
+            if (framework === 'express') {
+                return await initExpressServer(hwebApp, options, actualPort, actualHostname);
+            } else if (framework === 'fastify') {
+                return await initFastifyServer(hwebApp, options, actualPort, actualHostname);
+            } else  {
+                // Default to Native
+                return await initNativeServer(hwebApp, options, actualPort, actualHostname);
+            }
+        }
+    }
+}
+
+/**
+ * Inicializa servidor Express fechado
+ */
+async function initExpressServer(hwebApp: any, options: HightJSOptions, port: number, hostname: string) {
+    const msg = Console.dynamicLine(`  ${Colors.FgCyan}●  ${Colors.Reset}Iniciando HightJS com Express...`);
+    const express = require('express');
+    const app = express();
+
+    // Middlewares básicos para Express
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+
+    // Cookie parser se disponível
+    try {
+        const cookieParser = require('cookie-parser');
+        app.use(cookieParser());
+    } catch (e) {
+        Console.error("Não foi possivel achar cookie-parser")
+    }
+
+    await hwebApp.prepare();
+    const handler = hwebApp.getRequestHandler();
+
+    app.use(handler);
+
+    const server = app.listen(port, hostname, () => {
+        sendBox({ ...options, port });
+        msg.end(`  ${Colors.FgCyan}●  ${Colors.Reset}Servidor Express iniciado (compatibilidade)`);
+    });
+
+    // Configura WebSocket para hot reload
+    hwebApp.setupWebSocket(server);
+    hwebApp.executeInstrumentation();
+    return server;
+}
+
+/**
+ * Inicializa servidor Fastify fechado
+ */
+async function initFastifyServer(hwebApp: any, options: HightJSOptions, port: number, hostname: string) {
+    const msg = Console.dynamicLine(`  ${Colors.FgCyan}●  ${Colors.Reset}Iniciando HightJS com Fastify...`);
+    const fastify = require('fastify')({ logger: false });
+
+    // Registra plugins básicos para Fastify
+    try {
+        await fastify.register(require('@fastify/cookie'));
+    } catch (e) {
+        Console.error("Não foi possivel achar @fastify/cookie")
+    }
+
+    try {
+        await fastify.register(require('@fastify/formbody'));
+    } catch (e) {
+        Console.error("Não foi possivel achar @fastify/formbody")
+    }
+
+    await hwebApp.prepare();
+    const handler = hwebApp.getRequestHandler();
+
+    // Registra o handler do hweb
+    await fastify.register(async (fastify: any) => {
+        fastify.all('*', handler);
+    });
+    hwebApp.setupWebSocket(fastify);
+
+    const address = await fastify.listen({ port, host: hostname });
+    sendBox({ ...options, port });
+    msg.end(`  ${Colors.FgCyan}●  ${Colors.Reset}Servidor Fastify iniciado (compatibilidade)`);
+    hwebApp.executeInstrumentation();
+    return fastify;
+}
+
+/**
+ * Inicializa servidor nativo do HightJS usando HTTP puro
+ */
+async function initNativeServer(hwebApp: any, options: HightJSOptions, port: number, hostname: string) {
+    const msg = Console.dynamicLine(`  ${Colors.FgMagenta}⚡  ${Colors.Reset}${Colors.Bright}Iniciando HightJS em modo NATIVO${Colors.Reset}`);
+
+    const http = require('http');
+    const { parse: parseUrl } = require('url');
+    const { parse: parseQuery } = require('querystring');
+
+    await hwebApp.prepare();
+    const handler = hwebApp.getRequestHandler();
+
+    // Middleware para parsing do body com proteções de segurança
+    const parseBody = (req: any): Promise<any> => {
+        return new Promise((resolve, reject) => {
+            if (req.method === 'GET' || req.method === 'HEAD') {
+                resolve(null);
+                return;
+            }
+
+            let body = '';
+            let totalSize = 0;
+            const maxBodySize = 10 * 1024 * 1024; // 10MB limite
+
+            // Timeout para requisições que demoram muito
+            const timeout = setTimeout(() => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            }, 30000); // 30 segundos
+
+            req.on('data', (chunk: Buffer) => {
+                totalSize += chunk.length;
+
+                // Proteção contra ataques de DoS por body muito grande
+                if (totalSize > maxBodySize) {
+                    clearTimeout(timeout);
+                    req.destroy();
+                    reject(new Error('Request body too large'));
+                    return;
+                }
+
+                body += chunk.toString();
+            });
+
+            req.on('end', () => {
+                clearTimeout(timeout);
+
+                try {
+                    const contentType = req.headers['content-type'] || '';
+                    if (contentType.includes('application/json')) {
+                        // Validação adicional para JSON
+                        if (body.length > 1024 * 1024) { // 1MB limite para JSON
+                            reject(new Error('JSON body too large'));
+                            return;
+                        }
+                        resolve(JSON.parse(body));
+                    } else if (contentType.includes('application/x-www-form-urlencoded')) {
+                        resolve(parseQuery(body));
+                    } else {
+                        resolve(body);
+                    }
+                } catch (error) {
+                    resolve(body); // Fallback para string se parsing falhar
+                }
+            });
+
+            req.on('error', (error: Error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    };
+
+    // Cria o servidor HTTP nativo com configurações de segurança
+    const server = http.createServer(async (req: any, res: any) => {
+        // Configurações de segurança básicas
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'DENY');
+        res.setHeader('X-XSS-Protection', '1; mode=block');
+        res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+
+        // Timeout para requisições
+        req.setTimeout(30000, () => {
+            res.statusCode = 408; // Request Timeout
+            res.end('Request timeout');
+        });
+
+        try {
+            // Validação básica de URL para prevenir ataques
+            const url = req.url || '/';
+            if (url.length > 2048) {
+                res.statusCode = 414; // URI Too Long
+                res.end('URL too long');
+                return;
+            }
+
+            // Parse do body com proteções
+            req.body = await parseBody(req);
+
+            // Adiciona host se não existir
+            req.headers.host = req.headers.host || `localhost:${port}`;
+
+            // Chama o handler do HightJS
+            await handler(req, res);
+        } catch (error) {
+            Console.error('Erro no servidor nativo:', error);
+
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'text/plain');
+
+                if (error instanceof Error) {
+                    if (error.message.includes('too large')) {
+                        res.statusCode = 413; // Payload Too Large
+                        res.end('Request too large');
+                    } else if (error.message.includes('timeout')) {
+                        res.statusCode = 408; // Request Timeout
+                        res.end('Request timeout');
+                    } else {
+                        res.end('Internal server error');
+                    }
+                } else {
+                    res.end('Internal server error');
+                }
+            }
+        }
+    });
+
+    // Configurações de segurança do servidor
+    server.setTimeout(35000); // Timeout geral do servidor
+    server.maxHeadersCount = 100; // Limita número de headers
+    server.headersTimeout = 60000; // Timeout para headers
+    server.requestTimeout = 30000; // Timeout para requisições
+
+    server.listen(port, hostname, () => {
+        sendBox({ ...options, port });
+        msg.end(`  ${Colors.FgGreen}⚡  ${Colors.Reset}${Colors.Bright}Servidor HightJS NATIVO ativo!${Colors.Reset}`);
+    });
+
+    // Configura WebSocket para hot reload
+    hwebApp.setupWebSocket(server);
+    hwebApp.executeInstrumentation();
+    return server;
+}

package/src/hotReload.ts

@@ -0,0 +1,289 @@
+import { WebSocket, WebSocketServer } from 'ws';
+import * as chokidar from 'chokidar';
+import * as path from 'path';
+import * as fs from 'fs';
+import { IncomingMessage } from 'http';
+import * as url from 'url';
+import { clearFileCache } from './router';
+import Console, {Levels} from "./api/console"
+export class HotReloadManager {
+    private wss: WebSocketServer | null = null;
+    private watchers: chokidar.FSWatcher[] = [];
+    private projectDir: string;
+    private clients: Set<WebSocket> = new Set();
+    private pingInterval: NodeJS.Timeout | null = null;
+    private backendApiChangeCallback: (() => void) | null = null;
+    private frontendChangeCallback: (() => void) | null = null;
+
+    constructor(projectDir: string) {
+        this.projectDir = projectDir;
+    }
+
+    async start() {
+        // Não cria servidor na porta separada - será integrado ao Express
+        this.setupWatchers();
+    }
+
+    // Novo método para integrar com Express
+    handleUpgrade(request: IncomingMessage, socket: any, head: Buffer) {
+        if (!this.wss) {
+            this.wss = new WebSocketServer({ noServer: true });
+            this.setupWebSocketServer();
+        }
+
+        this.wss.handleUpgrade(request, socket, head, (ws) => {
+            this.wss!.emit('connection', ws, request);
+        });
+    }
+
+    private setupWebSocketServer() {
+        if (!this.wss) return;
+
+        this.wss.on('connection', (ws: WebSocket) => {
+            this.clients.add(ws);
+
+            // Setup ping/pong para manter conexão viva
+            const ping = () => {
+                if (ws.readyState === WebSocket.OPEN) {
+                    ws.ping();
+                }
+            };
+
+            const pingTimer = setInterval(ping, 30000); // Ping a cada 30 segundos
+
+            ws.on('pong', () => {
+                // Cliente respondeu ao ping - conexão ainda ativa
+            });
+
+            ws.on('close', () => {
+                this.clients.delete(ws);
+                clearInterval(pingTimer);
+            });
+
+            ws.on('error', () => {
+                this.clients.delete(ws);
+                clearInterval(pingTimer);
+            });
+        });
+    }
+
+    private setupWatchers() {
+        // 1. Watcher para arquivos frontend (rotas, componentes) - EXCLUINDO backend
+        const frontendWatcher = chokidar.watch([
+            path.join(this.projectDir, 'src/web/**/*.{tsx,ts,jsx,js}'),
+        ], {
+            ignored: [
+                /(^|[\/\\])\../, // arquivos ocultos
+                path.join(this.projectDir, 'src/web/backend/**/*') // exclui toda a pasta backend
+            ],
+            persistent: true,
+            ignoreInitial: true
+        });
+
+        frontendWatcher.on('change', async (filePath) => {
+            Console.logWithout(Levels.INFO, `🔄 Frontend alterado: ${filePath}`);
+            clearFileCache(filePath);
+            // Checa build do arquivo alterado
+            const result = await this.checkFrontendBuild(filePath);
+            if (result.error) {
+                this.notifyClients('frontend-error', { file: filePath, error: result.error });
+            } else {
+                this.frontendChangeCallback?.();
+                this.notifyClients('frontend-reload');
+            }
+        });
+        frontendWatcher.on('add', async (filePath) => {
+            Console.info(`➕ Novo arquivo frontend: ${path.basename(filePath)}`);
+            const result = await this.checkFrontendBuild(filePath);
+            if (result.error) {
+                this.notifyClients('frontend-error', { file: filePath, error: result.error });
+            } else {
+                this.frontendChangeCallback?.();
+                this.notifyClients('frontend-reload');
+            }
+        });
+        frontendWatcher.on('unlink', (filePath) => {
+            Console.info(`🗑️ Arquivo frontend removido: ${path.basename(filePath)}`);
+            clearFileCache(filePath);
+            this.frontendChangeCallback?.();
+            this.notifyClients('frontend-reload');
+        });
+
+        // 2. Watcher específico para rotas de API backend
+        const backendApiWatcher = chokidar.watch([
+            path.join(this.projectDir, 'src/web/backend/routes/**/*.{ts,tsx,js,jsx}'),
+        ], {
+            ignored: /(^|[\/\\])\../,
+            persistent: true,
+            ignoreInitial: true
+        });
+
+        backendApiWatcher.on('change', (filePath) => {
+            Console.info(`🔄 API backend alterada: ${path.basename(filePath)}`);
+            this.clearBackendCache(filePath);
+            this.notifyClients('backend-api-reload');
+
+            // Chama o callback, se definido
+            this.backendApiChangeCallback?.();
+        });
+
+        backendApiWatcher.on('add', (filePath) => {
+            Console.info(`➕ Nova API backend: ${path.basename(filePath)}`);
+            this.notifyClients('backend-api-reload');
+        });
+
+        backendApiWatcher.on('unlink', (filePath) => {
+            Console.info(`🗑️ API backend removida: ${path.basename(filePath)}`);
+            this.clearBackendCache(filePath);
+            this.notifyClients('backend-api-reload');
+        });
+
+        // 3. Watcher para arquivos backend (server.ts, configs)
+        const backendWatcher = chokidar.watch([
+            path.join(this.projectDir, 'src/server.ts'),
+            path.join(this.projectDir, 'src/**/*.ts'),
+            '!**/src/web/**', // exclui pasta web
+        ], {
+            ignored: /(^|[\/\\])\../,
+            persistent: true,
+            ignoreInitial: true
+        });
+
+        backendWatcher.on('change', () => {
+            this.restartServer();
+        });
+
+        this.watchers.push(frontendWatcher, backendApiWatcher, backendWatcher);
+    }
+
+    private notifyClients(type: string, data?: any) {
+        const message = JSON.stringify({ type, data, timestamp: Date.now() });
+
+        this.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(message);
+            }
+        });
+    }
+
+    private restartServer() {
+        // Notifica clientes que o servidor está reiniciando
+        this.notifyClients('server-restart');
+
+        // Aguarda um pouco e tenta reconectar
+        setTimeout(() => {
+            this.notifyClients('server-ready');
+        }, 2000);
+    }
+
+    stop() {
+        // Para todos os watchers
+        this.watchers.forEach(watcher => watcher.close());
+        this.watchers = [];
+
+        // Para ping interval
+        if (this.pingInterval) {
+            clearInterval(this.pingInterval);
+        }
+
+        // Fecha WebSocket server
+        if (this.wss) {
+            this.wss.close();
+        }
+    }
+
+    // Retorna o script do cliente para injetar no HTML
+    getClientScript(): string {
+        return `
+        <script>
+        (function() {
+            if (typeof window !== 'undefined') {
+                let ws;
+                let reconnectInterval;
+                
+                function connect() {
+                    ws = new WebSocket('ws://localhost:3000/hweb-hotreload/');
+                    
+                    ws.onopen = function() {
+                        clearInterval(reconnectInterval);
+                    };
+                    
+                    ws.onmessage = function(event) {
+                        const message = JSON.parse(event.data);
+                        
+                        switch(message.type) {
+                            case 'frontend-reload':
+                                window.location.reload();
+                                break;
+                            case 'server-restart':
+                                break;
+                            case 'server-ready':
+                                setTimeout(() => window.location.reload(), 500);
+                                break;
+                        }
+                    };
+                    
+                    ws.onclose = function() {
+                        reconnectInterval = setInterval(() => {
+                            connect();
+                        }, 1000);
+                    };
+                    
+                    ws.onerror = function() {
+                        // Silencioso - sem logs
+                    };
+                }
+                
+                connect();
+            }
+        })();
+        </script>
+        `;
+    }
+
+    private clearBackendCache(filePath: string) {
+        // Limpa o cache do require para forçar reload da rota de API
+        const absolutePath = path.resolve(filePath);
+        delete require.cache[absolutePath];
+
+        // Também limpa dependências relacionadas
+        Object.keys(require.cache).forEach(key => {
+            if (key.includes(path.dirname(absolutePath))) {
+                delete require.cache[key];
+            }
+        });
+    }
+
+    // Método para registrar callback de mudança de API backend
+    onBackendApiChange(callback: () => void) {
+        this.backendApiChangeCallback = callback;
+    }
+
+    // Método para registrar callback de mudança de frontend
+    onFrontendChange(callback: () => void) {
+        this.frontendChangeCallback = callback;
+    }
+
+    private async checkFrontendBuild(filePath: string) {
+        // Usa ts-node para checar erros de compilação do arquivo alterado
+        const tsNodePath = require.resolve('ts-node');
+        const { spawn } = require('child_process');
+        return new Promise<{ error?: string }>((resolve) => {
+            const proc = spawn(process.execPath, [tsNodePath, '--transpile-only', filePath], {
+                cwd: this.projectDir,
+                env: process.env,
+            });
+            let errorMsg = '';
+            proc.stderr.on('data', (data: Buffer) => {
+                errorMsg += data.toString();
+            });
+            proc.on('close', (code: number) => {
+                if (code !== 0 && errorMsg) {
+                    resolve({ error: errorMsg });
+                } else {
+                    resolve({});
+                }
+            });
+        });
+    }
+}