@fastify/reply-from 8.4.3 → 9.0.0

package/README.md

@@ -292,21 +292,24 @@ The default behavior is `reply.send(error)`, which will be disabled if the
 option is specified.
 It must reply the error.
 
-#### `rewriteHeaders(headers, req)`
+#### `rewriteHeaders(headers, request)`
 
 Called to rewrite the headers of the response, before them being copied
 over to the outer response.
+Parameters are the original headers and the Fastify request.
 It must return the new headers object.
 
-#### `rewriteRequestHeaders(originalReq, headers)`
+#### `rewriteRequestHeaders(request, headers)`
 
 Called to rewrite the headers of the request, before them being sent to the other server.
+Parameters are the Fastify request and the original request headers.
 It must return the new headers object.
 
-#### `getUpstream(originalReq, base)`
+#### `getUpstream(request, base)`
 
 Called to get upstream destination, before the request is being sent. Useful when you want to decide which target server to call based on the request data.
 Helpful for a gradual rollout of new services.
+Parameters are the Fastify request and the base string from the plugin options.
 It must return the upstream destination.
 
 #### `queryString` or `queryString(search, reqUrl)`

package/index.js

@@ -63,7 +63,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
     }
 
     // we leverage caching to avoid parsing the destination URL
-    const dest = getUpstream(req, base)
+    const dest = getUpstream(this.request, base)
     let url
     if (cache) {
       const cacheKey = dest + source
@@ -136,7 +136,7 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
 
     !disableRequestLogging && this.request.log.info({ source }, 'fetching from remote server')
 
-    const requestHeaders = rewriteRequestHeaders(req, headers)
+    const requestHeaders = rewriteRequestHeaders(this.request, headers)
     const contentLength = requestHeaders['content-length']
     let requestImpl
     if (retryMethods.has(req.method) && !contentLength) {
@@ -166,11 +166,11 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
       !disableRequestLogging && this.request.log.info('response received')
       if (sourceHttp2) {
         copyHeaders(
-          rewriteHeaders(stripHttp1ConnectionHeaders(res.headers), req),
+          rewriteHeaders(stripHttp1ConnectionHeaders(res.headers), this.request),
           this
         )
       } else {
-        copyHeaders(rewriteHeaders(res.headers, req), this)
+        copyHeaders(rewriteHeaders(res.headers, this.request), this)
       }
       this.code(res.statusCode)
       if (onResponse) {

package/package.json

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

package/test/get-upstream-type.js

@@ -0,0 +1,46 @@
+'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()
+instance.register(From, {
+  disableCache: true
+})
+
+t.plan(8)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  res.end(req.headers.host)
+})
+
+instance.get('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    getUpstream: (req) => {
+      t.pass('getUpstream called with correct request parameter')
+      t.equal(req, request)
+      return `http://localhost:${target.address().port}`
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen({ port: 0 }, (err) => {
+  t.error(err)
+
+  target.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res) => {
+      t.error(err)
+      t.equal(res.statusCode, 200)
+    })
+  })
+})

package/test/rewrite-headers-type.js

@@ -0,0 +1,45 @@
+'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()
+instance.register(From)
+
+t.plan(8)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  res.statusCode = 205
+  res.end('hello world')
+})
+
+instance.get('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    rewriteHeaders: (headers, req) => {
+      t.pass('rewriteHeaders called with correct request parameter')
+      t.equal(req, request)
+      return {}
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen({ port: 0 }, (err) => {
+  t.error(err)
+
+  target.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.statusCode, 205)
+    })
+  })
+})

package/test/rewrite-request-headers-type.js

@@ -0,0 +1,45 @@
+'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()
+instance.register(From)
+
+t.plan(8)
+t.teardown(instance.close.bind(instance))
+
+const target = http.createServer((req, res) => {
+  t.pass('request proxied')
+  t.equal(req.method, 'GET')
+  res.statusCode = 205
+  res.end(req.headers.host)
+})
+
+instance.get('/', (request, reply) => {
+  reply.from(`http://localhost:${target.address().port}`, {
+    rewriteRequestHeaders: (originalReq, headers) => {
+      t.pass('rewriteRequestHeaders called with correct request parameter')
+      t.equal(originalReq, request)
+      return {}
+    }
+  })
+})
+
+t.teardown(target.close.bind(target))
+
+instance.listen({ port: 0 }, (err) => {
+  t.error(err)
+
+  target.listen({ port: 0 }, (err) => {
+    t.error(err)
+
+    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+      t.error(err)
+      t.equal(res.statusCode, 205)
+    })
+  })
+})

package/types/index.d.ts

@@ -11,7 +11,6 @@ import {
 } from 'fastify';
 
 import {
-  IncomingMessage,
   IncomingHttpHeaders,
   RequestOptions,
   AgentOptions,
@@ -23,7 +22,6 @@ import {
   Agent as SecureAgent
 } from "https";
 import {
-  Http2ServerRequest,
   IncomingHttpHeaders as Http2IncomingHttpHeaders,
   ClientSessionRequestOptions,
   ClientSessionOptions,
@@ -59,14 +57,14 @@ declare namespace fastifyReplyFrom {
     body?: unknown;
     rewriteHeaders?: (
       headers: Http2IncomingHttpHeaders | IncomingHttpHeaders,
-      req?: Http2ServerRequest | IncomingMessage
+      request?: FastifyRequest<RequestGenericInterface, RawServerBase>
     ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
     rewriteRequestHeaders?: (
-      req: Http2ServerRequest | IncomingMessage,
+      request: FastifyRequest<RequestGenericInterface, RawServerBase>,
       headers: Http2IncomingHttpHeaders | IncomingHttpHeaders
     ) => Http2IncomingHttpHeaders | IncomingHttpHeaders;
     getUpstream?: (
-      req: Http2ServerRequest | IncomingMessage,
+      request: FastifyRequest<RequestGenericInterface, RawServerBase>,
       base: string
     ) => string;
   }

package/types/index.test-d.ts

@@ -1,11 +1,10 @@
 import replyFrom, { FastifyReplyFromOptions } from "..";
-import fastify, {FastifyReply, RawServerBase} from "fastify";
+import fastify, {FastifyReply, FastifyRequest, RawServerBase, RequestGenericInterface} from "fastify";
 import { AddressInfo } from "net";
 import { IncomingHttpHeaders } from "http2";
 import { expectType } from 'tsd';
 import * as http from 'http';
 import * as https from 'https';
-import * as http2 from 'http2';
 // @ts-ignore
 import tap from 'tap'
 
@@ -67,11 +66,11 @@ async function main() {
       reply.from("/v3", {
           body: {hello: "world"},
           rewriteRequestHeaders(req, headers) {
-              expectType<http.IncomingMessage | http2.Http2ServerRequest>(req);
+              expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req);
               return headers;
           },
           getUpstream(req, base) {
-              expectType<http.IncomingMessage | http2.Http2ServerRequest>(req);
+              expectType<FastifyRequest<RequestGenericInterface, RawServerBase>>(req);
               return base;
           }
       });