@fastify/fetch 0.1.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Set default behavior to automatically convert line endings
+* text=auto eol=lf

package/.github/dependabot.yml

@@ -0,0 +1,53 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
+    schedule:
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
+    open-pull-requests-limit: 10
+
+  - package-ecosystem: "npm"
+    directory: "/"
+    commit-message:
+      # Prefix all commit messages with "chore: "
+      prefix: "chore"
+    schedule:
+      interval: "weekly"
+    cooldown:
+      default-days: 7
+    versioning-strategy: "increase-if-necessary"
+    allow:
+      - dependency-name: "*"
+        update-types:
+          - "version-update:semver-major"
+    ignore:
+      # TODO: remove ignore until neostandard support ESLint 10
+      - dependency-name: "eslint"
+      - dependency-name: "neostandard"
+      - dependency-name: "@stylistic/*"
+    open-pull-requests-limit: 10
+    groups:
+      # Production dependencies with breaking changes
+      dependencies:
+        dependency-type: "production"
+      # ESLint related dependencies
+      dev-dependencies-eslint:
+        patterns:
+          - "eslint"
+          - "neostandard"
+          - "@stylistic/*"
+      # TypeScript related dependencies
+      dev-dependencies-typescript:
+        patterns:
+          - "@types/*"
+          - "tstyche"
+          - "typescript"

package/.github/workflows/ci.yml

@@ -0,0 +1,33 @@
+name: CI
+
+on:
+  push:
+    branches:
+     - main
+     - next
+     - 'v*'
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '*.md'
+
+# This allows a subsequently queued workflow run to interrupt previous runs
+concurrency:
+  group: "${{ github.workflow }}-${{ github.event.pull_request.head.label || github.head_ref || github.ref }}"
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    permissions:
+      contents: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/plugins-ci.yml@v6
+    with:
+      license-check: true
+      lint: true

package/.github/workflows/lock-threads.yml

