How to Create a GraphQL Server with NestJS and TypeScript?

How to Create a GraphQL Server with NestJS and TypeScript?

"Elevate APIs with NestJS and TypeScript: Unleash GraphQL's Power"

What is GraphQL API Design?

GraphQL, a query language for APIs, revolutionizes data fetching and manipulation with its robustness and clarity when combined with TypeScript, a statically typed superset of JavaScript.

GraphQL as a new API design paradigm.

GraphQL offers a flexible, efficient approach to data interaction, allowing clients to request specific information using a single endpoint. Its schema-driven approach allows for data structures, relationships, and operations, enabling front-end developers to control data queries and minimize over-fetching or under-fetching.

Create a small example of GraphQL as a new API design paradigm.

We'll use Node.js and Express to construct a simple GraphQL server, and we'll create a schema for querying and updating book data. TypeScript will also be used to ensure type safety.

Step 1: Install the required packages

npm init -y
npm install express express-graphql graphql

Step 2: Set up the server and GraphQL schema

//index.ts
import express from 'express';
import { graphqlHTTP } from 'express-graphql';
import { GraphQLSchema, GraphQLObjectType, GraphQLString } from 'graphql';

const app = express();

const BookType = new GraphQLObjectType({
  name: 'Book',
  fields: () => ({
    title: { type: GraphQLString },
    author: { type: GraphQLString },
  }),
});

const RootQuery = new GraphQLObjectType({
  name: 'RootQueryType',
  fields: {
    book: {
      type: BookType,
      args: {
        title: { type: GraphQLString },
      },
      resolve(parent, args) {
        // Simulate fetching book data from a database
        return { title: args.title, author: 'Unknown Author' };
      },
    },
  },
});

const schema = new GraphQLSchema({
  query: RootQuery,
});

app.use('/graphql', graphqlHTTP({ schema, graphiql: true }));

app.listen(4000, () => {
  console.log('Server is running on port 4000');
});

Step 3: Run your server using ts-node

npx ts-node index.ts

Step 4: Open your browser and navigate

To access the GraphQL playground, open your browser and visit localhost:4000/graphql. You may run interactive searches here.

Step 5: Test query to retrieve a book by its title

query {
  book(title: "The Hitchhiker's Guide to the Galaxy") {
    title
    author
  }
}

How Does TypeScript Empower Type-Safe Development?

TypeScript, a statically typed JavaScript, enables compile-time error detection and GraphQL-based type safety. It allows for consistent data structures on both servers and clients, integrating back-end schema types into front-end codebases, providing auto-completion, tooling support, and reducing runtime errors.

Why Use GraphQL and TypeScript Together?

The combination of GraphQL with TypeScript provides a development experience that combines flexibility and dependability. It provides several benefits, including compile-time validation, automatic documentation, strong refactoring, and increased communication between server and client teams. Furthermore, TypeScript's strong typing boosts GraphQL's functionality by guaranteeing that your data is consistent and errors are identified before they reach production.

What are the steps involved in setting up a GraphQL server using the NestJS framework and TypeScript?

The process of configuring a GraphQL server with the NestJS framework, establishing a strongly typed schema, implementing resolvers, and exploiting TypeScript's advantages to provide a more secure, efficient, and maintainable API.

Step1:Nest CLI to create a new project

npx @nestjs/cli new common-project

Step 2: Navigate to your project directory

cd common-project

Step 3: Install the required dependencies for GraphQL and TypeORM:

npm install @nestjs/graphql @nestjs/typeorm graphql typeorm

Step 4: Create data models using TypeScript classes

// src/user/user.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column()
  email: string;
}

Step 5: Configure your database connection in the app.module.ts.

// src/app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user/user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'data.db',
      entities: [User],
      synchronize: true,
    }),
  ],
})
export class AppModule {}

Step 6: Define your GraphQL schema and resolvers

// src/user/user.resolver.ts
import { Resolver, Query } from '@nestjs/graphql';
import { User } from './user.entity';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';

@Resolver(() => User)
export class UserResolver {
  constructor(
    @InjectRepository(User)
    private readonly userRepository: Repository<User>,
  ) {}

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

Step 7: Set up the GraphQL module in app.module.ts

// src/app.module.ts
import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { UserResolver } from './user/user.resolver';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user/user.entity';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'data.db',
      entities: [User],
      synchronize: true,
    }),
    GraphQLModule.forRoot({
      autoSchemaFile: true,
    }),
  ],
  providers: [UserResolver],
})
export class AppModule {}

Step 8: Start your NestJS application using the Nest CLI

npm run start

Step 9: Open your browser and navigate GraphQL playground

To access the GraphQL playground, open your browser and go to localhost:3000/graphql. You may now run GraphQL queries and investigate your schema.

Summary
Using TypeORM to integrate NestJS, GraphQL, and a SQL database results in a strong stack for designing efficient and maintainable APIs. The procedure begins with the creation of a NestJS project, followed by the installation of dependencies, the definition of data models in TypeScript, and the configuration of the TypeORM connection to the SQL database. You can easily obtain and alter data using a well-defined GraphQL schema and resolvers that connect with TypeORM repositories. This integration provides robust typing across the application, quick querying with GraphQL, and the NestJS framework's features. The GraphQL playground becomes a testing environment for your queries as you run the application, making it easy to create and enhance your API.

Did you find this article valuable?

Support ByteScrum Technologies by becoming a sponsor. Any amount is appreciated!