તમે NestJS સાથે GraphQL API કેવી રીતે બનાવો છો?

Question

Accepted Answer

NestJS પાસે `@nestjs/graphql` (Apollo Server પર આધારિત) દ્વારા પ્રથમ-શ્રેણીનો **GraphQL** સમર્થન છે. તે **code-first** અભિગમ પ્રદાન કરે છે (TypeScript ક્લાસીસ અને ડેકોરેટર્સ સાથે તમારો સ્કીમા વ્યાખ્યાયિત કરો, સ્કીમા સ્વતઃ-જનરેટ થાય) — આ NestJS શૈલીનો ઉપયોગ કરવાનો રીતો છે — ફ્રેમવર્કના ડેકોરેટર/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 (સ્કીમા, ડેકોરેટર્સ સાથે વ્યાખ્યાયિત)

```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 માં, ડેકોરેટેડ ક્લાસીસ (`@ObjectType`, `@Field`) સ્કીમા વ્યાખ્યાયિત કરે છે — TypeScript પ્રકાર GraphQL સ્કીમા સ્વતઃ જનરેટ કરે છે, તેમને સમન્વયમાં રાખે છે।

## 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 દ્વારા સેવાઓને સોંપે છે — REST નિયંત્રકોની જેમ સમાન પેટર્ન।

## સંબંધિત ક્ષેત્રોનું નિરાકરણ (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` સંબંધિત/નેસ્ટેડ ક્ષેત્રોને આળસથી નિરાકર કરે છે — પરંતુ તાલિકાઓ માટે, આ **N+1 query સમસ્યાનું** જોખમ ઉત્પન્ન કરે છે, DataLoader બેચિંગ દ્વારા હલ કરાય છે।

## 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 નો પ્રથમ-શ્રેણીનો GraphQL સમર્થન મૂલ્યવાન છે કારણ કે તે GraphQL ના ફાયદા લાવે છે — ક્લાયન્ટો બરાબર તે ડેટા લાવે છે જે તેમને જોઈએ છે (વધારાના અને અપૂર્ણ લાવણીને દૂર કરીને), એક શક્તિશાળી-પ્રકારનું એન્ડપોઈન્ટ, અને જટિલ/નેસ્ટેડ ડેટાની શ્રેષ્ઠ હેન્ડલિંગ — NestJS ના પરિચિત, સંરચિત મોડેલમાં।
	eમને સમજવું આધુનિક APIs બનાવવા માટે મહત્વપૂર્ણ છે, ખાસ કરીને આદર્શ **code-first અભિગમ** (TypeScript ક્લાસીસ અને `@ObjectType`/`@Field`/`@Resolver` ડેકોરેટર્સ સાથે સ્કીમા વ્યાખ્યાયિત કરવું, સ્કીમા સ્વતઃ-જનરેટ અને સમન્વયમાં રાખવું) જે NestJS ના ડેકોરેટર/DI આર્કિટેક્ચરમાં કુદરતી રીતે ફિટ છે — resolvers નિયંત્રકો જેવા કામ કરે છે, સોંપેલ સેવાઓને સોંપે છે।

પ્રકારો, queries, mutations, અને resolved ક્ષેત્રો કેવી રીતે વ્યાખ્યાયિત કરવા તે જાણવું, અને **N+1 query સમસ્યાની** સાક્ષી રાખવી (અને નેસ્ટેડ ડેટા માટે ઉપાય તરીકે DataLoader) વરિષ્ઠ-સ્તરનું જ્ઞાન છે।

સમાનરૂપે મહત્વપૂર્ણ **GraphQL વિ REST વેપાર-બંધ** સમજવું છે આપેલ પ્રોજેક્ટ માટે યોગ્ય અભિગમ પસંદ કરવા માટે (GraphQL લવચક, જટિલ, બહુ-ક્લાયન્ટ ડેટા જરૂરિયાતો માટે; REST સરળ APIs માટે મજબૂત HTTP કેશિંગ સાથે)।

GraphQL એક પ્રમુખ API પેરાડાયમ છે, અને NestJS ની સ્વચ્છ સંકલન તેને મહત્વપૂર્ણ, વારંવાર-સુસંગત ક્ષમતા બનાવે છે લવચક, કાર્યક્ષમ back-ends બનાવવા માટે।