hono-rate-limiter 0.1.0

package/README.md

@@ -0,0 +1,56 @@
+<h1 align="center"> <code>🔥hono-rate-limiter🔥</code> </h1>
+
+<div align="center">
+
+[![tests](https://img.shields.io/github/actions/workflow/status/rhinobase/hono-rate-limiter/test.yaml)](https://github.com/rhinobase/hono-rate-limiter/actions/workflows/test.yaml)
+[![npm version](https://img.shields.io/npm/v/hono-rate-limiter.svg)](https://npmjs.org/package/hono-rate-limiter "View this project on NPM")
+[![npm downloads](https://img.shields.io/npm/dm/hono-rate-limiter)](https://www.npmjs.com/package/hono-rate-limiter)
+[![license](https://img.shields.io/npm/l/hono-rate-limiter)](LICENSE)
+
+</div>
+
+Rate limiting middleware for [Hono](https://hono.dev/). Use to
+limit repeated requests to public APIs and/or endpoints such as password reset.
+
+## Usage
+
+```ts
+import { rateLimiter } from "hono-rate-limiter";
+
+const limiter = rateLimiter({
+  windowMs: 15 * 60 * 1000, // 15 minutes
+  limit: 100, // Limit each IP to 100 requests per `window` (here, per 15 minutes).
+  standardHeaders: "draft-7", // draft-6: `RateLimit-*` headers; draft-7: combined `RateLimit` header
+  // store: ... , // Redis, MemoryStore, etc. See below.
+});
+
+// Apply the rate limiting middleware to all requests.
+app.use(limiter);
+```
+
+# Data Stores
+
+Express-rate-limit supports external data stores to sychronize hit counts across multiple processes and servers.
+
+By default, `MemoryStore` is used. This one does not synchronize it’s state across instances. It’s simple to deploy, and often sufficient for basic abuse prevention, but will be inconnsistent across reboots or in deployments with multiple process or servers.
+
+Deployments requiring more consistently enforced rate limits should use an external store.
+
+Here is a list of stores:
+
+| Name        | Description                                                                                         |
+| ----------- | --------------------------------------------------------------------------------------------------- |
+| MemoryStore | (default) Simple in-memory option. Does not share state when app has multiple processes or servers. |
+| RedisStore  | A [Redis](https://redis.io/)-backed store, more suitable for large or demanding deployments.        |
+
+Take a look at this [guide](https://express-rate-limit.mintlify.app/guides/creating-a-store) if you wish to create your own store.
+
+# Contributing
+
+We would love to have more contributors involved!
+
+To get started, please read our [Contributing Guide](https://github.com/rhinobase/hono-rate-limiter/blob/main/CONTRIBUTING.md).
+
+# Credits
+
+The `hono-rate-limiter` project is heavily inspired by [express-rate-limit](https://github.com/express-rate-limit/express-rate-limit)

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "hono-rate-limiter",
+  "version": "0.1.0",
+  "type": "commonjs",
+  "dependencies": {
+    "@swc/helpers": "~0.5.2"
+  },
+  "peerDependencies": {
+    "hono": "^4.1.1"
+  },
+  "exports": {
+    ".": {
+      "default": "./src/index.js",
+      "types": "./src/index.d.ts"
+    },
+    "./redis": {
+      "default": "./src/redis/index.js",
+      "types": "./src/redis/index.d.ts"
+    }
+  },
+  "main": "./src/index.js"
+}

package/src/core/defaultKeyGenerator.d.ts

@@ -0,0 +1,2 @@
+import type { Context, Env, Input } from "hono";
+export declare function defaultKeyGenerator<E extends Env, P extends string, I extends Input>(c: Context<E, P, I>): string;

package/src/core/defaultKeyGenerator.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"defaultKeyGenerator",{enumerable:true,get:function(){return defaultKeyGenerator}});const _adapter=require("hono/adapter");function defaultKeyGenerator(c){const runtime=(0,_adapter.getRuntimeKey)();let key=null;switch(runtime){case"workerd":key=c.req.raw.headers.get("CF-Connecting-IP");break;case"fastly":key=c.req.raw.headers.get("Fastly-Client-IP");break;case"other":key=c.req.raw.headers.get("x-real-ip");break;default:break}return key!=null?key:""}

package/src/core/headers.d.ts

@@ -0,0 +1,28 @@
+import type { Context } from "hono";
+import type { RateLimitInfo } from "../types";
+/**
+ * Sets `RateLimit-*`` headers based on the sixth draft of the IETF specification.
+ * See https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-ratelimit-headers-06.
+ *
+ * @param context {Context} - The hono context object to set headers on.
+ * @param info {RateLimitInfo} - The rate limit info, used to set the headers.
+ * @param windowMs {number} - The window length.
+ */
+export declare const setDraft6Headers: (context: Context, info: RateLimitInfo, windowMs: number) => void;
+/**
+ * Sets `RateLimit` & `RateLimit-Policy` headers based on the seventh draft of the spec.
+ * See https://datatracker.ietf.org/doc/html/draft-ietf-httpapi-ratelimit-headers-07.
+ *
+ * @param context {Context} - The hono context object to set headers on.
+ * @param info {RateLimitInfo} - The rate limit info, used to set the headers.
+ * @param windowMs {number} - The window length.
+ */
+export declare const setDraft7Headers: (context: Context, info: RateLimitInfo, windowMs: number) => void;
+/**
+ * Sets the `Retry-After` header.
+ *
+ * @param context {Context} - The hono context object to set headers on.
+ * @param info {RateLimitInfo} - The rate limit info, used to set the headers.
+ * @param windowMs {number} - The window length.
+ */
+export declare const setRetryAfterHeader: (context: Context, info: RateLimitInfo, windowMs: number) => void;

package/src/core/headers.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:all[name]})}_export(exports,{setDraft6Headers:function(){return setDraft6Headers},setDraft7Headers:function(){return setDraft7Headers},setRetryAfterHeader:function(){return setRetryAfterHeader}});const getResetSeconds=(resetTime,windowMs)=>{let resetSeconds;if(resetTime){const deltaSeconds=Math.ceil((resetTime.getTime()-Date.now())/1e3);resetSeconds=Math.max(0,deltaSeconds)}else if(windowMs){resetSeconds=Math.ceil(windowMs/1e3)}return resetSeconds};const setDraft6Headers=(context,info,windowMs)=>{if(context.finalized)return;const windowSeconds=Math.ceil(windowMs/1e3);const resetSeconds=getResetSeconds(info.resetTime);context.header("RateLimit-Policy",`${info.limit};w=${windowSeconds}`);context.header("RateLimit-Limit",info.limit.toString());context.header("RateLimit-Remaining",info.remaining.toString());if(resetSeconds)context.header("RateLimit-Reset",resetSeconds.toString())};const setDraft7Headers=(context,info,windowMs)=>{if(context.finalized)return;const windowSeconds=Math.ceil(windowMs/1e3);const resetSeconds=getResetSeconds(info.resetTime,windowMs);context.header("RateLimit-Policy",`${info.limit};w=${windowSeconds}`);context.header("RateLimit",`limit=${info.limit}, remaining=${info.remaining}, reset=${resetSeconds}`)};const setRetryAfterHeader=(context,info,windowMs)=>{if(context.finalized)return;const resetSeconds=getResetSeconds(info.resetTime,windowMs);context.header("Retry-After",resetSeconds==null?void 0:resetSeconds.toString())};

package/src/core/index.d.ts

@@ -0,0 +1,13 @@
+import type { Env, Input } from "hono";
+import type { ConfigType } from "../types";
+/**
+ *
+ * Create an instance of IP rate-limiting middleware for Hono.
+ *
+ * @param config {ConfigType} - Options to configure the rate limiter.
+ *
+ * @returns - The middleware that rate-limits clients based on your configuration.
+ *
+ * @public
+ */
+export declare function rateLimiter<E extends Env, P extends string, I extends Input>(config?: Partial<ConfigType<E, P, I>>): import("hono").MiddlewareHandler<E, P, I>;

package/src/core/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"rateLimiter",{enumerable:true,get:function(){return rateLimiter}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default");const _factory=require("hono/factory");const _memorystore=_interop_require_default._(require("../memory-store"));const _defaultKeyGenerator=require("./defaultKeyGenerator");const _headers=require("./headers");const _validations=require("./validations");function rateLimiter(config){const{windowMs=6e4,limit=5,message="Too many requests, please try again later.",statusCode=429,standardHeaders="draft-6",requestPropertyName="rateLimit",skipFailedRequests=false,skipSuccessfulRequests=false,keyGenerator=_defaultKeyGenerator.defaultKeyGenerator,skip=()=>false,requestWasSuccessful=c=>c.res.status<400,handler=async(c,_next,options)=>{c.status(options.statusCode);const responseMessage=typeof options.message==="function"?await options.message(c):options.message;if(typeof responseMessage==="string")return c.text(responseMessage);return c.json(responseMessage)},store=new _memorystore.default}=config!=null?config:{};const options={windowMs,limit,message,statusCode,standardHeaders,requestPropertyName,skipFailedRequests,skipSuccessfulRequests,keyGenerator,skip,requestWasSuccessful,handler,store};if(!(0,_validations.isValidStore)(store))throw new Error("The store is not correctly implmented!");if(typeof store.init==="function")store.init(options);return(0,_factory.createMiddleware)(async(c,next)=>{const isSkippable=await skip(c);if(isSkippable){await next();return}const key=await keyGenerator(c);const{totalHits,resetTime}=await store.increment(key);const retrieveLimit=typeof limit==="function"?limit(c):limit;const _limit=await retrieveLimit;const info={limit:_limit,used:totalHits,remaining:Math.max(_limit-totalHits,0),resetTime};c.set(requestPropertyName,info);if(standardHeaders&&!c.finalized){if(standardHeaders==="draft-7"){(0,_headers.setDraft7Headers)(c,info,windowMs)}else{(0,_headers.setDraft6Headers)(c,info,windowMs)}}let decremented=false;const decrementKey=async()=>{if(!decremented){await store.decrement(key);decremented=true}};const shouldSkipRequest=async()=>{if(skipFailedRequests||skipSuccessfulRequests){const wasRequestSuccessful=await requestWasSuccessful(c);if(skipFailedRequests&&!wasRequestSuccessful||skipSuccessfulRequests&&wasRequestSuccessful)await decrementKey()}};if(totalHits>_limit){if(standardHeaders){(0,_headers.setRetryAfterHeader)(c,info,windowMs)}await shouldSkipRequest();return handler(c,next,options)}try{await next();await shouldSkipRequest()}catch(error){if(skipFailedRequests)await decrementKey()}finally{if(!c.finalized)await decrementKey()}})}

package/src/core/validations.d.ts

@@ -0,0 +1,2 @@
+import type { Store } from "../types";
+export declare const isValidStore: (value: Store) => value is Store;

package/src/core/validations.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"isValidStore",{enumerable:true,get:function(){return isValidStore}});const isValidStore=value=>!!(value==null?void 0:value.increment);

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./core";
+export type * from "./types";

package/src/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});const _export_star=require("@swc/helpers/_/_export_star");_export_star._(require("./core"),exports);

package/src/memory-store/index.d.ts

@@ -0,0 +1,128 @@
+/// <reference types="node" />
+import type { ClientRateLimitInfo, ConfigType, Store } from "../types";
+/**
+ * The record that stores information about a client - namely, how many times
+ * they have hit the endpoint, and when their hit count resets.
+ *
+ * Similar to `ClientRateLimitInfo`, except `resetTime` is a compulsory field.
+ */
+type Client = {
+    totalHits: number;
+    resetTime: Date;
+};
+/**
+ * A `Store` that stores the hit count for each client in memory.
+ *
+ * @public
+ */
+export declare class MemoryStore implements Store {
+    /**
+     * The duration of time before which all hit counts are reset (in milliseconds).
+     */
+    windowMs: number;
+    /**
+     * These two maps store usage (requests) and reset time by key (for example, IP
+     * addresses or API keys).
+     *
+     * They are split into two to avoid having to iterate through the entire set to
+     * determine which ones need reset. Instead, `Client`s are moved from `previous`
+     * to `current` as they hit the endpoint. Once `windowMs` has elapsed, all clients
+     * left in `previous`, i.e., those that have not made any recent requests, are
+     * known to be expired and can be deleted in bulk.
+     */
+    previous: Map<string, Client>;
+    current: Map<string, Client>;
+    /**
+     * A reference to the active timer.
+     */
+    interval?: NodeJS.Timeout;
+    /**
+     * Confirmation that the keys incremented in once instance of MemoryStore
+     * cannot affect other instances.
+     */
+    localKeys: boolean;
+    /**
+     * Method that initializes the store.
+     *
+     * @param options {ConfigType} - The options used to setup the middleware.
+     */
+    init(options: ConfigType): void;
+    /**
+     * Method to fetch a client's hit count and reset time.
+     *
+     * @param key {string} - The identifier for a client.
+     *
+     * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client.
+     *
+     * @public
+     */
+    get(key: string): Promise<ClientRateLimitInfo | undefined>;
+    /**
+     * Method to increment a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client.
+     *
+     * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client.
+     *
+     * @public
+     */
+    increment(key: string): Promise<ClientRateLimitInfo>;
+    /**
+     * Method to decrement a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client.
+     *
+     * @public
+     */
+    decrement(key: string): Promise<void>;
+    /**
+     * Method to reset a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client.
+     *
+     * @public
+     */
+    resetKey(key: string): Promise<void>;
+    /**
+     * Method to reset everyone's hit counter.
+     *
+     * @public
+     */
+    resetAll(): Promise<void>;
+    /**
+     * Method to stop the timer (if currently running) and prevent any memory
+     * leaks.
+     *
+     * @public
+     */
+    shutdown(): void;
+    /**
+     * Recycles a client by setting its hit count to zero, and reset time to
+     * `windowMs` milliseconds from now.
+     *
+     * NOT to be confused with `#resetKey()`, which removes a client from both the
+     * `current` and `previous` maps.
+     *
+     * @param client {Client} - The client to recycle.
+     * @param now {number} - The current time, to which the `windowMs` is added to get the `resetTime` for the client.
+     *
+     * @return {Client} - The modified client that was passed in, to allow for chaining.
+     */
+    private resetClient;
+    /**
+     * Retrieves or creates a client, given a key. Also ensures that the client being
+     * returned is in the `current` map.
+     *
+     * @param key {string} - The key under which the client is (or is to be) stored.
+     *
+     * @returns {Client} - The requested client.
+     */
+    private getClient;
+    /**
+     * Move current clients to previous, create a new map for current.
+     *
+     * This function is called every `windowMs`.
+     */
+    private clearExpired;
+}
+export default MemoryStore;

package/src/memory-store/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:all[name]})}_export(exports,{MemoryStore:function(){return MemoryStore},default:function(){return _default}});let MemoryStore=class MemoryStore{init(options){this.windowMs=options.windowMs;if(this.interval)clearInterval(this.interval);this.interval=setInterval(()=>{this.clearExpired()},this.windowMs);if(this.interval.unref)this.interval.unref()}async get(key){var _this_current_get;return(_this_current_get=this.current.get(key))!=null?_this_current_get:this.previous.get(key)}async increment(key){const client=this.getClient(key);const now=Date.now();if(client.resetTime.getTime()<=now){this.resetClient(client,now)}client.totalHits++;return client}async decrement(key){const client=this.getClient(key);if(client.totalHits>0)client.totalHits--}async resetKey(key){this.current.delete(key);this.previous.delete(key)}async resetAll(){this.current.clear();this.previous.clear()}shutdown(){clearInterval(this.interval);void this.resetAll()}resetClient(client,now=Date.now()){client.totalHits=0;client.resetTime.setTime(now+this.windowMs);return client}getClient(key){if(this.current.has(key))return this.current.get(key);let client;if(this.previous.has(key)){client=this.previous.get(key);this.previous.delete(key)}else{client={totalHits:0,resetTime:new Date};this.resetClient(client)}this.current.set(key,client);return client}clearExpired(){this.previous=this.current;this.current=new Map}constructor(){this.previous=new Map;this.current=new Map;this.localKeys=true}};const _default=MemoryStore;

package/src/redis/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export { default, RedisStore } from "./store.js";

package/src/redis/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:all[name]})}_export(exports,{RedisStore:function(){return _store.RedisStore},default:function(){return _store.default}});const _export_star=require("@swc/helpers/_/_export_star");const _interop_require_wildcard=require("@swc/helpers/_/_interop_require_wildcard");_export_star._(require("./types.js"),exports);const _store=_interop_require_wildcard._(require("./store.js"));

