Refactorización del código de middleware del proyecto NodeJS, usando rutas, controladores y modelos

Actualmente tengo dificultades para estructurar mi proyecto NodeJS. Seguí varias series de YouTube y vi a personas que usaban diferentes técnicas para estructurar su código. ¿Qué estructura me sugerirías en mi caso? ¿Cuál es la mejor práctica?

Tengo mi app.jsque contiene el establecimiento de conexión a MongoDB, inicializando express, bodyParser, pug como motor de vista y finalmente iniciando el servidor.

My router.jscontiene todas las rutas y, desafortunadamente, algo de código de middleware, que quiero mover a su propio controlador dedicado.

La modelscarpeta contiene todos los archivos de esquema para MongoDB.

// File structure:
.
├─ controllers
|  ├─ morticians.js
|  ├─ people.js
|  └─ pickups.js
├─ models
|  ├─ mortician.js
|  ├─ person.js
|  └─ pickup.js
├─ views
|  ├─ elements
|  |  └─ ..
|  ├─ pages
|  |  ├─ dashboard.pug
|  |  └─ ..
|  └─ layout.pug
├─ app.js
└─ router.js

Somos un hospital ya veces la gente muere aquí. Un funerario viene y los recoge, pero el proceso para eliminar a esta persona de nuestros sistemas aún no está automatizado. Para eso es esta aplicación web. Extraer a todos los fallecidos de nuestra base de datos, mostrarlos en la aplicación web y eliminarlos tan pronto como el encargado de la funeraria llegó y recogió a esa persona.

1. Cuando se solicita la página principal, busca a todas las personas, luego a todos los funerarios de MongoDB y finalmente renderiza la página. Puedo imaginar que esta no es la mejor práctica, pero ¿cómo refactorizarla?

// snippet router.js
const Person= require('./models/person')
const Mortician = require('./models/mortician')
router.get('/', (req, res, next) => {
  Person.find({ pickedUp: false }, (err, people) => {
    Mortician.find({}, (err, morticians) => {
      if (err) return console.log(err);
      res.render('pages/dashboard', {
        title: 'Dashboard',
        persons: people,
        morticians: morticians
      })
    })
  })
}

Intenté mover las operaciones de MongoDB a sus controllerarchivos, así. Funcionó, pero no estoy seguro, ya que utiliza múltiples promesas y no simplifica las cosas:

// snippet router.js
const ConPeople = require('./controllers/people')
const ConMorticians = require('./controllers/morticians')
router.get('/',
  (req, res, next) => {
    res.locals.options = { pickedUp: false }
    ConPeople.find(req, res, next)
      .then((people) => {
        res.locals.people = people
        next()
      })
  },
  (req, res, next) => {
    res.locals.options = {}
    ConMorticians.find(req, res, next)
      .then((morticians) => {
        res.locals.morticians = morticians
        next()
      })
  },
  (req, res) => {
    res.render('pages/dashboard', {
      title: 'Dashboard',
      people: res.locals.people,
      morticians: res.locals.morticians.reverse()
    })
  }
)

// snippet controllers/people.js
module.exports = {
  find: (req, res, next) => {
    return Person.find(res.locals.options)
  }
}

2. En algunos casos, necesito ejecutar comandos como eliminar o agregar una persona de MongoDB. Por ejemplo, un funerario viene y recoge a una persona. Necesito establecer el estado de esa persona en pickedUp = true, eventualmente agregar un nuevo funerario si se proporciona y agregar un nuevo documento a la colección pickups. ¿Cómo hago eso sin tener que volver a escribir las mismas líneas?

Hay 2 cosas que, cuando se usan en combinación, harán que el código sea mucho más agradable:

• Collection.finddevuelve una promesa .
• Para esperar a que se resuelva una promesa en JavaScript moderno, utilice await

Puede utilizar el siguiente código:

const Person= require('./models/person')
const Mortician = require('./models/mortician')
router.get('/', async (req, res, next) => {
  try {
    const persons = await Person.find({ pickedUp: false });
    const morticians = await Mortician.find({});
    res.render('pages/dashboard', {
      title: 'Dashboard',
      persons,
      morticians,
    });
  } catch(e) {
    // handle errors
  }
});

O, para recuperar los resultados en paralelo en lugar de en serie, use Promise.all:

router.get('/', async (req, res, next) => {
  try {
    const [persons, morticians] = await Promise.all([
      Person.find({ pickedUp: false }),
      Mortician.find({})
    ]);
    res.render('pages/dashboard', {
      title: 'Dashboard',
      persons,
      morticians,
    });
  } catch(e) {
    // handle errors
  }
});

Puede usar el mismo tipo de patrón siempre que tenga que realizar varias llamadas asincrónicas, sin necesidad de un desagradable anidamiento y sangría de corchetes.