DEV Community: Sasith Warnaka

🚀 Best ORM for NestJS in 2025: Drizzle ORM vs TypeORM vs Prisma

Sasith Warnaka — Sat, 13 Sep 2025 19:21:26 +0000

When building a NestJS backend, one of the first architectural decisions is:

👉 Which ORM (Object-Relational Mapper) should I use?

The ORM defines how your application talks to the database — directly impacting performance, scalability, and developer experience (DX).

This article compares the three most popular ORMs for NestJS in 2025:

TypeORM – classic, decorator-based ORM
Prisma – modern, schema-first ORM with tooling
Drizzle ORM – lightweight, SQL-first, TypeScript-native

And finally, we’ll decide which one is the best choice for high-performance NestJS projects in 2025.

⚡ TypeORM – The Classic Choice

Pros

Mature and widely used in the NestJS ecosystem
Supports PostgreSQL, MySQL, MariaDB, SQLite, MongoDB
Familiar OOP-style with decorators (@Entity, @Column)
Built-in relations, eager/lazy loading, cascading
Strong NestJS integration

Cons

Performance overhead due to heavy abstraction
Migrations can be buggy (schema drift issues)
TypeScript support is weak for relations
Lots of “magic” → harder debugging

Performance

Slower in complex queries due to reflection and metadata.

Lazy loading often causes the N+1 query problem.

✅ Best for teams from Hibernate/Entity Framework background or those who want auto-managed relations.

⚡ Prisma – The DX Darling

Pros

Schema-first approach (schema.prisma)
Auto-generates fully typed client → incredible DX
Rich ecosystem: Prisma Studio, Migrate, Data Browser
Great documentation & community

Cons

Performance overhead from Rust query engine
Transactions are limited (interactive mode)
Limited flexibility for raw SQL
Can be harder to tune for high-performance queries

Performance

⚠️ Faster than TypeORM, but still slower than SQL-focused builders like Drizzle.

✅ Best for teams who value developer experience and fast prototyping.

⚡ Drizzle ORM – The Performance Leader

Pros

TypeScript-first, SQL-first – schema and queries are fully typed
Lightweight – no runtime reflection
Near raw SQL performance
Safe migrations with drizzle-kit
Strong inference → safer refactors
Great with serverless DBs (Turso, Neon, Planetscale)

Cons

Newer, smaller ecosystem than Prisma/TypeORM
Requires developers to know SQL concepts
No lazy-loading → explicit joins only

Performance

Drizzle is currently the fastest ORM for NestJS apps in 2025.

It compiles queries down to SQL with minimal overhead.

✅ Best for performance-sensitive apps (real-time systems, analytics, fintech).

⚡ Benchmark & Feature Comparison

Feature / ORM	TypeORM	Prisma	Drizzle ORM
Performance	❌ Slowest	⚠️ Medium	✅ Fastest
Type Safety	⚠️ Partial	✅ Excellent	✅ Excellent
Migrations	⚠️ Buggy	✅ Good	✅ Excellent
Learning Curve	✅ Easy (OOP devs)	✅ Easy	⚠️ Needs SQL
Relations	✅ Built-in	✅ Declarative	⚠️ Manual
Ecosystem	✅ Mature	✅ Huge	⚠️ Growing
Best For	Legacy/OOP	DX-first teams	Performance & Type Safety

⚡ NestJS Integration Examples

🟢 TypeORM

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      url: process.env.DATABASE_URL,
      entities: [User, Post],
      synchronize: false,
    }),
    TypeOrmModule.forFeature([User, Post]),
  ],
})
export class AppModule {}

🟣 Prisma

@Injectable()
export class PrismaService extends PrismaClient 
  implements OnModuleInit {
  async onModuleInit() {
    await this.$connect();
  }
}

@Module({
  providers: [PrismaService],
  exports: [PrismaService],
})
export class PrismaModule {}

🔵 Drizzle ORM

import { drizzle } from "drizzle-orm/node-postgres";
import { Pool } from "pg";

const pool = new Pool({ connectionString: process.env.DATABASE_URL });
export const db = drizzle(pool);

@Module({
  providers: [{ provide: 'DB', useValue: db }],
  exports: ['DB'],
})
export class DatabaseModule {}

⚡ Final Verdict – Best ORM for NestJS in 2025

TypeORM → Best if you need decorator-style entities & auto-relations.
Prisma → Best if you want fantastic DX & tooling.
Drizzle ORM → Best if you care about performance, type safety, and migrations.

🏆 For most new NestJS projects in 2025, the winner is Drizzle ORM.

It combines raw SQL speed, strict TypeScript safety, and robust migrations → making it the future-proof choice for serious applications.

🎬 Conclusion

TypeORM is the legacy powerhouse, but struggles with performance.
Prisma is the most beginner-friendly with top DX.
Drizzle ORM is the best for modern, high-performance NestJS apps.

👉 If you’re starting a new project in 2025, choose Drizzle ORM for scalability and performance.

drizzle-team / drizzle-orm

ORM

Headless ORM for NodeJS, TypeScript and JavaScript 🚀

What's Drizzle?

Drizzle is a modern TypeScript ORM developers wanna use in their next project It is lightweight at only ~7.4kb minified+gzipped, and it's tree shakeable with exactly 0 dependencies.

Drizzle supports every PostgreSQL, MySQL and SQLite database, including serverless ones like Turso, Neon, Xata, PlanetScale, Cloudflare D1, FlyIO LiteFS, Vercel Postgres, Supabase and AWS Data API. No bells and whistles, no Rust binaries, no serverless adapters, everything just works out of the box.

Drizzle is serverless-ready by design. It works in every major JavaScript runtime like NodeJS, Bun, Deno, Cloudflare Workers, Supabase functions, any Edge runtime, and even in browsers.
With Drizzle you can be fast out of the box and save time and costs while never introducing any data proxies into your…

View on GitHub

Introduction to NestJS and TensorFlow for Machine Learning

Sasith Warnaka — Mon, 27 Jan 2025 21:51:26 +0000

What is NestJS?

NestJS is a modern Node.js framework Layouted to help you Construct efficient and scalable Host-side Uses. it stacked with typescript and follows principles from object-oriented and practical scheduling devising it light to form and run your cipher. With its Angular-inspired Structure it comes packed with helpful Characteristics like Requirement injection middleware and decorators making it a solid pick for Constructing reliable and powerful APIs.

Why TensorFlow.js for ML?

TensorFlow.js is a JavaScript library that allows developers to train and Use Calculater learning Representations directly in the browser or Node.js. it provides the power to:

charge pre-trained Representations or school green ones
do real-time predictions
Check cc computations exploitation webgl for acceleration

by combine tensorflowjs with nestjs you get form smart genus apis that incorporate cc Rolealities with amp light and ascendable backend frame

