DEV Community: Ezile Mdodana

Introducing @ezilemdodana/nest-mapper — Lightweight Mapping for NestJS

Ezile Mdodana — Thu, 05 Feb 2026 06:47:35 +0000

Hi NestJS community,

I’ve recently published @ezilemdodana/nest-mapper, a lightweight object mapper built specifically for NestJS projects.

The motivation behind it was simple: many existing NestJS mapping solutions introduce dependency or configuration challenges, especially in larger or evolving projects. This package aims to provide a clean, dependency-light, and NestJS-friendly alternative focused on straightforward DTO ↔ entity mapping.

If you’re working with NestJS and looking for a simpler mapping approach, I’d appreciate it if you could try it out and share feedback, issues, or improvement suggestions.

Package: https://www.npmjs.com/package/@ezilemdodana/nest-mapper

Feedback and contributions are welcome!

10 Common Mistakes Beginners Make

Ezile Mdodana — Wed, 17 Jul 2024 06:49:11 +0000

Introduction
Starting a career in software development is both exciting and challenging. While learning to code is crucial, understanding common pitfalls can help new developers navigate their journey more effectively. In this article, we will explore ten common mistakes that beginner software developers make and provide tips on how to avoid them.

1. Not Asking for Help
Many beginners feel intimidated about asking for help, fearing it might make them seem less competent. However, seeking assistance is a vital part of learning. Experienced developers, mentors, and even online communities can provide valuable insights and solutions to problems that might take hours to solve alone. Remember, asking questions is a sign of eagerness to learn and grow.

2. Neglecting Code Readability
Writing code that only you can understand is a common rookie mistake. Code readability is essential for collaboration and maintenance. Adopting best practices like using meaningful variable names, consistent indentation, and commenting on your code helps others (and your future self) understand your work. Following coding standards and guidelines also ensures that your code remains clean and maintainable.

3. Overlooking Version Control
Version control systems like Git are indispensable tools for developers. They allow you to track changes, collaborate with others, and revert to previous versions if something goes wrong. Despite its importance, many beginners avoid using version control due to perceived complexity. Start with basic Git commands like commit, push, pull, and branch, and gradually explore more advanced features.

4. Skipping Testing
Testing is often neglected by beginners, leading to unstable and buggy software. Writing tests ensures that your code works as intended and helps catch errors early. Start with unit tests to validate individual components, and gradually incorporate integration and automated tests. Tools like Jest for JavaScript, JUnit for Java, and PyTest for Python can help you get started.

5. Ignoring Documentation
Documentation is an often overlooked aspect of software development. It provides a roadmap for users and developers, explaining how the code works and how to use it. Whether it's inline comments, README files, or API documentation, take the time to document your code thoroughly. This practice not only helps others but also reinforces your understanding of the code.

6. Not Understanding the Problem Before Coding
Beginners may jump into coding without fully understanding the problem. It's essential to analyze and plan before writing code. Techniques like pseudocode, flowcharts, and diagrams can help clarify the problem and outline a solution. Taking the time to understand the problem can save a lot of rework and frustration later.

7. Overcomplicating Solutions
New developers might write overly complex solutions to simple problems. Advocate for simplicity and clarity in code. Introduce the KISS (Keep It Simple, Stupid) principle. Simple solutions are often more robust and easier to understand. Avoid over-engineering and focus on solving the problem at hand.

8. Lack of Consistent Learning
Some beginners stop learning once they get a job or complete a course. However, technology is always evolving, and continuous learning is essential. Stay updated with industry trends and best practices by reading books, taking online courses, and participating in coding challenges. Engage with the developer community through forums, blogs, and conferences.

9. Underestimating the Importance of Soft Skills
Technical skills are crucial, but soft skills like communication, teamwork, and time management are equally important. These skills can impact a developer's career and work environment significantly. Good communication ensures that ideas are clearly conveyed, and teamwork fosters a collaborative and productive environment. Managing your time effectively helps in meeting deadlines and balancing workloads.

10. Failure to Review and Refactor Code
Beginners often write code and move on without reviewing or refactoring. Code reviews are an excellent way to catch mistakes, get feedback, and learn from more experienced developers. Regularly refactoring code improves its structure and performance. Adopt a mindset of continuous improvement and seek opportunities to enhance your code.

Conclusion
By addressing these common mistakes and adopting best practices, beginner software developers can set themselves up for success. Continuous learning, seeking feedback, and being open to new ideas will help you grow and excel in your career. Embrace the journey, learn from your mistakes, and remember that every experienced developer started where you are now.

Implementing Queues Using Linked Lists in NestJS

Ezile Mdodana — Mon, 15 Jul 2024 17:01:21 +0000

Introduction

One of the fundamental data structures is the queue, which follows the First-In-First-Out (FIFO) principle. Combining the flexibility of linked lists with the functionality of queues can lead to efficient and dynamic data handling. This article guides you through the implementation of queues using linked lists in NestJS.

Understanding Queues and Linked Lists

Queue Overview:

A queue is a linear data structure where elements are added at one end (rear) and removed from the other end (front). This structure is ideal for scenarios like task scheduling, request handling, and managing asynchronous operations.

Linked List Overview:

A linked list is a collection of nodes where each node contains data and a reference to the next node in the sequence. Linked lists allow for efficient insertions and deletions without the need for contiguous memory.

