adaptive-concurrency 0.1.0

package/dist/limiter/factories/makePartitionedLimiter.js

@@ -0,0 +1,30 @@
+import { Limiter, } from "../../Limiter.js";
+import { PartitionedStrategy, } from "../PartitionedStrategy.js";
+import { DelayedRejectStrategy } from "../DelayedRejectStrategy.js";
+export function makePartitionedLimiter(options) {
+    const limit = options.limiter?.limit ?? Limiter.makeDefaultLimit();
+    const delayByPartition = new Map(Object.entries(options.partitions).map(([name, cfg]) => [name, cfg.delayMs ?? 0]));
+    const partitionsWithoutDelay = Object.fromEntries(Object.entries(options.partitions).map(([name, cfg]) => [name, { percent: cfg.percent }]));
+    return new Limiter({
+        ...options.limiter,
+        limit,
+        acquireStrategy: new PartitionedStrategy({
+            partitionResolver: options.partitionResolver,
+            partitions: partitionsWithoutDelay,
+            initialLimit: limit.currentLimit,
+            metricRegistry: options.limiter?.metricRegistry,
+        }),
+        allotmentUnavailableStrategy: new DelayedRejectStrategy({
+            delayMsForContext: (context) => {
+                const partition = options.partitionResolver(context);
+                if (partition === undefined) {
+                    return 0;
+                }
+                return delayByPartition.get(partition) ?? 0;
+            },
+            ...(options.maxConcurrentDelays === undefined
+                ? {}
+                : { maxConcurrentDelays: options.maxConcurrentDelays }),
+        }),
+    });
+}

package/dist/limiter/factories/makeSimpleLimiter.d.ts

@@ -0,0 +1,3 @@
+import { Limiter, type LimiterOptions, type SyncAcquireResult } from "../../Limiter.js";
+export declare function makeSimpleLimiter<ContextT = void>(options?: Omit<LimiterOptions<ContextT, SyncAcquireResult>, "acquireStrategy">): Limiter<ContextT, SyncAcquireResult>;
+//# sourceMappingURL=makeSimpleLimiter.d.ts.map

package/dist/limiter/factories/makeSimpleLimiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeSimpleLimiter.d.ts","sourceRoot":"","sources":["../../../src/limiter/factories/makeSimpleLimiter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAEP,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACvB,MAAM,kBAAkB,CAAC;AAE1B,wBAAgB,iBAAiB,CAAC,QAAQ,GAAG,IAAI,EAC/C,OAAO,GAAE,IAAI,CACX,cAAc,CAAC,QAAQ,EAAE,iBAAiB,CAAC,EAC3C,iBAAiB,CACb,GACL,OAAO,CAAC,QAAQ,EAAE,iBAAiB,CAAC,CAOtC"}

package/dist/limiter/factories/makeSimpleLimiter.js

@@ -0,0 +1,9 @@
+import { Limiter, SemaphoreStrategy, } from "../../Limiter.js";
+export function makeSimpleLimiter(options = {}) {
+    const limit = options.limit ?? Limiter.makeDefaultLimit();
+    return new Limiter({
+        ...options,
+        limit,
+        acquireStrategy: new SemaphoreStrategy(limit.currentLimit),
+    });
+}

package/dist/limiter/factories.d.ts

