@sigitex/route 1.0.0

package/src/middleware/rateLimit.ts

@@ -0,0 +1,107 @@
+import { HTTP } from "../HTTP";
+import type {
+  RequestContext,
+  ResponseContext,
+  RouteMiddleware,
+} from "../router.types";
+
+export type RateLimitStore = {
+  increment(
+    key: string,
+    window: number,
+  ): Promise<{ count: number; reset: number }>
+}
+
+export type RateLimitOptions = {
+  readonly window?: number
+  readonly max?: number
+  readonly key?: (context: RequestContext) => string
+  readonly store?: RateLimitStore
+  readonly headers?: boolean
+}
+
+export function rateLimit(options?: RateLimitOptions): RouteMiddleware {
+  const window = options?.window ?? 60
+  const max = options?.max ?? 100
+  const key = options?.key ?? rateLimit.ip
+  const store = options?.store ?? rateLimit.memory()
+  const headers = options?.headers ?? true
+
+  let lastResult: { count: number; reset: number } | undefined
+
+  return {
+    before: async (context: RequestContext) => {
+      const id = key(context)
+      const result = await store.increment(id, window)
+      lastResult = result
+
+      if (result.count > max) {
+        const response = new Response(
+          JSON.stringify({ error: HTTP.statusText.TooManyRequests }),
+          {
+            status: HTTP.status.TooManyRequests,
+            statusText: HTTP.statusText.TooManyRequests,
+          },
+        )
+        if (headers) {
+          response.headers.set(HTTP.header.XRateLimitLimit, String(max))
+          response.headers.set(HTTP.header.XRateLimitRemaining, "0")
+          response.headers.set(
+            HTTP.header.XRateLimitReset,
+            String(result.reset),
+          )
+        }
+        return response
+      }
+    },
+    after: ({ response }: ResponseContext) => {
+      if (headers && lastResult) {
+        const remaining = Math.max(0, max - lastResult.count)
+        response.headers.set(HTTP.header.XRateLimitLimit, String(max))
+        response.headers.set(HTTP.header.XRateLimitRemaining, String(remaining))
+        response.headers.set(
+          HTTP.header.XRateLimitReset,
+          String(lastResult.reset),
+        )
+      }
+    },
+  }
+}
+
+export namespace rateLimit {
+  export function ip({ request }: RequestContext): string {
+    return (
+      request.headers.get(HTTP.header.CFConnectingIP) ??
+      request.headers.get(HTTP.header.XForwardedFor)?.split(",")[0]?.trim() ??
+      "unknown"
+    )
+  }
+
+  export function memory(): RateLimitStore {
+    const windows = new Map<string, { count: number; reset: number }>()
+
+    return {
+      async increment(key: string, window: number) {
+        const now = Math.floor(Date.now() / 1000)
+        const windowStart = now - (now % window)
+        const windowKey = `${key}:${windowStart}`
+        const reset = windowStart + window
+
+        const entry = windows.get(windowKey)
+        if (entry) {
+          entry.count++
+          return { count: entry.count, reset }
+        }
+
+        windows.set(windowKey, { count: 1, reset })
+
+        // Clean up expired windows
+        for (const [k, v] of windows) {
+          if (v.reset < now) windows.delete(k)
+        }
+
+        return { count: 1, reset }
+      },
+    }
+  }
+}

package/src/middleware/referrerPolicy.ts

@@ -0,0 +1,27 @@
+import { HTTP } from "../HTTP"
+import type { ResponseContext, RouteMiddleware } from "../router.types"
+
+function make(value: string): RouteMiddleware {
+  return {
+    after: ({ response }: ResponseContext) => {
+      response.headers.set(HTTP.header.ReferrerPolicy, value)
+    },
+  }
+}
+
+export namespace referrerPolicy {
+  export const noReferrer = make(HTTP.referrerPolicy.noReferrer)
+  export const noReferrerWhenDowngrade = make(
+    HTTP.referrerPolicy.noReferrerWhenDowngrade,
+  )
+  export const origin = make(HTTP.referrerPolicy.origin)
+  export const originWhenCrossOrigin = make(
+    HTTP.referrerPolicy.originWhenCrossOrigin,
+  )
+  export const sameOrigin = make(HTTP.referrerPolicy.sameOrigin)
+  export const strictOrigin = make(HTTP.referrerPolicy.strictOrigin)
+  export const strictOriginWhenCrossOrigin = make(
+    HTTP.referrerPolicy.strictOriginWhenCrossOrigin,
+  )
+  export const unsafeUrl = make(HTTP.referrerPolicy.unsafeUrl)
+}

