I’ve been working with APIs for years, and a recent project forced me to confront a common reality: modern applications need speed, real-time data, and clear communication between frontends and backends. REST sometimes feels like delivering furniture in separate boxes with no assembly instructions. That’s why I built a system combining NestJS for structure, Prisma for talking to the database, and Redis to keep everything fast. Let’s build it together.
Think of NestJS as the blueprint for your server. It uses TypeScript, which acts like a strict supervisor, catching errors before your code even runs. We start by setting up the project with GraphQL. Apollo Server is a popular choice here because it’s powerful and well-supported.
nest new graphql-api --package-manager npm
cd graphql-api
npm install @nestjs/graphql @nestjs/apollo @apollo/server graphqlThe core of our API is in the GraphQL module setup. This code creates the schema and enables a playground for testing.
// app.module.ts
import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { ApolloDriver, ApolloDriverConfig } from '@nestjs/apollo';
import { join } from 'path';
@Module({
imports: [
GraphQLModule.forRoot<ApolloDriverConfig>({
driver: ApolloDriver,
autoSchemaFile: join(process.cwd(), 'src/schema.gql'),
sortSchema: true,
playground: true,
}),
],
})
export class AppModule {}Next, we connect to the database. This is where Prisma shines. Instead of writing raw SQL, you define your data model in a simple file. Prisma then generates a fully type-safe client. It’s like having a personal translator for your database.
// schema.prisma
model User {
id String @id @default(cuid())
email String @unique
name String?
posts Post[]
}
model Post {
id String @id @default(cuid())
title String
content String
published Boolean @default(false)
author User @relation(fields: [authorId], references: [id])
authorId String
}After running npx prisma generate, you get a Prisma Client you can use in a service.
// users.service.ts
import { Injectable } from '@nestjs/common';
import { PrismaService } from '../prisma.service';
@Injectable()
export class UsersService {
constructor(private prisma: PrismaService) {}
async getUserWithPosts(id: string) {
return this.prisma.user.findUnique({
where: { id },
include: { posts: true }, // Get user and their posts in one query
});
}
}But here’s a problem. What if a query asks for 100 users and then, for each user, their posts? Without care, this makes 101 database calls: one for the users, and 100 more for each user’s posts. This is the “N+1” problem. How do we stop it?
We use a tool called DataLoader. It batches multiple requests for similar data into single queries. It’s a queue manager for your database calls. You create a loader for specific relationships.
// posts.dataloader.ts
import * as DataLoader from 'dataloader';
import { PrismaService } from '../prisma.service';
export function createPostsLoader(prisma: PrismaService) {
return new DataLoader<string, any>(async (authorIds: string[]) => {
const posts = await prisma.post.findMany({
where: { authorId: { in: authorIds } },
});
// Group posts by their authorId
const postsByAuthorId = posts.reduce((acc, post) => {
acc[post.authorId] = acc[post.authorId] || [];
acc[post.authorId].push(post);
return acc;
}, {});
// Return posts in the same order as the requested authorIds
return authorIds.map((id) => postsByAuthorId[id] || []);
});
}Speed isn’t just about smart queries; it’s about avoiding unnecessary work. That’s where Redis enters. It’s an in-memory data store, perfect for caching frequent queries. NestJS has a built-in module for this.
// app.module.ts - updated
import { CacheModule } from '@nestjs/cache-manager';
import { redisStore } from 'cache-manager-redis-store';
@Module({
imports: [
CacheModule.register({
store: redisStore,
host: 'localhost',
port: 6379,
ttl: 300, // Cache data for 5 minutes
}),
// ...other imports
],
})You can then easily use it in a resolver to store the result of a complex query. The next time the same data is requested, it comes from lightning-fast memory, not the database.
// posts.resolver.ts
import { CACHE_MANAGER } from '@nestjs/cache-manager';
import { Inject, Injectable } from '@nestjs/common';
import { Cache } from 'cache-manager';
@Injectable()
export class PostsResolver {
constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
@Query(() => [Post])
async getPopularPosts() {
const cached = await this.cacheManager.get('popular_posts');
if (cached) {
return cached; // Instantly return from cache
}
const posts = await this.postsService.findPopular(); // Expensive query
await this.cacheManager.set('popular_posts', posts, 300000); // Cache for 5 min
return posts;
}
}What about keeping data secure? GraphQL mutations for login can return a token. We then use a Guard—NestJS’s security middleware—to protect other operations.
Real-time updates are a game-changer. GraphQL subscriptions allow the server to push data to clients when something happens, like a new post from a followed user. Setting up WebSockets in NestJS for this is straightforward and changes your app from static to live.
Finally, how do you know your API is healthy? You need to monitor performance. Tools like Apollo Studio offer tracing, showing you exactly how long each part of a query takes. This helps you spot slow database calls or resolvers that need caching.
Combining NestJS, Prisma, and Redis creates a foundation that is robust, fast, and scalable. You get the clear structure of GraphQL, the safety and ease of Prisma with your data, and the incredible speed of Redis caching. It solves real problems developers face every day.
Have you tried combining these tools? What challenges did you face? Building this stack has significantly improved how I deliver data to applications. If you found this walkthrough helpful, please share it with other developers. I’d love to hear your thoughts and experiences in the comments below.
