hightjs 0.5.3 → 0.5.5

package/dist/adapters/express.d.ts

@@ -0,0 +1,7 @@
+import type { Request as ExpressRequest, Response as ExpressResponse } from 'express';
+import { GenericRequest, GenericResponse, FrameworkAdapter } from '../types/framework';
+export declare class ExpressAdapter implements FrameworkAdapter {
+    type: "express";
+    parseRequest(req: ExpressRequest): GenericRequest;
+    createResponse(res: ExpressResponse): GenericResponse;
+}

package/dist/adapters/express.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressAdapter = void 0;
+class ExpressAdapter {
+    constructor() {
+        this.type = 'express';
+    }
+    parseRequest(req) {
+        return {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            body: req.body,
+            query: req.query,
+            params: req.params,
+            cookies: req.cookies || {},
+            raw: req,
+        };
+    }
+    createResponse(res) {
+        return new ExpressResponseWrapper(res);
+    }
+}
+exports.ExpressAdapter = ExpressAdapter;
+class ExpressResponseWrapper {
+    constructor(res) {
+        this.res = res;
+    }
+    get raw() {
+        return this.res;
+    }
+    status(code) {
+        this.res.status(code);
+        return this;
+    }
+    header(name, value) {
+        this.res.setHeader(name, value);
+        return this;
+    }
+    cookie(name, value, options) {
+        this.res.cookie(name, value, options || {});
+        return this;
+    }
+    clearCookie(name, options) {
+        // Filter out the deprecated 'expires' option to avoid Express deprecation warning
+        const { expires, ...filteredOptions } = options || {};
+        this.res.clearCookie(name, filteredOptions);
+        return this;
+    }
+    json(data) {
+        this.res.json(data);
+    }
+    text(data) {
+        this.res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+        this.res.send(data);
+    }
+    send(data) {
+        this.res.send(data);
+    }
+    redirect(url) {
+        this.res.redirect(url);
+    }
+}

package/dist/adapters/factory.d.ts

@@ -0,0 +1,23 @@
+import { FrameworkAdapter } from '../types/framework';
+/**
+ * Factory para criar o adapter correto baseado no framework detectado
+ */
+export declare class FrameworkAdapterFactory {
+    private static adapter;
+    /**
+     * Detecta automaticamente o framework baseado na requisição/resposta
+     */
+    static detectFramework(req: any, res: any): FrameworkAdapter;
+    /**
+     * Força o uso de um framework específico
+     */
+    static setFramework(framework: 'express' | 'fastify' | 'native'): void;
+    /**
+     * Reset do adapter (útil para testes)
+     */
+    static reset(): void;
+    /**
+     * Retorna o adapter atual (se já foi detectado)
+     */
+    static getCurrentAdapter(): FrameworkAdapter | null;
+}

