CacheModule setup in NestJS - Step-by-Step Execution

Concept Flow - CacheModule setup

Import CacheModule

↓

Configure CacheModule with options

↓

Register CacheModule in AppModule imports

↓

Inject CACHE_MANAGER in components

↓

Use cache methods: get, set, del

↓

Cache stores data and serves cached responses

This flow shows how to import, configure, register, and use CacheModule in a NestJS app.

Execution Sample

NestJS

import { CacheModule, Module } from '@nestjs/common';

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

This code imports and registers CacheModule with a 5-second cache time-to-live.

Execution Table

Step	Action	Input/Config	Result/State Change	Notes
1	Import CacheModule	from '@nestjs/common'	CacheModule available for use	Module ready to be configured
2	Call CacheModule.register	{ ttl: 5 }	CacheModule configured with 5s TTL	Cache will expire entries after 5 seconds
3	Add CacheModule to AppModule imports	imports: [CacheModule.register({ ttl: 5 })]	CacheModule registered in app	Cache manager injectable in app
4	Inject CACHE_MANAGER in component	constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache)	CacheManager instance available	Can call cache methods
5	Use cacheManager.set('key', 'value')	'key', 'value'	Value stored in cache	Stored with 5s TTL
6	Use cacheManager.get('key')	'key'	'value' if within TTL else null	Returns cached value or null if expired
7	Wait >5 seconds	TTL expires	Cached value removed	Cache entry expired
8	Use cacheManager.get('key')	'key'	null	Cache miss after expiration
9	Exit	N/A	CacheModule lifecycle ends with app	Cache cleans up on app shutdown

💡 Cache entries expire after TTL; CacheModule lifecycle tied to app lifecycle

Variable Tracker

Variable	Start	After Step 5	After Step 7	Final
cache entry for 'key'	undefined	'value'	expired (removed)	undefined

Key Moments - 3 Insights

Why does cacheManager.get('key') return null after some time?

Because the cache entry expires after the TTL (5 seconds here), as shown in execution_table step 7 and 8.

How do we make CacheModule available in the app?

By importing CacheModule.register() with options inside the AppModule imports array, as shown in step 3.

Can we use CacheManager without registering CacheModule?

No, CacheManager is provided by CacheModule, so it must be registered first (step 3).

Visual Quiz - 3 Questions

Look at the execution table, what is the cache entry value after step 5?

A undefined

B null

C 'value'

D expired

💡 Hint

Check the 'Result/State Change' column at step 5 in the execution_table.

At which step does the cache entry expire and get removed?

A Step 6

B Step 7

C Step 8

D Step 9

💡 Hint

Look for the step mentioning TTL expiration in the execution_table.

If we change TTL to 10 seconds, how does the variable tracker change?

A Cache entry remains valid longer, after step 7 it still holds 'value'

B Cache entry expires after step 7 as before

C Cache entry never expires

D Cache entry is removed immediately

💡 Hint

TTL controls cache expiration time shown in variable_tracker and execution_table steps 5-8.

Concept Snapshot

CacheModule setup in NestJS:
- Import CacheModule from '@nestjs/common'
- Register with options: CacheModule.register({ ttl: seconds })
- Add to AppModule imports array
- Inject CACHE_MANAGER to use cache methods
- Cache entries expire after TTL automatically

Full Transcript

This visual execution trace shows how to set up CacheModule in a NestJS application. First, CacheModule is imported from '@nestjs/common'. Then, it is configured by calling CacheModule.register with options like ttl (time to live). This configured module is added to the imports array of the AppModule, making the cache manager available throughout the app. Components can inject CACHE_MANAGER to store and retrieve cached data using methods like set and get. Cached entries automatically expire after the TTL duration, demonstrated by the cache entry for 'key' being valid after step 5, then expiring after step 7. This lifecycle ensures efficient caching with automatic cleanup.

Practice

1. What is the main purpose of importing CacheModule in a NestJS application?

easy

A. To enable temporary storage of data to speed up responses

B. To connect to a database automatically

C. To handle user authentication

D. To manage application logging

Solution

1. Step 1: Understand CacheModule's role

   CacheModule is used to store data temporarily to reduce repeated processing.

2. Step 2: Compare with other options

   It does not handle database, authentication, or logging directly.

3. Final Answer:

   To enable temporary storage of data to speed up responses -> Option A

