DEV Community: Afshin Tavakolian

🚀 Building a Modular and Scalable Backend with NestJS

Afshin Tavakolian — Sat, 23 Nov 2024 00:06:34 +0000

As developers, we often face challenges in building maintainable and scalable backend systems. Questions like:

How do I manage multiple modules efficiently?
What’s the best way to integrate Docker for database switching?
How can I auto-generate API documentation while ensuring security?

To address these challenges, I’ve created a NestJS Starter Template that streamlines backend development. It’s packed with features like modular design, Docker integration, JWT authentication, and Swagger documentation.

What is This Template About?

This starter template is designed for developers who want to hit the ground running with NestJS, a progressive Node.js framework. It includes:

Scalable Modular Architecture: Each feature is encapsulated, making the codebase clean and maintainable.
Pre-configured Docker Setup: Switch between MySQL and PostgreSQL with ease.
Swagger Documentation: Automatically generated and interactive API docs.
JWT Authentication: Secure authentication out of the box.
Environment-based Configuration: Centralized management for development, staging, and production.

Key Features

1️⃣ Modular Design

The template uses a feature-based folder structure:

src/

├── modules/

│   ├── auth/  # Authentication module

│   ├── user/  # User module

├── common/    # Shared utilities (e.g., decorators, pipes)

├── configs/   # Environment configurations

├── core/      # Core functionalities (e.g., database, logger)

2️⃣ Dockerized Development

Whether you prefer MySQL or PostgreSQL, the setup is pre-configured:

# Run with MySQL

docker-compose -f docker-compose.mysql.yml up --build

  
  
  Run with PostgreSQL


docker-compose -f docker-compose.postgres.yml up --build

3️⃣ JWT Authentication

The starter comes with:

Register Route: Sign up new users.
Login Route: Authenticate and receive a JWT.
Protected Routes: Access only with a valid token.

4️⃣ Swagger Integration

API documentation is auto-generated with Swagger, accessible at /api/docs.

How to Get Started

Step 1: Clone the Repository

git clone 

cd nestStarthttps://github.com/your-repo/nestStart.git

Step 2: Configure Environment Variables

# General Configuration

PORT=3000

NODE_ENV=development

  
  
  Database Configuration


DB_TYPE=postgres

DB_HOST=postgres

DB_PORT=5432

DB_USERNAME=admin

DB_PASSWORD=password

DB_NAME=my_database

  
  
  JWT Configuration


JWT_SECRET=my_super_secret_key

JWT_EXPIRES_IN=1h

Step 3: Run the Application

# Using Docker

docker-compose -f docker-compose.postgres.yml up --build

  
  
  Or run locally


npm install

npm run start:dev

Endpoints

POST /auth/register: Register a new user.
POST /auth/login: Authenticate and get a JWT.
GET /users: View all users (requires authentication).

What’s Next?

I plan to enhance the template with:

Advanced logging and analytics
GraphQL support
Unit and integration tests

Conclusion

This starter template is my contribution to the developer community. It’s open-source, flexible, and ready for production. Whether you're building an API for a startup or managing an enterprise-grade application, this template will save you hours of setup time.

👉 Check it out on GitHub

I’d love to hear your feedback. What features would you like to see added? Let’s connect and build something amazing together. 💻✨

Feel free to use and customize this article for your LinkedIn post. Let me know if you need further adjustments! 🚀

Building an Extensible Notification System

Afshin Tavakolian — Sat, 05 Oct 2024 09:01:10 +0000

Building an Extensible Notification System

In today’s digital world, notification systems have become an essential part of various platforms and applications. These systems are responsible for delivering important alerts to users via different channels such as email, SMS, or in-app notifications. The design of such a system should be flexible enough to allow for the easy addition of new notification channels in the future without requiring major structural changes.

The Challenge

Imagine you are developing a notification system for a platform. This system must be able to send notifications through multiple channels (such as email, SMS, in-app notifications, and even push messages). Additionally, some notifications may need to be sent through multiple channels simultaneously. The system must be designed in such a way that it can easily be extended to support new channels in the future without rewriting much of the existing code.

Exploring Suitable Design Patterns

To tackle this challenge, there are several design patterns that can be implemented. Let's explore three design patterns: Strategy, Observer, and Decorator, and see how they fit into building an extensible notification system.

1. Strategy Pattern

The Strategy pattern allows you to switch between different algorithms dynamically. In this case, each notification channel (like email, SMS, etc.) can be treated as a separate strategy, with each channel implemented in its own class, following a common interface.

Pros:

Flexibility: You can easily swap out the notification channel by changing the strategy object.
Clean Code: Each notification channel is implemented separately, making it easier to manage and maintain.

Cons:

Complexity with Multiple Channels: If you want to send notifications through multiple channels simultaneously, managing them can become more complex.

2. Observer Pattern

The Observer pattern enables you to notify multiple observers (in this case, notification channels) at the same time. Whenever a notification is triggered, all subscribed channels are notified and can send the message accordingly.

Pros:

Simultaneous Notifications: You can send notifications through multiple channels simultaneously.
Easy to Extend: Adding new channels is easy without changing the core structure of the system.

Cons:

Complex Management: Managing and coordinating between different channels can become complex and requires careful design.

3. Decorator Pattern

The Decorator pattern allows you to dynamically add new behavior to objects without altering their structure. In the case of notifications, you can chain different behaviors (such as sending via SMS and email) together.

Pros:

High Flexibility: You can add new behaviors (channels) dynamically without changing the core system.
Chaining: Allows you to send notifications through multiple channels by chaining behaviors.

Cons:

Complexity in Management: As more channels are added, managing the chain of decorators can become complex.

Choosing the Best Design Pattern

After reviewing the patterns, Observer Pattern stands out as the best choice for this challenge. The ability to manage multiple notification channels simultaneously and easily extend the system by adding new channels makes it the most suitable solution. With this pattern, you can scale the system as new notification channels are introduced, without having to rewrite significant parts of the code.

Implementing the Observer Pattern

Here’s how you can implement the Observer pattern for your notification system. You would have a core NotificationSubject class that handles notifying all the attached channels. Each channel (like email, SMS, etc.) would be an observer attached to this subject.

class NotificationSubject {
    protected $observers = [];

    public function attach(NotificationObserver $observer) {
        $this->observers[] = $observer;
    }

    public function notify($message) {
        foreach ($this->observers as $observer) {
            $observer->send($message);
        }
    }
}

interface NotificationObserver {
    public function send($message);
}

class EmailObserver implements NotificationObserver {
    public function send($message) {
        // Send email
    }
}

class SmsObserver implements NotificationObserver {
    public function send($message) {
        // Send SMS
    }
}

Whenever a message is passed to the notify method, all attached observers (channels) will send the notification through their respective medium.

Conclusion

An extensible notification system allows you to easily add new notification channels while managing multiple channels simultaneously. The Observer Pattern is chosen as the best solution because of its ability to handle multiple notification channels and its flexibility to expand the system as new channels are added.

Keywords:

Notification System
Extensible Design
Design Patterns
Observer Pattern
Managing Notifications

This article explored the challenge of implementing an extensible notification system and reviewed potential design patterns that could be used to manage and expand notification channels in the future.