package/dist/adapters/factory.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameworkAdapterFactory = void 0;
+const express_1 = require("./express");
+const fastify_1 = require("./fastify");
+const native_1 = require("./native");
+const console_1 = __importStar(require("../api/console"));
+/**
+ * Factory para criar o adapter correto baseado no framework detectado
+ */
+class FrameworkAdapterFactory {
+    /**
+     * Detecta automaticamente o framework baseado na requisição/resposta
+     */
+    static detectFramework(req, res) {
+        // Se já detectamos antes, retorna o mesmo adapter
+        if (this.adapter) {
+            return this.adapter;
+        }
+        const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgYellow}●  ${console_1.Colors.Reset}Detecting web framework...`);
+        // Detecta Express
+        if (req.app && req.route && res.locals !== undefined) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Express`);
+            this.adapter = new express_1.ExpressAdapter();
+            return this.adapter;
+        }
+        // Detecta Fastify
+        if (req.server && req.routerPath !== undefined && res.request) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Fastify`);
+            this.adapter = new fastify_1.FastifyAdapter();
+            return this.adapter;
+        }
+        // Detecta HTTP nativo do Node.js
+        if (req.method !== undefined && req.url !== undefined && req.headers !== undefined &&
+            res.statusCode !== undefined && res.setHeader !== undefined && res.end !== undefined) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: HightJS Native (HTTP)`);
+            this.adapter = new native_1.NativeAdapter();
+            return this.adapter;
+        }
+        // Fallback mais específico para Express
+        if (res.status && res.send && res.json && res.cookie) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Express (fallback)`);
+            this.adapter = new express_1.ExpressAdapter();
+            return this.adapter;
+        }
+        // Fallback mais específico para Fastify
+        if (res.code && res.send && res.type && res.setCookie) {
+            msg.end(`  ${console_1.Colors.FgGreen}●  ${console_1.Colors.Reset}Framework detected: Fastify (fallback)`);
+            this.adapter = new fastify_1.FastifyAdapter();
+            return this.adapter;
+        }
+        // Default para HightJS Native se não conseguir detectar
+        msg.end(`  ${console_1.Colors.FgYellow}●  ${console_1.Colors.Reset}Unable to detect framework. Using HightJS Native as default.`);
+        this.adapter = new native_1.NativeAdapter();
+        return this.adapter;
+    }
+    /**
+     * Força o uso de um framework específico
+     */
+    static setFramework(framework) {
+        switch (framework) {
+            case 'express':
+                this.adapter = new express_1.ExpressAdapter();
+                break;
+            case 'fastify':
+                this.adapter = new fastify_1.FastifyAdapter();
+                break;
+            case 'native':
+                this.adapter = new native_1.NativeAdapter();
+                break;
+            default:
+                throw new Error(`Unsupported framework: ${framework}`);
+        }
+    }
+    /**
+     * Reset do adapter (útil para testes)
+     */
+    static reset() {
+        this.adapter = null;
+    }
+    /**
+     * Retorna o adapter atual (se já foi detectado)
+     */
+    static getCurrentAdapter() {
+        return this.adapter;
+    }
+}
+exports.FrameworkAdapterFactory = FrameworkAdapterFactory;
+FrameworkAdapterFactory.adapter = null;

package/dist/adapters/fastify.d.ts

@@ -0,0 +1,25 @@
+interface FastifyRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string | string[]>;
+    body?: any;
+    query?: Record<string, any>;
+    params?: Record<string, string>;
+    cookies?: Record<string, string>;
+}
+interface FastifyReply {
+    status(code: number): FastifyReply;
+    header(name: string, value: string): FastifyReply;
+    setCookie(name: string, value: string, options?: any): FastifyReply;
+    clearCookie(name: string, options?: any): FastifyReply;
+    type(contentType: string): FastifyReply;
+    send(data: any): void;
+    redirect(url: string): void;
+}
+import { GenericRequest, GenericResponse, FrameworkAdapter } from '../types/framework';
+export declare class FastifyAdapter implements FrameworkAdapter {
+    type: "fastify";
+    parseRequest(req: FastifyRequest): GenericRequest;
+    createResponse(reply: FastifyReply): GenericResponse;
+}
+export {};

package/dist/adapters/fastify.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FastifyAdapter = void 0;
+class FastifyAdapter {
+    constructor() {
+        this.type = 'fastify';
+    }
+    parseRequest(req) {
+        return {
+            method: req.method,
+            url: req.url,
+            headers: req.headers,
+            body: req.body,
+            query: req.query,
+            params: req.params,
+            cookies: req.cookies || {},
+            raw: req
+        };
+    }
+    createResponse(reply) {
+        return new FastifyResponseWrapper(reply);
+    }
+}
+exports.FastifyAdapter = FastifyAdapter;
+class FastifyResponseWrapper {
+    constructor(reply) {
+        this.reply = reply;
+    }
+    get raw() {
+        return this.reply;
+    }
+    status(code) {
+        this.reply.status(code);
+        return this;
+    }
+    header(name, value) {
+        this.reply.header(name, value);
+        return this;
+    }
+    cookie(name, value, options) {
+        this.reply.setCookie(name, value, options);
+        return this;
+    }
+    clearCookie(name, options) {
+        this.reply.clearCookie(name, options);
+        return this;
+    }
+    json(data) {
+        this.reply.send(data);
+    }
+    text(data) {
+        this.reply.type('text/plain; charset=utf-8');
+        this.reply.send(data);
+    }
+    send(data) {
+        this.reply.send(data);
+    }
+    redirect(url) {
+        this.reply.redirect(url);
+    }
+}

package/dist/adapters/native.d.ts

@@ -0,0 +1,8 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+import { GenericRequest, GenericResponse, FrameworkAdapter } from '../types/framework';
+export declare class NativeAdapter implements FrameworkAdapter {
+    type: "native";
+    parseRequest(req: IncomingMessage): GenericRequest;
+    createResponse(res: ServerResponse): GenericResponse;
+    private parseCookies;
+}

package/dist/adapters/native.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NativeAdapter = void 0;
+const url_1 = require("url");
+// --- Funções Auxiliares de Segurança ---
+/**
+ * Remove caracteres de quebra de linha (\r, \n) de uma string para prevenir
+ * ataques de HTTP Header Injection (CRLF Injection).
+ * @param value O valor a ser sanitizado.
+ * @returns A string sanitizada.
+ */
+function sanitizeHeaderValue(value) {
+    return String(value).replace(/[\r\n]/g, '');
+}
+/**
+ * Valida se o nome de um cookie contém apenas caracteres permitidos pela RFC 6265.
+ * Isso previne a criação de cookies com nomes inválidos ou maliciosos.
+ * @param name O nome do cookie a ser validado.
+ * @returns `true` se o nome for válido, `false` caso contrário.
+ */
+function isValidCookieName(name) {
+    // A RFC 6265 define 'token' como 1 ou mais caracteres que não são controle nem separadores.
+    // Separadores: ( ) < > @ , ; : \ " / [ ] ? = { }
+    const validCookieNameRegex = /^[a-zA-Z0-9!#$%&'*+-.^_`|~]+$/;
+    return validCookieNameRegex.test(name);
+}
+class NativeAdapter {
+    constructor() {
+        this.type = 'native';
+    }
+    parseRequest(req) {
+        const url = (0, url_1.parse)(req.url || '', true);
+        return {
+            method: req.method || 'GET',
+            url: req.url || '/',
+            headers: req.headers,
+            // Adicionado fallback para null para maior segurança caso o body parser não tenha rodado.
+            body: req.body ?? null,
+            // Tipo mais específico para a query.
+            query: url.query,
+            params: {}, // Será preenchido pelo roteador
+            cookies: this.parseCookies(req.headers.cookie || ''),
+            raw: req
+        };
+    }
+    createResponse(res) {
+        return new NativeResponseWrapper(res);
+    }
+    parseCookies(cookieHeader) {
+        const cookies = {};
+        if (!cookieHeader)
+            return cookies;
+        cookieHeader.split(';').forEach(cookie => {
+            const [name, ...rest] = cookie.trim().split('=');
+            if (name && rest.length > 0) {
+                try {
+                    // Tenta decodificar o valor do cookie.
+                    cookies[name] = decodeURIComponent(rest.join('='));
+                }
+                catch (e) {
+                    // Prevenção de crash: Ignora cookies com valores malformados (e.g., URI inválida).
+                    console.error(`Warning: Malformed cookie with name "${name}" was ignored.`);
+                }
+            }
+        });
+        return cookies;
+    }
+}
+exports.NativeAdapter = NativeAdapter;
+class NativeResponseWrapper {
+    constructor(res) {
+        this.res = res;
+        this.statusCode = 200;
+        this.headers = {};
+        this.cookiesToSet = []; // Array para lidar corretamente com múltiplos cookies.
+        this.finished = false;
+    }
+    get raw() {
+        return this.res;
+    }
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    header(name, value) {
+        // Medida de segurança CRÍTICA: Previne HTTP Header Injection (CRLF Injection).
+        // Sanitiza tanto o nome quanto o valor do header para remover quebras de linha.
+        const sanitizedName = sanitizeHeaderValue(name);
+        const sanitizedValue = sanitizeHeaderValue(value);
+        if (name !== sanitizedName || String(value) !== sanitizedValue) {
+            console.warn(`Warning: Potential HTTP Header Injection attempt detected and sanitized. Original header: "${name}"`);
+        }
+        this.headers[sanitizedName] = sanitizedValue;
+        return this;
+    }
+    cookie(name, value, options) {
+        // Medida de segurança: Valida o nome do cookie.
+        if (!isValidCookieName(name)) {
+            console.error(`Error: Invalid cookie name "${name}". The cookie will not be set.`);
+            return this;
+        }
+        let cookieString = `${name}=${encodeURIComponent(value)}`;
+        if (options) {
+            // Sanitiza as opções que são strings para prevenir Header Injection.
+            if (options.domain)
+                cookieString += `; Domain=${sanitizeHeaderValue(options.domain)}`;
+            if (options.path)
+                cookieString += `; Path=${sanitizeHeaderValue(options.path)}`;
+            if (options.expires)
+                cookieString += `; Expires=${options.expires.toUTCString()}`;
+            if (options.maxAge)
+                cookieString += `; Max-Age=${options.maxAge}`;
+            if (options.httpOnly)
+                cookieString += '; HttpOnly';
+            if (options.secure)
+                cookieString += '; Secure';
+            if (options.sameSite) {
+                const sameSiteValue = typeof options.sameSite === 'boolean' ? 'Strict' : options.sameSite;
+                cookieString += `; SameSite=${sanitizeHeaderValue(sameSiteValue)}`;
+            }
+        }
+        this.cookiesToSet.push(cookieString);
+        return this;
+    }
+    clearCookie(name, options) {
+        const clearOptions = { ...options, expires: new Date(0), maxAge: 0 };
+        return this.cookie(name, '', clearOptions);
+    }
+    writeHeaders() {
+        if (this.finished)
+            return;
+        this.res.statusCode = this.statusCode;
+        Object.entries(this.headers).forEach(([name, value]) => {
+            this.res.setHeader(name, value);
+        });
+        // CORREÇÃO: Envia múltiplos cookies corretamente como headers 'Set-Cookie' separados.
+        // O método antigo de juntar com vírgula estava incorreto.
+        if (this.cookiesToSet.length > 0) {
+            this.res.setHeader('Set-Cookie', this.cookiesToSet);
+        }
+    }
+    json(data) {
+        if (this.finished)
+            return;
+        this.header('Content-Type', 'application/json; charset=utf-8');
+        this.writeHeaders();
+        const jsonString = JSON.stringify(data);
+        this.res.end(jsonString);
+        this.finished = true;
+    }
+    text(data) {
+        if (this.finished)
+            return;
+        this.header('Content-Type', 'text/plain; charset=utf-8');
+        this.writeHeaders();
+        this.res.end(data);
+        this.finished = true;
+    }
+    send(data) {
+        if (this.finished)
+            return;
+        const existingContentType = this.headers['Content-Type'];
+        if (typeof data === 'string') {
+            if (!existingContentType) {
+                this.header('Content-Type', 'text/plain; charset=utf-8');
+            }
+            this.writeHeaders();
+            this.res.end(data);
+        }
+        else if (Buffer.isBuffer(data)) {
+            this.writeHeaders();
+            this.res.end(data);
+        }
+        else if (data !== null && typeof data === 'object') {
+            this.json(data); // Reutiliza o método json para consistência
+            return; // O método json já finaliza a resposta
+        }
+        else {
+            if (!existingContentType) {
+                this.header('Content-Type', 'text/plain; charset=utf-8');
+            }
+            this.writeHeaders();
+            this.res.end(String(data));
+        }
+        this.finished = true;
+    }
+    redirect(url) {
+        if (this.finished)
+            return;
+        this.status(302);
+        // A sanitização no método .header() previne que um URL manipulado
+        // cause um ataque de Open Redirect via Header Injection.
+        this.header('Location', url);
+        this.writeHeaders();
+        this.res.end();
+        this.finished = true;
+    }
+}

