NestJS + Apollo联邦微服务架构下GraphQL缓存实现方案咨询

Hey there! I’ve tackled similar caching hurdles in federated GraphQL + NestJS setups before, so let me break down a practical solution that meets your exact needs. The core idea is to generate a unique cache key that captures every factor that could change your query result—query content, variables, and relevant request headers—then use NestJS's caching module alongside a custom GraphQL interceptor to handle the cache logic.

We'll build a system that:

• Generates a unique key based on query text, variables, and critical request headers
• Checks for cached data using this key before running the query
• Caches fresh results when no cached data exists
• Handles cache invalidation for mutation operations

1. Set Up NestJS Cache Module #

First, install the required packages (we'll use Redis for distributed caching, perfect for microservices):

npm install @nestjs/cache-manager cache-manager-redis-store

Then register the cache module globally in your root AppModule:

import { Module } from '@nestjs/common';
import { CacheModule } from '@nestjs/cache-manager';
import { redisStore } from 'cache-manager-redis-store';

@Module({
  imports: [
    CacheModule.registerAsync({
      useFactory: async () => ({
        store: await redisStore({
          url: 'redis://your-redis-host:6379', // Update with your Redis config
        }),
        ttl: 300, // Default cache TTL in seconds (adjust based on your data)
      }),
      isGlobal: true, // Make the cache available across all modules
    }),
  ],
})
export class AppModule {}

2. Build a Custom GraphQL Cache Interceptor #

This interceptor will handle extracting cache-relevant data, generating the key, and managing cache checks/updates:

import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
import { Observable, of } from 'rxjs';
import { tap } from 'rxjs/operators';
import { Cache } from 'cache-manager';
import { InjectCache } from '@nestjs/cache-manager';
import { GqlExecutionContext } from '@nestjs/graphql';

@Injectable()
export class GraphQLCacheInterceptor implements NestInterceptor {
  constructor(@InjectCache() private readonly cacheManager: Cache) {}

  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
    const gqlCtx = GqlExecutionContext.create(context);
    const request = gqlCtx.getContext().req;

    // Extract all factors that affect the query result
    const queryText = gqlCtx.getInfo().operation.text;
    const variables = JSON.stringify(gqlCtx.getArgs().variables || {});
    // Add only headers that impact your data (e.g., user ID, locale, auth tokens)
    const relevantHeaders = JSON.stringify({
      userId: request.headers['x-user-id'],
      locale: request.headers['accept-language'],
    });

    // Generate a unique, URL-safe cache key
    const cacheKey = `graphql:${Buffer.from(`${queryText}:${variables}:${relevantHeaders}`).toString('base64')}`;

    // Check cache first
    return this.cacheManager.get(cacheKey).then((cachedData) => {
      if (cachedData) {
        return of(cachedData); // Return cached data immediately
      }
      // Run the query and cache the result if no cache exists
      return next.handle().pipe(
        tap((freshData) => {
          this.cacheManager.set(cacheKey, freshData);
        }),
      );
    });
  }
}

3. Apply the Interceptor #

You can apply this interceptor globally (for all resolvers) or to specific resolvers:

Global Application #

Add the interceptor to your root module's providers to enable caching across all GraphQL resolvers:

import { Module } from '@nestjs/common';
import { GraphQLModule } from '@nestjs/graphql';
import { ApolloFederationDriver, ApolloFederationDriverConfig } from '@nestjs/apollo';
import { GraphQLCacheInterceptor } from './graphql-cache.interceptor';
import { APP_INTERCEPTOR } from '@nestjs/core';

@Module({
  imports: [
    GraphQLModule.forRoot<ApolloFederationDriverConfig>({
      driver: ApolloFederationDriver,
      autoSchemaFile: true,
    }),
  ],
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: GraphQLCacheInterceptor,
    },
  ],
})
export class AppModule {}

Per-Resolver Application #

Use the @UseInterceptors decorator on specific resolvers if you only want to cache certain queries:

import { Resolver, Query, UseInterceptors } from '@nestjs/graphql';
import { GraphQLCacheInterceptor } from './graphql-cache.interceptor';
import { User } from './user.entity';
import { UserService } from './user.service';

@Resolver(() => User)
export class UserResolver {
  constructor(private readonly userService: UserService) {}

  @Query(() => User)
  @UseInterceptors(GraphQLCacheInterceptor)
  async getUser(@Args('id') id: string) {
    return this.userService.getUserById(id);
  }
}

4. Handle Cache Invalidation (Critical for Mutations) #

When you run mutations (e.g., updating user data), you need to invalidate related cache entries to avoid serving stale data. Create a helper service to handle this:

import { Injectable } from '@nestjs/common';
import { Cache } from 'cache-manager';
import { InjectCache } from '@nestjs/cache-manager';

@Injectable()
export class CacheInvalidationService {
  constructor(@InjectCache() private readonly cacheManager: Cache) {}

  async invalidateUserRelatedCache(userId: string) {
    // Use Redis key pattern matching to delete all cache entries tied to this user
    const matchingKeys = await this.cacheManager.store.keys(`graphql:*${userId}*`);
    await Promise.all(matchingKeys.map((key) => this.cacheManager.del(key)));
  }
}

Then call this service in your mutation resolvers:

import { Mutation, Args, Context } from '@nestjs/graphql';
import { UserResolver } from './user.resolver';
import { UpdateUserInput } from './dto/update-user.input';
import { CacheInvalidationService } from './cache-invalidation.service';

@Mutation(() => User)
async updateUser(
  @Args('input') input: UpdateUserInput,
  @Context() context,
) {
  const updatedUser = await this.userService.updateUser(input);
  // Invalidate cache for the updated user
  await this.cacheInvalidationService.invalidateUserRelatedCache(context.req.headers['x-user-id']);
  return updatedUser;
}

• Distributed Cache: Always use a distributed cache like Redis (not in-memory cache) for federated microservices—memory cache won't share data across service instances.
• Cache Key Precision: Only include headers/variables that actually affect the query result. Including unnecessary data will bloat your cache keys and reduce hit rates.
• TTL Tuning: Adjust the TTL based on how often your data changes. For frequently updated data, use shorter TTLs; for static data, use longer ones.
• Error Handling: Consider adding error handling in the interceptor (e.g., fall back to running the query if cache access fails).

内容的提问来源于stack exchange，提问作者Kelly