feat(middleware): Introduce Timeout Middleware

deno_dist/middleware.ts

@@ -13,6 +13,7 @@ export { jwt } from './middleware/jwt/index.ts'
 export * from './middleware/logger/index.ts'
 export * from './middleware/method-override/index.ts'
 export * from './middleware/powered-by/index.ts'
+export * from './middleware/timeout/index.ts'
 export * from './middleware/timing/index.ts'
 export * from './middleware/pretty-json/index.ts'
 export * from './middleware/secure-headers/index.ts'

deno_dist/middleware/timeout/index.ts

@@ -0,0 +1,61 @@
+import { HTTPException } from '../../http-exception.ts'
+import type { MiddlewareHandler } from '../../types.ts'
+import type { StatusCode } from '../../utils/http-status.ts'
+
+interface TimeoutOptions {
+  message?: string
+  code?: StatusCode
+}
+
+const DEFAULT_ERROR_MESSAGE = 'Gateway Timeout'
+const DEFAULT_ERROR_CODE = 504
+
+interface DurationUnits {
+  [key: string]: number
+}
+
+const parseDuration = (duration: string): number => {
+  const units: DurationUnits = { ms: 1, s: 1000, m: 60000, h: 3600000 }
+  const pattern = /(\d+)(ms|s|m|h)/g
+  let totalMilliseconds = 0
+
+  let match: RegExpExecArray | null
+  while ((match = pattern.exec(duration)) !== null) {
+    const value = parseInt(match[1], 10)
+    const unit = match[2]
+
+    if (!units[unit]) {
+      throw new Error(`Unsupported time unit: ${unit}`)
+    }
+    totalMilliseconds += value * units[unit]
+  }
+
+  return totalMilliseconds
+}
+
+export const timeout = (
+  duration: number | string,
+  options: TimeoutOptions = {}
+): MiddlewareHandler => {
+  const errorMessage = options.message ?? DEFAULT_ERROR_MESSAGE
+  const errorCode = options.code ?? DEFAULT_ERROR_CODE
+  const ms = typeof duration === 'string' ? parseDuration(duration) : duration
+
+  return async (context, next) => {
+    let timer: number | undefined
+
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new HTTPException(errorCode, { message: errorMessage }))
+      }, ms) as unknown as number
+    })
+
+    try {
+      await Promise.race([next(), timeoutPromise])
+    } finally {
+      if (timer !== undefined) {
+        clearTimeout(timer)
+      }
+    }
+  }
+}

package.json

@@ -179,6 +179,11 @@
       "import": "./dist/middleware/jwt/index.js",
       "require": "./dist/cjs/middleware/jwt/index.js"
     },
+    "./timeout": {
+      "types": "./dist/types/middleware/timeout/index.d.ts",
+      "import": "./dist/middleware/timeout/index.js",
+      "require": "./dist/cjs/middleware/timeout/index.js"
+    },
     "./timing": {
       "types": "./dist/types/middleware/timing/index.d.ts",
       "import": "./dist/middleware/timing/index.js",

src/middleware.ts

@@ -13,6 +13,7 @@ export { jwt } from './middleware/jwt'
 export * from './middleware/logger'
 export * from './middleware/method-override'
 export * from './middleware/powered-by'
+export * from './middleware/timeout'
 export * from './middleware/timing'
 export * from './middleware/pretty-json'
 export * from './middleware/secure-headers'

src/middleware/timeout/index.test.ts

@@ -0,0 +1,70 @@
+import { Hono } from '../../hono'
+import { timeout } from '.'
+
+describe('Timeout API', () => {
+  const app = new Hono()
+  app.use('/slow-endpoint', timeout(1000))
+  app.use(
+    '/slow-endpoint/custom',
+    timeout('1s100ms', {
+      message: 'Request timeout. Please try again later.',
+      code: 408,
+    })
+  )
+  app.use(
+    '/slow-endpoint/error',
+    timeout('1s2000ms', {
+      message: 'Request timeout. Please try again later.',
+      code: 408,
+    })
+  )
+  app.use('/normal-endpoint', timeout(1000))
+
+  app.get('/slow-endpoint', async (c) => {
+    await new Promise((resolve) => setTimeout(resolve, 1100))
+    return c.text('This should not show up')
+  })
+
+  app.get('/slow-endpoint/custom', async (c) => {
+    await new Promise((resolve) => setTimeout(resolve, 1100))
+    return c.text('This should not show up')
+  })
+
+  app.get('/slow-endpoint/error', async (c) => {
+    await new Promise((resolve) => setTimeout(resolve, 1100))
+    return c.text('This should not show up')
+  })
+
+  app.get('/normal-endpoint', async (c) => {
+    await new Promise((resolve) => setTimeout(resolve, 900))
+    return c.text('This should not show up')
+  })
+
+  it('Should contain total duration', async () => {
+    const res = await app.request('http://localhost/slow-endpoint')
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(504)
+    expect(await res.text()).toContain('Gateway Timeout')
+  })
+
+  it('Should apply custom error message and status code', async () => {
+    const res = await app.request('http://localhost/slow-endpoint/custom')
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(408)
+    expect(await res.text()).toContain('Request timeout. Please try again later.')
+  })
+
+  it('Error timeout', async () => {
+    const res = await app.request('http://localhost/slow-endpoint/error')
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(200) // Confirming the endpoint does not trigger a timeout as expected
+    expect(await res.text()).toContain('This should not show up')
+  })
+
+  it('No Timeout', async () => {
+    const res = await app.request('http://localhost/normal-endpoint')
+    expect(res).not.toBeNull()
+    expect(res.status).toBe(200)
+    expect(await res.text()).toContain('This should not show up')
+  })
+})

src/middleware/timeout/index.ts

@@ -0,0 +1,61 @@
+import { HTTPException } from '../../http-exception'
+import type { MiddlewareHandler } from '../../types'
+import type { StatusCode } from '../../utils/http-status'
+
+interface TimeoutOptions {
+  message?: string
+  code?: StatusCode
+}
+
+const DEFAULT_ERROR_MESSAGE = 'Gateway Timeout'
+const DEFAULT_ERROR_CODE = 504
+
+interface DurationUnits {
+  [key: string]: number
+}
+
+const parseDuration = (duration: string): number => {
+  const units: DurationUnits = { ms: 1, s: 1000, m: 60000, h: 3600000 }
+  const pattern = /(\d+)(ms|s|m|h)/g
+  let totalMilliseconds = 0
+
+  let match: RegExpExecArray | null
+  while ((match = pattern.exec(duration)) !== null) {
+    const value = parseInt(match[1], 10)
+    const unit = match[2]
+
+    if (!units[unit]) {
+      throw new Error(`Unsupported time unit: ${unit}`)
+    }
+    totalMilliseconds += value * units[unit]
+  }
+
+  return totalMilliseconds
+}
+
+export const timeout = (
+  duration: number | string,
+  options: TimeoutOptions = {}
+): MiddlewareHandler => {
+  const errorMessage = options.message ?? DEFAULT_ERROR_MESSAGE
+  const errorCode = options.code ?? DEFAULT_ERROR_CODE
+  const ms = typeof duration === 'string' ? parseDuration(duration) : duration
+
+  return async (context, next) => {
+    let timer: number | undefined
+
+    const timeoutPromise = new Promise<void>((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new HTTPException(errorCode, { message: errorMessage }))
+      }, ms) as unknown as number
+    })
+
+    try {
+      await Promise.race([next(), timeoutPromise])
+    } finally {
+      if (timer !== undefined) {
+        clearTimeout(timer)
+      }
+    }
+  }
+}