@@ -0,0 +1,19 @@
+name: Lock Threads
+
+on:
+  schedule:
+    - cron: '0 0 1 * *'
+  workflow_dispatch:
+
+concurrency:
+  group: lock
+
+permissions:
+  contents: read
+
+jobs:
+  lock-threads:
+    permissions:
+      issues: write
+      pull-requests: write
+    uses: fastify/workflows/.github/workflows/lock-threads.yml@v6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026-present The Fastify team <https://github.com/fastify/fastify#team>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,188 @@
+# @fastify/fetch
+
+[![CI](https://github.com/fastify/fastify-fetch/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/fastify/fastify-fetch/actions/workflows/ci.yml)
+[![NPM version](https://img.shields.io/npm/v/@fastify/fetch.svg?style=flat)](https://www.npmjs.com/package/@fastify/fetch)
+[![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
+
+Handle requests using the Web Standard [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) (`Request`/`Response`).
+
+## Install
+
+```bash
+npm install @fastify/fetch
+```
+
+## Usage
+
+```javascript
+import Fastify from 'fastify'
+import fastifyFetch from '@fastify/fetch'
+
+const fastify = Fastify()
+
+await fastify.register(fastifyFetch)
+
+fastify.fetch.get('/hello', async (request, ctx) => {
+  ctx.log.info('handling request')
+  return new Response('Hello World')
+})
+
+fastify.fetch.post('/data', async (request, ctx) => {
+  const body = await request.json()
+  return Response.json({ received: body })
+})
+
+await fastify.listen({ port: 3000 })
+```
+
+## API
+
+### Handler Signature
+
+```javascript
+fastify.fetch.get(path, [options], handler)
+fastify.fetch.post(path, [options], handler)
+fastify.fetch.put(path, [options], handler)
+fastify.fetch.delete(path, [options], handler)
+fastify.fetch.patch(path, [options], handler)
+fastify.fetch.options(path, [options], handler)
+fastify.fetch.head(path, [options], handler)
+```
+
+The handler receives two arguments:
+
+- `request` - Web Standard [Request](https://developer.mozilla.org/en-US/docs/Web/API/Request) object
+- `ctx` - Context object
+
+The handler must return a Web Standard [Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) object.
+
+### Context Object
+
+| Property | Type | Description |
+|----------|------|-------------|
+| `ctx.log` | `FastifyBaseLogger` | Fastify logger instance |
+| `ctx.server` | `FastifyInstance` | Fastify server instance |
+| `ctx.params` | `Record<string, string>` | Route parameters |
+| `ctx.query` | `Record<string, string>` | Query string parameters |
+| `ctx.request` | `FastifyRequest` | Original Fastify request |
+| `ctx.reply` | `FastifyReply` | Original Fastify reply |
+| `ctx.abortController` | `AbortController \| undefined` | AbortController instance when enabled for the route |
+
+### Route options
+
+The optional `options` object accepts standard Fastify route options plus:
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `abortController` | `boolean` | `false` | Create an `AbortController` for the route and expose it as `ctx.abortController`. The Web `Request` signal is aborted when the client aborts the request or when the handler lifecycle ends. |
+
+```javascript
+fastify.fetch.get('/long-running', { abortController: true }, async (request, ctx) => {
+  const result = await doWork({ signal: request.signal })
+  return Response.json(result)
+})
+```
+
+### Hooks
+
+Routes registered with `fastify.fetch.*` are standard Fastify routes, so all Fastify hooks are supported:
+
+| Hook | Fires |
+|------|-------|
+| `onRequest` | Yes |
+| `preParsing` | Yes |
+| `preValidation` | Yes |
+| `preHandler` | Yes |
+| `onSend` | Yes |
+| `onResponse` | Yes |
+| `onError` | Yes (on errors) |
+
+```javascript
+fastify.addHook('onRequest', async (request, reply) => {
+  // runs before the fetch handler
+})
+
+fastify.addHook('onResponse', async (request, reply) => {
+  // runs after the response is sent
+})
+```
+
+## Examples
+
+### JSON Response
+
+```javascript
+fastify.fetch.get('/users/:id', async (request, ctx) => {
+  const user = await getUser(ctx.params.id)
+  return Response.json(user)
+})
+```
+
+### Custom Headers
+
+```javascript
+fastify.fetch.get('/data', async (request, ctx) => {
+  return new Response('data', {
+    headers: {
+      'X-Custom-Header': 'value',
+      'Cache-Control': 'max-age=3600'
+    }
+  })
+})
+```
+
+### Custom Status Code
+
+```javascript
+fastify.fetch.post('/users', async (request, ctx) => {
+  const body = await request.json()
+  const user = await createUser(body)
+  return Response.json(user, { status: 201 })
+})
+```
+
+### Reading Request Body
+
+```javascript
+fastify.fetch.post('/upload', async (request, ctx) => {
+  // JSON
+  const json = await request.json()
+
+  // Text
+  const text = await request.text()
+
+  // FormData
+  const formData = await request.formData()
+
+  // ArrayBuffer
+  const buffer = await request.arrayBuffer()
+
+  return new Response('OK')
+})
+```
+
+### Using Query Parameters
+
+```javascript
+fastify.fetch.get('/search', async (request, ctx) => {
+  const { q, limit } = ctx.query
+  const results = await search(q, parseInt(limit))
+  return Response.json(results)
+})
+```
+
+### Accessing Request URL
+
+```javascript
+fastify.fetch.get('/info', async (request, ctx) => {
+  const url = new URL(request.url)
+  return Response.json({
+    pathname: url.pathname,
+    search: url.search
+  })
+})
+```
+
+## License
+
+Licensed under [MIT](./LICENSE).

package/eslint.config.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = require('neostandard')()

package/examples/example.mjs

@@ -0,0 +1,40 @@
+import Fastify from 'fastify'
+import fastifyFetch from '../index.js'
+
+const fastify = Fastify({ logger: true })
+
+await fastify.register(fastifyFetch)
+
+fastify.fetch.get('/hello', async (request, ctx) => {
+  ctx.log.info('handling request')
+  return new Response('Hello World')
+})
+
+fastify.fetch.get('/users/:id', async (request, ctx) => {
+  return Response.json({ id: ctx.params.id, name: 'John Doe' })
+})
+
+fastify.fetch.post('/data', async (request, ctx) => {
+  const body = await request.json()
+  return Response.json({ received: body })
+})
+
+fastify.fetch.get('/search', async (request, ctx) => {
+  return Response.json({ query: ctx.query })
+})
+
+await fastify.listen({ port: 3000 })
+
+/**
+ * Test the endpoints using curl:
+ *
+ * curl http://localhost:3000/hello
+ *
+ * curl http://localhost:3000/users/42
+ *
+ * curl -X POST http://localhost:3000/data \
+ *   -H "Content-Type: application/json" \
+ *   -d '{"name": "John Doe", "age": 30}'
+ *
+ * curl "http://localhost:3000/search?q=test&limit=10"
+ */

package/index.js

@@ -0,0 +1,158 @@
+'use strict'
+
+const fp = require('fastify-plugin')
+const { Readable } = require('node:stream')
+
+const kAbortController = Symbol('fastify-fetch.abortController')
+const requestLifecycleEnded = new DOMException('Request lifecycle ended', 'AbortError')
+
+function createWebRequest (fastifyRequest, signal) {
+  const url = new URL(fastifyRequest.url, `http://${fastifyRequest.headers.host}`)
+  const hasBody = !['GET', 'HEAD'].includes(fastifyRequest.method)
+  const body = fastifyRequest.body
+
+  let webBody
+  if (hasBody && body) {
+    if (body instanceof Readable) {
+      webBody = Readable.toWeb(body)
+    } else {
+      throw new Error('Request body must be a Readable stream')
+    }
+  }
+
+  if (signal === undefined) {
+    return new Request(url, {
+      method: fastifyRequest.method,
+      headers: new Headers(fastifyRequest.headers),
+      body: webBody,
+      duplex: webBody ? 'half' : undefined
+    })
+  }
+
+  return new Request(url, {
+    method: fastifyRequest.method,
+    headers: new Headers(fastifyRequest.headers),
+    body: webBody,
+    duplex: webBody ? 'half' : undefined,
+    signal
+  })
+}
+
+async function sendWebResponse (fastifyReply, webResponse) {
+  if (!(webResponse instanceof Response)) {
+    throw new Error('Handler must return a Response object')
+  }
+
+  fastifyReply.status(webResponse.status)
+
+  for (const [key, value] of webResponse.headers) {
+    fastifyReply.header(key, value)
+  }
+
+  const body = await webResponse.arrayBuffer()
+  fastifyReply.send(Buffer.from(body))
+}
+
+function abortWebRequest (request) {
+  request[kAbortController]?.abort()
+}
+
+function prepareRouteOptions (options, abortControllerEnabled) {
+  if (options === undefined) {
+    return undefined
+  }
+
+  const routeOptions = { ...options }
+  delete routeOptions.abortController
+  if (!abortControllerEnabled) {
+    return routeOptions
+  }
+
+  const hooks = routeOptions.onRequestAbort
+  if (hooks === undefined) {
+    routeOptions.onRequestAbort = abortWebRequest
+  } else if (Array.isArray(hooks)) {
+    routeOptions.onRequestAbort = [abortWebRequest, ...hooks]
+  } else {
+    routeOptions.onRequestAbort = [abortWebRequest, hooks]
+  }
+
+  return routeOptions
+}
+
+async function fastifyFetch (fastify, options) {
+  fastify.removeAllContentTypeParsers()
+  fastify.addContentTypeParser('*', function (request, payload, done) {
+    done(null, payload)
+  })
+
+  const methods = ['get', 'post', 'put', 'delete', 'patch', 'options', 'head']
+  const fetch = {}
+
+  for (const method of methods) {
+    fetch[method] = (path, options, handler) => {
+      if (handler === undefined) {
+        handler = options
+        options = undefined
+      }
+
+      const abortControllerEnabled = options?.abortController === true
+      const routeOptions = prepareRouteOptions(options, abortControllerEnabled)
+      let routeHandler
+
+      if (abortControllerEnabled) {
+        routeHandler = async function handleRequestWithAbortController (request, reply) {
+          const abortController = new AbortController()
+          request[kAbortController] = abortController
+
+          try {
+            const webRequest = createWebRequest(request, abortController.signal)
+            const ctx = {
+              log: request.log,
+              server: fastify,
+              params: request.params,
+              query: request.query,
+              request,
+              reply,
+              abortController
+            }
+
+            const webResponse = await handler(webRequest, ctx)
+            await sendWebResponse(reply, webResponse)
+          } finally {
+            delete request[kAbortController]
+            abortController.abort(requestLifecycleEnded)
+          }
+        }
+      } else {
+        routeHandler = async function handleRequest (request, reply) {
+          const webRequest = createWebRequest(request)
+          const ctx = {
+            log: request.log,
+            server: fastify,
+            params: request.params,
+            query: request.query,
+            request,
+            reply
+          }
+
+          const webResponse = await handler(webRequest, ctx)
+          await sendWebResponse(reply, webResponse)
+        }
+      }
+
+      if (routeOptions === undefined) {
+        fastify[method](path, routeHandler)
+      } else {
+        fastify[method](path, routeOptions, routeHandler)
+      }
+    }
+  }
+
+  fastify.decorate('fetch', fetch)
+}
+
+module.exports = fp(fastifyFetch, {
+  fastify: '>=5.0.0',
+  name: '@fastify/fetch'
+})

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@fastify/fetch",
+  "version": "0.1.0",
+  "description": "Handle requests using the fetch standard",
+  "main": "index.js",
+  "type": "commonjs",
+  "types": "types/index.d.ts",
+  "scripts": {
+    "lint": "eslint",
+    "lint:fix": "eslint --fix",
+    "test": "borp && npm run test:types",
+    "test:types": "tstyche"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fastify/fastify-fetch.git"
+  },
+  "keywords": [
+    "fastify",
+    "fetch",
+    "web-standard",
+    "request",
+    "response"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/fastify/fastify-fetch/issues"
+  },
+  "homepage": "https://github.com/fastify/fastify-fetch",
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/fastify"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/fastify"
+    }
+  ],
+  "dependencies": {
+    "fastify-plugin": "^6.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1",
+    "borp": "^1.0.0",
+    "fastify": "^5.0.0",
+    "neostandard": "^0.13.0",
+    "tstyche": "^7.0.0"
+  }
+}

package/test/index.test.js

@@ -0,0 +1,496 @@
+'use strict'
+
+const { test, describe } = require('node:test')
+const assert = require('node:assert')
+const Fastify = require('fastify')
+const fastifyFetch = require('../index.js')
+
+describe('fastify-fetch', async () => {
+  test('GET request returns text response', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/hello', async (request, ctx) => {
+      return new Response('Hello World')
+    })
+
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/hello'
+    })
+
+    assert.strictEqual(response.statusCode, 200)
+    assert.strictEqual(response.body, 'Hello World')
+  })
+
+  test('POST request with JSON body', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.post('/data', async (request, ctx) => {
+      const body = await request.json()
+      return Response.json({ received: body })
+    })
+
+    const response = await fastify.inject({
+      method: 'POST',
+      url: '/data',
+      headers: { 'content-type': 'application/json' },
+      payload: JSON.stringify({ name: 'test' })
+    })
+
+    assert.strictEqual(response.statusCode, 200)
+    assert.deepStrictEqual(JSON.parse(response.body), { received: { name: 'test' } })
+  })
+
+  test('Response headers are forwarded', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/headers', async (request, ctx) => {
+      return new Response('ok', {
+        headers: { 'x-custom-header': 'custom-value' }
+      })
+    })
+
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/headers'
+    })
+
+    assert.strictEqual(response.headers['x-custom-header'], 'custom-value')
+  })
+
+  test('Response status codes work', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/created', async (request, ctx) => {
+      return new Response('created', { status: 201 })
+    })
+
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/created'
+    })
+
+    assert.strictEqual(response.statusCode, 201)
+  })
+
+  test('Route parameters accessible via ctx.params', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/users/:id', async (request, ctx) => {
+      return Response.json({ id: ctx.params.id })
+    })
+
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/users/123'
+    })
+
+    assert.deepStrictEqual(JSON.parse(response.body), { id: '123' })
+  })
+
+  test('Query string accessible via ctx.query', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/search', async (request, ctx) => {
+      return Response.json({ q: ctx.query.q })
+    })
+
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/search?q=hello'
+    })
+
+    assert.deepStrictEqual(JSON.parse(response.body), { q: 'hello' })
+  })
+
+  test('Logger accessible via ctx.log', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    let logCalled = false
+    fastify.fetch.get('/log', async (request, ctx) => {
+      assert.ok(ctx.log)
+      assert.strictEqual(typeof ctx.log.info, 'function')
+      logCalled = true
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/log'
+    })
+
+    assert.ok(logCalled)
+  })
+
+  test('Server accessible via ctx.server', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/server', async (request, ctx) => {
+      assert.strictEqual(ctx.server, fastify)
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/server'
+    })
+  })
+
+  test('AbortController is disabled by default', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    let cachedRequest
+
+    fastify.fetch.get('/abort-controller-disabled', async (request, ctx) => {
+      cachedRequest = request
+      assert.strictEqual(ctx.abortController, undefined)
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/abort-controller-disabled'
+    })
+
+    assert.strictEqual(cachedRequest.signal.aborted, false)
+  })
+
+  test('AbortController accessible via ctx.abortController when enabled', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/abort-controller', { abortController: true }, async (request, ctx) => {
+      assert.ok(ctx.abortController instanceof AbortController)
+      assert.strictEqual(request.signal, ctx.abortController.signal)
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/abort-controller'
+    })
+  })
+
+  test('Fastify request accessible via ctx.request', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/fastify-request', async (request, ctx) => {
+      assert.ok(ctx.request)
+      assert.strictEqual(ctx.request.method, 'GET')
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/fastify-request'
+    })
+  })
+
+  test('Fastify reply accessible via ctx.reply', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/fastify-reply', async (request, ctx) => {
+      assert.ok(ctx.reply)
+      assert.strictEqual(typeof ctx.reply.send, 'function')
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/fastify-reply'
+    })
+  })
+
+  test('PUT method works', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.put('/update', async (request, ctx) => {
+      const body = await request.json()
+      return Response.json({ updated: body })
+    })
+
+    const response = await fastify.inject({
+      method: 'PUT',
+      url: '/update',
+      headers: { 'content-type': 'application/json' },
+      payload: JSON.stringify({ value: 'new' })
+    })
+
+    assert.deepStrictEqual(JSON.parse(response.body), { updated: { value: 'new' } })
+  })
+
+  test('DELETE method works', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.delete('/remove/:id', async (request, ctx) => {
+      return Response.json({ deleted: ctx.params.id })
+    })
+
+    const response = await fastify.inject({
+      method: 'DELETE',
+      url: '/remove/456'
+    })
+
+    assert.deepStrictEqual(JSON.parse(response.body), { deleted: '456' })
+  })
+
+  test('PATCH method works', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.patch('/patch', async (request, ctx) => {
+      const body = await request.json()
+      return Response.json({ patched: body })
+    })
+
+    const response = await fastify.inject({
+      method: 'PATCH',
+      url: '/patch',
+      headers: { 'content-type': 'application/json' },
+      payload: JSON.stringify({ field: 'patched' })
+    })
+
+    assert.deepStrictEqual(JSON.parse(response.body), { patched: { field: 'patched' } })
+  })
+
+  test('OPTIONS method works', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.options('/cors', async (request, ctx) => {
+      return new Response(null, {
+        status: 204,
+        headers: { 'access-control-allow-origin': '*' }
+      })
+    })
+
+    const response = await fastify.inject({
+      method: 'OPTIONS',
+      url: '/cors'
+    })
+
+    assert.strictEqual(response.statusCode, 204)
+    assert.strictEqual(response.headers['access-control-allow-origin'], '*')
+  })
+
+  test('HEAD method works', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.head('/head', async (request, ctx) => {
+      return new Response(null, {
+        headers: { 'x-custom': 'value' }
+      })
+    })
+
+    const response = await fastify.inject({
+      method: 'HEAD',
+      url: '/head'
+    })
+
+    assert.strictEqual(response.statusCode, 200)
+    assert.strictEqual(response.headers['x-custom'], 'value')
+  })
+
+  test('onRequest hook fires', async () => {
+    const fastify = Fastify()
+    let hookCalled = false
+
+    fastify.addHook('onRequest', async (request, reply) => {
+      hookCalled = true
+    })
+
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/hook-test', async (request, ctx) => {
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/hook-test'
+    })
+
+    assert.strictEqual(hookCalled, true)
+  })
+
+  test('preHandler hook fires', async () => {
+    const fastify = Fastify()
+    let hookCalled = false
+
+    fastify.addHook('preHandler', async (request, reply) => {
+      hookCalled = true
+    })
+
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/prehandler-test', async (request, ctx) => {
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/prehandler-test'
+    })
+
+    assert.strictEqual(hookCalled, true)
+  })
+
+  test('route options are forwarded', async () => {
+    const fastify = Fastify()
+    let hookCalled = false
+
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/route-options', {
+      preHandler: async (request, reply) => {
+        hookCalled = true
+      }
+    }, async (request, ctx) => {
+      return new Response('ok')
+    })
+
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/route-options'
+    })
+
+    assert.strictEqual(response.statusCode, 200)
+    assert.strictEqual(hookCalled, true)
+  })
+
+  test('onSend hook fires', async () => {
+    const fastify = Fastify()
+    let hookCalled = false
+
+    fastify.addHook('onSend', async (request, reply, payload) => {
+      hookCalled = true
+      return payload
+    })
+
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/onsend-test', async (request, ctx) => {
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/onsend-test'
+    })
+
+    assert.strictEqual(hookCalled, true)
+  })
+
+  test('onResponse hook fires', async () => {
+    const fastify = Fastify()
+    let hookCalled = false
+
+    fastify.addHook('onResponse', async (request, reply) => {
+      hookCalled = true
+    })
+
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/onresponse-test', async (request, ctx) => {
+      return new Response('ok')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/onresponse-test'
+    })
+
+    assert.strictEqual(hookCalled, true)
+  })
+
+  test('onError hook fires on handler error', async () => {
+    const fastify = Fastify()
+    let hookCalled = false
+
+    fastify.addHook('onError', async (request, reply, error) => {
+      hookCalled = true
+    })
+
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/onerror-test', async (request, ctx) => {
+      throw new Error('test error')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/onerror-test'
+    })
+
+    assert.strictEqual(hookCalled, true)
+  })
+
+  test('handler must return Response object', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    fastify.fetch.get('/invalid-response', async (request, ctx) => {
+      return 'not a response'
+    })
+
+    const response = await fastify.inject({
+      method: 'GET',
+      url: '/invalid-response'
+    })
+
+    assert.strictEqual(response.statusCode, 500)
+    assert.ok(response.body.includes('Handler must return a Response object'))
+  })
+
+  test('Request must be aborted after the handler completes when enabled', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    let cachedRequest
+
+    fastify.fetch.get('/caching-request', { abortController: true }, async (request, ctx) => {
+      cachedRequest = request
+      return new Response('response')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/caching-request'
+    })
+
+    assert.ok(cachedRequest.signal.aborted)
+  })
+
+  test('Request must be aborted after the handler throws an error when enabled', async () => {
+    const fastify = Fastify()
+    await fastify.register(fastifyFetch)
+
+    let cachedRequest
+
+    fastify.fetch.get('/throwing-error', { abortController: true }, async (request, ctx) => {
+      cachedRequest = request
+      throw new Error('Unexpected exception raised')
+    })
+
+    await fastify.inject({
+      method: 'GET',
+      url: '/throwing-error'
+    })
+
+    assert.ok(cachedRequest.signal.aborted)
+  })
+})

