@fastify/reply-from 8.4.3 → 9.0.1

package/.taprc

@@ -8,4 +8,4 @@ statements: 96
 branches: 96
 
 files:
-  - test/**/*.js
+  - test/**/*.test.js

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/lib/request.js

@@ -112,6 +112,10 @@ function buildRequest (opts) {
     })
     req.on('error', done)
     req.on('response', res => {
+      // remove timeout for sse connections
+      if (res.headers['content-type'] === 'text/event-stream') {
+        req.setTimeout(0)
+      }
       done(null, { statusCode: res.statusCode, headers: res.headers, stream: res })
     })
     req.once('timeout', () => {
@@ -210,6 +214,12 @@ function buildRequest (opts) {
       if (err) done(err)
     })
     req.on('response', headers => {
+      // remove timeout for sse connections
+      if (headers['content-type'] === 'text/event-stream') {
+        req.setTimeout(0)
+        http2Client.setTimeout(0)
+      }
+
       const statusCode = headers[':status']
       done(null, { statusCode, headers, stream: req })
     })
@@ -250,7 +260,7 @@ function getHttp2Opts (opts) {
   http2Opts.sessionOptions = http2Opts.sessionOptions || {}
 
   if (!http2Opts.sessionTimeout) {
-    http2Opts.sessionTimeout = opts.sessionTimeout || 6000
+    http2Opts.sessionTimeout = opts.sessionTimeout || 60000
   }
   if (!http2Opts.requestTimeout) {
     http2Opts.requestTimeout = 10000

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "8.4.3",
+  "version": "9.0.1",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -46,7 +46,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.25.0"
+    "tsd": "^0.26.0"
   },
   "dependencies": {
     "@fastify/error": "^3.0.0",

package/test/get-upstream-type.test.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/http-timeout.test.js

@@ -0,0 +1,82 @@
+'use strict'
+
+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()
+
+test('http request timeout', async (t) => {
+  t.autoend(false)
+
+  const target = Fastify()
+  t.teardown(target.close.bind(target))
+
+  target.get('/', (request, reply) => {
+    t.pass('request arrives')
+
+    clock.setTimeout(() => {
+      reply.status(200).send('hello world')
+      t.end()
+    }, 200)
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, { http: { requestOptions: { timeout: 100 } } })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen({ port: 0 })
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/`, { 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'
+    })
+    clock.tick(200)
+    return
+  }
+
+  t.fail()
+})
+
+test('http sse removes timeout test', async (t) => {
+  const target = Fastify()
+  t.teardown(target.close.bind(target))
+
+  target.get('/', (request, reply) => {
+    t.pass('request arrives')
+
+    reply.header('content-type', 'text/event-stream').status(200).send('hello world')
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+
+  instance.register(From, { http: { requestOptions: { timeout: 100 } } })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen({ port: 0 })
+
+  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+  t.equal(statusCode, 200)
+})

package/test/{http2-target-multi-crash.js → http2-target-multi-crash.test.js}

@@ -16,7 +16,9 @@ test('http -> http2 crash multiple times', async (t) => {
 
   instance.register(From, {
     base: 'http://localhost:3128',
-    http2: true,
+    http2: {
+      sessionTimeout: 6000
+    },
     sessionTimeout: 200
   })
 

package/test/{http2-timeout.js → http2-timeout.test.js}

@@ -20,7 +20,7 @@ test('http2 request timeout', async (t) => {
 
   instance.register(From, {
     base: `http://localhost:${target.server.address().port}`,
-    http2: { requestTimeout: 100 }
+    http2: { requestTimeout: 100, sessionTimeout: 6000 }
   })
 
   instance.get('/', (request, reply) => {
@@ -92,3 +92,34 @@ test('http2 session timeout', async (t) => {
 
   t.fail()
 })
+
+test('http2 sse removes request and session timeout test', async (t) => {
+  const target = Fastify({ http2: true, sessionTimeout: 0 })
+
+  target.get('/', (request, reply) => {
+    t.pass('request arrives')
+
+    reply.status(200).header('content-type', 'text/event-stream').send('hello world')
+  })
+
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+
+  instance.register(From, {
+    base: `http://localhost:${target.server.address().port}`,
+    http2: { sessionTimeout: 100 }
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from(`http://localhost:${target.server.address().port}/`)
+  })
+
+  await instance.listen({ port: 0 })
+
+  t.teardown(instance.close.bind(instance))
+  t.teardown(target.close.bind(target))
+
+  const { statusCode } = await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+  t.equal(statusCode, 200)
+})

package/test/rewrite-headers-type.test.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.test.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;
           }
       });

package/test/http-timeout.js

@@ -1,57 +0,0 @@
-'use strict'
-
-const t = require('tap')
-const Fastify = require('fastify')
-const From = require('..')
-const got = require('got')
-const FakeTimers = require('@sinonjs/fake-timers')
-
-const clock = FakeTimers.createClock()
-
-t.autoend(false)
-
-const target = Fastify()
-t.teardown(target.close.bind(target))
-
-target.get('/', (request, reply) => {
-  t.pass('request arrives')
-
-  clock.setTimeout(() => {
-    reply.status(200).send('hello world')
-    t.end()
-  }, 200)
-})
-
-async function main () {
-  await target.listen({ port: 0 })
-
-  const instance = Fastify()
-  t.teardown(instance.close.bind(instance))
-
-  instance.register(From, { http: { requestOptions: { timeout: 100 } } })
-
-  instance.get('/', (request, reply) => {
-    reply.from(`http://localhost:${target.server.address().port}/`)
-  })
-
-  await instance.listen({ port: 0 })
-
-  try {
-    await got.get(`http://localhost:${instance.server.address().port}/`, { 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'
-    })
-    clock.tick(200)
-    return
-  }
-
-  t.fail()
-}
-
-main()