Effortless File Structure Setup for Node.js Fastify Projects

Streamlining API Development: Fast, Secure, and Scalable with Modern Tools

If my journey through backend frameworks were a Netflix series, it’d be called “The Toxic Developer Chronicles.” I started with Express.js — simple, reliable, and perfect for a beginner like me. Then, I found Fastify, which felt like the cool, efficient kid in class that made everything run smoother.

But like any developer tempted by the promise of something shinier, I flirted with NestJS. For a while, it felt like I had leveled up — I mean, who doesn’t love decorators and a full-fledged architectural pattern? But deep down, I missed Fastify’s lightweight speed and simplicity. So, like any good plot twist, I returned to my old flame: Fastify.

Add TypeScript to this mix (because writing JavaScript in freestyle mode wasn’t winning me any points), and I finally found my sweet spot.

Now, enough about my toxic relationships with frameworks — let’s dive into how to set up a clean, scalable file structure using Fastify, Prisma, and TypeScript. It’s time to organize, optimize, and level up your Node.js projects.

Tech Stack Overview

Node.js

The foundation of our backend. Node.js lets us handle multiple requests efficiently with its non-blocking, event-driven architecture. It’s the powerhouse for modern web development.

Fastify

Think of Fastify as the lean, mean, fast alternative to Express.js. It’s lightweight, highly performant, and comes with built-in support for plugins and schema validation. Perfect for scalable applications.

TypeScript

If JavaScript is the wild west, TypeScript is the sheriff that brings law and order. By adding strong typing and better tooling, it helps us write cleaner, more maintainable code.

Prisma

An ORM (Object-Relational Mapping) tool that simplifies database operations. Why Prisma?

• Concept: ORM abstracts the database layer, so instead of writing raw queries, you work with your data as objects.
• Importance: Speeds up development, ensures type safety (with TypeScript), and reduces the chance of database errors.
• In this article, we’ll use Prisma with MongoDB in NoSQL mode — a flexible choice for modern web apps.

MongoDB

A NoSQL database that stores data in a flexible, JSON-like format. It’s perfect for dynamic schemas and fast iterations — exactly what we need for this project.

Helmet.js

A middleware that adds security-related HTTP headers to your app. It’s a simple way to protect your APIs from common web vulnerabilities.

Rate Limit

Essential for preventing abuse, especially on public APIs. It limits the number of requests a client can make within a specific timeframe, helping protect your app from DoS attacks.

JWT (JSON Web Token)

JWT is our go-to for stateless authentication. It securely passes user data between the server and client.

• While we’ll set up the basics here, a deeper dive into Fastify JWT is worthy of its own article. Stay tuned for that!

Why a Proper File Structure Matters

Messy codebases are like a cluttered desk — sure, you can work on it, but you’ll spend half your time looking for stuff. When every new feature feels like an expedition through spaghetti code, productivity takes a hit. Let’s dive into why a clean, organized file structure isn’t just a “nice-to-have” but an essential part of successful projects.

1. Messy Projects Slow You Down

A poorly organized file structure creates roadblocks:

• Confusion Over File Locations: You waste time hunting for routes, controllers, or config files because they’re scattered.
• Hard-to-Understand Dependencies: Without separation of concerns, it’s easy to get lost in deeply intertwined logic.
• Onboarding Nightmare: New team members (or even your future self) will struggle to understand what’s going on.

Example: Messy Structure

project-root/
├── index.js
├── routes/
│   ├── auth.js
│   ├── products.js
├── db/
│   ├── prisma-client.js
├── auth-helpers/
│   ├── jwt.js
│   ├── hash.js
├── utils/
│   ├── helpers.js
│   ├── constants.js

This might look okay for a small app, but when you add more routes, utilities, and middlewares, it quickly turns chaotic.

2. Benefits of a Clean File Structure

A well-organized structure is like a well-oiled machine. Here’s why it matters:

• Clarity:
  You’ll know exactly where everything is, making it easier to navigate.
  Example: Want to add a new route? Head straight to the routes/ folder.
• Ease of Collaboration:
  A clear structure makes it easier for others to contribute. Everyone can follow the same conventions, avoiding “my code works, but I have no idea how” scenarios.
• Debugging Simplicity:
  When files are modular and logically grouped, pinpointing bugs becomes easier.

Example: Modular File Structure

