Custom cache keys in NestJS - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

How does a custom cache key affect caching in NestJS?

Consider a NestJS controller method using a custom cache key function. What will be the effect on caching behavior?

NestJS

import { Controller, Get } from '@nestjs/common';
import { CacheKey, CacheTTL } from '@nestjs/cache-manager';

@Controller('items')
export class ItemsController {
  @Get()
  @CacheKey('custom_key')
  @CacheTTL(30)
  findAll() {
    return ['item1', 'item2'];
  }
}

A The cache will always use 'custom_key' as the key for storing the response, ignoring request parameters.

B The cache key will be generated dynamically based on request parameters automatically.

C The cache will not store any response because custom keys disable caching.

D The cache key will be a combination of method name and parameters, ignoring the custom key.

💡 Hint

Think about what the @CacheKey decorator does in NestJS.

The @CacheKey decorator sets a fixed key for caching the method's response. This means the cache always uses the given string as the key, ignoring any request parameters.

📝 Syntax

intermediate

Identify the correct syntax to set a custom cache key in NestJS

Which of the following code snippets correctly sets a custom cache key for a controller method in NestJS?

A

@CacheKey('myKey')
@Get()
getData() { return 'data'; }

B

@CacheKey(myKey)
@Get()
getData() { return 'data'; }

C

@CacheKey({ key: 'myKey' })
@Get()
getData() { return 'data'; }

D

@CacheKey()
@Get()
getData() { return 'data'; }

💡 Hint

Remember how decorators accept string literals for keys.

The @CacheKey decorator requires a string argument to specify the cache key. Option A correctly passes a string literal.

🔧 Debug

advanced

Why does the custom cache key not work as expected?

Given this code, why does the cache not store separate responses for different user IDs?

NestJS

import { Controller, Get, Param } from '@nestjs/common';
import { CacheKey } from '@nestjs/cache-manager';

@Controller('users')
export class UsersController {
  @Get(':id')
  @CacheKey('user_data')
  getUser(@Param('id') id: string) {
    return { id, name: 'User ' + id };
  }
}

A Because @CacheKey does not work with route parameters.

B Because the method lacks @CacheTTL decorator to enable caching.

C Because the cache key is fixed to 'user_data', responses for all user IDs overwrite each other.

D Because the cache key should be a function returning a key string.

💡 Hint

Think about how cache keys identify cached data.

The fixed cache key 'user_data' causes all responses to be stored under the same key, so different user IDs overwrite each other in the cache.

🧠 Conceptual

advanced

How to create dynamic custom cache keys in NestJS?

Which approach correctly creates dynamic cache keys based on method parameters in NestJS?

A NestJS automatically generates dynamic cache keys without extra code.

B Use @CacheKey decorator with a template string including parameters directly.

C Use @CacheKey decorator multiple times with different keys for each parameter value.

D Use a custom interceptor that generates cache keys including method arguments dynamically.

💡 Hint

Think about how to customize cache keys beyond static strings.

The @CacheKey decorator only accepts static strings. To create dynamic keys based on parameters, you need a custom interceptor that builds keys at runtime.

❓ state_output

expert

What is the cache key used and output after calling the method twice with different params?

Given the following NestJS controller and custom interceptor, what cache keys are used and what is the output after two calls with different parameters?

NestJS

import { CacheInterceptor, ExecutionContext, Injectable, Controller, Get, Param, UseInterceptors } from '@nestjs/common';

@Injectable()
class CustomCacheInterceptor extends CacheInterceptor {
  trackBy(context: ExecutionContext): string | undefined {
    const request = context.switchToHttp().getRequest();
    const id = request.params.id;
    return `user_${id}`;
  }
}

@Controller('users')
@UseInterceptors(CustomCacheInterceptor)
export class UsersController {
  @Get(':id')
  getUser(@Param('id') id: string) {
    return { id, name: 'User ' + id };
  }
}

// Calls:
// 1) GET /users/1
// 2) GET /users/2

A Cache keys used: 'users_getUser'; outputs: same cached response for both calls

B Cache keys used: 'user_1' and 'user_2'; outputs: {id:'1', name:'User 1'} and {id:'2', name:'User 2'}

C Cache keys used: 'user_data'; outputs: first call cached, second call overwrites

D No cache keys used; outputs: fresh response each call

💡 Hint

Look at how the custom interceptor builds the cache key.

The custom interceptor uses the route parameter 'id' to build unique cache keys 'user_1' and 'user_2'. Each call caches and returns the correct user data separately.