package/dist/api/console.d.ts

@@ -0,0 +1,94 @@
+import { Options as BoxenOptions } from 'boxen';
+/**
+ * Um "handle" para uma linha dinâmica. As instâncias desta classe
+ * são retornadas por `Console.dynamicLine()` e usadas para controlar
+ * o conteúdo da linha.
+ */
+export declare class DynamicLine {
+    private readonly _id;
+    constructor(initialContent: string);
+    /**
+     * Atualiza o conteúdo da linha no console.
+     * @param newContent O novo texto a ser exibido.
+     */
+    update(newContent: string): void;
+    /**
+     * Finaliza a linha, opcionalmente com um texto final, e a torna estática.
+     * @param finalContent O texto final a ser exibido.
+     */
+    end(finalContent: string): void;
+}
+export declare enum Colors {
+    Reset = "\u001B[0m",
+    Bright = "\u001B[1m",
+    Dim = "\u001B[2m",
+    Underscore = "\u001B[4m",
+    Blink = "\u001B[5m",
+    Reverse = "\u001B[7m",
+    Hidden = "\u001B[8m",
+    FgBlack = "\u001B[30m",
+    FgRed = "\u001B[31m",
+    FgGreen = "\u001B[32m",
+    FgYellow = "\u001B[33m",
+    FgBlue = "\u001B[34m",
+    FgMagenta = "\u001B[35m",
+    FgCyan = "\u001B[36m",
+    FgWhite = "\u001B[37m",
+    FgGray = "\u001B[90m",// ← adicionado
+    BgBlack = "\u001B[40m",
+    BgRed = "\u001B[41m",
+    BgGreen = "\u001B[42m",
+    BgYellow = "\u001B[43m",
+    BgBlue = "\u001B[44m",
+    BgMagenta = "\u001B[45m",
+    BgCyan = "\u001B[46m",
+    BgWhite = "\u001B[47m",
+    BgGray = "\u001B[100m"
+}
+export declare enum Levels {
+    ERROR = "ERROR",
+    WARN = "WARN",
+    INFO = "INFO",
+    DEBUG = "DEBUG",
+    SUCCESS = "SUCCESS"
+}
+export default class Console {
+    private static activeLines;
+    private static lastRenderedLines;
+    /**
+     * Limpa todas as linhas dinâmicas da tela e as redesenha com o conteúdo atualizado.
+     * Observação: usamos lastRenderedLines para saber quantas linhas mover
+     * o cursor para cima (isso evita mover para cima demais quando uma nova
+     * linha foi registrada).
+     */
+    private static redrawDynamicLines;
+    /**
+     * Envolve a escrita de texto estático (logs normais) para não interferir
+     * com as linhas dinâmicas.
+     */
+    private static writeStatic;
+    private static registerDynamicLine;
+    private static updateDynamicLine;
+    private static endDynamicLine;
+    static error(...args: any[]): void;
+    static warn(...args: any[]): void;
+    static info(...args: any[]): void;
+    static success(...args: any[]): void;
+    static debug(...args: any[]): void;
+    static logCustomLevel(levelName: string, without?: boolean, color?: Colors, ...args: any[]): void;
+    static logWithout(level: Levels, colors?: Colors, ...args: any[]): void;
+    static log(level: Levels, colors?: Colors, ...args: any[]): void;
+    static ask(question: string, defaultValue?: string): Promise<string>;
+    static confirm(message: string, defaultYes?: boolean): Promise<boolean>;
+    static table(data: Record<string, any> | Array<{
+        Field: string;
+        Value: any;
+    }>): void;
+    static box(content: string, options?: BoxenOptions): void;
+    /**
+     * Cria e retorna um controlador para uma linha dinâmica no console.
+     * @param initialContent O conteúdo inicial a ser exibido.
+     * @returns Uma instância de DynamicLine para controlar a linha.
+     */
+    static dynamicLine(initialContent: string): DynamicLine;
+}