Use Cases and Goals of the Series

This series will take you from a beginner to a proficient developer capable of integrating ML with NestJS. the name goals include:

scope leading amp nestjs diligence with tensorflowjs
burden pre-trained Representations and education bespoke Representations
construction ascendable genus apis to break cc capabilities
exploring real-world cc Uses such as arsenic Checkimonial systems or see credit

Setting Up the Environment

1. Installing NestJS

Install the NestJS CLI:

npm i -g @nestjs/cli

Create a new NestJS project:

nest new ml-backend

Navigate to the project directory:

cd ml-backend

2. Adding TensorFlow.js to Your Project

Install TensorFlow.js:

npm install @tensorflow/tfjs

3. Overview of the Project Structure

After setting up, your project structure should look like this:

ml-backend/
├── src/
│   ├── app.controller.ts
│   ├── app.service.ts
│   ├── ml/
│   │   ├── ml.service.ts
│   │   └── ml.controller.ts
├── main.ts
├── package.json
└── tsconfig.json

In this structure:

app.controller.ts: Entry point for handling basic routes.
ml/: Folder dedicated to your machine learning logic and APIs.

Building Your First ML Model

1. How to Load and Use a Pre-Trained Model

Create an ML service:

nest generate service ml

Add the logic to load a pre-trained model in ml.service.ts:

import * as tf from '@tensorflow/tfjs';
import { Injectable } from '@nestjs/common';

@Injectable()
export class MlService {
  private model: tf.LayersModel;

  async loadModel(): Promise<void> {
    this.model = await tf.loadLayersModel('https://path-to-your-model/model.json');
  }

  async predict(inputData: number[]): Promise<number[]> {
    const tensor = tf.tensor2d([inputData], [1, inputData.length]);
    const prediction = this.model.predict(tensor) as tf.Tensor;
    return prediction.dataSync();
  }
}

Call loadModel() during the application bootstrap process to ensure the model is ready.

2. Making Predictions Using TensorFlow.js

TensorFlow.js allows you to work with tensors, which are multi-dimensional arrays optimized for ML computations.

Example prediction flow:

const input = [5.1, 3.5, 1.4, 0.2];
const result = await this.mlService.predict(input);
console.log('Prediction:', result);

3. Hands-On Example with a Simple Dataset

To keep it simple, let’s use a pre-trained Iris flower classification model. The input would be an array of four features (sepal length, sepal width, petal length, petal width), and the output will predict the class of the flower.

Integrating ML into a NestJS API

1. Creating a NestJS Service for ML Logic

The MlService already handles loading the model and making predictions. We’ll now expose this logic through a controller.

2. Building REST APIs to Expose Predictions

Create a controller:

nest generate controller ml

Add an endpoint to ml.controller.ts:

import { Controller, Post, Body } from '@nestjs/common';
import { MlService } from './ml.service';

@Controller('ml')
export class MlController {
  constructor(private readonly mlService: MlService) {}

  @Post('predict')
  async predict(@Body('input') input: number[]): Promise<number[]> {
    return this.mlService.predict(input);
  }
}

3. Testing APIs with Postman

Start the application:

npm run start

Open Postman and send a POST request to:

URL: http://localhost:3000/ml/predict

Body:

{
  "input": [5.1, 3.5, 1.4, 0.2]
}

The response will return predictions for the given input.

Next Steps

In the upcoming articles, we’ll explore:
Training and deploying custom ML models.
Optimizing API performance for real-world applications.
Building and deploying a full ML-powered application.

Mastering PM2: Optimizing Node.js and Next.js Applications for Performance and Scalability

Sasith Warnaka — Wed, 09 Oct 2024 20:33:23 +0000

In today's high-traffic web applications, ensuring smooth performance for projects like Next.js is essential. From my experience, PM2 has been a reliable tool for efficiently scaling, optimizing resources, and maintaining uptime. This article explores advanced PM2 techniques such as clustering, scaling, zero-downtime deployments, and monitoring—practical strategies I’ve successfully implemented in production environments to maintain high performance and reduce downtime.

Why PM2?

Before diving into advanced features, let’s clarify why PM2 is the go-to process manager for Node.js projects:

Process Management: PM2 automatically keeps your app running. If a process crashes, PM2 restarts it instantly, ensuring uptime.
Clustering: It allows you to spawn multiple instances of your Node.js app to take full advantage of multi-core CPUs, boosting your app’s performance.
Zero-Downtime Deployment: PM2 enables zero-downtime reloads, meaning that your application remains online even when it’s updated.
Real-Time Monitoring: With built-in monitoring tools, PM2 helps track CPU and memory usage for each process.

Advanced Features of PM2 for Node.js Projects

1. Cluster Mode: Unlocking Full CPU Potential

By default, Node.js applications run on a single thread, meaning they only use one CPU core. For CPU-bound tasks or high-concurrency applications, this can be a significant bottleneck. PM2’s cluster mode solves this by spawning multiple instances of your app, each mapped to a core.

Example:

pm2 start app.js -I max

This command tells PM2 to launch your app in cluster mode, with max instances based on the available CPU cores. PM2 automatically balances incoming requests across these instances using a built-in load balancer, improving response times and overall throughput.

Benefits:
Optimized CPU usage: Instead of one core, you utilize all available cores.
Fault tolerance: If one instance crashes, others remain unaffected.
Scalability: You can dynamically increase or decrease the number of instances based on real-time traffic.

2. Zero-Downtime Deployment

PM2 enables zero-downtime deployment using its reload mechanism, which restarts your application instances one at a time. This means the server continues to serve users while new code is deployed.

Command:

pm2 reload app

This is crucial for production environments, ensuring users do not experience any interruptions even during updates or patches. For Next.js apps using SSR (server-side rendering), this feature is invaluable.

Scaling and Optimizing Node.js Projects with PM2

For applications handling heavy loads or requiring high availability, PM2’s scaling options are key to success. Here are some advanced strategies:

1. Horizontal Scaling

To scale your Node.js applications horizontally, PM2’s cluster mode allows you to dynamically add or remove instances based on server load.

Example:

pm2 scale app +3  # Add 3 more instances
pm2 scale app 2   # Scale down to 2 instances

Horizontal scaling is ideal for high-traffic web apps, APIs, or any service where concurrency is crucial. For Next.js, where SSR adds to server load, PM2’s clustering optimizes the rendering process by distributing it across multiple instances.

2. Memory Management and Auto-Restart

Memory leaks are a common issue in Node.js applications, particularly in long-running processes. PM2 can monitor your app’s memory usage and automatically restart instances when they exceed a set memory limit. This helps maintain performance without manual intervention.

Example:

pm2 start app.js --max-memory-restart 500M