Combining these two, we can create a queue that efficiently handles dynamic data with minimal overhead.

Implementing the Queue Using Linked Lists

Node Class Each node in the linked list will contain data and a reference to the next node.

export class ListNode {
  constructor(
    public data: any,
    public next: ListNode | null = null,
  ) {}
}

Queue Class: The queue class manages the nodes, ensuring elements are enqueued at the rear and dequeued from the front.

export class LinkedListQueue {
  private head: ListNode | null = null;
  private tail: ListNode | null = null;

  enqueue(data: any): void {
    const newNode: ListNode = new ListNode(data);
    if (!this.tail) {
      this.head = this.tail = newNode;
    } else {
      this.tail.next = newNode;
      this.tail = newNode;
    }
  }

  dequeue(): null | any {
    if (!this.head) return null;
    const data = this.head.data;
    this.head = this.head.next;
    if (!this.head) this.tail = null;
    return data;
  }

  isEmpty(): boolean {
    return this.head === null;
  }

  front(): null | any {
    return this.head ? this.head.data : null;
  }

  print(): void {
    let current: ListNode = this.head;
    while (current) {
      console.log(current.data);
      current = current.next;
    }
  }
}

NestJS Service: Encapsulate the queue operations within a NestJS service.

@Injectable()
export class QueueService {
  private queue: LinkedListQueue = new LinkedListQueue();

  enqueueElement(data: any): void {
    this.queue.enqueue(data);
  }

  dequeueElement(): any {
    return this.queue.dequeue();
  }

  isQueueEmpty(): boolean {
    return this.queue.isEmpty();
  }

  getFrontElement(): any {
    return this.queue.front();
  }

  printQueue(): void {
    this.queue.print();
  }
}

Controller Integration

Create a controller to expose the queue operations through API endpoints.
I used swagger for testing the endpoints, you need to install swagger if you want to do the same.

@Controller('queue')
@ApiTags('Queue')
export class QueueController {
  constructor(private readonly queueService: QueueService) {}

  @Post('enqueue/:data')
  @ApiParam({ name: 'data', type: 'string' })
  enqueueElement(@Param('data') data: string) {
    this.queueService.enqueueElement(data);
    return { message: 'Element enqueued successfully' };
  }

  @Delete('dequeue')
  dequeueElement() {
    const data = this.queueService.dequeueElement();
    return { data };
  }

  @Get('is-empty')
  isQueueEmpty() {
    return { isEmpty: this.queueService.isQueueEmpty() };
  }

  @Get('front')
  getFrontElement() {
    const data = this.queueService.getFrontElement();
    return { data };
  }

  @Get()
  printQueue() {
    this.queueService.printQueue();
    return { message: 'Queue printed successfully' };
  }
}

Optimizing Queue Operations

Time Complexity:

Enqueue: O(1) – Adding an element to the tail.
Dequeue: O(1) – Removing an element from the head.
Front: O(1) – Accessing the front element.
IsEmpty: O(1) – Checking if the queue is empty.

Use Cases:

Task scheduling systems.
Managing asynchronous operations in web applications. ...and many more.

Conclusion

Implementing queues using linked lists in NestJS provides a dynamic and efficient way to manage data. By encapsulating queue operations within services and exposing them through controllers, you can create robust solutions for various real-world scenarios. Experiment with these implementations to enhance your NestJS applications' performance and scalability.

My way is not the only way!

Efficient Implementation of Linked Lists in NestJS

Ezile Mdodana — Fri, 12 Jul 2024 16:56:21 +0000

Introduction

NestJS, a progressive Node.js framework, offers a robust platform for building efficient and scalable server-side applications. Understanding and implementing efficient data structures can significantly improve the performance and maintainability of your applications. This article focuses on linked lists, specifically Single Linked List(SLL), a fundamental data structure, and how to effectively use them in NestJS.

Understanding Linked Lists

Overview:

A linked list is a linear data structure where each element (node) contains a reference (link) to the next element in the sequence. Unlike arrays, linked lists do not require contiguous memory locations, making them efficient for insertions and deletions.

Types of Linked Lists:

Singly Linked List: Each node points to the next node.
Doubly Linked List: Each node points to both the next and the previous nodes.
Circular Linked List: The last node points back to the first node, forming a circle.

Implementing a Singly Linked List in NestJS

Node Class: Each node in a linked list contains data and a reference to the next node.

export class ListNode {
  constructor(
    public data: any,
    public next: ListNode | null = null,
  ) {}
}

Linked List Class: The linked list class manages the nodes and provides methods for common operations.

export class LinkedList {
  private head: ListNode | null = null;

  add(data: any): void {
    const newNode: ListNode = new ListNode(data);
    if (!this.head) {
      this.head = newNode;
    } else {
      let current: ListNode = this.head;
      while (current.next) {
        current = current.next;
      }
      current.next = newNode;
    }
  }

  remove(data: any): void {
    if (!this.head) {
      return;
    }

    if (this.head.data === data) {
      this.head = this.head.next;
      return;
    }

    let current: ListNode = this.head;
    while (current.next && current.next.data !== data) {
      current = current.next;
    }

    if (current.next) {
      current.next = current.next.next;
    }
  }

  find(data: any): ListNode | null {
    let current: ListNode = this.head;
    while (current && current.data !== data) {
      current = current.next;
    }
    return current;
  }

