Class InMemoryServerCache

packages/core/src/cache/inmemory.ts:22–110

}

export class InMemoryServerCache extends MastraServerCache {
  private cache: TTLCache<string, unknown>;
  private ttlMs: number;

  constructor(options: InMemoryServerCacheOptions = {}) {
    super({ name: 'InMemoryServerCache' });

    this.ttlMs = options.ttlMs ?? 1000 * 60 * 5;
    // TTLCache requires positive integer or Infinity; use Infinity when TTL is disabled
    const ttl = this.ttlMs > 0 ? this.ttlMs : Infinity;

    this.cache = new TTLCache<string, unknown>({
      max: options.maxSize ?? 1000,
      ttl,
    });
  }

  async get(key: string): Promise<unknown> {
    return this.cache.get(key);
  }

  async set(key: string, value: unknown, ttlMs?: number): Promise<void> {
    if (ttlMs === undefined) {
      this.cache.set(key, value);
      return;
    }
    // TTLCache requires positive integer or Infinity; non-positive overrides
    // mean "no expiry" and must be normalized.
    this.cache.set(key, value, { ttl: ttlMs > 0 ? ttlMs : Infinity });
  }

  async listLength(key: string): Promise<number> {
    const value = this.cache.get(key);
    if (value === undefined) {
      return 0; // Key doesn't exist - return 0
    }
    if (!Array.isArray(value)) {
      throw new Error(`${key} exists but is not an array`);
    }
    return value.length;
  }

  async listPush(key: string, value: unknown): Promise<void> {
    const existing = this.cache.get(key);
    if (Array.isArray(existing)) {
      existing.push(value);
      // Refresh TTL on push by re-setting the key with the updated list
      if (this.ttlMs > 0) {
        this.cache.set(key, existing, { ttl: this.ttlMs });
      }
    } else if (existing !== undefined) {
      throw new Error(`${key} exists but is not an array`);
    } else {
      this.cache.set(key, [value]);
    }
  }

  async listFromTo(key: string, from: number, to: number = -1): Promise<unknown[]> {