In this case, if any instance consumes more than 500MB of memory, PM2 restarts it.

Advanced Ecosystem Configuration

For complex projects, managing multiple applications or microservices becomes essential. PM2 allows you to manage these apps using an ecosystem file where you define different services, environments, and configurations in one place.

Example ecosystem.config.js:

module.exports = {
  apps: [
    {
      name: 'api',
      script: './api.js',
      instances: 4,
      exec_mode: 'cluster',
      env: {
        NODE_ENV: 'production',
      }
    },
    {
      name: 'next-app',
      script: 'npm',
      args: 'start',
      instances: 'max',
      exec_mode: 'cluster',
      env: {
        NODE_ENV: 'production',
      }
    }
  ]
};

This setup allows you to run both a Node.js API and a Next.js app, each with multiple instances optimized for production.

Integrating PM2 with Docker

If you're running your Node.js or Next.js application inside Docker, PM2 can still manage your processes effectively. However, when using Docker, you should use pm2-runtime instead of the standard PM2 command, as Docker requires non-daemonized processes.

Example Dockerfile:

FROM node:latest
WORKDIR /app
COPY . .
RUN npm install
CMD ["pm2-runtime", "ecosystem.config.js"]

By using pm2-runtime, your application runs inside the container without issues related to daemonizing processes, making Docker and PM2 a powerful combination for containerized deployments.

Monitoring and Logs: Keeping Track of Your App’s Health

PM2 provides extensive monitoring tools for tracking your applications. The command pm2 monit shows real-time stats like CPU and memory usage, while pm2 logs lets you view logs from all instances in real-time.

For even more advanced monitoring, PM2 offers PM2 Plus, a web-based dashboard that gives you a comprehensive view of your application’s performance, including alerts, memory profiling, and more.

Command:

pm2 monit  # Real-time monitoring
pm2 logs   # Log viewing

Conclusion: Why PM2 is Essential for Node.js Projects

PM2 is a must-have tool for any Node.js developer looking to manage production-grade applications. Whether you're working with a simple API or a complex SSR framework like Next.js, PM2 helps you achieve:

Optimized performance through multi-core utilization.
Scalability with dynamic process scaling.
Reliability through auto-restarts and memory management.
Continuous availability with zero-downtime deployments.

By leveraging PM2’s advanced features, you can ensure your Node.js applications run smoothly, even under heavy load, and are ready to handle any production challenge.

Redux with Persistent State Rehydration in Next.js (App Router)

Sasith Warnaka — Sun, 22 Sep 2024 20:03:04 +0000

It can be overwhelming when it comes to application state management on the different pages when working with Next.js. Redux comes in handy in this case which is a robust and effective state management solution and it is made better when implemented with Redux Persist which makes the state to survive even after a page refresh. This tutorial is aimed a getting started with Redux and Redux Persist in Next.js, in particular with the App Router (/app) structure.

Prerequisites

Before starting, ensure that you have Node.js and npm installed. If not, download and install them from the official Node.js website.

Step 1: Setting up a Next.js App Router Project

To create a new Next.js project with the App Router structure, run the following command:

npx create-next-app@latest my-next-app

Make sure to enable the experimental App Router feature when prompted.

Step 2: Installing Redux and Redux Persist

Next, install the required packages for Redux and Redux Persist:

npm install redux react-redux redux-persist

These dependencies will help you manage state within your app and persist it across sessions.

Step 3: Setting Up Redux Store and Persist Configuration

In your project, create a redux folder in the src directory to organize Redux files. Inside this folder, create a store.js file to configure the Redux store and Redux Persist.

// src/redux/store.js

import { configureStore } from '@reduxjs/toolkit';
import { persistStore, persistReducer } from 'redux-persist';
import storage from 'redux-persist/lib/storage'; 
import rootReducer from './reducers';

const persistConfig = {
  key: 'root',
  storage,
};

const persistedReducer = persistReducer(persistConfig, rootReducer);

export const store = configureStore({
  reducer: persistedReducer,
});

export const persistor = persistStore(store);

Step 4: Creating Reducers

In the same redux folder, create a reducers folder to define your reducers. For this example, create a simple counter reducer.


// src/redux/reducers/counterReducer.js

const initialState = {
  count: 0,
};

const counterReducer = (state = initialState, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    case 'DECREMENT':
      return { count: state.count - 1 };
    default:
      return state;
  }
};

export default counterReducer;

Next, create an index.js file in the reducers folder to combine reducers (if you have multiple):


// src/redux/reducers/index.js

import { combineReducers } from 'redux';
import counterReducer from './counterReducer';

export default combineReducers({
  counter: counterReducer,
});

Step 5: Creating Actions

In the redux folder, create an actions folder to define action creators. Create a counterActions.js file to handle the counter actions.

// src/redux/actions/counterActions.js

export const increment = () => ({
  type: 'INCREMENT',
});

export const decrement = () => ({
  type: 'DECREMENT',
});

Step 6: Integrating Redux and Redux Persist with App Router

To integrate Redux and Redux Persist with the Next.js App Router, modify the layout.js file within the app directory. This file wraps your application’s UI and ensures that Redux and Redux Persist are accessible across all routes.


// app/layout.js

import { Provider } from 'react-redux';
import { PersistGate } from 'redux-persist/integration/react';
import { store, persistor } from '../src/redux/store';
import './globals.css';

export default function RootLayout({ children }) {
  return (
    <html lang="en">
      <body>
        <Provider store={store}>
          <PersistGate loading={null} persistor={persistor}>
            {children}
          </PersistGate>
        </Provider>
      </body>
    </html>
  );
}

This setup ensures that Redux and Redux Persist are initialized when the app loads.

Step 7: Using Redux in a Component

Now, let's create a page that uses the Redux state. Inside the app directory, create a new folder counter and add a page.js file to create a simple counter component.


// app/counter/page.js

'use client'; // Enable client-side rendering for this page

import { useDispatch, useSelector } from 'react-redux';
import { increment, decrement } from '../../src/redux/actions/counterActions';

export default function CounterPage() {
  const count = useSelector((state) => state.counter.count);
  const dispatch = useDispatch();

  return (
    <div>
      <h1>Counter: {count}</h1>
      <button onClick={() => dispatch(increment())}>Increment</button>
      <button onClick={() => dispatch(decrement())}>Decrement</button>
    </div>
  );
}

The useSelector hook retrieves the current counter state, and useDispatch dispatches the increment and decrement actions.

Step 8: Running Your Application

Finally, start your Next.js application by running:

npm run dev

Visit http://localhost:3000/counter to see your counter page in action. The state will persist even after page reloads, thanks to Redux Persist.

Conclusion

