Hybrid applications in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when running a NestJS hybrid app with both HTTP and microservice listeners?

Consider a NestJS hybrid application that starts both an HTTP server and a microservice listener. What will happen when you send an HTTP request to the app's endpoint?

NestJS

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { Transport } from '@nestjs/microservices';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.connectMicroservice({ transport: Transport.TCP });
  await app.startAllMicroservices();
  await app.listen(3000);
}
bootstrap();

A The app listens on port 3000 for HTTP requests and also listens for TCP microservice messages simultaneously.

B The app only listens for TCP microservice messages and ignores HTTP requests.

C The app listens only on port 3000 for HTTP requests and does not start the microservice listener.

D The app throws an error because it cannot start both HTTP and microservice listeners at the same time.

💡 Hint

Think about how NestJS handles multiple listeners in a hybrid app.

In a NestJS hybrid app, you can start both HTTP and microservice listeners. The HTTP server listens on the specified port, and the microservice listens on its transport layer (TCP here). Both run simultaneously.

❓ lifecycle

intermediate

What happens if you call app.listen() before app.startAllMicroservices() in a NestJS hybrid app?

In a NestJS hybrid app, you have two ways to start servers: app.listen() for HTTP and app.startAllMicroservices() for microservices. What is the effect of calling app.listen() before app.startAllMicroservices()?

NestJS

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.connectMicroservice({ transport: Transport.REDIS });
  await app.listen(3000);
  await app.startAllMicroservices();
}
bootstrap();

A Only the HTTP server runs; the microservice listener is ignored silently.

B The microservice listener never starts because app.listen() blocks the event loop.

C The app throws an error because startAllMicroservices must be called before listen.

D The HTTP server starts first, then the microservice listener starts after; both run correctly.

💡 Hint

Consider how async/await works and how NestJS manages multiple listeners.

Calling app.listen() starts the HTTP server and returns a promise that resolves when the server is ready. Then app.startAllMicroservices() starts the microservice listeners. Both run correctly regardless of order.

📝 Syntax

advanced

Which option correctly creates a NestJS hybrid app with HTTP and RabbitMQ microservice?

Choose the code snippet that correctly sets up a NestJS hybrid application with an HTTP server and a RabbitMQ microservice listener.

A

const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: { urls: 'amqp://localhost', queue: 'main_queue' } });
await app.startAllMicroservices();
await app.listen(3000);

B

const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: { urls: ['amqp://localhost'], queue: 'main_queue' } });
await app.startAllMicroservices();
await app.listen(3000);

C

const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: { url: 'amqp://localhost', queue: 'main_queue' } });
await app.startAllMicroservices();
await app.listen(3000);

D

const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: { url: ['amqp://localhost'], queue: 'main_queue' } });
await app.startAllMicroservices();
await app.listen(3000);

💡 Hint

Check the property name for RabbitMQ connection URLs in NestJS microservice options.

The correct property for RabbitMQ connection URLs is urls as an array of strings. Option B uses this correctly. Other options use incorrect property names or types.

🔧 Debug

advanced

Why does this NestJS hybrid app fail to receive microservice messages?

Given the following code, why does the microservice listener not receive any messages?

NestJS

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.connectMicroservice({ transport: Transport.TCP });
  await app.listen(3000);
  // Missing await app.startAllMicroservices();
}
bootstrap();

A Because the transport type TCP is not supported in hybrid apps.

B Because <code>app.listen()</code> blocks microservice messages from being processed.

C Because <code>app.startAllMicroservices()</code> was not called, so the microservice listener never started.

D Because the microservice listener must be started before <code>app.listen()</code> or it fails silently.

💡 Hint

Check if the microservice listener is actually started.

Calling app.connectMicroservice() only configures the microservice. You must call app.startAllMicroservices() to start listening. Without it, microservice messages are not received.

🧠 Conceptual

expert

What is the main advantage of using a NestJS hybrid application?

Why would a developer choose to build a NestJS hybrid application instead of separate HTTP and microservice apps?

A It allows sharing the same codebase and dependency injection container for both HTTP and microservice servers, reducing duplication and improving maintainability.

B It automatically scales microservices independently without any additional configuration.

C It forces the app to use only one transport protocol, simplifying network setup.

D It disables HTTP server features to optimize microservice performance.

💡 Hint

Think about code reuse and architecture benefits.

A NestJS hybrid app runs both HTTP and microservice servers in the same process and shares the same dependency injection container. This reduces code duplication and makes maintenance easier.

Practice

1. What is a hybrid application in NestJS?

easy

A. An app that combines HTTP and microservices in one project

B. An app that only uses HTTP controllers

C. An app that only uses microservices

D. An app that runs on multiple servers

Solution

1. Step 1: Understand NestJS application types

   NestJS apps can be HTTP-based, microservice-based, or both combined.

