Al desarrollar una aplicación Node.js utilizando Express.js, estructurar su código base de manera efectiva es crucial para la mantenibilidad, la escalabilidad y la facilidad de colaboración. Una estructura de proyecto bien organizada le permite gestionar la complejidad, lo que facilita la navegación y la comprensión del código. En este blog, exploraremos una estructura de carpetas típica para una aplicación Express.js y explicaremos el propósito de cada directorio y archivo.

Descripción general de la estructura del proyecto
A continuación se muestra una estructura de carpetas común para una aplicación Express.js:

?
├── ? app.js
├── ? bin
├── ? config
├── ? controllers
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? middleware
│   ├── ? auth.js
│   ├── ? logger.js
│   └── ...
├── ? models
│   ├── ? customer.js
│   ├── ? product.js
│   └── ...
├── ? routes
│   ├── ? api.js
│   ├── ? auth.js
│   └── ...
├── ? public
│   ├── ? css
│   ├── ? js
│   ├── ? images
│   └── ...
├── ? views
│   ├── ? index.ejs
│   ├── ? product.ejs
│   └── ...
├── ? tests
│   ├── ? unit
│   ├── ? integration
│   ├── ? e2e
│   └── ...
├── ? utils
│   ├── ? validation.js
│   ├── ? helpers.js
│   └── ...
└── ? node_modules

Explicación de cada directorio y archivo
aplicación.js
El archivo app.js es el punto de entrada de su aplicación. Es donde inicializa la aplicación Express, configura el middleware, define rutas e inicia el servidor. Piense en ello como el centro de control de su aplicación web.

const express = require('express');
const app = express();
const config = require('./config');
const routes = require('./routes');
// Middleware setup
app.use(express.json());
// Routes setup
app.use('/api', routes);
// Start server
const PORT = config.port || 3000;
app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});
module.exports = app;

papelera
El directorio bin normalmente contiene scripts para iniciar su servidor web. Estos scripts se pueden utilizar para establecer variables de entorno o gestionar diferentes entornos (por ejemplo, desarrollo, producción).

Ejemplo: bin/www

#!/usr/bin/env node
const app = require('../app');
const debug = require('debug')('your-app:server');
const http = require('http');
const port = normalizePort(process.env.PORT || '3000');
app.set('port', port);
const server = http.createServer(app);
server.listen(port);
server.on('error', onError);
server.on('listening', onListening);
function normalizePort(val) {
  const port = parseInt(val, 10);
  if (isNaN(port)) return val;
  if (port >= 0) return port;
  return false;
}
function onError(error) {
  if (error.syscall !== 'listen') throw error;
  const bind = typeof port === 'string' ? 'Pipe '   port : 'Port '   port;
  switch (error.code) {
    case 'EACCES':
      console.error(bind   ' requires elevated privileges');
      process.exit(1);
      break;
    case 'EADDRINUSE':
      console.error(bind   ' is already in use');
      process.exit(1);
      break;
    default:
      throw error;
  }
}
function onListening() {
  const addr = server.address();
  const bind = typeof addr === 'string' ? 'pipe '   addr : 'port '   addr.port;
  debug('Listening on '   bind);
}

configuración
El directorio de configuración contiene archivos de configuración para su aplicación, como conexiones de bases de datos, configuraciones del servidor y variables de entorno.

Ejemplo: config/index.js

module.exports = {
  port: process.env.PORT || 3000,
  db: {
    host: 'localhost',
    port: 27017,
    name: 'mydatabase'
  }
};

controladores
Los controladores contienen la lógica para manejar las solicitudes entrantes y generar respuestas. Cada archivo en el directorio de controladores normalmente corresponde a una parte diferente de su aplicación (por ejemplo, clientes, productos).

Ejemplo: controladores/cliente.js

const Customer = require('../models/customer');
exports.getAllCustomers = async (req, res) => {
  try {
    const customers = await Customer.find();
    res.json(customers);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};

middleware
Las funciones de middleware se utilizan para procesar solicitudes antes de que lleguen a los controladores. Pueden manejar tareas como autenticación, registro y validación de solicitudes.

Ejemplo: middleware/auth.js

module.exports = (req, res, next) => {
  const token = req.header('Authorization');
  if (!token) return res.status(401).json({ message: 'Access Denied' });
  try {
    const verified = jwt.verify(token, process.env.JWT_SECRET);
    req.user = verified;
    next();
  } catch (err) {
    res.status(400).json({ message: 'Invalid Token' });
  }
};

modelos
Los modelos definen la estructura de sus datos y manejan las interacciones con la base de datos. Cada archivo de modelo normalmente corresponde a una entidad de datos diferente (p. ej., Cliente, Producto).

Ejemplo: modelos/cliente.js

const mongoose = require('mongoose');
const customerSchema = new mongoose.Schema({
  name: {
    type: String,
    required: true
  },
  email: {
    type: String,
    required: true,
    unique: true
  },
  createdAt: {
    type: Date,
    default: Date.now
  }
});
module.exports = mongoose.model('Customer', customerSchema);

rutas
Las rutas definen las rutas a diferentes partes de su aplicación y las asignan a los controladores apropiados.

Ejemplo: rutas/api.js

const express = require('express');
const router = express.Router();
const customerController = require('../controllers/customer');
router.get('/customers', customerController.getAllCustomers);
module.exports = router;

público
El directorio público contiene archivos estáticos como CSS, JavaScript e imágenes que se entregan directamente al cliente.

Ejemplo: Estructura de directorio

public/
├── css/
├── js/
├── images/

vistas
Las vistas son plantillas que representan el HTML para el cliente. Utilizando un motor de plantillas como EJS, Pug o Manillars, puedes generar HTML dinámico.

Ejemplo: vistas/index.ejs

  
Welcome to My App
  

    
  

pruebas
El directorio de pruebas contiene archivos de prueba para garantizar que su aplicación funcione correctamente. Las pruebas suelen organizarse en pruebas unitarias, pruebas de integración y pruebas de un extremo a otro (e2e).

Ejemplo: Estructura de directorio

tests/
├── unit/
├── integration/
├── e2e/

utilidades
Las funciones de utilidad y los módulos auxiliares se almacenan en el directorio de utilidades. Estas funciones realizan tareas comunes como validación y formateo que se utilizan en toda la aplicación.

Ejemplo: utils/validation.js

exports.isEmailValid = (email) => {
  const re = /^[^\s@] @[^\s@] \.[^\s@] $/;
  return re.test(String(email).toLowerCase());
};

módulos_nodo
El directorio node_modules contiene todas las dependencias que su proyecto necesita. Este directorio es administrado por npm (o hilo) e incluye paquetes instalados desde el registro de npm.

Conclusión
Una aplicación Node.js bien estructurada que utilice Express.js mejora la capacidad de mantenimiento, la escalabilidad y la colaboración. Cada directorio y archivo en la estructura tiene un propósito específico, desde manejar la configuración y definir rutas hasta administrar middleware y renderizar vistas. Al organizar su base de código de manera efectiva, puede crear aplicaciones sólidas y escalables con facilidad.