@fastify/reply-from 12.0.1 → 12.1.0

package/.github/dependabot.yml

@@ -9,5 +9,5 @@ updates:
   - package-ecosystem: "npm"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
     open-pull-requests-limit: 10

package/.github/workflows/ci.yml

@@ -4,7 +4,6 @@ on:
   push:
     branches:
      - main
-     - master
      - next
      - 'v*'
     paths-ignore:
@@ -17,6 +16,9 @@ on:
 
 jobs:
   test:
+    permissions:
+      contents: write
+      pull-requests: write
     uses: fastify/workflows/.github/workflows/plugins-ci.yml@v5
     with:
       license-check: true

package/README.md

@@ -1,6 +1,6 @@
 # @fastify/reply-from
 
-[![CI](https://github.com/fastify/fastify-reply-from/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/fastify/fastify-reply-from/actions/workflows/ci.yml)
+[![CI](https://github.com/fastify/fastify-reply-from/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/fastify/fastify-reply-from/actions/workflows/ci.yml)
 [![NPM version](https://img.shields.io/npm/v/@fastify/reply-from.svg?style=flat)](https://www.npmjs.com/package/@fastify/reply-from)
 [![neostandard javascript style](https://img.shields.io/badge/code_style-neostandard-brightgreen?style=flat)](https://github.com/neostandard/neostandard)
 
@@ -477,6 +477,10 @@ By default: 0 (disabled)
 Override the `'Content-Type'` header of the forwarded request, if we are
 already overriding the [`body`](#body).
 
+#### `timeout`
+
+Set a specific timeout for the request. Override options `http.requestOptions.timeout`, `http2.requestOptions.timeout`, `undici.headersTimeout` and `undici.bodyTimeout` from the plugin config.
+
 ### Combining with [@fastify/formbody](https://github.com/fastify/fastify-formbody)
 
 `formbody` expects the body to be returned as a string and not an object.

package/index.js

@@ -55,6 +55,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     opts = opts || {}
     const req = this.request.raw
     const method = opts.method || req.method
+    const timeout = opts.timeout
     const onResponse = opts.onResponse
     const rewriteHeaders = opts.rewriteHeaders || headersNoOp
     const rewriteRequestHeaders = opts.rewriteRequestHeaders || requestHeadersNoOp
@@ -169,7 +170,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
       requestImpl = createRequestRetry(request, this, getDefaultDelay)
     }
 
-    requestImpl({ method, url, qs, headers: requestHeaders, body }, (err, res) => {
+    requestImpl({ method, url, qs, headers: requestHeaders, body, timeout }, (err, res) => {
       if (err) {
         this.request.log.warn(err, 'response errored')
         if (!this.sent) {

package/lib/request.js

@@ -120,7 +120,8 @@ function buildRequest (opts) {
       hostname: opts.url.hostname,
       headers: opts.headers,
       agent: agents[opts.url.protocol.replace(/^unix:/, '')],
-      ...httpOpts.requestOptions
+      ...httpOpts.requestOptions,
+      timeout: opts.timeout ?? httpOpts.requestOptions.timeout
     })
     req.on('error', done)
     req.on('response', res => {
@@ -146,8 +147,8 @@ function buildRequest (opts) {
       method: opts.method,
       headers: Object.assign({}, opts.headers),
       body: opts.body,
-      headersTimeout: undiciOpts.headersTimeout,
-      bodyTimeout: undiciOpts.bodyTimeout
+      headersTimeout: opts.timeout ?? undiciOpts.headersTimeout,
+      bodyTimeout: opts.timeout ?? undiciOpts.bodyTimeout
     }
 
     let pool
@@ -212,7 +213,7 @@ function buildRequest (opts) {
     if (!isGet && !isDelete) {
       end(req, opts.body, done)
     }
-    req.setTimeout(http2Opts.requestTimeout, () => {
+    req.setTimeout(opts.timeout ?? http2Opts.requestTimeout, () => {
       const err = new Http2RequestTimeoutError()
       req.close(http2.constants.NGHTTP2_CANCEL)
       done(err)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "12.0.1",
+  "version": "12.1.0",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "type": "commonjs",
@@ -70,7 +70,7 @@
     "got": "^11.8.6",
     "h2url": "^0.2.0",
     "neostandard": "^0.12.0",
-    "nock": "^13.5.4",
+    "nock": "^14.0.0",
     "proxy": "^2.1.1",
     "proxyquire": "^2.1.3",
     "simple-get": "^4.0.1",

package/test/http-timeout.test.js

@@ -6,19 +6,19 @@ const From = require('..')
 const got = require('got')
 const FakeTimers = require('@sinonjs/fake-timers')
 
-const clock = FakeTimers.createClock()
-
 test('http request timeout', async (t) => {
+  const clock = FakeTimers.createClock()
   const target = Fastify()
   t.teardown(target.close.bind(target))
 
   target.get('/', (_request, reply) => {
     t.pass('request arrives')
 
-    clock.setTimeout(() => {
+    setTimeout(() => {
       reply.status(200).send('hello world')
-      t.end()
     }, 200)
+
+    clock.tick(200)
   })
 
   await target.listen({ port: 0 })
@@ -45,7 +45,60 @@ test('http request timeout', async (t) => {
       error: 'Gateway Timeout',
       message: 'Gateway Timeout'
     })
+    return
+  }
+
+  t.fail()
+})
+
+test('http request with specific timeout', async (t) => {
+  const clock = FakeTimers.createClock()
+  const target = Fastify()
+  t.teardown(target.close.bind(target))
+
+  target.get('/', (_request, reply) => {
+    t.pass('request arrives')
+
+    setTimeout(() => {
+      reply.status(200).send('hello world')
+    }, 200)
+
     clock.tick(200)
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, { http: { requestOptions: { timeout: 100 } } })
+
+  instance.get('/success', (_request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`, {
+      timeout: 300
+    })
+  })
+  instance.get('/fail', (_request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`, {
+      timeout: 50
+    })
+  })
+
+  await instance.listen({ port: 0 })
+  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/success`, { retry: 0 })
+  t.equal(statusCode, 200)
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/fail`, { retry: 0 })
+  } catch (err) {
+    t.equal(err.response.statusCode, 504)
+    t.match(err.response.headers['content-type'], /application\/json/)
+    t.same(JSON.parse(err.response.body), {
+      statusCode: 504,
+      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+      error: 'Gateway Timeout',
+      message: 'Gateway Timeout'
+    })
     return
   }
 

package/test/http2-timeout.test.js

@@ -4,6 +4,7 @@ const { test } = require('tap')
 const Fastify = require('fastify')
 const From = require('..')
 const got = require('got')
+const FakeTimers = require('@sinonjs/fake-timers')
 
 test('http2 request timeout', async (t) => {
   const target = Fastify({ http2: true, sessionTimeout: 0 })
@@ -49,6 +50,63 @@ test('http2 request timeout', async (t) => {
   t.fail()
 })
 
+test('http2 request with specific timeout', async (t) => {
+  const clock = FakeTimers.createClock()
+  const target = Fastify({ http2: true })
+  t.teardown(target.close.bind(target))
+
+  target.get('/', (_request, reply) => {
+    t.pass('request arrives')
+
+    setTimeout(() => {
+      reply.status(200).send('hello world')
+    }, 200)
+
+    clock.tick(200)
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: { requestTimeout: 100, sessionTimeout: 6000 }
+  })
+
+  instance.get('/success', (_request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`, {
+      timeout: 300
+    })
+  })
+  instance.get('/fail', (_request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`, {
+      timeout: 50
+    })
+  })
+
+  await instance.listen({ port: 0 })
+  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/success`, { retry: 0 })
+  t.equal(statusCode, 200)
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/fail`, { retry: 0 })
+  } catch (err) {
+    t.equal(err.response.statusCode, 504)
+    t.match(err.response.headers['content-type'], /application\/json/)
+    t.same(JSON.parse(err.response.body), {
+      statusCode: 504,
+      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+      error: 'Gateway Timeout',
+      message: 'Gateway Timeout'
+    })
+    return
+  }
+
+  t.fail()
+})
+
 test('http2 session timeout', async (t) => {
   const target = Fastify({ http2: true, sessionTimeout: 0 })
   t.teardown(target.close.bind(target))

package/test/undici-timeout.test.js

@@ -1,24 +1,24 @@
 'use strict'
 
-const t = require('tap')
+const { test } = require('tap')
 const Fastify = require('fastify')
 const From = require('..')
 const got = require('got')
 const FakeTimers = require('@sinonjs/fake-timers')
 
-const clock = FakeTimers.createClock()
-
-t.test('undici request timeout', async (t) => {
+test('undici request timeout', async (t) => {
+  const clock = FakeTimers.createClock()
   const target = Fastify()
   t.teardown(target.close.bind(target))
 
   target.get('/', (_request, reply) => {
     t.pass('request arrives')
 
-    clock.setTimeout(() => {
+    setTimeout(() => {
       reply.status(200).send('hello world')
-      t.end()
     }, 1000)
+
+    clock.tick(1000)
   })
 
   await target.listen({ port: 0 })
@@ -50,7 +50,66 @@ t.test('undici request timeout', async (t) => {
       error: 'Gateway Timeout',
       message: 'Gateway Timeout'
     })
+    return
+  }
+
+  t.fail()
+})
+
+test('undici request with specific timeout', async (t) => {
+  const clock = FakeTimers.createClock()
+  const target = Fastify()
+  t.teardown(target.close.bind(target))
+
+  target.get('/', (_request, reply) => {
+    t.pass('request arrives')
+
+    setTimeout(() => {
+      reply.status(200).send('hello world')
+    }, 1000)
+
     clock.tick(1000)
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    undici: {
+      headersTimeout: 100,
+    }
+  })
+
+  instance.get('/success', (_request, reply) => {
+    reply.from('/', {
+      timeout: 1000
+    })
+  })
+  instance.get('/fail', (_request, reply) => {
+    reply.from('/', {
+      timeout: 50
+    })
+  })
+
+  await instance.listen({ port: 0 })
+
+  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/success`, { retry: 0 })
+  t.equal(statusCode, 200)
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/fail`, { retry: 0 })
+  } catch (err) {
+    t.equal(err.response.statusCode, 504)
+    t.match(err.response.headers['content-type'], /application\/json/)
+    t.same(JSON.parse(err.response.body), {
+      statusCode: 504,
+      code: 'FST_REPLY_FROM_GATEWAY_TIMEOUT',
+      error: 'Gateway Timeout',
+      message: 'Gateway Timeout'
+    })
     return
   }
 

package/types/index.d.ts

@@ -16,19 +16,19 @@ import {
   AgentOptions,
   IncomingHttpHeaders,
   RequestOptions,
-} from 'http'
+} from 'node:http'
 import {
   ClientSessionOptions,
   ClientSessionRequestOptions,
   IncomingHttpHeaders as Http2IncomingHttpHeaders,
   SecureClientSessionOptions,
-} from 'http2'
+} from 'node:http2'
 import {
   Agent as SecureAgent,
   AgentOptions as SecureAgentOptions,
   RequestOptions as SecureRequestOptions
-} from 'https'
-import { Pool, ProxyAgent } from 'undici'
+} from 'node:https'
+import { Pool, ProxyAgent, Dispatcher } from 'undici'
 
 declare module 'fastify' {
   interface FastifyReply {
@@ -83,6 +83,7 @@ declare namespace fastifyReplyFrom {
       base: string
     ) => string;
     method?: HTTPMethods;
+    timeout?: number;
   }
 
   interface Http2Options {
@@ -104,7 +105,7 @@ declare namespace fastifyReplyFrom {
     disableCache?: boolean;
     http?: HttpOptions;
     http2?: Http2Options | boolean;
-    undici?: Pool.Options & { proxy?: string | URL | ProxyAgent.Options };
+    undici?: Pool.Options & { proxy?: string | URL | ProxyAgent.Options } | { request: Dispatcher['request'] };
     contentTypesToEncode?: string[];
     retryMethods?: (HTTPMethods | 'TRACE')[];
     maxRetriesOn503?: number;

package/types/index.test-d.ts

@@ -1,9 +1,10 @@
 import fastify, { FastifyReply, FastifyRequest, RawReplyDefaultExpression, RawServerBase, RequestGenericInterface, RouteGenericInterface } from 'fastify'
 import * as http from 'node:http'
-import { IncomingHttpHeaders } from 'http2'
+import { IncomingHttpHeaders } from 'node:http2'
 import * as https from 'node:https'
-import { AddressInfo } from 'net'
+import { AddressInfo } from 'node:net'
 import { expectType } from 'tsd'
+import { Agent, Client, Dispatcher, Pool } from 'undici'
 import replyFrom, { FastifyReplyFromOptions } from '..'
 // @ts-ignore
 import tap from 'tap'
@@ -69,6 +70,7 @@ async function main () {
   })
   server.get('/v3', (_request, reply) => {
     reply.from('/v3', {
+      timeout: 1000,
       body: { hello: 'world' },
       rewriteRequestHeaders (req, headers) {
         expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req)
@@ -101,7 +103,7 @@ async function main () {
   instance.get('/http2', (_request, reply) => {
     reply.from('/', {
       method: 'POST',
-      // eslint-disable-next-line n/handle-callback-err -- Not a real request, not handling errors
+
       retryDelay: ({ req, res, getDefaultDelay }) => {
         const defaultDelay = getDefaultDelay()
         if (defaultDelay) return defaultDelay
@@ -158,6 +160,34 @@ async function main () {
   })
   await undiciInstance.ready()
 
+  const undiciInstanceAgent = fastify()
+  undiciInstance.register(replyFrom, {
+    base: 'http://example2.com',
+    undici: new Agent()
+  })
+  await undiciInstanceAgent.ready()
+
+  const undiciInstancePool = fastify()
+  undiciInstance.register(replyFrom, {
+    base: 'http://example2.com',
+    undici: new Pool('http://example2.com')
+  })
+  await undiciInstancePool.ready()
+
+  const undiciInstanceClient = fastify()
+  undiciInstance.register(replyFrom, {
+    base: 'http://example2.com',
+    undici: new Client('http://example2.com')
+  })
+  await undiciInstanceClient.ready()
+
+  const undiciInstanceDispatcher = fastify()
+  undiciInstance.register(replyFrom, {
+    base: 'http://example2.com',
+    undici: new Dispatcher()
+  })
+  await undiciInstanceDispatcher.ready()
+
   tap.pass('done')
   tap.end()
 }