DEV Community: Jayvee Ramos

Handling Data Updates and Expirations in Redis for Enhanced Cache Management

Jayvee Ramos — Fri, 17 Nov 2023 03:03:22 +0000

Handling Data Updates and Expirations in Redis for Enhanced Cache Management

Welcome back to our Redis and Express optimization series! In our previous tutorials, we explored setting up Redis, basic operations like adding and retrieving data, and optimizing data retrieval using Redis caching. Now, let's delve into a crucial aspect of cache management—handling data updates and expirations.

The Challenge of Data Updates:

In a dynamic application, data is constantly evolving. Consider a scenario where a user edits their post. In your database, the post gets updated to reflect the change. However, with our current caching strategy, the outdated post information persists in Redis.

A Quick Recap of Redis Key-Value Storage:

Redis, being a key-value store, retains data in memory. For instance, the key "post1" might be associated with the value "I like cars." But what if a user updates their post to "I don't like cars"? How can we ensure our cache reflects this change?

Strategies for Handling Data Updates:

Immediate Update Approach:
- When a user updates their post, we can immediately update the corresponding Redis cache using client.set. This approach guarantees that our cache is always synchronized with the latest data in the database.
Expiration-based Approach:
- Alternatively, we can set an expiration time for each cache entry. After a specified period (e.g., 10 seconds), Redis automatically clears the cache. Subsequent requests trigger a fresh data retrieval, ensuring updated information is fetched.

Combining Strategies for Robust Cache Management:

The ideal approach often involves a combination of both strategies. Immediate updates ensure consistency in real-time, while expirations act as a safety net, preventing outdated data from persisting indefinitely.

Implementing Expirations in Redis:

Let's explore the expiration approach. When setting a value in Redis, we can specify its time-to-live (TTL) using the EX parameter:

// Example: Setting a value with a 10-second expiration
client.setEx('post1', 'I like cars', 'EX', 10);

This code ensures that the key "post1" will expire and be removed from the cache after 10 seconds.

Practical Demonstration:

Let's observe this in action. In our example, we set a cache expiration of 10 seconds for a post. After this period, Redis automatically removes the entry, prompting a fresh data retrieval.

Conclusion:

Handling data updates and expirations is crucial for maintaining a reliable and responsive cache system. Whether you opt for immediate updates, expirations, or a blend of both, understanding these strategies ensures your application remains performant and up-to-date.

In our next tutorial, we'll explore more advanced features of Redis, so stay tuned for further Redis and Express optimization insights!

Optimizing Data Retrieval with Redis Caching in Your Express App

Jayvee Ramos — Fri, 17 Nov 2023 03:03:12 +0000

Optimizing Data Retrieval with Redis Caching in Your Express App

In our previous tutorials, we successfully set up Redis and explored basic operations like adding and retrieving data. Now, let's take our application to the next level by incorporating Redis caching to dramatically improve data retrieval speed.

Simulating Real-World Scenarios:

In a real-world scenario, our application may need to fetch data from an external API or a database. To simulate this, we'll make an HTTP request to the JSONPlaceholder API, a free API for testing and prototyping. This API allows us to retrieve posts using a dynamic post ID.

Here's a glimpse of the Express route:

make sure to install axios just run this command on your terminal npm install axios

// index.js

// index.js

const express = require("express");
const axios = require("axios");
const redis = require("redis");

const app = express();
const port = 8080;

const client = redis.createClient({
  host: "127.0.0.1",
  port: 6379,
});

client.on("error", (error) => {
  if (error) {
    console.error("ERROR***", error);
  } else {
    console.log("Redis connect.");
  }
});

(async () => {
  client.connect();
})();

app.use(express.json());

// Endpoint to add data to Redis
app.post("/", async (req, res) => {
  const { key, value } = req.body;

  // Set data in Redis
  const response = await client.set(key, value);

  // Respond with the Redis response
  res.json(response);
});

app.get("/:key", async (req, res) => {
  const { key } = req.params;

  // Get data from Redis
  const value = await client.get(key);

  // Respond with the Redis value
  res.json({ key, value });
});

app.get("/existing/:key", async (req, res) => {
  const { key } = req.params;
  // Check if data exists in Redis
  const redisData = await client.get(key);

  if (redisData) {
    // If data is in Redis, return it
    res.json({ key, redisData });
  } else {
    // If not, interact with the database and store the data in Redis
    const databaseData = await fetchDataFromDatabase(key);
    await client.set(key, databaseData);

    // Return the data fetched from the database
    res.json({ key, databaseData });
  }
});

// Endpoint to get posts from JSONPlaceholder API
app.get("/posts/:id", async (req, res) => {
  const id = req.params.id;

  // Check if the post is cached
  const cachedPost = await client.get(`post-${id}`);

  if (cachedPost) {
    // If cached, return the data
    return res.json(JSON.parse(cachedPost));
  }

  // If not cached, make an HTTP request to JSONPlaceholder API
  const response = await axios.get(
    `https://jsonplaceholder.typicode.com/posts/${id}`
  );
  const postData = response.data;

  // Cache the retrieved data in Redis
  await client.set(`post-${id}`, JSON.stringify(postData));

  // Return the retrieved data
  res.json(postData);
});

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

Leveraging Redis Caching for Faster Responses:

Now, let's break down the logic:

We check if the requested post is already cached in Redis using the key post-${id}.
If the post is cached, we retrieve and return it, avoiding the need for an external API request.
If not cached, we make an HTTP request to the JSONPlaceholder API to get the post data.
We cache the retrieved data in Redis for future use.
Finally, we return the post data.

Enhancing Speed with Redis Cache:

By using Redis caching, we've significantly optimized our application. The first request to an uncached post might take some time due to the API call, but subsequent requests for the same post are lightning-fast, thanks to the cached data.

Handling Data Updates:

In real-world applications, we must consider how to handle data updates. If a post gets updated or deleted, we need to ensure our cache is updated accordingly. This often involves implementing cache invalidation or expiration strategies.

In our next section, we'll explore strategies for handling data updates in a Redis-cached environment. Stay tuned for more Redis and Express optimization tips!

Adding and Retrieving Data with Redis in Your Express Application

Jayvee Ramos — Fri, 17 Nov 2023 03:02:56 +0000

Welcome back to our Redis and Express tutorial series! In the previous sections, we set up Redis on our local machine and established the foundations of our Express.js application. Now, let's dive into the exciting part – adding and retrieving data using Redis.

Adding Data to Redis:

To add data to Redis, we'll create a new endpoint that accepts a POST request. Here's how you can do it:

// index.js

// index.js

const express = require("express");
const redis = require("redis");

const app = express();
const port = 8080;

const client = redis.createClient({
  host: "127.0.0.1",
  port: 6379,
});

client.on("error", (error) => {
  if (error) {
    console.error("ERROR***", error);
  } else {
    console.log("Redis connect.");
  }
});

(async () => {
  client.connect();
})();

app.use(express.json());

// Endpoint to add data to Redis
app.post("/", async (req, res) => {
  const { key, value } = req.body;

  // Set data in Redis
  const response = await client.set(key, value);

  // Respond with the Redis response
  res.json(response);
});

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

Now, you can use Postman or any other API testing tool to send a POST request to http://localhost:8080 with a JSON body containing a key and value. For example:

{
  "key": "post",
  "value": "This is a cool course"
}

Retrieving Data from Redis:

To retrieve data, we'll create another endpoint that accepts a GET request. Here's how you can implement it:

// index.js

const express = require("express");
const redis = require("redis");

const app = express();
const port = 8080;

const client = redis.createClient({
  host: "127.0.0.1",
  port: 6379,
});

client.on("error", (error) => {
  if (error) {
    console.error("ERROR***", error);
  } else {
    console.log("Redis connect.");
  }
});

(async () => {
  client.connect();
})();

app.use(express.json());

// Endpoint to add data to Redis
app.post("/", async (req, res) => {
  const { key, value } = req.body;

  // Set data in Redis
  const response = await client.set(key, value);

  // Respond with the Redis response
  res.json(response);
});

app.get("/:key", async (req, res) => {
  const { key } = req.params;

  // Get data from Redis
  const value = await client.get(key);

  // Respond with the Redis value
  res.json({ key, value });
});

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

Now, you can send a GET request to http://localhost:880 with a JSON body containing the key you want to retrieve. For example:

{
  "key": "post"
}

Practical Scenario: Interacting with Database and Redis:

In a real-world scenario, we want to check if the data exists in Redis before interacting with the database. If the data is in Redis, we return it; otherwise, we fetch it from the database, store it in Redis for future use, and then return it. Here's a sneak peek into our next section:

// index.js

const express = require("express");
const redis = require("redis");

const app = express();
const port = 8080;

const client = redis.createClient({
  host: "127.0.0.1",
  port: 6379,
});

client.on("error", (error) => {
  if (error) {
    console.error("ERROR***", error);
  } else {
    console.log("Redis connect.");
  }
});

(async () => {
  client.connect();
})();

app.use(express.json());

// Endpoint to add data to Redis
app.post("/", async (req, res) => {
  const { key, value } = req.body;

  // Set data in Redis
  const response = await client.set(key, value);

  // Respond with the Redis response
  res.json(response);
});

app.get("/:key", async (req, res) => {
  const { key } = req.params;

  // Get data from Redis
  const value = await client.get(key);

  // Respond with the Redis value
  res.json({ key, value });
});