You have successfully integrated Redux and Redux Persist into a Next.js project using the App Router. This setup allows for seamless state management with persistence across sessions. From here, you can expand this approach to manage more complex states and interactions in your application. Happy coding!

GraphQL vs. REST: Choosing the Right API Strategy for your Project 🤔

Sasith Warnaka — Sat, 07 Sep 2024 15:11:13 +0000

APIs are the backbone of modern web and mobile applications; they enable the transfer of data between servers and clients easily. In recent times, two of the most popular ways in which APIs are designed are REST-Representational State Transfer-and GraphQL-Graph Query Language. While powerful, both come with their advantages and limitations. Choosing the right one for your project may affect your application's performance, speed of development, and long-term maintainability. This article provides a detailed comparison between REST and GraphQL based on their main features, advantages, and disadvantages. It also gives recommendations as to in which cases one should be used instead of another.

What is REST?

REST is a traditional architecture style that bases web services on a set of constraints, relying on standard HTTP methods like GET, POST, PUT, DELETE, and PATCH to operate on resources. Each resource shall be identifiable by a unique URL (endpoint), and the server shall determine how the response shall be formatted.

Pros of REST:

REST is lightweight-it's rather intuitive, easy to pick up, and makes use of the usual HTTP methods. It's much easier to get people up to speed and work together as long as most developers know how it works.
Caching Support: REST intrinsically supports HTTP caching because it's a process of storing responses locally for repeated requests to attain performance boosts.
Stateless: RESTful APIs are stateless; that is, everything a server needs to understand a client's request is part of that request itself. This allows scaling quite easily because it then becomes quite easy to distribute the requests across many servers.
Mature Ecosystem and Tooling: REST has been around for decades; thus, it comes with huge ecosystem, and solid tooling is out there to perform debugging and monitoring testing that will help developers make sure reliability and performance are guaranteed.

Cons of REST:

Data Over-fetching or Under-fetching: REST APIs might result in over-fetching, fetching more data than what was needed, or under-fetching, where too many requests need to be fired in order to receive all the data since the response structure resides with the server-side.
This will be painful with a number of endpoints dealing with multiple and maintaining them: while scaling up the application, it becomes complex and might turn out to be a headache for any changes at the backend, meaning updating lots of these endpoints, thereby again creating some overhead about their maintenance.
Limited flexibility in changing data structure: REST is not that flexible when it comes to change in data structure. Any client, though dependent upon the server for making changes, has to change the API response format, which usually makes the development and iteration quite slow.

What is GraphQL?

GraphQL is both a language for APIs and an execution environment that carries out those queries by relying on types provided by your data. On the other hand, GraphQL uses one endpoint for any type of request. The clients say what they want to get as a response - just what they need.

Pros of GraphQL:

Flexible Data Retrieval: GraphQL has the facility for clients to fetch only the data they really need; hence, no over-fetching and under-fetching problems. This will then imply efficient data usage and probably faster response times.
Single endpoint for all requests: GraphQL uses a single endpoint for all requests. Consequently, it reduces complexity and hence minimizes the headaches associated with API versioning. In this respect, it turns out to be pretty helpful for dynamic and fast-changing applications.
Strongly typed: GraphQL schemes are strongly typed, offering a clear contract between the server and the client. This therefore reduces errors, and one could more correctly guess API responses. It enhances collaboration between the front-end and the back-end teams.
Real-Time Data with Subscriptions: GraphQL offers subscriptions that enable fetching of data in real time. Thus, it is better suited for applications that demand this data be alive-something like chat applications, social feeds, or updates about ongoing sports events.

Cons of GraphQL:

Steeper Learning Curve: GraphQL demands a new query language and needs to be set up with a schema; therefore, it hugely increases the complexity and time needed at the beginning of development.
Caching Challenges: GraphQL does not quite perform well with traditional HTTP caching; hence, more advanced caching solutions need to be implemented, such as client-side caching, or with the use of specific tools like Apollo Client.
Overhead for Simple Use Cases: For applications whose data requirements are simple, the flexibility afforded by GraphQL is overkill and brings a certain degree of unnecessary complexity into the project.
Possible expensive queries: Since the client is in a position to request any combination of data from the server, there is a possibility that a client can request more data than expected. That is, the costly or inefficiency-guaranteeing queries that could degrade the performance of the server. Mitigating this calls for careful monitoring and analysis of query complexity.

When to Choose REST?

Simple applications: REST would go for projects with simple data requirements and clearly defined resources. It's rather lightweight, considerably documented, and highly compatible with most web standards.
Caching to optimize performance: In case your application heavily relies on HTTP caching to manage performance with reduced server load, then REST is ideal.
Well-Established Projects: REST works best when the system is legacy or based on, or when a team is accustomed to working with the philosophy of REST.

When to Choose GraphQL?

Complex Data Requirements: GraphQL comes into its own when an application needs to fetch data from multiple sources or when clients require only subsets of a dataset.
Real-Time Updates and Dynamic Data: Applications that make use of updates to live dashboards or any kind of collaboration tools rely very much on GraphQL subscriptions.
Agile Development and Iteration: GraphQL allows rapid development and iteration because the client can define their data needs independently of the actual results they are interested in, hence reducing changes required in the backend.
Mobile and Low Bandwidth Environments: GraphQL plays an important role in applications where the minimization of data transfer is of essence, such as mobile applications and low-bandwidth environments, by reducing data payload.

Conclusion:

GraphQL and REST have different strong points, which predominate in various situations. REST would be a good choice when you operate simple, clearly defined APIs with high caching demands, while GraphQL could act perfectly within complex applications that require flexibility and real-time features along with data fetching efficiency. Anyway, this or that could fit depending on the actual needs of your project and the level of proficiency of your team.

Which API strategy should be employed depends on data complexity, the performance needs of an application, and the type of client applications. If you can weigh the pros and cons of each approach well enough, then you're on your merry way to making a rather appropriate decision that sets your project up for success.

Redux with Persistent State Rehydration in Next.js

Sasith Warnaka — Tue, 31 Oct 2023 20:06:18 +0000

In a Next.js application, incorporating Redux for state management and persisting and rehydrating the state is crucial for ensuring a seamless user experience. This tutorial will guide you through setting up Redux and using Redux Persist for state persistence and rehydration in a Next.js application.

Prerequisites

Before getting started, make sure you have Node.js and npm installed on your machine. If not, you can download and install them from the official website.

Step 1: Creating a Next.js Application

Let's begin by creating a new Next.js application. Open your terminal and execute the following command:

npx create-next-app my-next-app

Replace my-next-app with the desired name for your project. This command sets up a new Next.js application for you.

Step 2: Installing Redux and Redux Persist

To add Redux and Redux Persist to your project, run the following command in your project's root directory:

npm install redux react-redux redux-persist

