**Options**

- `maxSize` - The maximum total size in bytes of all stored responses. Default `Infinity`.

- `maxCount` - The maximum amount of responses to store. Default `Infinity`.

- `maxEntrySize` - The maximum size in bytes that a response's body can be. If a response's body is greater than or equal to this, the response will not be cached. Default `Infinity`.

Returns the current total size in bytes of all stored responses.

Returns a boolean indicating whether the cache has reached its maximum size or count.

Emitted when the cache exceeds its maximum size or count limits. The event payload contains `size`, `maxSize`, `count`, and `maxCount` properties.

- `location` - The location of the SQLite database to use. Default `:memory:`.

- `maxCount` - The maximum number of entries to store in the database. Default `Infinity`.

- `maxEntrySize` - The maximum size in bytes that a response's body can be. If a response's body is greater than or equal to this, the response will not be cached. Default `Infinity`.

* **factory** `(origin: URL, opts: Object) => Dispatcher` - Default: `(origin, opts) => new Client(origin, opts)`

* **connections** `number | null` (optional) - Default: `null` - The number of `Client` instances to create. When set to `null`, the `Pool` instance will create an unlimited amount of `Client` instances.

* **clientTtl** `number | null` (optional) - Default: `null` - The amount of time before a `Client` instance is removed from the `Pool` and closed. When set to `null`, `Client` instances will not be removed or closed based on age.

* **clientFactory** `(origin: URL, opts: Object) => Dispatcher` (optional) - Default: `(origin, opts) => new Pool(origin, opts)`

* **requestTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the request. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).

* **proxyTls** `BuildOptions` (optional) - Options object passed when creating the underlying socket via the connector builder for the proxy server. It extends from [`Client#ConnectOptions`](/docs/docs/api/Client.md#parameter-connectoptions).

* **proxyTunnel** `boolean` (optional) - By default, ProxyAgent will request that the Proxy facilitate a tunnel between the endpoint and the agent. Setting `proxyTunnel` to false avoids issuing a CONNECT extension, and includes the endpoint domain and path in each request.

Examples:

const { Writable } = require('node:stream')

const { EventEmitter } = require('node:events')

const { assertCacheKey, assertCacheValue } = require('../util/cache.js')

class MemoryCacheStore extends EventEmitter {

#maxCount = Infinity

#maxSize = Infinity

#maxEntrySize = Infinity

#size = 0

#count = 0

#entries = new Map()

#hasEmittedMaxSizeEvent = false

/**

constructor (opts) {

super()

if (opts) {

if (typeof opts !== 'object') {

throw new TypeError('MemoryCacheStore options must be an object')

}

}

/**

get size () {

return this.#size

}

/**

isFull () {

return this.#size >= this.#maxSize || this.#count >= this.#maxCount

}

/**

store.#size += entry.size

// Check if cache is full and emit event if needed

if (store.#size > store.#maxSize || store.#count > store.#maxCount) {

// Emit maxSizeExceeded event if we haven't already

if (!store.#hasEmittedMaxSizeEvent) {

store.emit('maxSizeExceeded', {

size: store.#size,

maxSize: store.#maxSize,

count: store.#count,

maxCount: store.#maxCount

})

store.#hasEmittedMaxSizeEvent = true

}

// Perform eviction

for (const [key, entries] of store.#entries) {

for (const entry of entries.splice(0, entries.length / 2)) {

store.#size -= entry.size

store.#entries.delete(key)

}

}

// Reset the event flag after eviction

if (store.#size < store.#maxSize && store.#count < store.#maxCount) {

store.#hasEmittedMaxSizeEvent = false

}

}

callback(null)

}

this[kOnConnect] = (origin, targets) => {

const result = this[kClients].get(origin)

if (result) {

result.count += 1

}

this.emit('connect', origin, [this, ...targets])

}

this[kOnDisconnect] = (origin, targets, err) => {

const result = this[kClients].get(origin)

if (result) {

result.count -= 1

if (result.count <= 0) {

this[kClients].delete(origin)

result.dispatcher.destroy()

}

}

this.emit('disconnect', origin, [this, ...targets], err)

}

this[kOnConnectionError] = (origin, targets, err) => {

// TODO: should this decrement result.count here?

this.emit('connectionError', origin, [this, ...targets], err)

}

}

get [kRunning] () {

let ret = 0

for (const { dispatcher } of this[kClients].values()) {

ret += dispatcher[kRunning]

}

return ret

}

throw new InvalidArgumentError('opts.origin must be a non-empty string or URL.')

}

const result = this[kClients].get(key)

if (!dispatcher) {

dispatcher = this[kFactory](opts.origin, this[kOptions])

.on('drain', this[kOnDrain])

.on('connect', this[kOnConnect])

.on('disconnect', this[kOnDisconnect])

.on('connectionError', this[kOnConnectionError])

this[kClients].set(key, { count: 0, dispatcher })

}

return dispatcher.dispatch(opts, handler)

}

async [kClose] () {

const closePromises = []

for (const { dispatcher } of this[kClients].values()) {

closePromises.push(dispatcher.close())

}

this[kClients].clear()

async [kDestroy] (err) {

const destroyPromises = []

for (const { dispatcher } of this[kClients].values()) {

destroyPromises.push(dispatcher.destroy(err))

}

this[kClients].clear()

get stats () {

const allClientStats = {}

for (const { dispatcher } of this[kClients].values()) {

if (dispatcher.stats) {

allClientStats[dispatcher[kUrl].origin] = dispatcher.stats

}

}

return allClientStats

kClients,

kNeedDrain,

kAddClient,

kGetDispatcher,

kRemoveClient

} = require('./pool-base')

const Client = require('./client')

const {

autoSelectFamily,

autoSelectFamilyAttemptTimeout,

allowH2,

clientTtl,

...options

} = {}) {

if (connections != null && (!Number.isFinite(connections) || connections < 0)) {

this[kConnections] = connections || null

this[kUrl] = util.parseOrigin(origin)

this[kOptions] = { ...util.deepClone(options), connect, allowH2, clientTtl }

this[kOptions].interceptors = options.interceptors

? { ...options.interceptors }

: undefined

this[kFactory] = factory

this.on('connect', (origin, targets) => {

if (clientTtl != null && clientTtl > 0) {

for (const target of targets) {

Object.assign(target, { ttl: Date.now() })

}

}

})

this.on('connectionError', (origin, targets, error) => {

// If a connection error occurs, we remove the client from the pool,

// and emit a connectionError event. They will not be re-used.

}

[kGetDispatcher] () {

const clientTtlOption = this[kOptions].clientTtl

for (const client of this[kClients]) {

// check ttl of client and if it's stale, remove it from the pool

if (clientTtlOption != null && clientTtlOption > 0 && client.ttl && ((Date.now() - client.ttl) > clientTtlOption)) {

this[kRemoveClient](client)

} else if (!client[kNeedDrain]) {

return client

}

}