Ufdjrw

I'm wondering if I'm doing thing the cleanest way. Here's my setup:

Files
 - app.js
 - routes.js
 - controllers
 - wallet.js

routes.js

const router = require('express').Router()
const wallet = require('./controllers/wallet')

router.post('/wallet/generate', wallet.generate)
router.get('/wallet/address', wallet.address)
router.get('/wallet/balance', wallet.balance)
router.post('/wallet/transfer', wallet.transfer)

module.exports = router

controllers/wallet.js

const generate = async (req, res) => 
 // ...


const address = async (req, res) => 
 // ...


const balance = async (req, res) => 
 // ...


const _transfer = async (req, res) => 
 // ...


const transfer = [
 // I put my subroute specific middlewares here
 handleInvalidAddress,
 handleInvalidAmount,
 handleInvalidTokenName,
 _transfer
]

module.exports = transfer, generate, address, balance

Is this an acceptable way to do it? I couldn't find any good examples of open source express apps I could model. It seems to me that declaring my small middlewares only specific to one route in the routes.js file would be wrong. All the logic is in the controllers folder and the middlewares are logic.

edit: the transfer middlewares They are unlikely to be reused anywhere else than the wallet transfer route. In real life they are bigger and shouldn't clutter the transfer route function

const handleInvalidAddress = (req, res, next) => 
 if (req.body.address) 
 return next()
 
 res.status(400).send('invalid address')


const handleInvalidAmount = (req, res, next) => 
 if (req.body.amount) 
 return next()
 
 res.status(400).send('invalid amount')


const handleInvalidTokenName = (req, res, next) => 
 if (req.body.tokenName) 
 return next()
 
 res.status(400).send('invalid token name')

It's a good recipe to define new router like shown above. In case middleware and route handler functions aren't reused, they can be used in-place. It doesn't need to be aware of wallet part because it's common to all routes:

const router = require('express').Router()

router.post('/generate', async (req, res) => ...)
router.get('/address', async (req, res) => ...)
router.get('/balance', async (req, res) => ...)


router.use('/transfer', function handleInvalidAddress(req, res, next) ...)
router.post('/transfer', async (req, res) => ...)

module.exports = router;

And mount it like:

const walletRouter = require('./routes/wallet') 
appRouter.use('/wallet', walletRouter);

In case wallet routes need to be distributed between several modules for some reason (e.g. plugin system), it may be beneficial to use dependency injection:

module.exports = router => 
 router.post('/generate', async (req, res) => ...)
 router.get('/address', async (req, res) => ...)
 router.get('/balance', async (req, res) => ...)

 router.use('/transfer', function handleInvalidAddress(req, res, next) ...)
 router.post('/transfer', async (req, res) => ...)
;

And mount it like:

const walletRouter = Router();
require('./routes/wallet')(walletRouter);
appRouter.use('/wallet', walletRouter);