Deno

Deno ist eine auf V8 basierende JavaScript-Laufzeitumgebung. Es ist nicht Node.js. Hono funktioniert auch auf Deno.

Du kannst mit Hono TypeScript-Code schreiben, die Anwendung mit dem Befehl deno ausführen und sie auf „Deno Deploy“ bereitstellen.

1. Deno installieren

Installiere zunächst den Befehl deno. Siehe die offizielle Dokumentation.

2. Einrichtung

Für Deno steht eine Projektvorlage zur Verfügung. Starte dein Projekt mit dem Befehl deno init.

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

Wechsle nach my-app. Bei Deno musst du Hono nicht ausdrücklich installieren.

cd my-app

3. Hello World

Bearbeite main.ts:

main.ts

import { Hono } from 'hono'

const app = new Hono()

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

Deno.serve(app.fetch)

4. Ausführen

Starte den Entwicklungsserver lokal. Öffne anschließend http://localhost:8000 in deinem Webbrowser.

deno task start

Portnummer ändern

Du kannst die Portnummer festlegen, indem du die Argumente von Deno.serve in main.ts anpasst:

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

Statische Dateien ausliefern

Um statische Dateien auszuliefern, verwende serveStatic aus dem Paket @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)

Der obige Code funktioniert mit der folgenden Verzeichnisstruktur.

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

rewriteRequestPath

Wenn du http://localhost:8000/static/* auf ./statics abbilden möchtest, kannst du die Option rewriteRequestPath verwenden:

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

mimes

Mit mimes kannst du MIME-Typen hinzufügen:

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

onFound

Mit onFound kannst du festlegen, was passieren soll, wenn die angeforderte Datei gefunden wird:

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

onNotFound

Mit onNotFound kannst du festlegen, was passieren soll, wenn die angeforderte Datei nicht gefunden wird:

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

precompressed

Die Option precompressed prüft, ob Dateien mit Erweiterungen wie .br oder .gz verfügbar sind, und liefert sie anhand des Headers Accept-Encoding aus. Dabei wird Brotli bevorzugt, gefolgt von Zstd und Gzip. Ist keine dieser Varianten verfügbar, wird die ursprüngliche Datei ausgeliefert.

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

Deno Deploy

Deno Deploy ist eine Serverless-Plattform, um JavaScript- und TypeScript-Anwendungen in der Cloud auszuführen. Sie bietet eine Verwaltungsebene zur Bereitstellung und Ausführung von Anwendungen über Integrationen wie die Bereitstellung mit GitHub.

Hono funktioniert auch auf Deno Deploy. Siehe die offizielle Dokumentation.

Tests

Das Testen einer Anwendung auf Deno ist einfach. Du kannst Tests mit Deno.test schreiben und assert oder assertEquals aus @std/assert verwenden.

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)
})

Führe anschließend den Befehl aus:

deno test hello.ts

npm und JSR

Hono ist sowohl auf npm als auch auf JSR, der JavaScript Registry, verfügbar. Du kannst in deiner deno.json entweder npm:hono oder jsr:@hono/hono verwenden:

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

Um Middleware zu verwenden, musst du im Import die Syntax für Deno-Verzeichnisse verwenden.

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

Bei Drittanbieter-Middleware musst du Hono möglicherweise aus derselben Registry wie die Middleware beziehen, damit TypeScript-Typen korrekt abgeleitet werden. Wenn du etwa Middleware von npm verwendest, solltest du auch Hono von npm verwenden:

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

Wir bieten außerdem viele Drittanbieter-Middleware-Pakete auf JSR an. Verwende für Middleware auf JSR auch Hono von JSR:

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