project-root/
├── src/
│   ├── controllers/
│   │   ├── auth.controller.ts
│   │   ├── product.controller.ts
│   ├── routes/
│   │   ├── auth.routes.ts
│   │   ├── product.routes.ts
│   ├── services/
│   │   ├── auth.service.ts
│   │   ├── product.service.ts
│   ├── plugins/
│   │   ├── prisma.plugin.ts
│   │   ├── security.plugin.ts
│   ├── config/
│   │   ├── db.config.ts
│   │   ├── jwt.config.ts

3. Small Example: Separating Concerns with Controllers and Routes

Let’s say you’re working on an authentication feature. Here’s how a clean structure benefits you:

Controller: auth.controller.ts

Handles the logic for login and registration.

import { FastifyRequest, FastifyReply } from 'fastify';

export async function login(req: FastifyRequest, reply: FastifyReply) {
  const { email, password } = req.body as { email: string; password: string };
  // Authentication logic
  return reply.send({ message: 'Login successful!' });
}

export async function register(req: FastifyRequest, reply: FastifyReply) {
  const { email, password } = req.body as { email: string; password: string };
  // Registration logic
  return reply.send({ message: 'User registered successfully!' });
}

Route: auth.routes.ts

Defines the endpoints and links them to the controller logic.

import { FastifyInstance } from 'fastify';
import { login, register } from '../controllers/auth.controller';

export default async function authRoutes(fastify: FastifyInstance) {

  fastify.post('/login', login);

  fastify.post('/register', register);
}

Main App: index.ts

Imports the routes without cluttering the core logic.

import fastify from 'fastify';
import authRoutes from './routes/auth.routes';

const app = fastify();

app.register(authRoutes, { prefix: '/api/v1/auth' });

app.listen({ port: 3000 }, () => {
  console.log('Server running on http://localhost:3000');
});

The Result: Faster, Cleaner Development

With this structure:

• Adding a new feature is as simple as creating a controller and linking it to a route.
• Debugging involves checking specific files instead of hunting through monolithic code.
• The entire team (or future-you) will thank you for the clarity and simplicity.

Proposed File Structure

Now comes the heart of the article — our proposed file structure! This structure keeps the project modular, scalable, and easy to maintain, even as the complexity grows.

Let’s visualize the tree first and then break it down folder by folder.

project-root/
├── src/
│   ├── config/             # Configuration files (e.g., database, JWT)
│   ├── controllers/        # Request-handling logic
│   ├── plugins/            # Fastify plugins (e.g., Prisma, Helmet)
│   ├── routes/             # API routes
│   ├── schemas/            # Data validation schemas
│   ├── services/           # Business logic
│   ├── utils/              # Utility functions/helpers
│   ├── index.ts            # Main application entry point
├── prisma/
│   ├── schema.prisma       # Prisma schema
├── .env                    # Environment variables
├── tsconfig.json           # TypeScript configuration
├── package.json            # Dependencies and scripts

2. Explanation of Each Folder’s Purpose

src/

The main folder housing all application logic.

config/
Stores configuration files, such as database connections or JWT settings.
Example:

// db.config.ts
export const dbConfig = {
  url: process.env.DATABASE_URL,
};

controllers/
Handles requests and responses. Controllers are responsible for the "what to do" part of an endpoint.
Example:

// product.controller.ts
import { FastifyRequest, FastifyReply } from 'fastify';
export async function getProducts(req: FastifyRequest, reply: FastifyReply) {
  // Fetch products logic
  return reply.send({ message: 'List of products' });
}

plugins/
Contains reusable Fastify plugins (like Prisma, Helmet, or CORS).
Example:

// prisma.plugin.ts
import fp from 'fastify-plugin';
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

export default fp(async (fastify) => {
  fastify.decorate('prisma', prisma);
});

routes/
Defines the API endpoints and links them to controllers. Each route is modular.
Example:

// product.schema.ts
export const productSchema = {
  type: 'object',
  properties: {
    name: { type: 'string' },
    price: { type: 'number' },
  },
  required: ['name', 'price'],
};

services/
Contains business logic, separated from controllers to keep them slim and reusable.
Example:

// product.service.ts
export async function fetchProducts() {
  // Database logic
  return [{ name: 'Product A', price: 100 }];
}

utils/
A utility toolbox with helper functions for repetitive tasks.
Example:

// logger.ts
export function log(message: string) {
  console.log(`[LOG] ${message}`);
}

prisma/

