Class CacheManager<T>

constructor

• new CacheManager<T extends {}>(
      cacheOptions?: ResolvedCreateCacheOptions<T>,
  ): CacheManager<T>

  Type Parameters

  • T extends {}

  Parameters

  • OptionalcacheOptions: ResolvedCreateCacheOptions<T>

  Returns CacheManager<T>

ReadonlycacheOptions

Readonlymetadata

clear

• clear(): Promise<boolean>

  Returns Promise<boolean>

clearByPrefix

• clearByPrefix(prefix: string): Promise<[boolean, boolean[]]>

  Clear all keys that match a prefix

  Parameters

  • prefix: string

    The prefix to filter keys by

  Returns Promise<[boolean, boolean[]]>

  Whether the cache was cleared, and an array of booleans for each key

del

• del(key: string): Promise<boolean>

  Parameters

  • key: string

  Returns Promise<boolean>

disconnect

• disconnect(): Promise<undefined>

  Returns Promise<undefined>

extend

• extend(options?: ResolvedCreateCacheOptions<T>): CacheManager<T>

  Extend the current cache manager with new options, stores, etc.

  Parameters

  • Optionaloptions: ResolvedCreateCacheOptions<T>

    The options to extend the cache manager with

  Returns CacheManager<T>

  A new cache manager

get

• get(key: string): Promise<undefined | null | T>

  Parameters

  • key: string

  Returns Promise<undefined | null | T>

hasKey

• hasKey(key: string): boolean

  Parameters

  • key: string

    The key to check for

  Returns boolean

  Whether the key exists in the cache

isData

• isData(item: undefined | null | T, allowNull: false): item is T

  Check if the item is data (not null or undefined)

  Parameters

  • item: undefined | null | T

    The item to check
  • allowNull: false

    Whether to allow null values

  Returns item is T

  Whether the item is valid (cache) data

keys

• keys(): string[]

  Returns string[]

  An array of all keys stored in the cache

keysByPrefix

• keysByPrefix(prefix: string): string[]

  Get all (cached) keys that match a prefix

  Parameters

  • prefix: string

    The prefix to filter keys by

  Returns string[]

  An array of keys that match the prefix

mdel

• mdel(keys: string[]): Promise<[boolean, boolean[]]>

  Parameters

  • keys: string[]

  Returns Promise<[boolean, boolean[]]>

mget

• mget(keys: string[]): Promise<(undefined | null | T)[]>

  Parameters

  • keys: string[]

  Returns Promise<(undefined | null | T)[]>

mset

• mset(
      list: SetCacheArguments<null | T>[],
  ): Promise<SetCacheArguments<null | T>[]>

  Parameters

  • list: SetCacheArguments<null | T>[]

  Returns Promise<SetCacheArguments<null | T>[]>

off

• off<E extends keyof Events>(event: E, listener: Events[E]): EventEmitter

  Type Parameters

  • E extends keyof Events

  Parameters

  • event: E
  • listener: Events[E]

  Returns EventEmitter

on

• on<E extends keyof Events>(event: E, listener: Events[E]): EventEmitter

  Type Parameters

  • E extends keyof Events

  Parameters

  • event: E
  • listener: Events[E]

  Returns EventEmitter

set

• set(key: string, value: null | T, ttl?: number): Promise<null | T>

  Parameters

  • key: string
  • value: null | T
  • Optionalttl: number

  Returns Promise<null | T>

ttl

• ttl(key: string): Promise<null | number>

  Parameters

  • key: string

  Returns Promise<null | number>

wrap

• wrap(
      key: string,
      fnc: () => T | Promise<T>,
      ttl?: number | (value: T) => number,
      refreshThreshold?: number,
  ): Promise<T>

  Parameters

  • key: string
  • fnc: () => T | Promise<T>
  • Optionalttl: number | (value: T) => number
  • OptionalrefreshThreshold: number

  Returns Promise<T>

StaticfromStore

• fromStore<O extends {}>(
      store: Keyv<O> | LRUCache<O> | LRUArgs<O>,
  ): CacheManager<O>

  Create a new cache manager from a store (Keyv or LRUCache)

  Type Parameters

  • O extends {}

  Parameters

  • store: Keyv<O> | LRUCache<O> | LRUArgs<O>

    The store to create the cache manager from

  Returns CacheManager<O>

  A new cache manager

StatichashAny

• hashAny(value: {}): string

  Hash any data type into a string, for use as a cache key

  Parameters

  • value: {}

    The value to hash

  Returns string

  The hashed value as a string