@fastify/reply-from 9.3.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "9.3.0",
+  "version": "9.4.0",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "types": "types/index.d.ts",

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/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;
           },