The Prisma folder contains the schema definition file. It’s where you define your database tables/models.

Example:

// schema.prisma
generator client {
  provider = "prisma-client-js"
}

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

model Product {
  id    String @id @default(auto()) @map("_id") @db.ObjectId
  name  String
  price Float
}

.env

Stores environment variables securely, such as the database URL or API keys.

Example:

DATABASE_URL=mongodb+srv://username:password@cluster.mongodb.net/mydb
JWT_SECRET=supersecret

tsconfig.json

The TypeScript configuration file ensures strict type checks and optimized transpilation.

Why This Structure Works

• Modular: Each part of the app is self-contained, making it easy to manage and scale.
• Readable: Developers (including future-you) can immediately understand the purpose of each folder.
• Reusable: Logic and utilities can be reused without duplication.

Setting Up the Environment

Before diving into code, let’s set up our development environment properly. This section covers the tools and libraries you’ll need and how to initialize a basic Fastify project with TypeScript.

1. Tools and Libraries Needed

Here’s what you’ll need to get started:

• Node.js: Our runtime environment for running JavaScript/TypeScript on the server.
• npm or yarn: For managing packages.
• Fastify: A lightweight, high-performance web framework.
• TypeScript: Adds static typing to JavaScript, making your code more robust and readable.
• Prisma: An ORM for database management.
• Helmet: Adds security headers to your app.
• dotenv: For managing environment variables.
• @fastify/jwt: For handling JSON Web Tokens (JWT).
• @fastify/rate-limit: To protect your API from abuse by limiting requests.

2. Basic Fastify Project Initialization with TypeScript

Step 1: Create a New Project

Run the following commands in your terminal to create a new project directory:

mkdir fastify-prisma-app
cd fastify-prisma-app
npm init -y

Step 2: Install Dependencies

Install the necessary libraries and tools:

npm install fastify @fastify/jwt @fastify/rate-limit @fastify/helmet prisma
npm install --save-dev typescript ts-node @types/node @types/jsonwebtoken

Step 3: Initialize TypeScript

Set up TypeScript by creating a tsconfig.json file:

npx tsc --init

Edit the tsconfig.json to include these key settings:

{
  "compilerOptions": {
    "target": "es6",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "outDir": "./dist",
    "rootDir": "./src"
  },
  "include": ["src/**/*"],
  "exclude": ["node_modules"]
}

Step 4: Initialize Fastify

Create a basic Fastify server in src/index.ts:

mkdir src
touch src/index.ts

In src/index.ts, add:

import Fastify from 'fastify';

const fastify = Fastify({ logger: true });

// Sample route
fastify.get('/', async (request, reply) => {
  return { message: 'Welcome to Fastify with TypeScript!' };
});

// Start the server
const start = async () => {
  try {
    await fastify.listen({ port: 3000 });
    console.log('Server is running at http://localhost:3000');
  } catch (err) {
    fastify.log.error(err);
    process.exit(1);
  }
};

start();

Step 5: Set Up Prisma

Initialize Prisma:

npx prisma init

This creates a prisma folder with a schema.prisma file and a .env file.

1. Configure Prisma to use MongoDB:
   Update schema.prisma with:

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

2. Add the database URL to .env:

DATABASE_URL=mongodb+srv://username:password@cluster.mongodb.net/mydatabase

3. Generate the Prisma client:

npx prisma generate

Step 6: Run the Server

Run the project with ts-node:

npx ts-node src/index.ts

Open http://localhost:3000 in your browser, and you should see:

{
  "message": "Welcome to Fastify with TypeScript!"
}

Why This Setup?

This setup ensures that:

1. You’re using TypeScript for better code maintainability.
2. Prisma simplifies database management.
3. Fastify’s lightweight and plugin-based design gives you flexibility and performance.

Integrating Prisma with MongoDB

MongoDB is a document-based NoSQL database, and integrating it with Prisma enables us to manage collections and documents with ease. Let’s walk through how to set up Prisma in NoSQL mode and create a basic schema.

1. Setting Up Prisma in NoSQL Mode

Prisma supports MongoDB in a slightly different way compared to SQL databases. Here’s how to configure it:

Step 1: Install Prisma

If you haven’t already, install Prisma and initialize it in your project:

npm install prisma
npx prisma init

Step 2: Update prisma/schema.prisma for MongoDB

Modify the schema.prisma file to use MongoDB:

datasource db {
  provider = "mongodb"
  url      = env("DATABASE_URL")
}

