DEV Community: Ravi Yasas

NestJS Best Practices for Developers

Ravi Yasas — Fri, 28 Mar 2025 04:01:41 +0000

My Spring Boot Best Practices for Developers article has become one of the most viewed in my articles. It offers valuable insights on how to effectively work with Spring Boot, covering tips, techniques, and strategies that can help developers write cleaner, more efficient code.

I also tackled a trending debate in the developer community with my article Which is the Best: NestJS or Spring Boot? With NestJS gaining significant popularity as a backend framework, I compared it to Spring Boot, weighing the pros and cons of each, and helping developers choose the right framework based on their project requirements.

In this article, I will discuss some tips when you work with the NestJS framework.

Use the Modular architecture

NestJS stands out for its modular architecture. It’s a great idea to structure your code into modules based on specific features or domains, such as users, authentication, or products. Each module should handle its own controllers, services, and DTOs (Data Transfer Objects). This approach helps keep your code organized, clean, and easy to maintain.

Stick to the MVC flow

Using the MVC pattern in NestJS helps organize your application efficiently, especially for larger applications. By following this pattern, you create a clean separation of concerns and improve code organization, which makes the application more scalable and maintainable.

Keep controllers focused on HTTP logic, delegate business logic to services, and use models for data structures.

Use DTOs properly for validations

You can use class-validator and class-transformer to validate incoming requests. This will make your code clean. It’s recommended that DTOs be used to define request payloads and pass them through the ValidationPipe for validation.

import { IsString, IsInt, Min, Max, IsOptional, IsEmail } from 'class-validator';

export class CreateUserDto {
  @IsString()
  @IsNotEmpty()
  name: string;

  @IsEmail()
  @IsNotEmpty()
  email: string;

  @IsInt()
  @Min(18)
  @Max(100)
  age: number;

  @IsOptional()
  @IsString()
  @IsNotEmpty()
  address?: string;
}

Use caching (In memory or distributed)

For lightweight apps, you can use in-memory caching, and for large-scale projects, you can go with distributed caching like Redis. Caching will improve performance and scalability

Remember to carefully manage cache invalidation to ensure your data remains accurate and up-to-date.

Take the advantage of Dependency Injection

Just like Spring Boot, NestJS uses dependency inject to make your life easier with decoupling components to make it easy to test and maintain. You can use @Injectable decorator. Unnecessary injections will make circular dependencies and it causes performance issues and memory leaks. Try to avoid them using forwardRef().

import { Injectable } from '@nestjs/common';

@Injectable()
export class UsersService {
  private readonly users = [];

  createUser(name: string, email: string) {
    const user = { name, email };
    this.users.push(user);
    return user;
  }

  getAllUsers() {
    return this.users;
  }
}

import { Controller, Get, Post, Body } from '@nestjs/common';
import { UsersService } from './users.service';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() body: { name: string; email: string }) {
    return this.usersService.createUser(body.name, body.email);
  }

  @Get()
  findAll() {
    return this.usersService.getAllUsers();
  }
}

Use an ORM framework

TypeORM and Prisma are two common ORM frameworks that can be used with NestJS. Compared to Prisma, TypeORM is powerful since it is a fully featured ORM framework with a massive community base.

Exercise caution when implementing Middleware and Interceptors
Every middleware or interceptor introduces some processing overhead. It’s best to use them sparingly and, when possible, combine multiple interceptors into one streamlined and efficient one.

Middleware runs before route handlers and has access to the request/response lifecycle. If you use middleware, you can limit the scope and handle errors.

Interceptors wrap around request handling and can modify input/output. If you use interceptors, keep it lightweight. Always try to avoid overriding the response. It is a common pitfall of using interceptors.

Use Fastify

Fastify is a powerful web framework that is created on top of NodeJS. If your project is a large-scale one, with a large number of concurrent requests, you can use Fastufy as the HTTP server to improve performance.

Use Lazy Loading for Modules