  print(): void {
    let current: ListNode = this.head;
    while (current) {
      console.log(current.data);
      current = current.next;
    }
  }
}

NestJS Service: Integrate the linked list into a NestJS service to encapsulate its operations.

@Injectable()
export class LinkedListService {
  private linkedList: LinkedList = new LinkedList();

  addElement(data: any): void {
    this.linkedList.add(data);
  }

  removeElement(data: any): void {
    this.linkedList.remove(data);
  }

  findElement(data: any): ListNode {
    return this.linkedList.find(data);
  }

  getElements(): void {
    return this.linkedList.print();
  }
}

Controller Integration

Create a controller to expose the linked list operations through API endpoints.

@Controller('linked-list')
export class LinkedListController {
  constructor(private readonly linkedListService: LinkedListService) {}

  @Post('add')
  addElement(@Body('data') data: any) {
    this.linkedListService.addElement(data);
    return { message: 'Element added successfully' };
  }

  @Delete('remove')
  removeElement(@Body('data') data: any) {
    this.linkedListService.removeElement(data);
    return { message: 'Element removed successfully' };
  }

  @Get('find')
  findElement(@Body('data') data: any) {
    const element = this.linkedListService.findElement(data);
    return { element };
  }

  @Get()
  getElements() {
    this.linkedListService.getElements();
    return { message: 'Elements printed successfully' };
  }
}

Optimizing Linked Lists

Time Complexity:
- Insertion: O(1) if inserting at the head; O(n) if inserting at the tail.
- Deletion: O(1) if deleting the head; O(n) if deleting another node.
- Search: O(n).

Use Cases:

Use linked lists for scenarios where frequent insertions and deletions are required.
Suitable for implementing queues, stacks, and other dynamic data structures.

Conclusion

Understanding and implementing linked lists in NestJS can greatly enhance the performance and scalability of your applications. By integrating linked lists into NestJS services and controllers, you can create robust and efficient solutions for various use cases. Experiment with these implementations in your projects to see the benefits firsthand.

My way is not the only way!

Middleware and Interceptors in NestJS: Best Practices

Ezile Mdodana — Fri, 14 Jun 2024 10:04:12 +0000

NestJS is a progressive Node.js framework for building efficient and scalable server-side applications. Among its many powerful features, middleware and interceptors stand out as essential tools for handling cross-cutting concerns in a clean and reusable manner. In this article, we'll explore the concepts of middleware and interceptors, their use cases, and best practices for implementing them in your NestJS applications.

Middleware in NestJS

What is Middleware?

Middleware functions are functions that have access to the request and response objects, and the next middleware function in the application's request-response cycle. Middleware can perform a variety of tasks, such as logging, authentication, parsing, and more.

Creating Middleware

In NestJS, middleware can be created as either a function or a class implementing the NestMiddleware interface. Here’s an example of both approaches:

Function-based Middleware

import { Request, Response, NextFunction } from 'express';

export function logger(req: Request, res: Response, next: NextFunction) {
  console.log(`Request...`);
  next();
}

Class-based Middleware

import { Injectable, NestMiddleware } from '@nestjs/common';
import { Request, Response, NextFunction } from 'express';

@Injectable()
export class LoggerMiddleware implements NestMiddleware {
  use(req: Request, res: Response, next: NextFunction) {
    console.log('Request...');
    next();
  }
}

Applying Middleware

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { logger } from './common/middleware/logger.middleware';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.use(logger);
  await app.listen(3000);
}
bootstrap();

To apply middleware to specific routes, use the configure method in a module:

import { Module, NestModule, MiddlewareConsumer } from '@nestjs/common';
import { LoggerMiddleware } from './common/middleware/logger.middleware';
import { CatsController } from './cats/cats.controller';

@Module({
  controllers: [CatsController],
})
export class CatsModule implements NestModule {
  configure(consumer: MiddlewareConsumer) {
    consumer
      .apply(LoggerMiddleware)
      .forRoutes(CatsController);
  }
}

Use Cases for Middleware

Logging: Log requests for debugging and analytics.
Authentication: Check if a user is authenticated before proceeding.
Request Parsing: Parse incoming request bodies (e.g., JSON, URL-encoded).

Interceptors in NestJS

What is an Interceptor?

Interceptors are used to perform actions before and after the execution of route handlers. They can transform request/response data, handle logging, or modify the function execution flow.

Creating Interceptors

Interceptors are implemented using the NestInterceptor interface and the @Injectable decorator. Here’s an example of a basic interceptor:

import {
  Injectable,
  NestInterceptor,
  ExecutionContext,
  CallHandler,
} from '@nestjs/common';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

@Injectable()
export class TransformInterceptor<T> implements NestInterceptor<T, any> {
  intercept(
    context: ExecutionContext,
    next: CallHandler,
  ): Observable<any> {
    return next
      .handle()
      .pipe(map(data => ({ data })));
  }
}

Applying Interceptors

Interceptors can be applied globally, at the controller level, or at the route handler level.

Global Interceptors

To apply an interceptor globally, use the useGlobalInterceptors method in the main.ts file:

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { TransformInterceptor } from './common/interceptors/transform.interceptor';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalInterceptors(new TransformInterceptor());
  await app.listen(3000);
}
bootstrap();

Controller-level Interceptors

To apply an interceptor at the controller level, use the @UseInterceptors decorator:

import { Controller, Get, UseInterceptors } from '@nestjs/common';
import { TransformInterceptor } from './common/interceptors/transform.interceptor';

@Controller('cats')
@UseInterceptors(TransformInterceptor)
export class CatsController {
  @Get()
  findAll() {
    return { message: 'This action returns all cats' };
  }
}

Route-level Interceptors

To apply an interceptor at the route handler level, use the @UseInterceptors decorator directly on the method:

import { Controller, Get, UseInterceptors } from '@nestjs/common';
import { TransformInterceptor } from './common/interceptors/transform.interceptor';

@Controller('cats')
export class CatsController {
  @Get()
  @UseInterceptors(TransformInterceptor)
  findAll() {
    return { message: 'This action returns all cats' };
  }
}

Use Cases for Interceptors

Response Transformation: Modify response data before sending it to the client.
Logging: Log method execution time and other details.
Exception Mapping: Transform exceptions into user-friendly error messages.
Caching: Implement caching mechanisms for repeated requests.

Best Practices

Keep Middleware Lightweight: Middleware should be focused on tasks that need to be performed on every request, such as logging or authentication. Avoid heavy processing in middleware.
Use Interceptors for Transformation: Use interceptors for transforming request and response data, logging execution time, and handling errors.
Modularize Middleware and Interceptors: Create separate files and directories for middleware and interceptors to keep the codebase organized.
Leverage Dependency Injection: Use NestJS's dependency injection system to inject services into middleware and interceptors.
Avoid Redundant Code: Use global middleware and interceptors for tasks that need to be applied across the entire application, and use route-specific ones for more granular control.

Conclusion

Middleware and interceptors are powerful tools in NestJS that help you handle cross-cutting concerns effectively. By following best practices and understanding their use cases, you can create more maintainable and scalable NestJS applications. Whether you're logging requests, handling authentication, transforming responses, or caching data, middleware and interceptors provide the flexibility and control needed to build robust applications.

My way is not the only way!

Recursion

Ezile Mdodana — Thu, 13 Jun 2024 06:11:53 +0000

This is a submission for DEV Computer Science Challenge v24.06.12: One Byte Explainer.

Explainer

A programming technique where a function calls itself to solve a problem. It breaks down complex problems into simpler ones. Crucial for tasks like tree traversal and solving puzzles (e.g., Fibonacci sequence). Helps write clean, concise code but can risk infinite loops if not handled correctly.

Additional Context

Fundamental Concept: Recursion is a fundamental concept in computer science, used across various domains from algorithms to problem-solving techniques.
Practical Applications: It's widely used in sorting algorithms (like quicksort and mergesort), data structures (like trees and graphs), and problem-solving (like backtracking and dynamic programming).
Educational Value: Understanding recursion is essential for learning more advanced concepts in computer science, making it a pivotal topic for both students and professionals.
Balance of Simplicity and Power: While recursion simplifies code and reduces redundancy, it also requires careful handling to avoid issues like infinite recursion and stack overflow.
Common Misconceptions: Many beginners struggle with recursion, so a clear and concise explanation can demystify the concept and highlight its importance and utility in a way that's approachable and informative.

Real-time Applications with NestJS and WebSockets

Ezile Mdodana — Mon, 10 Jun 2024 19:10:48 +0000

Real-time applications have become an integral part of modern web development, enabling instant communication and dynamic interactions. NestJS, with its powerful framework and support for WebSockets, makes it easy to build such applications. In this article, we'll explore how to create real-time applications with NestJS and WebSockets, covering key concepts, implementation steps, and best practices.

Why Use WebSockets?

WebSockets provide a full-duplex communication channel over a single TCP connection, allowing real-time data exchange between the client and server. Unlike traditional HTTP requests, WebSockets maintain an open connection, enabling instant updates without the need for polling.

Setting Up a NestJS Project

First, create a new NestJS project:

nest new real-time-app

Navigate to the project directory:

cd real-time-app

Installing WebSocket Dependencies

NestJS provides a WebSocket module out of the box. Install the necessary package:

npm install @nestjs/websockets @nestjs/platform-socket.io

Creating a WebSocket Gateway

A gateway in NestJS acts as a controller for WebSocket events. Create a new gateway using the NestJS CLI:

nest generate gateway chat

This will create a new chat.gateway.ts file. Let's define our gateway to handle real-time chat messages:

import {
  SubscribeMessage,
  WebSocketGateway,
  OnGatewayInit,
  OnGatewayConnection,
  OnGatewayDisconnect,
  WebSocketServer,
} from '@nestjs/websockets';
import { Logger } from '@nestjs/common';
import { Socket, Server } from 'socket.io';

@WebSocketGateway()
export class ChatGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer() server: Server;
  private logger: Logger = new Logger('ChatGateway');

  @SubscribeMessage('message')
  handleMessage(client: Socket, payload: string): void {
    this.server.emit('message', payload);
  }

  afterInit(server: Server) {
    this.logger.log('Init');
  }

  handleConnection(client: Socket, ...args: any[]) {
    this.logger.log(`Client connected: ${client.id}`);
  }

  handleDisconnect(client: Socket) {
    this.logger.log(`Client disconnected: ${client.id}`);
  }
}

Explanation