app.get("/existing/:key", async (req, res) => {
  const { key } = req.params;
  // Check if data exists in Redis
  const redisData = await client.get(key);

  if (redisData) {
    // If data is in Redis, return it
    res.json({ key, redisData });
  } else {
    // If not, interact with the database and store the data in Redis
    const databaseData = await fetchDataFromDatabase(key);
    await client.set(key, databaseData);

    // Return the data fetched from the database
    res.json({ key, databaseData });
  }
});

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

Stay tuned for our next section, where we'll dive deeper into this practical scenario and demonstrate how to seamlessly integrate Redis caching with your database interactions. If you haven't already, make sure Redis is running, and your Express server is up and listening on port 880. Happy coding!

Setting Up Redis and Express for Your Application

Jayvee Ramos — Fri, 17 Nov 2023 03:02:33 +0000

Setting Up Redis and Express for Your Application

Welcome back! In the previous section, we explored the concept of Redis caching and how it can significantly boost query performance. Now, let's dive into the practical side of things and set up Redis on our local machine to get ready for integration with our Express.js application.

Downloading Redis:

Visit Redis Official Page:
- Go to the official Redis page.
Choose Stable Version:
- On the Downloads page, select the stable version for your operating system.
Download and Extract:
- Click "Download" to get the Redis archive.
- Extract the contents to a directory of your choice.
Run Redis Server:
- Navigate to the extracted folder.
- Enter the "src" directory.
- Find and execute the "redis-server" executable.
Test Connection with Redis CLI:
- Open another terminal.
- Navigate to the same directory.
- Run the "redis-cli" executable.
- Type ping to test the connection. You should receive a "pong" response.

That's it! You now have Redis up and running on your local machine.

Setting Up Your Express Application:

Now, let's set up an Express.js application to integrate with Redis.

Initialize Node Application:
- Open your preferred text editor (e.g., Visual Studio Code) in an empty directory.
- Open the integrated terminal.
- Run npm init -y to initialize a Node.js application.
Install Express:

Create an index.js file.
Install Express using npm install express.

// index.js
const express = require('express');
const app = express();

const port = 8800;

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

Install Nodemon (Optional):
- Install Nodemon globally for automatic server updates.
- Use npm install -g nodemon.

nodemon index

Install Redis Library:
- Install the redis library for connecting to Redis.
- Use npm install redis.

// index.js
const express = require('express');
const redis = require('redis');

const app = express();
const port = 880;

const redisUrl = 'redis://localhost:6379';
const client = redis.createClient(redisUrl);

app.use(express.json());

app.listen(port, () => {
  console.log(`Now listening on port ${port}`);
});

With Redis and Express set up, we are ready to move on to the next section, where we'll explore how to insert data into Redis. Stay tuned for the continuation of this tutorial!

Understanding Caching with Redis: A Step-by-Step Tutorial

Jayvee Ramos — Fri, 17 Nov 2023 03:02:01 +0000

Introduction:

Welcome back, everyone! In this tutorial blog post, we'll dive into the concept of caching and explore how Redis, an open-source in-memory data structure store, can significantly speed up query times from our server.

What is Redis?

On the RedisToGo landing page, Redis is described as an in-memory data structure store primarily used as a database cache. But what does "in-memory" mean, and why would we want to use it? Let's break it down.

In-Memory Data Store:

Traditional databases like PostgreSQL and MongoDB store data persistently on disk. In contrast, an in-memory data store keeps data in volatile memory. If the system running the database goes down, the data is lost. So, why use in-memory databases?

Caching and Query Optimization:

The primary reason is caching. Imagine a scenario where our server needs to retrieve a specific post from a database with millions or billions of records. Without optimization, the database would perform a full-body scan, searching through each record until it finds the requested one. This process can be slow and resource-intensive.

Introducing Redis as a Solution:

To address this, we introduce Redis, an in-memory key-value store. Unlike traditional databases, Redis can immediately retrieve data associated with a specific key, offering a significant performance boost.

How Redis Caching Works:

We visualize the process with a server-database model. Traditionally, the server queries the database for data. With Redis, before going to the database, the server checks with Redis if it already has the required data. If Redis has the data (cached), the server retrieves it from Redis, skipping the potentially expensive database query.

Real-World Scenario:

Consider a scenario where our application frequently requests post data with an ID. Redis allows us to cache this data, reducing the need for repeated, time-consuming database queries.

Implementing Redis Caching:

In the next sections, we'll delve into a real-world example using Node.js as our server. However, note that Redis is versatile and works with various servers and languages. We'll cover the code implementation and explore how to leverage Redis to optimize query performance.

Conclusion:

Caching with Redis is a powerful technique for enhancing the speed and efficiency of data retrieval in applications with high query volumes. Stay tuned for the upcoming sections where we'll practically implement Redis caching in a Node.js environment.

Stay connected for the next section, where we'll guide you through downloading Redis on your local machine. Redis is a valuable tool in your development arsenal, regardless of the server or language you're working with. See you in the next section!

Dynamic rate-limiting middleware in Express

Jayvee Ramos — Tue, 14 Nov 2023 02:39:26 +0000

To create a dynamic rate-limiting middleware in Express that can be used at different levels (controller, app, router), you can use the express-rate-limit package. This middleware can be configured dynamically based on the parameters you pass.

Here's an example of a custom rate-limiting middleware that can be used at different levels in Express:

First, install the express-rate-limit package:

npm install express-rate-limit

Then, create a module that exports a function to generate the rate-limiting middleware dynamically:

// rateLimitMiddleware.js

const rateLimit = require("express-rate-limit");

function createRateLimitMiddleware(options) {
  // You can configure the rate limit dynamically using the options parameter
  const limiter = rateLimit({
    windowMs: options.windowMs || 60 * 1000, // 1 minute by default
    max: options.max || 100, // 100 requests per windowMs by default
    message: options.message || "Too many requests, please try again later."
  });

  return limiter;
}

module.exports = createRateLimitMiddleware;

Next, in your Express application, you can use this dynamically created rate-limiting middleware in different levels:

At the App Level:

const express = require("express");
const app = express();
const createRateLimitMiddleware = require("./rateLimitMiddleware");

// Apply rate limiting for the entire app
const appLevelRateLimiter = createRateLimitMiddleware({
  windowMs: 60 * 60 * 1000, // 1 hour
  max: 1000, // 1000 requests per hour
});

app.use(appLevelRateLimiter);
// Other app configurations and routes

At the Router/Route Level:

const express = require("express");
const router = express.Router();
const createRateLimitMiddleware = require("./rateLimitMiddleware");

// Apply rate limiting for a specific router
const routerLevelRateLimiter = createRateLimitMiddleware({
  windowMs: 60 * 1000, // 1 minute
  max: 30, // 30 requests per minute
});

router.use(routerLevelRateLimiter);
// Define router paths and their respective handlers

At the Controller Level (per route):

const express = require("express");
const router = express.Router();
const createRateLimitMiddleware = require("./rateLimitMiddleware");

// Apply rate limiting for specific routes/controllers
const specificRouteRateLimiter = createRateLimitMiddleware({
  windowMs: 60 * 1000, // 1 minute
  max: 10, // 10 requests per minute
});

router.get("/specific-route", specificRouteRateLimiter, (req, res) => {
  // Controller logic for the specific route
});

This setup allows you to dynamically configure rate-limiting based on your specific needs at different levels within your Express application. Adjust the parameters in the options object passed to createRateLimitMiddleware to fit your requirements.

13.1 Payment Integration

Jayvee Ramos — Tue, 07 Nov 2023 03:28:42 +0000

Introduction:

In this tutorial, we will continue our journey of building a microservice-based reservation system with payment integration using NestJS. We've previously covered setting up the communication between the reservation and payment services. In this post, we will focus on billing the user and implementing validation.

Billing the User

Before we create a reservation in our database, we want to bill the user using the newly created CreateChargeDTO and our payments service.
update your reservations.service.ts with the following content:

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

import { ReservationsRepository } from './reservations.repository';
import { CreateReservationDto } from './dto/create-reservation.dto';
import { UpdateReservationDto } from './dto/update-reservation.dto';
import { PAYMENTS_SERVICE } from '@app/common';
import { ClientProxy } from '@nestjs/microservices';
import { map } from 'rxjs';

@Injectable()
export class ReservationsService {
  constructor(
    private readonly reservationsRepository: ReservationsRepository,
    @Inject(PAYMENTS_SERVICE) private readonly payment_service: ClientProxy,
  ) {}

  async create(createReservationDto: CreateReservationDto, userId: string) {
    return this.payment_service
      .send('create_charge', createReservationDto.charge)
      .pipe(
        map(async () => {
          return this.reservationsRepository.create({
            ...createReservationDto,
            timestamp: new Date(),
            userId,
          });
        }),
      );
  }

  async findAll() {
    return this.reservationsRepository.find({});
  }

  async findOne(_id: string) {
    return this.reservationsRepository.findOne({ _id });
  }

  async update(_id: string, updateReservationDto: UpdateReservationDto) {
    return this.reservationsRepository.findOneAndUpdate(
      { _id },
      { $set: updateReservationDto },
    );
  }

  async remove(_id: string) {
    return this.reservationsRepository.findOneAndDelete({ _id });
  }
}

Dynamic Invoice IDs

Instead of hardcoding the invoice ID, let's extract it from the Stripe response, to ensure that it correlates the reservation with the Stripe charge. This dynamic approach ensures accurate invoice tracking.

