Deno

Deno est un environnement d'exécution JavaScript construit sur V8, distinct de Node.js. Hono fonctionne aussi sur Deno.

Vous pouvez utiliser Hono, écrire le code en TypeScript, exécuter l'application avec la commande deno et la déployer sur « Deno Deploy ».

1. Installation de Deno

Installez d'abord la commande deno. Consultez la documentation officielle.

2. Configuration

Un modèle de démarrage est disponible pour Deno. Créez votre projet avec la commande deno init.

deno init --npm hono --template=deno my-app

Ouvrez my-app. Avec Deno, vous n'avez pas à installer Hono explicitement.

cd my-app

3. Bonjour le monde

Modifiez main.ts :

main.ts

import { Hono } from 'hono'

const app = new Hono()

app.get('/', (c) => c.text('Hello Deno!'))

Deno.serve(app.fetch)

4. Exécution

Démarrez le serveur de développement localement. Ensuite, ouvrez http://localhost:8000 dans votre navigateur web.

deno task start

Modifier le numéro de port

Vous pouvez préciser le numéro de port en modifiant les arguments de Deno.serve dans main.ts :

Deno.serve(app.fetch) 
Deno.serve({ port: 8787 }, app.fetch) 

Servir des fichiers statiques

Pour servir des fichiers statiques, utilisez serveStatic du paquet @hono/deno.

deno add jsr:@hono/deno

import { Hono } from 'hono'
import { serveStatic } from '@hono/deno'

const app = new Hono()

app.use('/static/*', serveStatic({ root: './' }))
app.use('/favicon.ico', serveStatic({ path: './favicon.ico' }))
app.get('/', (c) => c.text('You can access: /static/hello.txt'))
app.get('*', serveStatic({ path: './static/fallback.txt' }))

Deno.serve(app.fetch)

Le code ci-dessus fonctionne avec l'arborescence suivante.

./
├── favicon.ico
├── index.ts
└── static
    ├── demo
    │   └── index.html
    ├── fallback.txt
    ├── hello.txt
    └── images
        └── dinotocat.png

rewriteRequestPath

Si vous souhaitez faire correspondre http://localhost:8000/static/* à ./statics, utilisez l'option rewriteRequestPath :

app.get(
  '/static/*',
  serveStatic({
    root: './',
    rewriteRequestPath: (path) =>
      path.replace(/^\/static/, '/statics'),
  })
)

mimes

Vous pouvez ajouter des types MIME avec mimes :

app.get(
  '/static/*',
  serveStatic({
    mimes: {
      m3u8: 'application/vnd.apple.mpegurl',
      ts: 'video/mp2t',
    },
  })
)

onFound

Avec onFound, vous pouvez préciser le traitement à effectuer lorsque le fichier demandé est trouvé :

app.get(
  '/static/*',
  serveStatic({
    // ...
    onFound: (_path, c) => {
      c.header('Cache-Control', `public, immutable, max-age=31536000`)
    },
  })
)

onNotFound

Avec onNotFound, vous pouvez préciser le traitement à effectuer lorsque le fichier demandé est introuvable :

app.get(
  '/static/*',
  serveStatic({
    onNotFound: (path, c) => {
      console.log(`${path} is not found, you access ${c.req.path}`)
    },
  })
)

precompressed

L'option precompressed vérifie si des fichiers portant des extensions telles que .br ou .gz sont disponibles et les sert selon l'en-tête Accept-Encoding. Elle privilégie Brotli, puis Zstd et Gzip. Si aucun de ces fichiers n'est disponible, elle sert le fichier original.

app.get(
  '/static/*',
  serveStatic({
    precompressed: true,
  })
)

Deno Deploy

Deno Deploy est une plateforme serverless qui exécute des applications JavaScript et TypeScript dans le cloud. Elle fournit un plan de gestion pour déployer et exécuter des applications via des intégrations telles que le déploiement GitHub.

Hono fonctionne aussi sur Deno Deploy. Consultez la documentation officielle.

Tests

Tester une application sur Deno est facile. Vous pouvez utiliser Deno.test et les fonctions assert ou assertEquals de @std/assert.

deno add jsr:@std/assert

hello.ts

import { Hono } from 'hono'
import { assertEquals } from '@std/assert'

Deno.test('Hello World', async () => {
  const app = new Hono()
  app.get('/', (c) => c.text('Please test me'))

  const res = await app.request('http://localhost/')
  assertEquals(res.status, 200)
})

Ensuite, exécutez la commande :

deno test hello.ts

npm et JSR

Hono est disponible sur npm et JSR (le registre JavaScript). Vous pouvez utiliser npm:hono ou jsr:@hono/hono dans votre deno.json :

{
  "imports": {
    "hono": "jsr:@hono/hono"
    "hono": "npm:hono"
  }
}

Pour utiliser les middlewares, vous devez employer la syntaxe de répertoire Deno dans l'import.

{
  "imports": {
    "hono/": "npm:/hono/"
  }
}

Lorsque vous utilisez un middleware tiers, vous devrez parfois récupérer Hono depuis le même registre que le middleware pour assurer une inférence correcte des types TypeScript. Par exemple, si le middleware provient de npm, utilisez aussi Hono depuis npm :

{
  "imports": {
    "hono": "npm:hono",
    "zod": "npm:zod",
    "@hono/zod-validator": "npm:@hono/zod-validator"
  }
}

Nous distribuons également de nombreux paquets de middlewares tiers sur JSR. Lorsque vous utilisez un middleware de JSR, utilisez Hono depuis JSR :

{
  "imports": {
    "hono": "jsr:@hono/hono",
    "zod": "npm:zod",
    "@hono/zod-validator": "jsr:@hono/zod-validator"
  }
}