@ozanarslan/corpus 0.0.1

package/dist/RateLimiter/index.d.ts

@@ -0,0 +1,321 @@
+/**
+ * Request rate limiting, as a ready-made {@link Middleware}.
+ *
+ * {@link RateLimiter} counts requests per caller within a rolling window and
+ * rejects anything over the limit with {@link Status.TOO_MANY_REQUESTS}. Who
+ * "the caller" is depends on what the request proves about itself: an
+ * authenticated request is identified by its token, an unauthenticated one by
+ * its IP, and one with neither by a fingerprint of its headers. Each tier gets
+ * its own limit, since they differ in how accountable and how forgeable they
+ * are.
+ *
+ * Identifiers are hashed with a rotating salt before being stored, so the
+ * limiter never holds a token or an IP in memory.
+ *
+ * ```ts
+ * import { RateLimiter } from "@ozanarslan/corpus";
+ *
+ * new RateLimiter({ windowMs: 60_000, limits: { authenticated: 120, ipBased: 60, fingerprint: 20 } });
+ * ```
+ *
+ * Counting is backed by {@link RateLimiterStoreInterface}; the default
+ * {@link RateLimiterMemoryStore} is per-process, so a multi-instance deployment
+ * wants a shared store instead.
+ *
+ * @module RateLimiter
+ */
+import { Middleware, type MiddlewareHandler } from "../Middleware";
+import { type MaybePromise, type OrString } from "../utils/is";
+import { type Tuple } from "../utils/tuple";
+/** One caller's counter for the current window. */
+interface RateLimiterEntry {
+    /** Requests seen in this window, including the one being handled. */
+    hits: number;
+    /** Unix milliseconds at which the window ends and the count resets. */
+    resetAt: number;
+}
+/**
+ * The storage contract for rate limit counters.
+ *
+ * Implement it to back the limiter with Redis or anything else shared across
+ * processes — the default {@link RateLimiterMemoryStore} only counts within one.
+ * Every method may be synchronous or asynchronous; the limiter awaits either.
+ */
+interface RateLimiterStoreInterface {
+    /**
+     * Reads a caller's entry.
+     *
+     * @param id - The hashed caller identifier.
+     * @returns The entry, or `undefined` when the caller has none.
+     */
+    get(id: string): MaybePromise<RateLimiterEntry | undefined>;
+    /**
+     * Writes a caller's entry, replacing any existing one.
+     *
+     * @param id - The hashed caller identifier.
+     * @param entry - The counter to store.
+     */
+    set(id: string, entry: RateLimiterEntry): MaybePromise<void>;
+    /**
+     * Removes a caller's entry.
+     *
+     * @param id - The hashed caller identifier.
+     */
+    delete(id: string): MaybePromise<void>;
+    /**
+     * Removes every entry whose window has ended.
+     *
+     * @param now - Unix milliseconds to compare against
+     * {@link RateLimiterEntry.resetAt}.
+     */
+    cleanup(now: number): MaybePromise<void>;
+    /** Removes every entry, expired or not. */
+    clear(): MaybePromise<void>;
+    /**
+     * Reports how many entries are held.
+     *
+     * @returns The entry count, used to decide when a cleanup is forced.
+     */
+    size(): MaybePromise<number>;
+}
+/**
+ * In-process counter storage, used when no store is configured.
+ *
+ * Writes are serialised per identifier through a promise lock, so concurrent
+ * requests from the same caller cannot interleave their read-modify-write and
+ * lose a hit.
+ *
+ * State lives in one process's memory, so it is lost on restart and not shared
+ * between instances — behind a load balancer, each instance enforces the limit
+ * separately. Use a shared {@link RateLimiterStoreInterface} when that matters.
+ */
+declare class RateLimiterMemoryStore implements RateLimiterStoreInterface {
+    /** The counters, keyed by hashed identifier. */
+    protected readonly map: Map<string, RateLimiterEntry>;
+    /** In-flight write locks, keyed by identifier. Present only while a write is running. */
+    protected readonly locks: Map<string, Promise<void>>;
+    /**
+     * Reads a caller's entry.
+     *
+     * @param id - The hashed caller identifier.
+     * @returns The entry, or `undefined` when absent. Expired entries are returned
+     * as-is; the limiter checks {@link RateLimiterEntry.resetAt} itself.
+     */
+    get(id: string): RateLimiterEntry | undefined;
+    /**
+     * Writes a caller's entry, waiting for any write already in progress for the
+     * same identifier.
+     *
+     * @param id - The hashed caller identifier.
+     * @param entry - The counter to store.
+     */
+    set(id: string, entry: RateLimiterEntry): Promise<void>;
+    /**
+     * Removes a caller's entry.
+     *
+     * @param id - The hashed caller identifier.
+     */
+    delete(id: string): void;
+    /**
+     * Removes every entry whose window has already ended.
+     *
+     * @param now - Unix milliseconds to compare against.
+     */
+    cleanup(now: number): void;
+    /** Removes every entry, resetting all counters. */
+    clear(): void;
+    /**
+     * @returns How many entries are currently held.
+     */
+    size(): number;
+}
+/**
+ * The limiter's settings. {@link RateLimiter} merges what you pass over
+ * {@link defaultConfig}, so every field is optional at the call site.
+ */
+type RateLimiterConfig = {
+    /** Limits based on identifier type: */
+    limits: {
+        /** Authenticated users — higher limit, accountable identity (e.g., 120 requests) */
+        authenticated: number;
+        /** IP-based — moderate, may be shared (NAT, proxies) (e.g., 60 requests) */
+        ipBased: number;
+        /** Fingerprint / anonymous — lowest, least trustworthy (e.g., 20 requests) */
+        fingerprint: number;
+    };
+    /**
+     * You can pass a different header key to check for authenticated users.
+     * "Bearer " string is only sliced for Authorization.
+     * */
+    authHeader?: OrString<"Authorization">;
+    /** Time window in milliseconds during which the rate limit applies (default: 60,000ms = 1 minute) */
+    windowMs: number;
+    /**
+     * How often to rotate the salt used for hashing identifiers (default: 24h)
+     * Prevents long-term tracking and adds an extra layer of privacy
+     * */
+    saltRotateMs: number;
+    /**
+     * Probability (0-1) of triggering a cleanup of expired entries on each request
+     * Balances memory usage against performance (default: 0.005 = 0.5%)
+     * */
+    cleanProbability: number;
+    /**
+     * Maximum number of entries before forcing a cleanup
+     * Prevents unbounded memory growth (default: 50,000)
+     * */
+    maxStoreSize: number;
+    /**
+     * Bring your own store implementation like redis.
+     * Uses {@link RateLimiterMemoryStore} by default.
+     * */
+    store?: RateLimiterStoreInterface;
+    /**
+     * Customizable HTTP header names for rate limit information.
+     * Allows integration with different API conventions or frontend expectations.
+     *
+     * @example
+     * // Custom header names (e.g., for legacy systems)
+     * headerNames: {
+     *   limit: "X-RateLimit-Limit",
+     *   remaining: "X-RateLimit-Remaining",
+     *   reset: "X-RateLimit-Reset",
+     *   retryAfter: "Retry-After"
+     * }
+     *
+     * @default Uses standard RateLimit-* headers as defined in IETF draft:
+     * - limit: "RateLimit-Limit"
+     * - remaining: "RateLimit-Remaining"
+     * - reset: "RateLimit-Reset"
+     * - retryAfter: "Retry-After"
+     */
+    headerNames: {
+        /** Header name for the maximum allowed requests in the current window */
+        limit: string;
+        /** Header name for the remaining requests in the current window */
+        remaining: string;
+        /** Header name for the timestamp (Unix seconds) when the window resets */
+        reset: string;
+        /** Header name for seconds to wait before retrying when rate limited */
+        retryAfter: string;
+    };
+};
+/**
+ * A {@link Middleware} that limits how often a caller may make requests.
+ *
+ * Every response carries the limit, the remaining allowance and the reset time,
+ * and those header names are added to
+ * {@link HeaderKey.AccessControlExposeHeaders} so browser clients can actually
+ * read them. Exceeding the limit throws an {@link Exception} carrying the
+ * response built so far, so the rejection keeps its rate limit headers.
+ */
+declare class RateLimiter extends Middleware {
+    /**
+     * Creates a limiter and registers it on the nearest {@link App}.
+     *
+     * It targets the routes registered so far, minus
+     * {@link RouteVariant.bundle} ones — a single page load pulls dozens of
+     * assets, which would exhaust any sensible limit. Construct it after your
+     * routes; routes registered later are not covered.
+     *
+     * @param config - Overrides for {@link defaultConfig}. Merged shallowly, so
+     * supplying `limits` or `headerNames` replaces that group whole.
+     */
+    constructor(config?: Partial<RateLimiterConfig>);
+    /**
+     * Counts the request and either continues the chain or rejects it.
+     *
+     * @param c - The {@link Context} for the request.
+     * @param next - Runs the rest of the chain.
+     * @throws {@link Exception} with {@link Status.TOO_MANY_REQUESTS} when the
+     * limit is exceeded. The current {@link Res} is passed as the exception data,
+     * so the rejection carries the rate limit headers already set on it.
+     */
+    handler: MiddlewareHandler;
+    /**
+     * Counts one request against its caller's allowance and writes the rate limit
+     * headers.
+     *
+     * A window is created on the first request and reused until
+     * {@link RateLimiterEntry.resetAt} passes, at which point the counter starts
+     * over — a fixed window, not a sliding one. The hit is counted whether or not
+     * it is allowed, so a caller that keeps hammering a closed window stays closed
+     * until it resets.
+     *
+     * Exposed separately from {@link RateLimiter.handler} so the same accounting
+     * can be driven from outside a request chain, in tests or a custom handler.
+     *
+     * @param reqHeaders - The request headers, used to identify the caller.
+     * @param resHeaders - The response headers to write the limit, remaining,
+     * reset and — when rejected — retry-after values into.
+     * @returns `true` when the request is within the limit.
+     */
+    getResult(reqHeaders: Headers, resHeaders: Headers): Promise<boolean>;
+    /** The merged settings this limiter runs with. */
+    protected readonly config: RateLimiterConfig;
+    /** Where counters are kept. The configured store, or a {@link RateLimiterMemoryStore}. */
+    protected readonly store: RateLimiterStoreInterface;
+    /** The current hashing salt. Rotated by {@link RateLimiter.salt}. */
+    protected storedSalt: string;
+    /** Unix milliseconds at which {@link RateLimiter.storedSalt} is replaced. */
+    protected saltRotatesAt: number;
+    /**
+     * Identifies the caller and picks the limit that applies to it.
+     *
+     * Three tiers are tried in order of how much the request proves about itself.
+     * A bearer token of plausible length identifies an authenticated caller and
+     * earns the highest limit. Failing that, a valid address from the proxy
+     * headers earns the IP limit — shared by everyone behind a NAT, hence lower.
+     * Failing that, a fingerprint of the user agent and accept headers earns the
+     * lowest limit, since it is trivially forgeable.
+     *
+     * Tokens are hashed without the salt so a caller keeps one bucket across
+     * rotations; addresses and fingerprints are salted, so they cannot be
+     * correlated across rotation windows.
+     *
+     * The prefixes (`u:`, `i:`, `f:`) keep the tiers in separate namespaces, so a
+     * collision across tiers is impossible.
+     *
+     * @param headers - The request headers.
+     * @returns A {@link Tuple} of the hashed identifier and the applicable limit.
+     */
+    protected getIdAndLimit(headers: Headers): Tuple<string, number>;
+    /**
+     * Returns the current hashing salt, rotating it when it has expired.
+     *
+     * Rotation is lazy rather than scheduled, so no timer is held open. A rotation
+     * changes every derived identifier at once, which resets the affected
+     * counters — acceptable at a daily cadence, and the point: it bounds how long
+     * any caller can be tracked.
+     *
+     * @returns The salt to mix into address and fingerprint hashes.
+     */
+    protected salt(): string;
+    /**
+     * Decides whether to sweep expired entries before handling a request.
+     *
+     * Cleanup runs on a small random fraction of requests, so the cost is spread
+     * out instead of landing on a timer, and unconditionally once the store passes
+     * {@link RateLimiterConfig.maxStoreSize}, which bounds memory under a flood of
+     * one-off callers.
+     */
+    protected maybeCleanStore(): Promise<void>;
+    /**
+     * Removes every entry whose window has ended.
+     *
+     * @returns How many entries remain.
+     */
+    protected cleanStore(): Promise<number>;
+    /**
+     * Clears every counter, expired or not, resetting all callers to a full
+     * allowance. Mainly useful between tests.
+     */
+    clearStore(): Promise<void>;
+    /**
+     * @returns How many counters are currently held, expired ones included until
+     * the next cleanup.
+     */
+    getStoreSize(): Promise<number>;
+}
+export { RateLimiter, RateLimiterMemoryStore, type RateLimiterStoreInterface, type RateLimiterConfig, };
+//# sourceMappingURL=index.d.ts.map

