3.2.9

.editorconfig

@@ -7,3 +7,11 @@ insert_final_newline = false
 [src/**.ts]
 charset = utf-8
 indent_style = tab
+
+[README.md]
+indent_style = space
+indent_size = 4
+
+[{package,package-lock}.json]
+indent_style = space
+indent_size = 2

.github/workflows/publish-main.yml

@@ -1,8 +1,8 @@
-name: Publish (pre)
+name: Publish
 
 on:
   release:
-    types: [published]
+    types: [ published ]
 
 jobs:
   publish:
@@ -11,7 +11,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 'latest'
+          node-version: latest
           registry-url: https://registry.npmjs.org/
       - name: Install dependencies
         run: npm ci
@@ -20,12 +20,12 @@ jobs:
       - name: Publish to npmjs
         env:
           NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}}
-        run: npm publish --tag pre --access public
+        run: npm publish --tag latest --access public
       - uses: actions/setup-node@v3
         with:
-          node-version: 'latest'
+          node-version: latest
           registry-url: https://npm.pkg.github.com/
       - name: Publish to GPR
         env:
           NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}
-        run: npm publish --tag pre --access public
+        run: npm publish --tag latest --access public

.github/workflows/test.yml

@@ -0,0 +1,21 @@
+name: Test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  run:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-node@v3
+        with:
+          node-version: latest
+          registry-url: https://registry.npmjs.org/
+      - name: Install dependencies
+        run: npm ci
+      - name: Run tests
+        run: npm test

.npmignore

@@ -1,7 +1,10 @@
-.github/
-src/
-test/
-.nvmrc
-MIGRATION.md
-tsconfig.json
 .editorconfig
+.github/
+.gitignore
+.nvmrc
+coverage/
+jest.config.ts
+MIGRATION.md
+src/
+tests/
+tsconfig.json

MIGRATION.md

@@ -7,7 +7,6 @@ From `v2.x.x` to `v3.x.x`.
 
 - [Update Router](#update-router)
 - [Handlers](#handlers)
-- [Fetch](#fetch--routerhandle)
 
 
 ## Update Router

README.md

@@ -4,8 +4,6 @@ Cloudflare Workers Router is a super lightweight router (1.0K gzipped) with midd
 
 When I was trying out Cloudflare Workers I almost immediately noticed how fast it was compared to other serverless offerings. So I wanted to build a full-fledged API to see how it performs doing real work, but since I wasn't able to find a router that suited my needs I created my own.
 
-I worked a lot with [Express.js](https://expressjs.com/) in the past and really enjoyed their middleware approach, but since none of the available Cloudflare Worker routers offered middleware support at the time, I felt the need to create this router.
-
 
 ## Contents
 
@@ -33,6 +31,10 @@ Migrating from `v2.x.x`, check out the [Migration Guide](MIGRATION.md).
 ```typescript
 import { Router } from '@tsndr/cloudflare-worker-router'
 
+// Env Types
+export type Var<T = string> = T
+export type Secret<T = string> = T
+
 export type Env = {
     // Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
     // MY_KV_NAMESPACE: KVNamespace
@@ -43,11 +45,23 @@ export type Env = {
     // Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
     // MY_BUCKET: R2Bucket
 
-    SECRET_TOKEN: string
+    ENVIRONMENT: Var<'dev' | 'prod'>
+
+    SECRET_TOKEN: Secret
 }
 
-// Initialize router
-const router = new Router<Env>()
+// Request Extension
+export type ExtReq = {
+    userId?: number
+}
+
+// Context Extension
+export type ExtCtx = {
+    //sentry?: Toucan
+}
+
+// Initialize Router
+const router = new Router<Env, ExtCtx, ExtReq>()
 
 // Enabling build in CORS support
 router.cors()
@@ -210,19 +224,20 @@ If enabled will overwrite other `OPTIONS` requests.
 
 #### `config` (object, optional)
 
-Key                    | Type      | Default Value
----------------------- | --------- | -------------
-`allowOrigin`          | `string`  | `*`
-`allowMethods`         | `string`  | `*`
-`allowHeaders`         | `string`  | `*`
-`maxAge`               | `integer` | `86400`
-`optionsSuccessStatus` | `integer` | `204`
+Key                        | Type       | Default Value
+-------------------------- | ---------- | -------------
+`allowOrigin`              | `string`   | `*`
+`allowMethods`             | `string`   | `*`
+`allowHeaders`             | `string`   | `*`
+`allowCredentials`         | `boolean`  | `undefined`
+`vary`                     | `string`   | `undefined`
+`maxAge`                   | `integer`  | `86400`
+`optionsSuccessStatus`     | `integer`  | `204`
 
 
 ### Supported Methods
 
 - `router.any(url, [...handlers])`
-- `router.connect(url, [...handlers])`
 - `router.delete(url, [...handlers])`
 - `router.get(url, [...handlers])`
 - `router.head(url, [...handlers])`
@@ -230,7 +245,6 @@ Key                    | Type      | Default Value
 - `router.patch(url, [...handlers])`
 - `router.post(url, [...handlers])`
 - `router.put(url, [...handlers])`
-- `router.trace(url, [...handlers])`
 
 
 #### `url` (string)
@@ -278,7 +292,7 @@ wrangler init <name>
 Use of TypeScript is strongly encouraged :)
 
 ```bash
-npm i -D @tsndr/cloudflare-worker-router
+npm i @tsndr/cloudflare-worker-router
 ```
 
 
@@ -287,6 +301,10 @@ npm i -D @tsndr/cloudflare-worker-router
 ```typescript
 import { Router } from '@tsndr/cloudflare-worker-router'
 
+// Env Types
+export type Var<T = string> = T
+export type Secret<T = string> = T
+
 export type Env = {
   // Example binding to KV. Learn more at https://developers.cloudflare.com/workers/runtime-apis/kv/
   // MY_KV_NAMESPACE: KVNamespace
@@ -296,32 +314,57 @@ export type Env = {
   //
   // Example binding to R2. Learn more at https://developers.cloudflare.com/workers/runtime-apis/r2/
   // MY_BUCKET: R2Bucket
+  //
+  // Example Variable
+  // ENVIRONMENT: Var<'dev' | 'prod'>
+  //
+  // Example Secret
+  // JWT_SECRET: Secret
 }
 
-const router = new Router<Env>()
+// Request Extension
+export type ExtReq = {
+  userId?: number
+}
+
+// Context Extension
+export type ExtCtx = {
+  //sentry?: Toucan
+}
+
+// Handler Type
+export type Handler = RouterHandler<Env, ExtCtx, ExtReq>
+
+// Initialize Router
+const router = new Router<Env, ExtCtx, ExtReq>()
+
+// Enable Debug Mode
+router.debug()
+
+// Enabling build in CORS support
+//router.cors()
 
 /// Example Route
 //
 // router.get('/hi', async () => {
-//    return new Response('Hello World')
-//})
+//   return new Response('Hello World')
+// })
 
 
 /// Example Route for splitting into multiple files
 //
-// const hiHandler: RouteHandler<Env> = async () => {
+// const helloHandler: Handler = async () => {
 //    return new Response('Hello World')
 // }
 //
-// router.get('/hi', hiHandler)
-
+// router.get('/hellow', helloHandler)
 
 // TODO: add your routes here
 
 export default {
-    async fetch(request: Request, env: Env, ctx: ExecutionContext) {
-        return router.handle(request, env, ctx)
-    }
+  async fetch(request: Request, env: Env, ctx: ExecutionContext) {
+    return router.handle(request, env, ctx)
+  }
 }
 ```
 
@@ -336,6 +379,12 @@ import { Router } from '@tsndr/cloudflare-worker-router'
 
 const router = new Router()
 
+// Enable Debug Mode
+//router.debug()
+
+// Enabling build in CORS support
+//router.cors()
+
 /// Example Route
 //
 // router.get('/hi', async () => {

package.json

@@ -1,22 +1,23 @@
 {
   "name": "@tsndr/cloudflare-worker-router",
-  "version": "3.0.0-16",
+  "version": "3.2.9",
   "description": "",
-  "main": "index.js",
+  "type": "module",
+  "exports": "./index.js",
   "types": "index.d.ts",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "test": "vitest"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/tsndr/cloudflare-worker-router.git"
   },
   "keywords": [
+    "api",
     "cloudflare",
     "cloudflare-worker",
     "cloudflare-workers",
-    "express",
-    "expressjs",
     "framework",
     "middleware",
     "router",
@@ -31,7 +32,9 @@
   },
   "homepage": "https://github.com/tsndr/cloudflare-worker-router#readme",
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20230518.0",
-    "typescript": "^5.0.4"
+    "@cloudflare/workers-types": "^4.20241022.0",
+    "@edge-runtime/vm": "^4.0.3",
+    "typescript": "^5.6.3",
+    "vitest": "^2.1.3"
   }
 }

src/index.ts

@@ -6,10 +6,10 @@
 * @property {string} url URL String
 * @property {RouterHandler[]} handlers Array of handler functions
 */
-export type Route<TEnv, TCtx, TReq> = {
+export type Route<Env, CtxExt, ReqExt> = {
 	method: string
 	url: string
-	handlers: RouterHandler<TEnv, TCtx, TReq>[]
+	handlers: RouterHandler<Env, CtxExt, ReqExt>[]
 }
 
 /**
@@ -20,9 +20,9 @@ export type Route<TEnv, TCtx, TReq> = {
 * @property {RouterRequest} req Request Object
 * @property {ExecutionContext} ctx Context Object
 */
-export type RouterContext<TEnv = any, TCtx = any, TReq = any> = TCtx & {
-	env: TEnv
-	req: RouterRequest<TReq>
+export type RouterContext<Env = any, CtxExt = {}, ReqExt = {}> = CtxExt & {
+	env: Env
+	req: RouterRequest<ReqExt>
 	dbg: boolean
 	ctx?: ExecutionContext
 }
@@ -39,7 +39,7 @@ export type RouterContext<TEnv = any, TCtx = any, TReq = any> = TCtx & {
 * @property {Request} raw Raw Request Object
 * @property {IncomingRequestCfProperties} [cf] object containing custom Cloudflare properties. (https://developers.cloudflare.com/workers/examples/accessing-the-cloudflare-object)
 */
-export type RouterRequest<TReq> = TReq & {
+export type RouterRequest<ReqExt> = ReqExt & {
 	url: string
 	method: string
 	params: RouterRequestParams
@@ -51,7 +51,7 @@ export type RouterRequest<TReq> = TReq & {
 	json<T>(): Promise<T>
 	formData(): Promise<FormData>
 	blob(): Promise<Blob>
-	bearer: () => string | undefined
+	bearer(): string | undefined
 	cf?: IncomingRequestCfProperties
 }
 
@@ -80,8 +80,8 @@ export type RouterRequestQuery = {
 * @param {RouterContext} ctx
 * @returns {Promise<Response | void> Response | void}
 */
-export type RouterHandler<TEnv = any, TCtx = any, TReq = any> = {
-	(ctx: RouterContext<TEnv, TCtx, TReq>): Promise<Response | void> | Response | void
+export type RouterHandler<Env = any, CtxExt = {}, ReqExt = {}> = {
+	(ctx: RouterContext<Env, CtxExt, ReqExt>): Promise<Response | void> | Response | void
 }
 
 /**
@@ -91,6 +91,8 @@ export type RouterHandler<TEnv = any, TCtx = any, TReq = any> = {
 * @property {string} [allowOrigin="*"] Access-Control-Allow-Origin (default: `*`)
 * @property {string} [allowMethods="*"] Access-Control-Allow-Methods (default: `*`)
 * @property {string} [allowHeaders="*"] Access-Control-Allow-Headers (default: `*`)
+* @property {boolean} [allowCredentials="true"] Access-Control-Allow-Credentials (default: undefined)
+* @property {string} [vary="origin"] vary (default: undefined)
 * @property {number} [maxAge=86400] Access-Control-Max-Age (default: `86400`)
 * @property {number} [optionsSuccessStatus=204] Return status code for OPTIONS request (default: `204`)
 */
@@ -98,6 +100,8 @@ export type RouterCorsConfig = {
 	allowOrigin?: string
 	allowMethods?: string
 	allowHeaders?: string
+	allowCredentials?: boolean
+	vary?: string
 	maxAge?: number
 	optionsSuccessStatus?: number
 }
@@ -116,7 +120,7 @@ export type RouterBuffer = {
 * @public
 * @class
 */
-export class Router<TEnv = any, TCtx = any, TReq = any> {
+export class Router<Env = any, CtxExt = {}, ReqExt = {}> {
 
 	/**
 	* Router Array
@@ -124,7 +128,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @protected
 	* @type {Route[]}
 	*/
-	protected routes: Route<TEnv, TCtx, TReq>[] = []
+	protected routes: Route<Env, CtxExt, ReqExt>[] = []
 
 	/**
 	* Global Handlers
@@ -132,7 +136,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @protected
 	* @type {RouterHandler[]}
 	*/
-	protected globalHandlers: RouterHandler<TEnv, TCtx, TReq>[] = []
+	protected globalHandlers: RouterHandler<Env, CtxExt, ReqExt>[] = []
 
 	/**
 	* Debug Mode
@@ -150,14 +154,6 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	*/
 	protected corsConfig: RouterCorsConfig = {}
 
-	/**
-	* Buffer
-	*
-	* @protected
-	* @type {RouterBuffer}
-	*/
-	protected buffer: RouterBuffer = {}
-
 	/**
 	* CORS enabled
 	*
@@ -172,24 +168,13 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public use(...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public use(...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		for (let handler of handlers) {
 			this.globalHandlers.push(handler)
 		}
 		return this
 	}
 
-	/**
-	* Register CONNECT route
-	*
-	* @param {string} url
-	* @param  {RouterHandler[]} handlers
-	* @returns {Router}
-	*/
-	public connect(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
-		return this.register('CONNECT', url, handlers)
-	}
-
 	/**
 	* Register DELETE route
 	*
@@ -197,7 +182,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public delete(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public delete(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('DELETE', url, handlers)
 	}
 
@@ -208,7 +193,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public get(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public get(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('GET', url, handlers)
 	}
 
@@ -219,7 +204,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public head(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public head(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('HEAD', url, handlers)
 	}
 
@@ -230,7 +215,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public options(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public options(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('OPTIONS', url, handlers)
 	}
 
@@ -241,7 +226,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public patch(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public patch(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('PATCH', url, handlers)
 	}
 
@@ -252,7 +237,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public post(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public post(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('POST', url, handlers)
 	}
 
@@ -263,21 +248,10 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public put(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public put(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('PUT', url, handlers)
 	}
 
-	/**
-	* Register TRACE route
-	*
-	* @param {string} url
-	* @param  {RouterHandler[]} handlers
-	* @returns {Router}
-	*/
-	public trace(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
-		return this.register('TRACE', url, handlers)
-	}
-
 	/**
 	* Register route, ignoring method
 	*
@@ -285,7 +259,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param  {RouterHandler[]} handlers
 	* @returns {Router}
 	*/
-	public any(url: string, ...handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	public any(url: string, ...handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		return this.register('*', url, handlers)
 	}
 
@@ -295,7 +269,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param {boolean} [state=true] Whether to turn on or off debug mode (default: true)
 	* @returns {Router}
 	*/
-	public debug(state: boolean = true): Router<TEnv, TCtx, TReq> {
+	public debug(state: boolean = true): Router<Env, CtxExt, ReqExt> {
 		this.debugMode = state
 		return this
 	}
@@ -306,12 +280,14 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param {RouterCorsConfig} [config]
 	* @returns {Router}
 	*/
-	public cors(config?: RouterCorsConfig): Router<TEnv, TCtx, TReq> {
+	public cors(config?: RouterCorsConfig): Router<Env, CtxExt, ReqExt> {
 		this.corsEnabled = true
 		this.corsConfig = {
 			allowOrigin: config?.allowOrigin ?? '*',
 			allowMethods: config?.allowMethods ?? '*',
 			allowHeaders: config?.allowHeaders ?? '*',
+			allowCredentials: config?.allowCredentials ?? undefined,
+			vary: config?.vary ?? undefined,
 			maxAge: config?.maxAge ?? 86400,
 			optionsSuccessStatus: config?.optionsSuccessStatus ?? 204
 		}
@@ -325,6 +301,10 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 			headers.set('Access-Control-Allow-Methods', this.corsConfig.allowMethods)
 		if (this.corsConfig.allowHeaders && !headers.has('Access-Control-Allow-Headers'))
 			headers.set('Access-Control-Allow-Headers', this.corsConfig.allowHeaders)
+		if (this.corsConfig.allowCredentials && !headers.has('Access-Control-Allow-Credentials'))
+			headers.set('Access-Control-Allow-Credentials', this.corsConfig.allowCredentials.toString())
+		if (this.corsConfig.vary && !headers.has('vary'))
+			headers.set('vary', this.corsConfig.vary.toString())
 		if (this.corsConfig.maxAge && !headers.has('Access-Control-Max-Age'))
 			headers.set('Access-Control-Max-Age', this.corsConfig.maxAge.toString())
 		return headers
@@ -339,7 +319,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param {RouterHandler[]} handlers Arrar of handler functions
 	* @returns {Router}
 	*/
-	private register(method: string, url: string, handlers: RouterHandler<TEnv, TCtx, TReq>[]): Router<TEnv, TCtx, TReq> {
+	private register(method: string, url: string, handlers: RouterHandler<Env, CtxExt, ReqExt>[]): Router<Env, CtxExt, ReqExt> {
 		this.routes.push({
 			method,
 			url,
@@ -356,7 +336,7 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 	* @param {RouterRequest} request
 	* @returns {Route | undefined}
 	*/
-	private getRoute(request: RouterRequest<TReq>): Route<TEnv, TCtx, TReq> | undefined {
+	private getRoute(request: RouterRequest<ReqExt>): Route<Env, CtxExt, ReqExt> | undefined {
 		const url = new URL(request.url)
 		const pathArr = url.pathname.split('/').filter(i => i)
 
@@ -390,18 +370,19 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 		}) || this.routes.find(r => r.url === '*' && [request.method, '*'].includes(r.method))
 	}
 
-   /**
+	/**
 	* Handle requests
 	*
 	* @param {Request} request
-	* @param {TEnv} env
-	* @param {TCtx} [extCtx]
-	* @param {TReq} [extReq]
+	* @param {Env} env
+	* @param {CtxExt} [ctxExt]
+	* @param {ReqExt} [reqExt]
 	* @returns {Promise<Response>}
 	*/
-	public async handle(request: Request, env: TEnv, ctx?: ExecutionContext, extCtx?: TCtx, extReq?: TReq): Promise<Response> {
+	public async handle(request: Request, env: Env, ctx?: ExecutionContext, ctxExt?: CtxExt, reqExt?: ReqExt): Promise<Response> {
+		const buffer: RouterBuffer = {}
 		const req = {
-			...(extReq ?? {}),
+			...(reqExt ?? {}),
 			method: request.method,
 			headers: request.headers,
 			url: request.url,
@@ -409,13 +390,13 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 			raw: request,
 			params: {},
 			query: {},
-			arrayBuffer: async (): Promise<ArrayBuffer> => this.buffer.arrayBuffer ? this.buffer.arrayBuffer : this.buffer.arrayBuffer = await request.arrayBuffer(),
-			text: async (): Promise<string> => this.buffer.text ? this.buffer.text : this.buffer.text = await request.text(),
-			json: async <T>(): Promise<T> => this.buffer.json ? this.buffer.json : this.buffer.json = await request.json<T>(),
-			formData: async (): Promise<FormData> => this.buffer.formData ? this.buffer.formData : this.buffer.formData = await request.formData(),
-			blob: async (): Promise<Blob> => this.buffer.blob ? this.buffer.blob : this.buffer.blob = await request.blob(),
+			arrayBuffer: async (): Promise<ArrayBuffer> => buffer.arrayBuffer ? buffer.arrayBuffer : buffer.arrayBuffer = await request.clone().arrayBuffer(),
+			text: async (): Promise<string> => buffer.text ? buffer.text : buffer.text = await request.clone().text(),
+			json: async <T>(): Promise<T> => buffer.json ? buffer.json : buffer.json = await request.clone().json<T>(),
+			formData: async (): Promise<FormData> => buffer.formData ? buffer.formData : buffer.formData = await request.clone().formData(),
+			blob: async (): Promise<Blob> => buffer.blob ? buffer.blob : buffer.blob = await request.clone().blob(),
 			bearer: () => request.headers.get('Authorization')?.replace(/^(B|b)earer /, '').trim()
-		} as RouterRequest<TReq>
+		} as RouterRequest<ReqExt>
 
 		if (this.corsEnabled && req.method === 'OPTIONS') {
 			return new Response(null, {
@@ -425,34 +406,37 @@ export class Router<TEnv = any, TCtx = any, TReq = any> {
 		}
 
 		const route = this.getRoute(req)
-
-		if (!route)
-			return new Response(this.debugMode ? 'Route not found!' : null, { status: 404 })
-
-		const handlers = [...this.globalHandlers, ...route.handlers]
-		const dbg = this.debugMode
-
 		let response: Response | undefined
 
-		for (const handler of handlers) {
-			const context = {
-				...(extCtx ?? {}),
-				env,
-				req,
-				dbg,
-				ctx
-			} as RouterContext<TEnv, TCtx, TReq>
+		if (!route)
+			response = new Response(this.debugMode ? 'Route not found!' : null, { status: 404 })
 
-			const res = await handler(context)
+		if (!response) {
+			const handlers = [
+				...this.globalHandlers,
+				...(route?.handlers ?? [])
+			]
 
-			if (res) {
-				response = res
-				break
+			for (const handler of handlers) {
+				const context = {
+					...(ctxExt ?? {}),
+					env,
+					req,
+					dbg: this.debugMode,
+					ctx
+				} as RouterContext<Env, CtxExt, ReqExt>
+
+				const res = await handler(context)
+
+				if (res) {
+					response = res
+					break
+				}
 			}
 		}
 
 		if (!response)
-			return new Response(this.debugMode ? 'Handler did not return a Response!' : null, { status: 404 })
+			response = new Response(this.debugMode ? 'Handler did not return a Response!' : null, { status: 404 })
 
 		if (this.corsEnabled) {
 			response = new Response(response.body, response)

tests/index.spec.ts

@@ -0,0 +1,366 @@
+import { describe, expect, test } from 'vitest'
+import { Router } from '../src/index'
+
+describe('Router', () => {
+	test('use', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.use(() => testResponse)).toBeInstanceOf(Router)
+
+		router.get('/', () => new Response('failed'))
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('delete', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'DELETE' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.delete('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('get', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'GET' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.get('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('head', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'HEAD' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.head('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('options', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'OPTIONS' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.options('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('patch', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'PATCH' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.patch('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('post', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'POST' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.post('/test', () => testResponse)).toBeInstanceOf(Router)
+		expect(router.post('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('put', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'PUT' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.put('/test', () => testResponse)).toBeInstanceOf(Router)
+		expect(router.put('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('any', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'POST' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.any('/test', () => testResponse)).toBeInstanceOf(Router)
+		expect(router.any('/', () => testResponse)).toBeInstanceOf(Router)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('cors', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/', { method: 'GET' })
+		const testOptionsRequest = new Request('https://example.com/', { method: 'OPTIONS' })
+		const testResponse = new Response('success', { status: 200 })
+
+		expect(router.cors()).toBeInstanceOf(Router)
+
+		router.get('/', () => testResponse)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toBe(200)
+
+		expect(response.headers.get('Access-Control-Allow-Origin')).toBe('*')
+		expect(response.headers.get('Access-Control-Allow-Methods')).toBe('*')
+		expect(response.headers.get('Access-Control-Allow-Headers')).toBe('*')
+		expect(response.headers.get('Access-Control-Allow-Credentials')).toBe(null)
+		expect(response.headers.get('vary')).toBe(null)
+		expect(response.headers.get('Access-Control-Max-Age')).toBe('86400')
+
+		const optionsRes = await router.handle(testOptionsRequest, {})
+
+		expect(optionsRes.status).toBe(204)
+		expect(optionsRes.headers.get('Access-Control-Allow-Origin')).toBe('*')
+		expect(optionsRes.headers.get('Access-Control-Allow-Methods')).toBe('*')
+		expect(optionsRes.headers.get('Access-Control-Allow-Headers')).toBe('*')
+		expect(optionsRes.headers.get('Access-Control-Allow-Credentials')).toBe(null)
+		expect(optionsRes.headers.get('vary')).toBe(null)
+		expect(optionsRes.headers.get('Access-Control-Max-Age')).toBe('86400')
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('params', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/bar/foo')
+
+		router.get('/:foo/:bar', ({ req }) => {
+			return Response.json(req.params)
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.json()).toMatchObject({ foo: 'bar', bar: 'foo' })
+	})
+
+	test('query', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/?foo=bar&bar=foo')
+
+		router.get('/', ({ req }) => {
+			return Response.json(req.query)
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.json()).toMatchObject({ foo: 'bar', bar: 'foo' })
+	})
+
+	test('404', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(404)
+	})
+
+	test('debug mode', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+
+		router.debug()
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(404)
+
+		expect(await response.text()).toBe('Route not found!')
+	})
+
+	test('handler no response', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/')
+
+		router.debug()
+
+		router.get('/', () => {})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(404)
+
+		expect(await response.text()).toBe('Handler did not return a Response!')
+	})
+
+	test('wildcard', async () => {
+		const router = new Router()
+		const testRequest = new Request('https://example.com/foo/bar')
+		const testResponse = new Response('success', { status: 200 })
+
+		router.get('*', () => testResponse)
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('bearer', async () => {
+		const router = new Router()
+		const testToken = 'super-secret-token'
+		const testRequest = new Request('https://example.com/', { headers: { 'Authorization': `Bearer ${testToken}` }})
+
+		router.get('/', ({ req }) => new Response(req.bearer()))
+
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.text()).toBe(testToken)
+	})
+})
+
+describe('Middleware', () => {
+	const router = new Router()
+	const testHandlerSuccess = () => new Response('success', { status: 200 })
+	const testHandlerContinue = () => {}
+	const testHandlerFailed = () => new Response('failed', { status: 403 })
+
+	router.get('/success', testHandlerContinue, testHandlerSuccess)
+	router.get('/failed', testHandlerFailed, testHandlerSuccess)
+
+	test('continue', async () => {
+		const testRequest = new Request('https://example.com/success')
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(200)
+
+		expect(await response.text()).toBe('success')
+	})
+
+	test('block', async () => {
+		const testRequest = new Request('https://example.com/failed')
+		const response = await router.handle(testRequest, {})
+
+		expect(response.status).toEqual(403)
+
+		expect(await response.text()).toBe('failed')
+	})
+})
+
+describe('Body', () => {
+
+	test('text then text', async () => {
+		const router = new Router()
+		const testText = "lorem ipsum dolor sit amet"
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testText })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				text: await req.text(),
+				text2: await req.text()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ text: testText, text2: testText })
+	})
+
+	test('json then json', async () => {
+		const router = new Router()
+		const testObject = { text: 'cloudflare-worker-router', binary: true, amount: 17 }
+		const testJson = JSON.stringify(testObject)
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testJson })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				json: await req.json(),
+				json2: await req.json()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ json: testObject, json2: testObject })
+	})
+
+	test('text then json', async () => {
+		const router = new Router()
+		const testObject = { text: 'cloudflare-worker-router', binary: true, amount: 17 }
+		const testJson = JSON.stringify(testObject)
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testJson })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				text: await req.text(),
+				json: await req.json()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ text: testJson, json: testObject })
+	})
+
+	test('json then text', async () => {
+		const router = new Router()
+		const testObject = { text: 'cloudflare-worker-router', binary: true, amount: 17 }
+		const testJson = JSON.stringify(testObject)
+		const testRequest = new Request('https://example.com/', { method: 'POST', body: testJson })
+
+		router.post('/', async ({ req }) => {
+			return Response.json({
+				json: await req.json(),
+				text: await req.text()
+			})
+		})
+
+		const response = await router.handle(testRequest, {})
+
+		expect(await response.json()).toMatchObject({ text: testJson, json: testObject })
+	})
+})

tsconfig.json

@@ -1,7 +1,7 @@
 {
     "compilerOptions": {
         "outDir": ".",
-        "module": "commonjs",
+        "module": "esnext",
         "target": "esnext",
         "lib": ["esnext"],
         "declaration": true,

vite.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+	test: {
+		environment: 'edge-runtime',
+		reporters: ['verbose'],
+		watch: false
+	}
+})