@WebSocketGateway(): Decorator to mark the class as a WebSocket gateway
@WebSocketServer(): Decorator to inject the WebSocket server instance
handleMessage(): Method to handle incoming messages and broadcast them to all connected clients
afterInit(): Lifecycle hook called after the gateway is initialized
handleConnection(): Lifecycle hook called when a client connects
handleDisconnect(): Lifecycle hook called when a client disconnects

Handling Events on the Client-Side

To handle WebSocket events on the client side, you can use the socket.io-client library. Install it using:

npm install socket.io-client

Here’s an example of a simple client-side implementation in an HTML file:

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Chat App</title>
  <script src="https://cdn.socket.io/4.0.1/socket.io.min.js"></script>
  <script>
    document.addEventListener('DOMContentLoaded', () => {
      const socket = io('http://localhost:3000');

      const form = document.getElementById('form');
      const input = document.getElementById('input');
      const messages = document.getElementById('messages');

      form.addEventListener('submit', (e) => {
        e.preventDefault();
        if (input.value) {
          socket.emit('message', input.value);
          input.value = '';
        }
      });

      socket.on('message', (message) => {
        const item = document.createElement('li');
        item.textContent = message;
        messages.appendChild(item);
      });
    });
  </script>
</head>
<body>
  <ul id="messages"></ul>
  <form id="form" action="">
    <input id="input" autocomplete="off" /><button>Send</button>
  </form>
</body>
</html>

Explanation

Socket.IO: The socket.io-client library is used to handle WebSocket connections
Connecting to the Server: io('http://localhost:3000') establishes a connection to the WebSocket server
Sending Messages: The form submission event sends messages to the server using socket.emit('message', input.value)
Receiving Messages: The socket.on('message') event handler updates the DOM with new messages

Best Practices

Authentication and Authorization: Ensure that WebSocket connections are authenticated and authorized. Use middlewares or guards to secure your WebSocket endpoints
Error Handling: Implement proper error handling for your WebSocket events to ensure robustness
Scalability: Use tools like Redis for pub/sub patterns if you need to scale your WebSocket server
Monitoring and Logging: Integrate monitoring tools to keep track of WebSocket connections and events

Conclusion

Building real-time applications with NestJS and WebSockets is straightforward and efficient. By leveraging NestJS's WebSocket module, you can create highly interactive and responsive applications. Follow best practices for authentication, error handling, and scalability to ensure your real-time application is robust and secure.

My way is not the only way!

Event-Driven Architecture with NestJS: Using the EventEmitter Module

Ezile Mdodana — Sat, 08 Jun 2024 12:58:34 +0000

In today's software development landscape, building scalable and maintainable applications is a primary concern for developers. Event-driven architecture (EDA) is a powerful design pattern that helps address these concerns by promoting decoupled and asynchronous communication between different parts of a system. NestJS, a progressive Node.js framework, provides robust support for EDA through its EventEmitter module. This article explores the benefits of EDA and demonstrates how to implement it using the EventEmitter module in a NestJS application.

Understanding Event-Driven Architecture

Event-driven architecture is a design paradigm in which system components communicate by producing and consuming events. An event is a significant change in state, such as a user action or system occurrence. This architecture consists of three main components:

Event Producers: Generate events when certain actions or changes occur.
Event Consumers: Listen for and react to specific events.
Event Channels: Transport events from producers to consumers.

EDA offers several benefits:

Decoupling: Components are loosely coupled, reducing dependencies and making the system more modular and maintainable.
Scalability: Asynchronous event handling allows the system to scale more effectively.
Responsiveness: Real-time event processing leads to more responsive applications.

NestJS and the EventEmitter Module

NestJS is a framework that leverages TypeScript to build efficient and scalable server-side applications. It incorporates many design patterns and best practices from Angular, providing a structured way to develop applications. One of the key features of NestJS is its support for event-driven programming through the EventEmitter module.

The EventEmitter module in NestJS is built on top of the Node.js events module, offering a simple yet powerful way to implement EDA. It allows you to define events, emit them from various parts of your application, and handle them with dedicated listeners.

Setting Up a NestJS Application

Before diving into the implementation, let's set up a basic NestJS application. If you haven't already, install the Nest CLI globally:

npm install -g @nestjs/cli

Create a new NestJS project:

nest new event-driven-app
cd event-driven-app

Install the EventEmitter module:

npm install @nestjs/event-emitter

Implementing Event-Driven Architecture

Defining Events

First, define the events your application will use. Create a events directory in the src folder, and within it, create an events.ts file:

// src/events/events.ts

export class UserCreatedEvent {
  constructor(public readonly userId: string, public readonly username: string) {}
}

Emitting Events

Next, emit events from appropriate parts of your application. For demonstration purposes, let's assume we have a UserService that creates users and emits a UserCreatedEvent when a new user is created.

Create a user directory in the src folder, and within it, create user.service.ts:

// src/user/user.service.ts

import { Injectable } from '@nestjs/common';
import { EventEmitter2 } from '@nestjs/event-emitter';
import { UserCreatedEvent } from '../events/events';

@Injectable()
export class UserService {
  constructor(private eventEmitter: EventEmitter2) {}

  createUser(userId: string, username: string): void {
    // Logic to create a user (e.g., saving to a database)

    // Emit UserCreatedEvent
    const event = new UserCreatedEvent(userId, username);
    this.eventEmitter.emit('user.created', event);
  }
}

Handling Events

Now, create an event listener to handle the UserCreatedEvent. Create a listeners directory in the src folder, and within it, create user-created.listener.ts:

