purgeStale skips purge due to expiration ceil (assumption) making cache use stale values about ttlcache HOT 2 CLOSED

import TTLCache from './'
import type {Options as TTLCacheOptions} from './'

export interface Options<K> extends TTLCacheOptions<K, number> {
  maxHits: number
}

export class RateLimiter<K> extends TTLCache<K, number> {
  readonly maxHits: number

  constructor (options: Options<K>) {
    options.updateAgeOnGet = false
    options.noUpdateTTL = true
    super(options)
    if (!options.maxHits || typeof options.maxHits !== 'number' || options.maxHits <= 0) {
      throw new TypeError('must specify a positive number of max hits allowed within the period')
    }
    this.maxHits = options.maxHits
  }

  // call limiter.hit(key) and it'll return true if it's allowed,
  // or false if it should be rejected.
  hit (key:K) {
    const value = (this.get(key) || 0) + 1
    this.set(key, value)
    return value < this.maxHits
  }
}

const rl = new RateLimiter<string>({ ttl: 100, maxHits: 10 })
const run = () => {
  const interval = setInterval(() => {
    const allowed = rl.hit('test')
    console.log(Date.now(), allowed, rl.get('test'))
    if (!allowed) {
      console.error('> > > > > hit rate limit')
      clearInterval(interval)
      setTimeout(run, 1)
    }
  }, 10)
}
run()

import type {Options as TTLCacheOptions} from './'
import TTLCache from './'

export interface Options {
  window: number
  max: number
}

interface RLEntryOptions extends TTLCacheOptions<number, boolean> {
  onEmpty: () => any
}

class RLEntry extends TTLCache<number, boolean> {
  onEmpty: () => any
  constructor(options: RLEntryOptions) {
    super(options)
    this.onEmpty = options.onEmpty
  }
  purgeStale() {
    const ret = super.purgeStale()
    if (this.size === 0 && ret) {
      this.onEmpty()
    }
    return ret
  }
}

class RateLimiter<K> extends Map<K, TTLCache<number, boolean>> {
  window: number
  max: number
  constructor(options: Options) {
    super()
    this.window = options.window
    this.max = options.max
  }
  hit(key: K) {
    const c = super.get(key) || new RLEntry({
      ttl: this.window,
      onEmpty: () => this.delete(key),
    })

    this.set(key, c)

    if (c.size > this.max) {
      // rejected, too many hits within window
      return false
    }
    c.set(performance.now(), true)
    return true
  }

  count (key: K) {
    const c = super.get(key)
    return c ? c.size : 0
  }
}