Update the Create Reservation DTO: (create-reservation.dto.ts)

import { CreateChargeDto } from '@app/common';
import { Type } from 'class-transformer';
import { IsDate, IsDefined, IsNotEmpty, ValidateNested } from 'class-validator';

export class CreateReservationDto {
  @IsDate()
  @Type(() => Date)
  startDate: Date;

  @IsDate()
  @Type(() => Date)
  endDate: Date;

  @Type(() => CreateChargeDto)
  @IsDefined()
  @IsNotEmpty()
  @ValidateNested()
  charge: CreateChargeDto;
}

We removed the user-supplied invoice ID field and
eliminate unused fields place ID.

Update the Reservation Schema:(reservation.entity.ts)

import { AbstractDocument } from '@app/common';
import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';

@Schema({ versionKey: false })
export class ReservationDocument extends AbstractDocument {
  @Prop({ type: Date, default: Date.now })
  timestamp: Date;

  @Prop({ type: Date, required: true })
  startDate: Date;

  @Prop({ type: Date, required: true })
  endDate: Date;

  @Prop({ type: String, required: true })
  userId: string;

  @Prop({ type: String, required: true })
  invoiceId: string;
}

export const ReservationSchema =
  SchemaFactory.createForClass(ReservationDocument);

We removed the place ID field since it is not being used and retained the invoice ID field to store the dynamically extracted ID.

Update your reservations.service.ts with the following content:

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

import { ReservationsRepository } from './reservations.repository';
import { CreateReservationDto } from './dto/create-reservation.dto';
import { UpdateReservationDto } from './dto/update-reservation.dto';
import { PAYMENTS_SERVICE } from '@app/common';
import { ClientProxy } from '@nestjs/microservices';
import { map } from 'rxjs';

@Injectable()
export class ReservationsService {
  constructor(
    private readonly reservationsRepository: ReservationsRepository,
    @Inject(PAYMENTS_SERVICE) private readonly payment_service: ClientProxy,
  ) {}

  async create(createReservationDto: CreateReservationDto, userId: string) {
    return this.payment_service
      .send('create_charge', createReservationDto.charge)
      .pipe(
        map(async (res) => {
          return this.reservationsRepository.create({
            ...createReservationDto,
            timestamp: new Date(),
            invoiceId: res.id,
            userId,
          });
        }),
      );
  }

  async findAll() {
    return this.reservationsRepository.find({});
  }

  async findOne(_id: string) {
    return this.reservationsRepository.findOne({ _id });
  }

  async update(_id: string, updateReservationDto: UpdateReservationDto) {
    return this.reservationsRepository.findOneAndUpdate(
      { _id },
      { $set: updateReservationDto },
    );
  }

  async remove(_id: string) {
    return this.reservationsRepository.findOneAndDelete({ _id });
  }
}

When creating a reservation, we send a request to Stripe to create a payment intent.
In the response from Stripe, we extract the payment intent ID, which serves as the invoice ID.
We use this extracted invoice ID to correlate the reservation with the Stripe charge.

Conclusion:

In this tutorial, we've extended our microservice-based reservation system with payment integration, focusing on billing the user and implementing robust validation. We've also shown how to handle unauthorized requests and dynamically extract invoice IDs for precise tracking. Furthermore, by using default test cards, we ensure secure payment processing. This comprehensive guide will help you build a robust and secure reservation system with payment capabilities using NestJS. Happy coding!

13. Integrating and Validating Payment Services in a Reservation System

Jayvee Ramos — Tue, 07 Nov 2023 03:28:27 +0000

Introduction:

In this tutorial, we will walk you through the process of integrating a payment service with a reservation service. This integration will enable your application to bill users for reservations. We will also cover the validation of input data to ensure data consistency and security.

Step 1: Define Payment Service

Define PAYMENTS_SERVICE in your libs/common/src/constants/service.ts

service.ts

export const AUTH_SERVICE = 'auth';
export const PAYMENTS_SERVICE = 'payments';

Step 2: Modify Reservation Module

To enable the reservation service to communicate with the payment service, we first need to set up the payment service as a client. In your reservations module, inject the payment service using an injection token:

import { Module } from '@nestjs/common';
import { ReservationsService } from './reservations.service';
import { ReservationsController } from './reservations.controller';
import {
  AUTH_SERVICE,
  DatabaseModule,
  LoggerModule,
  PAYMENTS_SERVICE,
} from '@app/common';
import { ReservationsRepository } from './reservations.repository';
import {
  ReservationDocument,
  ReservationSchema,
} from './entities/reservation.entity';
import { ConfigModule, ConfigService } from '@nestjs/config';
import * as Joi from 'joi';
import { ClientsModule, Transport } from '@nestjs/microservices';

@Module({
  imports: [
    DatabaseModule,
    DatabaseModule.forFeature([
      { name: ReservationDocument.name, schema: ReservationSchema },
    ]),
    LoggerModule,
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: Joi.object({
        MONGODB_URI: Joi.string().required(),
        PORT: Joi.number().required(),
        AUTH_HOST: Joi.string().required(),
        AUTH_PORT: Joi.number().required(),
      }),
    }),
    ClientsModule.registerAsync([
      {
        name: AUTH_SERVICE,
        useFactory: (configService: ConfigService) => ({
          transport: Transport.TCP,
          options: {
            host: configService.get('AUTH_HOST'),
            port: configService.get('AUTH_PORT'),
          },
        }),
        inject: [ConfigService],
      },
      {
        name: PAYMENTS_SERVICE,
        useFactory: (configService: ConfigService) => ({
          transport: Transport.TCP,
          options: {
            host: configService.get('PAYMENTS_HOST'),
            port: configService.get('PAYMENTS_PORT'),
          },
        }),
        inject: [ConfigService],
      },
    ]),
  ],
  controllers: [ReservationsController],
  providers: [ReservationsService, ReservationsRepository],
})
export class ReservationsModule {}

Step 3: Configure Environment Variables

Since we are using two new environment variables, PAYMENTS_HOST and PAYMENTS_PORT, which do not yet exist in our .env file, let's go ahead and define them. Please open your payments .env file and modify its content with the following code.

MONGODB_URI=mongodb://mongo:27017/reservation
PORT=3000
AUTH_HOST=auth
AUTH_PORT=3002
PAYMENTS_HOST=payments
PAYMENTS_PORT=3003

Step 4: Inject the Payment Service

Inject the payment service using NestJS's @Inject decorator and call it as a client proxy for microservices. Ensure that the import statement is correct.
update your reservations.service.ts with this content:

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

import { ReservationsRepository } from './reservations.repository';
import { CreateReservationDto } from './dto/create-reservation.dto';
import { UpdateReservationDto } from './dto/update-reservation.dto';
import { PAYMENTS_SERVICE } from '@app/common';
import { ClientProxy } from '@nestjs/microservices';

@Injectable()
export class ReservationsService {
  @Inject(PAYMENTS_SERVICE) payment_service: ClientProxy;
  constructor(
    private readonly reservationsRepository: ReservationsRepository,
  ) {}

  async create(createReservationDto: CreateReservationDto, userId: string) {
    return this.reservationsRepository.create({
      ...createReservationDto,
      timestamp: new Date(),
      userId,
    });
  }

  async findAll() {
    return this.reservationsRepository.find({});
  }

  async findOne(_id: string) {
    return this.reservationsRepository.findOne({ _id });
  }

  async update(_id: string, updateReservationDto: UpdateReservationDto) {
    return this.reservationsRepository.findOneAndUpdate(
      { _id },
      { $set: updateReservationDto },
    );
  }

  async remove(_id: string) {
    return this.reservationsRepository.findOneAndDelete({ _id });
  }
}

This step allows you to use the payment service for billing users when creating reservations.

Step 5: Creating Card DTO

Create a separate CardDTO to validate the credit card details. We will do it inside our libs/common/src/dto folder to allow us to use the CardDTO anywhere in our apps to avoid duplication:

touch libs/common/src/dto/card.dto.ts
touch libs/common/src/dto/create-charge.dto.ts

populate your card.dto.ts with the following content:

import { IsCreditCard, IsNotEmpty, IsNumber, IsString } from 'class-validator';

export class CardDTO {
  @IsString()
  @IsNotEmpty()
  cvc: string;

  @IsNumber()
  exp_month: number;

  @IsNumber()
  exp_year: number;

  @IsCreditCard()
  number: string;
}

populate your create-charge.dto.ts with the following content:

import { CardDTO } from './card.dto';
import { Type } from 'class-transformer';
import {
  IsDefined,
  IsNotEmpty,
  ValidateNested,
  IsNumber,
} from 'class-validator';

export class CreateChargeDto {
  @Type(() => CardDTO)
  @IsDefined()
  @IsNotEmpty()
  @ValidateNested()
  card: CardDTO;

  @IsNumber()
  amount: number;
}

Make sure to update the libs/common/src/dto/index.ts and export the newly created CardDTO and CreateChargeDto

export * from './user.dto';
export * from './card.dto';
export * from './create-charge.dto';

Please remember that we have already created a 'create-charge.dto' in our payments app. We need to delete the existing one and replace it with the newly created 'create-charge.dto' located inside our common folder. This change is necessary because we have not applied any validation to the 'create-charge.dto' in our payments app.

update your paymens.controller.ts with the following content to use our newly created create-charge.dto.ts in our @app/common:

import { Controller } from '@nestjs/common';
import { PaymentsService } from './payments.service';
import { MessagePattern, Payload } from '@nestjs/microservices';
import { CreateChargeDto } from '@app/common';

