@fastify/reply-from 9.0.0 → 9.0.2

package/.github/workflows/ci.yml

@@ -2,6 +2,11 @@ name: CI
 
 on:
   push:
+    branches:
+     - main
+     - master
+     - next
+     - 'v*'
     paths-ignore:
       - 'docs/**'
       - '*.md'

package/.taprc

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

package/README.md

@@ -312,6 +312,56 @@ 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.
 
+Only http1! As http2 uses one connection for the whole session only the base upstream is used. If you want to
+have different upstreams based on the request you can add multiple Fastify.register's with different
+ContraintStrategies.
+
+e.g.:
+
+Route grpc-web/http1 and grpc/http2 to different routes with a ContentType-ConstraintStrategy:
+```
+const contentTypeMatchContraintStrategy = {
+    // strategy name for referencing in the route handler `constraints` options
+    name: 'contentType',
+    // storage factory for storing routes in the find-my-way route tree
+    storage: function () {
+      let handlers = {}
+      return {
+        get: (type: any) => { return handlers[type] || null },
+        set: (type: any, store: any) => { handlers[type] = store }
+      }
+    },
+    // function to get the value of the constraint from each incoming request
+    deriveConstraint: (req: any, ctx: any) => { 
+      return req.headers['content-type']
+    },
+    // optional flag marking if handlers without constraints can match requests that have a value for this constraint
+    mustMatchWhenDerived: true
+  }
+ 
+  server.addConstraintStrategy(contentTypeMatchContraintStrategy);
+```
+
+and then 2 different upstreams with different register's:
+```
+// grpc-web / http1
+server.register(fastifyHttpProxy, {
+    // Although most browsers send with http2, nodejs cannot handle this http2 request
+    // therefore we have to transport to the grpc-web-proxy via http1
+    http2: false,
+    upstream: 'http://grpc-web-proxy',
+    constraints: { "contentType": "application/grpc-web+proto" }   
+});
+
+// grpc / http2
+server.register(fastifyHttpProxy, {
+    http2: true,
+    upstream: 'http://grpc.server',
+    constraints: { "contentType": "application/grpc+proto" }   
+});
+```
+
+
 #### `queryString` or `queryString(search, reqUrl)`
 
 Replaces the original querystring of the request with what is specified.

package/index.js

@@ -17,6 +17,7 @@ const {
   ServiceUnavailableError,
   GatewayTimeoutError,
   ConnectionResetError,
+  ConnectTimeoutError,
   UndiciSocketError,
   InternalServerError
 } = require('./lib/errors')