package/dist/RateLimiter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/RateLimiter/index.ts"],"names":[],"mappings":"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"}

package/dist/Request/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * HTTP method constants, and the `Request` extensions the framework relies on.
+ *
+ * {@link Method} gives the verbs as documented constants. {@link patchGlobalRequest}
+ * then adds two properties to the global `Request`: `params`, which {@link App}
+ * fills with the matched path parameters before parsing, and `cookies`, which
+ * parses the `Cookie` header into a {@link Cookies} map on first access.
+ *
+ * Like {@link patchGlobalHeaders}, this must be installed once at startup,
+ * before any request is served.
+ *
+ * @module Request
+ */
+import { Cookies } from "../Cookies";
+import type { OrString } from "../utils/is";
+import { type ValueOf } from "../utils/object";
+/** Commonly used HTTP verbs. See [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods) for the full spec. */
+declare const Method: {
+    /** Retrieve a resource from the server. */
+    readonly GET: "GET";
+    /** Submit data to create a new resource. */
+    readonly POST: "POST";
+    /** Replace an entire resource with new data. */
+    readonly PUT: "PUT";
+    /** Apply partial modifications to a resource. */
+    readonly PATCH: "PATCH";
+    /** Remove a resource from the server. */
+    readonly DELETE: "DELETE";
+    /** Get response headers without body. */
+    readonly HEAD: "HEAD";
+    /** Discover communication options. */
+    readonly OPTIONS: "OPTIONS";
+    /** Establish tunnel to server. */
+    readonly CONNECT: "CONNECT";
+    /** Echo back received request. */
+    readonly TRACE: "TRACE";
+};
+/**
+ * An HTTP method. The {@link Method} constants are suggested, but
+ * {@link OrString} keeps any custom verb assignable.
+ */
+type Method = OrString<ValueOf<typeof Method>>;
+/**
+ * Installs `params` and `cookies` on the global `Request`. Call it once at
+ * startup, before any request is served.
+ *
+ * The patch is applied twice over, for the same reason as
+ * {@link patchGlobalHeaders}. The prototype is extended so requests *the runtime*
+ * creates — every incoming request Bun hands to the server — carry the
+ * properties, since those never pass through a constructor the framework
+ * controls. The global class is then replaced too, so manually constructed
+ * requests can seed their cookies from {@link RequestInit.cookies}, which the
+ * prototype path has no access to.
+ *
+ * The subclass overrides `Symbol.hasInstance` to defer to the native class, so
+ * `instanceof Request` stays true for requests created outside the patch.
+ */
+declare function patchGlobalRequest(): void;
+declare global {
+    interface RequestInit {
+        /**
+         * Cookies to seed the request with. Anything in the `Cookie` header is
+         * layered on top of these.
+         */
+        cookies?: Cookies;
+    }
+    /** The `Request` surface after {@link patchGlobalRequest} has run. */
+    interface Request {
+        /**
+         * The raw path parameters matched by the route, populated by Bun's router.
+         * {@link Context.params} holds the parsed, validated version.
+         */
+        params: {
+            [x: string]: string;
+        };
+        /** The request's cookies, parsed from the `Cookie` header on first access. */
+        cookies: Cookies;
+    }
+}
+export { patchGlobalRequest, Method };
+//# sourceMappingURL=index.d.ts.map

