Cache stores (memory, Redis) in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when using NestJS CacheModule with memory store?

Consider a NestJS service that caches a value in memory using CacheModule. What will be the output of the following code snippet when retrieving the cached value?

NestJS

import { Injectable, Inject, Module } from '@nestjs/common';
import { CacheModule, CACHE_MANAGER } from '@nestjs/cache-manager';
import type { Cache } from 'cache-manager';

@Injectable()
export class SampleService {
  constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}

  async cacheAndGet() {
    await this.cacheManager.set('key', 'hello');
    return await this.cacheManager.get('key');
  }
}

@Module({
  imports: [CacheModule.register()],
  providers: [SampleService],
})
export class AppModule {}

A "hello"

B undefined

C null

D Throws a runtime error

💡 Hint

Think about what CacheModule.register() uses by default for storage.

By default, NestJS CacheModule uses an in-memory store. Setting a key and then getting it immediately returns the stored value.

📝 Syntax

intermediate

Which option correctly configures Redis cache store in NestJS?

You want to configure NestJS CacheModule to use Redis as the cache store. Which of the following code snippets correctly sets up Redis as the cache store?

A CacheModule.register({ store: require('cache-manager-redis-store'), host: 'localhost', port: 6379 })

B CacheModule.register({ store: 'redis', host: 'localhost', port: 6379 })

C CacheModule.register({ redis: { host: 'localhost', port: 6379 } })

D CacheModule.register({ store: require('redis'), host: 'localhost', port: 6379 })

💡 Hint

The Redis store requires a specific package to be passed as the store option.

To use Redis with NestJS CacheModule, you must pass the Redis store package (like 'cache-manager-redis-store') as the store option. Other options are incorrect or incomplete.

❓ state_output

advanced

What happens to cached data when using memory store in a clustered NestJS app?

In a NestJS app running multiple instances (clustered), you use CacheModule with the default memory store. What will happen when you cache data in one instance and try to access it from another?

A Cached data is shared across all instances and accessible everywhere

B CacheModule automatically syncs memory cache between instances

C Each instance has its own cache; data is not shared between instances

D Accessing cached data from another instance throws an error

💡 Hint

Think about how memory works in separate processes.

Memory cache is local to each process. In a clustered environment, each instance has its own memory space, so caches are isolated.

🔧 Debug

advanced

Why does the Redis cache throw a connection error in this NestJS setup?

You configured CacheModule with Redis store but get a connection error at runtime. Which of the following is the most likely cause?

NestJS

CacheModule.register({ store: require('cache-manager-redis-store'), host: '127.0.0.1', port: 6380 })

A Host IP '127.0.0.1' is invalid for Redis connections

B The store option should be a string 'redis' not a require call

C CacheModule does not support Redis caching

D Redis server is not running on port 6380

💡 Hint

Check if Redis server is listening on the specified port.

If Redis is not running or listening on the configured port, connection errors occur. The host and store usage are correct.

🧠 Conceptual

expert

Why choose Redis over memory store for caching in NestJS in production?

Which of the following reasons best explains why Redis is preferred over the default memory store for caching in a production NestJS app?

A Memory store is faster and more scalable than Redis

B Redis supports distributed caching and persists data beyond app restarts

C Redis cache is built into NestJS by default, no extra setup needed

D Memory store automatically syncs cache between multiple app instances

💡 Hint

Think about app restarts and multiple server instances.

Redis is an external cache that supports sharing data across multiple app instances and persists data beyond restarts, unlike the in-memory store.