तुम NestJS सह GraphQL API कसे तयार करता?

Question

Accepted Answer

NestJS ला `@nestjs/graphql` द्वारे **GraphQL** साठी first-class समर्थन आहे (Apollo Server वर बनविले). हे **code-first** दृष्टिकोन देते (TypeScript classes आणि decorators सह schema परिभाषित करा, schema स्वयंचलितपणे तयार होतो) — NestJS ची idiomatic पद्धती — framework च्या decorator/DI मॉडेलसाठी उपयुक्त.

## 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 मध्ये, decorated classes (`@ObjectType`, `@Field`) schema परिभाषित करतात — TypeScript प्रकार GraphQL schema स्वयंचलितपणे तयार करतात, त्यांना sync मध्ये ठेवतात.

## 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 (नियंत्रकांसारखे, परंतु GraphQL साठी) `@Query` आणि `@Mutation` हँडलर परिभाषित करतात, DI द्वारे services ला delegate करतात — REST नियंत्रकांच्या समान नमुने.

## संबंधित fields सोडवणे (N+1 समस्या टाळणे)

```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 को आलस्यपणे सोडवतो — परंतु lists साठी, यामुळे **N+1 query समस्या** चा धोका असतो, DataLoader batching द्वारे सोडविले जाते.

## GraphQL विरुद्ध REST ट्रेड-ऑफ

```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 चे first-class GraphQL समर्थन मूल्यवान आहे कारण हे GraphQL चे फायदे आणते — क्लायंट त्यांना आवश्यक अगोदर डेटा मिळवा (over- आणि under-fetching काढून टाका), एक strongly-typed endpoint, आणि जटिल/nested डेटाचे उत्कृष्ट हँडलिंग — NestJS च्या परिचित, संरचित मॉडेलमध्ये.
ison्याचे समज महत्वाचे आहे आधुनिक APIs तयार करण्यासाठी, विशेषत: idiomatic **code-first दृष्टिकोन** (TypeScript classes आणि `@ObjectType`/`@Field`/`@Resolver` decorators सह schema परिभाषित करणे, schema स्वयंचलितपणे तयार आणि sync मध्ये ठेवले) जे NestJS च्या decorator/DI आर्किटेक्चरमध्ये नैसर्गिकरित्या फिट होतो — resolvers नियंत्रकांच्या समान काम करतात, injected services ला delegate करतात.

प्रकार, queries, mutations, आणि resolved fields परिभाषित कसे करायचे हे जाणून, आणि **N+1 query समस्या** (आणि DataLoader समाधान म्हणून) nested डेटासाठी याचे सचेतता हे senior-level ज्ञान आहे.

समानरित्या महत्वाचे आहे **GraphQL विरुद्ध REST ट्रेड-ऑफ** समझणे दिलेल्या प्रकल्पासाठी योग्य दृष्टिकोन निवडण्यासाठी (flexible, complex, multi-client डेटा गरजांसाठी GraphQL; सरल APIs साठी strong HTTP caching सह REST).

GraphQL एक मुख्य API प्रतिमान आहे, आणि NestJS चे स्वच्छ एकीकरण हे flexible, efficient back-ends तयार करण्यासाठी एक महत्वपूर्ण, वारंवार-प्रासंगिक क्षमता बनवते.