package/src/redis/scripts.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The lua scripts, used to make consecutive queries on the same key and avoid
+ * race conditions by doing all the work on the redis server.
+ */
+declare const scripts: {
+    increment: string;
+    get: string;
+};
+export default scripts;

package/src/redis/scripts.js

@@ -0,0 +1,16 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});Object.defineProperty(exports,"default",{enumerable:true,get:function(){return _default}});const scripts={increment:`
+      local totalHits = redis.call("INCR", KEYS[1])
+      local timeToExpire = redis.call("PTTL", KEYS[1])
+      if timeToExpire <= 0 or ARGV[1] == "1"
+      then
+        redis.call("PEXPIRE", KEYS[1], tonumber(ARGV[2]))
+        timeToExpire = tonumber(ARGV[2])
+      end
+
+      return { totalHits, timeToExpire }
+		`.replaceAll(/^\s+/gm,"").trim(),get:`
+      local totalHits = redis.call("GET", KEYS[1])
+      local timeToExpire = redis.call("PTTL", KEYS[1])
+
+      return { totalHits, timeToExpire }
+		`.replaceAll(/^\s+/gm,"").trim()};const _default=scripts;

package/src/redis/store.d.ts

@@ -0,0 +1,92 @@
+import type { ClientRateLimitInfo, IncrementResponse, ConfigType as RateLimitConfiguration, Store } from "../types";
+import type { Options, RedisReply, SendCommandFn } from "./types.js";
+/**
+ * A `Store` for the `express-rate-limit` package that stores hit counts in
+ * Redis.
+ */
+export declare class RedisStore implements Store {
+    /**
+     * The function used to send raw commands to Redis.
+     */
+    sendCommand: SendCommandFn;
+    /**
+     * The text to prepend to the key in Redis.
+     */
+    prefix: string;
+    /**
+     * Whether to reset the expiry for a particular key whenever its hit count
+     * changes.
+     */
+    resetExpiryOnChange: boolean;
+    /**
+     * Stores the loaded SHA1s of the LUA scripts used for executing the increment
+     * and get key operations.
+     */
+    incrementScriptSha: Promise<string>;
+    getScriptSha: Promise<string>;
+    /**
+     * The number of milliseconds to remember that user's requests.
+     */
+    windowMs: number;
+    /**
+     * @constructor for `RedisStore`.
+     *
+     * @param options {Options} - The configuration options for the store.
+     */
+    constructor(options: Options);
+    /**
+     * Loads the script used to increment a client's hit count.
+     */
+    loadIncrementScript(): Promise<string>;
+    /**
+     * Loads the script used to fetch a client's hit count and expiry time.
+     */
+    loadGetScript(): Promise<string>;
+    /**
+     * Runs the increment command, and retries it if the script is not loaded.
+     */
+    retryableIncrement(key: string): Promise<RedisReply>;
+    /**
+     * Method to prefix the keys with the given text.
+     *
+     * @param key {string} - The key.
+     *
+     * @returns {string} - The text + the key.
+     */
+    prefixKey(key: string): string;
+    /**
+     * Method that actually initializes the store.
+     *
+     * @param options {RateLimitConfiguration} - The options used to setup the middleware.
+     */
+    init(options: RateLimitConfiguration): void;
+    /**
+     * Method to fetch a client's hit count and reset time.
+     *
+     * @param key {string} - The identifier for a client.
+     *
+     * @returns {ClientRateLimitInfo | undefined} - The number of hits and reset time for that client.
+     */
+    get(key: string): Promise<ClientRateLimitInfo | undefined>;
+    /**
+     * Method to increment a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client
+     *
+     * @returns {IncrementResponse} - The number of hits and reset time for that client
+     */
+    increment(key: string): Promise<IncrementResponse>;
+    /**
+     * Method to decrement a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client
+     */
+    decrement(key: string): Promise<void>;
+    /**
+     * Method to reset a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client
+     */
+    resetKey(key: string): Promise<void>;
+}
+export default RedisStore;