@@ -157,6 +158,8 @@ const fastifyReplyFrom = fp(function from (fastify, opts, next) {
             onError(this, { error: new ConnectionResetError() })
           } else if (err.code === 'UND_ERR_SOCKET') {
             onError(this, { error: new UndiciSocketError() })
+          } else if (err.code === 'UND_ERR_CONNECT_TIMEOUT') {
+            onError(this, { error: new ConnectTimeoutError() })
           } else {
             onError(this, { error: new InternalServerError(err.message) })
           }

package/lib/errors.js

@@ -9,5 +9,6 @@ module.exports.Http2SessionTimeoutError = createError('FST_REPLY_FROM_HTTP2_SESS
 module.exports.ServiceUnavailableError = createError('FST_REPLY_FROM_SERVICE_UNAVAILABLE', 'Service Unavailable', 503)
 module.exports.GatewayTimeoutError = createError('FST_REPLY_FROM_GATEWAY_TIMEOUT', 'Gateway Timeout', 504)
 module.exports.ConnectionResetError = createError('ECONNRESET', 'Connection Reset', 500)
+module.exports.ConnectTimeoutError = createError('UND_ERR_CONNECT_TIMEOUT', 'Connect Timeout Error', 500)
 module.exports.UndiciSocketError = createError('UND_ERR_SOCKET', 'Undici Socket Error', 500)
 module.exports.InternalServerError = createError('FST_REPLY_FROM_INTERNAL_SERVER_ERROR', '%s', 500)

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": "9.0.0",
+  "version": "9.0.2",
   "description": "forward your HTTP request to another server, for fastify",
   "main": "index.js",
   "types": "types/index.d.ts",
@@ -32,7 +32,7 @@
     "@fastify/multipart": "^7.4.0",
     "@fastify/pre-commit": "^2.0.2",
     "@sinonjs/fake-timers": "^10.0.0",
-    "@types/node": "^18.0.0",
+    "@types/node": "^20.1.4",
     "@types/tap": "^15.0.7",
     "fastify": "^4.0.2",
     "form-data": "^4.0.0",
@@ -46,7 +46,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.25.0"
+    "tsd": "^0.28.0"
   },
   "dependencies": {
     "@fastify/error": "^3.0.0",
@@ -54,7 +54,7 @@
     "fast-querystring": "^1.0.0",
     "fastify-plugin": "^4.0.0",
     "pump": "^3.0.0",
-    "tiny-lru": "^10.0.0",
+    "tiny-lru": "^11.0.0",
     "undici": "^5.19.1"
   },
   "pre-commit": [

package/test/{core-with-path-in-base.js → core-with-path-in-base.test.js}

@@ -39,7 +39,10 @@ target.listen({ port: 0 }, (err) => {
   instance.listen({ port: 0 }, (err) => {
     t.error(err)
 
-    get(`http://localhost:${instance.server.address().port}`, (err, res, data) => {
+    get({
+      url: `http://localhost:${instance.server.address().port}`,
+      agent: false
+    }, (err, res, data) => {
       t.error(err)
       t.equal(res.headers['content-type'], 'text/plain')
       t.equal(res.headers['x-my-header'], 'hello!')

package/test/{disable-request-logging.js → disable-request-logging.test.js}

@@ -19,12 +19,12 @@ const target = http.createServer((req, res) => {
 })
 
 t.test('use a custom instance of \'undici\'', async t => {
+  t.plan(3)
   t.teardown(target.close.bind(target))
 
   await new Promise((resolve, reject) => target.listen({ port: 0 }, err => err ? reject(err) : resolve()))
 
   t.test('disableRequestLogging is set to true', t => {
-    t.plan(10)
     const logStream = split(JSON.parse)
     const instance = Fastify({
       logger: {
@@ -69,7 +69,6 @@ t.test('use a custom instance of \'undici\'', async t => {
   })
 
   t.test('disableRequestLogging is set to false', t => {
-    t.plan(8)
     const logStream = split(JSON.parse)
     const instance = Fastify({
       logger: {
@@ -114,7 +113,6 @@ t.test('use a custom instance of \'undici\'', async t => {
   })
 
   t.test('disableRequestLogging is not defined', t => {
-    t.plan(8)
     const logStream = split(JSON.parse)
     const instance = Fastify({
       logger: {

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/undici-connect-timeout.test.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const t = require('tap')
+const http = require('http')
+const net = require('net')
+const Fastify = require('fastify')
+const From = require('..')
+const got = require('got')
+
+t.autoend(false)
+
+// never connect
+net.connect = function (options) {
+  return new net.Socket(options)
+}
+
+const target = http.createServer((req, res) => {
+  t.fail('target never called')
+})
+
+async function main () {
+  t.plan(2)
+  await target.listen({ port: 0 })
+
+  const instance = Fastify()
+  t.teardown(instance.close.bind(instance))
+  t.teardown(target.close.bind(target))
+
+  instance.register(From, {
+    base: `http://localhost:${target.address().port}`,
+    undici: {
+      connectTimeout: 50
+    }
+  })
+
+  instance.get('/', (request, reply) => {
+    reply.from()
+  })
+
+  await instance.listen({ port: 0 })
+
+  try {
+    await got.get(`http://localhost:${instance.server.address().port}/`, { retry: 0 })
+  } catch (err) {
+    t.equal(err.response.statusCode, 500)
+    t.same(JSON.parse(err.response.body), {
+      statusCode: 500,
+      code: 'UND_ERR_CONNECT_TIMEOUT',
+      error: 'Internal Server Error',
+      message: 'Connect Timeout Error'
+    })
+    return
+  }
+
+  t.fail()
+}
+
+main()

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()