// src/listeners/user-created.listener.ts

import { Injectable } from '@nestjs/common';
import { OnEvent } from '@nestjs/event-emitter';
import { UserCreatedEvent } from '../events/events';

@Injectable()
export class UserCreatedListener {
  @OnEvent('user.created')
  handleUserCreatedEvent(event: UserCreatedEvent) {
    // Logic to handle the event (e.g., sending a welcome email)
    console.log(`User created: ${event.userId} (${event.username})`);
  }
}

Registering the Listener

Finally, register the event listener in your application's module. Open app.module.ts and update it as follows:

// src/app.module.ts

import { Module } from '@nestjs/common';
import { EventEmitterModule } from '@nestjs/event-emitter';
import { UserService } from './user/user.service';
import { UserCreatedListener } from './listeners/user-created.listener';

@Module({
  imports: [
    EventEmitterModule.forRoot(),
  ],
  providers: [UserService, UserCreatedListener],
})
export class AppModule {}

Running the Application

With everything set up, you can now run your NestJS application:

npm run start:dev

Test the event-driven functionality by creating a user through the UserService:

// src/main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { UserService } from './user/user.service';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  const userService = app.get(UserService);

  userService.createUser('1', 'Test User');

  await app.listen(3000);
}
bootstrap();

Upon running the application, you should see the following output, indicating that the UserCreatedEvent was emitted and handled:

User created: 1 (Test User)

Conclusion

Event-driven architecture is a powerful approach for building scalable, maintainable, and responsive applications. NestJS's EventEmitter module makes it easy to implement EDA by providing a simple yet effective way to define, emit, and handle events. By following the steps outlined in this article, you can start leveraging the benefits of EDA in your NestJS applications, leading to more modular and efficient codebases.

My way is not the only way!

Deploying NestJS Apps to Heroku: A Comprehensive Guide

Ezile Mdodana — Fri, 07 Jun 2024 08:26:35 +0000

Deploying a NestJS application to Heroku can be a straightforward process if you follow the right steps. In this guide, we'll walk you through the entire process, from setting up your NestJS application to deploying it on Heroku and handling any dependencies or configurations.

Step 1: Setting Up Your NestJS Application

Before deploying, ensure you have a NestJS application ready. If you don't have one, you can create a new NestJS project using the Nest CLI.

1. Install Nest CLI:

npm install -g @nestjs/cli

2. Create a New Project:

nest new my-nestjs-app
cd my-nestjs-app

3. Run the Application Locally:

npm run start:dev

Step 2: Prepare Your Application for Heroku

Heroku requires a few specific configurations to properly deploy a Node.js application.
Let's go through these configurations step by step.

1. Create a Procfile:

In the root of your project, create a file named Procfile and add the following line:

web: npm run start:prod

This tells Heroku to start your application using the production build.
NB: The name of the file should be Procfile, nothing more nothing less, if the case is different from this, heroku won't recognize the file.

2.Update package.json:
Ensure your package.json has the following scripts:

"scripts": {
  "start": "nest start",
  "start:dev": "nest start --watch",
  "start:prod": "node dist/main.js",
  "build": "nest build"
}

Additionally, add the following configuration to ensure your app runs on the correct port:

"engines": {
  "node": ">=14.0.0"
}

Depending on the node version you are using for your application.

Step 3: Initialize a Git Repository

Heroku uses Git for deployments. Initialize a Git repository if you don't have one already.

1.Initialize Git:

git init
git add .
git commit -m "Initial commit"

Step 4: Deploy to Heroku
Now, let's deploy your application to Heroku.

1. Login to Heroku:
Let's use the Heroku CLI to login, run the command on your project directory.

heroku login

This command will open a browser and require your login credentials, populate and complete 2FA, if enabled. The come back to the CLI.

2. Create a New Heroku Application:

heroku create my-nestjs-app

3. Deploy Your Application:

git push heroku master

Step 5: Handle Environment Variables

Heroku allows you to manage environment variables through its dashboard or CLI, let's manage a few via the CLI.

1. Set Environment Variables:

heroku config:set NODE_ENV=production

If you have other environment variables, set them as well:

heroku config:set DATABASE_URL=your_database_url

Step 6: Verify Your Deployment

1. Open Your Application:

heroku open

You can open the application from the Heroku dashboard as well.

2. Check Logs:

If you encounter any issues, check the logs with:

heroku logs --tail

Conclusion

Deploying a NestJS application to Heroku is a straightforward process if you follow these steps. By preparing your application properly and using Heroku's powerful features, you can have your NestJS app running in the cloud in no time. Whether you're deploying a simple API or a complex application with multiple dependencies, Heroku provides a robust platform for managing your applications. Happy coding!

My way is not the only way!

Best Practices for Building Microservices with NestJS

Ezile Mdodana — Thu, 06 Jun 2024 06:57:49 +0000

Microservices architecture has become a popular approach for developing scalable and maintainable applications. NestJS, a progressive Node.js framework, offers robust support for building microservices with its modular architecture and powerful features. In this article, we'll explore best practices for building microservices with NestJS, providing clear details and examples to help you implement these practices effectively.

1. Design Microservices with a Clear Domain

Best Practice
Start by defining the boundaries of each microservice based on the business domains. Each microservice should have a single responsibility and encapsulate a specific business capability.