4. Quick Check:

   CacheModule = temporary data storage [OK]

Hint: CacheModule is about caching data, not databases or auth [OK]

Common Mistakes:

• Confusing CacheModule with database modules
• Thinking CacheModule manages authentication
• Assuming CacheModule handles logging

2. Which of the following is the correct way to import and register CacheModule with a TTL of 5 seconds in a NestJS module?

easy

A. CacheModule.register({ ttl: 5 })

B. CacheModule.forRoot({ ttl: 5 })

C. CacheModule.setup({ ttl: 5 })

D. CacheModule.init({ ttl: 5 })

Solution

1. Step 1: Recall CacheModule registration method

   CacheModule uses the static method register to configure options like ttl.

2. Step 2: Verify method names

   Methods like forRoot, setup, or init are not used by CacheModule.

3. Final Answer:

   CacheModule.register({ ttl: 5 }) -> Option A

4. Quick Check:

   Use register() to configure CacheModule [OK]

Hint: CacheModule uses register(), not forRoot() or init() [OK]

Common Mistakes:

• Using forRoot() instead of register()
• Using setup() or init() which do not exist
• Forgetting to pass options inside register()

3. Given this NestJS module setup:

import { CacheModule, Module } from '@nestjs/common';

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

What will be the effect of the ttl: 10 option?

medium

A. Cache entries expire after 10 minutes

B. Cache entries expire after 10 seconds

C. Cache entries never expire

D. Cache entries expire immediately

Solution

1. Step 1: Understand ttl meaning in CacheModule

   The ttl option sets the time-to-live in seconds for cached data.

2. Step 2: Interpret ttl: 10

   Since ttl is 10, cached data expires after 10 seconds.

3. Final Answer:

   Cache entries expire after 10 seconds -> Option B

4. Quick Check:

   ttl = seconds cache lives [OK]

Hint: ttl value is in seconds, not minutes [OK]

Common Mistakes:

• Assuming ttl is in minutes
• Thinking ttl disables expiration
• Confusing ttl with cache size

4. Identify the error in this CacheModule setup:

import { CacheModule, Module } from '@nestjs/common';

@Module({
  imports: [CacheModule.register({ ttl: '20' })],
})
export class AppModule {}

medium

A. register() method does not accept options

B. CacheModule cannot be imported from '@nestjs/common'

C. ttl should be a number, not a string

D. Module decorator is missing parentheses

Solution

1. Step 1: Check ttl option type

   ttl expects a number representing seconds, not a string.

2. Step 2: Verify other parts

   CacheModule import and Module decorator usage are correct; register() accepts options.

3. Final Answer:

   ttl should be a number, not a string -> Option C

4. Quick Check:

   ttl must be numeric [OK]

Hint: ttl must be a number, not quoted text [OK]

Common Mistakes:

• Passing ttl as a string instead of number
• Thinking register() has no parameters
• Misusing import paths

5. You want to cache HTTP GET responses in a NestJS controller using CacheModule with a global TTL of 15 seconds. Which setup correctly applies caching to all routes in the module?

hard

A. Import CacheModule with ttl 15 and manually store cache in each method

B. Import CacheModule with ttl 15 and add @Cacheable() decorator on each method

C. Import CacheModule with ttl 15 and add @Cache() decorator on the module

D. Import CacheModule with ttl 15 and add @UseInterceptors(CacheInterceptor) on the controller

Solution

1. Step 1: Understand CacheModule and CacheInterceptor usage

   CacheModule provides caching, and CacheInterceptor applies caching behavior to routes.

2. Step 2: Apply CacheInterceptor globally on controller

   Using @UseInterceptors(CacheInterceptor) on the controller enables caching for all its routes.

3. Step 3: Evaluate other options

   No @Cacheable() or @Cache() decorators exist in NestJS core; manual caching is possible but not automatic.

4. Final Answer:

   Import CacheModule with ttl 15 and add @UseInterceptors(CacheInterceptor) on the controller -> Option D

5. Quick Check:

   Use CacheInterceptor with CacheModule for route caching [OK]

Hint: Use CacheInterceptor decorator to enable caching on controllers [OK]

Common Mistakes:

• Using non-existent decorators like @Cacheable or @Cache
• Not applying CacheInterceptor to controller or routes
• Trying manual caching instead of interceptor