@lunora/ratelimit 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/packem_shared/RateLimiter-CeElVjB0.mjs

@@ -1,122 +0,0 @@
-import { availableAt, evaluate } from './availableAt-D5GyJtxT.mjs';
-import RateLimitError from './RateLimitError-YOUfRzXc.mjs';
-import { createMemoryStore } from './createDbStore-L1kD1g1n.mjs';
-
-const storageKeyFor = (name, key) => key === void 0 ? encodeURIComponent(name) : `${encodeURIComponent(name)}:${encodeURIComponent(key)}`;
-const hashToShard = (storageKey, shards) => {
-  let hash = 0;
-  for (let index = 0; index < storageKey.length; index += 1) {
-    hash = hash * 31 + storageKey.charCodeAt(index) | 0;
-  }
-  return Math.abs(hash) % shards;
-};
-const perShardConfig = (config, shards) => shards > 1 ? { ...config, capacity: (config.capacity ?? config.rate) / shards, rate: config.rate / shards } : config;
-const shardKeysFor = (name, key, shards) => {
-  const base = storageKeyFor(name, key);
-  return shards > 1 ? Array.from({ length: shards }, (_, shard) => `${base}#${String(shard)}`) : [base];
-};
-class RateLimiter {
-  config;
-  denyList;
-  normalize;
-  now;
-  store;
-  constructor(options) {
-    this.config = options.config;
-    this.denyList = new Set(options.denyList);
-    this.normalize = options.normalize ?? ((key) => key);
-    this.now = options.now ?? Date.now;
-    this.store = options.store ?? createMemoryStore();
-    for (const [name, config] of Object.entries(this.config)) {
-      if (config.shards !== void 0 && (!Number.isInteger(config.shards) || config.shards < 1)) {
-        throw new Error(`rate limit "${name}": shards must be a positive integer`);
-      }
-      if (!Number.isFinite(config.period) || config.period <= 0) {
-        throw new Error(`rate limit "${name}": period must be a positive number`);
-      }
-      if (!Number.isFinite(config.rate) || config.rate <= 0) {
-        throw new Error(`rate limit "${name}": rate must be a positive number`);
-      }
-      if (config.capacity !== void 0 && (!Number.isFinite(config.capacity) || config.capacity < 0)) {
-        throw new Error(`rate limit "${name}": capacity must be a non-negative number`);
-      }
-    }
-  }
-  /** Peek at whether a request would be permitted without consuming. */
-  async check(name, args = {}) {
-    return this.run(name, args, false);
-  }
-  /**
-   * Read the current config and the units admittable right now for a
-   * `(name, key)` pair. The value is projected forward to the current clock
-   * (token-bucket refill, fixed-window rollover, sliding-window decay), not
-   * the last persisted figure. For a sharded limit it reads only the single
-   * shard `limit()`/`run()` would route this key to — the sibling shards are
-   * never touched by this key, so summing them would over-report.
-   */
-  async getValue(name, args = {}) {
-    const config = this.resolve(name);
-    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);
-    return { config, ts: current.ts, value: current.value };
-  }
-  /** Consume capacity. Returns the outcome, or throws when `args.throws` is set. */
-  async limit(name, args = {}) {
-    return this.run(name, args, true);
-  }
-  /** Clear accounting for a `(name, key)` pair (e.g. on successful login). */
-  async reset(name, args = {}) {
-    const shards = this.resolve(name).shards ?? 1;
-    const normalizedKey = args.key === void 0 ? void 0 : this.normalize(args.key);
-    await Promise.all(shardKeysFor(name, normalizedKey, shards).map((storageKey) => Promise.resolve(this.store.delete(storageKey))));
-  }
-  resolve(name) {
-    const config = this.config[name];
-    if (!config) {
-      throw new Error(`rate limit "${name}" is not configured`);
-    }
-    return config;
-  }
-  async run(name, args, consume) {
-    const config = this.resolve(name);
-    const normalizedKey = args.key === void 0 ? void 0 : this.normalize(args.key);
-    if (normalizedKey !== void 0 && (this.denyList.has(normalizedKey) || this.denyList.has(args.key))) {
-      const status2 = { ok: false, reason: "deny", retryAfter: Number.POSITIVE_INFINITY };
-      if (args.throws) {
-        throw new RateLimitError(status2);
-      }
-      return status2;
-    }
-    const count = args.count ?? 1;
-    if (!Number.isInteger(count) || count <= 0) {
-      throw new Error(`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 prior = await this.store.get(storageKey);
-    const { status, value } = evaluate(perShardConfig(config, shards), prior, {
-      consume,
-      count,
-      now: this.now(),
-      reserve: args.reserve ?? false
-    });
-    if (value !== void 0) {
-      await this.store.set(storageKey, value);
-    }
-    if (!status.ok && args.throws) {
-      throw new RateLimitError(status);
-    }
-    return status;
-  }
-}
-
-export { RateLimiter };

package/dist/packem_shared/availableAt-D5GyJtxT.mjs

@@ -1,117 +0,0 @@
-const capacityOf = (config) => config.capacity ?? config.rate;
-const tokenBucket = (config, prior, options) => {
-  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);
-  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 };
-  }
-  const deficit = options.count - available;
-  const retryAfter = Math.ceil(deficit / ratePerMs);
-  if (options.consume && options.reserve && options.count <= capacity) {
-    return { status: { ok: true, retryAfter }, value: { ts: options.now, value: available - options.count } };
-  }
-  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;
-  }
-  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 };
-  }
-  const retryAfter = base.ts + config.period - options.now;
-  if (options.consume && options.reserve && options.count <= capacity) {
-    return { status: { ok: true, retryAfter }, value: { ts: base.ts, value: base.value - options.count } };
-  }
-  if (options.count > capacity) {
-    throw new Error(`@lunora/ratelimit: requested count ${String(options.count)} exceeds the limiter capacity ${String(capacity)}`);
-  }
-  return { status: { ok: false, reason: "rate", retryAfter }, value: void 0 };
-};
-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 estimated = previousCount * weight + currentCount;
-  const admit = estimated + options.count <= limit;
-  const retryAfter = () => {
-    const headroomNow = limit - currentCount - options.count;
-    if (previousCount > 0 && headroomNow >= 0) {
-      return Math.ceil(period - elapsed - headroomNow * period / previousCount);
-    }
-    const headroomNext = limit - options.count;
-    const intoNext = currentCount > 0 ? Math.max(0, period - headroomNext * period / currentCount) : 0;
-    return Math.ceil(period - elapsed + intoNext);
-  };
-  if (admit || options.consume && options.reserve && options.count <= limit) {
-    const value = { prev: previousCount, ts: windowStart, value: currentCount + options.count };
-    return { status: { ok: true, retryAfter: admit ? 0 : retryAfter() }, value: options.consume ? value : void 0 };
-  }
-  if (options.count > limit) {
-    throw new Error(`@lunora/ratelimit: requested count ${String(options.count)} exceeds the limiter capacity ${String(limit)}`);
-  }
-  return { status: { ok: false, reason: "rate", retryAfter: retryAfter() }, value: void 0 };
-};
-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) };
-  }
-  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;
-    }
-    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 };
-};
-const evaluate = (config, prior, options) => {
-  if (config.kind === "token bucket") {
-    return tokenBucket(config, prior, options);
-  }
-  if (config.kind === "sliding window") {
-    return slidingWindow(config, prior, options);
-  }
-  return fixedWindow(config, prior, options);
-};
-
-export { availableAt, evaluate };

package/dist/packem_shared/createDbStore-L1kD1g1n.mjs

@@ -1,103 +0,0 @@
-const createMemoryStore = () => {
-  const map = /* @__PURE__ */ new Map();
-  return {
-    delete: (storageKey) => {
-      map.delete(storageKey);
-    },
-    get: (storageKey) => map.get(storageKey),
-    set: (storageKey, value) => {
-      map.set(storageKey, value);
-    }
-  };
-};
-const runSql = (sql, query, ...params) => {
-  const runner = sql.exec;
-  return runner.call(sql, query, ...params).toArray();
-};
-const createSqlStore = (options) => {
-  const { sql } = options;
-  const table = options.table ?? "_lunora_rate_limits";
-  runSql(sql, `CREATE TABLE IF NOT EXISTS "${table}" (k TEXT PRIMARY KEY, value REAL NOT NULL, ts INTEGER NOT NULL, prev REAL)`);
-  return {
-    delete: (storageKey) => {
-      runSql(sql, `DELETE FROM "${table}" WHERE k = ?`, storageKey);
-    },
-    get: (storageKey) => {
-      const rows = runSql(sql, `SELECT value, ts, prev FROM "${table}" WHERE k = ?`, storageKey);
-      const row = rows[0];
-      if (!row) {
-        return void 0;
-      }
-      const value = { ts: row.ts, value: row.value };
-      if (row.prev !== null) {
-        value.prev = row.prev;
-      }
-      return value;
-    },
-    set: (storageKey, value) => {
-      runSql(
-        sql,
-        `INSERT INTO "${table}" (k, value, ts, prev) VALUES (?, ?, ?, ?) ON CONFLICT(k) DO UPDATE SET value = excluded.value, ts = excluded.ts, prev = excluded.prev`,
-        storageKey,
-        value.value,
-        value.ts,
-        // SQL bind: a missing `prev` must bind as SQL NULL, not undefined.
-        // eslint-disable-next-line unicorn/no-null -- SQLite/D1 bind parameters require null for a NULL column
-        value.prev ?? null
-      );
-    }
-  };
-};
-const createDatabaseStore = (options) => {
-  const { db } = options;
-  const table = options.table ?? "rateLimits";
-  const index = options.index ?? "by_key";
-  const keyField = options.keyField ?? "key";
-  const idCache = /* @__PURE__ */ new Map();
-  const find = async (storageKey) => {
-    const row = await db.query(table).withIndex(index, (q) => q.eq(keyField, storageKey)).first();
-    idCache.set(storageKey, row ? row._id : void 0);
-    return row;
-  };
-  const resolveId = async (storageKey) => {
-    if (idCache.has(storageKey)) {
-      return idCache.get(storageKey);
-    }
-    await find(storageKey);
-    return idCache.get(storageKey);
-  };
-  return {
-    delete: async (storageKey) => {
-      const id = await resolveId(storageKey);
-      if (id !== void 0) {
-        await db.delete(id);
-      }
-      idCache.delete(storageKey);
-    },
-    get: async (storageKey) => {
-      const row = await find(storageKey);
-      if (!row) {
-        return void 0;
-      }
-      const value = { ts: row.ts, value: row.value };
-      if (row.prev !== null && row.prev !== void 0) {
-        value.prev = row.prev;
-      }
-      return value;
-    },
-    set: async (storageKey, value) => {
-      const id = await resolveId(storageKey);
-      const document = { [keyField]: storageKey, ts: value.ts, value: value.value };
-      if (value.prev !== void 0) {
-        document.prev = value.prev;
-      }
-      if (id === void 0) {
-        idCache.set(storageKey, await db.insert(table, document));
-      } else {
-        await db.patch(id, document);
-      }
-    }
-  };
-};
-
-export { createDatabaseStore as createDbStore, createMemoryStore, createSqlStore };

package/dist/packem_shared/dbRateLimit-C4nMF5cN.mjs

@@ -1,7 +0,0 @@
-import { rateLimit } from './rateLimit-uQxVMZfh.mjs';
-import { RateLimiter } from './RateLimiter-CeElVjB0.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);
-
-export { databaseRateLimit as default };

package/dist/packem_shared/rateLimit-uQxVMZfh.mjs

@@ -1,42 +0,0 @@
-const STATUS_BY_REASON = {
-  deny: { code: "FORBIDDEN", status: 403 },
-  rate: { code: "TOO_MANY_REQUESTS", status: 429 }
-};
-const defaultMessage = (name, reason, retryAfter) => {
-  if (reason === "deny") {
-    return `request denied for "${name}"`;
-  }
-  return retryAfter === void 0 ? `rate limit "${name}" exceeded` : `rate limit "${name}" exceeded; retry after ${String(retryAfter)}ms`;
-};
-const rateLimit = (limiter, name, options = {}) => async ({ ctx, next }) => {
-  let status;
-  try {
-    const resolved = typeof limiter === "function" ? await limiter(ctx) : limiter;
-    status = await resolved.limit(name, { count: options.count, key: options.key?.(ctx) });
-  } catch (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
-    });
-  }
-  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
-    });
-  }
-  return next();
-};
-
-export { rateLimit };

package/dist/packem_shared/ratelimitPlugin-D5_-KV1T.mjs

@@ -1,12 +0,0 @@
-const ratelimitPlugin = (limiter) => {
-  return {
-    key: "ratelimit",
-    middleware: async ({ ctx, next }) => {
-      const resolved = typeof limiter === "function" ? await limiter(ctx) : limiter;
-      const existingApi = ctx.api ?? {};
-      return next({ ctx: { api: { ...existingApi, ratelimit: resolved } } });
-    }
-  };
-};
-
-export { ratelimitPlugin };