flowrouter is the new router and ittyrouter is the old router

example/bun-autorouter.ts

@@ -0,0 +1,12 @@
+import { AutoRouter } from '../src/AutoRouter'
+
+const router = AutoRouter({ port: 3001 })
+
+router
+  .get('/basic', () => new Response('Success!'))
+  .get('/text', () => 'Success!')
+  .get('/params/:foo', ({ foo }) => foo)
+  .get('/json', () => ({ foo: 'bar' }))
+  .get('/throw', (a) => a.b.c)
+
+export default router

example/bun-flowrouter.ts

@@ -0,0 +1,22 @@
+import { FlowRouter } from '../src/Router'
+import { error } from '../src/error'
+import { json } from '../src/json'
+import { withParams } from '../src/withParams'
+
+const router = FlowRouter({
+  port: 3001,
+  before: [withParams],
+  onError: [error],
+  after: [json],
+  missing: () => error(404, 'Are you sure about that?'),
+})
+
+router
+  .get('/basic', () => new Response('Success!'))
+  .get('/text', () => 'Success!')
+  .get('/params/:foo', ({ foo }) => foo)
+  .get('/json', () => ({ foo: 'bar' }))
+  .get('/throw', (a) => a.b.c)
+  // .all('*', () => error(404)) // still works
+
+export default router

example/request-types.ts

@@ -1,4 +1,4 @@
-import { IRequest, IRequestStrict, Router } from '../src/Router'
+import { IRequest, IRequestStrict, Router } from '../src/IttyRouter'
 
 type FooRequest = {
   foo: string

package.json

@@ -11,6 +11,11 @@
       "require": "./index.js",
       "types": "./index.d.ts"
     },
+    "./AutoRouter": {
+      "import": "./AutoRouter.mjs",
+      "require": "./AutoRouter.js",
+      "types": "./AutoRouter.d.ts"
+    },
     "./createCors": {
       "import": "./createCors.mjs",
       "require": "./createCors.js",
@@ -26,6 +31,11 @@
       "require": "./error.js",
       "types": "./error.d.ts"
     },