Load modules only when needed to improve startup speed and reduce memory consumption. Here is a sample lazy load module.

import { Module, DynamicModule } from '@nestjs/common';
import { LazyService } from './lazy.service';

@Module({})
export class LazyModule {
  static forRoot(): DynamicModule {
    return {
      module: LazyModule,
      providers: [LazyService], 
      exports: [LazyService], 
    };
  }
}

Optimize your DB queries

Although this isn’t specific to NestJS, I feel it’s important to mention it here.

Well design your database
Use an ORM tool (Optional)
Use indexes
Use pagination

Find more Database optimization tips…

Optimize modules

Remove unnecessary imports, relations, dependencies, and declarations. You can always take advantage of using the asynchronous behavior of NestJS.

I hope you find this article enjoyable, and I’d love to hear your thoughts!

Find the original article

Enjoyed this article? If you found this helpful, consider supporting my work by buying me a coffee! Your support helps me create more content like this. 🚀☕

👉 Buy Me a Coffee ☕☕☕

Introduction to PostGraphile

Ravi Yasas — Wed, 21 Jul 2021 10:24:18 +0000

What is PostGraphile?

If you are familiar with Spring Data JPA, it will be very easy to understand PostGraphile. But never mind. Let's look into it. PostgreSQL DB is one of the very popular DB for high-performance applications. The ProstGraphile works with PostgreSQL database and GraphQL. It provides instant and high-performance GraphQL APIs from the PostgreSQL schema within seconds. It gives a lot more features.

Features of PostGraphile

Stunning performance
Database relations are discovered automatically and automatic CRUD mutations Ex: vehicleById, createVehicle, updateVehicle, deleteVehicle... etc.
Enable query functions like sorting, filtering, pagination... etc.
Very easy to enable and use.
Schema documentation is generated through the CLI
You can directly call PostGraphile endpoints via your client application.

PostGraphile without a middleware service

You may think that we can use PostGraphile without a service. Because PostGraphile provides GraphQL APIs, then a client can directly call those APIs. Yes, this is possible, but if we need some customizations or if we need to request data from any other web services (Ex: REST), we need to have a middleware service like NestJS, Spring Boot...etc. It will look like this.

Install PostGraphile

Hit this command to install PostGraphile globally.

npm install -g postgraphile

PostGraphile CLI interface

My TestDB2 database has only one table called Vehicle. This is my DB structure.

Then I run the following command to get the PostGraphile CLI interface. You can find this from the Postgraohile documentation.

npx postgraphile -c 'postgres://postgres:1234@localhost/TestDB2' --watch --enhance-graphiql --dynamic-json

As you can see my database is TestDB2, my username is postgres and the password is 1234. Once I hit this command in the terminal it will give a few details as mentioned below. There some other CLI options. You can find more details from the official documentation.

If you can go to the http://localhost:5000/graphiql endpoint, you will be able to the PostGraphile CLI interface.

In Explore you can see Query and also you can create Mutations too. This is very similar to the GraphQL playground. All queries and mutations are automatically generated. So you have no worries, just click on the query or mutation and hit the play button to execute the query.

Please check the following video to understand the complete flow of working with PostGraphile.

Learn more about GraphQL, PostGraphile, NestJS and Angular, please visit Java Foundation

The story of OAuth 2.0

Ravi Yasas — Wed, 22 Jul 2020 10:20:54 +0000

This is a brief introduction to OAuth 2.0. You may have already heard terms like authorization, authentication, OAuth, OAuth 2.0, OpenID, OpenID Connect, JWT, SSO...etc. It is just like a mess for beginners. When it comes to security the major points are Authentication and Authorization. Before we learn about these things, let's discuss some basics.

What is the protocol means?

The protocol is just nothing but the official rules and regulations.
It just a set of rules, just explain "how to do it" or "how to implement".

What is authorization?

This is all about permissions and roles you are granted.
The authorization will never expose your identity or your credentials.

What is authentication?

Simply this is all about who you are.
If you are authenticated to a system, it means the system knows who you are.

