#CacheManager

#Resumen

CacheManager se basa en node-cache-manager y proporciona funcionalidades de gestión de módulos de caché para NocoBase. Los tipos de caché integrados son:

• memory - un lru-cache proporcionado por defecto por node-cache-manager
• redis - con soporte de node-cache-manager-redis-yet

Puede registrar y extender más tipos a través de la API.

#Conceptos clave

• Store: Define un método de almacenamiento en caché, que incluye un método de fábrica para crear cachés y otras configuraciones relacionadas. Cada método de caché tiene un identificador único que se proporciona durante el registro. Los identificadores únicos para los dos métodos de caché integrados son memory y redis.

• Método de fábrica de Store: Un método proporcionado por node-cache-manager y sus paquetes de extensión relacionados para crear cachés. Por ejemplo, 'memory' (proporcionado por defecto por node-cache-manager) y redisStore (proporcionado por node-cache-manager-redis-yet). Este método corresponde al primer parámetro del método caching de node-cache-manager.

• Cache: Una clase encapsulada por NocoBase que proporciona métodos para utilizar la caché. Al usar la caché, usted opera sobre una instancia de Cache. Cada instancia de Cache tiene un identificador único que puede utilizarse como espacio de nombres para distinguir diferentes módulos.

#Métodos de clase

#constructor()

#Firma

• constructor(options?: CacheManagerOptions)

#Tipos

export type CacheManagerOptions = Partial<{
  defaultStore: string;
  stores: {
    [storeType: string]: StoreOptions;
  };
}>;

type StoreOptions = {
  store?: 'memory' | FactoryStore<Store, any>;
  close?: (store: Store) => Promise<void>;
  // global config
  [key: string]: any;
};

#Detalles

#CacheManagerOptions

#StoreOptions

#options predeterminadas

import { redisStore, RedisStore } from 'cache-manager-redis-yet';

const defaultOptions: CacheManagerOptions = {
  defaultStore: 'memory',
  stores: {
    memory: {
      store: 'memory',
      // Configuración global
      max: 2000,
    },
    redis: {
      store: redisStore,
      close: async (redis: RedisStore) => {
        await redis.client.quit();
      },
    },
  },
};

El parámetro options se fusionará con las opciones predeterminadas. Las propiedades ya presentes en las opciones predeterminadas pueden omitirse. Por ejemplo:

const cacheManager = new CacheManager({
  stores: {
    defaultStore: 'redis',
    redis: {
      // redisStore ya está proporcionado en las opciones predeterminadas, solo necesita proporcionar la configuración de redisStore.
      url: 'redis://localhost:6379',
    },
  },
});

#registerStore()

Registra un nuevo método de almacenamiento en caché. Por ejemplo:

import { redisStore } from 'cache-manager-redis-yet';

cacheManager.registerStore({
  // Identificador único para el store
  name: 'redis',
  // Método de fábrica para crear el store
  store: redisStore,
  // Cierra la conexión del store
  close: async (redis: RedisStore) => {
    await redis.client.quit();
  },
  // Configuración global
  url: 'xxx',
});

#Firma

• registerStore(options: { name: string } & StoreOptions)

#createCache()

Crea una caché. Por ejemplo:

await cacheManager.createCache({
  name: 'default', // Identificador único para la caché
  store: 'memory', // Identificador único para el store
  prefix: 'mycache', // Opcional, añade automáticamente el prefijo 'mycache:' a las claves de caché
  // Otras configuraciones del store, las configuraciones personalizadas se fusionarán con la configuración global del store
  max: 2000,
});

#Firma

• createCache(options: { name: string; prefix?: string; store?: string; [key: string]: any }): Promise<Cache>

#Detalles

#options

Si se omite store, se utilizará defaultStore. En este caso, el método de almacenamiento en caché cambiará según el método de caché predeterminado del sistema.

Cuando no hay configuraciones personalizadas, se devuelve el espacio de caché predeterminado creado por la configuración global y compartido por el método de caché actual. Se recomienda añadir un prefix para evitar conflictos de claves.

// Utiliza la caché predeterminada con la configuración global
await cacheManager.createCache({ name: 'default', prefix: 'mycache' });

#Cache

Consulte Cache

#getCache()

Obtiene la caché correspondiente.

cacheManager.getCache('default');

#Firma

• getCache(name: string): Cache

#flushAll()

Reinicia todas las cachés.

await cacheManager.flushAll();

#close()

Cierra todas las conexiones de middleware de caché.

await cacheManager.close();