@fastify/reply-from 9.2.0 → 9.4.0

package/README.md

@@ -388,6 +388,10 @@ through `JSON.stringify()`.
 Setting this option for GET, HEAD requests will throw an error "Rewriting the body when doing a {GET|HEAD} is not allowed".
 Setting this option to `null` will strip the body (and `content-type` header) entirely from the proxied request.
 
+#### `method`
+
+Replaces the original request method with what is specified. 
+
 #### `retriesCount`
 
 How many times it will try to pick another connection on socket hangup (`ECONNRESET` error).  

package/index.js

@@ -52,6 +52,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
   fastify.decorateReply('from', function (source, opts) {
     opts = opts || {}
     const req = this.request.raw
+    const method = opts.method || req.method
     const onResponse = opts.onResponse
     const rewriteHeaders = opts.rewriteHeaders || headersNoOp
     const rewriteRequestHeaders = opts.rewriteRequestHeaders || requestHeadersNoOp
@@ -127,12 +128,12 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     // fastify ignore message body when it's a GET or HEAD request
     // when proxy this request, we should reset the content-length to make it a valid http request
     // discussion: https://github.com/fastify/fastify/issues/953
-    if (req.method === 'GET' || req.method === 'HEAD') {
+    if (method === 'GET' || method === 'HEAD') {
       // body will be populated here only if opts.body is passed.
       // if we are doing that with a GET or HEAD request is a programmer error
       // and as such we can throw immediately.
       if (body) {
-        throw new Error(`Rewriting the body when doing a ${req.method} is not allowed`)
+        throw new Error(`Rewriting the body when doing a ${method} is not allowed`)
       }
     }
 
@@ -141,13 +142,13 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     const requestHeaders = rewriteRequestHeaders(this.request, headers)
     const contentLength = requestHeaders['content-length']
     let requestImpl
-    if (retryMethods.has(req.method) && !contentLength) {
+    if (retryMethods.has(method) && !contentLength) {
       requestImpl = createRequestRetry(request, this, retriesCount, retryOnError, maxRetriesOn503)
     } else {
       requestImpl = request
     }
 
-    requestImpl({ method: req.method, url, qs, headers: requestHeaders, body }, (err, res) => {
+    requestImpl({ method, url, qs, headers: requestHeaders, body }, (err, res) => {
       if (err) {
         this.request.log.warn(err, 'response errored')
         if (!this.sent) {

package/lib/request.js

@@ -22,10 +22,17 @@ function shouldUseUndici (opts) {
   return true
 }
 
+function isRequestable (obj) {
+  return obj !== null &&
+    typeof obj === 'object' &&
+    typeof obj.request === 'function'
+}
+
 function isUndiciInstance (obj) {
   return obj instanceof undici.Pool ||
     obj instanceof undici.Client ||
-    obj instanceof undici.Dispatcher
+    obj instanceof undici.Dispatcher ||
+    isRequestable(obj)
 }
 
 function buildRequest (opts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "9.2.0",
+  "version": "9.4.0",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -31,7 +31,7 @@
     "@fastify/formbody": "^7.4.0",
     "@fastify/multipart": "^7.4.0",
     "@fastify/pre-commit": "^2.0.2",
-    "@sinonjs/fake-timers": "^10.0.0",
+    "@sinonjs/fake-timers": "^11.0.0",
     "@types/node": "^20.1.4",
     "@types/tap": "^15.0.7",
     "fastify": "^4.0.2",

package/test/method.test.js

@@ -0,0 +1,70 @@
+'use strict'
+
+const t = require('tap')
+const Fastify = require('fastify')
+const From = require('..')
+const http = require('http')
+const get = require('simple-get').concat
+
+const instance = Fastify()
+
+t.plan(9)
+t.teardown(instance.close.bind(instance))
+
+const bodyString = JSON.stringify({ hello: 'world' })
+
+const parsedLength = Buffer.byteLength(bodyString)
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'POST')
+  t.equal(req.headers['content-type'], 'application/json')
+  t.same(req.headers['content-length'], parsedLength)
+  let data = ''
+  req.setEncoding('utf8')
+  req.on('data', (d) => {
+    data += d
+  })
+  req.on('end', () => {
+    t.same(JSON.parse(data), { hello: 'world' })
+    res.statusCode = 200
+    res.setHeader('content-type', 'application/json')
+    res.end(JSON.stringify({ something: 'else' }))
+  })
+})
+
+instance.patch('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, { method: 'POST' })
+})
+
+t.teardown(target.close.bind(target))
+
+target.listen({ port: 0 }, (err) => {
+  t.error(err)
+
+  instance.addContentTypeParser('application/json', function (req, payload, done) {
+    done(null, payload)
+  })
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    undici: true
+  })
+
+  instance.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      method: 'PATCH',
+      headers: {
+        'content-type': 'application/json'
+      },
+      body: bodyString
+    }, (err, res, data) => {
+      t.error(err)
+      const parsed = JSON.parse(data)
+      t.same(parsed, { something: 'else' })
+    })
+  })
+})

package/test/undici-custom-dispatcher.test.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const { test } = require('tap')
+const undici = require('undici')
+const Fastify = require('fastify')
+const From = require('..')
+
+class CustomDispatcher {
+  constructor (...args) {
+    this._dispatcher = new undici.Pool(...args)
+  }
+
+  request (...args) {
+    return this._dispatcher.request(...args)
+  }
+
+  close (...args) {
+    return this._dispatcher.close(...args)
+  }
+
+  destroy (...args) {
+    return this._dispatcher.destroy(...args)
+  }
+}
+
+test('use a custom instance of \'undici\'', async t => {
+  const target = Fastify({
+    keepAliveTimeout: 1
+  })
+
+  target.get('/', (req, reply) => {
+    t.pass('request proxied')
+
+    reply.headers({
+      'Content-Type': 'text/plain',
+      'x-my-header': 'hello!'
+    })
+
+    reply.statusCode = 205
+    reply.send('hello world')
+  })
+
+  await target.listen({ port: 3001 })
+  t.teardown(async () => {
+    await target.close()
+  })
+
+  const instance = Fastify({
+    keepAliveTimeout: 1
+  })
+
+  instance.register(From, {
+    undici: new CustomDispatcher('http://localhost:3001')
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from('http://myserver.local')
+  })
+
+  await instance.listen({ port: 0 })
+  t.teardown(async () => {
+    await instance.close()
+  })
+
+  const res = await undici.request(`http://localhost:${instance.server.address().port}`)
+
+  t.equal(res.headers['content-type'], 'text/plain')
+  t.equal(res.headers['x-my-header'], 'hello!')
+  t.equal(res.statusCode, 205)
+
+  const data = await res.body.text()
+  t.equal(data, 'hello world')
+})

package/types/index.d.ts

@@ -67,6 +67,7 @@ declare namespace fastifyReplyFrom {
       request: FastifyRequest<RequestGenericInterface, RawServerBase>,
       base: string
     ) => string;
+    method?: HTTPMethods;
   }
 
   interface Http2Options {

package/types/index.test-d.ts

@@ -90,6 +90,7 @@ async function main() {
 
   instance.get("/http2", (request, reply) => {
       reply.from("/", {
+          method: "POST",
           rewriteHeaders(headers, req) {
               return headers;
           },