This will install the necessary dependencies for Redux and Redux Persist.

Step 3: Setting Up Redux

In your Next.js project, create a folder named redux inside the src directory. This folder will house your Redux configuration.

Inside the redux folder, create a file named store.js to set up your Redux store and include Redux Persist:

// src/redux/store.js

import { createStore } from 'redux';
import { persistStore, persistReducer } from 'redux-persist';
import storage from 'redux-persist/lib/storage';
import rootReducer from './reducers';

const persistConfig = {
  key: 'root',
  storage,
};

const persistedReducer = persistReducer(persistConfig, rootReducer);

export const store = createStore(persistedReducer);
export const persistor = persistStore(store);

Step 4: Create Reducers

Inside the redux folder, create a folder named reducers. This is where you'll define your reducers. For this example, let's create a simple counter reducer. Inside the reducers folder, create a file called counterReducer.js:

// src/redux/reducers/counterReducer.js

const initialState = {
  count: 0,
};

const counterReducer = (state = initialState, action) => {
  switch (action.type) {
    case 'INCREMENT':
      return { count: state.count + 1 };
    case 'DECREMENT':
      return { count: state.count - 1 };
    default:
      return state;
  }
};

export default counterReducer;

Step 5: Creating Actions

In your redux folder, create a folder named actions. Create a file named counterActions.js to define your actions:

// src/redux/actions/counterActions.js

export const increment = () => ({
  type: 'INCREMENT',
});

export const decrement = () => ({
  type: 'DECREMENT',
});

Step 6: Integrating Redux into Next.js

In your Next.js application, you need to integrate Redux. Create a file named _app.js in the pages directory. This file is special in Next.js and wraps your entire application with global components. Import the Provider component from react-redux, your Redux store, and the PersistGate component from redux-persist/integration/react:

// pages/_app.js

import { Provider } from 'react-redux';
import { PersistGate } from 'redux-persist/integration/react';
import { store, persistor } from '../src/redux/store';

function MyApp({ Component, pageProps }) {
  return (
    <Provider store={store}>
      <PersistGate loading={null} persistor={persistor}>
        <Component {...pageProps} />
      </PersistGate>
    </Provider>
  );
}

export default MyApp;

Step 7: Using Redux in a Component

You can now use Redux in your components. Let's create a simple counter component to demonstrate how Redux works. In the pages directory, create a file named index.js:

// pages/index.js

import { useDispatch, useSelector } from 'react-redux';
import { increment, decrement } from '../src/redux/actions/counterActions';

export default function Home() {
  const count = useSelector((state) => state.count);
  const dispatch = useDispatch();

  return (
    <div>
      <h1>Redux Counter Example</h1>
      <p>Count: {count}</p>
      <button onClick={() => dispatch(increment())}>Increment</button>
      <button onClick={() => dispatch(decrement())}>Decrement</button>
    </div>
  );
}

Conclusion

You have successfully set up Redux with state persistence and rehydration in your Next.js application. With Redux Persist, your application's state will be saved and restored even after page refreshes or navigation.

Feel free to expand upon this basic example and implement more advanced features as your project requires. Redux and Redux Persist offer a robust solution for state management in Next.js applications. Happy coding!

Update : Redux with Persistent State Rehydration in Next.js (App Router)

Node.js Architectural Patterns with Examples

Sasith Warnaka — Tue, 05 Sep 2023 04:25:17 +0000

Exploring Node.js Architectural Patterns with Examples
Node.js, with its non-blocking, event-driven architecture, has become a popular choice for building a wide range of applications. When developing with Node.js, it's essential to choose the right architectural pattern to match your project's requirements. In this article, we'll explore several Node.js architectural patterns and provide examples to illustrate their use.

1. MVC (Model-View-Controller)

The Model-View-Controller (MVC) pattern is a widely-used architectural pattern for web applications. It separates an application into three components:

Model: Handles data and business logic.
View: Handles presentation and user interface.
Controller: Manages the interaction between Model and View.

Here's a simple Node.js MVC example using Express.js:

const express = require('express');
const app = express();

// Model
const items = [];

// View
app.get('/items', (req, res) => {
  res.json(items);
});

