Manejo Robusto de Fallos Críticos y Apagado Elegante en Node.js

const express = require('express');
const { Pool } = require('pg');

const app = express();
const pool = new Pool({ connectionString: process.env.DATABASE_URL });

// Ejemplo de ruta que puede generar un error asíncrono no capturado
app.get('/error', (req, res, next) => {
    // Simula un error asíncrono no capturado
    Promise.reject(new Error('¡Error asíncrono no manejado!'));
});

// Ejemplo de ruta que puede generar un error síncrono no capturado
app.get('/sync-error', (req, res, next) => {
    throw new Error('¡Error síncrono no manejado!');
});

app.get('/', (req, res) => {
    res.send('Servidor funcionando. Intenta /error o /sync-error para probar el shutdown.');
});

const server = app.listen(process.env.PORT || 3000, () => {
    console.log(`Servidor corriendo de forma segura en http://localhost:${process.env.PORT || 3000}`);
});

// --- EL SNIPPET DE CONTROL PERIMETRAL --- 

function initializeResilienceBunker(httpServer, dbPool) {
    let shutdownInProgress = false;
    let shutdownTimeoutId = null;

    const initiateGracefulShutdown = async (errorSource, errorDetails) => {
        if (shutdownInProgress) {
            console.warn(`⚠️ Intento de apagado duplicado desde [${errorSource}]. Ignorando.`);
            return;
        }
        shutdownInProgress = true;
        console.error(`🚨 ALERTA CRÍTICA [${errorSource}]:`, errorDetails instanceof Error ? errorDetails.message : errorDetails);
        if (errorDetails instanceof Error && errorDetails.stack) {
            console.error(errorDetails.stack);
        }

        // 1. Detener el servidor HTTP para dejar de aceptar nuevas conexiones
        console.log('🛑 Iniciando cierre del servidor HTTP. No se aceptarán más peticiones.');
        httpServer.close(async (err) => {
            if (err) {
                console.error('❌ Error al cerrar el servidor HTTP:', err);
            } else {
                console.log('✅ Servidor HTTP cerrado exitosamente.');
            }

            try {
                // 2. Liberar de forma segura el pool de conexiones de la DB
                console.log('📦 Drenando y cerrando pool de PostgreSQL...');
                await dbPool.end();
                console.log('✅ Pool de PostgreSQL drenado y cerrado limpiamente.');
            } catch (errDb) {
                console.error('❌ Error al cerrar recursos de la DB:', errDb);
            } finally {
                // Si todo salió bien, limpiar el timeout forzado y salir
                if (shutdownTimeoutId) {
                    clearTimeout(shutdownTimeoutId);
                }
                console.log('🚪 Proceso terminado con código de salida 1.');
                process.exit(1); // Salida por error controlado
            }
        });

        // Forced Exit Fallback: Si el drenado tarda más de 10s, forzar salida para evitar bucles zombies
        shutdownTimeoutId = setTimeout(() => {
            console.error('⚠️ Forzando salida: El cierre de recursos excedió el tiempo límite (10s).');
            process.exit(1);
        }, 10000);
    };

    // Capturar promesas rechazadas que no tienen un .catch()
    process.on('unhandledRejection', (reason, promise) => {
        initiateGracefulShutdown('unhandledRejection', reason);
    });

    // Capturar errores síncronos volados en el hilo principal
    process.on('uncaughtException', (error) => {
        initiateGracefulShutdown('uncaughtException', error);
    });

    // Capturar señales de terminación (e.g., Ctrl+C, SIGTERM de orquestadores)
    process.on('SIGTERM', () => {
        initiateGracefulShutdown('SIGTERM', 'Señal de terminación recibida.');
    });

    process.on('SIGINT', () => {
        initiateGracefulShutdown('SIGINT', 'Señal de interrupción (Ctrl+C) recibida.');
    });
}

// Inyección del búnker al arrancar la app
initializeResilienceBunker(server, pool);