@@ -0,0 +1,31 @@
+import { Limiter, type AsyncAcquireResult, type LimiterOptions, type SyncAcquireResult } from "../Limiter.js";
+import { type LifoBlockingRejectionOptions } from "./LifoBlockingRejection.js";
+import { type PartitionConfig } from "./PartitionedStrategy.js";
+export declare function makeSimpleLimiter<ContextT = void>(options?: LimiterOptions<ContextT, SyncAcquireResult>): Limiter<ContextT, SyncAcquireResult>;
+export interface BlockingLimiterFactoryOptions<ContextT> {
+    timeout?: number;
+    limiter?: Omit<LimiterOptions<ContextT, AsyncAcquireResult>, "rejectionStrategy">;
+}
+export declare function makeBlockingLimiter<ContextT = void>(options?: BlockingLimiterFactoryOptions<ContextT>): Limiter<ContextT, AsyncAcquireResult>;
+export interface LifoBlockingLimiterFactoryOptions<ContextT> {
+    backlogSize?: number;
+    backlogTimeout?: LifoBlockingRejectionOptions<ContextT>["backlogTimeout"];
+    limiter?: Omit<LimiterOptions<ContextT, AsyncAcquireResult>, "rejectionStrategy">;
+}
+export declare function makeLifoBlockingLimiter<ContextT = void>(options?: LifoBlockingLimiterFactoryOptions<ContextT>): Limiter<ContextT, AsyncAcquireResult>;
+export interface PartitionedLimiterFactoryOptions<ContextT, PartitionName extends string = string> {
+    partitionResolver: (context: ContextT) => PartitionName | undefined;
+    partitions: Record<PartitionName, PartitionConfig>;
+    limiter?: Omit<LimiterOptions<ContextT, SyncAcquireResult>, "acquireStrategy">;
+}
+export declare function makePartitionedLimiter<ContextT, PartitionName extends string = string>(options: PartitionedLimiterFactoryOptions<ContextT, PartitionName>): Limiter<ContextT, SyncAcquireResult>;
+export interface PartitionedBlockingLimiterFactoryOptions<ContextT, PartitionName extends string = string> extends PartitionedLimiterFactoryOptions<ContextT, PartitionName> {
+    timeout?: number;
+}
+export declare function makePartitionedBlockingLimiter<ContextT, PartitionName extends string = string>(options: PartitionedBlockingLimiterFactoryOptions<ContextT, PartitionName>): Limiter<ContextT, AsyncAcquireResult>;
+export interface PartitionedLifoBlockingLimiterFactoryOptions<ContextT, PartitionName extends string = string> extends PartitionedLimiterFactoryOptions<ContextT, PartitionName> {
+    backlogSize?: number;
+    backlogTimeout?: LifoBlockingRejectionOptions<ContextT>["backlogTimeout"];
+}
+export declare function makePartitionedLifoBlockingLimiter<ContextT, PartitionName extends string = string>(options: PartitionedLifoBlockingLimiterFactoryOptions<ContextT, PartitionName>): Limiter<ContextT, AsyncAcquireResult>;
+//# sourceMappingURL=factories.d.ts.map

package/dist/limiter/factories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factories.d.ts","sourceRoot":"","sources":["../../src/limiter/factories.ts"],"names":[],"mappings":"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"}

package/dist/limiter/factories.js

@@ -0,0 +1,74 @@
+import { Limiter, } from "../Limiter.js";
+import { FifoBlockingRejection } from "./FifoBlockingRejection.js";
+import { LifoBlockingRejection, } from "./LifoBlockingRejection.js";
+import { PartitionedStrategy, } from "./PartitionedStrategy.js";
+import { VegasLimit } from "../limit/VegasLimit.js";
+function makeLimit(provided) {
+    return provided ?? new VegasLimit();
+}
+export function makeSimpleLimiter(options = {}) {
+    return new Limiter(options);
+}
+export function makeBlockingLimiter(options = {}) {
+    return new Limiter({
+        ...options.limiter,
+        rejectionStrategy: new FifoBlockingRejection({
+            timeout: options.timeout,
+        }),
+    });
+}
+export function makeLifoBlockingLimiter(options = {}) {
+    return new Limiter({
+        ...options.limiter,
+        rejectionStrategy: new LifoBlockingRejection({
+            backlogSize: options.backlogSize,
+            backlogTimeout: options.backlogTimeout,
+        }),
+    });
+}
+export function makePartitionedLimiter(options) {
+    const limit = makeLimit(options.limiter?.limit);
+    return new Limiter({
+        ...options.limiter,
+        limit,
+        acquireStrategy: new PartitionedStrategy({
+            partitionResolver: options.partitionResolver,
+            partitions: options.partitions,
+            initialLimit: limit.currentLimit,
+            metricRegistry: options.limiter?.metricRegistry,
+        }),
+    });
+}
+export function makePartitionedBlockingLimiter(options) {
+    const limit = makeLimit(options.limiter?.limit);
+    return new Limiter({
+        ...options.limiter,
+        limit,
+        acquireStrategy: new PartitionedStrategy({
+            partitionResolver: options.partitionResolver,
+            partitions: options.partitions,
+            initialLimit: limit.currentLimit,
+            metricRegistry: options.limiter?.metricRegistry,
+        }),
+        rejectionStrategy: new FifoBlockingRejection({
+            timeout: options.timeout,
+        }),
+    });
+}
+export function makePartitionedLifoBlockingLimiter(options) {
+    const limit = makeLimit(options.limiter?.limit);
+    return new Limiter({
+        ...options.limiter,
+        limit,
+        acquireStrategy: new PartitionedStrategy({
+            partitionResolver: options.partitionResolver,
+            partitions: options.partitions,
+            initialLimit: limit.currentLimit,
+            metricRegistry: options.limiter?.metricRegistry,
+        }),
+        rejectionStrategy: new LifoBlockingRejection({
+            backlogSize: options.backlogSize,
+            backlogTimeout: options.backlogTimeout,
+        }),
+    });
+}

