@fastify/reply-from 9.6.0 → 9.8.0

package/README.md

@@ -82,7 +82,7 @@ proxy.register(require('@fastify/reply-from'), {
 
 #### `undici`
 
-By default, [undici](https://github.com/mcollina/undici) will be used to perform the HTTP/1.1
+By default, [undici](https://github.com/nodejs/undici) will be used to perform the HTTP/1.1
 requests. Enabling this flag should guarantee
 20-50% more throughput.
 
@@ -102,6 +102,18 @@ proxy.register(require('@fastify/reply-from'), {
   }
 })
 ```
+
+You can also include a proxy for the undici client:
+
+```js
+proxy.register(require('@fastify/reply-from'), {
+  base: 'http://localhost:3001/',
+  undici: {
+    proxy: 'http://my.proxy.server:8080',
+  }
+})
+```
+
 See undici own options for more configurations.
 
 You can also pass the plugin a custom instance:
@@ -281,6 +293,7 @@ If a `handler` is passed to the `retryDelay` object the onus is on the client to
 - `res` is the raw response returned by the underlying agent (if available) __Note__: this object is not a Fastify response, but instead the low-level response from the agent. This property may be null if no response was obtained at all, like from a connection reset or timeout.
 - `attempt` in the object callback refers to the current retriesAttempt number. You are given the freedom to use this in concert with the retryCount property set to handle retries
 - `getDefaultRetry` refers to the default retry handler. If this callback returns not null and you wish to handle those case of errors simply invoke it as done below.
+- `retriesCount` refers to the retriesCount property a client passes to reply-from. Note if the client does not explicitly set this value it will default to 0. The objective value here is to avoid hard-coding and seeing the retriesCount set. It is your perogative to ensure that you ensure the value here is as you wish (and not `0` if not intended to be as a result of a lack of not setting it).
 
 Given example
 
@@ -324,7 +337,7 @@ const customRetryLogic = ({req, res, err, getDefaultRetry}: RetryDetails) => {
 ### `reply.from(source, [opts])`
 
 The plugin decorates the
-[`Reply`](https://github.com/fastify/fastify/blob/master/docs/Reply.md)
+[`Reply`](https://fastify.dev/docs/latest/Reference/Reply)
 instance with a `from` method, which will reply to the original request
 __from the desired source__. The options allows to override any part of
 the request or response being sent or received to/from the source.
@@ -427,7 +440,7 @@ server.register(fastifyHttpProxy, {
 });
 ```
 
-#### `queryString` or `queryString(search, reqUrl)`
+#### `queryString` or `queryString(search, reqUrl, request)`
 
 Replaces the original querystring of the request with what is specified.
 This will be passed to

package/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const fp = require('fastify-plugin')
-const { lru } = require('tiny-lru')
+const { LruMap } = require('toad-cache')
 const querystring = require('fast-querystring')
 const fastContentTypeParse = require('fast-content-type-parse')
 const Stream = require('node:stream')
@@ -32,7 +32,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   const retryMethods = new Set(opts.retryMethods || [
     'GET', 'HEAD', 'OPTIONS', 'TRACE'])
 
-  const cache = opts.disableCache ? undefined : lru(opts.cacheURLs || 100)
+  const cache = opts.disableCache ? undefined : new LruMap(opts.cacheURLs || 100)
   const base = opts.base
   const requestBuilt = buildRequest({
     http: opts.http,
@@ -80,7 +80,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     const sourceHttp2 = req.httpVersionMajor === 2
     const headers = sourceHttp2 ? filterPseudoHeaders(req.headers) : { ...req.headers }
     headers.host = url.host
-    const qs = getQueryString(url.search, req.url, opts)
+    const qs = getQueryString(url.search, req.url, opts, this.request)
     let body = ''
 
     if (opts.body !== undefined) {
@@ -163,7 +163,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
 
     if (retryDelay) {
       requestImpl = createRequestRetry(request, this, (req, res, err, retries) => {
-        return retryDelay({ err, req, res, attempt: retries, getDefaultDelay })
+        return retryDelay({ err, req, res, attempt: retries, getDefaultDelay, retriesCount })
       })
     } else {
       requestImpl = createRequestRetry(request, this, getDefaultDelay)
@@ -227,9 +227,9 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   name: '@fastify/reply-from'
 })
 
-function getQueryString (search, reqUrl, opts) {
+function getQueryString (search, reqUrl, opts, request) {
   if (typeof opts.queryString === 'function') {
-    return '?' + opts.queryString(search, reqUrl)
+    return '?' + opts.queryString(search, reqUrl, request)
   }
 
   if (opts.queryString) {

package/lib/request.js

@@ -3,7 +3,7 @@ const http = require('node:http')
 const https = require('node:https')
 const querystring = require('node:querystring')
 const eos = require('end-of-stream')
-const pump = require('pump')
+const { pipeline } = require('node:stream')
 const undici = require('undici')
 const { stripHttp1ConnectionHeaders } = require('./utils')
 const http2 = require('node:http2')
@@ -83,7 +83,11 @@ function buildRequest (opts) {
     } else if (isUndiciInstance(opts.undici)) {
       undiciInstance = opts.undici
     } else if (!globalAgent) {
-      undiciAgent = new undici.Agent(getUndiciOptions(opts.undici))
+      if (undiciOpts.proxy) {
+        undiciAgent = new undici.ProxyAgent(getUndiciProxyOptions(opts.undici))
+      } else {
+        undiciAgent = new undici.Agent(getUndiciOptions(opts.undici))
+      }
     } else {
       undiciAgent = undici.getGlobalDispatcher()
     }
@@ -204,7 +208,8 @@ function buildRequest (opts) {
       ...stripHttp1ConnectionHeaders(opts.headers)
     }, http2Opts.requestOptions)
     const isGet = opts.method === 'GET' || opts.method === 'get'
-    if (!isGet) {
+    const isDelete = opts.method === 'DELETE' || opts.method === 'delete'
+    if (!isGet && !isDelete) {
       end(req, opts.body, done)
     }
     req.setTimeout(http2Opts.requestTimeout, () => {
@@ -248,7 +253,7 @@ function end (req, body, cb) {
   if (!body || typeof body === 'string' || body instanceof Uint8Array) {
     req.end(body)
   } else if (body.pipe) {
-    pump(body, req, err => {
+    pipeline(body, req, err => {
       if (err) cb(err)
     })
   } else {
@@ -303,6 +308,13 @@ function getAgentOptions (opts) {
   }
 }
 
+function getUndiciProxyOptions ({ proxy, ...opts }) {
+  if (typeof proxy === 'string' || proxy instanceof URL) {
+    return getUndiciOptions({ uri: proxy, ...opts })
+  }
+  return getUndiciOptions({ ...proxy, ...opts })
+}
+
 function getUndiciOptions (opts = {}) {
   const res = {
     pipelining: 1,

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@fastify/reply-from",
-  "version": "9.6.0",
+  "version": "9.8.0",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
     "lint": "standard | snazzy",
-    "lint:fix": "standard --fix",
+    "lint:fix": "standard --fix | snazzy",
     "test": "npm run test:unit && npm run test:typescript",
     "test:unit": "tap",
     "test:typescript": "tsd"
@@ -41,6 +41,7 @@
     "h2url": "^0.2.0",
     "msgpack5": "^6.0.1",
     "nock": "^13.2.6",
+    "proxy": "^2.1.1",
     "proxyquire": "^2.1.3",
     "semver": "^7.5.1",
     "simple-get": "^4.0.1",
@@ -48,7 +49,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.30.1"
+    "tsd": "^0.31.0"
   },
   "dependencies": {
     "@fastify/error": "^3.0.0",
@@ -56,8 +57,7 @@
     "fast-content-type-parse": "^1.1.0",
     "fast-querystring": "^1.0.0",
     "fastify-plugin": "^4.0.0",
-    "pump": "^3.0.0",
-    "tiny-lru": "^11.0.0",
+    "toad-cache": "^3.7.0",
     "undici": "^5.19.1"
   },
   "pre-commit": [

package/test/full-delete-http2.test.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+test('http -> http2', async function (t) {
+  const instance = Fastify()
+
+  t.teardown(instance.close.bind(instance))
+
+  const target = Fastify({
+    http2: true
+  })
+
+  target.delete('/', (request, reply) => {
+    t.pass('request proxied')
+    reply.code(200).header('x-my-header', 'hello!').send({
+      hello: 'world'
+    })
+  })
+
+  instance.delete('/', (request, reply) => {
+    reply.from()
+  })
+
+  t.teardown(target.close.bind(target))
+
+  await target.listen({ port: 0 })
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: true
+  })
+
+  await instance.listen({ port: 0 })
+
+  const { headers, body, statusCode } = await got(
+    `http://localhost:${instance.server.address().port}`,
+    {
+      method: 'DELETE',
+      responseType: 'json'
+    }
+  )
+  t.equal(statusCode, 200)
+  t.equal(headers['x-my-header'], 'hello!')
+  t.match(headers['content-type'], /application\/json/)
+  t.same(body, { hello: 'world' })
+})

package/test/full-querystring-rewrite-option-function-request.test.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('node:http')
+const get = require('simple-get').concat
+const querystring = require('node:querystring')
+
+const instance = Fastify()
+
+instance.addHook('preHandler', (request, reply, done) => {
+  request.addedVal = 'test'
+  done()
+})
+
+t.plan(10)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  t.equal(req.url, '/world?q=test')
+  res.statusCode = 205
+  res.setHeader('Content-Type', 'text/plain')
+  res.setHeader('x-my-header', 'hello!')
+  res.end('hello world')
+})
+
+instance.get('/hello', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}/world?a=b`, {
+    queryString (search, reqUrl, request) {
+      return querystring.stringify({ q: request.addedVal })
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen({ port: 0 }, (err) => {
+  t.error(err)
+
+  instance.register(From)
+
+  instance.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}/hello?a=b`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.headers['content-type'], 'text/plain')
+      t.equal(res.headers['x-my-header'], 'hello!')
+      t.equal(res.statusCode, 205)
+      t.equal(data.toString(), 'hello world')
+    })
+  })
+})

package/test/retry-with-a-custom-handler.test.js

@@ -160,3 +160,27 @@ test('we can exceed our retryCount and introspect attempts independently', async
   t.equal(res.statusCode, 205)
   t.equal(res.body.toString(), 'Hello World 5!')
 })
+
+test('we handle our retries based on the retryCount', async (t) => {
+  const attemptCounter = []
+  const customRetryLogic = ({ req, res, err, attempt, getDefaultDelay, retriesCount }) => {
+    if (retriesCount < attempt) {
+      return null
+    }
+
+    if (res && res.statusCode === 500 && req.method === 'GET') {
+      attemptCounter.push(attempt)
+      return 0.1
+    }
+    return null
+  }
+
+  const { instance } = await setupServer(t, { retryDelay: customRetryLogic, retriesCount: 2 }, 500)
+
+  const res = await got.get(`http://localhost:${instance.server.address().port}`, { retry: 5 })
+
+  t.match(attemptCounter, [0, 1])
+  t.equal(res.headers['content-type'], 'text/plain')
+  t.equal(res.statusCode, 205)
+  t.equal(res.body.toString(), 'Hello World 5!')
+})

package/test/undici-proxy-agent.test.js

@@ -0,0 +1,79 @@
+'use strict'
+
+const { test } = require('tap')
+const { createServer } = require('node:http')
+const Fastify = require('fastify')
+const get = require('simple-get').concat
+const { createProxy } = require('proxy')
+const From = require('..')
+
+const configFormat = {
+  string: (value) => value,
+  'url instance': (value) => new URL(value),
+  object: (value) => ({ uri: value })
+}
+
+for (const [description, format] of Object.entries(configFormat)) {
+  test(`use undici ProxyAgent to connect through proxy - configured via ${description}`, async (t) => {
+    t.plan(5)
+    const target = await buildServer()
+    const proxy = await buildProxy()
+    t.teardown(target.close.bind(target))
+    t.teardown(proxy.close.bind(proxy))
+
+    const targetUrl = `http://localhost:${target.address().port}`
+    const proxyUrl = `http://localhost:${proxy.address().port}`
+
+    proxy.on('connect', () => {
+      t.ok(true, 'should connect to proxy')
+    })
+
+    target.on('request', (req, res) => {
+      res.setHeader('content-type', 'application/json')
+      res.end(JSON.stringify({ hello: 'world' }))
+    })
+
+    const instance = Fastify()
+    t.teardown(instance.close.bind(instance))
+
+    instance.register(From, {
+      base: targetUrl,
+      undici: {
+        proxy: format(proxyUrl)
+      }
+    })
+
+    instance.get('/', (request, reply) => {
+      reply.from()
+    })
+
+    const executionFlow = () => new Promise((resolve) => {
+      instance.listen({ port: 0 }, err => {
+        t.error(err)
+
+        get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+          t.error(err)
+          t.same(res.statusCode, 200)
+          t.match(JSON.parse(data.toString()), { hello: 'world' })
+          resolve()
+        })
+      })
+    })
+
+    await executionFlow()
+  })
+}
+
+function buildServer () {
+  return new Promise((resolve) => {
+    const server = createServer()
+    server.listen(0, () => resolve(server))
+  })
+}
+
+function buildProxy () {
+  return new Promise((resolve) => {
+    const server = createProxy(createServer())
+    server.listen(0, () => resolve(server))
+  })
+}

package/types/index.d.ts

@@ -28,6 +28,7 @@ import {
   RequestOptions as SecureRequestOptions
 } from "https";
 import { Pool } from 'undici';
+import { ProxyAgent } from 'undici';
 
 declare module "fastify" {
   interface FastifyReply {
@@ -40,13 +41,18 @@ declare module "fastify" {
 
 type FastifyReplyFrom = FastifyPluginCallback<fastifyReplyFrom.FastifyReplyFromOptions>
 declare namespace fastifyReplyFrom {
-  type QueryStringFunction = (search: string | undefined, reqUrl: string) => string;
+  type QueryStringFunction = (
+    search: string | undefined,
+    reqUrl: string,
+    request: FastifyRequest<RequestGenericInterface, RawServerBase>
+  ) => string;
 
   export type RetryDetails = {
     err: Error;
     req: FastifyRequest<RequestGenericInterface, RawServerBase>;
     res: FastifyReply<RawServerBase>;
     attempt: number;
+    retriesCount: number;
     getDefaultDelay: () => number | null;
   }
   export interface FastifyReplyFromHooks {
@@ -98,7 +104,7 @@ declare namespace fastifyReplyFrom {
     disableCache?: boolean;
     http?: HttpOptions;
     http2?: Http2Options | boolean;
-    undici?: Pool.Options;
+    undici?: Pool.Options & { proxy?: string  | URL | ProxyAgent.Options };
     contentTypesToEncode?: string[];
     retryMethods?: (HTTPMethods | 'TRACE')[];
     maxRetriesOn503?: number;

package/types/index.test-d.ts

@@ -38,7 +38,8 @@ const fullOptions: FastifyReplyFromOptions = {
   disableCache: false,
   undici: {
     connections: 100,
-    pipelining: 10
+    pipelining: 10,
+    proxy: 'http://example2.com:8080'
   },
   contentTypesToEncode: ['application/x-www-form-urlencoded'],
   retryMethods: ['GET', 'HEAD', 'OPTIONS', 'TRACE'],
@@ -60,6 +61,10 @@ async function main() {
 
   server.register(replyFrom, fullOptions);
 
+  server.register(replyFrom, { undici: { proxy: new URL('http://example2.com:8080') } });
+
+  server.register(replyFrom, { undici: { proxy: { uri: 'http://example2.com:8080' } } });
+
   server.get("/v1", (request, reply) => {
       expectType<FastifyReply>(reply.from());
   });
@@ -91,7 +96,7 @@ async function main() {
   instance.get("/http2", (request, reply) => {
       reply.from("/", {
           method: "POST",
-          retryDelay: ({err, req, res, attempt, getDefaultDelay}) => {
+          retryDelay: ({err, req, res, attempt, retriesCount, getDefaultDelay }) => {
               const defaultDelay = getDefaultDelay();
               if (defaultDelay) return defaultDelay;
 
@@ -111,7 +116,13 @@ async function main() {
           },
           onError(reply: FastifyReply<RawServerBase>, error) {
               return reply.send(error.error);
-          }
+          },
+          queryString(search, reqUrl, request) {
+              expectType<string | undefined>(search);
+              expectType<string>(reqUrl);
+              expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(request);
+              return '';
+          },
       });
   });