2. Step 2: Define hybrid application

   A hybrid app combines HTTP and microservices in one project to handle both communication types.

3. Final Answer:

   An app that combines HTTP and microservices in one project -> Option A

4. Quick Check:

   Hybrid app = HTTP + microservices [OK]

Hint: Hybrid means mixing HTTP and microservices in one app [OK]

Common Mistakes:

• Thinking hybrid means multiple servers
• Confusing hybrid with only HTTP or only microservices
• Assuming hybrid apps are separate projects

2. Which method is used to add microservice support in a NestJS hybrid application?

easy

A. connectMicroservice()

B. createMicroservice()

C. addMicroservice()

D. useMicroservice()

Solution

1. Step 1: Recall NestJS microservice integration method

   The official NestJS method to add microservices to an app is connectMicroservice().

2. Step 2: Verify method names

   Other options like createMicroservice(), addMicroservice(), or useMicroservice() are not valid NestJS methods.

3. Final Answer:

   connectMicroservice() -> Option A

4. Quick Check:

   Use connectMicroservice() to add microservices [OK]

Hint: Remember: connectMicroservice() connects microservices [OK]

Common Mistakes:

• Using createMicroservice() which does not exist
• Confusing with addMicroservice() or useMicroservice()
• Trying to add microservices without this method

3. Given this NestJS hybrid app code snippet, what will be the output when the app starts?

const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.TCP });
await app.startAllMicroservices();
await app.listen(3000);
console.log('App is running');

medium

A. App listens on port 3000 but microservices do not start

B. App is running (and microservices start listening)

C. Error: connectMicroservice is not a function

D. App crashes due to missing microservice configuration

Solution

1. Step 1: Analyze microservice connection

   The code calls connectMicroservice with TCP transport, which is valid to add microservices.

2. Step 2: Check microservice start and app listen

   startAllMicroservices() starts microservices, then app.listen(3000) starts HTTP server. Console logs 'App is running'.

3. Final Answer:

   App is running (and microservices start listening) -> Option B

4. Quick Check:

   connectMicroservice + startAllMicroservices + listen = running app [OK]

Hint: connectMicroservice + startAllMicroservices means microservices run [OK]

Common Mistakes:

• Thinking microservices start automatically without startAllMicroservices()
• Confusing connectMicroservice with createMicroservice
• Assuming app.listen blocks microservices

4. Identify the error in this NestJS hybrid app setup:

const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.REDIS });
await app.listen(3000);
await app.startAllMicroservices();

medium

A. AppModule cannot be used with microservices

B. connectMicroservice() does not accept transport option

C. startAllMicroservices() must be called before app.listen()

D. Missing await before connectMicroservice()

Solution

1. Step 1: Check method call order

   In NestJS, microservices must be started before the HTTP server listens, so startAllMicroservices() should be before app.listen().

2. Step 2: Validate other options

   connectMicroservice() accepts transport option; AppModule supports microservices; connectMicroservice() is synchronous, no await needed.

3. Final Answer:

   startAllMicroservices() must be called before app.listen() -> Option C

4. Quick Check:

   Start microservices before HTTP listen [OK]

Hint: Call startAllMicroservices() before app.listen() [OK]

Common Mistakes:

• Calling startAllMicroservices() after app.listen()
• Adding await to connectMicroservice()
• Thinking transport option is invalid

5. You want to build a NestJS hybrid app that handles HTTP requests and listens to RabbitMQ messages. Which steps correctly set up the microservice part?

hard

A. Use connectMicroservice({ transport: Transport.TCP }) and call startAllMicroservices() after app.listen()

B. Use createMicroservice({ transport: Transport.RMQ }) and call app.listen() before starting microservices

C. Add RabbitMQ config in AppModule imports and call app.listen() only

D. Use connectMicroservice({ transport: Transport.RMQ, options: { urls: ['amqp://localhost'], queue: 'main_queue' } }), then call startAllMicroservices() before app.listen()

Solution

1. Step 1: Choose correct microservice setup for RabbitMQ

   connectMicroservice() with Transport.RMQ and proper options (urls, queue) is the correct way to add RabbitMQ microservice.

2. Step 2: Call startAllMicroservices() before app.listen()

   Microservices must start before HTTP server listens to ensure both run properly.

3. Final Answer:

   Use connectMicroservice({ transport: Transport.RMQ, options: { urls: ['amqp://localhost'], queue: 'main_queue' } }), then call startAllMicroservices() before app.listen() -> Option D

4. Quick Check:

   connectMicroservice + RMQ options + startAllMicroservices before listen [OK]

Hint: Set RMQ options in connectMicroservice and start microservices first [OK]

Common Mistakes:

• Using createMicroservice() which is not a NestFactory method
• Calling app.listen() before starting microservices
• Using wrong transport type for RabbitMQ
• Not providing RabbitMQ connection options