feat(hono-base): introduce onUnknownError

src/compose.ts

@@ -1,5 +1,5 @@
 import type { Context } from './context'
-import type { Env, ErrorHandler, Next, NotFoundHandler } from './types'
+import type { Env, ErrorHandler, UnknownErrorHandler, Next, NotFoundHandler } from './types'
 
 /**
  * Compose middleware functions into a single function based on `koa-compose` package.
@@ -15,6 +15,7 @@ import type { Env, ErrorHandler, Next, NotFoundHandler } from './types'
 export const compose = <E extends Env = Env>(
   middleware: [[Function, unknown], unknown][] | [[Function]][],
   onError?: ErrorHandler<E>,
+  onUnknownError?: UnknownErrorHandler<E>,
   onNotFound?: NotFoundHandler<E>
 ): ((context: Context, next?: Next) => Promise<Context>) => {
   return (context, next) => {
@@ -50,10 +51,13 @@ export const compose = <E extends Env = Env>(
         try {
           res = await handler(context, () => dispatch(i + 1))
         } catch (err) {
+          context.error = err
           if (err instanceof Error && onError) {
-            context.error = err
             res = await onError(err, context)
             isError = true
+          } else if (onUnknownError) {
+            res = await onUnknownError(err, context)
+            isError = true
           } else {
             throw err
           }

src/context.ts

@@ -313,7 +313,7 @@ export class Context<
    * })
    * ```
    */
-  error: Error | undefined
+  error: unknown | undefined
 
   #status: StatusCode | undefined
   #executionCtx: FetchEventLike | ExecutionContext | undefined

src/hono-base.ts

@@ -24,6 +24,7 @@ import type {
   OnHandlerInterface,
   RouterRoute,
   Schema,
+  UnknownErrorHandler,
 } from './types'
 import { COMPOSED_HANDLER } from './utils/constants'
 import { getPath, getPathNoStrict, mergePath } from './utils/url'
@@ -41,6 +42,11 @@ const errorHandler: ErrorHandler = (err, c) => {
   return c.text('Internal Server Error', 500)
 }
 
+const unknownErrorHandler: UnknownErrorHandler = (err, c) => {
+  console.error(err)
+  return c.text('Internal Server Error', 500)
+}
+
 type GetPath<E extends Env> = (request: Request, options?: { env?: E['Bindings'] }) => string
 
 export type HonoOptions<E extends Env> = {
@@ -173,6 +179,7 @@ class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string =
       getPath: this.getPath,
     })
     clone.errorHandler = this.errorHandler
+    clone.unknownErrorHandler = this.unknownErrorHandler
     clone.#notFoundHandler = this.#notFoundHandler
     clone.routes = this.routes
     return clone
@@ -181,6 +188,7 @@ class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string =
   #notFoundHandler: NotFoundHandler = notFoundHandler
   // Cannot use `#` because it requires visibility at JavaScript runtime.
   private errorHandler: ErrorHandler = errorHandler
+  private unknownErrorHandler: UnknownErrorHandler = unknownErrorHandler
 
   /**
    * `.route()` allows grouping other Hono instance in routes.
@@ -265,6 +273,11 @@ class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string =
     return this
   }
 
+  onUnknownError = (handler: UnknownErrorHandler): Hono<E, S, BasePath> => {
+    this.unknownErrorHandler = handler
+    return this
+  }
+
   /**
    * `.notFound()` allows you to customize a Not Found Response.
    *
@@ -386,7 +399,7 @@ class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string =
     if (err instanceof Error) {
       return this.errorHandler(err, c)
     }
-    throw err
+    return this.unknownErrorHandler(err, c)
   }
 
   #dispatch(
@@ -433,7 +446,12 @@ class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends string =
         : res ?? this.#notFoundHandler(c)
     }
 
-    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler)
+    const composed = compose(
+      matchResult[0],
+      this.errorHandler,
+      this.unknownErrorHandler,
+      this.#notFoundHandler
+    )
 
     return (async () => {
       try {

src/types.ts

@@ -100,6 +100,11 @@ export type ErrorHandler<E extends Env = any> = (
   c: Context<E>
 ) => Response | Promise<Response>
 
+export type UnknownErrorHandler<E extends Env = any> = (
+  err: unknown,
+  c: Context<E>
+) => Response | Promise<Response>
+
 ////////////////////////////////////////
 //////                            //////
 //////     HandlerInterface       //////