+    "./FlowRouter": {
+      "import": "./FlowRouter.mjs",
+      "require": "./FlowRouter.js",
+      "types": "./FlowRouter.d.ts"
+    },
     "./html": {
       "import": "./html.mjs",
       "require": "./html.js",

src/AutoRouter.ts

@@ -0,0 +1,12 @@
+import { error } from 'error'
+import { json } from 'json'
+import { withParams } from 'withParams'
+import { Router, RouterOptions} from './Router'
+
+export const AutoRouter = (options?: RouterOptions) => Router({
+  before: [withParams],
+  onError: [error],
+  after: [json],
+  missing: () => error(404, 'Are you sure about that?'),
+  ...options,
+})

src/Router.spec.ts → src/IttyRouter.spec.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest'
 import { createTestRunner, extract, toReq } from '../test'
-import { Router } from './Router'
+import { IttyRouter as Router } from './IttyRouter'
 
 const ERROR_MESSAGE = 'Error Message'
 

src/IttyRouter.ts

@@ -0,0 +1,125 @@
+export type GenericTraps = {
+  [key: string]: any
+}
+
+export type RequestLike = {
+  method: string,
+  url: string,
+} & GenericTraps
+
+export type IRequestStrict = {
+  method: string,
+  url: string,
+  route: string,
+  params: {
+    [key: string]: string,
+  },
+  query: {
+    [key: string]: string | string[] | undefined,
+  },
+  proxy?: any,
+} & Request
+
+export type IRequest = IRequestStrict & GenericTraps
+
+export type IttyRouterOptions = {
+  base?: string
+  routes?: RouteEntry[]
+} & Record<string, any>
+
+export type RouteHandler<I = IRequest, A extends any[] = any[]> = {
+  (request: I, ...args: A): any
+}
+
+export type RouteEntry = [
+  httpMethod: string,
+  match: RegExp,
+  handlers: RouteHandler[],
+  path?: string,
+]
+
+// this is the generic "Route", which allows per-route overrides
+export type Route = <RequestType = IRequest, Args extends any[] = any[], RT = RouterType>(
+  path: string,
+  ...handlers: RouteHandler<RequestType, Args>[]
+) => RT
+
+// this is an alternative UniveralRoute, accepting generics (from upstream), but without
+// per-route overrides
+export type UniversalRoute<RequestType = IRequest, Args extends any[] = any[]> = (
+  path: string,
+  ...handlers: RouteHandler<RequestType, Args>[]
+) => RouterType<UniversalRoute<RequestType, Args>, Args>
+
+// helper function to detect equality in types (used to detect custom Request on router)
+export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
+
+export type CustomRoutes<R = Route> = {
+  [key: string]: R,
+}
+
+export type RouterType<R = Route, Args extends any[] = any[]> = {
+  __proto__: RouterType<R>,
+  routes: RouteEntry[],
+  fetch: <A extends any[] = Args>(request: RequestLike, ...extra: Equal<R, Args> extends true ? A : Args) => Promise<any>
+  handle: <A extends any[] = Args>(request: RequestLike, ...extra: Equal<R, Args> extends true ? A : Args) => Promise<any>
+  all: R,
+  delete: R,
+  get: R,
+  head: R,
+  options: R,
+  patch: R,
+  post: R,
+  put: R,
+} & CustomRoutes<R> & Record<string, any>
+
+export const IttyRouter = <
+  RequestType = IRequest,
+  Args extends any[] = any[],
+  RouteType = Equal<RequestType, IRequest> extends true ? Route : UniversalRoute<RequestType, Args>
+>({ base = '', routes = [], ...other }: IttyRouterOptions = {}): RouterType<RouteType, Args> =>
+  // @ts-expect-error TypeScript doesn't know that Proxy makes this work
+  ({
+    __proto__: new Proxy({}, {
+      // @ts-expect-error (we're adding an expected prop "path" to the get)
+      get: (target: any, prop: string, receiver: RouterType, path: string) =>
+        prop == 'handle' ? receiver.fetch :
+        // @ts-expect-error - unresolved type
+        (route: string, ...handlers: RouteHandler<I>[]) =>
+          routes.push(
+            [
+              prop.toUpperCase?.(),
+              RegExp(`^${(path = (base + route)
+                .replace(/\/+(\/|$)/g, '$1'))                       // strip double & trailing splash
+                .replace(/(\/?\.?):(\w+)\+/g, '($1(?<$2>*))')       // greedy params
+                .replace(/(\/?\.?):(\w+)/g, '($1(?<$2>[^$1/]+?))')  // named params and image format
+                .replace(/\./g, '\\.')                              // dot in path
+                .replace(/(\/?)\*/g, '($1.*)?')                     // wildcard
+              }/*$`),
+              handlers,                                             // embed handlers
+              path,                                                 // embed clean route path
+            ]
+          ) && receiver
+    }),
+    routes,
+    ...other,
+    async fetch (request: RequestLike, ...args)  {
+      let response,
+          match,
+          url = new URL(request.url),
+          query: Record<string, any> = request.query = { __proto__: null }
+
+      // 1. parse query params
+      for (let [k, v] of url.searchParams)
+        query[k] = query[k] ? ([] as string[]).concat(query[k], v) : v
+
+      // 2. then test routes
+      for (let [method, regex, handlers, path] of routes)
+        if ((method == request.method || method == 'ALL') && (match = url.pathname.match(regex))) {
+          request.params = match.groups || {}                                     // embed params in request
+          request.route = path                                                    // embed route path in request
+          for (let handler of handlers)
+            if ((response = await handler(request.proxy ?? request, ...args)) != null) return response
+        }
+    },
+  })

src/Router.ts

@@ -1,77 +1,21 @@
-export type GenericTraps = {
-  [key: string]: any
-}
+import {
+  Equal,
+  IRequest,
+  RequestLike,
+  Route,
+  RouteHandler,
+  IttyRouterOptions,
+  RouterType,
+  UniversalRoute,
+} from './IttyRouter'
 
-export type RequestLike = {
-  method: string,
-  url: string,
-} & GenericTraps
-
-export type IRequestStrict = {
-  method: string,
-  url: string,
-  route: string,
-  params: {
-    [key: string]: string,
-  },
-  query: {
-    [key: string]: string | string[] | undefined,
-  },
-  proxy?: any,
-} & Request
-
-export type IRequest = IRequestStrict & GenericTraps
+export type ErrorHandler = <Input = Error>(input: Input) => void
 
 export type RouterOptions = {
-  base?: string
-  routes?: RouteEntry[]
-} & Record<string, any>
-
-export type RouteHandler<I = IRequest, A extends any[] = any[]> = {
-  (request: I, ...args: A): any
-}
-
-export type RouteEntry = [
-  httpMethod: string,
-  match: RegExp,
-  handlers: RouteHandler[],
-  path?: string,
-]
-
-// this is the generic "Route", which allows per-route overrides
-export type Route = <RequestType = IRequest, Args extends any[] = any[], RT = RouterType>(
-  path: string,
-  ...handlers: RouteHandler<RequestType, Args>[]
-) => RT
-
-// this is an alternative UniveralRoute, accepting generics (from upstream), but without
-// per-route overrides
-export type UniversalRoute<RequestType = IRequest, Args extends any[] = any[]> = (
-  path: string,
-  ...handlers: RouteHandler<RequestType, Args>[]
-) => RouterType<UniversalRoute<RequestType, Args>, Args>
-
-// helper function to detect equality in types (used to detect custom Request on router)
-type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2) ? true : false;
-
-export type CustomRoutes<R = Route> = {
-  [key: string]: R,
-}
-
-export type RouterType<R = Route, Args extends any[] = any[]> = {
-  __proto__: RouterType<R>,
-  routes: RouteEntry[],
-  fetch: <A extends any[] = Args>(request: RequestLike, ...extra: Equal<R, Args> extends true ? A : Args) => Promise<any>
-  handle: <A extends any[] = Args>(request: RequestLike, ...extra: Equal<R, Args> extends true ? A : Args) => Promise<any>
-  all: R,
-  delete: R,
-  get: R,
-  head: R,
-  options: R,
-  patch: R,
-  post: R,
-  put: R,
-} & CustomRoutes<R> & Record<string, any>
+  before?: Function[]
+  onError?: ErrorHandler[]
+  after?: Function[]
+} & IttyRouterOptions
 
 export const Router = <
   RequestType = IRequest,
