7-deploying-a-scalable-graphql-api-with-nestjs-and-mongodb.html

Deploying a Scalable GraphQL API with NestJS and MongoDB

In today's fast-paced development environment, building scalable APIs is a necessity for modern applications. GraphQL has gained popularity for its flexibility and efficiency in handling complex queries, making it an excellent choice for API development. NestJS, a progressive Node.js framework, combined with MongoDB, a powerful NoSQL database, provides a robust stack for deploying a scalable GraphQL API. In this article, we will guide you through the process of setting up an efficient GraphQL API using NestJS and MongoDB, complete with practical code examples and actionable insights.

What is GraphQL?

GraphQL is a query language for APIs and a runtime for executing those queries by using a type system you define for your data. Unlike traditional REST APIs, where the server defines the structure of the responses, GraphQL allows clients to request exactly the data they need. This reduces over-fetching and under-fetching of data, leading to improved performance and a better user experience.

Why Use NestJS?

NestJS is built on top of Node.js and uses TypeScript, which enhances developer productivity and allows for the creation of highly testable and maintainable applications. Key features include:

Modular architecture: Promotes reusability and scalability.
Dependency injection: Simplifies code management and testing.
Out-of-the-box support for GraphQL: Makes it easy to set up a GraphQL API.

Why Use MongoDB?

MongoDB is a document-oriented NoSQL database that is highly flexible and scalable. It stores data in BSON format, allowing for a dynamic schema. Benefits of using MongoDB include:

High performance: Fast read and write operations.
Scalability: Easily handle large volumes of data across distributed systems.
Flexibility: Adapt easily to evolving data models.

Setting Up the Project

Step 1: Install NestJS CLI

First, ensure you have Node.js installed on your machine. Then, install the NestJS CLI globally:

npm install -g @nestjs/cli

Step 2: Create a New NestJS Project

Create a new NestJS project using the CLI:

nest new graphql-nestjs-mongodb
cd graphql-nestjs-mongodb

Step 3: Install Dependencies

Next, install the necessary dependencies for GraphQL and MongoDB:

npm install @nestjs/graphql graphql-tools graphql apollo-server-express mongoose @nestjs/mongoose

Step 4: Configure MongoDB

You need to connect your NestJS application to MongoDB. Create a .env file at the root of your project and add your MongoDB connection string:

MONGODB_URI=mongodb://localhost:27017/graphql-nestjs

Step 5: Set Up Mongoose Module

Open app.module.ts and import the Mongoose module:

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { GraphQLModule } from '@nestjs/graphql';
import { join } from 'path';
import { ItemsModule } from './items/items.module';

@Module({
  imports: [
    MongooseModule.forRoot(process.env.MONGODB_URI),
    GraphQLModule.forRoot({
      autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
      playground: true, // Enable GraphQL playground
    }),
    ItemsModule,
  ],
})
export class AppModule {}

Step 6: Creating a Simple Item Model

Create a new module for items:

nest generate module items
nest generate service items
nest generate resolver items

In items/items.model.ts, define a simple Mongoose schema:

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { Document } from 'mongoose';

export type ItemDocument = Item & Document;

@Schema()
export class Item {
  @Prop()
  name: string;

  @Prop()
  description: string;

  @Prop()
  price: number;
}

export const ItemSchema = SchemaFactory.createForClass(Item);

Step 7: Implementing the Resolver

In items/items.resolver.ts, implement the resolver for GraphQL queries and mutations:

import { Resolver, Query, Mutation, Args } from '@nestjs/graphql';
import { Item } from './items.model';
import { ItemsService } from './items.service';

@Resolver(() => Item)
export class ItemsResolver {
  constructor(private itemsService: ItemsService) {}

  @Query(() => [Item])
  async items() {
    return this.itemsService.findAll();
  }

  @Mutation(() => Item)
  async createItem(
    @Args('name') name: string,
    @Args('description') description: string,
    @Args('price') price: number,
  ) {
    return this.itemsService.create({ name, description, price });
  }
}

Step 8: Implementing the Service

In items/items.service.ts, implement the service methods for interacting with the MongoDB database:

import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Item, ItemDocument } from './items.model';

@Injectable()
export class ItemsService {
  constructor(@InjectModel(Item.name) private itemModel: Model<ItemDocument>) {}

  async findAll(): Promise<Item[]> {
    return this.itemModel.find().exec();
  }

  async create(itemData: Partial<Item>): Promise<Item> {
    const newItem = new this.itemModel(itemData);
    return newItem.save();
  }
}

Testing the API

Run your application:

npm run start

Navigate to http://localhost:3000/graphql in your browser. You should see the GraphQL playground. You can test your API by running the following queries:

Querying Items

query {
  items {
    id
    name
    description
    price
  }
}

Creating an Item

mutation {
  createItem(name: "Item 1", description: "This is item 1", price: 10.99) {
    id
    name
  }
}

Conclusion

Deploying a scalable GraphQL API using NestJS and MongoDB is a powerful approach to building modern applications. With the modular architecture of NestJS and the flexibility of MongoDB, you can create efficient APIs that handle complex queries with ease. By following the steps in this article, you can set up your own scalable API and explore the vast possibilities that GraphQL offers.

Key Takeaways:

GraphQL provides a flexible way to query data, reducing over-fetching and under-fetching.
NestJS offers a modular architecture and built-in support for GraphQL and MongoDB.
Mongoose simplifies database interactions and ensures that your application remains scalable.

Embrace the power of GraphQL, NestJS, and MongoDB to build robust APIs that meet the needs of modern applications!