Example
Suppose we are building an e-commerce platform. We can define the following microservices:

User Service: Handles user authentication, registration, and profile management.
Product Service: Manages product listings, inventory, and pricing.
Order Service: Processes customer orders and handles payment transactions.

By designing microservices around specific business domains, we ensure better scalability and maintainability.

2. Use a Consistent Communication Protocol

Best Practice

Choose a consistent communication protocol for inter-service communication. Common protocols include HTTP, gRPC, and message brokers like RabbitMQ or Kafka. NestJS supports various communication strategies, allowing you to choose the one that best fits your needs.

Example

Using RabbitMQ for event-driven communication between microservices:

// user.service.ts
import { Controller } from '@nestjs/common';
import { EventPattern } from '@nestjs/microservices';

@Controller()
export class UserService {
  @EventPattern('user_created')
  handleUserCreated(data: any) {
    console.log('User created event received:', data);
    // Process the event
  }
}

// product.service.ts
import { Controller } from '@nestjs/common';
import { ClientProxy, ClientProxyFactory, Transport } from '@nestjs/microservices';

@Controller()
export class ProductService {
  private client: ClientProxy;

  constructor() {
    this.client = ClientProxyFactory.create({
      transport: Transport.RMQ,
      options: {
        urls: ['amqp://localhost:5672'],
        queue: 'product_queue',
      },
    });
  }

  createProduct(product: any) {
    // Create product logic
    this.client.emit('product_created', product);
  }
}

3. Implement API Gateways

Best Practice

Use an API gateway to aggregate multiple microservice endpoints into a single entry point. This simplifies client interactions and allows for better management of cross-cutting concerns like authentication, rate limiting, and logging.

Example

Creating an API gateway with NestJS:

import { Module } from '@nestjs/common';
import { ClientsModule, Transport } from '@nestjs/microservices';

@Module({
  imports: [
    ClientsModule.register([
      { name: 'USER_SERVICE', transport: Transport.RMQ, options: { urls: ['amqp://localhost:5672'], queue: 'user_queue' } },
      { name: 'PRODUCT_SERVICE', transport: Transport.RMQ, options: { urls: ['amqp://localhost:5672'], queue: 'product_queue' } },
    ]),
  ],
})
export class ApiGatewayModule {}

4. Implement Robust Error Handling

Best Practice

Implement consistent and robust error handling mechanisms across all microservices. This includes handling exceptions, retries, and fallback mechanisms.

Example

Using an exception filter in NestJS:

import { ExceptionFilter, Catch, ArgumentsHost, HttpException } from '@nestjs/common';

@Catch(HttpException)
export class HttpErrorFilter implements ExceptionFilter {
  catch(exception: HttpException, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse();
    const status = exception.getStatus();

    const errorResponse = {
      statusCode: status,
      timestamp: new Date().toISOString(),
      path: ctx.getRequest().url,
    };

    response.status(status).json(errorResponse);
  }
}

// In your main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { HttpErrorFilter } from './common/filters/http-error.filter';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.useGlobalFilters(new HttpErrorFilter());
  await app.listen(3000);
}
bootstrap();

5. Secure Microservices

Best Practice

Implement security best practices to protect your microservices. This includes using TLS/SSL, API keys, OAuth, and JWT for authentication and authorization.

Example

Securing an endpoint with JWT in NestJS:

// auth.module.ts

import { Module } from '@nestjs/common';
import { JwtModule } from '@nestjs/jwt';
import { PassportModule } from '@nestjs/passport';
import { JwtStrategy } from './jwt.strategy';

@Module({
  imports: [
    PassportModule.register({ defaultStrategy: 'jwt' }),
    JwtModule.register({
      secret: 'secretKey',
      signOptions: { expiresIn: '60s' },
    }),
  ],
  providers: [JwtStrategy],
  exports: [PassportModule, JwtModule],
})
export class AuthModule {}

// jwt.strategy.ts
import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { ExtractJwt, Strategy } from 'passport-jwt';

@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor() {
    super({
      jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
      secretOrKey: 'secretKey',
    });
  }

  async validate(payload: any) {
    return { userId: payload.sub, username: payload.username };
  }
}

// In your controller
import { Controller, Get, UseGuards } from '@nestjs/common';
import { AuthGuard } from '@nestjs/passport';

@Controller('protected')
export class ProtectedController {
  @Get()
  @UseGuards(AuthGuard('jwt'))
  getProtectedResource() {
    return 'This is a protected resource';
  }
}

6. Implement Health Checks and Monitoring

Best Practice

Implement health checks and monitoring to ensure the availability and performance of your microservices. Use tools like Prometheus, Grafana, or NestJS built-in health checks.

Example

Adding a health check endpoint in NestJS:

import { Module } from '@nestjs/common';
import { TerminusModule } from '@nestjs/terminus';
import { TypeOrmModule } from '@nestjs/typeorm';
import { HealthController } from './health.controller';

@Module({
  imports: [TerminusModule, TypeOrmModule.forRoot()],
  controllers: [HealthController],
})
export class AppModule {}

// health.controller.ts
import { Controller, Get } from '@nestjs/common';
import { HealthCheck, HealthCheckService, TypeOrmHealthIndicator } from '@nestjs/terminus';

@Controller('health')
export class HealthController {
  constructor(
    private health: HealthCheckService,
    private db: TypeOrmHealthIndicator,
  ) {}