// Controller
app.post('/items', (req, res) => {
  const newItem = req.body;
  items.push(newItem);
  res.status(201).json(newItem);
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

2. RESTful API

Node.js is a popular choice for building RESTful APIs. RESTful architecture follows principles such as statelessness and uniform interfaces.

Here's a simple REST API example using Express.js:

const express = require('express');
const app = express();

app.get('/api/books', (req, res) => {
  // Return a list of books
});

app.get('/api/books/:id', (req, res) => {
  // Return details of a specific book
});

app.post('/api/books', (req, res) => {
  // Create a new book
});

app.put('/api/books/:id', (req, res) => {
  // Update a book
});

app.delete('/api/books/:id', (req, res) => {
  // Delete a book
});

app.listen(3000, () => {
  console.log('RESTful API server is running on port 3000');
});

3. Microservices

Microservices architecture involves breaking down a complex application into small, independent services. Each service has its own functionality and communicates with others via APIs. Node.js is well-suited for building microservices due to its lightweight nature and scalability.

Here's a simplified example:

// Service 1
const express = require('express');
const app = express();
// Define service 1 routes and functionality

// Service 2
const express2 = require('express');
const app2 = express2();
// Define service 2 routes and functionality

// ...

app.listen(3001, () => {
  console.log('Service 1 is running on port 3001');
});

app2.listen(3002, () => {
  console.log('Service 2 is running on port 3002');
});

4. Real-time Applications

Node.js is an excellent choice for real-time applications that require low-latency communication between the server and clients. Libraries like Socket.io make it easy to implement real-time features.

Here's a basic chat application example:

const express = require('express');
const http = require('http');
const socketIo = require('socket.io');

const app = express();
const server = http.createServer(app);
const io = socketIo(server);

io.on('connection', (socket) => {
  console.log('A user connected');

  socket.on('chat message', (message) => {
    io.emit('chat message', message);
  });

  socket.on('disconnect', () => {
    console.log('A user disconnected');
  });
});

server.listen(3000, () => {
  console.log('Chat server is running on port 3000');
});

5. Event-Driven Architecture

Node.js's event-driven nature makes it suitable for an Event-Driven Architecture. You can use the EventEmitter module to build systems that respond to events and asynchronous actions.

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();

myEmitter.on('event', () => {
  console.log('An event occurred!');
});

myEmitter.emit('event');

6. GraphQL

GraphQL is a query language for APIs that allows clients to request exactly the data they need. Node.js can be used to build GraphQL servers, making it suitable for situations where clients have diverse data requirements.

Here's a simplified example using the Apollo Server library:

const { ApolloServer, gql } = require('apollo-server');

const typeDefs = gql`
  type Query {
    hello: String
  }
`;

const resolvers = {
  Query: {
    hello: () => 'Hello, world!',
  },
};

const server = new ApolloServer({ typeDefs, resolvers });

server.listen().then(({ url }) => {
  console.log(`GraphQL server ready at ${url}`);
});

7. Layered Architecture

Similar to MVC, you can organize your Node.js application into layers such as presentation, business logic, and data access. This promotes separation of concerns and maintainability.

8. CQRS (Command Query Responsibility Segregation)

In the CQRS (Command Query Responsibility Segregation) pattern, you separate the reading and writing parts of your application. Node.js can be used to build the APIs for both the command and query sides of your system.

9. Hexagonal Architecture

Hexagonal Architecture emphasizes the separation of concerns and the use of ports and adapters to isolate the core application from external dependencies. Node.js can be used effectively in this pattern.

The choice of architectural pattern depends on your project's specific requirements, scalability needs, and your team's familiarity with the pattern. Often, a combination of these patterns is used within a single application to address different concerns effectively.

Explore these architectural patterns and choose the one that best fits your Node.js project to ensure scalability, maintainability, and performance.

Next.js Image vs. HTML : Optimizing Website Images for Performance

Sasith Warnaka — Sat, 10 Jun 2023 17:06:23 +0000

Images are an integral part of web design, but they can significantly impact website performance if not optimized properly. In this article, we will explore the benefits of using Next.js Image compared to the standard HTML <img> element and provide examples of how you can implement similar optimizations using HTML.

Size Optimization:

Next.js Image:

Next.js Image excels in size optimization by automatically serving correctly sized images for each device. It utilizes modern image formats like WebP and AVIF to reduce file sizes while maintaining quality. The component determines the width and height of the image based on the imported file, preventing layout shifts during image loading.

Example:

import Image from 'next/image';
import profilePic from '../public/profile.jpg';

const MyComponent = () => (
  <Image
    src={profilePic}
    alt="Profile Picture"
    // Width and height are automatically provided based on the imported image file
  />
);

HTML <img>:

To optimize image sizes using HTML, you can resize and compress images before uploading them to your website. Additionally, specify the width and height attributes in the tag to reserve space for the image, ensuring proper layout and preventing layout shifts.

Example:

<img src="image.jpg" alt="Description of the image" width="500" height="300" />

Visual Stability

Next.js Image:

Next.js Image addresses visual stability concerns by automatically preventing layout shifts during image loading. It reserves space for the image and applies techniques like blur-up placeholders and native browser lazy loading.

Example:

import Image from 'next/image';
import profilePic from '../public/profile.jpg';

const MyComponent = () => (
  <Image
    src={profilePic}
    alt="Profile Picture"
    // Width and height are automatically provided based on the imported image file
    // Additional props for visual stability can be added
    // e.g., placeholder="blur" for blur-up placeholders
  />
);

HTML <img>:

To maintain visual stability, reserve space for the image using CSS. Set the width and height of the parent container and use CSS properties like object-fit to control how the image is displayed within its container.

Example:

<div style="width: 500px; height: 300px;">
  <img src="image.jpg" alt="Description of the image" style="object-fit: cover; width: 100%; height: 100%;" />
</div>

Lazy Loading

Next.js Image:

Next.js Image leverages native browser lazy loading, ensuring that images are loaded only when they enter the viewport. This improves page load times, particularly for websites with numerous images.
Example:

import Image from 'next/image';
import profilePic from '../public/profile.jpg';

const MyComponent = () => (
  <Image
    src={profilePic}
    alt="Profile Picture"
    // Width and height are automatically provided based on the imported image file
    // Lazy loading is enabled by default
  />
);

HTML <img>:

To implement lazy loading using HTML, use the loading="lazy" attribute in the tag. This attribute instructs the browser to lazily load the image when it enters the viewport.

Example:

<img src="image.jpg" alt="Description of the image" loading="lazy" />

Image Optimization

Next.js Image:

Next.js Image provides automatic image optimization, including size reduction through modern image formats and on-demand image resizing for images stored on remote servers. It also integrates with content delivery networks (CDNs) for optimized image delivery.

Example:

import Image from 'next/image';
import profilePic from '../public/profile.jpg';

const MyComponent = () => (
  <Image
    src={profilePic}
    alt="Profile Picture"
    // Width and height are automatically provided based on the imported image file
    // Image optimization is handled by Next.js
  />
);

HTML <img>:

To optimize images using HTML, consider compressing images before uploading them to your website. Use image compression tools or services to reduce file sizes while maintaining acceptable image quality. Additionally, leverage CDNs to serve optimized versions of your images, benefiting from caching, compression, and content delivery.

Conclusion

While the standard HTML <img> element offers some image optimization possibilities, Next.js Image provides a more comprehensive and streamlined solution for optimizing images within the Next.js framework. Next.js Image offers size optimization, visual stability, lazy loading, and automatic image optimization features, allowing developers to deliver high-performance websites with ease.

However, if you're working with HTML, you can still achieve image optimization by resizing and compressing images, specifying width and height attributes, implementing lazy loading, and utilizing CDNs for optimized image delivery. Consider your specific requirements and the level of optimization needed when deciding between Next.js Image and HTML <img>.

Building a Laravel and Next.js Project with Docker: A Step-by-Step Guide

Sasith Warnaka — Thu, 08 Jun 2023 15:29:50 +0000

In modern web development, combining the power of Laravel, a robust PHP framework, with Next.js, a popular React framework, can deliver an exceptional full-stack web application experience. To enhance the development process and facilitate deployment, Docker provides an efficient containerization solution. In this article, we'll explore a step-by-step guide on how to build a Laravel and Next.js project using Docker.

Table of Contents:

1.Prerequisites
2.Setting up Laravel Backend with Docker
2.1 Dockerizing the Laravel Backend
2.2 Defining the Docker Compose File
2.3 Establishing Communication with the Next.js Frontend
3.Building the Next.js Frontend with Docker
3.1 Dockerizing the Next.js Frontend
3.2 Defining the Docker Compose File
3.3 Connecting to the Laravel Backend
4.Deploying the Docker Containers
5.Conclusion

Section 1: Prerequisites

Before diving into the implementation, it's essential to ensure you have the necessary tools installed, including Docker, Composer, and Node.js.

Section 2: Setting up Laravel Backend with Docker

2.1 Dockerizing the Laravel Backend:

Create a Dockerfile in the root directory of your Laravel project with the following content:

FROM php:8.0-fpm

WORKDIR /var/www/html

RUN apt-get update && apt-get install -y \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    zip \
    unzip \
    git \
    nano

RUN docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd zip

COPY . /var/www/html

RUN chown -R www-data:www-data /var/www/html/storage

CMD ["php-fpm"]


EXPOSE 9000

2.2 Defining the Docker Compose File:

Create a docker-compose.yml file in the project's root directory with the following content:

version: "3"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8000:9000"
    volumes:
      - .:/var/www/html
    depends_on:
      - db

  db:
    image: mariadb:10.6
    ports:
      - "3306:3306"
    environment:
      MYSQL_DATABASE: newsDb
      MYSQL_USER: root
      MYSQL_PASSWORD: secretnewsDb
      MYSQL_ROOT_PASSWORD: secretnewsDb
    volumes:
      - ./mysql:/var/lib/mysql

2.3 Establishing Communication with the Next.js Frontend:

Update your Laravel application's API endpoints to point to the Docker network and the correct Laravel container URL. Make sure to use the appropriate container names or aliases defined in the Docker Compose file (e.g., http://laravel-container:9000/api).

Section 3: Building the Next.js Frontend with Docker

3.1 Dockerizing the Next.js Frontend:

Create a Dockerfile in the root directory of your Next.js project with the following content:

FROM node:16-alpine
RUN mkdir -p /app
WORKDIR /app
COPY . .
RUN npm install
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

3.2 Defining the Docker Compose File:

Update the docker-compose.yml file in the project's root directory with the following content:

version: "3"
services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    depends_on:
      - laravel

  laravel:
    # Configuration for Laravel backend service

  db:
    # Configuration for the database service

3.3 Connecting to the Laravel Backend:

Update your Next.js application's API endpoints to point to the Docker network and the correct Laravel container URL. Make sure to use the appropriate container names or aliases defined in the Docker Compose file (e.g., http://laravel-container:9000/api).

Section 4: Deploying the Docker Containers

To deploy the Docker containers, open a terminal in the project's root directory and run the following command:

docker-compose up --build

This command will build the Docker images for both the Laravel backend and Next.js frontend and start the containers. Once the containers are up and running, open another terminal and follow the steps below to set up the database for the Laravel backend.

4.1 Accessing the Laravel Backend Container:

Open a new terminal window and run the following command to access the running Laravel backend container:

docker-compose exec app bash

This command will open a bash session inside the Laravel container.

4.2 Running Database Migrations:

Once you are inside the Laravel container, run the following command to execute the database migrations:

php artisan migrate

This command will create the necessary database tables based on the migration files defined in your Laravel project.

4.3 Verifying the Database Setup:

After running the migrations, you can verify the database setup by accessing the MySQL container. Open another terminal window and run the following command:

docker-compose exec db bash

This command will open a bash session inside the MySQL container. Once inside the container, you can use the MySQL command-line client to connect to the database and perform any necessary checks or queries.

Section 5: Conclusion

In this article, we explored a step-by-step guide on building a Laravel and Next.js project with Docker. By Dockerizing both the Laravel backend and Next.js frontend, establishing communication between the containers, and deploying the application, you can streamline your development and deployment processes. Leveraging Docker's containerization capabilities allows for efficient collaboration and scalability.

Note: This article provides a high-level overview of building a Laravel and Next.js project with Docker. For detailed instructions, code examples, and further exploration, it's recommended to refer to the official documentation of Laravel, Next.js, and Docker.

GitHub Repositories:

Laravel Backend Example: https://github.com/sasithwarnakafonseka/backend-laravel-api
Next.js Frontend Example: https://github.com/sasithwarnakafonseka/react-news-app

Building Maintainable Next.js Applications with SOLID Principles

Sasith Warnaka — Thu, 08 Jun 2023 06:13:18 +0000

Next.js is a powerful framework for building React applications, providing server-side rendering, static site generation, and a wealth of features. When combined with SOLID principles, Next.js enables the development of highly maintainable, extensible, and robust applications. In this article, we will explore how to apply SOLID principles to Next.js development, with practical examples to demonstrate their effectiveness.

Single Responsibility Principle (SRP):
The Single Responsibility Principle states that a component or module should have a single responsibility. In Next.js, we can apply this principle by breaking down our code into smaller, focused components and pages. For example:

// UserProfile.js
const UserProfile = ({ user }) => {
  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.bio}</p>
    </div>
  );
};