@Controller()
export class PaymentsController {
  constructor(private readonly paymentsService: PaymentsService) {}

  @MessagePattern('create_charge')
  async createcharge(@Payload() data: CreateChargeDto) {
    return this.paymentsService.createCharge(data);
  }
}

Step 6: Updating the Create Reservation DTO

To facilitate billing for reservations, update the Create Reservation DTO to include a card property.

In your reservation app inside the dto folder, Open your create-reservation.dto.ts file and update with this content:

import { CardDTO } from '@app/common';
import { Type } from 'class-transformer';
import {
  IsDate,
  IsDefined,
  IsNotEmpty,
  IsNumber,
  IsString,
  ValidateNested,
} from 'class-validator';

export class CreateReservationDto {
  @IsDate()
  @Type(() => Date)
  startDate: Date;

  @IsDate()
  @Type(() => Date)
  endDate: Date;

  @IsString()
  @IsNotEmpty()
  placeId: string;

  @IsString()
  @IsNotEmpty()
  invoiceId: string;

  @Type(() => CardDTO)
  @IsDefined()
  @IsNotEmpty()
  @ValidateNested()
  card: CardDTO;

  @IsNumber()
  amount: number;
}

Step 7: Test Your DTO

Test Scenario: Reservation Creation with Validation
Request Details:

Method: POST
Endpoint: http://localhost:3000/reservations
Test Steps:

Invalid Card Information missing cvc

Send a POST request with the following payload:

{
  "startDate": "2023-11-01",
  "endDate": "2023-11-05",
  "placeId": "1232",
  "invoiceId": "67890",
  "charge": {
   "card": {
    "exp_month": 12,     
    "exp_year": 2025,      
    "number": "4242 4242 4242 4242"  
  },
  "amount": 99.99
  }
}

Check the response for validation errors, especially for the "cvc" field.

Valid Card Information

Send a POST request with the following payload:

{
  "startDate": "2023-11-01",
  "endDate": "2023-11-05",
  "placeId": "1232",
  "invoiceId": "67890",
  "charge": {
   "card": {
    "cvc": "123",
    "exp_month": 12,     
    "exp_year": 2025,      
    "number": "4242 4242 4242 4242"  
  },
  "amount": 99.99
  }
}

Check the response for a successful reservation creation.

Expected Outcomes:

In Step 1, you should receive a validation error response indicating that the "cvc" field is incorrect.

In Step 2, you should receive a successful reservation creation response.

This scenario will help you verify if the validation is working correctly and if the reservation creation is functioning as expected.

Conclusion:

You've successfully integrated and validated the payment service in your reservation system. With robust schema validation and proper data exchange, you can ensure a reliable and secure booking process. This tutorial provides a foundation for building more complex systems and enhancing the capabilities of your microservices. Happy coding!

In the next lesson, we will connect it with our Stripe to persist our payments and make a few modifications to our payment service. This will be our last lesson in payment integration.

12. Payment Processing with Stripe API

Jayvee Ramos — Tue, 07 Nov 2023 03:28:11 +0000

Introduction

In today's tutorial, we will guide you through creating a microservice for processing payments in your reservation system using the Stripe API. This microservice will handle the task of billing customers when they book reservations, and we'll take you through each step to set it up.

Let's get started!

Step 1: Creating a New NestJS App

To kick things off, we'll use the Nest CLI to generate a new app. Open your terminal and run the following command:

nest generate app payments

This command creates a new NestJS application named "payments" for handling payments in your reservation system. It includes a default controller and a basic payments module.

Step 2: Docker Configuration

Next, we'll set up Docker for this microservice. I will not explain this code because we already tackled it in our previous tutorials

touch apps/payments/Dockerfile

it will create a Dockerfile inside the payments folder now populate it with this content:

# Use Node Alpine as the base image for development
FROM node:alpine as development

WORKDIR /usr/src/app

COPY package.json package-lock.json ./
RUN npm install -g && npm install

COPY . .

RUN npm run build

# Create a production image
FROM node:alpine as production

ARG NODE_ENV=production
ENV NODE_ENV=${NODE_ENV}

WORKDIR /usr/src/app

COPY package.json package-lock.json ./
RUN npm install --only=production

COPY --from=development /usr/src/app/dist ./dist
COPY --from=development /usr/src/app/package.json ./package.json

CMD [ "node", "dist/apps/payments/main" ]

What we did was just Copy the Docker file from your reservations app and place it in the payments app folder. In the Docker file, we changed the startup command to point to the dist/apps/payments folder.

Update docker-compose.yaml - Now, update your Docker Compose file to include the payments service. Make sure to specify a unique port (e.g., 3003) and expose it for the payments microservice.

Open your docker-compose file and update it with the following content to include payment service:

services:
  reservations:
    build:
      context: .
      dockerfile: apps/reservations/Dockerfile
      target: development
    command: npm run start:dev reservations
    env_file:
      - ./apps/reservations/.env
    ports:
      - '3000:3000'
    volumes:
      - .:/usr/src/app
  auth:
    build:
      context: .
      dockerfile: apps/auth/Dockerfile
      target: development
    command: npm run start:dev auth
    env_file:
      - apps/auth/.env
    ports:
      - '3001:3001'
    volumes:
      - .:/usr/src/app
  payments:
    build:
      context: .
      dockerfile: apps/payments/Dockerfile
      target: development
    command: npm run start:dev payments
    env_file:
      - apps/payments/.env
    ports:
      - '3003:3003'
    volumes:
      - .:/usr/src/app
  mongo:
    image: mongo

Step 3: Configuring the Microservice

In the payments folder, open the main.ts file and turn this app into a standalone microservice. Update it with the following content:

import { NestFactory } from '@nestjs/core';
import { PaymentsModule } from './payments.module';
import { Logger } from 'nestjs-pino';
import { Transport } from '@nestjs/microservices';
import { ConfigService } from '@nestjs/config';

async function bootstrap() {
  const app = await NestFactory.create(PaymentsModule);
  const configService = app.get(ConfigService);
  app.connectMicroservice({
    transport: Transport.TCP,
    options: {
      host: '0.0.0.0',
      port: configService.get('PORT'),
    },
  });

  app.useLogger(app.get(Logger));

  await app.startAllMicroservices();
}
bootstrap();

We just configure the transport as "transport.TCP" and set the port using the config service. But since we are using a PORT environment variable which does not yet exist in the payments service we should now create a .env file and specify the PORT variables

touch apps/payments/.env

populate it with the following code:

PORT=3003

Then on your config module in the payments module (payments.module.ts) set it up as we did for the auth service. This allows you to access and validate the PORT environment variable as follows:

import { Module } from '@nestjs/common';
import { PaymentsController } from './payments.controller';
import { PaymentsService } from './payments.service';
import * as Joi from 'joi';
import { ConfigModule } from '@nestjs/config';
import { LoggerModule } from '@app/common';

@Module({
  imports: [
    LoggerModule,
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: Joi.object({
        PORT: Joi.number().required(),
        STRIPE_SECRET_KEY: Joi.string().required(), //we will set up this on step 4
      }),
    }),
  ],
  controllers: [PaymentsController],
  providers: [PaymentsService],
})
export class PaymentsModule {}

Step 4: Setting up the Stripe API

Before you can start processing payments, you need to set up a Stripe account. Head to Stripe's website, sign up for an account, and create an account within your dashboard.

In your Stripe dashboard, you will find your publishable key and secret key. We will use the secret key for API calls, so make sure to set it as an environment variable in your .env file.

update your payments .env file and include your secret_key which you got from your stripe dashboard:

PORT=3003
STRIPE_SECRET_KEY=sk_test_51NZp96JyPkGHZlunZYLEUwARyNBuxHbJ3tVFat6XtJxSxLwhJgIxMdeC4wtt42WkrWCM3H20yRVeMkc9SW38Uprt00xPMCJIDR

Make sure to use your own secret key, the secret key I provided is deactivated

Next, install the Node.js Stripe API client library with the following command:

npm install stripe

Step 5: Initializing the Stripe Client

let's create a DTO (Data Transfer Object) first

mkdir apps/payments/src/dto
touch apps/payments/src/dto/create-charge.dto.ts

it will create a new directory named dto inside your payments folder then inside dto it will create a file named create-charge.dto.ts

populate the create-charge.dto.ts with this content:

import Stripe from 'stripe';

export class CreateChargeDto {
  card: Stripe.PaymentMethodCreateParams.Card1;
  amount: number;
}

We can now use this CreatechargeDto to our controller and service

Open your payments.service.ts and populate it with the following content:

import { Injectable } from '@nestjs/common';
import { ConfigService } from '@nestjs/config';
import Stripe from 'stripe';
import { CreateChargeDto } from './dto/create-charge.dto';

@Injectable()
export class PaymentsService {
  private readonly stripe = new Stripe(
    this.configService.get('STRIPE_SECRET_KEY'),
    {
      apiVersion: '2023-10-16',
    },
  );
  constructor(private readonly configService: ConfigService) {}

  async createCharge({ amount }: CreateChargeDto) {
    const paymentIntent = await this.stripe.paymentIntents.create({
      amount: amount * 100,
      automatic_payment_methods: {
        enabled: true,
        allow_redirects: 'never',
      },
      confirm: true,
      payment_method: 'pm_card_visa',
      currency: 'usd',
    });

    return paymentIntent;
  }
}

