Cómo estructurar y gestionar un proyecto de backend con un Boot Manager

Aquí tienes un ejemplo avanzado de cómo estructurar y gestionar un proyecto de backend con un "boot manager" que coordina 16 archivos server.js organizados en carpetas y subcarpetas, y conecta con 20 páginas del frontend, también organizadas en carpetas y subcarpetas. El código incluye punteros (referencias a objetos), arrays, clases, objetos y métodos.

 

Estructura del Proyecto

Backend 

backend/
├── bootManager.js
├── servers/
│   ├── module1/
│   │   ├── authServer.js
│   │   ├── userServer.js
│   ├── module2/
│   │   ├── apiServer.js
│   │   ├── dbServer.js
│   └── module3/
│       ├── staticServer.js
│       ├── socketServer.js
│       ├── logServer.js
│       ├── mailServer.js
├── shared/
│   ├── helpers.js
│   ├── config.js

Frontend

frontend/
├── index.html
├── pages/
│   ├── moduleA/
│   │   ├── home.html
│   │   ├── login.html
│   │   └── register.html
│   ├── moduleB/
│   │   ├── profile.html
│   │   ├── settings.html
│   ├── moduleC/
│   │   ├── dashboard.html
│   │   ├── reports.html
│   │   └── analytics.html
│   ├── moduleD/
│       ├── contact.html
│       ├── about.html
│       └── faq.html
├── js/
│   ├── moduleA/
│   │   ├── home.js
│   │   ├── login.js
│   ├── moduleB/
│   │   ├── profile.js
│   │   ├── settings.js

Backend: Código Fuente Avanzado

bootManager.js 

Este archivo inicializa y gestiona los servidores, utilizándolos como punteros dentro de un array dinámico. 

const path = require('path');

// Lista de servidores con sus rutas y funciones
const servers = [
    { name: 'authServer', file: './servers/module1/authServer.js' },
    { name: 'userServer', file: './servers/module1/userServer.js' },
    { name: 'apiServer', file: './servers/module2/apiServer.js' },
    { name: 'dbServer', file: './servers/module2/dbServer.js' },
    { name: 'staticServer', file: './servers/module3/staticServer.js' },
    { name: 'socketServer', file: './servers/module3/socketServer.js' },
    { name: 'logServer', file: './servers/module3/logServer.js' },
    { name: 'mailServer', file: './servers/module3/mailServer.js' }
];

// Inicializador de servidores
class BootManager {
    constructor(servers) {
        this.servers = servers.map(server => ({
            name: server.name,
            instance: require(path.resolve(server.file)),
        }));
    }

    async startAll() {
        for (const server of this.servers) {
            console.log(`Iniciando ${server.name}...`);
            await server.instance.start();
        }
        console.log('Todos los servidores están en ejecución.');
    }
}

// Ejecutar el gestor
(async () => {
    const manager = new BootManager(servers);
    await manager.startAll();
})();
 

authServer.js

 Un ejemplo de servidor específico.

const express = require('express');
const app = express();

const start = () => {
    return new Promise((resolve, reject) => {
        app.get('/auth', (req, res) => res.send('Servidor de Autenticación activo'));
        app.listen(3001, () => {
            console.log('authServer funcionando en http://localhost:3001');
            resolve();
        }).on('error', reject);
    });
};

module.exports = { start };

Repites una estructura similar para los demás archivos del backend.

 

Frontend: Código Fuente Avanzado

home.js

Un archivo de frontend con interacción dinámica.

document.addEventListener('DOMContentLoaded', () => {
    const button = document.getElementById('welcomeButton');
    button.addEventListener('click', () => {
        alert('¡Bienvenido al módulo A!');
    });
});
 

login.js

Un archivo para gestionar el login del usuario.

document.getElementById('loginForm').addEventListener('submit', async (e) => {
    e.preventDefault();
    const username = document.getElementById('username').value;
    const password = document.getElementById('password').value;

    const response = await fetch('/auth', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ username, password }),
    });

    const result = await response.json();
    if (result.success) {
        alert('Login exitoso');
    } else {
        alert('Error en el login');
    }
});

index.html  

Un archivo principal del frontend con rutas dinámicas.

<!DOCTYPE html>
<html lang="es">
<head>
    <meta charset="UTF-8">
    <title>Frontend Modular</title>
    <script src="./js/moduleA/home.js" defer></script>
</head>
<body>
    <h1>Módulo A</h1>
    <button id="welcomeButton">¡Haz clic aquí!</button>
</body>
</html>
 

 

Ventajas

• Backend Modular: Cada servidor tiene responsabilidades específicas.
• Frontend Escalable: Las páginas y scripts están organizados según módulos.
• Gestión Dinámica: El boot manager gestiona todos los servidores como punteros dinámicos.
• Interacción Completa: Las páginas del frontend están conectadas a los servidores backend, permitiendo comunicación fluida.