alleviate Copy package name

Copy code

import { createLRU } from "alleviate"

const lru = createLRU({ max: 3 })

lru.set("foo", "bar")
lru.has("foo") // true
lru.get("foo") // "bar", marks "foo" as most recently used
lru.peek("foo") // "bar", does not affect LRU order

lru.setMany({
	biz: "baz",
	lorem: "ipsum",
})
lru.setMany([
	["0", "0"],
	["1", "1"],
	["2", "3"],
])

lru.clear()

Copy code

import { createTTLMap } from "alleviate"

const cache = createTTLMap({ ttl: 60_000 })

cache.set("foo", "bar")
cache.has("foo") // true, does not affect TTL
cache.get("foo") // "bar", refreshes TTL unless `getRefreshesTTL` is false
cache.peek("foo") // "bar", does not affect TTL
cache.clear()

Copy code

import { memoize } from "alleviate"

const fibonacci = memoize((num: number) => {
	/* ... */
})
fibonacci(100)
fibonacci(100) // skips executing function, returns cached result

const memoized = memoize(fn, {
	max: 100, // number of cached results to keep before evicting the oldest
	keepNullish: true, // whether to cache nullish results (null, undefined). Defaults to `false`
	serialize: (params) => {}, // custom parameter serialization for the cache key. Defaults to `fnv1a-64(object-identity(data))`
})

Copy code

import { createQueue } from "alleviate"

const queue = createQueue({ concurrency: 4 })

// run a function asap
const response = await queue.run(() => fetch("https://example.com"))

// wrap a function to run it later, or multiple times
const callExample = queue.wrap((path: string) => fetch(`https://example.com/${path}`))
await callExample("foo")

Copy code

import { createLimiter } from "alleviate"

const limiter = createLimiter({
	concurrency: 4, // How many promises can be running at once (defaults to 3/4ths of available threads)
	pool: 4, // Max number of calls before blocking (defaults to `concurrency`)
	initial: 16, // How much the pool starts with (defaults to `pool`)
	refill: 60, // How much the pool increases per `refillInterval` (defaults to `pool`)
	refillInterval: 1000, // How often the pool is refilled in ms
	refillOverLimit: false, // Whether the pool should be refilled over its limit
	timeout: null, // How long to wait in ms for a call to resolve before rejecting
})

const response = await limiter.run(() => fetch("https://example.com"))

const callExample = limiter.wrap((path: string) => fetch(`https://example.com/${path}`))
await callExample("foo")

// If `timeout` is set, `.run()` will receive an AbortSignal.
const limiter = createLimiter({ timeout: 100 })
const response = await limiter.run((signal) => fetch("https://example.com", { signal }))

/* -- Examples -- */

// 60 requests per minute
const limiter = createLimiter({
	concurrency: 16,
	pool: 60,
	refillInterval: 60_000,
})

// 60 requests per minute, more spread out
const limiter = createLimiter({
	concurrency: 16,
	pool: 60,
	initial: 16,
	refill: 10,
	refillInterval: 10_000,
})

Copy code

const dataloader = createDataLoader<string, number>({
	// The loader function receives a batch of keys passed into `load` and `loadMany`
	// and must returns an array where the items must match the order of the keys.
	loader: async (keys: string[]): Promise<number[]> => {
		const result = await fetchData(keys)
		return keys.map((key) => result[key])
	},
	// Whether to cache results. Also accepts `Map`s.
	cache: true,
	// Allows customizing how the keys are serialized for caching. Defaults to `object-identity`.
	cacheKeyFn: (key): string => key,
	// Whether to cache errors *returned* by the loader (not the loader throwing)
	cacheErrors: true,
	// Whether to limit batch sizes and by how much. Defaults to no max batch size.
	maxBatchSize: 25,
})