In the payments service, we created a private read-only variable to initialize the Stripe client using your secret key from the config service. and we set up the API version as well.

We also create a payment charge. using the Payment Intents API provided by Stripe for secure payment processing. We created a new payment method and then charged the user.

We created a payment intent with the payment method and charge amount.
We set the confirm the payment intent to true to charge the user immediately.
We add an async method called** createCharge** to handle payment charges. Define the parameters, such as the card details and the amount to charge.

Step 7: Exposing the Payment Service

To make the payment service accessible to other microservices, set up a new async route in the payments controller decorated with the @MessagePattern decorator. Extract the payload and define a dedicated DTO for the data being passed to the create charge method.

Open your payment.controller.ts then update its content with this code:

import { Controller, UsePipes, ValidationPipe } from '@nestjs/common';
import { PaymentsService } from './payments.service';
import { MessagePattern, Payload } from '@nestjs/microservices';
import { CreateChargeDto } from '@app/common';

@Controller()
export class PaymentsController {
  constructor(private readonly paymentsService: PaymentsService) {}

  @MessagePattern('create_charge')
  @UsePipes(new ValidationPipe())
  async createcharge(@Payload() data: CreateChargeDto) {
    return this.paymentsService.createCharge(data);
  }
}

We use NestJS's built-in validation pipes to validate the incoming metadata on the payload.

Conclusion

Congratulations! You've successfully created a microservice for processing payments using the Stripe API. This service can be integrated into your reservation system to handle payment processing securely. With the right configuration and integration, your application is ready to bill customers for their reservations.

In the next lessons, we will integrate and test it with our reservations.

11. Implementing Authentication in Microservices with NestJS

Jayvee Ramos — Tue, 07 Nov 2023 03:27:58 +0000

Introduction:

In a microservices architecture, securing your services and routes is of paramount importance. One way to achieve this is by implementing authentication. This blog post will guide you through the process of adding JWT-based authentication to your routes in a NestJS-based microservices setup. We'll create a common JWT authentication guard that can be reused across various microservices to protect routes, ensuring that only authenticated users can access them.

Prerequisites:

Before getting started, make sure you have the following prerequisites in place:

A basic understanding of NestJS and microservices.
NestJS installed.
Docker and Docker Compose for containerization.
Postman (or any other API testing tool) for testing your routes.

Step 1: Setting up Microservices with NestJS

To enable communication between microservices, you'll need to set up a transport layer. We'll use a TCP-based transport layer for this tutorial. Start by installing the necessary NestJS microservices package:

npm install @nestjs/microservices

Once installed, make sure to update the content of your apps/auth/src/main.ts file in your authentication service with the following content:

import { NestFactory } from '@nestjs/core';
import { AuthModule } from './auth.module';
import { ValidationPipe } from '@nestjs/common';
import { Logger } from 'nestjs-pino';
import { ConfigService } from '@nestjs/config';
import * as cookieParser from 'cookie-parser';
import { Transport } from '@nestjs/microservices';

async function bootstrap() {
  const app = await NestFactory.create(AuthModule);
  const configService = app.get(ConfigService);
  app.connectMicroservice({
    transport: Transport.TCP,
    options: {
      host: '0.0.0.0',
      port: configService.get('TCP_PORT'),
    },
  });
  app.use(cookieParser());
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
    }),
  );
  app.useLogger(app.get(Logger));

  await app.startAllMicroservices();
  await app.listen(configService.get('HTTP_PORT'));
}
bootstrap();

Our host property 0.0.0.0, which tells the microservice to bind to all interfaces on the host, and then for the port, I extract this from the environment.
we call this environment variable TCP_PORT.

I also changed the PORT variable for our HTTP server and called this HTTP_PORT

This configuration allows your authentication service to communicate with other services via TCP.

since we are using a new environment variable and renaming the old variable PORT to HTTP_PORT which is not yet declared in our auth .env file let's update our .env file and add the HTTP_PORT and TCP_PORT

JWT_SECRET=your_secret_key
JWT_EXPIRATION=3600
HTTP_PORT=3001
TCP_PORT=3002

Remember that we validated all our environment variables in our auth module so we need also to update our auth.module.ts with the following content:

import { Module } from '@nestjs/common';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UsersModule } from './users/users.module';
import { LoggerModule } from '@app/common';
import { JwtModule } from '@nestjs/jwt';
import { ConfigModule, ConfigService } from '@nestjs/config';
import * as Joi from 'joi';
import { LocalStrategy } from './strategies/local.strategy';
import { JwtStrategy } from './strategies/jwt.strategy';

@Module({
  imports: [
    UsersModule,
    LoggerModule,
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: Joi.object({
        JWT_SECRET: Joi.string().required(),
        JWT_EXPIRATION: Joi.string().required(),
        HTTP_PORT: Joi.number().required(),
        TCP_PORT: Joi.number().required(),
      }),
    }),
    JwtModule.registerAsync({
      useFactory: (configService: ConfigService) => ({
        secret: configService.get<string>('JWT_SECRET'),
        signOptions: {
          expiresIn: `${configService.get<string>('JWT_EXPIRATION')}s`,
        },
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, LocalStrategy, JwtStrategy],
})
export class AuthModule {}

Step 2: Creating a Common JWT Auth Guard

The next step is to create a common JWT authentication guard that can be used across different services. This guard will validate JWT tokens passed in requests. To do this, create a new folder in your common directory for auth-related components:

mkdir libs/common/src/auth
touch libs/common/src/auth/jwt-auth.guard.ts
touch libs/common/src/auth/index.ts

it will create an auth directory in your common library then inside that directory it will create two files the index.ts and the jwt-auth.guard.ts

let's also create a constants folder inside our common library in which all our services stored in constant variable will live:

mkdir libs/common/src/constants
touch libs/common/src/constants/service.ts
touch libs/common/src/constants/index.ts

populate your constants/service.ts with the following content:

export const AUTH_SERVICE = 'auth';

Also populate your constants/index.ts with the following content:

export * from './service';

since we created the necessary files and folders we need let's now populate our auth/jwt-auth.guard.ts with the following content:

import {
  CanActivate,
  ExecutionContext,
  Inject,
  Injectable,
} from '@nestjs/common';
import { Observable, of } from 'rxjs';
import { ClientProxy } from '@nestjs/microservices';
import { Request } from 'express';

import { catchError, map, tap } from 'rxjs/operators';
import { AUTH_SERVICE } from '../constants/service';

@Injectable()
export class JwtAuthGuard implements CanActivate {
  constructor(@Inject(AUTH_SERVICE) private readonly authClient: ClientProxy) {}

  canActivate(
    context: ExecutionContext,
  ): boolean | Promise<boolean> | Observable<boolean> {
    const jwt =
      context.switchToHttp().getRequest().cookies?.Authentication ||
      context.switchToHttp().getRequest()?.Authentication ||
      context.switchToHttp().getRequest().headers?.Authentication;
    console.log('jwt', jwt);

    if (!jwt) {
      return false;
    }

    return this.authClient
      .send('authenticate', {
        Authentication: jwt,
      })
      .pipe(
        tap((res) => {
          context.switchToHttp().getRequest<Request>().user = res;
        }),
        map(() => true),
        catchError(() => of(false)),
      );
  }
}

This JwtAuthGuard will check for the JWT token in the request's cookies. If a valid token is found, it communicates with the authentication service using the defined pattern and checks if the JWT is valid. If it's valid, it sets the user on the request object and allows the request to proceed.

In the libs/common/src/auth/index.ts file export your jwt-auth.guard.ts by populating it with this content:

//auth/index.ts
export * from './jwt-auth.guard';

also in the libs/common/src/index.ts file add export all from the auth folder and from constants folder by updating it with this content:

export * from './database';
export * from './logger';
export * from './auth';
export * from './constants';

Step 3: Adding a Message Pattern for Authentication

In your authentication service, set up a message pattern that corresponds to the authentication flow. In the apps/auth/src/auth.controller.ts of your auth service, update your content with the following code:

import { Controller, Post, Res, UseGuards } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalAuthGuard } from './guards/local.auth-guard';
import { CurrentUser } from './current-user.decorator';
import { UserDocument } from './users/models/user.schema';
import { Response } from 'express';
import { MessagePattern } from '@nestjs/microservices';
import { JwtAuthGuard } from './guards/jwt-auth.guard';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @UseGuards(LocalAuthGuard)
  @Post('login')
  async login(
    @CurrentUser() user: UserDocument,
    @Res({ passthrough: true }) response: Response,
  ) {
    await this.authService.login(user, response);
    response.send(user);
  }

  @UseGuards(JwtAuthGuard)
  @MessagePattern('authenticate')
  async authenticate(@Payload() data: any) {
    return data.user;
  }
}

This code sets up a message pattern named authenticate that can be used to authenticate JWT tokens we are using are existing JWTAUthGuard to do that.

We also need to update our apps/auth/src/strategies/jwt.strategy.ts because right now we are pulling the JWT off of the request header in the cookies object. However, when the JWT is coming in from our RPC call our JwtAuthGuard, it's not going to be inside of a cookies object.
It's just going to be under the straight request object.

So we can put in a bit of logic here to say if there is no request cookie, we can then check to see if the authentication key actually exists on the request object itself:

