Utilitaire Factory

L’utilitaire Factory fournit des fonctions utiles pour créer les composants de Hono, comme les middlewares. Il est parfois difficile de définir les bons types TypeScript ; cet utilitaire simplifie cette tâche.

Importation

import { Hono } from 'hono'
import { createFactory, createMiddleware } from 'hono/factory'

createFactory()

createFactory() crée une instance de la classe Factory.

import { createFactory } from 'hono/factory'

const factory = createFactory()

Vous pouvez passer vos types Env comme paramètres génériques :

type Env = {
  Variables: {
    foo: string
  }
}

const factory = createFactory<Env>()

Options

facultatif defaultAppOptions: HonoOptions

Les options par défaut à passer à l’application Hono créée par createApp().

const factory = createFactory({
  defaultAppOptions: { strict: false },
})

const app = factory.createApp() // `strict: false` is applied

createMiddleware()

createMiddleware() est un raccourci pour factory.createMiddleware(). Cette fonction crée votre middleware personnalisé.

const messageMiddleware = createMiddleware(async (c, next) => {
  await next()
  c.res.headers.set('X-Message', 'Good morning!')
})

Conseil : Pour recevoir un argument comme message, vous pouvez l’envelopper dans une fonction comme suit.

const messageMiddleware = (message: string) => {
  return createMiddleware(async (c, next) => {
    await next()
    c.res.headers.set('X-Message', message)
  })
}

app.use(messageMiddleware('Good evening!'))

factory.createHandlers()

createHandlers() permet de définir des gestionnaires ailleurs que dans app.get('/').

import { createFactory } from 'hono/factory'
import { logger } from 'hono/logger'

// ...

const factory = createFactory()

const middleware = factory.createMiddleware(async (c, next) => {
  c.set('foo', 'bar')
  await next()
})

const handlers = factory.createHandlers(logger(), middleware, (c) => {
  return c.json(c.var.foo)
})

app.get('/api', ...handlers)

factory.createApp()

createApp() permet de créer une instance de Hono avec les bons types. En utilisant cette méthode avec createFactory(), vous évitez de répéter la définition du type Env.

Dans une application comme celle-ci, vous devez définir Env à deux endroits :

import { createMiddleware } from 'hono/factory'

type Env = {
  Variables: {
    myVar: string
  }
}

// 1. Set the `Env` to `new Hono()`
const app = new Hono<Env>()

// 2. Set the `Env` to `createMiddleware()`
const mw = createMiddleware<Env>(async (c, next) => {
  await next()
})

app.use(mw)

Avec createFactory() et createApp(), vous ne définissez Env qu’à un seul endroit.

import { createFactory } from 'hono/factory'

// ...

// Set the `Env` to `createFactory()`
const factory = createFactory<Env>()

const app = factory.createApp()

// factory also has `createMiddleware()`
const mw = factory.createMiddleware(async (c, next) => {
  await next()
})

createFactory() accepte l’option initApp pour initialiser une app créée par createApp(). L’exemple suivant utilise cette option.

// factory-with-db.ts
type Env = {
  Bindings: {
    MY_DB: D1Database
  }
  Variables: {
    db: DrizzleD1Database
  }
}

export default createFactory<Env>({
  initApp: (app) => {
    app.use(async (c, next) => {
      const db = drizzle(c.env.MY_DB)
      c.set('db', db)
      await next()
    })
  },
})

// crud.ts
import factoryWithDB from './factory-with-db'

const app = factoryWithDB.createApp()

app.post('/posts', (c) => {
  c.var.db.insert()
  // ...
})