🚀 servidor-manager

Librería ligera para la gestión, configuración y despliegue automatizado de servidores HTTP en Node.js.

Diseñada para simplificar la creación de APIs RESTful, manejar rutas, middlewares, CORS, servir archivos estáticos, parseo de cuerpos de peticiones y renderizado de vistas, todo con una API inspirada en Express pero optimizada para entornos de automatización y despliegue continuo.

📦 Instalación

npm install servidor-manager

Nota: Requiere Node.js >= 16.0.0

⚡ Inicio rápido

const servidor = require('servidor-manager');
const app = servidor();

// Middleware globales
app.use(servidor.json());
app.use(servidor.urlencoded());
app.use(servidor.cors());

// Rutas
app.get('/api/saludo/:nombre?', (req, res) => {
  const nombre = req.params.nombre || 'Mundo';
  res.json({ mensaje: `¡Hola ${nombre}!` });
});

// Iniciar servidor
app.listen(3000, () => {
  console.log('Servidor corriendo en http://localhost:3000');
});

📖 Guía de uso

🧩 Métodos de la aplicación

const app = servidor();

// Configuración
app.set('env', 'production');
app.set('views', './views');
app.set('view engine', 'html');

// Obtener configuración
console.log(app.get('env')); // 'production'

// Habilitar/deshabilitar
app.enable('x-powered-by');
app.disable('etag');

// Montar sub-aplicaciones o routers
const admin = servidor.Router();
admin.get('/dashboard', (req, res) => res.json({ admin: true }));
app.use('/admin', admin);

🛣️ Sistema de rutas

// Rutas con parámetros dinámicos
app.get('/usuarios/:id', (req, res) => {
  res.json({ id: req.params.id });
});

// Parámetros opcionales
app.get('/buscar/:termino?', (req, res) => {
  res.json({ termino: req.params.termino || 'todos' });
});

// Múltiples métodos en una ruta
app.route('/api/items')
  .get((req, res) => res.json({ items: [] }))
  .post((req, res) => res.status(201).json({ creado: true }));

🎯 Middlewares integrados

// CORS con configuración avanzada
app.use(servidor.cors({
  origin: ['https://example.com', /\.trusted\.org$/],
  methods: ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
  credentials: true,
  maxAge: 86400
}));

// Parseo de cuerpos
app.use(servidor.json());        // application/json
app.use(servidor.urlencoded());  // application/x-www-form-urlencoded
app.use(servidor.text());        // text/plain
app.use(servidor.raw());         // Buffer crudo

// Archivos estáticos
app.use(servidor.static('public'));

📨 Request (req)

app.get('/api/demo', (req, res) => {
  req.query;       // Query string parseado (?q=busqueda&limite=10)
  req.params;      // Parámetros de ruta (:id)
  req.body;        // Cuerpo parseado (con middleware json/urlencoded)
  req.headers;     // Headers de la petición
  req.path;        // Ruta sin query string
  req.hostname;    // Hostname del cliente
  req.ip;          // IP del cliente
  req.xhr;         // ¿Es petición AJAX?
  req.protocol;    // 'http' o 'https'
  req.secure;      // ¿Conexión segura?
  
  // Negociación de contenido
  req.accepts(['json', 'html', 'xml']);
  req.is('json');  // Verifica Content-Type
  
  // Header específico
  req.get('User-Agent');
});

📤 Response (res)

app.get('/api/demo', (req, res) => {
  res.send('Texto plano');
  res.json({ clave: 'valor' });
  res.status(201).json({ creado: true });
  res.redirect('/otra-ruta');
  res.redirect(301, '/nueva-url');
  
  // Renderizar vistas
  res.render('vista', { titulo: 'Mi página' });
  
  // Cookies
  res.cookie('sesion', 'abc123', { httpOnly: true, maxAge: 3600000 });
  res.clearCookie('sesion');
  
  // Headers
  res.set('X-Custom-Header', 'valor');
  res.type('application/json');
  res.vary('Accept-Encoding');
  
  // Archivos
  res.sendFile('/ruta/al/archivo.pdf');
  res.download('/ruta/al/archivo.pdf', 'descarga.pdf');
  res.attachment('archivo.txt');
  
  // Negociación de contenido
  res.format({
    'text/html': () => res.render('pagina'),
    'application/json': () => res.json({ datos: true }),
    default: () => res.status(406).send('Not Acceptable')
  });
});

🔀 Router (sub-aplicaciones)

const api = servidor.Router();

// Middleware específico del router
api.use((req, res, next) => {
  console.log('API llamada:', req.method, req.url);
  next();
});

// Rutas del router
api.get('/usuarios', (req, res) => res.json([{ id: 1 }]));
api.post('/usuarios', (req, res) => res.status(201).json(req.body));

