DEV Community: Ibrahim Ayandiran

Part 1: Mastering Modules in Node.js

Ibrahim Ayandiran — Wed, 03 Jul 2024 18:40:35 +0000

In our digital world, everything around us is part of a vast tech ecosystem with software at its core. Over the years, a plethora of programming languages have been created to develop software. Some are problem-specific, some are multi-functional, and others have evolved from being problem-specific to multi-functional. JavaScript, at its genesis, was a programming language designed to bring interactivity to web applications. It's come a long way since then, and JavaScript now offers much more.

Node.js is a JavaScript runtime environment built on the Chrome V8 engine, allowing execution of JavaScript code outside web browsers. One of its core strengths lies in its modular structure. By the end of this article, you will have a clear understanding of what modules are, what problem they are trying to solve and how to use them.

Understanding Modules Through DRY and SRP

If you're familiar with the software development principles of DRY (Don't Repeat Yourself) and SRP (Single Responsibility Principle), then you've grasped the core problems that modules address. Modules are blocks of code that encapsulate related functionalities, making them reusable and maintainable. A well-written module adheres to both DRY and SRP principles, offering several advantages:

Code Reusability:

Instead of duplicating code across your application, you can create a module and reuse it wherever needed. This reduces redundancy and minimizes errors.

Maintenance:

Updating the logic becomes simpler and less error-prone. With modules, you only need to change the code in one place (the module itself) rather than modify it in multiple locations throughout your application.

Separation of Concerns:

Modules allow developers to break down complex applications into smaller, manageable parts with focused functionalities. This improves code readability and fosters better collaboration within development teams, as developers can work on specific modules without worrying about unintended side effects in other areas of the application.

Namespace Management:

Modules prevent naming conflicts. Variables and functions declared within a module are local to that module, avoiding clashes with global variables or variables used in other modules. to that module, avoiding clashes with global variables or variables used in other modules.

Types of Modules:

In Node.JS there are three(3) types of modules, these are;

Core/Built-in Modules:

These are built-in modules that come pre-installed with Node.js, providing essential functionalities like file system access (fs), HTTP communication (http), and path manipulation (path).

Local/Custom Modules:

These are modules you define within your application. They can be imported across different parts of your project extending its functionalities.

Third-Party Modules:

These are the third-party modules you import using the npm install or yarn add command. These modules are developed by other developers and published in the software registry.

How to create Local/Custom Modules:

Depending on your module syntax, creating a module in Node.js can be done either of the ways listed below:

CJS (Common JavaScript):

// Define code block 
function add(arg1, arg2) {
    return arg1 + arg2;
}

// Export code block
module.exports = add;

// Define code block
class MathHelper {
    add(arg1, arg2) {
        return arg1 + arg2
    }
}
module.exports = MathHelper

ES6 (ECMAScript 2015):

function add(arg1, arg2) {
    return arg1 + arg2;
}

// Export code block
export { add };

export function add(arg1, arg2) {
    return arg1 + arg2;
}
`

class MathHelper {
    add(arg1, arg2) {
        return arg1 + arg2
    }
}
// Export code block
export default add;

Importing Modules in Node.js

Despite the three different types of modules in Node.js (core, local, and third-party), the import process remains consistent. However, the specific syntax you use might differ depending on your chosen module syntax style.

CJS (Common JavaScript):

// Built-in/Core Module
const http = require("http");

// Custom/Local Module 
const add = require("./mathUtils");

// Third-Party Module
const express = require("express")

ES6 (ECMAScript 2015):

// Built-in/Core Module
import http from "http";

// Custom/Local Module 
import add from "./mathUtils";

// Third-Party Module
import express from "express"

Conclusion

In this first part of our series on Node.js modules, we unpacked the essentials. We explored how modules promote code reusability, maintainability, and separation of concerns—the cornerstones of clean code. We also covered the different types of modules available: core modules, custom local modules you define within your project, and the vast ecosystem of third-party modules accessible through npm.

Stay tuned for part two, where we'll delve deeper into the technical aspects. We'll explore module wrappers, their role in providing private scope and caching, and how they differ from Immediately Invoked Function Expressions (IIFEs). We'll also discuss module caching in detail, explaining how Node.js optimizes performance by storing the results of required modules.
For further reading check out the Official Node.js Documentation on Modules

Part 1: Mastering Modules in Node.js

Ibrahim Ayandiran — Wed, 03 Jul 2024 18:40:34 +0000

Understanding Modules Through DRY and SRP

Code Reusability:

Instead of duplicating code across your application, you can create a module and reuse it wherever needed. This reduces redundancy and minimizes errors.

Maintenance:

Separation of Concerns:

Namespace Management:

Types of Modules:

In Node.JS there are three(3) types of modules, these are;

Core/Built-in Modules:

These are built-in modules that come pre-installed with Node.js, providing essential functionalities like file system access (fs), HTTP communication (http), and path manipulation (path).

Local/Custom Modules:

These are modules you define within your application. They can be imported across different parts of your project extending its functionalities.

Third-Party Modules:

These are the third-party modules you import using the npm install or yarn add command. These modules are developed by other developers and published in the software registry.

How to create Local/Custom Modules:

Depending on your module syntax, creating a module in Node.js can be done either of the ways listed below:

CJS (Common JavaScript):

// Define code block 
function add(arg1, arg2) {
    return arg1 + arg2;
}

// Export code block
module.exports = add;

// Define code block
class MathHelper {
    add(arg1, arg2) {
        return arg1 + arg2
    }
}
module.exports = MathHelper

ES6 (ECMAScript 2015):

function add(arg1, arg2) {
    return arg1 + arg2;
}

// Export code block
export { add };

export function add(arg1, arg2) {
    return arg1 + arg2;
}
`

