Cache

import { RedisCachePlugin, VendureConfig } from '@vendure/core';export const config: VendureConfig = {    // ...    plugins: [        RedisCachePlugin.init({            redisOptions: {                host: 'localhost',                port: 6379,            },        }),    ],};

import { Injectable } from '@nestjs/common';import { CacheService } from '@vendure/core';@Injectable()export class MyService {    constructor(private cacheService: CacheService) {}    async myMethod() {        const cacheKey = 'MyService.myMethod';        const cachedValue = await this.cacheService.get(cacheKey);        if (cachedValue) {            return cachedValue;        }        const newValue = await this.expensiveOperation();        // Cache the result for 1 minute (60 * 1000 milliseconds)        await this.cacheService.set(cacheKey, newValue, { ttl: 60 * 1000 });        return newValue;    }    private async expensiveOperation() {        // Do something expensive    }}

getVariantIds(productId: ID): Promise<ID[]> {    const cacheKey = `ProductService.getVariantIds:${productId}`;    const cachedValue = await this.cacheService.get(cacheKey);    if (cachedValue) {        return cachedValue;    }    const newValue = await this.expensiveOperation(productId);    await this.cacheService.set(cacheKey, newValue, { ttl: 60 * 1000 });    return newValue;}

await this.cacheService.delete(cacheKey);

const cacheKey = `ProductService.getVariantIds:${productId}`;await this.cacheService.set(cacheKey, newValue, {    tags: [`Product:${productId}`]});// laterawait this.cacheService.invalidateTags([`Product:${productId}`]);

import { Injectable } from '@nestjs/common';import { CacheService, ID, EventBus, ProductEvent,RequestContext } from '@vendure/core';@Injectable()export class FacetValueChecker {    // Create a Cache instance with a 1-day TTL    private facetValueCache = this.cacheService.createCache({        getKey: (productId: ID) => `FacetValueChecker.${productId}`,        options: { ttl: 1000 * 60 * 60 * 24 },    });    constructor(private cacheService: CacheService, private eventBus: EventBus) {        this.eventBus.ofType(ProductEvent).subscribe(event => {            if (event.type !== 'created') {                // Invalidate the cache entry when a Product is updated or deleted                this.facetValueCache.delete(event.entity.id);            }        });    }    async getFacetValueIdsForProduct(ctx: RequestContext, productId: ID): Promise<ID[]> {        return this.facetValueCache.get(productId, () =>            // This function will only be called if the cache entry does not exist            // or has expired. It will set the result in the cache automatically.            this.calculateFacetValueIdsForProduct(ctx, productId));    }    async calculateFacetValueIdsForProduct(ctx: RequestContext, productId: ID): Promise<ID[]> {        // Do something expensive    }}

const activeTaxZone = await this.requestContextCache.get(    ctx,    'activeTaxZone',    () => taxZoneStrategy        .determineTaxZone(ctx, zones, ctx.channel, order),);

import {  Channel,  createSelfRefreshingCache,  EventBus,  InitializerEvent,  InternalServerError,  Logger,  RequestContext  SelfRefreshingCache,  TransactionalConnection,} from '@vendure/core';@Injectable()export class PublicChannelService {  private publicChannel: SelfRefreshingCache<Channel, [RequestContext]>; // [!code highlight]  private readonly logCtx = 'PublicChannelService';  constructor(    private connection: TransactionalConnection,    private eventBus: EventBus,  ) {    this.eventBus.ofType(InitializerEvent).subscribe(async () => {      this.publicChannel = await createSelfRefreshingCache({ // [!code highlight]        name: 'PublicChannelService.publicChannel', // [!code highlight]        ttl: 1000 * 60 * 5, // 5min // [!code highlight]        refresh: { fn: ctx => this.findPublicChannel(ctx), defaultArgs: [RequestContext.empty()] }, // [!code highlight]      }); // [!code highlight]    });  }  async getPublicChannel(): Promise<Channel> {    const publicChannel = await this.publicChannel.value(); // [!code highlight]    if (!publicChannel) {      throw new InternalServerError(`error.public-channel-not-found`);    }    return publicChannel;  }  private async findPublicChannel(ctx: RequestContext): Promise<Channel> {    const publicChannel = await this.connection.getRepository(ctx, Channel).findOne({      where: { code: DEFAULT_PUBLIC_CHANNEL_CODE },      relations: ['defaultShippingZone', 'defaultTaxZone'],    });    if (!publicChannel) {      Logger.error('Could not find public channel!', this.logCtx);      throw new InternalServerError(`error.public-channel-not-found`);    }    return publicChannel;  }}