DEV Community: codeagboro

Folder Arrangement in a Node Js application

codeagboro — Sun, 26 Mar 2023 14:23:45 +0000

Organizing your codebase in Node.js can be a challenge, depending on the specific needs of your project. Fortunately, there are some common folder structures that make it easier to maintain and keep tidy. There are several structures that can be employed in arranging folders for a node js application. Below is a list of a few of them however it is worthy of note that folder arrangement is based on the needs of your project.

MVC Structure:

MVC is a widely used software architecture for web applications. It divides the program into three parts: Model, View and Controller. We can use this structure to organize our Node.js folder structure. For instance, here's an example of how to do it:

- project/
  - controllers/
    - usersController.js
    - productsController.js
  - models/
    - userModel.js
    - productModel.js
  - views/
    - users/
      - index.ejs
      - profile.ejs
    - products/
      - index.ejs
      - details.ejs
  - public/
    - css/
      - style.css
    - js/
      - script.js
  - app.js
  - index.js
  - package.json

This structure consists of a controllers/ folder that holds the application's controllers. Every controller deals with user requests and collaborates with the model to get or update data. The models/ folder contains the models for the application, which handle data storage and retrieval. The views/ folder has the views of the app, that are responsible for displaying HTML to the user. Moreover, inside public/ there are static assets such as CSS and JavaScript files. Lastly, index.js acts as the main entry point for the application, where it connects controllers, models, and views together.

Node.js's MVC pattern assists in isolating concerns, allowing code to be more modular and maintainable. Controllers, models, and views can all be developed separately, thus facilitating testing and debugging. Moreover, it facilitates a cleaner separation of responsibilities, wherein each application component is responsible for a particular set of functions, making the code easier to comprehend.

However in a typical MVC structure we can also have routes and config folders seperately
The routes/ folder holds the application's routes, which define the endpoints a user can use. These routes handle receiving HTTP requests, connecting to the appropriate controller function and delivering back an HTTP response. As part of the MVC structure, these routes act as part of the Controller layer, as they control how data flows between an individual and the application.

The config/ folder is home to configuration files like environment variables, database settings and authentication settings. In MVC structure, these configuration files are part of the Model layer since they manage the storage and retrieval of data for the application.
So, the config/ and routes/ folders can be included in the MVC folder structure like this:

- src/
  - controllers/
    - usersController.js
    - productsController.js
  - models/
    - userModel.js
    - productModel.js
  - routes/
    - users.js
    - products.js
  - views/
    - users/
      - index.ejs
      - profile.ejs
    - products/
      - index.ejs
      - details.ejs
  - config/
    - env.js
    - database.js
    - auth.js
  - public/
    - css/
      - style.css
    - js/
      - script.js
  - app.js
 - index.js
  - package.json

Arrangement based on features

Another common pattern is to organize the project based on the feature or module. In this pattern, each feature or module has its own folder that contains all the necessary files for that feature or module. For example:

- project/
  - features/
    - users/
      - index.js
      - usersController.js
      - userModel.js
      - user.ejs
      - user.css
      - user.js
    - products/
      - index.js
      - productsController.js
      - productModel.js
      - product.ejs
      - product.css
      - product.js
  - app.js
  - package.json

There are other patterns as well, such as organizing by layers (presentation, application, domain, infrastructure), by file type (controllers, models, views, helpers), or by use case. Ultimately, the folder structure you choose should be based on the needs of your project and your personal preference.

Handling exception in Node Js Express

codeagboro — Sun, 19 Mar 2023 12:25:26 +0000

Node.js is a powerful platform for building server-side applications, but like all programming languages, it can be prone to errors and exceptions. These exceptions can arise due to miscellaneous factors such as incorrect input, external dependencies, or network issues. This article discusses the handling of Node.js and Express exceptions – one of the most popular web application frameworks built on Node.js.

An exception is an event that disrupts the normal flow of a program's instructions, which then returns an error message when it occurs. In Node.js, whenever code confronts an issue that it cannot handle, an exception is thrown which is then sent to the runtime system in search of an appropriate handler.

Types of Exceptions

Synchronous
A synchronous exception is an exception that takes place while a program is in the middle of running. If a synchronous exception occurs, it halts the execution of the program and directs it to the closest catch block which can manage it.
As an illustration, take a look at this code snippet:

function divide(x, y) {
  if (y === 0) {
    throw new Error('Division by zero!');
  }
  return x / y;
}

try {
  const result = divide(10, 0);
  console.log(result);
} catch (error) {
  console.log(error.message);
}

When we call the divide function with arguments (10, 0), an exception is thrown immediately which forces the execution to jump to the catch block where it logs an error message, 'Division by zero!'. Synchronous exceptions can be easy to handle and their predictable nature makes them desirable in some cases. However, if not handled properly they can cause abrupt termination of a program which is undesirable. To minimize this risk, one can employ defensive programming techniques such as validating inputs and handling edge cases. Thus, understanding how to handle synchronous exceptions is crucial for any developer. By using defensive programming and proper error handling mechanisms, we can make our programs more reliable and robust by minimizing any synchronous exceptions that may occur.

Asynchronous
When dealing with asynchronous code, errors can be thrown. This is known as an asynchronous exception, and won't be handled immediately - the program continues execution until it reaches the nearest error handler. In Node.js and Express, there are two ways we can handle such exceptions: using the try-catch mechanism, or employing error middleware.

Using try-catch allows us to wrap our asynchronous code in a try block, and specify a catch block for any exceptions thrown. For example:

router.get('/', async (req, res) => {
  try {
    const data = await fetchData();
    res.send(data);
  } catch (error) {
    console.log(error);
    res.status(500).send('Internal Server Error');
  }
});

In this code, we have an asynchronous route handler that's calling the fetchData function which returns a Promise. We attempt to call it by establishing a try block and catching any exceptions that might be thrown in the catch block. If an issue arises, we log the error and send a 500 Internal Server Error response back to the user.

An alternate way to deal with asynchronous exceptions is to utilize error middleware. Error middleware catches any unforeseen exceptions and sends an appropriate error response back to the user. For example:

function errorHandler(err, req, res, next) {
  console.log(err);
  res.status(500).send('Internal Server Error');
}

app.use(errorHandler);

This code defines an error handler middleware function which takes four arguments: err, req, res and next. When an unhandled exception occurs in our application, this function is invoked by the system and logs the error message to the console. Additionally, a 500 Internal Server Error response is sent back to the client.

It is essential that errors are handled correctly as this will improve robustness and reliability of both Node.js and Express applications, as well as providing an excellent user experience.

In conclusion, handling exceptions should be a priority in order for applications to remain stable; however it is just as important to take steps in order to prevent them from arising in the first place by writing error-free code, validating inputs and using external libraries responsibly.