effect 2.3.2 → 2.3.4

package/dist/esm/internal/rateLimiter.js

@@ -1,12 +1,42 @@
+import * as Duration from "../Duration.js";
 import * as Effect from "../Effect.js";
-import * as SynchronizedRef from "../SynchronizedRef.js";
+import * as FiberRef from "../FiberRef.js";
+import { globalValue } from "../GlobalValue.js";
 /** @internal */
-export const make = (limit, window) => Effect.gen(function* (_) {
-  const scope = yield* _(Effect.scope);
+export const make = ({
+  algorithm = "token-bucket",
+  interval,
+  limit
+}) => {
+  switch (algorithm) {
+    case "fixed-window":
+      {
+        return fixedWindow(limit, interval);
+      }
+    case "token-bucket":
+      {
+        return tokenBucket(limit, interval);
+      }
+  }
+};
+const tokenBucket = (limit, window) => Effect.gen(function* (_) {
+  const millisPerToken = Math.ceil(Duration.toMillis(window) / limit);
   const semaphore = yield* _(Effect.makeSemaphore(limit));
-  const ref = yield* _(SynchronizedRef.make(false));
-  const reset = SynchronizedRef.updateEffect(ref, running => running ? Effect.succeed(true) : Effect.sleep(window).pipe(Effect.zipRight(SynchronizedRef.set(ref, false)), Effect.zipRight(semaphore.releaseAll), Effect.forkIn(scope), Effect.interruptible, Effect.as(true)));
-  const take = Effect.zipRight(semaphore.take(1), reset);
+  const latch = yield* _(Effect.makeSemaphore(0));
+  const refill = Effect.sleep(millisPerToken).pipe(Effect.zipRight(latch.releaseAll), Effect.zipRight(semaphore.release(1)), Effect.flatMap(free => free === limit ? Effect.unit : refill));
+  yield* _(latch.take(1), Effect.zipRight(refill), Effect.forever, Effect.forkScoped, Effect.interruptible);
+  const take = Effect.uninterruptibleMask(restore => Effect.flatMap(FiberRef.get(currentCost), cost => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))));
   return effect => Effect.zipRight(take, effect);
 });
+const fixedWindow = (limit, window) => Effect.gen(function* (_) {
+  const semaphore = yield* _(Effect.makeSemaphore(limit));
+  const latch = yield* _(Effect.makeSemaphore(0));
+  yield* _(latch.take(1), Effect.zipRight(Effect.sleep(window)), Effect.zipRight(latch.releaseAll), Effect.zipRight(semaphore.releaseAll), Effect.forever, Effect.forkScoped, Effect.interruptible);
+  const take = Effect.uninterruptibleMask(restore => Effect.flatMap(FiberRef.get(currentCost), cost => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))));
+  return effect => Effect.zipRight(take, effect);
+});
+/** @internal */
+const currentCost = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/RateLimiter/currentCost"), () => FiberRef.unsafeMake(1));
+/** @internal */
+export const withCost = cost => Effect.locally(currentCost, cost);
 //# sourceMappingURL=rateLimiter.js.map

package/dist/esm/internal/rateLimiter.js.map

