Cache Manager API

Complete API reference for the caching utilities

Cache Manager API Reference

The Cache Manager provides a unified interface for various caching strategies and backends optimized for edge environments.

CacheManager

Main cache management class supporting multiple backends and strategies.

Constructor

new CacheManager(options)

Parameters:

• options (object): Cache configuration options

Options:

• backend (string): Cache backend (‘memory’, ‘redis’, ‘cloudflare-kv’)
• ttl (number): Default TTL in milliseconds
• maxSize (number): Maximum cache size
• strategy (string): Eviction strategy (‘lru’, ‘lfu’, ‘fifo’)
• compression (boolean): Enable compression
• namespace (string): Cache namespace

Methods

get(key, options)

Retrieve a value from cache.

const value = await cache.get('user:123');

Parameters:

• key (string): Cache key
• options (object, optional): Get options

Returns: Promise resolving to cached value or undefined

set(key, value, options)

Store a value in cache.

await cache.set('user:123', userData, { ttl: 300000 });

Parameters:

• key (string): Cache key
• value (any): Value to cache
• options (object, optional): Set options

delete(key)

Remove a value from cache.

await cache.delete('user:123');

Parameters:

• key (string): Cache key

clear()

Clear all cached values.

await cache.clear();

has(key)

Check if key exists in cache.

const exists = await cache.has('user:123');

Parameters:

• key (string): Cache key

Returns: Promise resolving to boolean

getStats()

Get cache statistics.

const stats = await cache.getStats();
// { hits: 150, misses: 25, size: 175, hitRate: 0.857 }

Returns: Promise resolving to statistics object

memoize(fn, options)

Create a memoized version of a function.

const getUser = cache.memoize(
  async (id) => await fetchUserFromDB(id),
  { ttl: 300000, keyFn: (id) => `user:${id}` }
);

const user = await getUser('123'); // Cached automatically

Parameters:

• fn (function): Function to memoize
• options (object, optional): Memoization options

Returns: Memoized function

Cache Strategies

LRU (Least Recently Used)

const cache = new CacheManager({
  strategy: 'lru',
  maxSize: 1000
});

LFU (Least Frequently Used)

const cache = new CacheManager({
  strategy: 'lfu',
  maxSize: 1000
});

FIFO (First In, First Out)

const cache = new CacheManager({
  strategy: 'fifo',
  maxSize: 1000
});

Cache Backends

Memory Backend

const cache = new CacheManager({
  backend: 'memory',
  maxSize: 1000
});

Redis Backend

const cache = new CacheManager({
  backend: 'redis',
  url: 'redis://localhost:6379',
  ttl: 300000
});

Cloudflare KV Backend

const cache = new CacheManager({
  backend: 'cloudflare-kv',
  namespace: 'my-app-cache'
});

Cache Patterns

Read-Through Caching

class ReadThroughCache {
  constructor(cache, dataSource) {
    this.cache = cache;
    this.dataSource = dataSource;
  }

  async get(key) {
    let value = await this.cache.get(key);
    if (!value) {
      value = await this.dataSource.get(key);
      if (value) {
        await this.cache.set(key, value);
      }
    }
    return value;
  }
}

Write-Through Caching

class WriteThroughCache {
  constructor(cache, dataSource) {
    this.cache = cache;
    this.dataSource = dataSource;
  }

  async set(key, value) {
    await this.dataSource.set(key, value);
    await this.cache.set(key, value);
  }
}

Cache-Aside Pattern

class CacheAside {
  constructor(cache, dataSource) {
    this.cache = cache;
    this.dataSource = dataSource;
  }

  async get(key) {
    let value = await this.cache.get(key);
    if (!value) {
      value = await this.dataSource.get(key);
      if (value) {
        await this.cache.set(key, value);
      }
    }
    return value;
  }

  async set(key, value) {
    await this.dataSource.set(key, value);
    await this.cache.set(key, value);
  }
}

Type Definitions

CacheOptions

interface CacheOptions {
  ttl?: number;
  tags?: string[];
  compression?: boolean;
}

CacheStats

interface CacheStats {
  hits: number;
  misses: number;
  size: number;
  hitRate: number;
  evictions: number;
}

MemoizeOptions

interface MemoizeOptions extends CacheOptions {
  keyFn?: (...args: any[]) => string;
  maxAge?: number;
}