Middleware Timeout

Le middleware Timeout permet de gérer facilement les délais d’expiration des requêtes dans votre application. Il permet de définir une durée maximale pour les requêtes et, si vous le souhaitez, des réponses d’erreur personnalisées lorsque cette durée est dépassée.

Importation

import { Hono } from 'hono'
import { timeout } from 'hono/timeout'

Utilisation

Voici comment utiliser le middleware Timeout avec des paramètres par défaut et personnalisés :

Paramètres par défaut :

const app = new Hono()

// Applying a 5-second timeout
app.use('/api', timeout(5000))

// Handling a route
app.get('/api/data', async (c) => {
  // Your route handler logic
  return c.json({ data: 'Your data here' })
})

Paramètres personnalisés :

import { HTTPException } from 'hono/http-exception'

// Custom exception factory function
const customTimeoutException = (context) =>
  new HTTPException(408, {
    message: `Request timeout after waiting ${context.req.headers.get(
      'Duration'
    )} seconds. Please try again later.`,
  })

// for Static Exception Message
// const customTimeoutException = new HTTPException(408, {
//   message: 'Operation timed out. Please try again later.'
// });

// Applying a 1-minute timeout with a custom exception
app.use('/api/long-process', timeout(60000, customTimeoutException))

app.get('/api/long-process', async (c) => {
  // Simulate a long process
  await new Promise((resolve) => setTimeout(resolve, 61000))
  return c.json({ data: 'This usually takes longer' })
})

Remarques

• Le délai d’expiration peut être spécifié en millisecondes. Le middleware rejette automatiquement la Promise et peut lever une erreur si la durée spécifiée est dépassée.

• Le middleware Timeout ne peut pas être utilisé avec un flux. Utilisez plutôt stream.close et setTimeout ensemble.

app.get('/sse', async (c) => {
  let id = 0
  let running = true
  let timer: number | undefined

  return streamSSE(c, async (stream) => {
    timer = setTimeout(() => {
      console.log('Stream timeout reached, closing stream')
      stream.close()
    }, 3000) as unknown as number

    stream.onAbort(async () => {
      console.log('Client closed connection')
      running = false
      clearTimeout(timer)
    })

    while (running) {
      const message = `It is ${new Date().toISOString()}`
      await stream.writeSSE({
        data: message,
        event: 'time-update',
        id: String(id++),
      })
      await stream.sleep(1000)
    }
  })
})

Conflits entre middlewares

Soyez attentif à l’ordre des middlewares, en particulier lorsque vous utilisez des middlewares de gestion des erreurs ou liés aux durées, car cela peut affecter le comportement du middleware Timeout.