  @Get()
  @HealthCheck()
  check() {
    return this.health.check([
      async () => this.db.pingCheck('database'),
    ]);
  }
}

7. Use CI/CD for Continuous Deployment

Best Practice

Implement continuous integration and continuous deployment (CI/CD) pipelines to automate the testing, building, and deployment of your microservices. Use tools like GitHub Actions, Jenkins, or GitLab CI/CD.

Conclusion

Building microservices with NestJS offers a powerful and flexible approach to developing scalable and maintainable applications. By following these best practices, you can ensure your microservices are well-designed, secure, and resilient. Embrace the modular architecture of NestJS, leverage its rich ecosystem, and implement robust communication and error-handling strategies to create a successful microservices-based system.

My way is not the only way!

Animated Spinner - React Native

Ezile Mdodana — Tue, 21 Mar 2023 12:36:26 +0000

Most of the times in Mobile Development, you might want to have an interactive spinner/activity indicator. In this short article we are going to demonstrate how we can achieve that to an Expo generated React Native app.

We demonstrate this using Lottie React Native, therefore, you need to install the librabry lottie-react-native by running the command yarn add lottie-react-native.

Now, go to https://lottiefiles.com/, you need to create a free account before you can be able to download animations, here you can search and download the animated activity indicator that you want to use, select to download the Lottie JSON file. Take the JSON file and put it inside your react native project (e.g assets/animation.json).

Now, you can create a shared component that you will use throughout your project, or wherever you want to use it. Let's have a look at the example of such component below:

import React from 'react';
import Lottie from 'lottie-react-native';

const LoadingComponent = () => {
   return(
       <Lottie source={require('../src/assets/animation.json')} autoPlay loop />
    );
};
export default LoadingComponent;

Here, we are importing Lottie from 'lottie-react-native', a library that we installed, the component returns and animation which is created from the JSON file we downloaded from https://lottiefiles.com/. Notice, what we return on the component has autoPlay and loop, autoPlay is for making the animation play automatically, and loop is for the animation to continue playing, while rendered.

You can always modify or play around these on the React useEffect, give the animation the behavior you want based on some conditions.

You now have an animated activity indicator on your app.

Thank you very much for reading.🤓😎

Suspense for Data Fetching - React

Ezile Mdodana — Sun, 19 Mar 2023 07:20:35 +0000

React 16.6 has added a <Suspense> component that lets you wait for some code to load and declaratively specify a loading state (like a spinner) while the data is still being fetched.
_Suspense _lets your components wait for something(data) before they can render.

A common way to fetch data in React apps today is to use an effect, like this:

// In a function component:

useEffect(() => {
  fetchSomething();
}, []);

This approach is called fetch-on-render since it does not start fetching until after the component has rendered on screen, this approach normally leads async waterfall.

Let's take a look on a component fetching data with the traditional way, consider the components, and :

function Student() {
  const [student, setStudent] = useState(null);

  useEffect(() => {
    getStudent().then(s => setStudent(s));
  }, []);

  if (student === null) {
    return <p>Loading, please wait...</p>;
  }
  return (
    <>
      <h1>{student.name}</h1>
      <Text>{student.name} Subjects</Text>
      <StudentSubjects />
    </>
  );
}

function StudentSubjects() {
  const [subjects, setSubjects] = useState(null);

  useEffect(() => {
    getStudentSubjects().then(ss => setSubjects(ss));
  }, []);

  if (subjects === null) {
    return <h2>Loading, please wait...</h2>;
  }
  return (
    <ul>
      {subjects.map(subject => (
        <li key={subject.id}>{subject.name}</li>
      ))}
    </ul>
  );
}

What's happening here is:

We start fetching a student
We wait…
We finish fetching student
We start fetching student subjects
We wait…
We finish fetching student subjects

If fetching a student takes three seconds, we’ll only start fetching the student subjects after three seconds! Remember our old friend, waterfall? That’s a waterfall right there: an unintentional sequence that should have been parallelized.

Waterfalls are common in code that fetches data on render. They’re possible to solve, but as the product grows, many people prefer to use a solution that guards against this problem.

Now, let's see how we can improve this by using :

// This is not a Promise. It's a special object from the Suspense integration.
const resource = fetchProfileData();

function StudentDetails() {
  return (
    <Suspense fallback={<h1>Loading student...</h1>}>
      <Student />
      <Suspense fallback={<h1>Loading student subjects...</h1>}>
        <StudentSubjects/>
      </Suspense>
    </Suspense>
  );
}

function Student() {
  // Try to read student info, although it might not have loaded yet
  const student = resource.student.read();
  return <h1>{student.name}</h1>;
}

function StudentSubjects() {
  // attempt to read student subjects, although they might not have loaded yet
  const subjects = resource.subjects.read();
  return (
    <ul>
      {subjects.map(subject => (
        <li key={subject.id}>{subject.name}</li>
      ))}
    </ul>
  );
}

With Suspense, here's what happens:

Start fetching
Start rendering
Finish fetching

In the traditional approach here's what was happening:

Start fetching
Finish fetching
Start rendering We fetched data before we called setState.

With Suspense, we don’t wait for the response to come back before we start rendering on screen. We start rendering immediately after kicking off the network request.

On the Suspense component, the fallback is basically what is displayed while still loading, a spinner, maybe.

Thank you very much for reading.
Happy coding!🤓😎