404 / error handling

# Conflicts:
#	packages/typescript-koa-runtime/src/server.ts

Author: mnahkies

e2e/src/express.entrypoint.ts

@@ -1,4 +1,3 @@
-import {ExpressRuntimeError} from "@nahkies/typescript-express-runtime/errors"
 import {type NextFunction, type Request, type Response, Router} from "express"
 import {bootstrap} from "./generated/server/express"
 import {createRequestHeadersRouter} from "./routes/express/request-headers"
@@ -26,15 +25,22 @@ export async function startExpressServer() {
       origin: "http://example.com",
     },
     router: createRouter(),
-  })
-
-  app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
-    if (res.headersSent) {
-      return next(err)
-    }
-
-    const {status, body} = createErrorResponse(err)
-    res.status(status).json(body)
+    notFoundHandler: (req: Request, res: Response, next: NextFunction) => {
+      res.status(404).json({code: 404, message: "route not found"})
+    },
+    errorHandler: (
+      err: Error,
+      req: Request,
+      res: Response,
+      next: NextFunction,
+    ) => {
+      if (res.headersSent) {
+        return next(err)
+      }
+
+      const {status, body} = createErrorResponse(err)
+      res.status(status).json(body)
+    },
   })
 
   return {app, server, address}

e2e/src/index.axios.spec.ts

@@ -66,14 +66,18 @@ describe.each(startServerFunctions)(
             () => {
               throw new Error("expected request to fail")
             },
-            (err: unknown) => err,
+            (err: AxiosError) => err,
           )
 
         expect(err).toMatchObject({
           message: "Request failed with status code 404",
           name: "AxiosError",
           status: 404,
         })
+        expect(err.response?.data).toMatchObject({
+          code: 404,
+          message: "route not found",
+        })
       })
     })
 

e2e/src/index.fetch.spec.ts

@@ -64,6 +64,10 @@ describe.each(startServerFunctions)(
         })
 
         expect(res.status).toBe(404)
+        await expect(res.json()).resolves.toMatchObject({
+          code: 404,
+          message: "route not found",
+        })
       })
     })
 

e2e/src/koa.entrypoint.ts

@@ -7,16 +7,6 @@ import {createErrorResponse} from "./shared"
 function createRouter() {
   const router = new Router()
 
-  router.use(async (ctx, next) => {
-    try {
-      await next()
-    } catch (err) {
-      const {status, body} = createErrorResponse(err)
-      ctx.status = status
-      ctx.body = body
-    }
-  })
-
   const requestHeadersRouter = createRequestHeadersRouter()
   const validationRouter = createValidationRouter()
 
@@ -37,6 +27,25 @@ export async function startKoaServer() {
       allowMethods: ["GET", "OPTIONS"],
       origin: "http://example.com",
     },
+    middleware: [
+      async function errorHandler(ctx, next) {
+        try {
+          await next()
+        } catch (err) {
+          const {status, body} = createErrorResponse(err)
+          ctx.status = status
+          ctx.body = body
+        }
+      },
+      async function notFoundHandler(ctx, next) {
+        await next()
+        if (ctx.body || ctx.status !== 404) {
+          return
+        }
+        ctx.status = 404
+        ctx.body = {code: 404, message: "route not found"}
+      },
+    ],
     router: createRouter(),
   })
 }

packages/typescript-express-runtime/src/server.ts

@@ -4,7 +4,12 @@ import type {AddressInfo} from "node:net"
 
 import type {OptionsJson} from "body-parser"
 import Cors, {type CorsOptions, type CorsOptionsDelegate} from "cors"
-import express, {type Express, type RequestHandler, type Router} from "express"
+import express, {
+  type ErrorRequestHandler,
+  type Express,
+  type RequestHandler,
+  type Router,
+} from "express"
 
 // from https://stackoverflow.com/questions/39494689/is-it-possible-to-restrict-number-to-a-certain-range
 type Enumerate<
@@ -79,10 +84,20 @@ export type ServerConfig = {
 
   /**
    * provide arbitrary express middleware to be mounted before all request handlers
-   * useful for mounting logging, error handlers, alternative body parsers, etc
+   * useful for mounting logging, alternative body parsers, etc
    */
   middleware?: RequestHandler[]
 
+  /**
+   * Provide a custom 404 handler
+   */
+  notFoundHandler?: RequestHandler
+
+  /**
+   * Provide a custom error handler
+   */
+  errorHandler?: ErrorRequestHandler
+
   /**
    * the router to use, normally obtained by calling the generated `createRouter`
    * function
@@ -119,6 +134,8 @@ export async function startServer({
   body = undefined,
   port = 0,
   router,
+  notFoundHandler,
+  errorHandler,
 }: ServerConfig): Promise<{
   app: Express
   server: Server
@@ -143,6 +160,14 @@ export async function startServer({
 
   app.use(router)
 
+  if (notFoundHandler) {
+    app.use(notFoundHandler)
+  }
+
+  if (errorHandler) {
+    app.use(errorHandler)
+  }
+
   return new Promise((resolve, reject) => {
     try {
       const server = app.listen(port)

packages/typescript-koa-runtime/src/server.ts

@@ -62,7 +62,11 @@ export type KoaRuntimeResponder<
 }
 
 export type ServerConfig = {
-  /** set to "disabled" to disable cors middleware, omit or pass undefined for defaults */
+  /**
+   * set to "disabled" to disable cors middleware, omit or pass undefined for defaults
+   *
+   * the default behavior is to allow all origins
+   **/
   cors?: "disabled" | Cors.Options | undefined
 
   /**
@@ -74,8 +78,8 @@ export type ServerConfig = {
   body?: "disabled" | KoaBodyMiddlewareOptions | undefined
 
   /**
-   *
-   * useful for mounting logging, alternative body parsers, etc.
+   * allows you to provide arbitrary koa middleware
+   * useful for mounting logging, error handlers, 404 handling, alternative body parsers, etc.
    */
   middleware?: Middleware[]