Login without registration

Can you manage hundreds of usernames and passwords? This is ridiculous. Instead of managing many usernames and passwords, now you can log in via an existing account. It can be Google, Facebook, or any other social media account or any private account.

For example, just think you are going to login to Soundcloud. Look at the following process. You can log in to Soundcloud via your Google account without creating separate accounts in Soundcloud. Once you click on login, you will be able to see a window like below.

If you click "Continue with Google". Then a separate window opens. You can see the URL, it is Google and asked you to enter your email and password. You are not passing your credentials to a third party.

Once you are identified from Google, you are successfully login to Soundcloud. This is very convenient, secure, and easy. Under the hood, it is the process of OAuth2.0

What is OAuth2.0?

OAuth2.0 is an authorization protocol.
It explains how to delegate the authorization.
This works over HTTP
This can be used to authorize applications, servers, devices...etc
The token-based authentication depends on OAuth 2.0 OAuth2.0 will never share your identity or credentials.
Mainly this is used external applications to access any secure content.

Roles of OAuth2.0

Basically, OAuth2.0 describes four roles. Let's compare these roles with our example

Resource owner
This is actually you, it means the owner of the protected resource.
Client
This is the application that requests to access the protected resource.
Here it is soundcloud.com
Resource server
This is the server that hosts protected resources.
Here it is google.com
Authorization server
This server issues access tokens
It can be Google or separate authorization servers Google uses.

OAuth2.0 authorization channels

OAuth2.0 uses a two-way channel process to make sure of a very secure authorization process. According to the situation, we can use the front channel, back channel, or both channels.

Front channel
- This is suitable for pure single-page applications that don't have a backend.
- This is browser-based
Back channel
- This is server-based
- Back channel is not visible to front-end
- You will be able to understand these channels later on in this post. Keep reading.

Authorization flows of OAuth2.0

Authorization code flow (front channel + back channel)
Implicit flow (front channel only)
Resource owner password credentials flow (back channel only)
Client credentials flow (back channel) Mostly we are using Authorization code flow and implicit flow.

OAuth2.0 authorization code flow

In the above diagram, front channel flows are directed in green arrows and back channel flows are directed in dashed green arrows. The back channel process is not visible to the user.

For more info about OAuth 2.0, please visit The story of OAuth 2.0

Builder pattern

Ravi Yasas — Fri, 29 May 2020 16:35:10 +0000

This is another creational design pattern. Just think about the StringBuilder. If you create a StringBuilder object, you can append strings one by one to the same StringBuilder object.

    StringBuilder stringBuilder = new StringBuilder();
    stringBuilder.append("Java").append("Foundation");

This is the functionality of the builder pattern. There are a few ways to implement the builder pattern.

Using constructor

Using inner classes

This is the best approach to implement the builder pattern.

--> Find advantages, disadvantages, usages and more details about the builder pattern

Enable Swagger2 with Spring Boot

Ravi Yasas — Sun, 10 May 2020 18:01:15 +0000

Swagger2 dependencies

Add these dependencies to your pom.xml file

Swagger configuration file

Now you can create the Swagger configuration file

Now you are ready. Your REST controllers are now available on Swagger 2. You can access the Swagger documentation via http://localhost:8090/swagger-ui.html You may change the port with the port your application is running.

You can find the complete code from my GitHub

Vector vs ArrayList vs LinkedList

Ravi Yasas — Sat, 25 Apr 2020 21:16:56 +0000

Here I mentioned all the differences between Vector, ArrayList, and LinkedList.

	Vector	ArrayList	LinkedList
Data structure	Growable array	Dynamic array	Doubly linked list
Increment size	100%	50%	No initial size
Traverse	Uses enumeration	Uses iterator	Uses iterator
Accessibility	Random and fast	Random and fast	Sequential and slow
Order	Insertion order	Insertion order	Insertion order
Duplicates	Allowed	Allowed	Allowed
Insert / Delete	Slow	Slow	Fast
Synchronized	Yes	No	No
Null values	Allowed	Allowed	Allowed

