ranuts/node — mini framework HTTP

Un pequeño juego de herramientas HTTP para Node.js, sin dependencias: un servidor HTTP, un enrutador, un servidor WebSocket, middleware de cuerpo y de archivos estáticos, y un puñado de ayudas para la terminal y el sistema de archivos.

⚠️ Solo Node. Este punto de entrada carga node:http, node:fs, node:child_process y compañía. Impórtalo desde ranuts/node, nunca desde código de navegador.

Importar

import { Server, Router, staticMiddleware, body } from 'ranuts/node';

El middleware que interpreta el cuerpo se exporta como body (su nombre interno es bodyMiddleware). No existe ninguna exportación llamada bodyMiddleware.

Primeros pasos

import { Server, Router, staticMiddleware, body } from 'ranuts/node';

const app = new Server();
const router = new Router();

// Las rutas se emparejan por ruta exacta. El manejador recibe el Context de la petición.
router.get('/hello', (ctx) => {
  ctx.res.setHeader('Content-Type', 'application/json');
  ctx.res.end(JSON.stringify({ message: 'hello world' }));
});

// POST con cuerpo JSON: body() lo interpreta y lo deja en ctx.request.body
router.post('/echo', (ctx) => {
  ctx.res.end(JSON.stringify({ youSent: ctx.request.body }));
});

// body() interpreta el cuerpo de la petición Y rellena ctx.request (method / path / url / query),
// que es lo que lee el enrutador, así que regístralo ANTES de router.routes().
app.use(body());
app.use(router.routes());
app.use(router.allowedMethods());

// Sirve archivos estáticos (para `/` recurre a ./public/index.html)
app.use(staticMiddleware({ pathname: './public' }));

const server = app.listen(3000, () => {
  console.log('Server running at http://localhost:3000');
});
// `server` es la instancia de Server de node:http que hay debajo.

El orden del middleware importa: el Router lee ctx.request.path y ctx.request.method, y quien los rellena es body(). Registra body() primero. El body() que viene incluido interpreta hoy por hoy cuerpos application/json y multipart/form-data.

API

Server

Exportación por defecto. Un servidor mínimo al estilo de Koa, montado sobre node:http.

Firma del middleware

type Next = () => Promise<void> | Promise<never>;
type MiddlewareFunction = (ctx: Context, next: Next) => void | Promise<void>;

Llama a next() para pasar el control al siguiente middleware. Los middleware se despachan en el orden en que se registraron; llamar a next() dos veces lanza un error.

Forma del Context

Router

Exportación por defecto. Registra manejadores por método HTTP y ruta exacta, y luego los ofrece como middleware mediante routes().

Firma del manejador

type Handler = (ctx: Context, next: Next) => void;

Lee los datos de la petición en ctx.request (method, path, url, query, body) y responde a través de ctx.res. Las rutas se emparejan de forma exacta: no hay segmentos :param; para los parámetros de consulta usa ctx.request.query.

Middleware

Opciones de body(options)

Opciones de staticMiddleware(option)

WebSocket

import { Server, WSS } from 'ranuts/node';

const app = new Server();
const server = app.listen(3000);
const wss = new WSS(server);

wss.on('connect', (client) => {
  client.on('message', (data) => client.send('echo: ' + data));
});
// wss.broadcast(data) envía a todos los clientes conectados; wss.clients es la lista.

Cada client ofrece send(data, options?), ping(), pong(), close() y socket, además de los eventos message, close y error.

Utilidades

Véase también

Ese mismo punto de entrada ranuts/node trae además ayudas para el sistema de archivos, documentadas aparte:

• writeFile
• readFile
• appendFile
• readDir
• watchFile
• queryFileInfo