package/types/index.d.ts

@@ -0,0 +1,59 @@
+import { FastifyPluginAsync, FastifyInstance, FastifyBaseLogger, FastifyRequest, FastifyReply, RouteShorthandOptions } from 'fastify'
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    fetch: fastifyFetch.FetchRoutes
+  }
+}
+
+type FastifyFetchPlugin = FastifyPluginAsync<NonNullable<fastifyFetch.FastifyFetchOptions>>
+
+declare namespace fastifyFetch {
+  export interface FetchContext {
+    log: FastifyBaseLogger
+    server: FastifyInstance
+    params: Record<string, string>
+    query: Record<string, string>
+    request: FastifyRequest
+    reply: FastifyReply
+    abortController?: AbortController
+  }
+
+  export interface FetchContextWithAbortController extends FetchContext {
+    abortController: AbortController
+  }
+
+  export interface FetchRouteOptions extends RouteShorthandOptions {
+    abortController?: boolean
+  }
+
+  export type FetchHandler = (request: Request, ctx: FetchContext) => Response | Promise<Response>
+  export type FetchHandlerWithAbortController = (request: Request, ctx: FetchContextWithAbortController) => Response | Promise<Response>
+
+  export interface FetchRoute {
+    (path: string, handler: FetchHandler): void
+    (path: string, options: FetchRouteOptions & { abortController: true }, handler: FetchHandlerWithAbortController): void
+    (path: string, options: FetchRouteOptions, handler: FetchHandler): void
+  }
+
+  export interface FetchRoutes {
+    get: FetchRoute
+    post: FetchRoute
+    put: FetchRoute
+    delete: FetchRoute
+    patch: FetchRoute
+    options: FetchRoute
+    head: FetchRoute
+  }
+
+  export interface FastifyFetchOptions {
+  }
+
+  export const fastifyFetch: FastifyFetchPlugin
+
+  export { fastifyFetch as default }
+}
+
+declare function fastifyFetch (...params: Parameters<FastifyFetchPlugin>): ReturnType<FastifyFetchPlugin>
+
+export = fastifyFetch