Compile-time polymorphism vs Run-time polymorphism

Ravi Yasas — Sat, 25 Apr 2020 20:43:21 +0000

In this post, you will understand,

What is run-time polymorphism?
What is compile-time polymorphism?
What does it happen in the compile-time & run-time?

Run-time polymorphism

You may look at the following classes.

//Parent class
class Parent {
    public void eat(){
        System.out.println("Parent - eat()");
    }
}

//Child class
class Child extends Parent {

    @Override
    public void eat() {
        System.out.println("Child - eat()");
    }
}

public class OOPDemo {

    public static void main(String args[]){
        Parent obj = new Child();
        obj.eat();
    }
}

In this example, I have created a parent class, child class, and the main class. Then I have created a Child object by Parent reference. Now let's check what happens in the compile-time and run-time.

Compile-time

In compile time it takes care of the Parent reference.
Because objects are created in the run time.
First, it checks is there any eat() method in Parent class.
In this example Parent class has eat() method.
So it doesn't give any exception in the compile-time and compilation will be a success.

Run time

At the run time it takes care of the Child reference and it creates the new child object.
Then it checks is there any eat() method in Child class.
There is an eat() method in Child also.
Then this method will be called at the run time.
It means object creation is happening at the run time by JVM and Run time is responsible to call which eat() method to call.
That is why it is called run-time polymorphism (Dynamic polymorphism)

Compile-time polymorphism

class Animal{

    public void eat(){
        System.out.println("Eat method");
    }

    public void eat(int quantity){
        System.out.println("Eat method with quantity");
    }
}

public class ReferenceDemo {
    public static void main(String args[]){
        Animal animal = new Animal();
        animal.eat();
    }
}

In this case, a single class has the same methods with two different parameters. As you know it is called method overloading.

Compile-time

In compile time it checks animal.eat() method in Animal class.
No arg eat() method is there in the animal class.
According to the parameter list, it will call which method should be called.
Then the compilation is OK.

Run time

At the run time it creates the same Animal type object.
Then it checks the same thing that it did at the compile time.
It means compile time is enough to check which method should be called.
That is why it is called Compile time polymorphism (Static polymorphism).

Final words !

Overriding = run-time polymorphism = dynamic polymorphism
Overloading = compile-time polymorphism = static polymorphism

More info: www.javafoundation.xyz

Java interview coding questions - Part 02

Ravi Yasas — Sat, 25 Apr 2020 20:17:55 +0000

Palindrome check

Reverse a number

Copy an array

Check the longest word

Swap numbers of two integers

Common elements of two arrays

Java interview coding questions - Part 01

Ravi Yasas — Sat, 25 Apr 2020 16:20:37 +0000

How to count words in a String

How to remove duplicates in a String

How to reverse a String

How to add a List to a Map

How to add a List to a Set

How to add a List to an array

How to sort an array

Default methods in Java 8

Ravi Yasas — Sat, 25 Apr 2020 15:25:00 +0000

The problem

interface Automobile{
    void engineStart();
    void engineStop();
}

class Car implements Automobile{
    public void engineStart() { }
    public void engineStop() { }
}

class Bus implements Automobile{
    public void engineStart() { }
    public void engineStop() { }
}

Just think we need to add another method in the interface in the future.
But if we add it, we have to change all other classes which are implemented that interface.

Default methods

To overcome this, default methods are introduced in Java 1.8
The interface segregation principle can be replaced with default methods in Java.
This is the best option to change the existing interfaces without changing implemented classes.
Until Java 1.7 every method inside an interface is always public and abstract.
In 1.8 version default and static methods are also allowed.
In 1.9 version private methods are also allowed.
Default methods can be overridden in implementing class.
Default methods cannot be overridden object class's methods.

The solution using Java 8 default methods

interface Automobile{
    default void m1(){}
}

interface Car{
    default void m1(){}
}