@@ -83,40 +27,62 @@ export const Router = <
     __proto__: new Proxy({}, {
       // @ts-expect-error (we're adding an expected prop "path" to the get)
       get: (target: any, prop: string, receiver: RouterType, path: string) =>
-        prop == 'handle' ? receiver.fetch :
-        // @ts-expect-error - unresolved type
-        (route: string, ...handlers: RouteHandler<I>[]) =>
-          routes.push(
-            [
-              prop.toUpperCase?.(),
-              RegExp(`^${(path = (base + route)
-                .replace(/\/+(\/|$)/g, '$1'))                       // strip double & trailing splash
-                .replace(/(\/?\.?):(\w+)\+/g, '($1(?<$2>*))')       // greedy params
-                .replace(/(\/?\.?):(\w+)/g, '($1(?<$2>[^$1/]+?))')  // named params and image format
-                .replace(/\./g, '\\.')                              // dot in path
-                .replace(/(\/?)\*/g, '($1.*)?')                     // wildcard
-              }/*$`),
-              handlers,                                             // embed handlers
-              path,                                                 // embed clean route path
-            ]
-          ) && receiver
+        // prop == 'handle' ? receiver.fetch :
+          // @ts-expect-error - unresolved type
+          (route: string, ...handlers: RouteHandler<I>[]) =>
+            routes.push(
+              [
+                prop.toUpperCase?.(),
+                RegExp(`^${(path = (base + route)
+                  .replace(/\/+(\/|$)/g, '$1'))                       // strip double & trailing splash
+                  .replace(/(\/?\.?):(\w+)\+/g, '($1(?<$2>*))')       // greedy params
+                  .replace(/(\/?\.?):(\w+)/g, '($1(?<$2>[^$1/]+?))')  // named params and image format
+                  .replace(/\./g, '\\.')                              // dot in path
+                  .replace(/(\/?)\*/g, '($1.*)?')                     // wildcard
+                }/*$`),
+                handlers,                                             // embed handlers
+                path,                                                 // embed clean route path
+              ]
+            ) && receiver
     }),
     routes,
     ...other,
-    async fetch (request: RequestLike, ...args)  {
-      let response, match, url = new URL(request.url), query: Record<string, any> = request.query = { __proto__: null }
+    async fetch (request: RequestLike, ...args) {
+      let response,
+          match,
+          url = new URL(request.url),
+          query: Record<string, any> = request.query = { __proto__: null }
+
+      try {
+        // 1. parse query params
+        for (let [k, v] of url.searchParams)
+          query[k] = query[k] ? ([] as string[]).concat(query[k], v) : v
+
+        for (let handler of other.before || [])
+          if ((response = await handler(request.proxy ?? request, ...args)) != null) break
+
+        // 2. then test routes
+        outer: for (let [method, regex, handlers, path] of routes)
+          if ((method == request.method || method == 'ALL') && (match = url.pathname.match(regex))) {
+            request.params = match.groups || {}                                     // embed params in request
+            request.route = path                                                    // embed route path in request
+
+            for (let handler of handlers)
+              if ((response = await handler(request.proxy ?? request, ...args)) != null) break outer
+          }
+
+        // 3. respond with missing hook if available + needed
+        response = response ?? other.missing?.(request.proxy ?? request, ...args)
+      } catch (err) {
+        if (!other.onError) throw err
+
+        for (let handler of other.onError || [])
+          response = await handler(response ?? err)
+      }
 
-      // 1. parse query params
-      for (let [k, v] of url.searchParams)
-        query[k] = query[k] ? ([] as string[]).concat(query[k], v) : v
+      for (let handler of other.after || [])
+        response = await handler(response)
 
-      // 2. then test routes
-      for (let [method, regex, handlers, path] of routes)
-        if ((method == request.method || method == 'ALL') && (match = url.pathname.match(regex))) {
-          request.params = match.groups || {}                                     // embed params in request
-          request.route = path                                                    // embed route path in request
-          for (let handler of handlers)
-            if ((response = await handler(request.proxy ?? request, ...args)) != null) return response
-        }
+      return response
     },
   })