Build Type-Safe GraphQL APIs with TypeGraphQL and Fastify

js

Build Type-Safe GraphQL APIs with TypeGraphQL and Fastify

Learn how to create high-performance, type-safe GraphQL APIs using TypeGraphQL and Fastify for seamless development and speed.

Jan 13, 2026

Build Type-Safe GraphQL APIs with TypeGraphQL and Fastify

I’ve been thinking about building GraphQL APIs lately, and a particular frustration keeps coming up. I write my business logic in TypeScript, with all its wonderful type safety, only to then define my GraphQL schema separately. This creates two sources of truth that can drift apart. What if my code and my API schema could be the same thing? That’s exactly what led me to explore combining TypeGraphQL with Fastify.

TypeGraphQL lets you define your entire GraphQL schema using TypeScript classes and decorators. You write your types once. The schema is generated from your code. This means when you change a field in your TypeScript class, your GraphQL API updates automatically. There’s no manual sync. TypeScript’s compiler becomes your first line of defense against API inconsistencies.

But why Fastify? Many tutorials pair TypeGraphQL with Express. It works, but Fastify offers something special: raw speed and a built-in validation system. Fastify is one of the fastest web frameworks for Node.js. Its plugin system is clean, and it’s designed from the ground up for performance. For a GraphQL endpoint that might handle complex queries, every millisecond counts.

Think about it. You get the developer experience of a fully type-safe GraphQL API, built directly from your TypeScript, served by one of the fastest available servers. It feels like having your cake and eating it too. The integration is about removing friction and boosting performance, two things every developer cares about.

Let’s look at how this works in practice. First, you define your data types as TypeScript classes with decorators. This is your single source of truth.

import { Field, ID, ObjectType, InputType } from "type-graphql";

@ObjectType()
export class User {
  @Field(() => ID)
  id: string;

  @Field()
  email: string;

  @Field({ nullable: true })
  name?: string;
}

@InputType()
export class CreateUserInput {
  @Field()
  email: string;

  @Field({ nullable: true })
  name?: string;
}

Notice something? The User class serves both as a TypeScript type for our internal logic and as the definition for the GraphQL User object type. The CreateUserInput class defines the shape of data clients can send. This is the core idea. One class, two purposes.

Next, we create resolvers. These are also TypeScript classes with methods that handle GraphQL queries and mutations. The decorators tell TypeGraphQL what each method does.

import { Arg, Mutation, Query, Resolver } from "type-graphql";
import { User, CreateUserInput } from "./user-type";

@Resolver(() => User)
export class UserResolver {
  private users: User[] = []; // Simple in-memory store for example

  @Query(() => [User])
  async getUsers(): Promise<User[]> {
    return this.users;
  }

  @Query(() => User, { nullable: true })
  async getUser(@Arg("id") id: string): Promise<User | undefined> {
    return this.users.find(user => user.id === id);
  }

  @Mutation(() => User)
  async createUser(@Arg("data") data: CreateUserInput): Promise<User> {
    const newUser = {
      id: `user_${Date.now()}`,
      ...data,
    };
    this.users.push(newUser);
    return newUser;
  }
}

The resolver is clean. The @Query() and @Mutation() decorators are self-explanatory. The @Arg() decorator grabs arguments from the GraphQL query. The best part? The data argument in createUser is strongly typed as CreateUserInput. TypeScript will complain if you try to access a property that doesn’t exist. Your IDE’s autocomplete will work. It’s a seamless development experience.

Now, how do we plug this into Fastify? We don’t use the standard express-graphql or apollo-server-express. Instead, we use type-graphql’s buildSchema to create a schema from our resolvers, and then serve it with a Fastify-specific adapter. Here’s a basic server setup.

import Fastify from "fastify";
import { buildSchema } from "type-graphql";
import { UserResolver } from "./user-resolver";
import { graphqlFastify } from "./fastify-adapter"; // A custom wrapper

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

async function startServer() {
  // Build the GraphQL schema programmatically
  const schema = await buildSchema({
    resolvers: [UserResolver],
  });

  // Register the GraphQL route with Fastify
  app.register(graphqlFastify, {
    schema,
    graphiql: true, // Enable the GraphiQL UI for testing
  });

  await app.listen({ port: 4000 });
  console.log(`Server running at http://localhost:4000/graphql`);
}

startServer().catch(console.error);

The graphqlFastify function is a small wrapper that adapts the GraphQL schema to Fastify’s request/reply lifecycle. It handles the HTTP POST requests, passes the query to the schema, and sends back the JSON response. Fastify’s speed comes from its lightweight core and efficient handling of requests and responses.

What about validation? GraphQL has its own type validation, but sometimes you need more. Fastify has excellent JSON schema validation for regular REST routes. With this setup, you rely on GraphQL’s native argument validation, which TypeGraphQL enhances. You can add custom validation rules using libraries like class-validator with decorators inside your InputType classes.

Is there a catch? The initial setup has a few more steps than a simple Express server. You need to understand both TypeGraphQL’s decorator patterns and Fastify’s plugin system. But once it’s running, the workflow is incredibly smooth. You modify a TypeScript class, and your API is updated. You get errors at compile time, not when a client sends a malformed query.

This combination is perfect for projects where performance and type safety are non-negotiable. Microservices, BFF (Backend for Frontend) layers, or any new GraphQL API where you control the server. It reduces a whole category of bugs and makes the API a natural extension of your TypeScript codebase.

So, the next time you start a GraphQL project, consider this stack. Start with your TypeScript types. Decorate them. Write your resolver logic. Let TypeGraphQL build the schema. Serve it with Fastify. You’ll end up with an API that is fast, reliable, and a joy to maintain. The gap between your code and your API contract will vanish.

Did this approach to building APIs spark any ideas for your own projects? If you found this walk-through helpful, please share it with other developers who might be wrestling with GraphQL and type safety. Have you tried a similar setup, or do you have questions about a specific part of the integration? Let me know in the comments below—I’d love to hear about your experiences and keep the conversation going.

As a best-selling author, I invite you to explore my books on Amazon. Don’t forget to follow me on Medium and show your support. Thank you! Your support means the world!

101 Books

101 Books is an AI-driven publishing company co-founded by author Aarav Joshi. By leveraging advanced AI technology, we keep our publishing costs incredibly low—some books are priced as low as $4—making quality knowledge accessible to everyone.

Check out our book Golang Clean Code available on Amazon.

Stay tuned for updates and exciting news. When shopping for books, search for Aarav Joshi to find more of our titles. Use the provided link to enjoy special discounts!

📘 Checkout my latest ebook for free on my channel!
Be sure to like, share, comment, and subscribe to the channel!

Our Creations

Be sure to check out our creations:

We are on Medium

Share: Facebook Twitter Reddit LinkedIn WhatsApp Telegram Pinterest Email Instagram

js