package/dist/statistics/ExpMovingAverage.d.ts

@@ -0,0 +1,21 @@
+import type { StreamingStatistic } from "./StreamingStatistic.js";
+/**
+ * Exponential moving average over a sample stream. During the warmup
+ * phase (the first {@link warmupWindow} samples) a simple arithmetic mean is
+ * used. After warmup, samples are blended using an exponential decay factor
+ * derived from the configured window size.
+ */
+export declare class ExpMovingAverage implements StreamingStatistic {
+    private value;
+    private sum;
+    private count;
+    private readonly window;
+    private readonly warmupWindow;
+    constructor(window: number, warmupWindow: number);
+    addSample(sample: number): number;
+    private static factor;
+    get currentValue(): number;
+    reset(): void;
+    update(operation: (current: number) => number): void;
+}
+//# sourceMappingURL=ExpMovingAverage.d.ts.map

package/dist/statistics/ExpMovingAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpMovingAverage.d.ts","sourceRoot":"","sources":["../../src/statistics/ExpMovingAverage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;GAKG;AACH,qBAAa,gBAAiB,YAAW,kBAAkB;IACzD,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,GAAG,CAAK;IAChB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAE1B,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;IAKhD,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAYjC,OAAO,CAAC,MAAM,CAAC,MAAM;IAIrB,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,KAAK,IAAI,IAAI;IAMb,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI;CAGrD"}

package/dist/statistics/ExpMovingAverage.js

@@ -0,0 +1,43 @@
+/**
+ * Exponential moving average over a sample stream. During the warmup
+ * phase (the first {@link warmupWindow} samples) a simple arithmetic mean is
+ * used. After warmup, samples are blended using an exponential decay factor
+ * derived from the configured window size.
+ */
+export class ExpMovingAverage {
+    value = 0;
+    sum = 0;
+    count = 0;
+    window;
+    warmupWindow;
+    constructor(window, warmupWindow) {
+        this.window = window;
+        this.warmupWindow = warmupWindow;
+    }
+    addSample(sample) {
+        if (this.count < this.warmupWindow) {
+            this.count++;
+            this.sum += sample;
+            this.value = this.sum / this.count;
+        }
+        else {
+            const factor = ExpMovingAverage.factor(this.window);
+            this.value = this.value * (1 - factor) + sample * factor;
+        }
+        return this.value;
+    }
+    static factor(n) {
+        return 2.0 / (n + 1);
+    }
+    get currentValue() {
+        return this.value;
+    }
+    reset() {
+        this.value = 0;
+        this.count = 0;
+        this.sum = 0;
+    }
+    update(operation) {
+        this.value = operation(this.value);
+    }
+}

package/dist/statistics/MinimumValue.d.ts

@@ -0,0 +1,12 @@
+import type { StreamingStatistic } from "./StreamingStatistic.js";
+/**
+ * Tracks the minimum value seen across all samples.
+ */
+export declare class MinimumValue implements StreamingStatistic {
+    private value;
+    addSample(sample: number): number;
+    get currentValue(): number;
+    reset(): void;
+    update(operation: (current: number) => number): void;
+}
+//# sourceMappingURL=MinimumValue.d.ts.map

package/dist/statistics/MinimumValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MinimumValue.d.ts","sourceRoot":"","sources":["../../src/statistics/MinimumValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;GAEG;AACH,qBAAa,YAAa,YAAW,kBAAkB;IACrD,OAAO,CAAC,KAAK,CAAY;IAEzB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAOjC,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,KAAK,IAAI,IAAI;IAIb,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI;CAIrD"}

package/dist/statistics/MinimumValue.js

@@ -0,0 +1,22 @@
+/**
+ * Tracks the minimum value seen across all samples.
+ */
+export class MinimumValue {
+    value = Infinity;
+    addSample(sample) {
+        if (sample < this.value) {
+            this.value = sample;
+        }
+        return this.value;
+    }
+    get currentValue() {
+        return this.value;
+    }
+    reset() {
+        this.value = Infinity;
+    }
+    update(operation) {
+        const current = this.value;
+        this.value = Math.min(current, operation(current));
+    }
+}

package/dist/statistics/MostRecentValue.d.ts