@@ -1 +1 @@
-{"version":3,"file":"rateLimiter.js","names":["Effect","SynchronizedRef","make","limit","window","gen","_","scope","semaphore","makeSemaphore","ref","reset","updateEffect","running","succeed","sleep","pipe","zipRight","set","releaseAll","forkIn","interruptible","as","take","effect"],"sources":["../../../src/internal/rateLimiter.ts"],"sourcesContent":[null],"mappings":"AACA,OAAO,KAAKA,MAAM,MAAM,cAAc;AAGtC,OAAO,KAAKC,eAAe,MAAM,uBAAuB;AAExD;AACA,OAAO,MAAMC,IAAI,GAAGA,CAACC,KAAa,EAAEC,MAAqB,KAKvDJ,MAAM,CAACK,GAAG,CAAC,WAAUC,CAAC;EACpB,MAAMC,KAAK,GAAG,OAAOD,CAAC,CAACN,MAAM,CAACO,KAAK,CAAC;EACpC,MAAMC,SAAS,GAAG,OAAOF,CAAC,CAACN,MAAM,CAACS,aAAa,CAACN,KAAK,CAAC,CAAC;EACvD,MAAMO,GAAG,GAAG,OAAOJ,CAAC,CAACL,eAAe,CAACC,IAAI,CAAC,KAAK,CAAC,CAAC;EACjD,MAAMS,KAAK,GAAGV,eAAe,CAACW,YAAY,CACxCF,GAAG,EACFG,OAAO,IACNA,OAAO,GAAGb,MAAM,CAACc,OAAO,CAAC,IAAI,CAAC,GAAGd,MAAM,CAACe,KAAK,CAACX,MAAM,CAAC,CAACY,IAAI,CACxDhB,MAAM,CAACiB,QAAQ,CAAChB,eAAe,CAACiB,GAAG,CAACR,GAAG,EAAE,KAAK,CAAC,CAAC,EAChDV,MAAM,CAACiB,QAAQ,CAACT,SAAS,CAACW,UAAU,CAAC,EACrCnB,MAAM,CAACoB,MAAM,CAACb,KAAK,CAAC,EACpBP,MAAM,CAACqB,aAAa,EACpBrB,MAAM,CAACsB,EAAE,CAAC,IAAI,CAAC,CAChB,CACJ;EACD,MAAMC,IAAI,GAAGvB,MAAM,CAACiB,QAAQ,CAACT,SAAS,CAACe,IAAI,CAAC,CAAC,CAAC,EAAEZ,KAAK,CAAC;EACtD,OAAQa,MAAM,IAAKxB,MAAM,CAACiB,QAAQ,CAACM,IAAI,EAAEC,MAAM,CAAC;AAClD,CAAC,CAAC"}
+{"version":3,"file":"rateLimiter.js","names":["Duration","Effect","FiberRef","globalValue","make","algorithm","interval","limit","fixedWindow","tokenBucket","window","gen","_","millisPerToken","Math","ceil","toMillis","semaphore","makeSemaphore","latch","refill","sleep","pipe","zipRight","releaseAll","release","flatMap","free","unit","take","forever","forkScoped","interruptible","uninterruptibleMask","restore","get","currentCost","cost","effect","Symbol","for","unsafeMake","withCost","locally"],"sources":["../../../src/internal/rateLimiter.ts"],"sourcesContent":[null],"mappings":"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"}

package/dist/esm/internal/version.js

