@lunora/ratelimit 1.0.0-alpha.5 → 1.0.0-alpha.7

package/dist/index.mjs

@@ -1,9 +1,9 @@
-export { availableAt, evaluate } from './packem_shared/availableAt-DN3Z6h_K.mjs';
-export { default as dbRateLimit } from './packem_shared/dbRateLimit-CXO7O3KO.mjs';
-export { default as RateLimitError } from './packem_shared/RateLimitError-53bWrDuJ.mjs';
-export { rateLimit } from './packem_shared/rateLimit-uQxVMZfh.mjs';
+export { availableAt, evaluate } from './packem_shared/availableAt-DQcuVfSA.mjs';
+export { default as dbRateLimit } from './packem_shared/dbRateLimit-WTU-e0r6.mjs';
+export { default as RateLimitError } from './packem_shared/RateLimitError-CiLy3DsZ.mjs';
+export { rateLimit } from './packem_shared/rateLimit-BBdG9GFo.mjs';
 export { ratelimitPlugin } from './packem_shared/ratelimitPlugin-D5_-KV1T.mjs';
-export { RateLimiter } from './packem_shared/RateLimiter-DQ9Peq-G.mjs';
+export { RateLimiter } from './packem_shared/RateLimiter-rDCxu_Nx.mjs';
 export { createDbStore, createMemoryStore, createSqlStore } from './packem_shared/createDbStore-L1kD1g1n.mjs';
 
 const VERSION = "0.0.0";

package/dist/packem_shared/{RateLimitError-53bWrDuJ.mjs → RateLimitError-CiLy3DsZ.mjs}

@@ -1,4 +1,5 @@
 import { LunoraError } from '@lunora/errors';
