faastjs
Version:
Serverless batch computing made simple.
432 lines • 52.9 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.AsyncOrderedQueue = exports.AsyncIterableQueue = exports.AsyncQueue = exports.throttle = exports.cacheFn = exports.memoizeFn = exports.RateLimiter = exports.Pump = exports.Funnel = exports.retryOp = exports.DeferredWorker = exports.Deferred = void 0;
const tslib_1 = require("tslib");
const assert_1 = tslib_1.__importDefault(require("assert"));
const crypto_1 = require("crypto");
const error_1 = require("./error");
const serialize_1 = require("./serialize");
const shared_1 = require("./shared");
class Deferred {
constructor() {
this.promise = new Promise((resolve, reject) => {
this.resolve = resolve;
this.reject = reject;
});
}
}
exports.Deferred = Deferred;
class DeferredWorker extends Deferred {
constructor(worker, cancel) {
super();
this.worker = worker;
this.cancel = cancel;
}
async execute() {
const cancelMessage = this.cancel?.();
if (cancelMessage) {
this.reject(new error_1.FaastError({ name: error_1.FaastErrorNames.ECANCEL }, cancelMessage));
}
else {
try {
const rv = await this.worker();
this.resolve(rv);
}
catch (err) {
this.reject(err);
}
}
}
}
exports.DeferredWorker = DeferredWorker;
function popFirst(set) {
let firstElem;
for (const elem of set) {
firstElem = elem;
break;
}
if (firstElem) {
set.delete(firstElem);
}
return firstElem;
}
async function retryOp(retryN, fn) {
const retryTest = typeof retryN === "function" ? retryN : (_, i) => i < retryN;
for (let i = 0; true; i++) {
try {
return await fn(i);
}
catch (err) {
if (!retryTest(err, i)) {
throw err;
}
await (0, shared_1.sleep)(Math.min(30 * 1000, 1000 * (1 + Math.random()) * 2 ** i) + Math.random());
}
}
}
exports.retryOp = retryOp;
class Funnel {
constructor(concurrency = 0, shouldRetry) {
this.concurrency = concurrency;
this.shouldRetry = shouldRetry;
this.pendingQueue = new Set();
this.executingQueue = new Set();
this.processed = 0;
this.errors = 0;
}
push(worker, shouldRetry, cancel) {
const retryTest = shouldRetry || this.shouldRetry || 0;
const retryWorker = () => retryOp(retryTest, worker);
const future = new DeferredWorker(retryWorker, cancel);
this.pendingQueue.add(future);
setImmediate(() => this.doWork());
return future.promise;
}
clear() {
this.pendingQueue.clear();
this.executingQueue.clear();
}
promises() {
return [...this.executingQueue, ...this.pendingQueue].map(p => p.promise);
}
all() {
return Promise.all(this.promises().map(p => p.catch(_ => { })));
}
size() {
return this.pendingQueue.size + this.executingQueue.size;
}
setMaxConcurrency(maxConcurrency) {
this.concurrency = maxConcurrency;
}
getConcurrency() {
return this.executingQueue.size;
}
doWork() {
const { pendingQueue } = this;
while (pendingQueue.size > 0 &&
(!this.concurrency || this.executingQueue.size < this.concurrency)) {
const worker = popFirst(pendingQueue);
this.executingQueue.add(worker);
worker.promise
.then(_ => this.processed++)
.catch(_ => this.errors++)
.then(_ => {
this.executingQueue.delete(worker);
this.doWork();
});
worker.execute();
}
}
}
exports.Funnel = Funnel;
/**
* @internal
*/
class Pump extends Funnel {
constructor(options, worker) {
super(options.concurrency);
this.options = options;
this.worker = worker;
this.stopped = false;
options.verbose = options.verbose ?? true;
}
start() {
const restart = () => {
if (this.stopped) {
return;
}
while (this.executingQueue.size + this.pendingQueue.size < this.concurrency) {
this.push(async () => {
try {
return await this.worker();
}
catch (err) {
this.options.verbose && console.error(err);
return;
}
finally {
setImmediate(restart);
}
});
}
};
this.stopped = false;
restart();
}
stop() {
this.stopped = true;
}
drain() {
this.stop();
return this.all();
}
setMaxConcurrency(concurrency) {
super.setMaxConcurrency(concurrency);
if (!this.stopped) {
this.start();
}
}
}
exports.Pump = Pump;
class RateLimiter {
constructor(targetRequestsPerSecond, burst = 1) {
this.targetRequestsPerSecond = targetRequestsPerSecond;
this.burst = burst;
this.lastTick = 0;
this.bucket = 0;
this.queue = new Set();
(0, assert_1.default)(targetRequestsPerSecond > 0);
(0, assert_1.default)(this.burst >= 1);
}
push(worker, cancel) {
this.updateBucket();
if (this.queue.size === 0 && this.bucket <= this.burst - 1) {
this.bucket++;
return worker();
}
const future = new DeferredWorker(worker, cancel);
this.queue.add(future);
if (this.queue.size === 1) {
this.drainQueue();
}
return future.promise;
}
updateBucket() {
const now = Date.now();
const secondsElapsed = (now - this.lastTick) / 1000;
this.bucket -= secondsElapsed * this.targetRequestsPerSecond;
this.bucket = Math.max(this.bucket, 0);
this.lastTick = now;
}
async drainQueue() {
const requestAmountToDrain = 1 - (this.burst - this.bucket);
const secondsToDrain = requestAmountToDrain / this.targetRequestsPerSecond;
if (secondsToDrain > 0) {
await (0, shared_1.sleep)(Math.ceil(secondsToDrain * 1000));
}
this.updateBucket();
while (this.bucket <= this.burst - 1) {
const next = popFirst(this.queue);
if (!next) {
break;
}
this.bucket++;
next.execute();
}
if (this.queue.size > 0) {
this.drainQueue();
}
}
clear() {
this.queue.clear();
}
}
exports.RateLimiter = RateLimiter;
function memoizeFn(fn, cache = new Map()) {
return (...args) => {
const key = JSON.stringify(args);
const prev = cache.get(key);
if (prev) {
return prev;
}
const value = fn(...args);
cache.set(key, value);
return value;
};
}
exports.memoizeFn = memoizeFn;
function cacheFn(cache, fn) {
return async (...args) => {
const key = (0, serialize_1.serialize)(args, true);
const hasher = (0, crypto_1.createHash)("sha256");
hasher.update(key);
const cacheKey = hasher.digest("hex");
const prev = await cache.get(cacheKey);
if (prev) {
const str = prev.toString();
if (str === "undefined") {
return undefined;
}
return (0, serialize_1.deserialize)(str);
}
const value = await fn(...args);
await cache.set(cacheKey, (0, serialize_1.serialize)(value, true));
return value;
};
}
exports.cacheFn = cacheFn;
/**
* A decorator for rate limiting, concurrency limiting, retry, memoization, and
* on-disk caching. See {@link Limits}.
* @remarks
* When programming against cloud services, databases, and other resources, it
* is often necessary to control the rate of request issuance to avoid
* overwhelming the service provider. In many cases the provider has built-in
* safeguards against abuse, which automatically fail requests if they are
* coming in too fast. Some systems don't have safeguards and precipitously
* degrade their service level or fail outright when faced with excessive load.
*
* With faast.js it becomes very easy to (accidentally) generate requests from
* thousands of cloud functions. The `throttle` function can help manage request
* flow without resorting to setting up a separate service. This is in keeping
* with faast.js' zero-ops philosophy.
*
* Usage is simple:
*
* ```typescript
* async function operation() { ... }
* const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);
* for(let i = 0; i < 100; i++) {
* // at most 10 concurrent executions at a rate of 5 invocations per second.
* throttledOperation();
* }
* ```
*
* Note that each invocation to `throttle` creates a separate function with a
* separate limits. Therefore it is likely that you want to use `throttle` in a
* global context, not within a dynamic context:
*
* ```typescript
* async function operation() { ... }
* for(let i = 0; i < 100; i++) {
* // WRONG - each iteration creates a separate throttled function that's only called once.
* const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);
* throttledOperation();
* }
* ```
*
* A better way to use throttle avoids creating a named `operation` function
* altogether, ensuring it cannot be accidentally called without throttling:
*
* ```typescript
* const operation = throttle({ concurrency: 10, rate: 5 }, async () => {
* ...
* });
* ```
*
* Throttle supports functions with arguments automatically infers the correct
* type for the returned function:
*
* ```typescript
* // `operation` inferred to have type (str: string) => Promise<string>
* const operation = throttle({ concurrency: 10, rate: 5 }, async (str: string) => {
* return string;
* });
* ```
*
* In addition to limiting concurrency and invocation rate, `throttle` also
* supports retrying failed invocations, memoizing calls, and on-disk caching.
* See {@link Limits} for details.
*
* @param limits - see {@link Limits}.
* @param fn - The function to throttle. It can take any arguments, but must
* return a Promise (which includes `async` functions).
* @returns Returns a throttled function with the same signature as the argument
* `fn`.
* @public
*/
function throttle(limits, fn) {
const { concurrency, retry, rate, burst, memoize, cache, cancel } = limits;
const funnel = new Funnel(concurrency, retry);
const cancellationQueue = [() => funnel.clear()];
let conditionedFunc;
if (rate) {
const rateLimiter = new RateLimiter(rate, burst);
cancellationQueue.push(() => rateLimiter.clear());
conditionedFunc = (...args) => funnel.push(() => rateLimiter.push(() => fn(...args)));
}
else {
conditionedFunc = (...args) => funnel.push(() => fn(...args));
}
if (cache) {
conditionedFunc = cacheFn(cache, conditionedFunc);
}
if (memoize) {
const mcache = new Map();
cancellationQueue.push(() => mcache.clear());
conditionedFunc = memoizeFn(conditionedFunc, mcache);
}
cancel?.then(() => cancellationQueue.forEach(cleanupFn => cleanupFn()));
return conditionedFunc;
}
exports.throttle = throttle;
function iteratorResult(value) {
return Promise.resolve(value).then(v => ({ done: false, value: v }));
}
const done = Promise.resolve({ done: true, value: undefined });
class AsyncQueue {
constructor() {
this.deferred = [];
this.enqueued = [];
}
enqueue(value) {
if (this.deferred.length > 0) {
const d = this.deferred.shift();
d.resolve(value);
}
else {
this.enqueued.push(Promise.resolve(value));
}
}
next() {
if (this.enqueued.length > 0) {
return this.enqueued.shift();
}
const d = new Deferred();
this.deferred.push(d);
return d.promise;
}
clear() {
this.deferred = [];
this.enqueued = [];
}
}
exports.AsyncQueue = AsyncQueue;
class AsyncIterableQueue extends AsyncQueue {
push(value) {
super.enqueue(iteratorResult(value));
}
done() {
super.enqueue(done);
}
[Symbol.asyncIterator]() {
return this;
}
}
exports.AsyncIterableQueue = AsyncIterableQueue;
class AsyncOrderedQueue {
constructor() {
this.queue = new AsyncQueue();
this.arrived = new Map();
this.current = 0;
}
push(value, sequence) {
this.enqueue(Promise.resolve(value), sequence);
}
pushImmediate(value) {
this.queue.enqueue(value);
}
enqueue(value, sequence) {
if (sequence < this.current) {
return;
}
if (!this.arrived.has(sequence)) {
this.arrived.set(sequence, value);
}
while (this.arrived.has(this.current)) {
this.queue.enqueue(this.arrived.get(this.current));
this.arrived.delete(this.current);
this.current++;
}
}
next() {
return this.queue.next();
}
clear() {
this.arrived.clear();
this.queue.clear();
this.current = 0;
}
}
exports.AsyncOrderedQueue = AsyncOrderedQueue;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"throttle.js","sourceRoot":"","sources":["../../src/throttle.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from \"assert\";\nimport { createHash } from \"crypto\";\nimport { PersistentCache } from \"./cache\";\nimport { FaastError, FaastErrorNames } from \"./error\";\nimport { deserialize, serialize } from \"./serialize\";\nimport { sleep } from \"./shared\";\n\nexport class Deferred<T = void> {\n    promise: Promise<T>;\n    resolve!: (arg: T | PromiseLike<T>) => void;\n    reject!: (err?: any) => void;\n    constructor() {\n        this.promise = new Promise<T>((resolve, reject) => {\n            this.resolve = resolve;\n            this.reject = reject;\n        });\n    }\n}\n\nexport class DeferredWorker<T = void> extends Deferred<T> {\n    constructor(\n        private worker: () => Promise<T>,\n        private cancel?: () => string | undefined\n    ) {\n        super();\n    }\n    async execute() {\n        const cancelMessage = this.cancel?.();\n        if (cancelMessage) {\n            this.reject(new FaastError({ name: FaastErrorNames.ECANCEL }, cancelMessage));\n        } else {\n            try {\n                const rv = await this.worker();\n                this.resolve(rv);\n            } catch (err: any) {\n                this.reject(err);\n            }\n        }\n    }\n}\n\nfunction popFirst<T>(set: Set<T>): T | undefined {\n    let firstElem: T | undefined;\n    for (const elem of set) {\n        firstElem = elem;\n        break;\n    }\n    if (firstElem) {\n        set.delete(firstElem);\n    }\n    return firstElem;\n}\n\nexport type RetryType = number | ((err: any, retries: number) => boolean);\n\nexport async function retryOp<T>(retryN: RetryType, fn: (retries: number) => Promise<T>) {\n    const retryTest =\n        typeof retryN === \"function\" ? retryN : (_: any, i: number) => i < retryN;\n    for (let i = 0; true; i++) {\n        try {\n            return await fn(i);\n        } catch (err: any) {\n            if (!retryTest(err, i)) {\n                throw err;\n            }\n            await sleep(\n                Math.min(30 * 1000, 1000 * (1 + Math.random()) * 2 ** i) + Math.random()\n            );\n        }\n    }\n}\n\nexport class Funnel<T = void> {\n    protected pendingQueue: Set<DeferredWorker<T>> = new Set();\n    protected executingQueue: Set<DeferredWorker<T>> = new Set();\n    public processed = 0;\n    public errors = 0;\n\n    constructor(public concurrency: number = 0, protected shouldRetry?: RetryType) {}\n\n    push(\n        worker: () => Promise<T>,\n        shouldRetry?: RetryType,\n        cancel?: () => string | undefined\n    ) {\n        const retryTest = shouldRetry || this.shouldRetry || 0;\n        const retryWorker = () => retryOp(retryTest, worker);\n        const future = new DeferredWorker(retryWorker, cancel);\n        this.pendingQueue.add(future);\n        setImmediate(() => this.doWork());\n        return future.promise;\n    }\n\n    clear() {\n        this.pendingQueue.clear();\n        this.executingQueue.clear();\n    }\n\n    promises() {\n        return [...this.executingQueue, ...this.pendingQueue].map(p => p.promise);\n    }\n\n    all() {\n        return Promise.all(this.promises().map(p => p.catch(_ => {})));\n    }\n\n    size() {\n        return this.pendingQueue.size + this.executingQueue.size;\n    }\n\n    setMaxConcurrency(maxConcurrency: number) {\n        this.concurrency = maxConcurrency;\n    }\n\n    getConcurrency() {\n        return this.executingQueue.size;\n    }\n\n    protected doWork() {\n        const { pendingQueue } = this;\n        while (\n            pendingQueue.size > 0 &&\n            (!this.concurrency || this.executingQueue.size < this.concurrency)\n        ) {\n            const worker = popFirst(pendingQueue)!;\n            this.executingQueue.add(worker);\n\n            worker.promise\n                .then(_ => this.processed++)\n                .catch(_ => this.errors++)\n                .then(_ => {\n                    this.executingQueue.delete(worker);\n                    this.doWork();\n                });\n            worker.execute();\n        }\n    }\n}\n\n/**\n * @internal\n */\nexport interface PumpOptions {\n    concurrency: number;\n    verbose?: boolean;\n}\n\n/**\n * @internal\n */\nexport class Pump<T = void> extends Funnel<T | void> {\n    stopped: boolean = false;\n    constructor(protected options: PumpOptions, protected worker: () => Promise<T>) {\n        super(options.concurrency);\n        options.verbose = options.verbose ?? true;\n    }\n\n    start() {\n        const restart = () => {\n            if (this.stopped) {\n                return;\n            }\n            while (this.executingQueue.size + this.pendingQueue.size < this.concurrency) {\n                this.push(async () => {\n                    try {\n                        return await this.worker();\n                    } catch (err: any) {\n                        this.options.verbose && console.error(err);\n                        return;\n                    } finally {\n                        setImmediate(restart);\n                    }\n                });\n            }\n        };\n        this.stopped = false;\n        restart();\n    }\n\n    stop() {\n        this.stopped = true;\n    }\n\n    drain() {\n        this.stop();\n        return this.all();\n    }\n\n    setMaxConcurrency(concurrency: number) {\n        super.setMaxConcurrency(concurrency);\n        if (!this.stopped) {\n            this.start();\n        }\n    }\n}\n\nexport class RateLimiter<T = void> {\n    protected lastTick = 0;\n    protected bucket = 0;\n    protected queue: Set<DeferredWorker<T>> = new Set();\n\n    constructor(protected targetRequestsPerSecond: number, protected burst: number = 1) {\n        assert(targetRequestsPerSecond > 0);\n        assert(this.burst >= 1);\n    }\n\n    push(worker: () => Promise<T>, cancel?: () => string | undefined) {\n        this.updateBucket();\n        if (this.queue.size === 0 && this.bucket <= this.burst - 1) {\n            this.bucket++;\n            return worker();\n        }\n\n        const future = new DeferredWorker(worker, cancel);\n        this.queue.add(future);\n        if (this.queue.size === 1) {\n            this.drainQueue();\n        }\n        return future.promise;\n    }\n\n    protected updateBucket() {\n        const now = Date.now();\n        const secondsElapsed = (now - this.lastTick) / 1000;\n        this.bucket -= secondsElapsed * this.targetRequestsPerSecond;\n        this.bucket = Math.max(this.bucket, 0);\n        this.lastTick = now;\n    }\n\n    protected async drainQueue() {\n        const requestAmountToDrain = 1 - (this.burst - this.bucket);\n        const secondsToDrain = requestAmountToDrain / this.targetRequestsPerSecond;\n        if (secondsToDrain > 0) {\n            await sleep(Math.ceil(secondsToDrain * 1000));\n        }\n        this.updateBucket();\n        while (this.bucket <= this.burst - 1) {\n            const next = popFirst(this.queue);\n            if (!next) {\n                break;\n            }\n            this.bucket++;\n            next.execute();\n        }\n        if (this.queue.size > 0) {\n            this.drainQueue();\n        }\n    }\n\n    clear() {\n        this.queue.clear();\n    }\n}\n\n/**\n * Specify {@link throttle} limits. These limits shape the way throttle invokes\n * the underlying function.\n * @public\n */\nexport interface Limits {\n    /**\n     * The maximum number of concurrent executions of the underlying function to\n     * allow. Must be supplied, there is no default. Specifying `0` or\n     * `Infinity` is allowed and means there is no concurrency limit.\n     */\n    concurrency: number;\n    /**\n     * The maximum number of calls per second to allow to the underlying\n     * function. Default: no rate limit.\n     */\n    rate?: number;\n    /**\n     * The maximum number of calls to the underlying function to \"burst\" -- e.g.\n     * the number that can be issued immediately as long as the rate limit is\n     * not exceeded. For example, if rate is 5 and burst is 5, and 10 calls are\n     * made to the throttled function, 5 calls are made immediately and then\n     * after 1 second, another 5 calls are made immediately. Setting burst to 1\n     * means calls are issued uniformly every `1/rate` seconds. If `rate` is not\n     * specified, then `burst` does not apply. Default: 1.\n     */\n    burst?: number;\n    /**\n     * Retry if the throttled function returns a rejected promise. `retry` can\n     * be a number or a function. If it is a number `N`, then up to `N`\n     * additional attempts are made in addition to the initial call. If retry is\n     * a function, it should return `true` if another retry attempt should be\n     * made, otherwise `false`. The first argument will be the value of the\n     * rejected promise from the previous call attempt, and the second argument\n     * will be the number of previous retry attempts (e.g. the first call will\n     * have value 0). Default: 0 (no retry attempts).\n     */\n    retry?: number | ((err: any, retries: number) => boolean);\n    /**\n     * If `memoize` is `true`, then every call to the throttled function will be\n     * saved as an entry in a map from arguments to return value. If same\n     * arguments are seen again in a future call, the return value is retrieved\n     * from the Map rather than calling the function again. This can be useful\n     * for avoiding redundant calls that are expected to return the same results\n     * given the same arguments.\n     *\n     * The arguments will be captured with `JSON.stringify`, therefore types\n     * that do not stringify uniquely won't be distinguished from each other.\n     * Care must be taken when specifying `memoize` to ensure avoid incorrect\n     * results.\n     */\n    memoize?: boolean;\n    /**\n     * Similar to `memoize` except the map from function arguments to results is\n     * stored in a persistent cache on disk. This is useful to prevent redundant\n     * calls to APIs which are expected to return the same results for the same\n     * arguments, and which are likely to be called across many faast.js module\n     * instantiations. This is used internally by faast.js for caching cloud\n     * prices for AWS, and for saving the last garbage collection\n     * date for AWS. Persistent cache entries expire after a period of time. See\n     * {@link PersistentCache}.\n     */\n    cache?: PersistentCache;\n    /**\n     * A promise that, if resolved, causes cancellation of pending throttled\n     * invocations. This is typically created using `Deferred`. The idea is to\n     * use the resolving of the promise as an asynchronous signal that any\n     * pending invocations in this throttled function should be cleared.\n     * @internal\n     */\n    cancel?: Promise<void>;\n}\n\nexport function memoizeFn<A extends any[], R>(\n    fn: (...args: A) => R,\n    cache: Map<string, R> = new Map()\n) {\n    return (...args: A) => {\n        const key = JSON.stringify(args);\n        const prev = cache.get(key);\n        if (prev) {\n            return prev;\n        }\n        const value = fn(...args);\n        cache.set(key, value);\n        return value;\n    };\n}\n\nexport function cacheFn<A extends any[], R>(\n    cache: PersistentCache,\n    fn: (...args: A) => Promise<R>\n) {\n    return async (...args: A) => {\n        const key = serialize(args, true);\n        const hasher = createHash(\"sha256\");\n        hasher.update(key);\n        const cacheKey = hasher.digest(\"hex\");\n        const prev = await cache.get(cacheKey);\n        if (prev) {\n            const str = prev.toString();\n            if (str === \"undefined\") {\n                return undefined;\n            }\n            return deserialize(str);\n        }\n        const value = await fn(...args);\n        await cache.set(cacheKey, serialize(value, true));\n        return value;\n    };\n}\n\n/**\n * A decorator for rate limiting, concurrency limiting, retry, memoization, and\n * on-disk caching. See {@link Limits}.\n * @remarks\n * When programming against cloud services, databases, and other resources, it\n * is often necessary to control the rate of request issuance to avoid\n * overwhelming the service provider. In many cases the provider has built-in\n * safeguards against abuse, which automatically fail requests if they are\n * coming in too fast. Some systems don't have safeguards and precipitously\n * degrade their service level or fail outright when faced with excessive load.\n *\n * With faast.js it becomes very easy to (accidentally) generate requests from\n * thousands of cloud functions. The `throttle` function can help manage request\n * flow without resorting to setting up a separate service. This is in keeping\n * with faast.js' zero-ops philosophy.\n *\n * Usage is simple:\n *\n * ```typescript\n * async function operation() { ... }\n * const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);\n * for(let i = 0; i < 100; i++) {\n *     // at most 10 concurrent executions at a rate of 5 invocations per second.\n *     throttledOperation();\n * }\n * ```\n *\n * Note that each invocation to `throttle` creates a separate function with a\n * separate limits. Therefore it is likely that you want to use `throttle` in a\n * global context, not within a dynamic context:\n *\n * ```typescript\n * async function operation() { ... }\n * for(let i = 0; i < 100; i++) {\n *     // WRONG - each iteration creates a separate throttled function that's only called once.\n *     const throttledOperation = throttle({ concurrency: 10, rate: 5 }, operation);\n *     throttledOperation();\n * }\n * ```\n *\n * A better way to use throttle avoids creating a named `operation` function\n * altogether, ensuring it cannot be accidentally called without throttling:\n *\n * ```typescript\n * const operation = throttle({ concurrency: 10, rate: 5 }, async () => {\n *     ...\n * });\n * ```\n *\n * Throttle supports functions with arguments automatically infers the correct\n * type for the returned function:\n *\n * ```typescript\n * // `operation` inferred to have type (str: string) => Promise<string>\n * const operation = throttle({ concurrency: 10, rate: 5 }, async (str: string) => {\n *     return string;\n * });\n * ```\n *\n * In addition to limiting concurrency and invocation rate, `throttle` also\n * supports retrying failed invocations, memoizing calls, and on-disk caching.\n * See {@link Limits} for details.\n *\n * @param limits - see {@link Limits}.\n * @param fn - The function to throttle. It can take any arguments, but must\n * return a Promise (which includes `async` functions).\n * @returns Returns a throttled function with the same signature as the argument\n * `fn`.\n * @public\n */\nexport function throttle<A extends any[], R>(\n    limits: Limits,\n    fn: (...args: A) => Promise<R>\n): (...args: A) => Promise<R> {\n    const { concurrency, retry, rate, burst, memoize, cache, cancel } = limits;\n    const funnel = new Funnel<R>(concurrency, retry);\n    const cancellationQueue = [() => funnel.clear()];\n\n    let conditionedFunc: (...args: A) => Promise<R>;\n\n    if (rate) {\n        const rateLimiter = new RateLimiter<R>(rate, burst);\n        cancellationQueue.push(() => rateLimiter.clear());\n        conditionedFunc = (...args: A) =>\n            funnel.push(() => rateLimiter.push(() => fn(...args)));\n    } else {\n        conditionedFunc = (...args: A) => funnel.push(() => fn(...args));\n    }\n\n    if (cache) {\n        conditionedFunc = cacheFn(cache, conditionedFunc);\n    }\n    if (memoize) {\n        const mcache = new Map<string, Promise<R>>();\n        cancellationQueue.push(() => mcache.clear());\n        conditionedFunc = memoizeFn(conditionedFunc, mcache);\n    }\n    cancel?.then(() => cancellationQueue.forEach(cleanupFn => cleanupFn()));\n    return conditionedFunc;\n}\n\nfunction iteratorResult<T>(value: T | Promise