In this article, I’ll demonstrate how to buid a simple and maintainable process manager for Node.js, leveraging its Event Loop.
The main idea is have a core processor that will be able to run a serie of tasks, in a synchronous way.
Let take simple example :
As the execution flow is asynchroneous, the result variable will not be valued before the crawling method ends, and the usage of the variable will occurs before its valuation
Callbacks are really handy, but what happen if if I have a process with several tasks in it?
Yes, we just felt into the Callback Hell!
The main issue with the nested callback is that your code has a lack of readability and flexibility. It’s quite difficult to understand what the code is meant to do. And if you have to modify the process, you’ll have to rethink the whole process.
We can do much better!
NodeJs processing model is based on a event loop, so we can easily use an event-driven approach.
We build a very simple “event bus” :
A task is a function that wrap a logical unit of work and a callback to the event bus:
Note that i use a context object, where task can store some data that following tasks can use, and use data previously setted.
Then we can build the processor. As we want the maximun readability, we want our process to be a declarative list of tasks. So our processor execute tasks in a synchronous way, waiting an event from the event bus before executing the next task :
Then, the definition of the process itself :
We first gather all the needed components, then simply build an array of the task in the needed order:
We are done! We now have a nicely decoupled task processor, and we now focus on writing unit of work that will be wrapped in tasks, so we are now will be able to follow the Single Responsibility Principle.