package/dist/Request/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/Request/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,OAAO,EAAqB,MAAM,WAAW,CAAC;AAEvD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAoB,KAAK,OAAO,EAAE,MAAM,gBAAgB,CAAC;AAEhE,4IAA4I;AAC5I,QAAA,MAAM,MAAM;IACX,2CAA2C;;IAE3C,4CAA4C;;IAE5C,gDAAgD;;IAEhD,iDAAiD;;IAEjD,yCAAyC;;IAEzC,yCAAyC;;IAEzC,sCAAsC;;IAEtC,kCAAkC;;IAElC,kCAAkC;;CAEzB,CAAC;AAEX;;;GAGG;AACH,KAAK,MAAM,GAAG,QAAQ,CAAC,OAAO,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC;AA2B/C;;;;;;;;;;;;;;GAcG;AACH,iBAAS,kBAAkB,SA4F1B;AAED,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,WAAW;QACpB;;;WAGG;QACH,OAAO,CAAC,EAAE,OAAO,CAAC;KAClB;IACD,sEAAsE;IACtE,UAAU,OAAO;QAChB;;;WAGG;QACH,MAAM,EAAE;YAAE,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAC;QAChC,8EAA8E;QAC9E,OAAO,EAAE,OAAO,CAAC;KACjB;CACD;AAED,OAAO,EAAE,kBAAkB,EAAE,MAAM,EAAE,CAAC"}