+import { STATUS_BY_REASON } from './rateLimit-BBdG9GFo.mjs';
 
 const describe = (status) => {
   if (status.reason === "deny") {
@@ -10,7 +11,8 @@ class RateLimitError extends LunoraError {
   reason;
   retryAfter;
   constructor(status, message) {
-    super("TOO_MANY_REQUESTS", message ?? describe(status), { name: "RateLimitError" });
+    const { code, status: httpStatus } = STATUS_BY_REASON[status.reason ?? "rate"];
+    super(code, message ?? describe(status), { name: "RateLimitError", status: httpStatus });
     this.reason = status.reason;
     this.retryAfter = status.retryAfter;
   }

package/dist/packem_shared/{RateLimiter-DQ9Peq-G.mjs → RateLimiter-rDCxu_Nx.mjs}

@@ -1,6 +1,6 @@
 import { LunoraError } from '@lunora/errors';
-import { availableAt, evaluate } from './availableAt-DN3Z6h_K.mjs';
-import RateLimitError from './RateLimitError-53bWrDuJ.mjs';
+import { availableAt, evaluate } from './availableAt-DQcuVfSA.mjs';
+import RateLimitError from './RateLimitError-CiLy3DsZ.mjs';
 import { createMemoryStore } from './createDbStore-L1kD1g1n.mjs';
 
 const storageKeyFor = (name, key) => key === void 0 ? encodeURIComponent(name) : `${encodeURIComponent(name)}:${encodeURIComponent(key)}`;
@@ -16,6 +16,10 @@ const shardKeysFor = (name, key, shards) => {
   const base = storageKeyFor(name, key);
   return shards > 1 ? Array.from({ length: shards }, (_, shard) => `${base}#${String(shard)}`) : [base];
 };
+const routeStorageKey = (name, key, shards) => {
+  const base = storageKeyFor(name, key);
+  return shards > 1 ? `${base}#${String(hashToShard(base, shards))}` : base;
+};
 class RateLimiter {
   config;
   denyList;
@@ -60,13 +64,8 @@ class RateLimiter {
     const shards = config.shards ?? 1;
     const now = this.now();
     const normalizedKey = args.key === void 0 ? void 0 : this.normalize(args.key);
-    if (shards > 1) {
-      const base = storageKeyFor(name, normalizedKey);
-      const storageKey = `${base}#${String(hashToShard(base, shards))}`;
-      const current2 = availableAt(perShardConfig(config, shards), await this.store.get(storageKey), now);
-      return { config, ts: current2.ts, value: current2.value };
-    }
-    const current = availableAt(config, await this.store.get(storageKeyFor(name, normalizedKey)), now);
+    const storageKey = routeStorageKey(name, normalizedKey, shards);
+    const current = availableAt(perShardConfig(config, shards), await this.store.get(storageKey), now);
     return { config, ts: current.ts, value: current.value };
   }
   /** Consume capacity. Returns the outcome, or throws when `args.throws` is set. */
@@ -101,8 +100,7 @@ class RateLimiter {
       throw new LunoraError("INTERNAL", `rate limit "${name}": count must be a positive integer`);
     }
     const shards = config.shards ?? 1;
-    const base = storageKeyFor(name, normalizedKey);
-    const storageKey = shards > 1 ? `${base}#${String(hashToShard(base, shards))}` : base;
+    const storageKey = routeStorageKey(name, normalizedKey, shards);
     const prior = await this.store.get(storageKey);
     const { status, value } = evaluate(perShardConfig(config, shards), prior, {
       consume,

package/dist/packem_shared/{availableAt-DN3Z6h_K.mjs → availableAt-DQcuVfSA.mjs}

@@ -1,12 +1,42 @@
 import { LunoraError } from '@lunora/errors';
 
 const capacityOf = (config) => config.capacity ?? config.rate;
-const tokenBucket = (config, prior, options) => {
+const projectTokenBucket = (config, prior, now) => {
   const capacity = capacityOf(config);
   const ratePerMs = config.rate / config.period;
-  const base = prior ?? { ts: options.now, value: capacity };
-  const elapsed = Math.max(0, options.now - base.ts);
-  const available = Math.min(capacity, base.value + elapsed * ratePerMs);
+  const base = prior ?? { ts: now, value: capacity };
+  const elapsed = Math.max(0, now - base.ts);
+  return { available: Math.min(capacity, base.value + elapsed * ratePerMs), capacity, ratePerMs };
+};
+const projectFixedWindow = (config, prior, now) => {
+  const start = config.start ?? 0;
+  const windowStart = start + Math.floor((now - start) / config.period) * config.period;
+  if (!prior || prior.ts < windowStart) {
+    let carry = 0;
+    if (prior && (prior.value < 0 || config.capacity !== void 0)) {
+      carry = prior.value;
+    }
+    return { ts: windowStart, value: Math.min(capacityOf(config), carry + config.rate) };
+  }
+  return { ts: prior.ts, value: prior.value };
+};
+const projectSlidingWindow = (config, prior, now) => {
+  const start = config.start ?? 0;
+  const windowStart = start + Math.floor((now - start) / config.period) * config.period;
+  const elapsed = now - windowStart;
+  const weight = (config.period - elapsed) / config.period;
+  let previousCount = 0;
+  let currentCount = 0;
+  if (prior?.ts === windowStart) {
+    previousCount = prior.prev ?? 0;
+    currentCount = prior.value;
+  } else if (prior?.ts === windowStart - config.period) {
+    previousCount = prior.value;
+  }
+  return { currentCount, elapsed, previousCount, weight, windowStart };
+};
+const tokenBucket = (config, prior, options) => {
+  const { available, capacity, ratePerMs } = projectTokenBucket(config, prior, options.now);
   if (available >= options.count) {
     const value = { ts: options.now, value: available - options.count };
     return { status: { ok: true, retryAfter: 0 }, value: options.consume ? value : void 0 };
@@ -16,19 +46,14 @@ const tokenBucket = (config, prior, options) => {
   if (options.consume && options.reserve && options.count <= capacity) {
     return { status: { ok: true, retryAfter }, value: { ts: options.now, value: available - options.count } };
   }
+  if (options.count > capacity) {
+    throw new LunoraError("INTERNAL", `@lunora/ratelimit: requested count ${String(options.count)} exceeds the limiter capacity ${String(capacity)}`);
+  }
   return { status: { ok: false, reason: "rate", retryAfter }, value: void 0 };
 };
 const fixedWindow = (config, prior, options) => {
   const capacity = capacityOf(config);
-  const start = config.start ?? 0;
-  const windowStart = start + Math.floor((options.now - start) / config.period) * config.period;
-  let base;
-  if (!prior || prior.ts < windowStart) {
-    const carry = prior && config.capacity !== void 0 ? Math.max(0, prior.value) : 0;
-    base = { ts: windowStart, value: Math.min(capacity, carry + config.rate) };
-  } else {
-    base = prior;
-  }
+  const base = projectFixedWindow(config, prior, options.now);
   if (base.value >= options.count) {
     const value = { ts: base.ts, value: base.value - options.count };
     return { status: { ok: true, retryAfter: 0 }, value: options.consume ? value : void 0 };
@@ -45,18 +70,7 @@ const fixedWindow = (config, prior, options) => {
 const slidingWindow = (config, prior, options) => {
   const limit = config.rate;
   const { period } = config;
-  const start = config.start ?? 0;
-  const windowStart = start + Math.floor((options.now - start) / period) * period;
-  const elapsed = options.now - windowStart;
-  const weight = (period - elapsed) / period;
-  let previousCount = 0;
-  let currentCount = 0;
-  if (prior?.ts === windowStart) {
-    previousCount = prior.prev ?? 0;
-    currentCount = prior.value;
-  } else if (prior?.ts === windowStart - period) {
-    previousCount = prior.value;
-  }
+  const { currentCount, elapsed, previousCount, weight, windowStart } = projectSlidingWindow(config, prior, options.now);
   const estimated = previousCount * weight + currentCount;
   const admit = estimated + options.count <= limit;
   const retryAfter = () => {
@@ -79,32 +93,13 @@ const slidingWindow = (config, prior, options) => {
 };
 const availableAt = (config, prior, now) => {
   if (config.kind === "token bucket") {
-    const capacity = capacityOf(config);
-    const ratePerMs = config.rate / config.period;
-    const base = prior ?? { ts: now, value: capacity };
-    const elapsed = Math.max(0, now - base.ts);
-    return { ts: now, value: Math.min(capacity, base.value + elapsed * ratePerMs) };
+    return { ts: now, value: projectTokenBucket(config, prior, now).available };
   }
-  const start = config.start ?? 0;
-  const windowStart = start + Math.floor((now - start) / config.period) * config.period;
   if (config.kind === "sliding window") {
-    const elapsed = now - windowStart;
-    const weight = (config.period - elapsed) / config.period;
-    let previousCount = 0;
-    let currentCount = 0;
-    if (prior?.ts === windowStart) {
-      previousCount = prior.prev ?? 0;
-      currentCount = prior.value;
-    } else if (prior?.ts === windowStart - config.period) {
-      previousCount = prior.value;
-    }
+    const { currentCount, previousCount, weight, windowStart } = projectSlidingWindow(config, prior, now);
     return { ts: windowStart, value: Math.max(0, config.rate - (previousCount * weight + currentCount)) };
   }
-  if (!prior || prior.ts < windowStart) {
-    const carry = prior && config.capacity !== void 0 ? Math.max(0, prior.value) : 0;
-    return { ts: windowStart, value: Math.min(capacityOf(config), carry + config.rate) };
-  }
-  return { ts: prior.ts, value: prior.value };
+  return projectFixedWindow(config, prior, now);
 };
 const evaluate = (config, prior, options) => {
   if (config.kind === "token bucket") {

package/dist/packem_shared/{dbRateLimit-CXO7O3KO.mjs → dbRateLimit-WTU-e0r6.mjs}

@@ -1,5 +1,5 @@
-import { rateLimit } from './rateLimit-uQxVMZfh.mjs';
-import { RateLimiter } from './RateLimiter-DQ9Peq-G.mjs';
+import { rateLimit } from './rateLimit-BBdG9GFo.mjs';
+import { RateLimiter } from './RateLimiter-rDCxu_Nx.mjs';
 import { createDbStore as createDatabaseStore } from './createDbStore-L1kD1g1n.mjs';
 
 const databaseRateLimit = (config, name, options = {}) => rateLimit((context) => new RateLimiter({ config, store: createDatabaseStore({ db: context.db, ...options.store }) }), name, options);

package/dist/packem_shared/{rateLimit-uQxVMZfh.mjs → rateLimit-BBdG9GFo.mjs}

@@ -1,3 +1,5 @@
+import { isLunoraError, isInternalCode, LunoraError } from '@lunora/errors';
+
 const STATUS_BY_REASON = {
   deny: { code: "FORBIDDEN", status: 403 },
   rate: { code: "TOO_MANY_REQUESTS", status: 429 }
@@ -14,29 +16,25 @@ const rateLimit = (limiter, name, options = {}) => async ({ ctx, next }) => {
     const resolved = typeof limiter === "function" ? await limiter(ctx) : limiter;
     status = await resolved.limit(name, { count: options.count, key: options.key?.(ctx) });
   } catch (error) {
+    if (isLunoraError(error) && isInternalCode(error.code)) {
+      throw error;
+    }
     console.error(`@lunora/ratelimit: rateLimit("${name}") threw; ${options.failOpen ? "failing open" : "failing closed"}`, error);
     if (options.failOpen) {
       return next();
     }
-    throw Object.assign(new Error(`rate limiter unavailable for "${name}"`), {
-      cause: error,
-      code: "SERVICE_UNAVAILABLE",
-      name: "LunoraError",
-      status: 503
-    });
+    throw new LunoraError("SERVICE_UNAVAILABLE", `rate limiter unavailable for "${name}"`, { cause: error, status: 503 });
   }
   if (!status.ok) {
     const reason = status.reason ?? "rate";
     const mapped = STATUS_BY_REASON[reason];
     const retryAfter = Number.isFinite(status.retryAfter) ? Math.ceil(status.retryAfter) : void 0;
-    throw Object.assign(new Error(options.message ?? defaultMessage(name, reason, retryAfter)), {
-      code: mapped.code,
-      name: "LunoraError",
-      retryAfter,
-      status: mapped.status
+    throw new LunoraError(mapped.code, options.message ?? defaultMessage(name, reason, retryAfter), {
+      status: mapped.status,
+      data: retryAfter === void 0 ? void 0 : { retryAfter }
     });
   }
   return next();
 };
 
-export { rateLimit };
+export { STATUS_BY_REASON, rateLimit };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/ratelimit",
-  "version": "1.0.0-alpha.5",
+  "version": "1.0.0-alpha.7",
   "description": "Rate limiting: token-bucket / fixed-window / sliding-window algorithms, deny list, sharding, pluggable stores, and procedure middleware",
   "keywords": [
     "cloudflare",
@@ -46,7 +46,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/errors": "1.0.0-alpha.2"
+    "@lunora/errors": "1.0.0-alpha.4"
   },
   "engines": {
     "node": "^22.15.0 || >=24.11.0"