Subscriptions in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this NestJS subscription resolver output?

Consider this NestJS GraphQL subscription resolver snippet. What will the client receive when the triggerEvent method is called?

NestJS

import { Resolver, Subscription, Mutation, Args } from '@nestjs/graphql';
import { PubSub } from 'graphql-subscriptions';

const pubSub = new PubSub();

@Resolver()
export class EventResolver {
  @Subscription(() => String, {
    filter: (payload, variables) => payload.event === variables.eventName,
  })
  eventTriggered(@Args('eventName') eventName: string) {
    return pubSub.asyncIterator('eventTriggered');
  }

  @Mutation(() => Boolean)
  async triggerEvent(@Args('event') event: string) {
    await pubSub.publish('eventTriggered', { event: event });
    return true;
  }
}

A The client receives the event string only if the event name matches the subscription argument.

B The client receives all events regardless of the event name argument.

C The client receives an error because asyncIterator is used incorrectly.

D The client receives no events because the filter function is incorrect.

💡 Hint

Look at the filter function inside the subscription decorator.

The filter function checks if the event payload's event matches the subscription argument eventName. Only matching events are sent to the client.

❓ lifecycle

intermediate

When is the subscription resolver's asyncIterator created in NestJS?

In a NestJS GraphQL subscription resolver, when is the asyncIterator function called during the subscription lifecycle?

NestJS

import { Resolver, Subscription } from '@nestjs/graphql';
import { PubSub } from 'graphql-subscriptions';

const pubSub = new PubSub();

@Resolver()
export class SampleResolver {
  @Subscription(() => String)
  sampleSub() {
    return pubSub.asyncIterator('sampleEvent');
  }
}

A When the client sends a mutation, not during subscription.

B When the client first subscribes, creating a new async iterator for that client.

C Only when an event is published, triggering the async iterator.

D When the server starts, creating a single async iterator for all clients.

💡 Hint

Think about how subscriptions work per client connection.

Each client subscription triggers the resolver method, which returns a new async iterator instance for that client to listen to events.

🔧 Debug

advanced

Why does this NestJS subscription never send events to clients?

Examine this subscription resolver code. Why do clients never receive events?

NestJS

import { Resolver, Subscription, Mutation, Args } from '@nestjs/graphql';
import { PubSub } from 'graphql-subscriptions';

const pubSub = new PubSub();

@Resolver()
export class DebugResolver {
  @Subscription(() => String)
  messageSent() {
    return pubSub.asyncIterator('messageSent');
  }

  @Mutation(() => Boolean)
  sendMessage(@Args('msg') msg: string) {
    pubSub.publish('messageSent', { messageSent: msg });
    return true;
  }
}

A The PubSub instance is not imported correctly, causing silent failures.

B The mutation does not await pubSub.publish, causing race conditions.

C The subscription resolver is missing the @Args decorator for the subscription argument.

D The subscription returns asyncIterator for 'messageSent' but publishes with a payload key 'message' instead of 'messageSent'.

💡 Hint

Check the event name and payload keys used in publish and asyncIterator.

The asyncIterator listens for events named 'messageSent'. The publish call sends a payload with key 'messageSent', matching the subscription field name. This ensures data is sent correctly.

📝 Syntax

advanced

Which option correctly defines a NestJS subscription with a filter?

Choose the correct syntax for a NestJS GraphQL subscription resolver that filters events by a variable userId.

A

@Subscription(() => String, { filter: (payload, variables) => variables.userId === payload.userId })
userMessages(userId: string) {
  return pubSub.asyncIterator('userMessages');
}

B

@Subscription(() => String, { filter: (payload) => payload.userId === userId })
userMessages(@Args('userId') userId: string) {
  return pubSub.asyncIterator('userMessages');
}

C

@Subscription(() => String, { filter: (payload, variables) => payload.userId === variables.userId })
userMessages(@Args('userId') userId: string) {
  return pubSub.asyncIterator('userMessages');
}

D

@Subscription(() => String, { filter: (payload, variables) => payload.userId == variables.userId })
userMessages(@Args('userId') userId: string) {
  return pubSub.asyncIterator('userMessages');
}

💡 Hint

Remember the filter function receives payload and variables as arguments.

Option C correctly uses the filter function with both payload and variables, and the resolver method correctly uses @Args to get the subscription argument.

Option C misses variables in filter.

Option C misses @Args decorator.

Option C uses loose equality == which is discouraged.

❓ state_output

expert

What is the output sequence for this NestJS subscription with multiple publishes?

Given this NestJS subscription and mutation, what sequence of messages will a subscribed client receive after calling sendMessages?

NestJS

import { Resolver, Subscription, Mutation } from '@nestjs/graphql';
import { PubSub } from 'graphql-subscriptions';

const pubSub = new PubSub();

@Resolver()
export class SequenceResolver {
  @Subscription(() => String)
  messageStream() {
    return pubSub.asyncIterator('messageStream');
  }

  @Mutation(() => Boolean)
  async sendMessages() {
    await pubSub.publish('messageStream', { messageStream: 'First' });
    await pubSub.publish('messageStream', { messageStream: 'Second' });
    await pubSub.publish('messageStream', { messageStream: 'Third' });
    return true;
  }
}

A The client receives messages in order: 'First', 'Second', 'Third'.

B The client receives messages in reverse order: 'Third', 'Second', 'First'.

C The client receives only the last message: 'Third'.

D The client receives no messages because multiple publishes are not supported.

💡 Hint

Consider how PubSub handles multiple publishes and async iterators.

PubSub emits each published event in order to all subscribed clients. The async iterator streams all events as they come, so the client receives all three messages in the order published.