import { Injectable } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy, ExtractJwt } from 'passport-jwt';
import { UsersService } from '../users/users.service';
import { ConfigService } from '@nestjs/config';
import { Tokenpayload } from '../interface/token-payload.interface';
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(
    configService: ConfigService,
    private readonly userService: UsersService,
  ) {
    super({
      jwtFromRequest: ExtractJwt.fromExtractors([
        (request: any) =>
          request?.cookies?.Authentication ||
          request?.Authentication ||
          request?.headers.Authentication,
      ]),
      secretOrKey: configService.get('JWT_SECRET'),
    });
  }

  async validate({ userId }: Tokenpayload) {
    return this.userService.getUser({ _id: userId });
  }
}

Step 4: Registering the Authentication Service as a Client

In the reservations service (or any other service that needs authentication), you need to register the authentication service as a client. Modify the reservations.module.ts file as follows:

import { Module } from '@nestjs/common';
import { ReservationsService } from './reservations.service';
import { ReservationsController } from './reservations.controller';
import { AUTH_SERVICE, DatabaseModule, LoggerModule } from '@app/common';
import { ReservationsRepository } from './reservations.repository';
import {
  ReservationDocument,
  ReservationSchema,
} from './entities/reservation.entity';
import { ConfigModule, ConfigService } from '@nestjs/config';
import * as Joi from 'joi';
import { ClientsModule, Transport } from '@nestjs/microservices';

@Module({
  imports: [
    DatabaseModule,
    DatabaseModule.forFeature([
      { name: ReservationDocument.name, schema: ReservationSchema },
    ]),
    LoggerModule,
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: Joi.object({
        MONGODB_URI: Joi.string().required(),
        PORT: Joi.number().required(),
      }),
    }),
    ClientsModule.registerAsync([
      {
        name: AUTH_SERVICE,
        useFactory: (configService: ConfigService) => ({
          transport: Transport.TCP,
          options: {
            host: configService.get('AUTH_HOST'),
            port: configService.get('AUTH_PORT'),
          },
        }),
        inject: [ConfigService],
      },
    ]),
  ],
  controllers: [ReservationsController],
  providers: [ReservationsService, ReservationsRepository],
})
export class ReservationsModule {}

This code registers the authentication service as a client using the TCP transport layer.

since we are using two new environment variable which is not yet declared in our reservations .env file let's update our .env file and add the AUTH_HOST and AUTH_PORT

MONGODB_URI=mongodb://mongo:27017/reservation
PORT=3000
AUTH_HOST=auth
AUTH_PORT=3002

So the AUTH_HOST is actually defined in the docker-compose.yaml services by the actual names of the services we defined.

So the hostname for auth will be auth and the hostname for reservations is reservations running in Docker.
So we set the auth host here to just be auth.
And the AUTH_PORT we set to 3002, which corresponds to the TCP_PORT we define in the auth service.

Step 5: User Extraction and DTO:

user.dto.ts
We want to make the user object accessible across our application. For this, we'll define a Data Transfer Object (DTO) for the user. This will ensure that the user data is consistent when sent over the network. Here's how you can create the user DTO:

mkdir libs/common/src/dto
touch libs/common/src/dto/user.dto.ts
touch libs/common/src/dto/index.ts

it will create a dto directory in your common library and then inside that directory, it will create two files the index.ts and the user.dto.ts

populate your user.dto.ts with the following content:

export interface UserDTO {
  _id: string;
  email: string;
  password: string;
}

export your newly created UserDTO in your index.ts by populating it with the following code:

export * from './user.dto';

current-user.decorator.ts
To access the current user in your routes, you can create a decorators folder. Create a current-user.decorator.ts file in the libs/common/src/decorators directory:

mkdir libs/common/src/decorators
touch libs/common/src/decorators/current-user.decorator.ts
touch libs/common/src/decorators/index.ts

it will create a decorators directory in your common library and then inside that directory, it will create two files the index.ts and the current-user.decorator.ts

populate your current-user.decorator.ts with this content:

import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { UserDocument } from 'apps/auth/src/users/models/user.schema';

const getCurrentUserByContex = (ctx: ExecutionContext): UserDocument => {
  return ctx.switchToHttp().getRequest().user;
};
export const CurrentUser = createParamDecorator(
  (_data: unknown, ctx: ExecutionContext) => getCurrentUserByContex(ctx),
);

export your newly created CurrentUser decorator in your index.ts by populating it with the following code:

export * from './current-user.decorator';

to use our user.dto.ts and current-user.decorator of all our services we need to make sure that we export it in our libs/common/src/index.ts file: update your index.ts file with this content:

export * from './database';
export * from './logger';
export * from './auth';
export * from './constants';
export * from './dto';
export * from './decorators';

We're ready to integrate our newly created common JwtAuthGuard into our reservations routes to lock them down to only authenticated users.

Open your reservationmain.ts file and update with he following content to use cookie parser middleware:

import { NestFactory } from '@nestjs/core';
import { ReservationsModule } from './reservations/reservations.module';
import { ValidationPipe } from '@nestjs/common';
import { Logger } from 'nestjs-pino';
import { ConfigService } from '@nestjs/config';
import * as cookieParser from 'cookie-parser';

async function bootstrap() {
  const app = await NestFactory.create(ReservationsModule);
  app.use(cookieParser());
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
    }),
  );
  app.useLogger(app.get(Logger));
  const configService = app.get(ConfigService);
  await app.listen(configService.get('PORT'));
}
bootstrap();

Open your reservations service (reservations.service.ts) and replace the existing code with the following to dynamically fetch the user ID of the currently authenticated user, instead of hardcoding it.

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

import { ReservationsRepository } from './reservations.repository';
import { CreateReservationDto } from './dto/create-reservation.dto';
import { UpdateReservationDto } from './dto/update-reservation.dto';

@Injectable()
export class ReservationsService {
  constructor(
    private readonly reservationsRepository: ReservationsRepository,
  ) {}

  async create(createReservationDto: CreateReservationDto, userId: string) {
    return this.reservationsRepository.create({
      ...createReservationDto,
      timestamp: new Date(),
      userId,
    });
  }

  async findAll() {
    return this.reservationsRepository.find({});
  }

  async findOne(_id: string) {
    return this.reservationsRepository.findOne({ _id });
  }

  async update(_id: string, updateReservationDto: UpdateReservationDto) {
    return this.reservationsRepository.findOneAndUpdate(
      { _id },
      { $set: updateReservationDto },
    );
  }

  async remove(_id: string) {
    return this.reservationsRepository.findOneAndDelete({ _id });
  }
}

Open your reservations controller (reservations.controller.ts) and update it with the following content to utilize our common JwtAuthGuard and retrieve the currently authenticated user data. We'll use the newly created CurrentUser decorator with the UserDto type, which is imported from our @app/common.

import {
  Controller,
  Get,
  Post,
  Body,
  Patch,
  Param,
  Delete,
  UseGuards,
} from '@nestjs/common';
import { ReservationsService } from './reservations.service';
import { CreateReservationDto } from './dto/create-reservation.dto';
import { UpdateReservationDto } from './dto/update-reservation.dto';
import { CurrentUser, JwtAuthGuard, UserDTO } from '@app/common';

@Controller('reservations')
export class ReservationsController {
  constructor(private readonly reservationsService: ReservationsService) {}

  @UseGuards(JwtAuthGuard)
  @Post()
  async create(
    @Body() createReservationDto: CreateReservationDto,
    @CurrentUser() user: UserDTO,
  ) {
    return await this.reservationsService.create(
      createReservationDto,
      user._id,
    );
  }

  @Get()
  @UseGuards(JwtAuthGuard)
  async findAll() {
    return this.reservationsService.findAll();
  }

  @Get(':id')
  @UseGuards(JwtAuthGuard)
  async findOne(@Param('id') id: string) {
    return this.reservationsService.findOne(id);
  }

  @Patch(':id')
  @UseGuards(JwtAuthGuard)
  async update(
    @Param('id') id: string,
    @Body() updateReservationDto: UpdateReservationDto,
  ) {
    return this.reservationsService.update(id, updateReservationDto);
  }

  @Delete(':id')
  @UseGuards(JwtAuthGuard)
  async remove(@Param('id') id: string) {
    return this.reservationsService.remove(id);
  }
}

By adding the @UseGuards(JwtAuthGuard) decorator to your route handlers, you ensure that only authenticated users can access these routes.

Conclusion:

In this tutorial, you learned how to add JWT-based authentication to your microservices architecture with NestJS. By creating a common JWT authentication guard, you can easily secure your routes across different services. This approach provides flexibility and reusability, allowing you to enforce authentication in a microservices environment efficiently.

10. Implementing JWT Authentication

Jayvee Ramos — Tue, 07 Nov 2023 03:27:43 +0000

Introduction

In our previous tutorial, we set up local authentication in a Nest.js application to handle user login and authentication. Now, we'll take it a step further and implement JWT (JSON Web Token) authentication to secure routes and endpoints in our application.

Creating the JWT Strategy

Create JWT Strategy: First, we need to create a JWT strategy that validates JWT tokens. Inside your auth/strategies folder, create a new TypeScript file, jwt.strategy.ts, and define the JWT strategy:
run the command to create jwt.strategy.ts

touch apps/auth/src/strategies/jwt.strategy.ts