generator client {
  provider = "prisma-client-js"
}

Step 3: Add Your Database URL

In the .env file, set the DATABASE_URL to your MongoDB connection string:

DATABASE_URL=mongodb+srv://username:password@cluster.mongodb.net/mydatabase

Make sure to replace username, password, and mydatabase with your actual database credentials.

2. Example Schema for Our Application

Let’s define a simple schema for a basic e-commerce-like application. We’ll include models for User, Product, and Order.

Here’s an example schema.prisma file:

model User {
  id        String   @id @default(auto()) @map("_id") @db.ObjectId
  name      String
  email     String   @unique
  createdAt DateTime @default(now())
}

model Product {
  id          String   @id @default(auto()) @map("_id") @db.ObjectId
  name        String
  description String?
  price       Float
  createdAt   DateTime @default(now())
}

model Order {
  id          String   @id @default(auto()) @map("_id") @db.ObjectId
  userId      String   @db.ObjectId
  products    String[] @db.Array(ObjectId)
  createdAt   DateTime @default(now())
}

3. Generating the Prisma Client

To use this schema in your project, generate the Prisma client:

npx prisma generate

This will create a client library you can import into your code to interact with the database.

4. Using Prisma in the Code

Here’s how you can use Prisma to interact with MongoDB in your Fastify project. Create a new file, src/prisma.ts, to initialize the Prisma client:

import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

export default prisma;

5. Example Usage in Fastify

Add a route to demonstrate interaction with the database. In src/index.ts, use Prisma to handle a GET request for all products:

import prisma from './prisma';

fastify.get('/products', async (request, reply) => {
  const products = await prisma.product.findMany();
  return { data: products };
});

To add a new product via a POST request:

fastify.post('/products', async (request, reply) => {
  const { name, description, price } = request.body as { name: string; description?: string; price: number };
  const product = await prisma.product.create({
    data: { name, description, price },
  });
  return { data: product };
});

6. Testing the Integration

Run the server:

npx ts-node src/index.ts

Test the endpoints with a tool like Postman or cURL:

• GET /products:
  Returns a list of all products.
• POST /products:
  Adds a new product to the database. Example request body:

{
  "name": "Fastify T-Shirt",
  "description": "A cool t-shirt for Fastify fans!",
  "price": 19.99
}

Why Prisma with MongoDB?

• Simplifies Database Queries: Prisma’s API abstracts MongoDB’s complexity.
• Type Safety: With TypeScript, you get compile-time checks.
• Auto-Migrations: Prisma makes database schema management easier.

This structure ensures that your app is scalable, maintainable, and ready for real-world use. grap a cup of coffee then we will dive into the next point? 😊

Building a Modular File Structure

A modular file structure is the key to maintaining, scaling, and debugging your Fastify application with ease. This section will guide you through:

1. Creating and Organizing Key Components: Routes, plugins, controllers, and services.
2. Connecting Them Logically: Ensuring smooth communication between layers.

1. Why Modular Structure Matters

Imagine trying to find a bug in a massive file with mixed routes, database queries, and utility functions — nightmare, right? Modularizing your application:
- Separates Concerns: Keeps logic clean and focused.
- Enhances Readability: Each file serves a clear purpose.
- Simplifies Collaboration: Team members can work on different modules independently.

2. Walkthrough of the Modular File Structure

Here’s a simple directory tree:

src/
├── controllers/
│ └── booksController.ts
├── routes/
│ └── booksRoute.ts
├── services/
│ └── booksService.ts
├── plugins/
│ └── prisma.ts
├── schemas/
│ └── bookSchema.ts
├── index.ts

2.1 Routes: Entry Points for Requests

Createsrc/routes/booksRoute.ts:

import { FastifyInstance } from 'fastify';
import { getBooksHandler, addBookHandler } from '../controllers/booksController';
export default async function bookRoutes(fastify: FastifyInstance) {
 fastify.get('/books', getBooksHandler);
 fastify.post('/books', addBookHandler);
}

Explanation:
- Each route points to a specific controller function, making routing and logic separate.

Register the route in. src/index.ts:

import bookRoutes from './routes/booksRoute';
fastify.register(bookRoutes, { prefix: '/api/v1' })

2.2 Controllers: Handling Business Logic

Create src/controllers/booksController.ts:

import { FastifyReply, FastifyRequest } from 'fastify';
import { getBooks, addBook } from '../services/booksService';
export async function getBooksHandler(request: FastifyRequest, reply: FastifyReply) {
 const books = await getBooks();
 reply.send(books);
}
export async function addBookHandler(request: FastifyRequest, reply: FastifyReply) {
 const book = request.body; // Add type-checking here with TypeScript interfaces
 const result = await addBook(book);
 reply.status(201).send(result);
}
```

Explanation:
- Controllers delegate data-fetching and processing to services, keeping request-response logic simple.

2.3 Services: Connecting to the Database

Create src/services/booksService.ts:

import prisma from '../plugins/prisma';
export async function getBooks() {
 return await prisma.book.findMany(); // Fetch all books
}
export async function addBook(book: any) {
 return await prisma.book.create({ data: book });
}

Explanation:
- Services handle database queries using Prisma, keeping data-related logic out of controllers.

2.4 Plugins: Adding Custom Features

Create src/plugins/prisma.ts:

import fp from 'fastify-plugin';
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient();

export default fp(async function (fastify) {
  fastify.decorate('prisma', prisma);

  fastify.addHook('onClose', async () => {
    await prisma.$disconnect();
  });
});

export { prisma };

Register this plugin in src/index.ts:

import dbPlugin from './plugins/dbPlugin';

fastify.register(dbPlugin);

2.5 Schemas: Validation and Type Safety

Create src/schemas/bookSchema.ts:

export const bookSchema = {
  type: 'object',
  properties: {
    title: { type: 'string' },
    author: { type: 'string' },
    year: { type: 'integer' },
  },
  required: ['title', 'author'],
};

Use the schema in booksRoutes.ts:

import { bookSchema } from '../schemas/bookSchema';

fastify.post('/books', { schema: { body: bookSchema } }, addBookHandler);

Explanation:
- Schemas ensure incoming data is validated before reaching controllers.

3. Connecting the Dots
Here’s how everything interacts:
1. Request hits a route → routes/bookRoutes.ts.
2. Route calls a controller → controllers/booksController.ts.
3. Controller interacts with a service → services/booksServices.ts.
4. Service performs database operations → plugins/prisma.ts.

Final Words on Modularity
By splitting the project into distinct parts, you ensure that each layer focuses on a specific responsibility. This makes debugging faster, onboarding smoother, and scaling easier.

Adding Security and Rate-Limiting Features

APIs are exposed to the internet, making them prime targets for malicious activities like brute-force attacks, data theft, and service abuse. To safeguard your Fastify application, implementing security headers and rate limiting is essential.

In this section, we’ll:

1. Integrate Helmet.js for security headers.
2. Set up Fastify Rate Limit to prevent abuse.
3. Explain why these features are critical for APIs.

1. Integrating Helmet.js for Security Headers

Helmet.js helps secure your app by setting appropriate HTTP headers to mitigate risks like:

• Cross-Site Scripting (XSS).
• Clickjacking.
• Information leaks through headers.

Installation:

npm install @fastify/helmet

Implementation:
Add this plugin to your Fastify app:

import fastifyHelmet from '@fastify/helmet';
fastify.register(fastifyHelmet, {
  contentSecurityPolicy: false, // Adjust as needed for your app
});

Explanation:

• X-Content-Type-Options: Prevents the browser from interpreting files as a different MIME type.
• X-Frame-Options: Protects against clickjacking attacks.
• Content-Security-Policy (CSP): Restricts sources for scripts, images, and styles.

Why It’s Critical:
These headers act as a protective shield against common attacks, adding a robust baseline of security to your API.

2. Setting Up Fastify Rate Limit

APIs need rate limiting to prevent abuse, such as excessive requests from bots or malicious actors.

Installation:

npm install @fastify/rate-limit

Implementation:
Add this plugin to your Fastify app:

import fastifyRateLimit from '@fastify/rate-limit';

fastify.register(fastifyRateLimit, {
  max: 100, // Maximum number of requests per window
  timeWindow: '1 minute', // Time window for the rate limit
});

Customization:
You can customize rate-limiting rules for specific routes:

fastify.get('/books', { config: { rateLimit: { max: 10, timeWindow: '10 seconds' } } }, async (request, reply) => {
  reply.send({ message: 'This route has custom rate limits!' });
});

Why It’s Critical:

• Prevents Denial-of-Service (DoS) attacks: By limiting the number of requests per user/IP.
• Improves API reliability: Protects server resources from being overwhelmed.

3. Why These Features Are Critical for APIs

• Enhanced User Trust: Secure APIs foster user confidence.
• Compliance: Many standards (e.g., GDPR, PCI DSS) recommend such features.
• Resource Management: Rate limiting ensures fair usage across all users.

Code Recap

Here’s how the security and rate-limiting integration might look in index.ts:

import fastifyHelmet from '@fastify/helmet';
import fastifyRateLimit from '@fastify/rate-limit';

fastify.register(fastifyHelmet, {
  contentSecurityPolicy: false,
});
fastify.register(fastifyRateLimit, {
  max: 100,
  timeWindow: '1 minute',
});

With these features in place, your API becomes significantly more secure and resilient

Setting Up Basic Authentication

Authentication is at the core of API security, ensuring only authorized users can access your resources. Here, we’ll discuss:

1. Adding JWT setup with Fastify for basic authentication.
2. Why authentication is vital.
3. Linking to a future in-depth article for more advanced setups.

1. Adding JWT Setup with Fastify for Authentication

JSON Web Tokens (JWTs) are widely used for stateless authentication. They provide a secure way to verify user identity across API calls.

Installation:

npm install @fastify/jwt

Implementation:
Add the JWT plugin to your Fastify app and configure a secret:

import fastifyJwt from '@fastify/jwt';

fastify.register(fastifyJwt, {
  secret: 'supersecretkey', // Replace with a secure, environment-based value
});

Creating a JWT:
To authenticate a user, generate a token during login:

fastify.post('/login', async (request, reply) => {
  const { username, password } = request.body;

// Dummy validation for illustration
  if (username === 'admin' && password === 'password') {
    const token = fastify.jwt.sign({ username });
    return reply.send({ token });
  }
  return reply.status(401).send({ message: 'Unauthorized' });
});

Verifying a JWT:
Secure routes by verifying the JWT:

fastify.addHook('onRequest', async (request, reply) => {
  try {
    await request.jwtVerify();
  } catch (err) {
    reply.send(err);
  }
});

fastify.get('/secure-data', async (request, reply) => {
  return { message: 'This is protected data!' };
});

2. Why Authentication Is Vital

• Protects Sensitive Data: Prevents unauthorized access to private resources.
• Supports Multi-Tier Access: Allows role-based control (e.g., admin vs. regular users).
• Enhances User Experience: Ensures that data is specific to the authenticated user.

3. Teasing the In-Depth Guide

Since authentication can get complex (e.g., role-based access control, token refresh strategies), we’ll save the details for another article.
Sneak Peek: In that guide, we’ll explore:

• Refresh tokens and token expiry handling.
• Securing sensitive operations with middleware.
• Integrating JWT with external identity providers.

Code Recap

Here’s a simplified view of what your authentication setup might look like:

import fastifyJwt from '@fastify/jwt';

// Register JWT plugin
fastify.register(fastifyJwt, {
  secret: 'supersecretkey',
});
// Login route
fastify.post('/login', async (request, reply) => {
  const { username, password } = request.body;
  if (username === 'admin' && password === 'password') {
    const token = fastify.jwt.sign({ username });
    return reply.send({ token });
  }
  return reply.status(401).send({ message: 'Unauthorized' });
});
// Secure route with JWT verification
fastify.get('/secure-data', async (request, reply) => {
  await request.jwtVerify();
  return { message: 'This is protected data!' };
});

Ready for More?

With basic JWT authentication in place, your API is now equipped with a robust layer of security. For advanced topics like token refresh and multi-role management, stay tuned for our upcoming guide!

Conclusion: Building APIs That Shine

Congratulations! 🎉 You’ve just journeyed through the essential aspects of building a clean, secure, and scalable API with Node.js, FastifyJS, TypeScript, and Prisma. From organizing files like a pro to integrating a robust database and adding security layers, you’ve armed yourself with the tools and knowledge to create professional-grade APIs.

With this setup, not only will your codebase stay maintainable, but your APIs will also perform like a dream — even under pressure. 💨

As you refine your skills, remember: API development isn’t just about code — it’s about creating solutions that make life easier for users and developers alike. So, keep experimenting, learning, and building.

And hey, if JWTs or advanced security concepts are still on your mind, don’t worry — I’ve got that covered in my upcoming articles. Stay tuned for more tech magic! ✨

Until next time, happy coding! 🚀