TypeScript Types

interface HitlimitOptions {
  /** Maximum requests per window */
  limit: number

  /** Time window (e.g., '1m', '1h', 60000) */
  window: string | number

  /** Key extraction function */
  key?: (req: Request) => string

  /** Storage backend */
  store?: Store

  /** Skip rate limiting for certain requests */
  skip?: (req: Request) => boolean

  /** Include rate limit headers */
  headers?: boolean

  /** HTTP status when rate limited */
  statusCode?: number

  /** Custom error response */
  response?: object | ((req: Request, res: Response) => object)
}

interface RateLimitInfo {
  /** Current request count */
  count: number

  /** Unix timestamp when window resets */
  resetTime: number
}

interface Store {
  /** Get current rate limit info */
  get(key: string): Promise<RateLimitInfo | null>

  /** Increment counter and return updated info */
  increment(key: string, windowMs: number): Promise<RateLimitInfo>

  /** Reset rate limit for a key */
  reset(key: string): Promise<void>

  /** Optional cleanup method */
  close?(): Promise<void>
}

interface MemoryStoreOptions {
  /** Cleanup interval in ms (default: 60000) */
  cleanupInterval?: number
}

interface SqliteStoreOptions {
  /** Path to SQLite database file */
  path: string

  /** Table name (default: 'rate_limits') */
  tableName?: string
}

interface RedisStoreOptions {
  /** Redis connection URL */
  url: string

  /** Key prefix (default: 'rl:') */
  prefix?: string

  /** Existing Redis client */
  client?: RedisClient
}

type Middleware = (
  req: Request,
  res: Response,
  next: NextFunction
) => void | Promise<void>

type NextFunction = (err?: any) => void

interface Request {
  rateLimit?: {
    limit: number
    remaining: number
    resetTime: number
  }
}

import type { HitlimitOptions, Store } from '@joint-ops/hitlimit'

const options: HitlimitOptions = {
  limit: 100,
  window: '1m',
  headers: true
}

const customStore: Store = {
  async get(key) { /* ... */ },
  async increment(key, windowMs) { /* ... */ },
  async reset(key) { /* ... */ }
}