Cache decorators in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when using @Cacheable with a method returning a random number?

Consider a NestJS service method decorated with @Cacheable() that returns a random number. What will happen when you call this method twice in a row?

NestJS

import { Cacheable } from '@nestjs/cache-manager';

class RandomService {
  @Cacheable()
  getRandom() {
    return Math.random();
  }
}

const service = new RandomService();
const first = service.getRandom();
const second = service.getRandom();
console.log(first === second);

A true - The second call returns the cached value from the first call

B false - Each call generates a new random number

C Throws a runtime error because caching is not configured

D undefined - The method does not return anything

💡 Hint

Think about what caching does to method results.

The @Cacheable() decorator caches the result of the method. So the first call stores the random number, and the second call returns the cached value, making both equal.

❓ lifecycle

intermediate

When is the cache cleared if you use @CacheEvict on a method?

In NestJS, if a method is decorated with @CacheEvict(), when does the cache get cleared?

NestJS

import { CacheEvict } from '@nestjs/cache-manager';

class UserService {
  @CacheEvict()
  updateUser(id: string, data: any) {
    // update user logic
    return true;
  }
}

A After the method successfully completes

B Only if the method throws an error

C Cache is never cleared automatically

D Before the method runs

💡 Hint

Think about when you want to remove stale data after an update.

The @CacheEvict() decorator clears the cache after the method finishes successfully to ensure stale data is removed.

📝 Syntax

advanced

Which option correctly uses @CacheKey and @CacheTTL decorators together?

Choose the correct way to set a custom cache key and TTL (time to live) for a method in NestJS.

NestJS

import { CacheKey, CacheTTL, Cacheable } from '@nestjs/cache-manager';

class ProductService {
  @Cacheable()
  @CacheKey('custom_key')
  @CacheTTL(120)
  getProduct(id: string) {
    return { id, name: 'Product' };
  }
}

A

@CacheTTL(120)
@CacheKey('custom_key')
@Cacheable()
getProduct(id: string) { return { id, name: 'Product' }; }

B

@CacheKey('custom_key')
@CacheTTL(120)
@Cacheable()
getProduct(id: string) { return { id, name: 'Product' }; }

C

@CacheTTL(120)
@Cacheable()
@CacheKey('custom_key')
getProduct(id: string) { return { id, name: 'Product' }; }

D

@Cacheable()
@CacheKey('custom_key')
@CacheTTL(120)
getProduct(id: string) { return { id, name: 'Product' }; }

💡 Hint

Remember the order decorators are applied matters in NestJS.

Decorators are applied bottom-up. @Cacheable() must be the last decorator so it wraps the others properly.

🔧 Debug

advanced

What error occurs if you use @Cacheable on a method returning a Promise but forget to await it?

Given a method decorated with @Cacheable() that returns a Promise, what happens if you call it without await and try to cache the result?

NestJS

import { Cacheable } from '@nestjs/cache-manager';

class AsyncService {
  @Cacheable()
  async fetchData() {
    return 'data';
  }
}

const service = new AsyncService();
const result = service.fetchData();
console.log(typeof result);

A 'string' - The cache automatically unwraps the Promise

B Throws a TypeError because caching expects a string

C 'object' - The cached value is a Promise object, not the resolved data

D undefined - The method returns nothing

💡 Hint

Think about what happens when you don't await an async function.

Without await, the method returns a Promise object. The cache stores this Promise, not the resolved value, so the type is 'object'.

🧠 Conceptual

expert

Which statement about NestJS cache decorators is TRUE?

Choose the true statement about how NestJS cache decorators work.

A @Cacheable caches method results and automatically invalidates cache on data changes

B @CacheEvict can be used to clear cache entries manually after specific method calls

C @CacheKey sets the cache expiration time in seconds for the method

D @CacheTTL defines a custom cache key string for the cached method

💡 Hint

Recall the purpose of each decorator.

@CacheEvict is used to clear cache entries manually. @CacheKey sets the cache key, and @CacheTTL sets the expiration time. @Cacheable caches results but does not auto-invalidate on data changes.