transitory/dist/types/cache/expiration/ExpirationCache.d.ts

In-memory cache with high hit rates via LFU eviction. Supports time-based expiration, automatic loading and metrics.

import { AbstractCache } from '../AbstractCache';
import { Cache } from '../Cache';
import { CacheSPI } from '../CacheSPI';
import { CommonCacheOptions } from '../CommonCacheOptions';
import { KeyType } from '../KeyType';
import { Metrics } from '../metrics/Metrics';
import { RemovalListener } from '../RemovalListener';
import { PARENT, ON_REMOVE, TRIGGER_REMOVE, ON_MAINTENANCE, MAINTENANCE } from '../symbols';
import { Expirable } from './Expirable';
import { MaxAgeDecider } from './MaxAgeDecider';
declare const DATA: unique symbol;
/**
 * Options available for a loading cache.
 */
export interface ExpirationCacheOptions<K extends KeyType, V> extends CommonCacheOptions<K, V> {
    maxWriteAge?: MaxAgeDecider<K, V>;
    maxNoReadAge?: MaxAgeDecider<K, V>;
    parent: Cache<K, Expirable<V>>;
}
/**
 * Wrapper for another cache that provides evictions of times based on timers.
 *
 * Currently supports expiration based on maximum age.
 */
export declare class ExpirationCache<K extends KeyType, V> extends AbstractCache<K, V> implements CacheSPI<K, V> {
    private [DATA];
    private [PARENT];
    [ON_REMOVE]?: RemovalListener<K, V>;
    [ON_MAINTENANCE]?: () => void;
    constructor(options: ExpirationCacheOptions<K, V>);
    /**
     * The maximum size the cache can be. Will be -1 if the cache is unbounded.
     *
     * @returns
     *   maximum size
     */
    get maxSize(): number;
    /**
     * The current size of the cache.
     *
     * @returns
     *   current size
     */
    get size(): number;
    /**
     * The size of the cache weighted via the activate estimator.
     *
     * @returns
     *   weighted size
     */
    get weightedSize(): number;
    /**
     * Store a value tied to the specified key. Returns the previous value or
     * `null` if no value currently exists for the given key.
     *
     * @param key -
     *   key to store value under
     * @param value -
     *   value to store
     * @returns
     *   current value or `null`
     */
    set(key: K, value: V): V | null;
    /**
     * Get the cached value for the specified key if it exists. Will return
     * the value or `null` if no cached value exist. Updates the usage of the
     * key.
     *
     * @param key -
     *   key to get
     * @returns
     *   current value or `null`
     */
    getIfPresent(key: K): V | null;
    /**
     * Peek to see if a key is present without updating the usage of the
     * key. Returns the value associated with the key or `null`  if the key
     * is not present.
     *
     * In many cases `has(key)` is a better option to see if a key is present.
     *
     * @param key -
     *   the key to check
     * @returns
     *   value associated with key or `null`
     */
    peek(key: K): V | null;
    /**
     * Check if the given key exists in the cache.
     *
     * @param key -
     *   key to check
     * @returns
     *   `true` if value currently exists, `false` otherwise
     */
    has(key: K): boolean;
    /**
     * Delete a value in the cache. Returns the deleted value or `null` if
     * there was no value associated with the key in the cache.
     *
     * @param key -
     *   the key to delete
     * @returns
     *   deleted value or `null`
     */
    delete(key: K): V | null;
    /**
     * Clear the cache removing all of the entries cached.
     */
    clear(): void;
    /**
     * Get all of the keys in the cache as an array. Can be used to iterate
     * over all of the values in the cache, but be sure to protect against
     * values being removed during iteration due to time-based expiration if
     * used.
     *
     * @returns
     *   snapshot of keys
     */
    keys(): K[];
    /**
     * Request clean up of the cache by removing expired entries and
     * old data. Clean up is done automatically a short time after sets and
     * deletes, but if your cache uses time-based expiration and has very
     * sporadic updates it might be a good idea to call `cleanUp()` at times.
     *
     * A good starting point would be to call `cleanUp()` in a `setInterval`
     * with a delay of at least a few minutes.
     */
    cleanUp(): void;
    /**
     * Get metrics for this cache. Returns an object with the keys `hits`,
     * `misses` and `hitRate`. For caches that do not have metrics enabled
     * trying to access metrics will throw an error.
     *
     * @returns
     *   metrics if available via the parent cache
     */
    get metrics(): Metrics;
    private [MAINTENANCE];
    private [TRIGGER_REMOVE];
}
export {};