@fastify/reply-from

If you need to proxy content types like multipart/form-data or text/event-stream using @fastify/reply-from, you must prevent Fastify from parsing them. If the body is parsed, it is consumed and cannot be forwarded to the upstream server.

You can achieve this by registering custom content type parsers that pass the raw body through using fastify.addContentTypeParser.

// Register custom content type parsers that pass raw body through
fastify.addContentTypeParser('multipart/form-data', function (req, body, done) {
  done(null, body)
})

fastify.addContentTypeParser('text/event-stream', function (req, body, done) {
  done(null, body)
})

fastify.register(require('@fastify/reply-from'))

fastify.post('/upload', (request, reply) => {
  // The multipart data will be proxied as-is to the upstream server
  reply.from('http://upstream-server.com/upload')
})

fastify.post('/events', (request, reply) => {
  // The SSE data will be proxied as-is to the upstream server
  reply.from('http://upstream-server.com/events')
})

The reply.from() method automatically handles body forwarding and JSON encoding based on the following logic:

1. Manual Body: If opts.body is provided:

   • If opts.body is a stream, an error is thrown (streams are not yet supported as a new body).
   • If opts.contentType is not provided, it defaults to application/json and the body is stringified via JSON.stringify.
   • If opts.body is null, the body is removed and content-length is set to 0.

2. Automatic Body: If opts.body is not provided, it uses this.request.body:

   • If this.request.body is a Stream, it is forwarded as-is.
   • If it is not a stream, the plugin checks the Content-Type of the incoming request. If the type is in the contentTypesToEncode set (defaulting to application/json), the body is transparently stringified via JSON.stringify before being sent upstream.

Note: For GET or HEAD requests, providing a body is considered a programmer error and will throw an error.

To use the plugin, register it with your Fastify instance. You can configure how the proxy behaves using the opts object.

Plugin Options

const fastify = require('fastify')
const fastifyReplyFrom = require('@fastify/reply-from')

const app = fastify()

app.register(fastifyReplyFrom, {
  base: 'https://api.example.com'
})

You can provide a custom handler to retryDelay to define how the client should wait between retries. This allows you to implement custom logic for specific error codes or status codes.

The handler receives an object containing:

• err: The error thrown by the agent.
• req: The low-level request object.
• res: The low-level response object (can be null).
• attempt: The current retry attempt number.
• getDefaultRetry: A callback to invoke the default retry logic.
• retriesCount: The number of retries configured by the client.

If you return a value from the handler, that is used as the delay. If you return null, the retry logic for that specific case is bypassed (unless handled by getDefaultRetry).

const customRetryLogic = ({err, req, res, attempt, getDefaultRetry}) => {
  const defaultDelay = getDefaultRetry(req, res, err, attempt);
  if (defaultDelay) return defaultDelay();

  if (res && res.statusCode === 500 && req.method === 'GET') {
    return 300;
  }

  if (err && err.code == "UND_ERR_SOCKET"){
    return 600;
  }

  return null;
}

fastify.register(FastifyReplyFrom, {
  base: 'http://localhost:3001/',
  retryDelay: customRetryLogic
})

The from method decorates the Fastify Reply instance. It allows you to reply to the original request by forwarding it to a source URL.

Note: If base was specified in the plugin registration, the source should not override the host/origin.

Available opts for reply.from():

• onResponse(request, reply, response): Called when a response is received. Use this to modify the body or remove headers like content-length if the body size changes. Note: headers are already sent at this stage.
• onError(reply, error): Called on error. You must reply with the error.
• rewriteHeaders(headers, request): Rewrites response headers before they are copied to the outer response.
• rewriteRequestHeaders(request, headers): Rewrites request headers before they are sent to the source.
• getUpstream(request, base): Dynamically determines the upstream destination (HTTP/1 only).
• queryString: Replaces the original query string. Can be an object or a function returning a string.
• body: Replaces the request body. Setting to null strips the body and content-type. (Not allowed for GET/HEAD).
• method: Replaces the request method.
• retriesCount: Number of times to retry on ECONNRESET.
• contentType: Overrides the Content-Type header if body is being overridden.
• timeout: Specific timeout for this request, overriding plugin defaults.

// Example: Modifying the response body in onResponse
reply.from('http://upstream-service/api', {
  onResponse: (request, reply, res) => {
    reply.removeHeader('content-length');
    reply.send('New body of different length');
  }
})