@@ -0,0 +1,12 @@
+import type { StreamingStatistic } from "./StreamingStatistic.js";
+/**
+ * Holds only the most recent sample value.
+ */
+export declare class MostRecentValue implements StreamingStatistic {
+    private value;
+    addSample(sample: number): number;
+    get currentValue(): number;
+    reset(): void;
+    update(operation: (current: number) => number): void;
+}
+//# sourceMappingURL=MostRecentValue.d.ts.map

package/dist/statistics/MostRecentValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MostRecentValue.d.ts","sourceRoot":"","sources":["../../src/statistics/MostRecentValue.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;GAEG;AACH,qBAAa,eAAgB,YAAW,kBAAkB;IACxD,OAAO,CAAC,KAAK,CAAuB;IAEpC,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAKjC,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED,KAAK,IAAI,IAAI;IAIb,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI;CAKrD"}

package/dist/statistics/MostRecentValue.js

@@ -0,0 +1,21 @@
+/**
+ * Holds only the most recent sample value.
+ */
+export class MostRecentValue {
+    value = null;
+    addSample(sample) {
+        this.value = sample;
+        return sample;
+    }
+    get currentValue() {
+        return this.value ?? 0;
+    }
+    reset() {
+        this.value = null;
+    }
+    update(operation) {
+        if (this.value !== null) {
+            this.value = operation(this.value);
+        }
+    }
+}

package/dist/statistics/StreamingStatistic.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Stateful summary of a numeric sample stream (e.g. minimum, last value, EMA).
+ */
+export interface StreamingStatistic {
+    /**
+     * Add a single sample and update the internal state.
+     * @param sample The sample value to add
+     * @returns The updated statistic value
+     */
+    addSample(sample: number): number;
+    /** Current statistic value. */
+    get currentValue(): number;
+    /**
+     * Reset the internal state as if no samples were ever added.
+     */
+    reset(): void;
+    /**
+     * Apply a transformation to the current value.
+     *
+     * The callback's return value may not be always be used as-is, specifically
+     * if doing so would violate the semantics of the statistic. (E.g., if the
+     * statistic is a minimum, and the callback returns a value greater than the
+     * current minimum, the statistic will not be updated.) For example, if the
+     * statistic is a minimum, and the callback returns a value greater than the
+     * current minimum, the statistic will not be updated.
+     */
+    update(operation: (current: number) => number): void;
+}
+//# sourceMappingURL=StreamingStatistic.d.ts.map

package/dist/statistics/StreamingStatistic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingStatistic.d.ts","sourceRoot":"","sources":["../../src/statistics/StreamingStatistic.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAElC,+BAA+B;IAC/B,IAAI,YAAY,IAAI,MAAM,CAAC;IAE3B;;OAEG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;;;;;;;;OASG;IACH,MAAM,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,CAAC;CACtD"}

package/dist/statistics/StreamingStatistic.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Only expects integer inputs. Always floors the result to an int.
+ * Always returns >= 1. So, squareRoot(0) = 1.
+ */
+export declare function squareRoot(n: number): number;
+/**
+ * Create a function that returns: max(baseline, squareRoot(n))
+ */
+export declare function squareRootWithBaseline(baseline: number): (n: number) => number;
+//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AASA;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAE9E"}

package/dist/utils/index.js

@@ -0,0 +1,19 @@
+/**
+ * Utility function used by limiters to calculate thresholds using the square
+ * root of the current limit. Values up to 1000 are pre-computed because the
+ * square root operation can be slow.
+ */
+const sqrtLookup = Array.from({ length: 1000 }, (_, i) => Math.max(1, Math.floor(Math.sqrt(i))));
+/**
+ * Only expects integer inputs. Always floors the result to an int.
+ * Always returns >= 1. So, squareRoot(0) = 1.
+ */
+export function squareRoot(n) {
+    return n < 1000 ? sqrtLookup[n] : Math.floor(Math.sqrt(n));
+}
+/**
+ * Create a function that returns: max(baseline, squareRoot(n))
+ */
+export function squareRootWithBaseline(baseline) {
+    return (n) => Math.max(baseline, squareRoot(n));
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "adaptive-concurrency",
+  "description": "A TypeScript adaptation of Netflix's concurrency-limits library.",
+  "keywords": [
+    "concurrency",
+    "adaptive concurrency",
+    "limits",
+    "rate limiting",
+    "dynamic rate limiting"
+  ],
+  "author": "Ethan Resnick <ethan.resnick@gmail.com>",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node --import tsx --test \"src/**/*.test.ts\""
+  },
+  "devDependencies": {
+    "tsx": "^4.19.0",
+    "typescript": "next"
+  }
+}