Here, the UserProfile component is responsible for rendering the user profile information, focusing solely on its presentation without handling any data fetching or state management.

Open-Closed Principle (OCP):
The Open-Closed Principle suggests that code should be open for extension but closed for modification. In Next.js, we can achieve this by using abstractions and interfaces. Let's consider an example:

// Button.js
const Button = ({ onClick, children }) => {
  return <button onClick={onClick}>{children}</button>;
};

// PrimaryButton.js
const PrimaryButton = ({ onClick, children }) => {
  return (
    <Button onClick={onClick} className="primary-button">
      {children}
    </Button>
  );
};

Here, the PrimaryButton component extends the behavior of the base Button component by adding a specific class name and style. By leveraging the OCP, we can create reusable components that can be easily extended without modifying the existing code.

Liskov Substitution Principle (LSP):
The Liskov Substitution Principle ensures that derived classes can be used interchangeably with their base classes without affecting the correctness of the program. In Next.js, we can demonstrate this principle using component inheritance:

// BaseLayout.js
const BaseLayout = ({ children }) => {
  return (
    <div>
      <header>Header</header>
      {children}
      <footer>Footer</footer>
    </div>
  );
};

// ExtendedLayout.js
const ExtendedLayout = ({ children }) => {
  return (
    <BaseLayout>
      <div>
        <h1>Extended Layout</h1>
        {children}
      </div>
    </BaseLayout>
  );
};

Here, the ExtendedLayout component extends the behavior of the BaseLayout component by adding additional content. The ExtendedLayout can be used interchangeably with the BaseLayout component without breaking the expected layout structure or functionality.

Interface Segregation Principle (ISP):
The Interface Segregation Principle suggests that client-specific interfaces should be preferred over general-purpose interfaces. In Next.js, we can follow this principle by creating focused and specific interfaces for our components:

// UserCard.js
const UserCard = ({ user }) => {
  return (
    <div>
      <h2>{user.name}</h2>
      <p>{user.email}</p>
    </div>
  );
};

Here, the UserCard component has a specific interface tailored to the user-related information it needs to display. By adhering to the ISP, we ensure that components have precise interfaces, reducing unnecessary dependencies and potential coupling.

Dependency Inversion Principle (DIP):
The Dependency Inversion Principle states that high-level modules should not depend on low-level modules. Both should depend on abstractions. In Next.js, we can implement the DIP through dependency injection:

// UserDataProvider.js
import { useEffect, useState } from 'react';

