File Explorer

1'use strict'2 3const { Writable } = require('node:stream')4const { EventEmitter } = require('node:events')5const { assertCacheKey, assertCacheValue } = require('../util/cache.js')6 7/**8 * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheKey} CacheKey9 * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheValue} CacheValue10 * @typedef {import('../../types/cache-interceptor.d.ts').default.CacheStore} CacheStore11 * @typedef {import('../../types/cache-interceptor.d.ts').default.GetResult} GetResult12 */13 14/**15 * @implements {CacheStore}16 * @extends {EventEmitter}17 */18class MemoryCacheStore extends EventEmitter {19  #maxCount = 102420  #maxSize = 104857600 // 100MB21  #maxEntrySize = 5242880 // 5MB22 23  #size = 024  #count = 025  #entries = new Map()26  #hasEmittedMaxSizeEvent = false27 28  /**29   * @param {import('../../types/cache-interceptor.d.ts').default.MemoryCacheStoreOpts | undefined} [opts]30   */31  constructor (opts) {32    super()33    if (opts) {34      if (typeof opts !== 'object') {35        throw new TypeError('MemoryCacheStore options must be an object')36      }37 38      if (opts.maxCount !== undefined) {39        if (40          typeof opts.maxCount !== 'number' ||41          !Number.isInteger(opts.maxCount) ||42          opts.maxCount < 043        ) {44          throw new TypeError('MemoryCacheStore options.maxCount must be a non-negative integer')45        }46        this.#maxCount = opts.maxCount47      }48 49      if (opts.maxSize !== undefined) {50        if (51          typeof opts.maxSize !== 'number' ||52          !Number.isInteger(opts.maxSize) ||53          opts.maxSize < 054        ) {55          throw new TypeError('MemoryCacheStore options.maxSize must be a non-negative integer')56        }57        this.#maxSize = opts.maxSize58      }59 60      if (opts.maxEntrySize !== undefined) {61        if (62          typeof opts.maxEntrySize !== 'number' ||63          !Number.isInteger(opts.maxEntrySize) ||64          opts.maxEntrySize < 065        ) {66          throw new TypeError('MemoryCacheStore options.maxEntrySize must be a non-negative integer')67        }68        this.#maxEntrySize = opts.maxEntrySize69      }70    }71  }72 73  /**74   * Get the current size of the cache in bytes75   * @returns {number} The current size of the cache in bytes76   */77  get size () {78    return this.#size79  }80 81  /**82   * Check if the cache is full (either max size or max count reached)83   * @returns {boolean} True if the cache is full, false otherwise84   */85  isFull () {86    return this.#size >= this.#maxSize || this.#count >= this.#maxCount87  }88 89  /**90   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} req91   * @returns {import('../../types/cache-interceptor.d.ts').default.GetResult | undefined}92   */93  get (key) {94    assertCacheKey(key)95 96    const topLevelKey = `${key.origin}:${key.path}`97 98    const now = Date.now()99    const entries = this.#entries.get(topLevelKey)100 101    const entry = entries ? findEntry(key, entries, now) : null102 103    return entry == null104      ? undefined105      : {106          statusMessage: entry.statusMessage,107          statusCode: entry.statusCode,108          headers: entry.headers,109          body: entry.body,110          vary: entry.vary ? entry.vary : undefined,111          etag: entry.etag,112          cacheControlDirectives: entry.cacheControlDirectives,113          cachedAt: entry.cachedAt,114          staleAt: entry.staleAt,115          deleteAt: entry.deleteAt116        }117  }118 119  /**120   * @param {import('../../types/cache-interceptor.d.ts').default.CacheKey} key121   * @param {import('../../types/cache-interceptor.d.ts').default.CacheValue} val122   * @returns {Writable | undefined}123   */124  createWriteStream (key, val) {125    assertCacheKey(key)126    assertCacheValue(val)127 128    const topLevelKey = `${key.origin}:${key.path}`129 130    const store = this131    const entry = { ...key, ...val, body: [], size: 0 }132 133    return new Writable({134      write (chunk, encoding, callback) {135        if (typeof chunk === 'string') {136          chunk = Buffer.from(chunk, encoding)137        }138 139        entry.size += chunk.byteLength140 141        if (entry.size >= store.#maxEntrySize) {142          this.destroy()143        } else {144          entry.body.push(chunk)145        }146 147        callback(null)148      },149      final (callback) {150        let entries = store.#entries.get(topLevelKey)151        if (!entries) {152          entries = []153          store.#entries.set(topLevelKey, entries)154        }155        const previousEntry = findEntry(key, entries, Date.now())156        if (previousEntry) {157          const index = entries.indexOf(previousEntry)158          entries.splice(index, 1, entry)159          store.#size -= previousEntry.size160        } else {161          entries.push(entry)162          store.#count += 1163        }164 165        store.#size += entry.size166 167        // Check if cache is full and emit event if needed168        if (store.#size > store.#maxSize || store.#count > store.#maxCount) {169          // Emit maxSizeExceeded event if we haven't already170          if (!store.#hasEmittedMaxSizeEvent) {171            store.emit('maxSizeExceeded', {172              size: store.#size,173              maxSize: store.#maxSize,174              count: store.#count,175              maxCount: store.#maxCount176            })177            store.#hasEmittedMaxSizeEvent = true178          }179 180          // Perform eviction181          for (const [key, entries] of store.#entries) {182            for (const entry of entries.splice(0, entries.length / 2)) {183              store.#size -= entry.size184              store.#count -= 1185            }186            if (entries.length === 0) {187              store.#entries.delete(key)188            }189          }190 191          // Reset the event flag after eviction192          if (store.#size < store.#maxSize && store.#count < store.#maxCount) {193            store.#hasEmittedMaxSizeEvent = false194          }195        }196 197        callback(null)198      }199    })200  }201 202  /**203   * @param {CacheKey} key204   */205  delete (key) {206    if (typeof key !== 'object') {207      throw new TypeError(`expected key to be object, got ${typeof key}`)208    }209 210    const topLevelKey = `${key.origin}:${key.path}`211 212    for (const entry of this.#entries.get(topLevelKey) ?? []) {213      this.#size -= entry.size214      this.#count -= 1215    }216    this.#entries.delete(topLevelKey)217  }218}219 220function findEntry (key, entries, now) {221  for (let i = 0; i < entries.length; i++) {222    const entry = entries[i]223    if (224      entry.deleteAt > now &&225      entry.method === key.method &&226      varyMatches(key, entry)227    ) {228      return entry229    }230  }231}232 233function varyMatches (key, entry) {234  if (entry.vary == null) {235    return true236  }237 238  for (const headerName in entry.vary) {239    if (Object.hasOwn(entry.vary, headerName) && !headerValueEquals(key.headers?.[headerName], entry.vary[headerName])) {240      return false241    }242  }243 244  return true245}246 247/**248 * @param {string|string[]|null|undefined} lhs249 * @param {string|string[]|null|undefined} rhs250 * @returns {boolean}251 */252function headerValueEquals (lhs, rhs) {253  if (lhs == null && rhs == null) {254    return true255  }256 257  if ((lhs == null && rhs != null) ||258      (lhs != null && rhs == null)) {259    return false260  }261 262  if (Array.isArray(lhs) && Array.isArray(rhs)) {263    if (lhs.length !== rhs.length) {264      return false265    }266 267    for (let i = 0; i < lhs.length; i++) {268      if (lhs[i] !== rhs[i]) {269        return false270      }271    }272 273    return true274  }275 276  return lhs === rhs277}278 279module.exports = MemoryCacheStore280