package/types/index.tst.ts

@@ -0,0 +1,108 @@
+import fastify, {
+  FastifyInstance,
+  FastifyPluginAsync,
+  FastifyBaseLogger,
+  FastifyRequest,
+  FastifyReply
+} from 'fastify'
+import { expect } from 'tstyche'
+import * as fastifyFetchStar from '..'
+import fastifyFetch, {
+  FetchContext,
+  FetchContextWithAbortController,
+  FetchHandler,
+  FetchHandlerWithAbortController,
+  FetchRouteOptions,
+  FetchRoutes,
+  fastifyFetch as fastifyFetchNamed
+} from '..'
+
+import fastifyFetchCjsImport = require('..')
+const fastifyFetchCjs = require('../..')
+
+const app: FastifyInstance = fastify()
+
+app.register(fastifyFetch)
+app.register(fastifyFetchNamed)
+app.register(fastifyFetchCjs)
+app.register(fastifyFetchCjsImport.default)
+app.register(fastifyFetchCjsImport.fastifyFetch)
+app.register(fastifyFetchStar.default)
+app.register(fastifyFetchStar.fastifyFetch)
+
+expect(fastifyFetch).type.toBe<FastifyPluginAsync>()
+expect(fastifyFetchNamed).type.toBe<FastifyPluginAsync>()
+expect(fastifyFetchCjs).type.toBe<any>()
+
+app.register(fastifyFetch).after(() => {
+  expect(app.fetch).type.toBe<FetchRoutes>()
+
+  app.fetch.get('/test', async (request, ctx) => {
+    expect(request).type.toBe<Request>()
+    expect(ctx).type.toBe<FetchContext>()
+    expect(ctx.log).type.toBe<FastifyBaseLogger>()
+    expect(ctx.server).type.toBe<FastifyInstance>()
+    expect(ctx.params).type.toBe<Record<string, string>>()
+    expect(ctx.query).type.toBe<Record<string, string>>()
+    expect(ctx.request).type.toBe<FastifyRequest>()
+    expect(ctx.reply).type.toBe<FastifyReply>()
+    expect(ctx.abortController).type.toBe<AbortController | undefined>()
+    return new Response('ok')
+  })
+
+  app.fetch.get('/abort', { abortController: true }, async (request, ctx) => {
+    expect(request).type.toBe<Request>()
+    expect(ctx).type.toBe<FetchContextWithAbortController>()
+    expect(ctx.abortController).type.toBe<AbortController>()
+    return new Response('ok')
+  })
+
+  app.fetch.post('/data', async (request, ctx) => {
+    return Response.json({ ok: true })
+  })
+
+  app.fetch.put('/update', async (request, ctx) => {
+    return new Response('updated')
+  })
+
+  app.fetch.delete('/remove', async (request, ctx) => {
+    return new Response('deleted')
+  })
+
+  app.fetch.patch('/patch', async (request, ctx) => {
+    return new Response('patched')
+  })
+
+  app.fetch.options('/options', async (request, ctx) => {
+    return new Response(null, { status: 204 })
+  })
+
+  app.fetch.head('/head', async (request, ctx) => {
+    return new Response(null)
+  })
+})
+
+const handler: FetchHandler = async (request, ctx) => {
+  return new Response('handler')
+}
+
+expect(handler).type.toBe<FetchHandler>()
+
+const handlerWithAbortController: FetchHandlerWithAbortController = async (request, ctx) => {
+  expect(ctx.abortController).type.toBe<AbortController>()
+  return new Response('handler')
+}
+
+expect(handlerWithAbortController).type.toBe<FetchHandlerWithAbortController>()
+
+const options: FetchRouteOptions = {
+  abortController: true,
+  schema: {
+    response: {
+      200: {
+        type: 'string'
+      }
+    }
+  }
+}
+expect(options).type.toBe<FetchRouteOptions>()