package/src/redis/store.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});function _export(target,all){for(var name in all)Object.defineProperty(target,name,{enumerable:true,get:all[name]})}_export(exports,{RedisStore:function(){return RedisStore},default:function(){return _default}});const _interop_require_default=require("@swc/helpers/_/_interop_require_default");const _scripts=_interop_require_default._(require("./scripts.js"));const toInt=input=>{if(typeof input==="number")return input;return Number.parseInt((input!=null?input:"").toString(),10)};const parseScriptResponse=results=>{if(!Array.isArray(results))throw new TypeError("Expected result to be array of values");if(results.length!==2)throw new Error(`Expected 2 replies, got ${results.length}`);const totalHits=results[0]===false?0:toInt(results[0]);const timeToExpire=toInt(results[1]);const resetTime=new Date(Date.now()+timeToExpire);return{totalHits,resetTime}};let RedisStore=class RedisStore{async loadIncrementScript(){const result=await this.sendCommand("SCRIPT","LOAD",_scripts.default.increment);if(typeof result!=="string"){throw new TypeError("unexpected reply from redis client")}return result}async loadGetScript(){const result=await this.sendCommand("SCRIPT","LOAD",_scripts.default.get);if(typeof result!=="string"){throw new TypeError("unexpected reply from redis client")}return result}async retryableIncrement(key){const evalCommand=async()=>this.sendCommand("EVALSHA",await this.incrementScriptSha,"1",this.prefixKey(key),this.resetExpiryOnChange?"1":"0",this.windowMs.toString());try{const result=await evalCommand();return result}catch(e){this.incrementScriptSha=this.loadIncrementScript();return evalCommand()}}prefixKey(key){return`${this.prefix}${key}`}init(options){this.windowMs=options.windowMs}async get(key){const results=await this.sendCommand("EVALSHA",await this.getScriptSha,"1",this.prefixKey(key));return parseScriptResponse(results)}async increment(key){const results=await this.retryableIncrement(key);return parseScriptResponse(results)}async decrement(key){await this.sendCommand("DECR",this.prefixKey(key))}async resetKey(key){await this.sendCommand("DEL",this.prefixKey(key))}constructor(options){this.sendCommand=options.sendCommand;var _options_prefix;this.prefix=(_options_prefix=options.prefix)!=null?_options_prefix:"rl:";var _options_resetExpiryOnChange;this.resetExpiryOnChange=(_options_resetExpiryOnChange=options.resetExpiryOnChange)!=null?_options_resetExpiryOnChange:false;this.incrementScriptSha=this.loadIncrementScript();this.getScriptSha=this.loadGetScript()}};const _default=RedisStore;