package/src/middleware/requestId.ts

@@ -0,0 +1,31 @@
+import { HTTP } from "../HTTP"
+import type {
+  RequestContext,
+  ResponseContext,
+  RouteMiddleware,
+} from "../router.types"
+
+export type RequestIdOptions = {
+  readonly header?: string
+  readonly generate?: () => string
+}
+
+export function requestId(options?: RequestIdOptions): RouteMiddleware {
+  const header = options?.header ?? HTTP.header.XRequestId
+  const generate = options?.generate ?? (() => crypto.randomUUID())
+
+  return {
+    before: ({ request, bind }: RequestContext) => {
+      const id = request.headers.get(header) ?? generate()
+      bind({ requestId: id })
+    },
+    after: ({
+      response,
+      requestId,
+    }: ResponseContext & { requestId: string }) => {
+      if (requestId) {
+        response.headers.set(header, requestId)
+      }
+    },
+  }
+}

package/src/middleware/setHeader.ts

@@ -0,0 +1,7 @@
+import type { ResponseContext, ResponseHandler } from "../router.types"
+
+export function setHeader(header: string, value: string): ResponseHandler {
+  return ({ response }: ResponseContext) => {
+    response.headers.set(header, value)
+  }
+}

package/src/middleware/www.ts

@@ -0,0 +1,12 @@
+import type { RequestContext, RequestHandler } from "../router.types"
+
+export function www({ secure }: { readonly secure?: boolean }): RequestHandler {
+  return ({ url }: RequestContext) => {
+    const isWww = url.hostname.startsWith("www.")
+    const isSecure = url.protocol === "https:"
+    if (isWww && (secure ? isSecure : true)) return
+    url.hostname = `www.${url.hostname}`
+    if (secure) url.protocol = "https:"
+    return Response.redirect(url, 301)
+  }
+}

package/src/route.ts

@@ -0,0 +1,21 @@
+import { Router } from "./Router"
+import type { RequestHandler, RouterFetch, RouterOptions } from "./router.types"
+
+export type MaybeHandler = RequestHandler | null | undefined | false | 0
+
+export function route(...handlers: MaybeHandler[]): RouterFetch
+export function route(
+  options: RouterOptions,
+  ...handlers: MaybeHandler[]
+): RouterFetch
+export function route(
+  options: RouterOptions | MaybeHandler,
+  ...handlers: MaybeHandler[]
+) {
+  const actualHandlers = handlers.filter((h): h is RequestHandler => !!h)
+  const router =
+    typeof options === "function"
+      ? new Router([options, ...actualHandlers])
+      : new Router(actualHandlers, options || undefined)
+  return router.route.bind(router)
+}

package/src/router.types.ts

@@ -0,0 +1,48 @@
+// oxlint-disable typescript/no-explicit-any
+import type { Container } from "@sigitex/bind"
+
+export type RouteTree = {
+  [key: string]: string | RouteTree
+}
+
+export type RouterFetch = (
+  request: Request,
+  env: Env,
+) => Promise<Response>
+
+export type RequestContext = {
+  readonly request: Request
+  readonly env: Env
+  readonly url: URL
+  readonly bind: RouterBind
+  readonly dispatch: RouterDispatch
+}
+
+export type RouterBind = (bindings: { [key: string]: any }) => void
+
+export type RouterDispatch = (
+  handler: RequestHandler,
+  middlewares: RouteMiddleware[],
+) => Promise<Response | undefined>
+
+export type ResponseContext = RequestContext & {
+  readonly response: Response
+}
+
+export type RequestHandler = (
+  context: any,
+) => unknown
+
+export type ResponseHandler = (
+  context: any,
+) => unknown
+
+export type RouterOptions = {
+  readonly container?: Container
+  readonly middlewares?: RouteMiddleware[]
+}
+
+export type RouteMiddleware = {
+  readonly before?: RequestHandler
+  readonly after?: ResponseHandler
+}