I’m developing an e-commerce application using NestJS and Prisma with PostgreSQL and have a requirement to cache category data globally to improve performance, retrieving the data immediately. I want to use Redis for caching, and I’m considering implementing a scheduled job to refresh the cache daily in a certain period like midnight or something.

Well, Is this considered a best practice for implementing global cache for category data? Are there any improvements or alternative approaches I should consider to make this implementation more efficient and maintainable sticking with the real world scenarios adopted by top e-commerce sites.

Additionally, I am concerned that if User 1 sets the category cache, User 2 and other users will be affected by this cache. To address this, I have implemented a centralized cache updater (scheduler) that automatically caches the category data daily. This way, the cached category data can be served globally for everyone. Is this approach recommended, or are there better strategies for handling global cache in an e-commerce application?

category.service.ts

  async getCategories(): Promise<Category[]> {
    const cachedCategories = await this.redisService.get(this.cacheKey);

    if (cachedCategories) {
      return JSON.parse(cachedCategories);
    }

    try {
      const categories = await this.databaseService.category.findMany({
        include: {
          subCategories: true,
        },
      });

      return categories; /* just returned from DB if category data doesnt exist on cache. 
 Didn't set the cache here since this will be handled by scheduler, otherwise, everyone else would have been affected by any changes made on caching by any random client.
 So, i just wanted to keep it global for everyone, meaning everyone who wants to view category data will be affected in same manner, getting up-to-date cached data which is set by scheduler at midnight*/
    } catch (error) {
      throw new InternalServerErrorException(error.message);
    }
  }


//The following method will be used in only scheduler
  async refreshCategoriesCache(): Promise<void> {
    try {
      const categories = await this.databaseService.category.findMany({
        include: {
          subCategories: true,
        },
      });

      await this.redisService.set(this.cacheKey, JSON.stringify(categories), this.cacheTtl);
    } catch (error) {
      throw new InternalServerErrorException(error.message);
    }
  }
}

scheduler.service.ts

import { Injectable } from '@nestjs/common';
import { Cron } from '@nestjs/schedule';
import { CategoryService } from './category.service';

@Injectable()
export class SchedulerService {
  constructor(private readonly categoryService: CategoryService) {}

  @Cron('0 0 * * *') // Runs every day at midnight
  async handleCron() {
    await this.categoryService.refreshCategoriesCache();
  }
}