dev-opus · May 4, 2021 08:56 · Raphdon832 · May 4, 2021
diff --git a/better.js b/better.js
 /*
  
  so uhm, up until about a week ago, my 
  defacto method for handling errors in an 
  async/await program-flow was to wrap my 
  entire code-block in a try/catch; performing 
  the operations in the `try {}` block and 
  handling any errors in the `catch(err) {}` block.
  
  it worked well, but it didn't sit well with me
  'cause them try/catch blocks be making my code
  "messy" and "bulky". also, i asked a friend [not
  sure if he considers me a friend though (^_^)]
  to review a rest api [scribble_api, check my github :)]
  i built for learning purposes. 
  
  one of the key issues he raised was my over-
  reliance on the try/catch blocks, stating that
  it wasn't a "best practices" kinda thing.
  
  so i traversed the internet, searching for a 
  better method and i found a few, but the one
  that appealed the most to me was the method
  wes bos used in his 2017 dotjs conference talk
  on async/await.
  
  enough of the [lenthy] comments, lets get to the
  code! :)
  
 */

 /*
  
  oops! one more lengthy comment block!
  i'll be demonstrating this method
  by mimicking a node.js/express.js
  app development environment

 */

 // code begins right under this line!!!

 // ./utils/handleErrors.js

 // catch async errors and propagate
 // them to the error handler function
 // using express.js `next()`
 const catchAsyncErrors = fn => {
  return function (req, res, next) {
    return fn(req, res, next).catch(next)
  }
 };

 // error handler to serve errors 
 // in json instead of express' 
 // default stack trace printing 
 const handleError = (err, res) => {
  const { message } = err;
  const statusCode = err.statusCode || 500;

  res.status(statusCode).json({
    status: 'Error',
    statusCode,
    message,
  });
 };

 // export the methods
 module.exports = { handleError, catchAsyncErrors };

 // ./controllers/notes.js 

 // require Notes model
 const Notes = require('../models/Notes');

 // create the async/await function with no 
 // cares about error handling, in essence,
 // no try/catch block
 const getNotes = async (req, res) => {
  const {noteSize} = req.params
  const notes await Notes.find({}).populate('author -__v').limit(noteSize).lean()
  
  if (!notes) {
    return res.status(404).json({
      status: 'failed',
      message: 'No notes in the DB',
      data: null
    });
  } 
  
  return res.status(200).json({
      status: 'success',
      message: 'get notes',
      data: notes
    });
 };

 // export the module methods
 module.exports = {getNotes, ...otherControllers}


 // ./routes/notes.js

 // import the catchAsyncErrors method and
 // the getNotes cotroller method
 const {catchAsyncErrors} = require('../utils/handleErrors');
 const {getNotes} = require('../controllers/notes');

 // create a route to handle GET requests on /api/notes
 router.get('/', catchAsyncErrors(getNotes)); // this is the line of truth!!!

 /*
  i know. i promised that you wouldn't be seeing this
  humongous comment blocks again, but this whole gist would
  be a waste if i don't explain what is happening on line
  110 to the best of my ability. and yeah, i need the 
  lenghty comments for that.
  
  getNotes is the async/await controller method with no
  built-in error mechanism(s) [!try/catch].
  
  catchAsyncErrors is the higher order func that recieves
  a single arg func, in this case, `getNotes`.
  
  when this catchAsyncErrors is called, it creates and 
  returns another func that recieves three args (req, res, next).
  
  this unnamed func returns the return-value of calling the 
  func arg passed to catchAsyncErrors, by calling this func
  (getNotes) with the the three args passed to it and a 
  `.catch(next)` method appended to it.
  
  that is where the magic occurs for catching and propagating
  any async error that occured in the `getNotes` controller
  method.
  
  this explanation might still be very vague for some people
  to comprehend, so i intend to make a flow-diagram for the 
  entire process discussed above and attach it to this gist 
  at a later time.
  
  pheeew! back to the code now..
 */

 // export the router

 module.exports = router;

 // ./app.js --> the entry point of the application

 /*
  *face palm* yet another lengthy comment block. *sigh*
  assume that the basic module loading for an express 
  entry point app happens here. 
 */

 // load the notes-router as well as the error handler modules
 // from their respective directories

 const notesRouter = require('./routes/notes');
 const {handleError} = require('./utils/handleErrors');

 // mount the /api/notes route
 app.use('/api/notes', notesRouter)

 // mount the custom error handler
 app.use((err, req, res, next) => {
  handleError(err, res);
 }) 

 // and that's it! if our app encounters an error
 // from say database timeout, our catchAsyncError
 // method propagates the error from the contoller 
 // to the handleError method above using `next`
	/*

	so uhm, up until about a week ago, my
	defacto method for handling errors in an
	async/await program-flow was to wrap my
	entire code-block in a try/catch; performing
	the operations in the `try {}` block and
	handling any errors in the `catch(err) {}` block.

	it worked well, but it didn't sit well with me
	'cause them try/catch blocks be making my code
	"messy" and "bulky". also, i asked a friend [not
	sure if he considers me a friend though (^_^)]
	to review a rest api [scribble_api, check my github :)]
	i built for learning purposes.

	one of the key issues he raised was my over-
	reliance on the try/catch blocks, stating that
	it wasn't a "best practices" kinda thing.

	so i traversed the internet, searching for a
	better method and i found a few, but the one
	that appealed the most to me was the method
	wes bos used in his 2017 dotjs conference talk
	on async/await.

	enough of the [lenthy] comments, lets get to the
	code! :)

	*/

	/*

	oops! one more lengthy comment block!
	i'll be demonstrating this method
	by mimicking a node.js/express.js
	app development environment

	*/

	// code begins right under this line!!!

	// ./utils/handleErrors.js

	// catch async errors and propagate
	// them to the error handler function
	// using express.js `next()`
	const catchAsyncErrors = fn => {
	return function (req, res, next) {
	return fn(req, res, next).catch(next)
	}
	};

	// error handler to serve errors
	// in json instead of express'
	// default stack trace printing
	const handleError = (err, res) => {
	const { message } = err;
	const statusCode = err.statusCode \|\| 500;

	res.status(statusCode).json({
	status: 'Error',
	statusCode,
	message,
	});
	};

	// export the methods
	module.exports = { handleError, catchAsyncErrors };

	// ./controllers/notes.js

	// require Notes model
	const Notes = require('../models/Notes');

	// create the async/await function with no
	// cares about error handling, in essence,
	// no try/catch block
	const getNotes = async (req, res) => {
	const {noteSize} = req.params
	const notes await Notes.find({}).populate('author -__v').limit(noteSize).lean()

	if (!notes) {
	return res.status(404).json({
	status: 'failed',
	message: 'No notes in the DB',
	data: null
	});
	}

	return res.status(200).json({
	status: 'success',
	message: 'get notes',
	data: notes
	});
	};

	// export the module methods
	module.exports = {getNotes, ...otherControllers}


	// ./routes/notes.js

	// import the catchAsyncErrors method and
	// the getNotes cotroller method
	const {catchAsyncErrors} = require('../utils/handleErrors');
	const {getNotes} = require('../controllers/notes');

	// create a route to handle GET requests on /api/notes
	router.get('/', catchAsyncErrors(getNotes)); // this is the line of truth!!!

	/*
	i know. i promised that you wouldn't be seeing this
	humongous comment blocks again, but this whole gist would
	be a waste if i don't explain what is happening on line
	110 to the best of my ability. and yeah, i need the
	lenghty comments for that.

	getNotes is the async/await controller method with no
	built-in error mechanism(s) [!try/catch].

	catchAsyncErrors is the higher order func that recieves
	a single arg func, in this case, `getNotes`.

	when this catchAsyncErrors is called, it creates and
	returns another func that recieves three args (req, res, next).

	this unnamed func returns the return-value of calling the
	func arg passed to catchAsyncErrors, by calling this func
	(getNotes) with the the three args passed to it and a
	`.catch(next)` method appended to it.

	that is where the magic occurs for catching and propagating
	any async error that occured in the `getNotes` controller
	method.

	this explanation might still be very vague for some people
	to comprehend, so i intend to make a flow-diagram for the
	entire process discussed above and attach it to this gist
	at a later time.

	pheeew! back to the code now..
	*/

	// export the router

	module.exports = router;

	// ./app.js --> the entry point of the application

	/*
	face palm yet another lengthy comment block. sigh
	assume that the basic module loading for an express
	entry point app happens here.
	*/

	// load the notes-router as well as the error handler modules
	// from their respective directories

	const notesRouter = require('./routes/notes');
	const {handleError} = require('./utils/handleErrors');

	// mount the /api/notes route
	app.use('/api/notes', notesRouter)

	// mount the custom error handler
	app.use((err, req, res, next) => {
	handleError(err, res);
	})

	// and that's it! if our app encounters an error
	// from say database timeout, our catchAsyncError
	// method propagates the error from the contoller
	// to the handleError method above using `next`