package/src/redis/types.d.ts

@@ -0,0 +1,29 @@
+/**
+ * The type of data Redis might return to us.
+ */
+type Data = boolean | number | string;
+export type RedisReply = Data | Data[];
+/**
+ * The library sends Redis raw commands, so all we need to know are the
+ * 'raw-command-sending' functions for each redis client.
+ */
+export type SendCommandFn = (...args: string[]) => Promise<RedisReply>;
+/**
+ * The configuration options for the store.
+ */
+export type Options = {
+    /**
+     * The function used to send commands to Redis.
+     */
+    readonly sendCommand: SendCommandFn;
+    /**
+     * The text to prepend to the key in Redis.
+     */
+    readonly prefix?: string;
+    /**
+     * Whether to reset the expiry for a particular key whenever its hit count
+     * changes.
+     */
+    readonly resetExpiryOnChange?: boolean;
+};
+export {};

package/src/redis/types.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/src/types/clientRateLimitInfo.d.ts

@@ -0,0 +1,4 @@
+export type ClientRateLimitInfo = {
+    totalHits: number;
+    resetTime?: Date;
+};

package/src/types/clientRateLimitInfo.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/src/types/config.d.ts

@@ -0,0 +1,106 @@
+import type { Context, Env, Input, Next } from "hono";
+import type { StatusCode } from "hono/utils/http-status";
+import type { Promisify } from "./promisify";
+import type { Store } from "./store";
+/**
+ * Hono request handler that sends back a response when a client is
+ * rate-limited.
+ *
+ * @param context {Context} - The Hono context object.
+ * @param next {Next} - The Hono `next` function, can be called to skip responding.
+ * @param optionsUsed {ConfigType} - The options used to set up the middleware.
+ */
+export type RateLimitExceededEventHandler<E extends Env = any, P extends string = any, I extends Input = NonNullable<unknown>> = (c: Context<E, P, I>, next: Next, optionsUsed: ConfigType<E, P, I>) => void;
+/**
+ * The configuration options for the rate limiter.
+ */
+export type ConfigType<E extends Env = any, P extends string = any, I extends Input = NonNullable<unknown>> = {
+    /**
+     * How long we should remember the requests.
+     *
+     * Defaults to `60000` ms (= 1 minute).
+     */
+    windowMs: number;
+    /**
+     * The maximum number of connections to allow during the `window` before
+     * rate limiting the client.
+     *
+     * Can be the limit itself as a number or express middleware that parses
+     * the request and then figures out the limit.
+     *
+     * Defaults to `5`.
+     */
+    limit: number | ((c: Context<E, P, I>) => Promisify<number>);
+    /**
+     * The response body to send back when a client is rate limited.
+     *
+     * Defaults to `'Too many requests, please try again later.'`
+     */
+    message: string | JSON | ((c: Context<E, P, I>) => Promisify<string | JSON>);
+    /**
+     * The HTTP status code to send back when a client is rate limited.
+     *
+     * Defaults to `HTTP 429 Too Many Requests` (RFC 6585).
+     */
+    statusCode: StatusCode;
+    /**
+     * Whether to enable support for the standardized rate limit headers (`RateLimit-*`).
+     *
+     * Defaults to `draft-6`.
+     */
+    standardHeaders: boolean | "draft-6" | "draft-7";
+    /**
+     * The name of the property on the request object to store the rate limit info.
+     *
+     * Defaults to `rateLimit`.
+     */
+    requestPropertyName: string;
+    /**
+     * If `true`, the library will (by default) skip all requests that have a 4XX
+     * or 5XX status.
+     *
+     * Defaults to `false`.
+     */
+    skipFailedRequests: boolean;
+    /**
+     * If `true`, the library will (by default) skip all requests that have a
+     * status code less than 400.
+     *
+     * Defaults to `false`.
+     */
+    skipSuccessfulRequests: boolean;
+    /**
+     * Method to generate custom identifiers for clients.
+     *
+     * By default, the client's IP address is used.
+     */
+    keyGenerator: (c: Context<E, P, I>) => Promisify<string>;
+    /**
+     * Hono request handler that sends back a response when a client is
+     * rate-limited.
+     *
+     * By default, sends back the `statusCode` and `message` set via the options.
+     */
+    handler: RateLimitExceededEventHandler<E, P, I>;
+    /**
+     * Method (in the form of middleware) to determine whether or not this request
+     * counts towards a client's quota.
+     *
+     * By default, skips no requests.
+     */
+    skip: (c: Context<E, P, I>) => Promisify<boolean>;
+    /**
+     * Method to determine whether or not the request counts as 'succesful'. Used
+     * when either `skipSuccessfulRequests` or `skipFailedRequests` is set to true.
+     *
+     * By default, requests with a response status code less than 400 are considered
+     * successful.
+     */
+    requestWasSuccessful: (c: Context<E, P, I>) => Promisify<boolean>;
+    /**
+     * The `Store` to use to store the hit count for each client.
+     *
+     * By default, the built-in `MemoryStore` will be used.
+     */
+    store: Store;
+};