populate it with the following content

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy, ExtractJwt } from 'passport-jwt';
import { UsersService } from '../users/users.service';
import { ConfigService } from '@nestjs/config';
import { Request } from 'express';
import { Tokenpayload } from '../interface/token-payload.interface';
@Injectable()
export class JwtStrategy extends PassportStrategy(Strategy) {
  constructor(
    private readonly configService: ConfigService,
    private readonly userService: UsersService,
  ) {
    super({
      jwtFromRequest: ExtractJwt.fromExtractors([
        (request: Request) => request.cookies.Authentication, // JWT in a cookie
      ]),
      secretOrKey: configService.get('JWT_SECRET'),
    });
  }

  async validate({ userId }: Tokenpayload) {
    return this.userService.getUser({ _id: userId });  //We will define 'getUser' in the user service later; for now, let's just declare it
  }
}

Creating DTO for getUser

To create get-user.dto.ts inside our user/dto folder run this command on your terminal:

touch apps/auth/src/users/dto/get-user.dto.ts

populate it with the following content:

import { IsNotEmpty, IsString } from 'class-validator';

export class GetUserDto {
  @IsString()
  @IsNotEmpty()
  _id: string;
}

In this DTO, we use the @IsEmail decorator to validate that the email field has a valid email format. This DTO is intended for retrieving a user by their email, and it enforces email format validation.

Implementing getUser method in user service

open your user.service.ts and update the content with the following code:

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { UserRepository } from './user.repository';
import { CreateUserDTO } from './dto/create-user.dto';
import * as bcryptjs from 'bcryptjs';
import { GetUserDto } from './dto/get-user.dto';
@Injectable()
export class UsersService {
  constructor(private readonly userRepository: UserRepository) {}

  async create(createUserDto: CreateUserDTO) {
    return this.userRepository.create({
      ...createUserDto,
      password: await bcryptjs.hash(createUserDto.password, 10),
    });
  }

  async verifyUser(email: string, password: string) {
    const user = await this.userRepository.findOne({ email });
    const passwordIsValid = await bcryptjs.compare(password, user.password);
    if (!passwordIsValid) {
      throw new UnauthorizedException('Invalid credentials');
    }
    return user;
  }

  async getUser(getUserDto: GetUserDto) {
    return this.userRepository.findOne(getUserDto);
  }
}

we just added a getUser method

Creating the JWT Auth Guard

Create JWT Auth Guard: Similar to our local authentication guard, we need an auth guard for JWT. Create a jwt-auth.guard.ts file in your guards folder to do this run this command on your terminal:

touch apps/auth/src/guards/jwt-auth.guard.ts

populate it with the following content:

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

@Injectable()
export class JwtAuthGuard extends AuthGuard('jwt') {}

Using JWT Authentication

Use JWT Auth Guard: You can use the JwtAuthGuard in your controller methods or routes to protect them.

Apply JWT Authentication: In your controllers, you can apply JWT authentication using the @UseGuards decorator. to protect routes: For example, to protect a route that returns the current update your user.controller.ts content with the following code:

import { Body, Controller, Get, Post, UseGuards } from '@nestjs/common';
import { UsersService } from './users.service';
import { CreateUserDTO } from './dto/create-user.dto';
import { JwtAuthGuard } from '../guards/jwt-auth.guard';
import { CurrentUser } from '../current-user.decorator';
import { UserDocument } from './models/user.schema';

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

  @Post()
  async createUser(@Body() createUserDto: CreateUserDTO) {
    return this.userService.create(createUserDto);
  }

  @Get()
  @UseGuards(JwtAuthGuard)
  getCurrentUser(@CurrentUser() user: UserDocument) {
    return user;
  }
}

In the auth module, add the jwt strategy as a provider:
update your auth.module.ts with the following content

import { Module } from '@nestjs/common';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UsersModule } from './users/users.module';
import { LoggerModule } from '@app/common';
import { JwtModule } from '@nestjs/jwt';
import { ConfigModule, ConfigService } from '@nestjs/config';
import * as Joi from 'joi';
import { LocalStrategy } from './strategies/local.strategy';
import { JwtStrategy } from './strategies/jwt.strategy';

