How can we replicate the one-liner streaming behavior provided by the deprecated request package?

[vvhiz]

The one-liner solution in the deprecated request package is impressive:

req.pipe(request('http://mysite.com/doodle.png')).pipe(resp)

We have a Node.js app that serves as a proxy server and uses this one-liner to forward all incoming requests to a private API server, then relay the responses back to users:

const app = express();

for (const endpoint of ENDPOINT_LIST) {
  app.all(endpoint, (req, res, next) => {
    req.pipe(request(RPIVATE_API_BASE_URL + endpoint)).pipe(res).on('error', next);
  }
}

However, since the request package is deprecated and contains multiple vulnerabilities, we need to migrate away from it. We are now considering Undici, as it is actively maintained by the Node.js team.

That said, it seems there’s no direct one-to-one replacement for the example above, meaning we’ll likely need to handle various edge cases manually — such as header management and other request/response handling details.

I’ve looked into the example of undici.stream() and the exmaple of undici.pipeline(), but both of them are somewhat confusing:

For pipeline()

  client.pipeline({
    path: '/',
    method: 'GET'
  }, ({ statusCode, headers, body }) => {
    console.log(`response received ${statusCode}`)
    console.log('headers', headers)
    return pipeline(body, new PassThrough(), () => {})
  }),

The limitations are:

• You must explicitly provide PipelineOptions.
• It only pipelines the response body, not the full response itself.

For stream()

fastifyServer.route({
  url: '/',
  method: 'GET',
  handler: (request, response) => {
    nodeServerUndiciClient.stream({
      path: '/',
      method: 'GET',
      opaque: response
    }, ({ opaque }) => opaque.raw)
  }
})

Apart from explicitly specifying PipelineOptions, it’s unclear how to handle the request parameter in the handler when streaming to a nodeServer.

[metcoder95]

There's no current possible way to replicate the exact one liner for the whole response, just for the response's body.

You can extend the dispatcher with an interceptor that directly does that as part of the response body, although can be complicated to achieve given (I'm unaware how the request's pipes works exactly).

You'd need to always check for headers and later pipe the response as you need.