hightjs 0.5.3 → 0.5.4

package/dist/api/http.js

@@ -0,0 +1,469 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HightJSResponse = exports.HightJSRequest = void 0;
+// Input validation and sanitization utilities
+class SecurityUtils {
+    static sanitizeHeader(value) {
+        if (Array.isArray(value)) {
+            return value.map(v => this.sanitizeString(v, this.MAX_HEADER_LENGTH));
+        }
+        return this.sanitizeString(value, this.MAX_HEADER_LENGTH);
+    }
+    static sanitizeString(str, maxLength) {
+        if (typeof str !== 'string')
+            return '';
+        // Remove null bytes and control characters except newline/tab
+        let clean = str.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+        // Limit length
+        if (clean.length > maxLength) {
+            clean = clean.substring(0, maxLength);
+        }
+        return clean;
+    }
+    static isValidURL(url) {
+        if (!url || typeof url !== 'string')
+            return false;
+        if (url.length > this.MAX_URL_LENGTH)
+            return false;
+        // Basic URL validation - prevent dangerous protocols
+        const dangerousProtocols = ['javascript:', 'data:', 'vbscript:', 'file:'];
+        const lowerUrl = url.toLowerCase();
+        return !dangerousProtocols.some(protocol => lowerUrl.startsWith(protocol));
+    }
+    static validateContentLength(length) {
+        return length >= 0 && length <= this.MAX_BODY_SIZE;
+    }
+}
+SecurityUtils.MAX_HEADER_LENGTH = 8192;
+SecurityUtils.MAX_COOKIE_LENGTH = 4096;
+SecurityUtils.MAX_URL_LENGTH = 2048;
+SecurityUtils.MAX_BODY_SIZE = 10 * 1024 * 1024; // 10MB
+/**
+ * Abstração sobre a requisição HTTP de entrada.
+ * Funciona com qualquer framework web (Express, Fastify, etc.)
+ */
+class HightJSRequest {
+    constructor(req) {
+        // Validate and sanitize request data
+        this._req = this.validateAndSanitizeRequest(req);
+    }
+    validateAndSanitizeRequest(req) {
+        // Validate URL
+        if (!SecurityUtils.isValidURL(req.url)) {
+            throw new Error('Invalid URL format');
+        }
+        // Sanitize headers
+        const sanitizedHeaders = {};
+        for (const [key, value] of Object.entries(req.headers || {})) {
+            const cleanKey = SecurityUtils.sanitizeString(key.toLowerCase(), 100);
+            if (cleanKey && value) {
+                sanitizedHeaders[cleanKey] = SecurityUtils.sanitizeHeader(value);
+            }
+        }
+        // Validate content length
+        const contentLength = req.headers['content-length'];
+        if (contentLength) {
+            const length = parseInt(Array.isArray(contentLength) ? contentLength[0] : contentLength, 10);
+            if (!SecurityUtils.validateContentLength(length)) {
+                throw new Error('Request too large');
+            }
+        }
+        // Sanitize cookies
+        const sanitizedCookies = {};
+        for (const [key, value] of Object.entries(req.cookies || {})) {
+            const cleanKey = SecurityUtils.sanitizeString(key, 100);
+            const cleanValue = SecurityUtils.sanitizeString(value, SecurityUtils.MAX_COOKIE_LENGTH);
+            if (cleanKey && cleanValue) {
+                sanitizedCookies[cleanKey] = cleanValue;
+            }
+        }
+        return {
+            ...req,
+            headers: sanitizedHeaders,
+            cookies: sanitizedCookies,
+            url: SecurityUtils.sanitizeString(req.url, SecurityUtils.MAX_URL_LENGTH)
+        };
+    }
+    /**
+     * Retorna o método HTTP da requisição (GET, POST, etc.)
+     */
+    get method() {
+        return this._req.method;
+    }
+    /**
+     * Retorna a URL completa da requisição
+     */
+    get url() {
+        return this._req.url;
+    }
+    /**
+     * Retorna todos os headers da requisição
+     */
+    get headers() {
+        return this._req.headers;
+    }
+    /**
+     * Retorna um header específico com validação
+     */
+    header(name) {
+        if (!name || typeof name !== 'string')
+            return undefined;
+        const cleanName = SecurityUtils.sanitizeString(name.toLowerCase(), 100);
+        return this._req.headers[cleanName];
+    }
+    /**
+     * Retorna todos os query parameters
+     */
+    get query() {
+        return this._req.query || {};
+    }
+    /**
+     * Retorna todos os parâmetros de rota
+     */
+    get params() {
+        return this._req.params || {};
+    }
+    /**
+     * Retorna todos os cookies
+     */
+    get cookies() {
+        return this._req.cookies || {};
+    }
+    /**
+     * Retorna um cookie específico com validação
+     */
+    cookie(name) {
+        if (!name || typeof name !== 'string')
+            return undefined;
+        const cleanName = SecurityUtils.sanitizeString(name, 100);
+        return this._req.cookies?.[cleanName];
+    }
+    /**
+     * Retorna o corpo (body) da requisição, já parseado como JSON com validação
+     */
+    async json() {
+        try {
+            const body = this._req.body;
+            // Validate JSON structure
+            if (typeof body === 'string') {
+                // Check for potential JSON bombs
+                if (body.length > SecurityUtils.MAX_BODY_SIZE) {
+                    throw new Error('Request body too large');
+                }
+                return JSON.parse(body);
+            }
+            return body;
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                throw new Error('Invalid JSON format');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Retorna o corpo da requisição como texto
+     */
+    async text() {
+        if (typeof this._req.body === 'string') {
+            return this._req.body;
+        }
+        return JSON.stringify(this._req.body);
+    }
+    /**
+     * Retorna o corpo da requisição como FormData (para uploads)
+     */
+    async formData() {
+        return this._req.body;
+    }
+    /**
+     * Retorna a requisição original do framework
+     */
+    get raw() {
+        return this._req.raw;
+    }
+    /**
+     * Verifica se a requisição tem um content-type específico
+     */
+    is(type) {
+        const contentType = this.header('content-type');
+        if (!contentType)
+            return false;
+        const ct = Array.isArray(contentType) ? contentType[0] : contentType;
+        return ct.toLowerCase().includes(type.toLowerCase());
+    }
+    /**
+     * Verifica se a requisição é AJAX/XHR
+     */
+    get isAjax() {
+        const xhr = this.header('x-requested-with');
+        return xhr === 'XMLHttpRequest';
+    }
+    /**
+     * Retorna o IP do cliente com validação melhorada
+     */
+    get ip() {
+        // Check X-Forwarded-For with validation
+        const forwarded = this.header('x-forwarded-for');
+        if (forwarded) {
+            const ips = Array.isArray(forwarded) ? forwarded[0] : forwarded;
+            const firstIp = ips.split(',')[0].trim();
+            // Basic IP validation
+            if (this.isValidIP(firstIp)) {
+                return firstIp;
+            }
+        }
+        // Check X-Real-IP
+        const realIp = this.header('x-real-ip');
+        if (realIp) {
+            const ip = Array.isArray(realIp) ? realIp[0] : realIp;
+            if (this.isValidIP(ip)) {
+                return ip;
+            }
+        }
+        return 'unknown';
+    }
+    isValidIP(ip) {
+        if (!ip || typeof ip !== 'string')
+            return false;
+        // Basic IPv4 validation
+        const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+        if (ipv4Regex.test(ip)) {
+            const parts = ip.split('.');
+            return parts.every(part => {
+                const num = parseInt(part, 10);
+                return num >= 0 && num <= 255;
+            });
+        }
+        // Basic IPv6 validation (simplified)
+        const ipv6Regex = /^([0-9a-fA-F]{0,4}:){1,7}[0-9a-fA-F]{0,4}$/;
+        return ipv6Regex.test(ip);
+    }
+    /**
+     * Retorna o User-Agent
+     */
+    get userAgent() {
+        const ua = this.header('user-agent');
+        return Array.isArray(ua) ? ua[0] : ua;
+    }
+}
+exports.HightJSRequest = HightJSRequest;
+/**
+ * Abstração para construir a resposta HTTP.
+ * Funciona com qualquer framework web (Express, Fastify, etc.)
+ */
+class HightJSResponse {
+    constructor() {
+        this._status = 200;
+        this._headers = {};
+        this._cookies = [];
+        this._body = null;
+        this._sent = false;
+    }
+    /**
+     * Define o status HTTP da resposta
+     */
+    status(code) {
+        this._status = code;
+        return this;
+    }
+    /**
+     * Define um header da resposta
+     */
+    header(name, value) {
+        this._headers[name] = value;
+        return this;
+    }
+    /**
+     * Define múltiplos headers
+     */
+    headers(headers) {
+        Object.assign(this._headers, headers);
+        return this;
+    }
+    /**
+     * Define um cookie
+     */
+    cookie(name, value, options) {
+        this._cookies.push({ name, value, options });
+        return this;
+    }
+    /**
+     * Remove um cookie
+     */
+    clearCookie(name, options) {
+        this._cookies.push({
+            name,
+            value: '',
+            options: { ...options, expires: new Date(0) }
+        });
+        return this;
+    }
+    /**
+     * Envia resposta JSON
+     */
+    json(data) {
+        this._headers['Content-Type'] = 'application/json';
+        this._body = JSON.stringify(data);
+        this._sent = true;
+        return this;
+    }
+    /**
+     * Envia resposta de texto
+     */
+    text(data) {
+        this._headers['Content-Type'] = 'text/plain; charset=utf-8';
+        this._body = data;
+        this._sent = true;
+        return this;
+    }
+    /**
+     * Envia resposta HTML
+     */
+    html(data) {
+        this._headers['Content-Type'] = 'text/html; charset=utf-8';
+        this._body = data;
+        this._sent = true;
+        return this;
+    }
+    /**
+     * Envia qualquer tipo de dados
+     */
+    send(data) {
+        this._body = data;
+        this._sent = true;
+        return this;
+    }
+    /**
+     * Redireciona para uma URL
+     */
+    redirect(url, status = 302) {
+        this._status = status;
+        this._headers['Location'] = url;
+        this._sent = true;
+        return this;
+    }
+    /**
+     * Método interno para aplicar a resposta ao objeto de resposta do framework
+     */
+    _applyTo(res) {
+        // Aplica status
+        res.status(this._status);
+        // Aplica headers
+        Object.entries(this._headers).forEach(([name, value]) => {
+            res.header(name, value);
+        });
+        // Aplica cookies
+        this._cookies.forEach(({ name, value, options }) => {
+            if (options?.expires && options.expires.getTime() === 0) {
+                res.clearCookie(name, options);
+            }
+            else {
+                res.cookie(name, value, options);
+            }
+        });
+        // Handle redirects specifically
+        if (this._headers['Location']) {
+            res.redirect(this._headers['Location']);
+            return;
+        }
+        // Envia o corpo se foi definido
+        if (this._sent && this._body !== null) {
+            if (this._headers['Content-Type']?.includes('application/json')) {
+                res.json(JSON.parse(this._body));
+            }
+            else {
+                res.send(this._body);
+            }
+        }
+    }
+    /**
+     * Método de compatibilidade com versão anterior (Express)
+     */
+    _send(res) {
+        // Assume que é Express se tem os métodos específicos
+        if (res.set && res.status && res.send) {
+            res.set(this._headers).status(this._status);
+            this._cookies.forEach(({ name, value, options }) => {
+                if (options?.expires && options.expires.getTime() === 0) {
+                    res.clearCookie(name, options);
+                }
+                else {
+                    res.cookie(name, value, options);
+                }
+            });
+            res.send(this._body);
+        }
+    }
+    // === MÉTODOS ESTÁTICOS DE CONVENIÊNCIA ===
+    /**
+     * Cria uma resposta JSON
+     */
+    static json(data, options) {
+        const response = new HightJSResponse();
+        if (options?.status)
+            response.status(options.status);
+        if (options?.headers)
+            response.headers(options.headers);
+        return response.json(data);
+    }
+    /**
+     * Cria uma resposta de texto
+     */
+    static text(data, options) {
+        const response = new HightJSResponse();
+        if (options?.status)
+            response.status(options.status);
+        if (options?.headers)
+            response.headers(options.headers);
+        return response.text(data);
+    }
+    /**
+     * Cria uma resposta HTML
+     */
+    static html(data, options) {
+        const response = new HightJSResponse();
+        if (options?.status)
+            response.status(options.status);
+        if (options?.headers)
+            response.headers(options.headers);
+        return response.html(data);
+    }
+    /**
+     * Cria um redirecionamento
+     */
+    static redirect(url, status = 302) {
+        return new HightJSResponse().redirect(url, status);
+    }
+    /**
+     * Cria uma resposta 404
+     */
+    static notFound(message = 'Not Found') {
+        return HightJSResponse.text(message, { status: 404 });
+    }
+    /**
+     * Cria uma resposta 500
+     */
+    static error(message = 'Internal Server Error') {
+        return HightJSResponse.text(message, { status: 500 });
+    }
+    /**
+     * Cria uma resposta 400
+     */
+    static badRequest(message = 'Bad Request') {
+        return HightJSResponse.text(message, { status: 400 });
+    }
+    /**
+     * Cria uma resposta 401
+     */
+    static unauthorized(message = 'Unauthorized') {
+        return HightJSResponse.text(message, { status: 401 });
+    }
+    /**
+     * Cria uma resposta 403
+     */
+    static forbidden(message = 'Forbidden') {
+        return HightJSResponse.text(message, { status: 403 });
+    }
+}
+exports.HightJSResponse = HightJSResponse;

package/dist/bin/hightjs.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/hightjs.js

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+"use strict";
+/*
+ * 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.
+ */
+// Registra o ts-node para que o Node.js entenda TypeScript/TSX
+require('ts-node').register();
+// Registra loaders customizados para arquivos markdown, imagens, etc.
+const { registerLoaders } = require('../loaders');
+registerLoaders();
+const { program } = require('commander');
+program
+    .version('1.0.0')
+    .description('CLI to manage the application.');
+// --- Comando DEV ---
+const fs = require('fs');
+const path = require('path');
+// 'program' já deve estar definido no seu arquivo
+// const { program } = require('commander');
+/**
+ * Função centralizada para iniciar a aplicação
+ * @param {object} options - Opções vindas do commander
+ * @param {boolean} isDev - Define se é modo de desenvolvimento
+ */
+function initializeApp(options, isDev) {
+    const appOptions = {
+        dev: isDev,
+        port: options.port,
+        hostname: options.hostname,
+        framework: 'native',
+        ssl: null, // Default
+    };
+    // 1. Verifica se a flag --ssl foi ativada
+    if (options.ssl) {
+        const C = require("../api/console");
+        const { Levels } = C;
+        const Console = C.default;
+        const sslDir = path.resolve(process.cwd(), 'certs');
+        const keyPath = path.join(sslDir, 'key.pem'); // Padrão 1: key.pem
+        const certPath = path.join(sslDir, 'cert.pem'); // Padrão 2: cert.pem
+        // (Você pode mudar para 'cert.key' se preferir, apenas ajuste os nomes aqui)
+        // 2. Verifica se os arquivos existem
+        if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
+            appOptions.ssl = {
+                key: keyPath,
+                cert: certPath
+            };
+            // 3. Adiciona a porta de redirecionamento (útil para o initNativeServer)
+            appOptions.ssl.redirectPort = options.httpRedirectPort || 80;
+        }
+        else {
+            Console.logWithout(Levels.ERROR, null, `Ensure that './certs/key.pem' and './certs/cert.pem' exist.`, `--ssl flag was used, but the files were not found.`);
+            process.exit(1); // Encerra o processo com erro
+        }
+    }
+    // 4. Inicia o helper com as opções
+    const teste = require("../helpers");
+    const t = teste.default(appOptions);
+    t.init();
+}
+// --- Comando DEV ---
+program
+    .command('dev')
+    .description('Starts the application in development mode.')
+    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
+    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
+    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
+    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
+    .action((options) => {
+    initializeApp(options, true); // Chama a função com dev: true
+});
+// --- Comando START (Produção) ---
+program
+    .command('start')
+    .description('Starts the application in production mode.')
+    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
+    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
+    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
+    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
+    .action((options) => {
+    initializeApp(options, false); // Chama a função com dev: false
+});
+/**
+ * Função corrigida para copiar diretórios recursivamente.
+ * Ela agora verifica se um item é um arquivo ou um diretório.
+ */
+function copyDirRecursive(src, dest) {
+    try {
+        // Garante que o diretório de destino exista
+        fs.mkdirSync(dest, { recursive: true });
+        // Usamos { withFileTypes: true } para evitar uma chamada extra de fs.statSync
+        const entries = fs.readdirSync(src, { withFileTypes: true });
+        for (let entry of entries) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                // Se for um diretório, chama a si mesma (recursão)
+                copyDirRecursive(srcPath, destPath);
+            }
+            else {
+                // Se for um arquivo, apenas copia
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`❌ Erro ao copiar ${src} para ${dest}:`, error);
+        // Lança o erro para parar o processo de exportação se a cópia falhar
+        throw error;
+    }
+}
+// --- INÍCIO DO SEU CÓDIGO (AGORA CORRIGIDO) ---
+program
+    .command('export')
+    .description('Exports the application as static HTML to the "exported" folder.')
+    .option('-o, --output <path>', 'Specifies the output directory', 'exported')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    // Usar path.resolve é mais seguro para garantir um caminho absoluto
+    const exportDir = path.resolve(projectDir, options.output);
+    console.log('🚀 Starting export...\n');
+    try {
+        // 1. Cria a pasta exported (limpa se já existir)
+        if (fs.existsSync(exportDir)) {
+            console.log('🗑️  Cleaning existing export folder...');
+            fs.rmSync(exportDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(exportDir, { recursive: true });
+        console.log('✅ Export folder created\n');
+        // 2. Inicializa e prepara o build
+        console.log('🔨 Building application...');
+        // ATENÇÃO: Ajuste o caminho deste 'require' conforme a estrutura do seu projeto!
+        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 complete\n');
+        // 3. Copia a pasta .hight para exported (*** CORRIGIDO ***)
+        const distDir = path.join(projectDir, '.hight');
+        if (fs.existsSync(distDir)) {
+            console.log('📦 Copying JavaScript files...');
+            const exportDistDir = path.join(exportDir, '.hight');
+            // --- Lógica de cópia substituída ---
+            // A função copyDirRecursive agora lida com tudo (arquivos e subpastas)
+            copyDirRecursive(distDir, exportDistDir);
+            // --- Fim da substituição ---
+            console.log('✅ JavaScript files copied\n');
+        }
+        // 4. Copia a pasta public se existir (*** CORRIGIDO ***)
+        const publicDir = path.join(projectDir, 'public');
+        if (fs.existsSync(publicDir)) {
+            console.log('📁 Copying public files...');
+            const exportPublicDir = path.join(exportDir, 'public');
+            // --- Lógica de cópia substituída ---
+            // Reutilizamos a mesma função corrigida
+            copyDirRecursive(publicDir, exportPublicDir);
+            // --- Fim da substituição ---
+            console.log('✅ Public files copied\n');
+        }
+        // 5. Gera o index.html
+        console.log('📝 Generating index.html...');
+        // ATENÇÃO: Ajuste os caminhos destes 'requires' conforme a estrutura do seu projeto!
+        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 scriptReplaced = html.replace('/_hight/', './.hight/');
+            const indexPath = path.join(exportDir, 'index.html');
+            fs.writeFileSync(indexPath, scriptReplaced, 'utf8');
+            console.log('✅ index.html generated\n');
+        }
+        console.log('🎉 Export completed successfully!');
+        console.log(`📂 Files exported to: ${exportDir}\n`);
+    }
+    catch (error) {
+        // Logar o erro completo (com stack trace) é mais útil
+        console.error('❌ Error during export:', error);
+        process.exit(1);
+    }
+});
+// Faz o "parse" dos argumentos passados na linha de comando
+program.parse(process.argv);