@@ -1,2 +1,2 @@
-export const moduleVersion = "2.3.2";
+export const moduleVersion = "2.3.4";
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "Functional programming in TypeScript",
   "license": "MIT",
   "repository": {

package/src/Effect.ts

@@ -4673,10 +4673,14 @@ export interface Permit {
  * @since 2.0.0
  */
 export interface Semaphore {
+  /** when the given amount of permits are available, run the effect and release the permits when finished */
   withPermits(permits: number): <A, E, R>(self: Effect<A, E, R>) => Effect<A, E, R>
+  /** take the given amount of permits, suspending if they are not yet available */
   take(permits: number): Effect<number>
-  release(permits: number): Effect<void>
-  releaseAll: Effect<void>
+  /** release the given amount of permits, and return the resulting available permits */
+  release(permits: number): Effect<number>
+  /** release all the taken permits, and return the resulting available permits */
+  releaseAll: Effect<number>
 }
 
 /**

package/src/RateLimiter.ts

@@ -1,9 +1,5 @@
 /**
- * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
- *
- * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
- *
- * Calls are queued up in an unbounded queue until capacity becomes available.
+ * Limits the number of calls to a resource to a maximum amount in some interval.
  *
  * @since 2.0.0
  */
@@ -13,11 +9,10 @@ import * as internal from "./internal/rateLimiter.js"
 import type { Scope } from "./Scope.js"
 
 /**
- * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
- *
- * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
+ * Limits the number of calls to a resource to a maximum amount in some interval.
  *
- * Calls are queued up in an unbounded queue until capacity becomes available.
+ * Note that only the moment of starting the effect is rate limited: the number
+ * of concurrent executions is not bounded.
  *
  * @since 2.0.0
  * @category models
@@ -27,11 +22,113 @@ export interface RateLimiter {
 }
 
 /**
+ * @since 2.0.0
+ */
+export declare namespace RateLimiter {
+  /**
+   * @since 2.0.0
+   * @category models
+   */
+  export interface Options {
+    /**
+     * The maximum number of requests that should be allowed.
+     */
+    readonly limit: number
+    /**
+     * The interval to utilize for rate-limiting requests. The semantics of the
+     * specified `interval` vary depending on the chosen `algorithm`:
+     *
+     * `token-bucket`: The maximum number of requests will be spread out over
+     * the provided interval if no tokens are available.
+     *
+     * For example, for a `RateLimiter` using the `token-bucket` algorithm with
+     * a `limit` of `10` and an `interval` of `1 seconds`, `1` request can be
+     * made every `100 millis`.
+     *
+     * `fixed-window`: The maximum number of requests will be reset during each
+     * interval. For example, for a `RateLimiter` using the `fixed-window`
+     * algorithm with a `limit` of `10` and an `interval` of `1 seconds`, a
+     * maximum of `10` requests can be made each second.
+     */
+    readonly interval: DurationInput
+    /**
+     * The algorithm to utilize for rate-limiting requests.
+     *
+     * Defaults to `token-bucket`.
+     */
+    readonly algorithm?: "fixed-window" | "token-bucket"
+  }
+}
+
+/**
+ * Constructs a new `RateLimiter` which will utilize the specified algorithm
+ * to limit requests (defaults to `token-bucket`).
+ *
+ * Notes
+ * - Only the moment of starting the effect is rate limited. The number of concurrent executions is not bounded.
+ * - Instances of `RateLimiter` can be composed.
+ * - The "cost" per effect can be changed. See {@link withCost}
+ *
+ * @example
+ * import { Effect, RateLimiter } from "effect";
+ * import { compose } from "effect/Function"
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function* ($) {
+ *     const perMinuteRL = yield* $(RateLimiter.make({ limit: 30, interval: "1 minutes" }))
+ *     const perSecondRL = yield* $(RateLimiter.make({ limit: 2, interval: "1 seconds" }))
+ *
+ *     // This rate limiter respects both the 30 calls per minute
+ *     // and the 2 calls per second constraints.
+ *      const rateLimit = compose(perMinuteRL, perSecondRL)
+ *
+ *     // simulate repeated calls
+ *     for (let n = 0; n < 100; n++) {
+ *       // wrap the effect we want to limit with rateLimit
+ *       yield* $(rateLimit(Effect.log("Calling RateLimited Effect")));
+ *     }
+ *   })
+ * );
+ *
  * @since 2.0.0
  * @category constructors
  */
-export const make: (limit: number, window: DurationInput) => Effect<
-  RateLimiter,
-  never,
-  Scope
-> = internal.make
+export const make: (options: RateLimiter.Options) => Effect<RateLimiter, never, Scope> = internal.make
+
+/**
+ * Alters the per-effect cost of the rate-limiter.
+ *
+ * This can be used for "credit" based rate-limiting where different API endpoints
+ * cost a different number of credits within a time window.
+ * Eg: 1000 credits / hour, where a query costs 1 credit and a mutation costs 5 credits.
+ *
+ * @example
+ * import { Effect, RateLimiter } from "effect";
+ * import { compose } from "effect/Function";
+ *
+ * const program = Effect.scoped(
+ *   Effect.gen(function* ($) {
+ *     // Create a rate limiter that has an hourly limit of 1000 credits
+ *     const rateLimiter = yield* $(RateLimiter.make({ limit: 1000, interval: "1 hours" }));
+ *     // Query API costs 1 credit per call ( 1 is the default cost )
+ *     const queryAPIRL = compose(rateLimiter, RateLimiter.withCost(1));
+ *     // Mutation API costs 5 credits per call
+ *     const mutationAPIRL = compose(rateLimiter, RateLimiter.withCost(5));
+
+ *     // Use the pre-defined rate limiters
+ *     yield* $(queryAPIRL(Effect.log("Sample Query")));
+ *     yield* $(mutationAPIRL(Effect.log("Sample Mutation")));
+ *
+ *     // Or set a cost on-the-fly
+ *     yield* $(
+ *       rateLimiter(Effect.log("Another query with a different cost")).pipe(
+ *         RateLimiter.withCost(3)
+ *       )
+ *     );
+ *   })
+ * );
+ *
+ * @since 2.0.0
+ * @category combinators
+ */
+export const withCost: (cost: number) => <A, E, R>(effect: Effect<A, E, R>) => Effect<A, E, R> = internal.withCost

package/src/index.ts

@@ -545,11 +545,7 @@ export * as Queue from "./Queue.js"
 export * as Random from "./Random.js"
 
 /**
- * Limits the number of calls to a resource to a maximum amount in some interval using the token bucket algorithm.
- *
- * Note that only the moment of starting the effect is rate limited: the number of concurrent executions is not bounded.
- *
- * Calls are queued up in an unbounded queue until capacity becomes available.
+ * Limits the number of calls to a resource to a maximum amount in some interval.
  *
  * @since 2.0.0
  */

package/src/internal/effect/circular.ts

@@ -35,7 +35,7 @@ import * as supervisor from "../supervisor.js"
 
 /** @internal */
 class Semaphore {
-  public waiters = new Set<() => boolean>()
+  public waiters = new Set<() => void>()
   public taken = 0
 
   constructor(readonly permits: number) {}
@@ -49,12 +49,11 @@ class Semaphore {
       if (this.free < n) {
         const observer = () => {
           if (this.free < n) {
-            return false
+            return
           }
           this.waiters.delete(observer)
           this.taken += n
           resume(core.succeed(n))
-          return true
         }
         this.waiters.add(observer)
         return Either.left(core.sync(() => {
@@ -65,22 +64,25 @@ class Semaphore {
       return Either.right(core.succeed(n))
     })
 
-  readonly updateTaken = (f: (n: number) => number): Effect.Effect<void> =>
+  readonly updateTaken = (f: (n: number) => number): Effect.Effect<number> =>
     core.withFiberRuntime((fiber) => {
       this.taken = f(this.taken)
-      fiber.getFiberRef(currentScheduler).scheduleTask(() => {
-        const iter = this.waiters.values()
-        let item = iter.next()
-        while (item.done === false && item.value() === true) {
-          item = iter.next()
-        }
-      }, fiber.getFiberRef(core.currentSchedulingPriority))
-      return core.unit
+      if (this.waiters.size > 0) {
+        fiber.getFiberRef(currentScheduler).scheduleTask(() => {
+          const iter = this.waiters.values()
+          let item = iter.next()
+          while (item.done === false && this.free > 0) {
+            item.value()
+            item = iter.next()
+          }
+        }, fiber.getFiberRef(core.currentSchedulingPriority))
+      }
+      return core.succeed(this.free)
     })
 
-  readonly release = (n: number): Effect.Effect<void> => this.updateTaken((taken) => taken - n)
+  readonly release = (n: number): Effect.Effect<number> => this.updateTaken((taken) => taken - n)
 
-  readonly releaseAll: Effect.Effect<void> = this.updateTaken((_) => 0)
+  readonly releaseAll: Effect.Effect<number> = this.updateTaken((_) => 0)
 
   readonly withPermits = (n: number) => <R, E, A>(self: Effect.Effect<R, E, A>) =>
     core.uninterruptibleMask((restore) =>

package/src/internal/rateLimiter.ts

@@ -1,30 +1,92 @@
 import type { DurationInput } from "../Duration.js"
+import * as Duration from "../Duration.js"
 import * as Effect from "../Effect.js"
-import type { RateLimiter } from "../RateLimiter.js"
-import type { Scope } from "../Scope.js"
-import * as SynchronizedRef from "../SynchronizedRef.js"
+import * as FiberRef from "../FiberRef.js"
+import { globalValue } from "../GlobalValue.js"
+import type * as RateLimiter from "../RateLimiter.js"
+import type * as Scope from "../Scope.js"
 
 /** @internal */
-export const make = (limit: number, window: DurationInput): Effect.Effect<
-  RateLimiter,
+export const make = ({
+  algorithm = "token-bucket",
+  interval,
+  limit
+}: RateLimiter.RateLimiter.Options): Effect.Effect<
+  RateLimiter.RateLimiter,
   never,
-  Scope
+  Scope.Scope
+> => {
+  switch (algorithm) {
+    case "fixed-window": {
+      return fixedWindow(limit, interval)
+    }
+    case "token-bucket": {
+      return tokenBucket(limit, interval)
+    }
+  }
+}
+
+const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
+  RateLimiter.RateLimiter,
+  never,
+  Scope.Scope
 > =>
   Effect.gen(function*(_) {
-    const scope = yield* _(Effect.scope)
+    const millisPerToken = Math.ceil(Duration.toMillis(window) / limit)
     const semaphore = yield* _(Effect.makeSemaphore(limit))
-    const ref = yield* _(SynchronizedRef.make(false))
-    const reset = SynchronizedRef.updateEffect(
-      ref,
-      (running) =>
-        running ? Effect.succeed(true) : Effect.sleep(window).pipe(
-          Effect.zipRight(SynchronizedRef.set(ref, false)),
-          Effect.zipRight(semaphore.releaseAll),
-          Effect.forkIn(scope),
-          Effect.interruptible,
-          Effect.as(true)
-        )
+    const latch = yield* _(Effect.makeSemaphore(0))
+    const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
+      Effect.zipRight(latch.releaseAll),
+      Effect.zipRight(semaphore.release(1)),
+      Effect.flatMap((free) => free === limit ? Effect.unit : refill)
+    )
+    yield* _(
+      latch.take(1),
+      Effect.zipRight(refill),
+      Effect.forever,
+      Effect.forkScoped,
+      Effect.interruptible
+    )
+    const take = Effect.uninterruptibleMask((restore) =>
+      Effect.flatMap(
+        FiberRef.get(currentCost),
+        (cost) => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))
+      )
     )
-    const take = Effect.zipRight(semaphore.take(1), reset)
     return (effect) => Effect.zipRight(take, effect)
   })
+
+const fixedWindow = (limit: number, window: DurationInput): Effect.Effect<
+  RateLimiter.RateLimiter,
+  never,
+  Scope.Scope
+> =>
+  Effect.gen(function*(_) {
+    const semaphore = yield* _(Effect.makeSemaphore(limit))
+    const latch = yield* _(Effect.makeSemaphore(0))
+    yield* _(
+      latch.take(1),
+      Effect.zipRight(Effect.sleep(window)),
+      Effect.zipRight(latch.releaseAll),
+      Effect.zipRight(semaphore.releaseAll),
+      Effect.forever,
+      Effect.forkScoped,
+      Effect.interruptible
+    )
+    const take = Effect.uninterruptibleMask((restore) =>
+      Effect.flatMap(
+        FiberRef.get(currentCost),
+        (cost) => Effect.zipRight(restore(semaphore.take(cost)), latch.release(1))
+      )
+    )
+    return (effect) => Effect.zipRight(take, effect)
+  })
+
+/** @internal */
+const currentCost = globalValue(
+  Symbol.for("effect/RateLimiter/currentCost"),
+  () => FiberRef.unsafeMake(1)
+)
+
+/** @internal */
+export const withCost = (cost: number) => Effect.locally(currentCost, cost)

package/src/internal/version.ts

@@ -1 +1 @@
-export const moduleVersion = "2.3.2"
+export const moduleVersion = "2.3.4"