hightjs 0.2.43 → 0.2.45

package/dist/bin/hightjs.js

@@ -4,6 +4,8 @@
 require('ts-node').register();
 const { program } = require('commander');
 const teste = require("../helpers");
+const fs = require('fs');
+const path = require('path');
 program
     .version('1.0.0')
     .description('CLI para gerenciar a aplicação.');
@@ -31,5 +33,396 @@ program
     const t = teste.default({ dev: false, port: options.port, hostname: options.hostname, framework: options.framework });
     t.init();
 });
+// --- Comando EXPORT ---
+program
+    .command('export')
+    .description('Exporta a aplicação como HTML estático na pasta "exported".')
+    .option('-o, --output <path>', 'Especifica o diretório de saída', 'exported')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const exportDir = path.join(projectDir, options.output);
+    console.log('🚀 Iniciando exportação...\n');
+    try {
+        // 1. Cria a pasta exported (limpa se já existir)
+        if (fs.existsSync(exportDir)) {
+            console.log('🗑️  Limpando pasta de exportação existente...');
+            fs.rmSync(exportDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(exportDir, { recursive: true });
+        console.log('✅ Pasta de exportação criada\n');
+        // 2. Inicializa e prepara o build
+        console.log('🔨 Buildando aplicação...');
+        const teste = require("../helpers");
+        const app = teste.default({ dev: false, port: 3000, hostname: '0.0.0.0', framework: 'native' });
+        await app.prepare();
+        console.log('✅ Build concluído\n');
+        // 3. Copia a pasta hweb-dist para exported
+        const distDir = path.join(projectDir, 'hweb-dist');
+        if (fs.existsSync(distDir)) {
+            console.log('📦 Copiando arquivos JavaScript...');
+            const exportDistDir = path.join(exportDir, 'hweb-dist');
+            fs.mkdirSync(exportDistDir, { recursive: true });
+            const files = fs.readdirSync(distDir);
+            files.forEach(file => {
+                fs.copyFileSync(path.join(distDir, file), path.join(exportDistDir, file));
+            });
+            console.log('✅ Arquivos JavaScript copiados\n');
+        }
+        // 4. Copia a pasta public se existir
+        const publicDir = path.join(projectDir, 'public');
+        if (fs.existsSync(publicDir)) {
+            console.log('📁 Copiando arquivos públicos...');
+            const exportPublicDir = path.join(exportDir, 'public');
+            function copyRecursive(src, dest) {
+                if (fs.statSync(src).isDirectory()) {
+                    fs.mkdirSync(dest, { recursive: true });
+                    fs.readdirSync(src).forEach(file => {
+                        copyRecursive(path.join(src, file), path.join(dest, file));
+                    });
+                }
+                else {
+                    fs.copyFileSync(src, dest);
+                }
+            }
+            copyRecursive(publicDir, exportPublicDir);
+            console.log('✅ Arquivos públicos copiados\n');
+        }
+        // 5. Gera o index.html
+        console.log('📝 Gerando index.html...');
+        const { render } = require('../renderer');
+        const { loadRoutes, loadLayout, loadNotFound } = require('../router');
+        // Carrega as rotas para gerar o HTML
+        const userWebDir = path.join(projectDir, 'src', 'web');
+        const userWebRoutesDir = path.join(userWebDir, 'routes');
+        const routes = loadRoutes(userWebRoutesDir);
+        loadLayout(userWebDir);
+        loadNotFound(userWebDir);
+        // Gera HTML para a rota raiz
+        const rootRoute = routes.find(r => r.pattern === '/') || routes[0];
+        if (rootRoute) {
+            const mockReq = {
+                url: '/',
+                method: 'GET',
+                headers: { host: 'localhost' },
+                hwebDev: false,
+                hotReloadManager: null
+            };
+            const html = await render({
+                req: mockReq,
+                route: rootRoute,
+                params: {},
+                allRoutes: routes
+            });
+            const indexPath = path.join(exportDir, 'index.html');
+            fs.writeFileSync(indexPath, html, 'utf8');
+            console.log('✅ index.html gerado\n');
+        }
+        console.log('🎉 Exportação concluída com sucesso!');
+        console.log(`📂 Arquivos exportados em: ${exportDir}\n`);
+    }
+    catch (error) {
+        console.error('❌ Erro durante a exportação:', error.message);
+        process.exit(1);
+    }
+});
+// --- Comando MIGRATE FROM NEXTJS ---
+program
+    .command('migrate-from-nextjs')
+    .description('Migra um projeto Next.js para HightJS.')
+    .option('-s, --source <path>', 'Caminho do projeto Next.js', process.cwd())
+    .option('-o, --output <path>', 'Diretório de saída para o projeto HightJS', './hightjs-project')
+    .action(async (options) => {
+    const sourcePath = path.resolve(options.source);
+    const outputPath = path.resolve(options.output);
+    console.log('🚀 Iniciando migração de Next.js para HightJS...\n');
+    console.log(`📂 Origem: ${sourcePath}`);
+    console.log(`📂 Destino: ${outputPath}\n`);
+    try {
+        // Verifica se o diretório de origem existe
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Diretório de origem não encontrado: ${sourcePath}`);
+        }
+        // Verifica se é um projeto Next.js
+        const nextConfigPath = path.join(sourcePath, 'next.config.js');
+        const nextConfigMjsPath = path.join(sourcePath, 'next.config.mjs');
+        const packageJsonPath = path.join(sourcePath, 'package.json');
+        if (!fs.existsSync(nextConfigPath) && !fs.existsSync(nextConfigMjsPath) && !fs.existsSync(packageJsonPath)) {
+            throw new Error('Não foi encontrado um projeto Next.js válido no diretório especificado.');
+        }
+        // Cria o diretório de saída
+        if (fs.existsSync(outputPath)) {
+            console.log('⚠️  Diretório de destino já existe. Limpando...');
+            fs.rmSync(outputPath, { recursive: true, force: true });
+        }
+        fs.mkdirSync(outputPath, { recursive: true });
+        // 1. Cria estrutura básica do HightJS
+        console.log('📁 Criando estrutura de diretórios...');
+        const srcDir = path.join(outputPath, 'src');
+        const webDir = path.join(srcDir, 'web');
+        const routesDir = path.join(webDir, 'routes');
+        const publicDir = path.join(outputPath, 'public');
+        fs.mkdirSync(srcDir, { recursive: true });
+        fs.mkdirSync(webDir, { recursive: true });
+        fs.mkdirSync(routesDir, { recursive: true });
+        fs.mkdirSync(publicDir, { recursive: true });
+        // 2. Copia arquivos públicos
+        console.log('📦 Copiando arquivos públicos...');
+        const nextPublicDir = path.join(sourcePath, 'public');
+        if (fs.existsSync(nextPublicDir)) {
+            copyDirectory(nextPublicDir, publicDir);
+        }
+        // 3. Migra páginas do Next.js para rotas do HightJS
+        console.log('🔄 Migrando páginas para rotas...');
+        const nextPagesDir = path.join(sourcePath, 'pages');
+        const nextAppDir = path.join(sourcePath, 'app');
+        const nextSrcPagesDir = path.join(sourcePath, 'src', 'pages');
+        const nextSrcAppDir = path.join(sourcePath, 'src', 'app');
+        let pagesDir = null;
+        let isAppRouter = false;
+        if (fs.existsSync(nextAppDir)) {
+            pagesDir = nextAppDir;
+            isAppRouter = true;
+            console.log('✅ Detectado Next.js App Router');
+        }
+        else if (fs.existsSync(nextSrcAppDir)) {
+            pagesDir = nextSrcAppDir;
+            isAppRouter = true;
+            console.log('✅ Detectado Next.js App Router (em src/)');
+        }
+        else if (fs.existsSync(nextPagesDir)) {
+            pagesDir = nextPagesDir;
+            console.log('✅ Detectado Next.js Pages Router');
+        }
+        else if (fs.existsSync(nextSrcPagesDir)) {
+            pagesDir = nextSrcPagesDir;
+            console.log('✅ Detectado Next.js Pages Router (em src/)');
+        }
+        if (pagesDir) {
+            if (isAppRouter) {
+                migrateAppRouter(pagesDir, routesDir);
+            }
+            else {
+                migratePagesRouter(pagesDir, routesDir);
+            }
+        }
+        // 5. Cria package.json
+        console.log('📄 Criando package.json...');
+        let originalPackageJson = {};
+        if (fs.existsSync(packageJsonPath)) {
+            originalPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        }
+        const newPackageJson = {
+            name: originalPackageJson.name || 'hightjs-app',
+            version: '1.0.0',
+            description: originalPackageJson.description || 'HightJS application migrated from Next.js',
+            scripts: {
+                dev: 'hight dev',
+                start: 'hight start',
+                build: 'hight export',
+                ...originalPackageJson.scripts
+            },
+            dependencies: {
+                hightjs: 'latest',
+                react: originalPackageJson.dependencies?.react || '^18.2.0',
+                'react-dom': originalPackageJson.dependencies?.['react-dom'] || '^18.2.0',
+                ...filterDependencies(originalPackageJson.dependencies)
+            },
+            devDependencies: {
+                '@types/node': '^20.11.24',
+                '@types/react': '^18.2.0',
+                '@types/react-dom': '^18.2.0',
+                typescript: '^5.3.3',
+                ...filterDependencies(originalPackageJson.devDependencies)
+            }
+        };
+        fs.writeFileSync(path.join(outputPath, 'package.json'), JSON.stringify(newPackageJson, null, 2), 'utf8');
+        // 6. Cria tsconfig.json
+        console.log('⚙️  Criando tsconfig.json...');
+        const tsConfig = {
+            compilerOptions: {
+                target: 'ES2020',
+                lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+                jsx: 'react-jsx',
+                module: 'commonjs',
+                moduleResolution: 'node',
+                esModuleInterop: true,
+                strict: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                resolveJsonModule: true,
+                allowSyntheticDefaultImports: true
+            },
+            include: ['src/**/*'],
+            exclude: ['node_modules']
+        };
+        fs.writeFileSync(path.join(outputPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2), 'utf8');
+        // 7. Cria README
+        console.log('📖 Criando README...');
+        const readmeContent = `# ${originalPackageJson.name || 'HightJS App'}
+
+Este projeto foi migrado de Next.js para HightJS.
+
+## Comandos Disponíveis
+
+- \`npm run dev\` - Inicia o servidor de desenvolvimento
+- \`npm run start\` - Inicia o servidor em modo produção
+- \`npm run build\` - Exporta a aplicação como HTML estático
+
+## Próximos Passos
+
+1. Instale as dependências: \`npm install\`
+2. Revise os arquivos migrados em \`src/web/routes/\`
+3. Ajuste manualmente qualquer código que precise de adaptação
+4. Execute \`npm run dev\` para testar
+
+## Notas de Migração
+
+- Rotas dinâmicas do Next.js foram convertidas para o formato HightJS
+- API Routes precisam ser migradas manualmente para HightJS API routes
+- Server Components foram convertidos para componentes React padrão
+- Revise imports e configurações específicas do Next.js
+
+Para mais informações sobre HightJS, visite a documentação.
+`;
+        fs.writeFileSync(path.join(outputPath, 'README.md'), readmeContent, 'utf8');
+        console.log('\n✅ Migração concluída com sucesso!');
+        console.log(`\n📂 Projeto criado em: ${outputPath}`);
+        console.log('\n📋 Próximos passos:');
+        console.log(`   1. cd ${path.relative(process.cwd(), outputPath)}`);
+        console.log('   2. npm install');
+        console.log('   3. npm run dev');
+        console.log('\n⚠️  IMPORTANTE: Revise os arquivos migrados e ajuste conforme necessário.\n');
+    }
+    catch (error) {
+        console.error('❌ Erro durante a migração:', error.message);
+        console.error(error.stack);
+        process.exit(1);
+    }
+});
+// Funções auxiliares para migração
+function copyDirectory(src, dest) {
+    if (!fs.existsSync(src))
+        return;
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectory(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+function migratePagesRouter(pagesDir, routesDir) {
+    function processDirectory(dir, baseRoute = '') {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Processa subdiretórios (rotas aninhadas)
+                const newBaseRoute = path.join(baseRoute, entry.name);
+                processDirectory(fullPath, newBaseRoute);
+            }
+            else if (entry.name.match(/\.(tsx?|jsx?)$/)) {
+                // Ignora arquivos especiais do Next.js
+                if (['_app', '_document', '_error', 'api'].some(special => entry.name.startsWith(special))) {
+                    continue;
+                }
+                // Converte nome do arquivo para rota HightJS
+                let fileName = entry.name.replace(/\.(tsx?|jsx?)$/, '');
+                let routePath = baseRoute;
+                if (fileName === 'index') {
+                    // index.tsx -> route vazia ou baseRoute
+                    routePath = baseRoute || '/';
+                }
+                else {
+                    // [id].tsx -> $id.tsx
+                    fileName = fileName.replace(/\[([^\]]+)\]/g, '$$$1');
+                    routePath = path.join(baseRoute, fileName);
+                }
+                // Lê o conteúdo original
+                const originalContent = fs.readFileSync(fullPath, 'utf8');
+                // Transforma o conteúdo
+                const transformedContent = transformNextJsPage(originalContent);
+                // Cria estrutura de diretórios se necessário
+                const targetDir = path.join(routesDir, baseRoute);
+                fs.mkdirSync(targetDir, { recursive: true });
+                // Salva o arquivo transformado
+                const targetFileName = fileName === 'index' ? 'route.tsx' : `${fileName}.route.tsx`;
+                const targetPath = path.join(targetDir, targetFileName);
+                fs.writeFileSync(targetPath, transformedContent, 'utf8');
+                console.log(`   ✓ ${path.relative(pagesDir, fullPath)} -> ${path.relative(routesDir, targetPath)}`);
+            }
+        }
+    }
+    processDirectory(pagesDir);
+}
+function migrateAppRouter(appDir, routesDir) {
+    function processDirectory(dir, baseRoute = '') {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        let hasPage = false;
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Suporta rotas dinâmicas como [id]
+                let dirName = entry.name;
+                if (dirName.startsWith('[') && dirName.endsWith(']')) {
+                    dirName = '$' + dirName.slice(1, -1);
+                }
+                const newBaseRoute = path.join(baseRoute, dirName);
+                processDirectory(fullPath, newBaseRoute);
+            }
+            else if (entry.name === 'page.tsx' || entry.name === 'page.jsx' || entry.name === 'page.ts' || entry.name === 'page.js') {
+                hasPage = true;
+                // Lê o conteúdo original
+                const originalContent = fs.readFileSync(fullPath, 'utf8');
+                // Transforma o conteúdo
+                const transformedContent = transformNextJsPage(originalContent);
+                // Cria estrutura de diretórios
+                const targetDir = path.join(routesDir, baseRoute);
+                fs.mkdirSync(targetDir, { recursive: true });
+                // Salva como route.tsx
+                const targetPath = path.join(targetDir, 'route.tsx');
+                fs.writeFileSync(targetPath, transformedContent, 'utf8');
+                console.log(`   ✓ ${path.relative(appDir, fullPath)} -> ${path.relative(routesDir, targetPath)}`);
+            }
+        }
+    }
+    processDirectory(appDir);
+}
+function transformNextJsPage(content) {
+    // Remove 'use client' e 'use server'
+    content = content.replace(/['"]use (client|server)['"]\s*;\s*/g, '');
+    // Remove imports específicos do Next.js
+    content = content.replace(/import\s+.*?from\s+['"]next\/.*?['"];?\s*/g, '');
+    // Substitui Link do Next.js por Link do HightJS
+    if (content.includes('Link')) {
+        content = `import { Link } from 'hightjs/client';\n` + content;
+    }
+    // Substitui useRouter do Next.js
+    content = content.replace(/import\s*\{\s*useRouter\s*\}\s*from\s*['"]next\/router['"]/g, "import { useRouter } from 'hightjs/client'");
+    // Substitui Image do Next.js por img normal (com comentário para revisão)
+    content = content.replace(/<Image\s+/g, '<img /* TODO: Migrado de Next.js Image - revisar otimizações */ ');
+    // Remove getServerSideProps, getStaticProps, getStaticPaths
+    content = content.replace(/export\s+(async\s+)?function\s+get(ServerSideProps|StaticProps|StaticPaths)\s*\([^)]*\)\s*\{[\s\S]*?\n\}/g, '');
+    // Adiciona comentário sobre metadata se houver
+    if (content.includes('export const metadata')) {
+        content = '// TODO: Migrar metadata do Next.js para HightJS\n' + content;
+    }
+    return content.trim();
+}
+function filterDependencies(deps) {
+    if (!deps)
+        return {};
+    const filtered = { ...deps };
+    // Remove dependências específicas do Next.js
+    delete filtered.next;
+    delete filtered['@next/font'];
+    delete filtered['next-auth'];
+    return filtered;
+}
 // Faz o "parse" dos argumentos passados na linha de comando
 program.parse(process.argv);

package/dist/router.js

@@ -531,7 +531,6 @@ function handleWebSocketUpgrade(request, socket, head, hotReloadManager) {
             hotReloadManager.handleUpgrade(request, socket, head);
         }
         else {
-            console.warn('⚠️ Hot-reload manager não disponível para:', pathname);
             socket.destroy();
         }
         return;

package/docs/README.md

@@ -0,0 +1,59 @@
+# 📚 Documentação HightJS
+
+Bem-vindo à documentação completa do HightJS!
+
+## 📑 Índice
+
+### Fundamentos
+- [📦 Estrutura Recomendada](./estrutura.md) - Como organizar seu projeto
+- [🖥️ Rotas Frontend](./rotas-frontend.md) - Criando páginas React
+- [🌐 Rotas Backend](./rotas-backend.md) - Criando APIs e endpoints
+
+### Recursos Avançados
+- [🛜 WebSocket](./websocket.md) - Comunicação em tempo real
+- [🧩 Middlewares](./middlewares.md) - Interceptando requisições
+- [🔐 Autenticação](./autenticacao.md) - Sistema JWT integrado
+
+### Ferramentas e Configuração
+- [🛠️ CLI](./cli.md) - Comandos e opções
+- [📂 Arquivos Especiais](./arquivos-especiais.md) - Arquivos com funções especiais
+- [🧱 Adapters](./adapters.md) - Native, Express, Fastify
+- [🔐 Segurança Interna](./seguranca.md) - Proteções nativas
+- [♻️ Hot Reload](./hot-reload.md) - Desenvolvimento com recarregamento automático
+
+### Ajuda
+- [❓ FAQ Rápido](./faq.md) - Perguntas frequentes
+- [✅ Checklist Mental](./checklist.md) - Guia rápido de referência
+
+---
+
+## 🚀 Início Rápido
+
+Se você está começando agora, recomendamos seguir esta ordem:
+
+1. [Estrutura Recomendada](./estrutura.md) - Entenda como organizar seu projeto
+2. [Rotas Frontend](./rotas-frontend.md) - Crie sua primeira página
+3. [Rotas Backend](./rotas-backend.md) - Crie sua primeira API
+4. [CLI](./cli.md) - Aprenda os comandos básicos
+
+## 💡 Recursos Avançados
+
+Quando estiver confortável com o básico, explore:
+
+- [Autenticação](./autenticacao.md) - Adicione login e proteção de rotas
+- [WebSocket](./websocket.md) - Implemente recursos em tempo real
+- [Middlewares](./middlewares.md) - Adicione lógica customizada nas requisições
+
+## 📖 Referência Completa
+
+Consulte estas páginas quando precisar de informações específicas:
+
+- [Arquivos Especiais](./arquivos-especiais.md) - Todos os arquivos especiais do framework
+- [Adapters](./adapters.md) - Diferentes formas de executar seu app
+- [Segurança Interna](./seguranca.md) - Como o HightJS protege sua aplicação
+- [Hot Reload](./hot-reload.md) - Como funciona o recarregamento automático
+
+---
+
+Voltar para o [README principal](../README.md)
+

package/docs/adapters.md

@@ -0,0 +1,7 @@
+# 🧱 Adapters
+
+Inicie via: `--framework native|express|fastify`
+
+- **Native**: zero dependências extras
+- **Express/Fastify**: instale peer deps (express ou fastify)
+

package/docs/arquivos-especiais.md

@@ -0,0 +1,10 @@
+# 📂 Arquivos Especiais
+
+| Arquivo                     | Localização                           | Função                                         |
+|-----------------------------|---------------------------------------|------------------------------------------------|
+| `layout.tsx`                | `/src/web`                            | Layout global + `export const metadata`         |
+| `notFound.tsx`              | `/src/web`                            | Página 404 customizada                         |
+| `middleware.ts`             | dentro de `/src/web/backend/routes`   | Middlewares globais por pasta backend           |
+| `hightweb.ts` / `.tsx`      | `/src/hightweb`                       | Instrumentação opcional executada no boot       |
+| `public/`                   | `/public`                             | Arquivos estáticos servidos diretamente         |
+