hightjs 0.2.43 → 0.2.46

package/src/bin/hightjs.js

@@ -5,6 +5,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')
@@ -36,5 +38,478 @@ program
         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/src/index.ts

@@ -185,6 +185,8 @@ export default function hweb(options: HightJSOptions) {
         request: HightJSRequest,
         params: { [key: string]: string }
     ): Promise<HightJSResponse> {
+        // @ts-ignore
+        process.hight = options;
         if (!middlewares || middlewares.length === 0) {
             // Não há middlewares, executa diretamente o handler final
             return await finalHandler(request, params);

package/src/renderer.tsx

@@ -105,7 +105,8 @@ function getJavaScriptFiles(req: GenericRequest): string {
                     return a.localeCompare(b);
                 });
 
-            if (jsFiles.length > 1) {
+            // @ts-ignore
+            if (jsFiles.length > 1 && !process.hight.dev) {
                 // Modo chunks sem manifesto
                 return jsFiles
                     .map(file => `<script src="/hweb-dist/${file}"></script>`)

package/src/router.ts

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

package/dist/adapters/starters/express.js

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

package/dist/adapters/starters/factory.js

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

package/dist/adapters/starters/fastify.js

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

package/dist/adapters/starters/index.js

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

package/dist/adapters/starters/native.js

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

package/dist/auth/example.d.ts

@@ -1,40 +0,0 @@
-/**
- * Exemplo de como usar os novos providers baseados em classes
- */
-export declare const authRoutes: {
-    pattern: string;
-    GET(req: import("..").HightJSRequest, params: {
-        [key: string]: string;
-    }): Promise<any>;
-    POST(req: import("..").HightJSRequest, params: {
-        [key: string]: string;
-    }): Promise<any>;
-    auth: import("./core").HWebAuth;
-};
-/**
- * Como usar em suas rotas API:
- *
- * // arquivo: /api/auth/[...value].ts
- * import { authRoutes } from '../../../src/auth/example';
- *
- * export const GET = authRoutes.GET;
- * export const POST = authRoutes.POST;
- */
-/**
- * Rotas disponíveis automaticamente:
- *
- * Core routes:
- * - GET  /api/auth/session - Obter sessão atual
- * - GET  /api/auth/providers - Listar providers
- * - GET  /api/auth/csrf - Obter token CSRF
- * - POST /api/auth/signin - Login
- * - POST /api/auth/signout - Logout
- *
- * Provider específico (CredentialsProvider):
- * - GET  /api/auth/credentials/config - Config do provider
- *
- * Provider específico (DiscordProvider):
- * - GET  /api/auth/signin/discord - Iniciar OAuth Discord
- * - GET  /api/auth/callback/discord - Callback OAuth Discord
- * - GET  /api/auth/discord/config - Config do provider Discord
- */