class MathHelper {
    add(arg1, arg2) {
        return arg1 + arg2
    }
}
// Export code block
export default add;

Importing Modules in Node.js

CJS (Common JavaScript):

// Built-in/Core Module
const http = require("http");

// Custom/Local Module 
const add = require("./mathUtils");

// Third-Party Module
const express = require("express")

ES6 (ECMAScript 2015):

// Built-in/Core Module
import http from "http";

// Custom/Local Module 
import add from "./mathUtils";

// Third-Party Module
import express from "express"

Conclusion

The ORM vs. ODM Debate: A Node.js Backend Perspective

Ibrahim Ayandiran — Mon, 13 May 2024 17:37:32 +0000

Imagine reusing a proven approach for a new project, only to hit a wall. That's exactly what happened to me as a Node.js developer. I was building a MongoDB app, but I tried to force-fit Prisma (an ORM) because of it similarity with a previous PostgreSQL project. Big mistake! Prisma's MongoDB support limited my options. This experience got me obsessed with understanding ORMs vs. ODMs (think Prisma vs. Mongoose). Now, I'm here to share what I learned about choosing the right tool for the database job!

So, what exactly are ORMs and ODMs? Let's break it down. These are tools that act as a bridge between your code and your database, but they cater to different database types.

The Database Bridge Builders: Understanding ORMs and ODMs

As backend engineers, we juggle complex data interactions between our code and the database. However, writing raw SQL queries can be tedious and error-prone. That's where Object-Relational Mappers (ORMs) and Object-Document Mappers (ODMs) come in – they act as powerful bridges simplifying those interactions.

What's an ORM?

Imagine our backend code as a well-structured shopping cart application. Products (data) are stored in a relational database (think of it as a giant online store with organized categories and tables). An ORM acts as a translator. It seamlessly converts the product objects (items in the cart) into SQL queries that the database understands. This lets us interact with the data using familiar object-oriented code instead of writing complex SQL statements from scratch.

How does an ORM help?

Boost Efficiency: Skip writing repetitive SQL queries and focus on building core functionalities using objects.
Minimize Errors: ORMs handle the translation, reducing the risk of typos in complex SQL commands.
Maintainability Magic: The code becomes clearer and easier to modify for future developers (or even our future selves!).

What's an ODM?

Now, imagine building a dynamic social media application. User profiles (data) can have various elements like posts, photos, and connections – a flexible structure. That's where ODMs excel! They work with document databases (think of it as a social media platform where user profiles are stored as JSON documents with diverse formats). ODMs map our user objects in the code to these documents within the database, allowing for a more adaptable approach.

How does an ODM help?

Embrace Flexibility: ODMs handle data with ever-changing structures, perfect for projects with evolving requirements.
Simplify Queries: Use object-oriented syntax or the native query language for document databases – no more complex SQL headaches.
Focus on the Logic: Spend less time wrestling with database specifics and more time crafting your application's core functionalities.

The Key Distinctions: ORMs vs. ODMs

While both ORMs and ODMs act as bridges between your code and database, they cater to fundamentally different database structures. Let's break it down in a table to see the key distinctions:

Similarities:

Despite their differences, ORMs and ODMs share some key features that make them valuable tools for backend developers:

Object Mapping: Both translate your code's objects (representing real-world entities) into the database's storage format.
Abstraction Layer: They act as a middle layer, simplifying data interaction by hiding the complexities of raw SQL queries.
Reduced Boilerplate: They eliminate the need for writing repetitive and error-prone SQL, allowing you to focus on core application logic.
In the next section, we'll delve deeper into how to choose the right tool (ORM vs. ODM) based on your specific database needs.

Choosing the Right Weapon: ORMs vs. ODMs for Your Database Needs

We've explored the strengths of both ORMs and ODMs, but which one reigns supreme for your project? Choosing the right tool is critical for:

Performance: ORMs excel in relational databases with complex queries, while ODMs shine in document databases with fast inserts/updates and flexible structures.
Development Efficiency: ORMs streamline complex relationships in relational databases, while ODMs simplify working with evolving data structures in document databases.
Maintainability: Well-suited ORMs or ODMs lead to cleaner, more maintainable code.

Conclusion: Choosing Your Database Partner

Understanding ORMs and ODMs equips you to make informed decisions for your Node.js projects. By considering factors like performance, development efficiency, and database type, you can choose the right tool for the job.

Remember, ORMs excel in structured relational databases with complex queries, while ODMs shine in flexible document databases with ever-changing data. With this knowledge, you're prepared to conquer any database challenge your Node.js projects throw your way!