ਤੁਸੀਂ NestJS ਨਾਲ GraphQL API ਕਿਵੇਂ ਬਣਾਉਂਦੇ ਹੋ?

Question

Accepted Answer

NestJS ਕੋਲ `@nestjs/graphql` ਦੁਆਰਾ **GraphQL** ਦਾ ਪਹਿਲਾ-ਸਿੰਘ ਸਮਰਥਨ ਹੈ (Apollo Server ਉੱਤੇ ਬਣਿਆ ਹੋਇਆ)। ਇਹ ਇੱਕ **code-first** ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (TypeScript ਕਲਾਸਾਂ ਅਤੇ decorators ਦੇ ਨਾਲ ਆਪਣਾ schema ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ, schema ਆਪਣੇ ਆਪ ਤੈਅ ਹੋ ਜਾਂਦਾ ਹੈ) — NestJS ਦਾ idiomaticਤਰੀਕਾ — ਜੋ ਫਰੇਮਵਰਕ ਦੇ 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 ਕਲਾਸਾਂ (`@ObjectType`, `@Field`) schema ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀਆਂ ਹਨ — TypeScript ਕਿਸਮਾਂ 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 (ਕੰਟਰੋਲਰਾਂ ਵਰਗੇ, ਪਰ 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 ਖੋਜ ਸਮੱਸਿਆ** ਦਾ ਖਤਰਾ ਰੱਖਦਾ ਹੈ, 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 ਦੇ ਲਾਭ — ਕਲਾਇੰਟਸ ਬਿਲਕੁਲ ਉਹ ਡੇਟਾ ਲਿਆ ਰਹੇ ਹਨ ਜੋ ਉਨ੍ਹਾਂ ਨੂੰ ਚਾਹੀਦਾ ਹੈ (over- ਅਤੇ under-fetching ਨੂੰ ਖਤਮ ਕਰਨਾ), ਇੱਕ ਸਿੰਗਲ ਮਜਬੂਤ-ਕਿਸਮ ਦਾ endpoint, ਅਤੇ ਜ਼ਟਿਲ/ਨੇਸਟਡ ਡੇਟਾ ਦੀ ਸ਼ਾਨਦਾਰ ਹੈਂਡਲਿੰਗ — NestJS ਦੇ ਜਾਣੂ, ਸੰਰਚਿਤ ਮਾਡਲ ਵਿੱਚ ਲੈ ਆਉਂਦਾ ਹੈ।
ank ਨੂੰ ਸਮਝਣਾ ਆਧੁਨਿਕ APIs ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ, ਖਾਸ ਕਰਕੇ idiomatic **code-first ਤਰੀਕਾ** (TypeScript ਕਲਾਸਾਂ ਅਤੇ `@ObjectType`/`@Field`/`@Resolver` decorators ਨਾਲ schema ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ, schema ਆਪਣੇ ਆਪ ਤੈਅ ਅਤੇ ਸਿੰਕ ਵਿੱਚ ਰੱਖਿਆ ਜਾ ਰਿਹਾ ਹੈ) ਜੋ NestJS ਦੇ decorator/DI ਆਰਕੀਟੈਕਚਰ ਨਾਲ ਕੁਦਰਤੀ ਢੰਗ ਨਾਲ ਫਿੱਟ ਹੋਂਦਾ ਹੈ — resolvers ਕੰਟਰੋਲਰਾਂ ਵਾਂਗ ਕੰਮ ਕਰਦੇ ਹਨ, injected ਸੇਵਾਵਾਂ ਨੂੰ ਭੇਜਦੇ ਹਨ।

Types, queries, mutations, ਅਤੇ resolved fields ਨੂੰ ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਹੈ, ਅਤੇ nested data ਲਈ **N+1 ਖੋਜ ਸਮੱਸਿਆ** ਬਾਰੇ ਜਾਗਰੂਕ ਹੋਣਾ (ਅਤੇ ਸਮਾਧਾਨ ਵਜੋਂ DataLoader) ਕੁੰਜੀ ਸੀਨੀਅਰ-ਲੈਵਲ ਗਿਆਨ ਹੈ।

ਇਹ ਸਮਝਣਾ ਕਿ **GraphQL ਬਨਾਮ REST trade-offs** ਕਿਵੇਂ ਹਨ ਤਾਂ ਜੋ ਕਿਸੇ ਦਿੱਤੀ ਪ੍ਰਾਜੈਕਟ (GraphQL ਲਈ ਲਚਕਦਾਰ, ਜ਼ਟਿਲ, ਮਲਟੀ-ਕਲਾਇੰਟ ਡੇਟਾ ਲੋੜਾਂ; REST ਸਿਧਾ APIs ਲਈ ਮਜਬੂਤ HTTP caching) ਦਿਖਾਇਆ ਜਾਂਦਾ ਹੈ, ਬਰਾਬਰ ਮਹੱਤਵਪੂਰਨ ਹੈ।

GraphQL ਇੱਕ ਪ੍ਰਮੁੱਖ API ਪਰਾਡਾਈਮ ਹੈ, ਅਤੇ NestJS ਦਾ ਸਾਫ ਏਕਕਰਣ ਇਸ ਨੂੰ ਲਚਕਦਾਰ, ਕਮਜ਼ੋਰ ਬੈਕ-ਐਂਡਸ ਬਣਾਉਣ ਲਈ ਇੱਕ ਮਹੱਤਵਪੂਰਨ, ਬਾਰ-ਬਾਰ-ਰੇਲਵੰਤ ਸਮਰਥਾ ਬਣਾ ਦਿੰਦਾ ਹੈ।