NestJS உடன் GraphQL API-ஐ எப்படி உருவாக்குவீர்கள்?

Question

Accepted Answer

NestJS-இல் `@nestjs/graphql` (Apollo Server மீது கட்டப்பட்டது) மூலம் முதல்-தர **GraphQL** ஆதரவு உள்ளது. இது ஒரு **code-first** அணுகுமுறையை வழங்குகிறது (TypeScript classes மற்றும் decorators மூலம் உங்கள் schema-ஐ வரையறுக்கவும், schema தானாக உருவாக்கப்படுகிறது) — idiomatic NestJS வழி — framework-இன் decorator/DI model-க்கு பொருந்துகிறது.

## GraphQL அமைத்தல் (code-first)

```ts
@Module({
  imports: [
    GraphQLModule.forRoot<ApolloDriverConfig>({
      driver: ApolloDriver,
      autoSchemaFile: "schema.gql",   // code-first: auto-generate the schema from classes
      playground: true,                // interactive query explorer in dev
    }),
  ],
})
export class AppModule {}
```

## Object types (schema, decorators மூலம் வரையறுக்கப்பட்டது)

```ts
@ObjectType()                        // a GraphQL type
export class User {
  @Field(() => ID) id: string;
  @Field() name: string;
  @Field() email: string;
  @Field(() => [Post]) posts: Post[];   // related type
}
```

Code-first-இல், decorate செய்யப்பட்ட classes (`@ObjectType`, `@Field`) schema-ஐ வரையறுக்கின்றன — TypeScript types GraphQL schema-ஐ தானாக உருவாக்கி, அவற்றை ஒத்திசைவில் வைத்திருக்கின்றன.

## Resolvers (queries மற்றும் mutations)

```ts
@Resolver(() => User)
export class UsersResolver {
  constructor(private usersService: UsersService) {}   // DI works as usual

@Query(() => [User])               // a query: returns a list of users
  users() {
    return this.usersService.findAll();
  }

@Query(() => User)
  user(@Args("id") id: string) {     // query with an argument
    return this.usersService.findOne(id);
  }

@Mutation(() => User)              // a mutation: creates a user
  createUser(@Args("input") input: CreateUserInput) {
    return this.usersService.create(input);
  }
}
```

Resolvers (controllers போல, ஆனால் GraphQL-க்கு) `@Query` மற்றும் `@Mutation` handlers-ஐ வரையறுத்து, DI மூலம் services-க்கு வழங்குகின்றன — REST controllers-ஐப் போன்ற அதே patterns.

## தொடர்புடைய fields-ஐ resolve செய்தல் (N+1 problem-ஐ தவிர்த்தல்)

```ts
@ResolveField(() => [Post])         // resolve User.posts on demand
posts(@Parent() user: User) {
  return this.postsService.findByUser(user.id);
}
// ⚠️ for lists, this can cause N+1 queries → use DataLoader to BATCH them
```

`@ResolveField` ஆனது தொடர்புடைய/nested fields-ஐ lazily resolve செய்கிறது — ஆனால் lists-க்கு, இது **N+1 query problem**-ஐ ஏற்படுத்தும் அபாயம் உள்ளது, இது DataLoader batching மூலம் தீர்க்கப்படுகிறது.

## GraphQL vs REST trade-offs

```text
GraphQL: clients request EXACTLY the fields they need (no over/under-fetching),
         one endpoint, strongly typed, great for complex/nested data & varied clients
REST:    simpler, better HTTP caching, well-understood — fine for straightforward APIs
→ Choose based on needs, not hype. NestJS supports both equally well.
```

## இது ஏன் முக்கியம்

NestJS-இன் முதல்-தர GraphQL ஆதரவு மதிப்புமிக்கது, ஏனெனில் இது GraphQL-இன் நன்மைகளை — clients தங்களுக்குத் தேவையான data-ஐ துல்லியமாகப் பெறுதல் (over- மற்றும் under-fetching-ஐ நீக்குதல்), ஒரு ஒற்றை strongly-typed endpoint, மற்றும் complex/nested data-ஐ சிறப்பாகக் கையாளுதல் — NestJS-இன் பழக்கமான, கட்டமைக்கப்பட்ட model-க்குள் கொண்டுவருகிறது.

நவீன APIs-ஐ உருவாக்குவதற்கு அதைப் புரிந்துகொள்வது முக்கியம், குறிப்பாக idiomatic **code-first அணுகுமுறை** (TypeScript classes மற்றும் `@ObjectType`/`@Field`/`@Resolver` decorators மூலம் schema-ஐ வரையறுத்தல், schema தானாக உருவாக்கப்பட்டு ஒத்திசைவில் வைக்கப்படுதல்) இது NestJS-இன் decorator/DI கட்டிடக்கலைக்கு இயற்கையாகப் பொருந்துகிறது — resolvers controllers போலவே வேலை செய்து, inject செய்யப்பட்ட services-க்கு வழங்குகின்றன.

Types, queries, mutations, மற்றும் resolved fields-ஐ எப்படி வரையறுப்பது, மற்றும் nested data-க்கு **N+1 query problem** (மற்றும் தீர்வாக DataLoader) பற்றி அறிந்திருப்பது முக்கிய senior-level அறிவாகும்.

ஒரு குறிப்பிட்ட project-க்கான சரியான அணுகுமுறையைத் தேர்வுசெய்ய **GraphQL vs REST trade-offs**-ஐ புரிந்துகொள்வதும் சமமாக முக்கியம் (நெகிழ்வான, complex, multi-client data தேவைகளுக்கு GraphQL; வலுவான HTTP caching கொண்ட எளிய APIs-க்கு REST).

GraphQL ஒரு பெரிய API paradigm ஆகும், மேலும் NestJS-இன் சுத்தமான integration நெகிழ்வான, திறமையான back-ends-ஐ உருவாக்குவதற்கான ஒரு முக்கியமான, அடிக்கடி தொடர்புடைய திறனாக ஆக்குகிறது.