@Module({
  imports: [
    UsersModule,
    LoggerModule,
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: Joi.object({
        JWT_SECRET: Joi.string().required(),
        JWT_EXPIRATION: Joi.string().required(),
        PORT: Joi.number().required(), //we wil setup this env later
      }),
    }),
    JwtModule.registerAsync({
      useFactory: (configService: ConfigService) => ({
        secret: configService.get<string>('JWT_SECRET'),
        signOptions: {
          expiresIn: `${configService.get<string>('JWT_EXPIRATION')}s`,
        },
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, LocalStrategy, JwtStrategy],
})
export class AuthModule {}

Add cookie-parser Middleware

install cookie-parser run the following command on your terminal

npm install cookie-parser
npm install -D @types/cookie-parser

open your auth/src/main.ts file and update it with the following content to use cookie-parser as middleware

import { NestFactory } from '@nestjs/core';
import { AuthModule } from './auth.module';
import { ValidationPipe } from '@nestjs/common';
import { Logger } from 'nestjs-pino';
import { ConfigService } from '@nestjs/config';
import * as cookieParser from 'cookie-parser';

async function bootstrap() {
  const app = await NestFactory.create(AuthModule);
  app.use(cookieParser());
  app.useGlobalPipes(
    new ValidationPipe({
      whitelist: true,
    }),
  );
  app.useLogger(app.get(Logger));
  const configService = app.get(ConfigService);
  await app.listen(configService.get('PORT'));
}
bootstrap();

Validating Unique Email during User Creation

Ensure Unique Email: To prevent the creation of multiple users with the same email, you can add validation during user creation. Modify your user service to validate email uniqueness before creating a new user: update your user.service.ts with the following content:

import {
  Injectable,
  UnauthorizedException,
  UnprocessableEntityException,
} from '@nestjs/common';
import { UserRepository } from './user.repository';
import { CreateUserDTO } from './dto/create-user.dto';
import * as bcryptjs from 'bcryptjs';
import { GetUserDto } from './dto/get-user.dto';
@Injectable()
export class UsersService {
  constructor(private readonly userRepository: UserRepository) {}

  async create(createUserDto: CreateUserDTO) {
    await this.validateCreateUserDto(createUserDto);
    return this.userRepository.create({
      ...createUserDto,
      password: await bcryptjs.hash(createUserDto.password, 10),
    });
  }

  private async validateCreateUserDto(createUserDto: CreateUserDTO) {
    try {
      await this.userRepository.findOne({ email: createUserDto.email });
    } catch (error) {
      return;
    }
    throw new UnprocessableEntityException('Email already exists');
  }

  async verifyUser(email: string, password: string) {
    const user = await this.userRepository.findOne({ email });
    const passwordIsValid = await bcryptjs.compare(password, user.password);
    if (!passwordIsValid) {
      throw new UnauthorizedException('Invalid credentials');
    }
    return user;
  }

  async getUser(getUserDto: GetUserDto) {
    return this.userRepository.findOne(getUserDto);
  }
}

We have just added a 'validateCreateUserDto' function to verify the existence of an email in our database, ensuring email uniqueness.

With these steps, you've implemented JWT authentication in your Nest.js application, ensuring secure access to protected routes. Additionally, you've added email uniqueness validation during user creation to maintain data integrity in your user database.

In the next tutorial, we'll explore more advanced authentication features and user management.

Stay tuned for the next part of our Nest.js authentication series!

9. Setting up local authentication

Jayvee Ramos — Tue, 07 Nov 2023 03:27:31 +0000

Introduction:

In this tutorial, we will dive into the process of setting up a secure authentication system in your NestJS application. We'll be using Passport, a popular authentication library that simplifies the authentication process. Our primary focus will be on setting up local authentication, which involves users logging in with their email and password credentials. We'll also integrate JSON Web Tokens (JWT) to secure our application.

Step 1: Setting Up the JWT Module

Before we start implementing authentication, let's ensure we have a clean setup for the JWT module. Make sure you have the necessary dependencies installed and properly configured.

Step 2: Creating Authentication Strategies

Passport has the concept of strategies in NestJS, where each strategy represents a different type of authentication method. We will start by creating a local strategy for email and password-based logins. This strategy will extend the Passport strategy, so ensure you import it correctly.

In your auth folder, create a new "strategies" folder to organize your authentication strategies. The first strategy we're creating is the local strategy, responsible for handling email and password-based authentication. This strategy should be an injectable class.

Define the Local Strategy:

So let's keep things organized in our auth folder.

Let's create a new strategies folder use this command to create new directory inside our auth folder:

mkdir apps/auth/src/strategies

Then create our first strategy file:

touch apps/auth/src/strategies/local.strategy.ts

This will be the local strategy and this is going to be the strategy that allows us to log in with a user's email and password, which essentially will start off the authentication flow.

Populate the local.strategy.ts file with the following content

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { PassportStrategy } from '@nestjs/passport';
import { Strategy } from 'passport-local';
import { UsersService } from '../users/users.service';

@Injectable()
export class LocalStrategy extends PassportStrategy(Strategy) {
  constructor(private userService: UsersService) {
    super({
      usernameField: 'email', // Use the email field as the username
    });
  }

  async validate(email: string, password: string): Promise<any> {
    try {
      return await this.userService.verifyUser(email, password); //We will define 'verifyUser' in the user service later; for now, let's just declare it
    } catch (error) {
      throw new UnauthorizedException(error);
    }
  }
}

since we are using user service here make sure that in our user.service.module.ts we add the userService in our export array like this `exports: [UsersService],`

Step 3: Hashing Passwords with Bcrypt

In your user service, it's crucial to hash passwords before storing them in the database. We'll use the Bcrypt library for secure password hashing. Start by installing Bcrypt as a dependency.

Install Bcrypt:

npm install bcryptjs
npm install --save-dev @types/bcryptjs

update your user.service.ts with the following content

import { Injectable, UnauthorizedException } from '@nestjs/common';
import { UserRepository } from './user.repository';
import { CreateUserDTO } from './dto/create-user.dto';
import * as bcryptjs from 'bcryptjs';
@Injectable()
export class UsersService {
  constructor(private readonly userRepository: UserRepository) {}

  async create(createUserDto: CreateUserDTO) {
    return this.userRepository.create({
      ...createUserDto,
      password: await bcryptjs.hash(createUserDto.password, 10),
    });
  }

  async verifyUser(email: string, password: string) {
    const user = await this.userRepository.findOne({ email });
    const passwordIsValid = await bcryptjs.compare(password, user.password);
    if (!passwordIsValid) {
      throw new UnauthorizedException('Invalid credentials');
    }
    return user;
  }
}

What we did was hash the password before saving it in the database, and we declared 'verifyUser' because we used it in our 'local.strategy.ts' file.

Step 4: Create the LocalAuthGuard

let's create new folder inside out auth folder by running the following command in your terminal:

mkdir apps/auth/src/guards

inside that folder we will create our local guard file by running the following command on your terminal:

touch apps/auth/src/guards/local.auth-guard.ts

populate local.auth-guard.ts with the following content

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

@Injectable()
export class LocalAuthGuard extends AuthGuard('local') {}

Code Explanation

export class LocalAuthGuard extends AuthGuard('local') {}: This class, LocalAuthGuard, extends the AuthGuard class and specifies the strategy 'local'. In Nest.js and Passport.js, the strategy name is used to determine which authentication strategy to apply. In this case, it's associated with a local authentication strategy, which involves verifying a user's credentials against a local database

Step 5: Creating a Current User Decorator

To easily access the currently authenticated user in your routes, create a decorator called "CurrentUser." This decorator will extract the user from the request.
run the following command to create a current-user.decorator.ts file inside our auth folder

touch apps/auth/src/current-user.decorator.ts

populate it with the following content

import { createParamDecorator, ExecutionContext } from '@nestjs/common';
import { UserDocument } from './users/models/user.schema';

const getCurrentUserByContex = (ctx: ExecutionContext): UserDocument => {
  return ctx.switchToHttp().getRequest().user;
};
export const CurrentUser = createParamDecorator(
  (_data: unknown, ctx: ExecutionContext) => getCurrentUserByContex(ctx),
);

Code Explanation:

const getCurrentUserByContext = (ctx: ExecutionContext): UserDocument => { ... }: This function takes an ExecutionContext object as a parameter and is used to retrieve the currently authenticated user from the request context. It does so by calling ctx.switchToHttp().getRequest().user, assuming that the user object is stored in the request object under the key "user." The function is typed to return a UserDocument.

export const CurrentUser = createParamDecorator((_data: unknown, ctx: ExecutionContext) => getCurrentUserByContext(ctx));: This code exports a custom parameter decorator called CurrentUser. The createParamDecorator function from Nest.js is used to create the decorator. It takes a callback function that receives two arguments: _data (unused) and ctx, the execution context. Inside this function, it calls getCurrentUserByContext(ctx) to retrieve the current user object, and this user object can be injected into the controller method when @CurrentUser() is used as a parameter.

Step 6 Create Token Payload Interface

On the next step, we will supply our JWT with a token payload, and since we are using TypeScript, it is recommended that we create an interface for our payload. Run the following command to create an 'interface' folder inside our 'auth/src' folder

mkdir apps/auth/src/interface

run this command to create a tokenPayload file inside the interface folder

touch apps/auth/src/interface/token-payload.interface.ts

populate it with the following code

export interface Tokenpayload {
  userId: string;
}

Step 6: Implementing the Login Service and routes

Setup Login Service

Now, let's implement the login service in your auth service so that we can use it in our auth controller
update your auth.service.ts with the following content

import { Injectable } from '@nestjs/common';
import { UserDocument } from './users/models/user.schema';
import { Response } from 'express';
import { ConfigService } from '@nestjs/config';
import { JwtService } from '@nestjs/jwt';
import { Tokenpayload } from './interface/token-payload.interface';

@Injectable()
export class AuthService {
  constructor(
    private readonly configService: ConfigService,
    private readonly jwtService: JwtService,
  ) {}

  async login(user: UserDocument, response: Response) {
    const tokenPayload: Tokenpayload = {
      userId: user._id.toString(),
    };

    // Calculate the token expiration time by adding seconds to the current date
    const expires = new Date();
    expires.setSeconds(
      expires.getSeconds() + this.configService.get('JWT_EXPIRATION'),
    );

    const token = this.jwtService.sign(tokenPayload);

    response.cookie('Authentication', token, {
      expires: expires,
      httpOnly: true,
    });
  }
}

Code Explanation

async login(user: UserDocument, response: Response) { ... }: This method is used to handle user login. It takes two parameters: user, which is of type UserDocument, and response, which is an Express Response object. In this method:

It creates a **tokenPayload **object, which typically includes user-specific data. In this case, it only contains the user's _id.

It calculates the token expiration time by adding the configured JWT expiration time to the current time.

It signs the JWT using the JwtService provided by Nest.js.

It sets the JWT as a cookie named 'Authentication' in the response, with an expiration date and the httpOnly flag, which is a common practice for securely storing JWTs.

Setup Login Routes
update your auth.controller.ts with the following content

import { Controller, Post, Res, UseGuards } from '@nestjs/common';
import { AuthService } from './auth.service';
import { LocalAuthGuard } from './guards/local.auth-guard';
import { CurrentUser } from './current-user.decorator';
import { UserDocument } from './users/models/user.schema';
import { Response } from 'express';

@Controller('auth')
export class AuthController {
  constructor(private readonly authService: AuthService) {}

  @UseGuards(LocalAuthGuard)
  @Post('login')
  async login(
    @CurrentUser() user: UserDocument,
    @Res({ passthrough: true }) response: Response,
  ) {
    await this.authService.login(user, response);
    response.send(user);
  }
}

Code Explanation

@UseGuards(LocalAuthGuard): This decorator specifies that the login method should use the LocalAuthGuard guard. This guard likely checks the user's credentials before allowing access to the method.

async login(@CurrentUser() user: UserDocument, @Res({ passthrough: true }) response: Response) { ... }: This is the login method, which is responsible for handling user login requests.
It uses the** @CurrentUser** decorator to inject the currently authenticated user (of type UserDocument) and the Express Response object into the method.

In the auth module, add the local strategy as a provider:
update your auth.module.ts with the following content

import { Module } from '@nestjs/common';
import { AuthController } from './auth.controller';
import { AuthService } from './auth.service';
import { UsersModule } from './users/users.module';
import { LoggerModule } from '@app/common';
import { JwtModule } from '@nestjs/jwt';
import { ConfigModule, ConfigService } from '@nestjs/config';
import * as Joi from 'joi';
import { LocalStrategy } from './strategies/local.strategy';

@Module({
  imports: [
    UsersModule,
    LoggerModule,
    ConfigModule.forRoot({
      isGlobal: true,
      validationSchema: Joi.object({
        JWT_SECRET: Joi.string().required(),
        JWT_EXPIRATION: Joi.string().required(),
        PORT: Joi.number().required(), //we wil setup this env later
      }),
    }),
    JwtModule.registerAsync({
      useFactory: (configService: ConfigService) => ({
        secret: configService.get<string>('JWT_SECRET'),
        signOptions: {
          expiresIn: `${configService.get<string>('JWT_EXPIRATION')}s`,
        },
      }),
      inject: [ConfigService],
    }),
  ],
  controllers: [AuthController],
  providers: [AuthService, LocalStrategy],
})
export class AuthModule {}

Step 7: Testing the Authentication System

Now that your authentication system is in place, test it by creating a user and logging in using Postman or your preferred API testing tool. Ensure you receive a JWT token in the response and that it's properly stored as an HTTP-only cookie.

run docker-compose up to start our application

Preconditions:

Your NestJS application with the authentication system is up and running.
You have an API testing tool like Postman or an equivalent ready for testing.

Steps:

1. User Registration:
Request: Make a POST request to the registration endpoint to create a new user.
URL:http://localhost:3001/users (or your registration endpoint URL)
Headers: Set the Content-Type to application/json.
Body: Include a JSON payload with the user's registration details, including email and password. For example:

{
  "email": "user@example.com",
  "password": "securePassword123@"
}

Expected Response: You should receive a response indicating the successful creation of the user. Ensure that the password is securely hashed before storing it in the database.

2. User Login:

Request: Make a POST request to the login endpoint to authenticate the newly registered user.
URL: http://localhost:3001/auth/login (or your login endpoint URL)
Headers: Set the Content-Type to application/json.
Body: Include a JSON payload with the user's login credentials (email and password).

{
  "email": "user@example.com",
  "password": "securePassword123@"
}

Expected Response: You should receive a response with a JWT token, and this token should also be securely stored as an HTTP-only cookie in the response. The response should also include the user's details. The JWT token can be used for subsequent authenticated requests.

Conclusion:

In this tutorial, we've covered the essential steps to set up a secure authentication system in your NestJS application using Passport and JWT. With local email and password-based authentication, you can now build a robust and secure user authentication process for your application. This foundation can be extended to support various authentication methods and user roles as your project evolves.