package/src/types/config.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/src/types/index.d.ts

@@ -0,0 +1,5 @@
+export type * from "./store";
+export type * from "./promisify";
+export type * from "./config";
+export type * from "./clientRateLimitInfo";
+export type * from "./rateLimitInfo";

package/src/types/index.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/src/types/promisify.d.ts

@@ -0,0 +1 @@
+export type Promisify<T> = T | Promise<T>;

package/src/types/promisify.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/src/types/rateLimitExceededEventHandler.d.ts

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

package/src/types/rateLimitExceededEventHandler.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/src/types/rateLimitInfo.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The rate limit related information for each client included in the
+ * Hono context object.
+ */
+export type RateLimitInfo = {
+    limit: number;
+    used: number;
+    remaining: number;
+    resetTime: Date | undefined;
+};

package/src/types/rateLimitInfo.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});

package/src/types/store.d.ts

@@ -0,0 +1,65 @@
+import type { ClientRateLimitInfo } from "./clientRateLimitInfo";
+import type { ConfigType } from "./config";
+export type IncrementResponse = ClientRateLimitInfo;
+/**
+ * An interface that all hit counter stores must implement.
+ */
+export type Store = {
+    /**
+     * Method that initializes the store, and has access to the options passed to
+     * the middleware too.
+     *
+     * @param options {ConfigType} - The options used to setup the middleware.
+     */
+    init?: (options: ConfigType) => void;
+    /**
+     * Method to fetch a client's hit count and reset time.
+     *
+     * @param key {string} - The identifier for a client.
+     *
+     * @returns {ClientRateLimitInfo} - The number of hits and reset time for that client.
+     */
+    get?: (key: string) => Promise<ClientRateLimitInfo | undefined> | ClientRateLimitInfo | undefined;
+    /**
+     * Method to increment a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client.
+     *
+     * @returns {IncrementResponse | undefined} - The number of hits and reset time for that client.
+     */
+    increment: (key: string) => Promise<IncrementResponse> | IncrementResponse;
+    /**
+     * Method to decrement a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client.
+     */
+    decrement: (key: string) => Promise<void> | void;
+    /**
+     * Method to reset a client's hit counter.
+     *
+     * @param key {string} - The identifier for a client.
+     */
+    resetKey: (key: string) => Promise<void> | void;
+    /**
+     * Method to reset everyone's hit counter.
+     */
+    resetAll?: () => Promise<void> | void;
+    /**
+     * Method to shutdown the store, stop timers, and release all resources.
+     */
+    shutdown?: () => Promise<void> | void;
+    /**
+     * Flag to indicate that keys incremented in one instance of this store can
+     * not affect other instances. Typically false if a database is used, true for
+     * MemoryStore.
+     *
+     * Used to help detect double-counting misconfigurations.
+     */
+    localKeys?: boolean;
+    /**
+     * Optional value that the store prepends to keys
+     *
+     * Used by the double-count check to avoid false-positives when a key is counted twice, but with different prefixes
+     */
+    prefix?: string;
+};

package/src/types/store.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:true});