const UserDataProvider = ({ children }) => {
  const [users, setUsers] = useState([]);

  useEffect(() => {
    fetchUsers().then((data) => setUsers(data));
  }, []);

  return <>{children(users)}</>;
};

Here, the UserDataProvider component fetches user data and provides it to its children as a render prop. By separating the data fetching logic from the components that rely on it, we adhere to the DIP, allowing for easier testing and flexibility.

Conclusion:
By applying SOLID principles to Next.js development, we can create maintainable, flexible, and scalable applications. The Single Responsibility Principle helps us create focused components and pages. The Open-Closed Principle promotes extensibility through abstractions. The Liskov Substitution Principle ensures interchangeability of derived and base components. The Interface Segregation Principle allows for specific and client-focused interfaces. Finally, the Dependency Inversion Principle encourages dependency injection for better modularity and testability. By embracing SOLID principles in Next.js development, we can build robust and maintainable applications that can easily evolve and scale over time.

SOLID Principles

Sasith Warnaka — Mon, 17 Apr 2023 15:09:32 +0000

Turning ideas into reality through software is a logical art form that must be done with great care. Building sophisticated software is fun and challenging, but maintaining and updating poorly written software is even more difficult and frustrating. The methodology for writing good, well-structured code is to follow and adhere to a set of principles known as the SOLID Principles.

The SOLID principle was developed by computer scientist Robert J. Martin in an article published in 2000. Since then, SOLID principles have been widely adopted and are considered the basis for good software design. Consider the abbreviation SOLID.

(E) Principle of Sole Liability

A class can serve only one purpose. That is, a class can perform only one type of operation, such as database logic, logging logic, and so on. This principle ensures that each class focuses on a single responsibility and does not burden the code with extra work that makes it difficult to modify or maintain. For example, consider a class responsible for recording and processing data. This violates the single responsibility principle because the class has two responsibilities. I recommend creating two separate classes, one for logging and one for handling data, each with its own responsibilities.

(O) pen/closing principle

Classes should be open for extension and closed for modification. That is, existing classes must be extensible without having to be rewritten to implement new functionality. This principle promotes the use of abstractions that enable flexible, modular code that can be extended without changing existing code.

For example, let's take a class that generates a report. Instead of modifying the existing class whenever a new report type is added, it is recommended that you create a new class that inherits from the original report class and adds new functionality.

(L)iskov's substitution principle

It should be easy to replace parent classes with child classes. That is, if the Rectangle class is a subtype of the Shape class, Shape can be replaced by Rectangle without breaking the functional flow. This principle promotes the use of inheritance in a way that preserves system functionality.

For example, consider a class hierarchy where the base class is Image and the derived classes are Rectangle and Circle. The Liskow substitution principle should allow code to use any expected shape, such as a rectangle or a circle, without causing problems.

(I) Principle of interfacial separation

Interfaces should not force classes to implement functionality they do not support. This means that larger interfaces must be split into smaller interfaces to provide support. This principle promotes the use of small, focused interfaces specific to the requirements of each class.

For example, take an interface with 10 methods. If a class needs to implement only two of these methods, consider splitting the interface into two sub-interfaces, each containing only the necessary methods.

(D) Principle of inversion of dependence

Classes should depend on abstractions, but not specifications. That is, higher-level modules should not depend on lower-level modules. Both must be based on abstraction. This principle uses interfaces to separate classes and promotes modular design. For example, consider a class that depends on a database. Instead of using the database classes directly, it is recommended to create an interface with the database and make the classes depend on the interface. This promotes loose coupling and enables flexible code.

Finally, the SOLID principles provide guidelines for writing maintainable and extensible software. Following these principles helps software engineers create code that is easier to understand, adapt, and maintain over time. By applying these principles, software engineers can create high-quality software.

DEV Community: Sasith Warnaka

🚀 Best ORM for NestJS in 2025: Drizzle ORM vs TypeORM vs Prisma

⚡ TypeORM – The Classic Choice

⚡ Prisma – The DX Darling

⚡ Drizzle ORM – The Performance Leader

⚡ Benchmark & Feature Comparison

⚡ NestJS Integration Examples

🟢 TypeORM

🟣 Prisma

🔵 Drizzle ORM

⚡ Final Verdict – Best ORM for NestJS in 2025

🎬 Conclusion

drizzle-team / drizzle-orm

ORM

Headless ORM for NodeJS, TypeScript and JavaScript 🚀

What's Drizzle?

Introduction to NestJS and TensorFlow for Machine Learning

What is NestJS?

Why TensorFlow.js for ML?

Use Cases and Goals of the Series

Setting Up the Environment

1. Installing NestJS

2. Adding TensorFlow.js to Your Project

3. Overview of the Project Structure

Building Your First ML Model

1. How to Load and Use a Pre-Trained Model

2. Making Predictions Using TensorFlow.js

3. Hands-On Example with a Simple Dataset

Integrating ML into a NestJS API

1. Creating a NestJS Service for ML Logic

2. Building REST APIs to Expose Predictions

3. Testing APIs with Postman

Open Postman and send a POST request to:

Mastering PM2: Optimizing Node.js and Next.js Applications for Performance and Scalability

Why PM2?

Advanced Features of PM2 for Node.js Projects

1. Cluster Mode: Unlocking Full CPU Potential

2. Zero-Downtime Deployment

Scaling and Optimizing Node.js Projects with PM2

1. Horizontal Scaling

2. Memory Management and Auto-Restart

Advanced Ecosystem Configuration

Integrating PM2 with Docker

Monitoring and Logs: Keeping Track of Your App’s Health

Conclusion: Why PM2 is Essential for Node.js Projects

Further Reading

Redux with Persistent State Rehydration in Next.js (App Router)

Prerequisites

Step 1: Setting up a Next.js App Router Project

Step 2: Installing Redux and Redux Persist

Step 3: Setting Up Redux Store and Persist Configuration

Step 4: Creating Reducers

Step 5: Creating Actions

Step 6: Integrating Redux and Redux Persist with App Router

Step 7: Using Redux in a Component

Step 8: Running Your Application

Conclusion

GraphQL vs. REST: Choosing the Right API Strategy for your Project 🤔

What is REST?

Pros of REST:

Cons of REST:

What is GraphQL?

Pros of GraphQL:

Cons of GraphQL:

When to Choose REST?

When to Choose GraphQL?

Conclusion:

Redux with Persistent State Rehydration in Next.js

Prerequisites

Step 1: Creating a Next.js Application

Step 2: Installing Redux and Redux Persist

Step 3: Setting Up Redux

Step 4: Create Reducers

Step 5: Creating Actions

Step 6: Integrating Redux into Next.js

Step 7: Using Redux in a Component

Conclusion

Node.js Architectural Patterns with Examples

1. MVC (Model-View-Controller)

2. RESTful API