NestJS microservices کو کس طریقے سے سپورٹ کرتا ہے؟

Question

Accepted Answer

NestJS میں **built-in microservices support** ہے — یہ ایک microservice کے طور پر چل سکتا ہے جو مختلف **transports** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) کے ذریعے HTTP کی بجائے communicate کرتا ہے، ایک consistent، message-based programming model استعمال کرتے ہوئے۔ وہی NestJS structure (modules, services, DI) لاگو ہوتی ہے؛ صرف transport اور message patterns بدلتے ہیں۔

## Microservice بنانا

```ts
// a microservice listens on a transport instead of HTTP
const app = await NestFactory.createMicroservice(AppModule, {
  transport: Transport.TCP,             // or REDIS, NATS, RMQ, KAFKA, GRPC
  options: { host: "0.0.0.0", port: 3001 },
});
await app.listen();
```

## Message patterns بمقابلہ event patterns

```ts
@Controller()
export class MathController {
  // REQUEST-RESPONSE: respond to a message and RETURN a result (RPC-style)
  @MessagePattern({ cmd: "sum" })
  sum(data: number[]): number {
    return data.reduce((a, b) => a + b, 0);   // the caller awaits this result
  }

// EVENT-BASED: react to an event, NO response expected (fire-and-forget)
  @EventPattern("order_created")
  handleOrderCreated(data: OrderDto) {
    this.processOrder(data);                   // just react; nothing returned
  }
}
```

دو communication styles ہیں: **`@MessagePattern`** request-response کے لیے (caller ایک نتیجے کا انتظار کرتا ہے، RPC کی طرح) اور **`@EventPattern`** events کے لیے (fire-and-forget، decoupled — publisher انتظار نہیں کرتا)۔

## دوسری microservice کو کال کرنا (client)

```ts
@Injectable()
export class AppService {
  constructor(@Inject("MATH_SERVICE") private client: ClientProxy) {}

async getSum() {
    // send() → request-response (returns an Observable of the result)
    return this.client.send({ cmd: "sum" }, [1, 2, 3]);
    // emit() → fire an event (no response)
    this.client.emit("order_created", orderData);
  }
}
```

ایک `ClientProxy` (`ClientsModule` کے ذریعے configured) دوسری services کو messages/events بھیجتا ہے — request-response کے لیے `send()`، events کے لیے `emit()`۔

## Hybrid applications

```ts
// an app can serve HTTP AND connect microservice transports simultaneously
const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: {...} });
await app.startAllMicroservices();
await app.listen(3000);   // HTTP too
```

## Transport کا انتخاب اہم ہے

```text
TCP   → simple direct service-to-service
Redis/NATS → lightweight pub/sub messaging
RabbitMQ/Kafka → robust message queues/streams (durability, retries, decoupling)
gRPC  → high-performance, strongly-typed RPC (protobuf)
→ Async message brokers (RMQ/Kafka) give decoupling & resilience; gRPC gives speed+typing.
```

## یہ کیوں اہم ہے

NestJS کی built-in microservices support اس لیے اہم ہے کہ یہ آپ کو distributed systems بنانے دیتی ہے جو *وہی* familiar NestJS structure (modules, providers, DI, decorators) استعمال کرتے ہوئے HTTP کو message-based transports سے بدل سکتے ہیں — ایک بڑا productivity اور consistency فائدہ۔

اسے سمجھنا scalable systems کو design کرنے کے لیے اہم ہے: **message-pattern (request-response) بمقابلہ event-pattern (fire-and-forget) distinction** براہ راست microservices communication کے بنیادی انتخاب سے map کرتی ہے — synchronous RPC-style calls بمقابلہ asynchronous، decoupled events (یہ بعد میں، message brokers کے ذریعے، resilience اور loose coupling فراہم کرتے ہوئے جو microservices کو مضبوط بناتے ہیں)۔

یہ جاننا کہ microservices کو کیسے بنایا جائے، message/event handlers کو define کریں، دوسری services کو `ClientProxy` کے ذریعے کال کریں، hybrid HTTP+microservice apps بنائیں، اور transports کا انتخاب کریں (lightweight pub/sub بمقابلہ durable queues جیسے Kafka/RabbitMQ بمقابلہ high-performance gRPC) distributed back-ends کو design کرنے کے لیے senior-level knowledge میں قیمتی ہے۔

اگرچہ microservices حقیقی complexity شامل کرتے ہیں (اور ہمیشہ monolith سے بہتر نہیں ہوتے)، NestJS implementation کو صاف اور consistent بناتا ہے، جو یہ ایک اہم architectural topic بناتا ہے بڑے پیمانے پر، distributed NestJS systems کو build کرنے کے لیے۔