@fastify/reply-from 9.0.1 → 10.0.0

package/.github/workflows/ci.yml

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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fastify/reply-from",
-  "version": "9.0.1",
+  "version": "10.0.0",
   "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.26.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.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.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/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()