// Parámetros de router
api.param('id', (req, res, next, id) => {
  req.usuario = { id };
  next();
});

api.get('/usuarios/:id', (req, res) => res.json(req.usuario));

// Montar en la aplicación principal
app.use('/api/v1', api);

🌐 CORS detallado

// Bloqueo estricto de orígenes no permitidos
app.use(servidor.cors({
  origin: 'https://example.com',
  methods: ['GET', 'POST'],
  strictOrigin: true  // 403 para orígenes no permitidos
}));

// Múltiples orígenes con RegExp
app.use(servidor.cors({
  origin: [/\.example\.com$/, /localhost:\d+/]
}));

// Callback dinámico
app.use(servidor.cors({
  origin: (origin, callback) => {
    if (dominiosPermitidos.includes(origin)) {
      callback(null, true);
    } else {
      callback(new Error('No permitido'));
    }
  }
}));

🖼️ Motor de vistas

// Registrar motor personalizado
app.engine('ejs', require('ejs').renderFile);
app.engine('pug', require('pug').renderFile);
app.set('view engine', 'ejs');
app.set('views', './views');

// Usar en rutas
app.get('/', (req, res) => {
  res.render('index', { titulo: 'Inicio', usuario: req.user });
});

⚠️ Manejo de errores

// Middleware de error (4 parámetros)
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).json({
    error: 'Error interno del servidor',
    mensaje: process.env.NODE_ENV === 'development' ? err.message : undefined
  });
});

// Ruta 404 (debe ir al final)
app.use((req, res) => {
  res.status(404).json({ error: 'Ruta no encontrada' });
});

🚀 Ejemplo completo

const servidor = require('servidor-manager');
const app = servidor();

// Configuración
app.set('env', process.env.NODE_ENV || 'development');
app.enable('x-powered-by');

// Middleware globales
app.use(servidor.cors({
  origin: 'http://localhost:3000',
  methods: ['GET', 'POST', 'PUT', 'DELETE']
}));
app.use(servidor.json());
app.use(servidor.urlencoded());
app.use(servidor.static('public'));

// Logger simple
app.use((req, res, next) => {
  const inicio = Date.now();
  res.on('finish', () => {
    console.log(`${req.method} ${req.url} ${res.statusCode} ${Date.now() - inicio}ms`);
  });
  next();
});

// Rutas API
const api = servidor.Router();

api.get('/usuarios', (req, res) => {
  res.json([{ id: 1, nombre: 'Juan' }, { id: 2, nombre: 'María' }]);
});

api.get('/usuarios/:id', (req, res) => {
  res.json({ id: req.params.id, nombre: 'Usuario ' + req.params.id });
});

api.post('/usuarios', (req, res) => {
  const usuario = req.body;
  usuario.id = Date.now();
  res.status(201).json(usuario);
});

app.use('/api/v1', api);

// Ruta principal
app.get('/', (req, res) => {
  res.json({
    mensaje: 'API funcionando',
    version: '1.0.0',
    endpoints: ['/api/v1/usuarios', '/api/v1/usuarios/:id']
  });
});

// Manejo de errores
app.use((err, req, res, next) => {
  console.error('Error:', err.message);
  res.status(500).json({ error: 'Error interno' });
});

app.use((req, res) => {
  res.status(404).json({ error: 'Ruta no encontrada' });
});

// Iniciar
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Servidor corriendo en http://localhost:${PORT}`);
  console.log(`Entorno: ${app.get('env')}`);
});

📋 API Reference

servidor()

| Método | Descripción | |--------|-------------| | servidor() | Crea una nueva aplicación | | servidor.Router() | Crea un nuevo router | | servidor.Route | Referencia al constructor Route | | servidor.json() | Middleware parser JSON | | servidor.urlencoded() | Middleware parser URL-encoded | | servidor.text() | Middleware parser texto | | servidor.raw() | Middleware parser Buffer | | servidor.static(root) | Middleware archivos estáticos | | servidor.cors(options) | Middleware CORS |

app

| Método | Descripción | |--------|-------------| | app.use([path,] fn) | Montar middleware o router | | app.route(path) | Crear ruta encadenable | | app.get/post/put/delete(path, ...handlers) | Métodos HTTP | | app.set(key, value) | Configuración | | app.get(key) | Obtener configuración | | app.enable/disable(key) | Habilitar/deshabilitar | | app.param(name, fn) | Middleware de parámetros | | app.engine(ext, fn) | Registrar motor de vistas | | app.render(view, options, cb) | Renderizar vista | | app.listen(port, [cb]) | Iniciar servidor HTTP |

🛠️ Tecnologías

• Node.js >= 16.0.0
• Módulos nativos (http, fs, path, url, querystring)
• Cero dependencias externas

📝 Licencia

MIT © 2026 daisuke_developer

⬆ Volver arriba