Lorem Ipsum MCP Server

"use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.withCost = exports.make = void 0; var internal = _interopRequireWildcard(require("./internal/rateLimiter.js")); function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } /** * 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 * ```ts * 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 */ const make = exports.make = 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 * ```ts * 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 */ const withCost = exports.withCost = internal.withCost; //# sourceMappingURL=RateLimiter.js.map