nicola-framework 1.0.3 → 1.0.5

package/README.md

@@ -10,30 +10,60 @@ Nicola expone un **servidor HTTP nativo** con un **router tipo Express** y utili
 
 ---
 
-## ✅ Estado actual del proyecto (lo que realmente hay)
+## 📌 Índice
+
+- [Qué incluye](#-qué-incluye)
+- [Instalación](#-instalación)
+- [Crear un proyecto (CLI)](#-crear-un-proyecto-cli)
+- [Levantar el servidor (dev)](#-levantar-el-servidor-dev)
+- [Quickstart (manual)](#-quickstart-manual)
+- [Guía del Router](#-guía-del-router)
+- [Request/Response (lo que hay)](#-requestresponse-lo-que-hay)
+- [Manejo de errores](#-manejo-de-errores)
+- [Middlewares](#-middlewares)
+- [Seguridad (Regulator + JWT)](#-seguridad-regulator--jwt)
+- [Dynamo ORM (Postgres)](#-dynamo-orm-postgres)
+- [Variables de entorno](#-variables-de-entorno)
+- [Tests](#-tests)
+- [Troubleshooting](#-troubleshooting)
+
+---
+
+## ✅ Qué incluye
+
+Esta lista está alineada con el **código actual** del repositorio:
 
 - **Core/Router**: `Nicola` (default) extiende `Remote`.
 - **Body parsing**: JSON si `Content-Type` incluye `application/json` (límite ~2MB). Si no, `req.body = {}`.
-- **Helpers de response**: `res.json(data)` y `res.send(text)`. (No existe `res.status()`.)
-- **CORS**: `EasyCors` permite `*` y responde `OPTIONS` con `204`.
+- **Helpers de response**: `res.json(data)` y `res.send(text)`.
+  - Nota: no existe `res.status()`; usa `res.statusCode`.
+- **CORS**: `EasyCors()` permite `*` y responde `OPTIONS` con `204`.
 - **Security headers**: `Teleforce` aplica headers básicos (no-sniff, frame deny, etc.).
 - **Logger**: `Shadowgraph` loggea al terminar la respuesta.
 - **Errores**: si un handler lanza error o llama `next(err)`, se responde HTML via `BlackBox`.
-- **JWT**: `Coherer` (HS256) funciona vía métodos **estáticos** y requiere `NICOLA_SECRET` en env.
-- **ORM**: `Dynamo` soporta **Postgres** hoy (driver `postgres`). La lib `pg` es **dependencia opcional** (se instala aparte).
-- **Hot reload**: `LiveCurrent` reinicia el proceso Node al detectar cambios en el directorio.
+  - En `NODE_ENV=production` se ocultan mensaje/stack al cliente.
+- **JWT**: `Coherer` (HS256) via métodos **estáticos** y requiere `NICOLA_SECRET`.
+- **ORM**: `Dynamo` soporta **Postgres** (driver `postgres`). `pg` es dependencia opcional.
+- **Hot reload**: `LiveCurrent` reinicia el proceso Node al detectar cambios (en `process.cwd()`).
 
 ---
 
 ## 📦 Instalación
 
+Requisitos:
+
+- Node.js >= 16
+- Proyecto ESM (Nicola es ESM)
+
+Instalar como dependencia del proyecto:
+
 ```bash
 npm install nicola-framework
 ```
 
 ### (Opcional) Postgres
 
-El dialecto Postgres usa `pg` por import dinámico.
+El dialecto Postgres usa `pg` por import dinámico. Si vas a usar Dynamo con Postgres:
 
 ```bash
 npm install pg
@@ -41,139 +71,376 @@ npm install pg
 
 ---
 
-## ⚡ Quickstart
+## 🧰 Crear un proyecto (CLI)
+
+Nicola incluye un CLI con dos comandos:
+
+- `init <nombre>`: crea una estructura mínima.
+- `start`: ejecuta `app.js` con hot reload (LiveCurrent).
 
-### Servidor HTTP básico
+### Opción A: sin instalar global (recomendado)
+
+```bash
+npx nicola init mi-api
+cd mi-api
+npm install
+npm start
+```
+
+### Opción B: instalando global
+
+```bash
+npm install -g nicola-framework
+nicola init mi-api
+cd mi-api
+npm install
+nicola start
+```
+
+### Qué genera `nicola init`
+
+La CLI crea:
+
+- `app.js`
+- `src/controllers/user.controller.js`
+- `src/routes/user.Routes.js`
+- `package.json` con `"type": "module"` y script `start`.
+
+El `app.js` generado monta las rutas así:
 
 ```js
-import Nicola from 'nicola-framework';
+import Nicola, { Regulator } from "nicola-framework";
+import UserRoute from "./src/routes/user.Routes.js";
+
+Regulator.load();
 
 const app = new Nicola();
 
-app.get('/', (req, res) => {
-  res.json({ ok: true, message: 'Hello from Nicola!' });
+app.use("/user", UserRoute);
+
+app.get("/", (req, res) => {
+  res.json({ message: "Bienvenido a tu proyecto en Nicola" });
 });
 
 app.listen(3000, () => {
-  console.log('Server running on http://localhost:3000');
+  console.log("Servidor corriendo en http://localhost:3000");
 });
 ```
 
-### Router anidado y params
+---
+
+## 🚀 Levantar el servidor (dev)
+
+Si tu entrypoint es `app.js` (como genera la CLI), tienes dos opciones:
+
+- `npm start` (en proyecto generado)
+- `nicola start` / `npx nicola start`
+
+`start` usa LiveCurrent, que:
+
+- observa cambios en el directorio actual (recursivo)
+- ignora `node_modules`
+- reinicia el proceso cuando detecta un cambio
+
+---
+
+## ⚡ Quickstart (manual)
+
+Servidor HTTP básico:
 
 ```js
-import { Nicola, Remote } from 'nicola-framework';
+import Nicola from "nicola-framework";
 
 const app = new Nicola();
-const api = new Remote();
 
-api.get('/users', (req, res) => {
-  res.json({ users: ['Alice', 'Bob'] });
+app.get("/", (req, res) => {
+  res.json({ ok: true, message: "Hello from Nicola!" });
 });
 
-api.get('/users/:id', (req, res) => {
-  res.json({ userId: req.params.id });
+app.listen(3000, () => {
+  console.log("Server running on http://localhost:3000");
 });
+```
 
-app.use('/api', api);
-app.listen(3000);
+Opcional: timeouts del server (en ms). Nicola lee estas variables al llamar `listen()`:
+
+```env
+NICOLA_REQUEST_TIMEOUT=30000
+NICOLA_HEADERS_TIMEOUT=10000
+NICOLA_KEEP_ALIVE_TIMEOUT=65000
 ```
 
 ---
 
-## 🧠 API (resumen fiel al código)
+## 🧭 Guía del Router
+
+### 1) Rutas básicas
+
+`Nicola` y `Remote` soportan:
 
-### `Nicola` (Core)
+- `get`, `post`, `put`, `patch`, `delete`
 
-- `new Nicola()`
-- `app.get/post/put/patch/delete(path, ...handlers)`
-- `app.use([path], ...handlers | router)`
-- `app.listen(port, [callback])`
+```js
+import Nicola from "nicola-framework";
+
+const app = new Nicola();
 
-Notas:
-- `Nicola.listen()` ejecuta internamente `Shadowgraph`, `EasyCors` y `Teleforce` en cada request.
-- `req.query` se construye desde querystring.
+app.get("/ping", (req, res) => {
+  res.statusCode = 200;
+  res.end("pong");
+});
 
-### `Remote` (Router)
+app.listen(3000);
+```
 
-`Remote` es el router base. Soporta middlewares y rutas con params (`/users/:id`).
+### 2) Params (`/users/:id`)
 
-Ejemplo de middleware simple:
+Cuando la ruta tiene `:param`, Nicola crea:
+
+- `req.params` (objeto con strings)
+
+```js
+app.get("/users/:id", (req, res) => {
+  res.json({ id: req.params.id });
+});
+```
+
+### 3) Routers anidados (`use`)
+
+Puedes montar un router dentro de otro:
+
+```js
+import { Nicola, Remote } from "nicola-framework";
+
+const app = new Nicola();
+const api = new Remote();
+
+api.get("/ping", (req, res) => {
+  res.end("pong");
+});
+
+app.use("/api", api);
+app.listen(3000);
+```
+
+Importante: el mount path es estricto. `/api` hace match con `/api/...` pero NO con `/apix/...`.
+
+### 4) Middlewares
+
+Un middleware tiene firma `(req, res, next)`:
 
 ```js
 app.use((req, res, next) => {
-  // No existe res.status(); usa statusCode
-  if (req.url === '/blocked') {
+  // no existe res.status(); usa res.statusCode
+  if (req.url === "/blocked") {
     res.statusCode = 403;
-    res.end('Forbidden');
+    res.end("Forbidden");
     return;
   }
   next();
 });
 ```
 
-Errores:
+Nicola soporta handlers sync y async (Promise). Si un handler async rechaza, el error se propaga a `next(err)`.
+
+---
+
+## 🧾 Request/Response (lo que hay)
+
+### Request (`req`)
+
+Nicola trabaja sobre `http.IncomingMessage` y añade:
+
+- `req.url`: **solo pathname** (sin querystring). Se reescribe internamente.
+- `req.query`: objeto creado desde `?a=1&b=hola`.
+- `req.params`: solo existe en rutas con `:param`.
+- `req.body`: solo se parsea si `Content-Type` incluye `application/json`.
+  - inválido => `400 Bad Request: Invalid JSON`
+  - > ~2MB => `413 Request Entity Too Large`
+  - si no es JSON => `{}`
+
+### Response (`res`)
+
+Nicola trabaja sobre `http.ServerResponse` y añade helpers:
+
+- `res.json(data)` → setea `Content-Type: application/json` y serializa.
+- `res.send(text)` → setea `Content-Type: text/plain`.
+
+Para status codes, usa:
+
+```js
+res.statusCode = 201;
+res.json({ created: true });
+```
+
+---
+
+## 💥 Manejo de errores
+
+Si ocurre un error en la cadena de handlers:
+
+- `throw new Error(...)`
+- o `next(err)`
+
+Nicola responde con `BlackBox` (HTML):
+
+- en `NODE_ENV=production` el cliente ve `Internal Server Error` sin stack
+- en dev, incluye `err.message` y stack
+
+Ejemplo:
 
 ```js
-app.get('/boom', (req, res) => {
-  throw new Error('Boom');
+app.get("/boom", (req, res) => {
+  throw new Error("Boom");
 });
 ```
 
 ---
 
-## 🔐 Seguridad
+## 🧩 Middlewares
 
-### `Regulator` (.env)
+### `Insulator(schema)` (validación de body)
 
-Lee `.env` desde el directorio actual (`process.cwd()`) y lo copia a `process.env`.
+Valida que existan campos y que su tipo coincida con `typeof`.
 
 ```js
-import { Regulator } from 'nicola-framework';
+import { Insulator } from "nicola-framework";
 
-Regulator.load();
+const schema = {
+  name: "string",
+  age: "number",
+};
+
+app.post("/users", Insulator(schema), (req, res) => {
+  res.json({ ok: true });
+});
+```
+
+Respuestas típicas:
+
+- falta campo → `400` y mensaje `Falta campo: name`
+- tipo incorrecto → `400` y mensaje `El campo age debe ser number`
+
+### `EasyCors(options)`
+
+Soporta:
+
+- `origin: "*"` (default)
+- `origin: ["https://app.com", "http://localhost:5173"]`
+
+```js
+import { EasyCors } from "nicola-framework";
+
+app.use(EasyCors({ origin: ["https://mi-front.com"] }));
+```
+
+Nota importante sobre `Nicola.listen()`: internamente siempre ejecuta `EasyCors()` **antes** de tu router.
+
+- puedes sobreescribir headers CORS en tus handlers para requests normales
+- pero el preflight `OPTIONS` se resuelve ahí mismo (204), antes de que corran tus rutas
+
+### `Teleforce`
+
+Agrega headers de seguridad básicos:
+
+- `X-Content-Type-Options: nosniff`
+- `X-Frame-Options: Deny`
+- `X-XSS-Protection: 1`
+
+### `Shadowgraph`
+
+Logger simple al finalizar la respuesta:
+
+`[GET] /ruta - 200 OK - 12ms`
+
+---
+
+## 🔐 Seguridad (Regulator + JWT)
+
+### `Regulator.load()` (.env)
+
+Lee `.env` desde `process.cwd()` y copia valores a `process.env`.
+
+Formato soportado:
+
+- `KEY=value`
+- líneas vacías OK
+- comentarios con `#` al inicio
+
+Ejemplo:
+
+```env
+NICOLA_SECRET=mi-secreto-super-seguro
+NODE_ENV=production
 ```
 
 ### `Coherer` (JWT HS256)
 
-`Coherer` es una clase con métodos **estáticos**.
+`Coherer` es una clase con métodos estáticos:
+
+- `Coherer.sign(payload, { expiresIn })`
+- `Coherer.verify(token)`
+
+`expiresIn` soporta formato **número + unidad**:
+
+- `10s`, `15m`, `24h`, `7d`, `1y`
+
+Ejemplo:
 
 ```js
-import { Regulator, Coherer } from 'nicola-framework';
+import { Regulator, Coherer } from "nicola-framework";
 
 Regulator.load();
 
 const token = Coherer.sign(
-  { userId: 123, role: 'admin' },
-  { expiresIn: '24h' }
+  { userId: 123, role: "admin" },
+  { expiresIn: "24h" }
 );
 
 const payload = Coherer.verify(token);
 console.log(payload.userId);
 ```
 
-`.env` mínimo:
+Middleware típico para proteger rutas (Bearer token):
 
-```env
-NICOLA_SECRET=mi-secreto-super-seguro
+```js
+import { Coherer } from "nicola-framework";
+
+const auth = (req, res, next) => {
+  const authHeader = req.headers.authorization || "";
+  const [, token] = authHeader.split(" ");
+  try {
+    req.user = Coherer.verify(token);
+    next();
+  } catch (err) {
+    res.statusCode = 401;
+    res.end("Unauthorized");
+  }
+};
 ```
 
 ---
 
-## 🗃️ Dynamo (ORM)
+## 🗃️ Dynamo ORM (Postgres)
 
-### Configuración
+### Conexión
 
-`Dynamo.connect()` **no recibe config**: toma la configuración desde variables de entorno.
+`Dynamo.connect()` no recibe config: lee variables de entorno.
 
 ```js
-import { Regulator, Dynamo } from 'nicola-framework';
+import { Regulator, Dynamo } from "nicola-framework";
 
 Regulator.load();
 await Dynamo.connect();
+
+// ... usar modelos/queries ...
+
+await Dynamo.disconnect();
 ```
 
-`.env` para Postgres:
+### Variables soportadas
+
+Mínimo:
 
 ```env
 DB_DRIVER=postgres
@@ -184,80 +451,110 @@ DB_PASS=postgres
 DB_NAME=mydb
 ```
 
+Alternativa: `DB_URL` (tiene prioridad sobre las variables separadas):
+
+```env
+DB_DRIVER=postgres
+DB_URL=postgres://user:pass@localhost:5432/mydb
+```
+
+SSL opcional via `DB_SSLMODE`:
+
+- `require` → SSL sin verificación estricta
+- `verify-ca` / `verify-full` → SSL con verificación
+- `disable` / `prefer` → sin SSL
+
 ### Modelos
 
+Un modelo es una clase que extiende `Dynamo.Model` y define:
+
+- `static tableName` (requerido)
+- `static schema` (opcional, para validar en `create`)
+
 ```js
-import { Dynamo } from 'nicola-framework';
+import { Dynamo } from "nicola-framework";
 
 export default class User extends Dynamo.Model {
-  static tableName = 'users';
+  static tableName = "users";
 
   static schema = {
-    name: { type: 'string', required: true },
-    email: { type: 'string', required: true },
-    age: { type: 'number', required: false }
+    name: { type: "string", required: true },
+    email: { type: "string", required: true },
+    age: { type: "number", required: false },
   };
 }
 ```
 
-### Queries
+### Operaciones comunes
 
 ```js
-// All
+// Obtener todo
 const users = await User.all();
 
-// Where
-const active = await User.where('active', true).get();
+// Where (si omites operador, asume '=')
+const active = await User.where("active", true).get();
 
-// Insert (valida contra schema)
-const created = await User.create({ name: 'Alice', email: 'a@a.com', age: 20 });
+// Select (string con comas o array)
+const names = await User.select("name,email").get();
 
-// Update / Delete
-await User.where('id', 1).update({ name: 'Alice 2' });
-await User.where('id', 1).delete();
+// Insert (valida con schema)
+const created = await User.create({ name: "Alice", email: "a@a.com", age: 20 });
 
-// Select específico (usa string con coma)
-const names = await User.select('name,email').get();
+// Update / Delete (recomendado: siempre con where)
+await User.where("id", 1).update({ name: "Alice 2" });
+await User.where("id", 1).delete();
 
-// Order/limit/offset vía QueryBuilder
-const latest = await User.query().orderBy('id', 'DESC').limit(10).offset(0).get();
+// Order + limit + offset
+const latest = await User.query().orderBy("id", "DESC").limit(10).offset(0).get();
 ```
 
+Notas importantes:
+
+- `update()` y `delete()` devuelven `count` (rowCount).
+- Evita `User.update({...})` o `User.delete()` sin `where(...)` porque operaría sobre toda la tabla.
+
 ---
 
-## 🧩 Middlewares
+## 🌱 Variables de entorno
 
-### `Insulator(schema)`
+Nicola lee:
 
-Valida `req.body` con un esquema **simple** de tipos (`typeof`).
+- `NODE_ENV` (`production` activa modo seguro en errores)
+- `NICOLA_SECRET` (JWT)
+- `NICOLA_REQUEST_TIMEOUT`, `NICOLA_HEADERS_TIMEOUT`, `NICOLA_KEEP_ALIVE_TIMEOUT`
+- `DB_DRIVER`, `DB_URL` o `DB_HOST/DB_PORT/DB_USER/DB_PASS/DB_NAME`, `DB_SSLMODE`
 
-```js
-import { Insulator } from 'nicola-framework';
+---
 
-const schema = {
-  name: 'string',
-  age: 'number'
-};
+## 🧪 Tests
 
-app.post('/users', Insulator(schema), (req, res) => {
-  res.json({ ok: true });
-});
+Este repo incluye tests con Jest + Supertest.
+
+```bash
+npm test
 ```
 
-### `Shadowgraph`, `Teleforce`, `EasyCors`
+---
 
-Se ejecutan automáticamente dentro de `Nicola.listen()`. También puedes llamarlos manualmente si estás usando `Remote` por separado.
+## 🧯 Troubleshooting
 
----
+### 1) "Please configure, NICOLA_SECRET..."
 
-## 🔥 LiveCurrent (hot reload)
+- define `NICOLA_SECRET` en tu `.env` y corre `Regulator.load()` antes de usar `Coherer`.
 
-```js
-import { LiveCurrent } from 'nicola-framework';
+### 2) "Por favor utiliza el comando npm install pg"
 
-const dev = new LiveCurrent('app.js');
-dev.boot();
-```
+- instala `pg` si vas a usar `DB_DRIVER=postgres`.
+
+### 3) El body llega vacío
+
+- Nicola solo parsea JSON cuando `Content-Type` incluye `application/json`.
+- `multipart/form-data` y `application/x-www-form-urlencoded` no están soportados (por ahora).
+
+### 4) CORS en preflight no aplica como esperas
+
+- `Nicola.listen()` ejecuta `EasyCors()` y responde `OPTIONS` con `204` antes de tus rutas.
+- si necesitas lógica avanzada de preflight, usa `Remote` + `http.createServer(...)` y monta tus middlewares manualmente.
 
 ---
 

package/bin/init.js

@@ -0,0 +1,68 @@
+import fs from "fs/promises"
+import { cyan, green, magent } from "../utils/console.js";
+import path from "path";
+import { app } from "./schemas/app.schema.js";
+import { route } from "./schemas/route.schema.js";
+import { controller } from "./schemas/controller.schema.js";
+
+
+export  async function runInit(projectName){
+    if (!projectName || typeof projectName !== 'string' || projectName.trim().length === 0) {
+        console.log(magent('Uso: nicola init <nombre-del-proyecto>'))
+        return;
+    }
+
+    const normalizedName = projectName.trim();
+    const rootPath = path.join(process.cwd(), normalizedName)
+    const srcPath = path.join(rootPath, 'src')
+    const packageJSON = {
+        name: normalizedName,
+        version: "1.0.0",
+        type: "module",
+        main: "app.js",
+        dependencies: {
+            "nicola-framework" : "latest"
+        },
+        scripts:{
+            "start": "nicola start"
+        } 
+        }
+    try{
+        // Fail fast if the directory already exists
+        await fs.access(rootPath)
+        throw new Error(`El directorio '${normalizedName}' ya existe.`)
+    } catch (err) {
+        // access failed => directory does not exist yet, continue
+        if (!(err && (err.code === 'ENOENT'))) {
+            throw err;
+        }
+    }
+
+    try{
+        await fs.mkdir(rootPath, {recursive: true});
+        console.log(magent('✓ Carpeta raiz creada con exito.'))
+        await fs.mkdir(srcPath, {recursive:true})
+        console.log(magent('✓ Carpeta src creada con exito.'))
+        await fs.writeFile(path.join(rootPath, 'package.json'), JSON.stringify(packageJSON, null, 2))
+        console.log(magent("✓ Archivo package.json creado con exito."))
+        await fs.mkdir(path.join(srcPath, "controllers"), { recursive: true })
+        console.log(magent('✓ Carpeta controllers creada con exito.'))
+        await fs.writeFile(path.join(srcPath, "controllers", "user.controller.js"), controller)
+        console.log(cyan('✓ Controlador creado con exito.'))
+        await fs.mkdir(path.join(srcPath, "routes"), { recursive: true })
+        console.log(magent('✓ Carpeta routes creada con exito.'))
+        await fs.writeFile(path.join(srcPath, "routes", "user.Routes.js"), route)
+        console.log(cyan('✓ Rutas creadas con exito.'))
+        await fs.writeFile(path.join(rootPath, "app.js"), app)
+        console.log(green('✓ Archivo principal app.js creado con exito.'))
+        console.log(green(`\nProyecto ${normalizedName} inicializado con exito!`))
+        console.log(green(`\nPara iniciar tu proyecto, ejecuta los siguientes comandos:\n`))
+        console.log(cyan(`cd ${normalizedName}`))
+        console.log(cyan(`npm install`))
+        console.log(cyan(`nicola start\n`))
+    }
+    catch(err){
+        console.error(err)
+        throw err;
+    }
+}

package/bin/nicola.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { yellow } from "../utils/console.js";
+import { runInit } from "./init.js"
+import { runStart } from "./start.js";
+
+const verb = process.argv[2]
+
+try {
+    switch (verb) {
+        case "init": {
+            const projectName = process.argv[3]
+            await runInit(projectName);
+            break;
+        }
+        case "start": {
+            runStart();
+            break;
+        }
+        default: {
+            console.log(yellow("Comando no reconocido. Prueba: nicola init <nombre> o nicola start"))
+            process.exitCode = 1;
+        }
+    }
+} catch (err) {
+    console.error(err);
+    process.exitCode = 1;
+}

package/bin/schemas/app.schema.js

@@ -0,0 +1,20 @@
+export const app = `
+import Nicola, { Regulator } from "nicola-framework"
+import UserRoute from "./src/routes/user.Routes.js"
+
+Regulator.load()
+
+const app =  new Nicola()
+
+app.use('/user', UserRoute);
+
+app.get('/', (req, res)=>{
+res.json({
+    message: 'Bienvenido a tu proyecto en Nicola'
+})
+})
+
+app.listen(3000, () =>{
+    console.log('Servidor corriendo en http://localhost:3000')
+})
+`

package/bin/schemas/controller.schema.js

@@ -0,0 +1,35 @@
+export const controller =`
+
+let users = [
+    {
+        "id":1,
+        "nombre": 'Erick Tiznado'
+    },
+    {
+        "id":2,
+        "nombre": 'Jane Doe'
+    }
+];
+
+const getAllUsers = (req, res) =>{
+    res.json(users)
+}
+
+const addNewUser = (req, res) => {
+    const {user} = req.body;
+
+    users.push(user);
+
+    res.json({
+        message: "Usuario registrado con exito",
+        status: true
+    })
+}
+
+
+
+export {
+    getAllUsers,
+    addNewUser
+}
+    `

package/bin/schemas/route.schema.js

@@ -0,0 +1,12 @@
+export const route = `
+
+import {getAllUsers, addNewUser} from "../controllers/user.controller.js"
+import { Remote } from "nicola-framework"
+
+const RemoteRouter = new Remote()
+
+RemoteRouter.get('/', getAllUsers);
+RemoteRouter.post('/add-user', addNewUser);
+
+export default RemoteRouter;
+`

package/bin/start.js

@@ -0,0 +1,8 @@
+import LiveCurrent from "../dev-tools/LiveCurrent.js"
+export const runStart = () =>{
+    const live =  new LiveCurrent("app.js");
+
+    live.boot()
+}
+
+

package/core/Core.js

@@ -11,7 +11,7 @@ class Core extends Remote {
 
   listen(port, callback) {
     const server = http.createServer((req, res) => {
-      const myURL = new URL(req.url, "http://" + req.headers.host);
+      const myURL = new URL(req.url, "http://" + (req.headers.host ?? 'localhost'));
       const pathURL = myURL.pathname;
       const urlParams = Object.fromEntries(myURL.searchParams);
 
@@ -33,19 +33,22 @@ class Core extends Remote {
             if (req.headers["content-type"]?.includes("application/json")) {
               let dataString = [];
               let chunklenght = 0;
+              let tooLarge = false;
               req.on("data", (chunk) => {
                 dataString.push(chunk);
                 chunklenght = chunklenght + chunk.length;
 
                 if (chunklenght > 2e6) {
-                  req.pause();
+                  tooLarge = true;
                   res.statusCode = 413;
                   res.end("Request Entity Too Large");
+                  req.destroy();
                   return;
                 }
               });
 
               req.on("end", () => {
+                if (tooLarge) return;
                 try {
                   if (dataString.length > 0) {
                     const buffer = Buffer.concat(dataString).toString();
@@ -69,6 +72,22 @@ class Core extends Remote {
         });
       });
     });
+
+    const requestTimeout = Number(process.env.NICOLA_REQUEST_TIMEOUT)
+    if (!Number.isNaN(requestTimeout) && requestTimeout > 0) {
+      server.requestTimeout = requestTimeout
+    }
+
+    const headersTimeout = Number(process.env.NICOLA_HEADERS_TIMEOUT)
+    if (!Number.isNaN(headersTimeout) && headersTimeout > 0) {
+      server.headersTimeout = headersTimeout
+    }
+
+    const keepAliveTimeout = Number(process.env.NICOLA_KEEP_ALIVE_TIMEOUT)
+    if (!Number.isNaN(keepAliveTimeout) && keepAliveTimeout > 0) {
+      server.keepAliveTimeout = keepAliveTimeout
+    }
+
     server.listen(port, callback);
     return server;
   }

package/core/Remote.js

@@ -91,6 +91,14 @@ class Remote {
     handle(req, res, done) {
         let index = 0
         let match = false
+
+        const matchesMountPath = (url, mountPath) => {
+            if (mountPath === '/') return true;
+            if (!url.startsWith(mountPath)) return false;
+            const nextChar = url.charAt(mountPath.length);
+            return nextChar === '' || nextChar === '/';
+        }
+
         const next = (err) => {
             if (err) {
                 return done(err)
@@ -102,7 +110,7 @@ class Remote {
                 if (!route) {
                     return done()
                 }
-                const middleware = route.method === 'USE' && req.url.startsWith(route.path);
+                const middleware = route.method === 'USE' && matchesMountPath(req.url, route.path);
                 const rutaCoincidence = route.path === req.url && route.method === req.method;
                 match = route.regex && route.regex.test(req.url) && route.method === req.method;
                 if(match){

package/database/Connection.js

@@ -5,7 +5,10 @@ class Connection {
 
 
     static async connect() {
-        const DB_DRIVER =  process.env.DB_DRIVER
+        const DB_DRIVER = process.env.DB_DRIVER
+        if (!DB_DRIVER) {
+            throw new Error('Missing DB_DRIVER environment variable')
+        }
         let config = {}
         if(process.env.DB_URL){
             const url = new URL(process.env.DB_URL);
@@ -14,7 +17,7 @@ class Connection {
                 user: url.username,
                 password: decodeURIComponent(url.password),
                 host: url.hostname,
-                port: url.port,
+                port: url.port ? Number(url.port) : undefined,
                 database: url.pathname.slice(1)
             }
         }
@@ -23,7 +26,7 @@ class Connection {
                 user: process.env.DB_USER,
                 password: process.env.DB_PASS,
                 host: process.env.DB_HOST,
-                port: process.env.DB_PORT,
+                port: process.env.DB_PORT ? Number(process.env.DB_PORT) : undefined,
                 database: process.env.DB_NAME
             }
         }
@@ -43,6 +46,14 @@ class Connection {
         if(!this.client) throw new Error("No hay conexion activa")
         return this.client.query(sql, params);
     }
+
+    static async disconnect() {
+        if (!this.client) return
+        if (typeof this.client.disconnect === 'function') {
+            await this.client.disconnect()
+        }
+        this.client = null
+    }
 }
 
 

package/database/dialects/Postgres.js

@@ -53,16 +53,23 @@ class Postgres extends Driver {
         if (!this.client) {
             throw new Error("Database not connected")
         }
-        try{
-        const result = await this.client.query(sql, params);
-        return {
-            rows: result.rows,
-            count: result.rowCount
+        try {
+            const result = await this.client.query(sql, params);
+            return {
+                rows: result.rows,
+                count: result.rowCount
+            }
+        } catch (err) {
+            const code = (err && err.code) ? `:${err.code}` : ''
+            const message = (err && err.message) ? err.message : String(err)
+            throw new Error(`Database Query Failed${code}: ${message}`)
         }
     }
-    catch(err){
-        throw new Error(`Database Query Failed:${err.code}: ${err.message}`)
-    }
+
+    async disconnect() {
+        if (!this.client) return
+        await this.client.end()
+        this.client = null
     }
 
     compileSelect(builder) {

package/database/index.js

@@ -7,6 +7,10 @@ class Dynamo{
         return Connection.connect()
     }
 
+    static async disconnect(){
+        return Connection.disconnect()
+    }
+
     static async query(sql, params){
         return Connection.query(sql, params)
     }

package/dev-tools/LiveCurrent.js

@@ -1,4 +1,4 @@
-import fs from 'fs/promises'
+import fs from 'fs'
 import { spawn } from 'child_process'
 import { green } from '../utils/console.js';
 class LiveCurrent{
@@ -25,7 +25,10 @@ class LiveCurrent{
 
     watch(){
         fs.watch(process.cwd(), {recursive: true}, (eventType, filename) => {
-            if(filename.includes('node_modules') || filename === ''){
+            if (!filename) {
+                return
+            }
+            if(filename.includes('node_modules')){
                 return
             }
             this.reload()

package/middlewares/BlackBox.js

@@ -1,15 +1,21 @@
 import { error } from '../templates/error.js'
-class BlackBox{
-    constructor(){
 
-    }
+class BlackBox {
+    constructor() {}
+
+    static ignite(err, req, res) {
+        const isProd = process.env.NODE_ENV === 'production'
+
+        if (isProd) {
+            console.error(err)
+        }
 
-    static ignite(err, req , res){
-        
-        res.writeHead(500, {'Content-Type': 'text/html'})
-        res.end(error(err.message, err.stack))
+        const message = isProd ? 'Internal Server Error' : (err?.message || 'Error')
+        const stack = isProd ? null : (err?.stack || null)
+
+        res.writeHead(500, { 'Content-Type': 'text/html' })
+        res.end(error(message, stack))
     }
 }
 
-
 export default BlackBox;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nicola-framework",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Web framework for Node.js",
   "type": "module",
   "main": "index.js",
@@ -24,6 +24,10 @@
     "middleware",
     "orm"
   ],
+  "bin": {
+    "nicola": "./bin/nicola.js",
+    "nicola-framework": "./bin/nicola.js"
+  },
   "author": "Erick Mauricio Tiznado Rodriguez",
   "license": "MIT",
   "devDependencies": {

package/security/Coherer.js

@@ -1,10 +1,17 @@
 import crypto from "crypto";
-import Regulator from "./Regulator.js";
 import { getExpTime } from "../utils/expTime.js";
 
 class Coherer {
   constructor() {}
 
+  static _getSecret() {
+    const secret = process.env.NICOLA_SECRET
+    if (!secret) {
+      throw new Error("Please configure, NICOLA_SECRET in the .env file")
+    }
+    return secret
+  }
+
   static codec(jsonData) {
     const dataString = JSON.stringify(jsonData);
     const buffer = Buffer.from(dataString);
@@ -12,13 +19,11 @@ class Coherer {
   }
 
   static sign(Payload, options) {
-    const SECRET = process.env.NICOLA_SECRET
-    if (!SECRET)
-      throw new Error("Please configure, NICOLA_SECRET in the .env file");
+    const SECRET = this._getSecret()
 
     let payloadB64 = "";
 
-    if ("expiresIn" in options) {
+    if (options && "expiresIn" in options) {
       const time = getExpTime(options.expiresIn);
       const newPayload = { ...Payload, exp: time };
       payloadB64 = this.codec(newPayload);
@@ -43,10 +48,30 @@ class Coherer {
   }
 
   static verify(token) {
-    const SECRET = process.env.NICOLA_SECRET
-        if (!SECRET)
-      throw new Error("Please configure, NICOLA_SECRET in the .env file");
-    const [headerB64, payloadB64, signature] = token.split(".");
+    const SECRET = this._getSecret()
+
+    if (typeof token !== "string") {
+      throw new Error("Token Invalido")
+    }
+
+    const parts = token.split(".")
+    if (parts.length !== 3) {
+      throw new Error("Token Invalido")
+    }
+
+    const [headerB64, payloadB64, signature] = parts;
+
+    let decodedHeader;
+    try {
+      decodedHeader = Buffer.from(headerB64, "base64url").toString("utf-8")
+      decodedHeader = JSON.parse(decodedHeader)
+    } catch {
+      throw new Error("Token Invalido")
+    }
+
+    if (decodedHeader?.alg !== "HS256" || decodedHeader?.typ !== "JWT") {
+      throw new Error("Token Invalido")
+    }
 
     const dataToCheck = headerB64 + "." + payloadB64;
 
@@ -55,23 +80,28 @@ class Coherer {
       .update(dataToCheck)
       .digest("base64url");
 
-    if (signature === signatureToChecks) {
-      let decodedPayload = Buffer.from(payloadB64, "base64url").toString(
-        "utf-8"
-      );
+    const sigA = Buffer.from(signature)
+    const sigB = Buffer.from(signatureToChecks)
+    if (sigA.length !== sigB.length || !crypto.timingSafeEqual(sigA, sigB)) {
+      throw new Error("Token Invalido")
+    }
 
-      decodedPayload = JSON.parse(decodedPayload);
-      if ("exp" in decodedPayload) {
-        const datenow = Date.now() / 1000;
+    let decodedPayload;
+    try {
+      decodedPayload = Buffer.from(payloadB64, "base64url").toString("utf-8")
+      decodedPayload = JSON.parse(decodedPayload)
+    } catch {
+      throw new Error("Token Invalido")
+    }
 
-        if (datenow > decodedPayload.exp) {
-          throw new Error("Token Expired");
-        }
+    if ("exp" in decodedPayload) {
+      const datenow = Date.now() / 1000;
+      if (datenow > decodedPayload.exp) {
+        throw new Error("Token Expired")
       }
-      return decodedPayload;
-    } else {
-      throw new Error("Token Invalido");
     }
+
+    return decodedPayload;
   }
 }
 

package/templates/error.js

@@ -1,6 +1,15 @@
-
+const escapeHtml = (value) => {
+    return String(value ?? '')
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;')
+}
 
 export const error = (message, stack) =>{
+    const safeMessage = escapeHtml(message)
+    const safeStack = stack ? escapeHtml(stack) : null
 
    return `
 <html>
@@ -26,10 +35,9 @@ export const error = (message, stack) =>{
     <body>
         <div class = "error-box">
             <h1> Reporte de Error </h1>
-            <h2>${message}</h2>
+            <h2>${safeMessage}</h2>
         </div>
-            <h3> Reporte de Error </h3>
-            <pre>${stack}</pre>        
+            ${safeStack ? `<h3> Reporte de Error </h3><pre>${safeStack}</pre>` : ''}
     </body>
 </html>
 `

package/test/Router.test.js

@@ -10,6 +10,13 @@ describe('🚦 Router System (Remote.js)', () => {
     beforeAll(() => {
         router = new Remote();
 
+        const api = new Remote();
+        api.get('/ping', (req, res) => {
+            res.statusCode = 200;
+            res.end('pong');
+        });
+        router.use('/api', api);
+
         // 1. Ruta Básica
         router.get('/', (req, res) => {
             res.statusCode = 200;
@@ -61,6 +68,15 @@ describe('🚦 Router System (Remote.js)', () => {
             expect(response.statusCode).toBe(200);
             expect(response.body).toEqual({ id: '555' });
         });
+
+        test('Router montado: /api no debe hacer match con /apix', async () => {
+            const ok = await request(server).get('/api/ping');
+            expect(ok.statusCode).toBe(200);
+            expect(ok.text).toBe('pong');
+
+            const no = await request(server).get('/apix/ping');
+            expect(no.statusCode).toBe(404);
+        });
     });
 
     describe('🛡️ Blindaje de Errores (P0 Fix)', () => {

package/dev-tools/DevRunner.js

@@ -1,6 +0,0 @@
-
-import LiveCurrent from "./LiveCurrent.js";
-
-const Live =  new LiveCurrent('app.js')
-
-Live.boot()