class Mazda3 implements Automobile, Car{
    public void m1() { }
}

In such cases you have to override the default method.
Otherwise Mazda3 class won't be able to find which m1( ) method needs to be called.

Or else you can use it like this also using the "super" keyword.

interface Automobile{
    default void m1(){}
}

interface Car{
    default void m1(){}
}

class Mazda3 implements Automobile, Car{
    public void m1() {
        Automobile.super.m1();    
    }
}

Lambda expressions in Java

Ravi Yasas — Fri, 24 Apr 2020 16:52:35 +0000

What is a lambda expression?

Lambda expression is a function without any signature.
It doesn't have a name, return type, and modifiers.
It can have any number of arguments.
For one argument lambda expressions, parenthesis are optional.
Compiler can understand the data type.
Curly braces are mandatory for many arguments.

Advantages of Lambda expressions

It helps to iterate, filter, and extract data from a collection in a very efficient way.
It saves a lot of code.
Code reuse
Reduce class files

Functional interface

An interface that has only one abstract method.
@FunctionalInterface annotation is used to declare an interface as a functional interface.
Ex: Runnable interface

Lambda expression signature

(argument-list) -> {body}
Ex:

( ) -> { }        
(p1) -> { }        
(p1, p2) -> { }

Rules

public void m1(int a, int b){    
    System.out.println(a+b);
}
    //lambda expressions
( a,b ) -> System.out.println(a+b);

Lambda expression doesn't have a name, a modifier and a return type.
If the code contains only one line. curly braces are optional.
Compiler can guess the return type.

public int square(int n){
    return n*n;
}

//lambda expressions
(int n) -> {return n*n;}
(n) -> {return n*n;}
n -> n*n;

If only one parameter is there, parentheses are optional.
Since it has only one line, curly braces are optional.
Without curly braces, the return type is optional.

Valid statements

Interf i = n -> n*n;
Interf i = (n) -> n*n;
Interf i = n -> {return n*n;};

Invalid statements

Interf i = n -> return n*n;
Interf i = n -> {return n*n};
Interf i = n -> {return n*n;}
Interf i = n -> {n*n;};

Example 01

public void m1(){
    System.out.println("Hello");
}

//lambda expressions
( ) -> System.out.println("Hello");

Example 02

public void add(int a, int b){
    System.out.println(a+b);
}

//lambda expressions
(int a, int b) -> System.out.println(a+b);
(a, b) -> System.out.println(a+b);

Example 03

public int square(int n){
    return n*n;
}

//lambda expressions
(int n) -> {return n*n;}
(n) -> {return n*n;}
n -> n*n;

Hibernate Optimistic locking and Pessimistic locking

Ravi Yasas — Fri, 24 Apr 2020 16:23:44 +0000

Optimistic locking

When two threads are going to update the same data at the same time, conflict can happen.
There are two options to handle this, Versioned and Version-less.

Versioned Optimistic locking

In this case, @version annotation can be used.
@version annotation allows Hibernate to activate the optimistic locking whenever executing an UPDATE and DELETE statements.

@Entity@Table(name = "orders")    
public class Order {
   @Id
   private long id;

   @Version
   private int version;

   private String description;
   private String status;

}

Version-less Optimistic locking

But in this approach, it considers the entity as a whole unit.
If you change two fields at the same time, then It will throw an ObjectOptimisticLockingFailureException.
To handle this we can use simply version-less optimistic locking.
This can be achieved by using @OptimisticzLocking and @DynamicUpdate annotations.

@Entity
@OptimisticLocking(type = OptimisticLockType.DIRTY)
@DynamicUpdate
public class VersionlessProduct {
    @Id
    private UUID id;
    private String name;
    private int stock;
}

Pessimistic locking

This can be implemented by @lock annotation

interface WidgetRepository extends JPARepository<Widget, Long> {

   @Lock(LockModeType.PESSIMISTIC_WRITE)
   Widget findOne(Long id);
}