/opt/canhelp/node_modules/next/dist/esm/server/lib/router-utils
Edit: /opt/canhelp/node_modules/next/dist/esm/server/lib/router-utils/proxy-request.js (3850B)
import url from 'url';
import { stringifyQuery } from '../../server-route-utils';
import { Duplex } from 'stream';
import { DetachedPromise } from '../../../lib/detached-promise';
export async function proxyRequest(req, res, parsedUrl, upgradeHead, reqBody, proxyTimeout) {
const { query } = parsedUrl;
delete parsedUrl.query;
parsedUrl.search = stringifyQuery(req, query);
const target = url.format(parsedUrl);
const HttpProxy = require('next/dist/compiled/http-proxy');
const proxy = new HttpProxy({
target,
changeOrigin: true,
ignorePath: true,
ws: true,
// we limit proxy requests to 30s by default, in development
// we don't time out WebSocket requests to allow proxying
proxyTimeout: proxyTimeout === null ? undefined : proxyTimeout || 30000,
headers: {
'x-forwarded-host': req.headers.host || ''
}
});
let finished = false;
// http-proxy does not properly detect a client disconnect in newer
// versions of Node.js. This is caused because it only listens for the
// `aborted` event on the our request object, but it also fully reads
// and closes the request object. Node **will not** fire `aborted` when
// the request is already closed. Listening for `close` on our response
// object will detect the disconnect, and we can abort the proxy's
// connection.
proxy.on('proxyReq', (proxyReq)=>{
res.on('close', ()=>proxyReq.destroy());
});
proxy.on('proxyRes', (proxyRes)=>{
if (res.destroyed) {
proxyRes.destroy();
} else {
res.on('close', ()=>proxyRes.destroy());
}
});
proxy.on('proxyRes', (proxyRes, innerReq, innerRes)=>{
const cleanup = (err)=>{
// cleanup event listeners to allow clean garbage collection
proxyRes.removeListener('error', cleanup);
proxyRes.removeListener('close', cleanup);
innerRes.removeListener('error', cleanup);
innerRes.removeListener('close', cleanup);
// destroy all source streams to propagate the caught event backward
innerReq.destroy(err);
proxyRes.destroy(err);
};
proxyRes.once('error', cleanup);
proxyRes.once('close', cleanup);
innerRes.once('error', cleanup);
innerRes.once('close', cleanup);
});
const detached = new DetachedPromise();
proxy.on('error', (err)=>{
console.error(`Failed to proxy ${target}`, err);
if (!finished) {
finished = true;
detached.reject(err);
if (!res.destroyed) {
if (!(res instanceof Duplex)) {
res.statusCode = 500;
}
res.end('Internal Server Error');
}
}
});
// If upgrade head is present or the response is a Duplex stream, treat as
// WebSocket request.
if (upgradeHead || res instanceof Duplex) {
proxy.on('proxyReqWs', (proxyReq)=>{
proxyReq.on('close', ()=>{
if (!finished) {
finished = true;
detached.resolve(true);
}
});
});
proxy.ws(req, res, upgradeHead);
detached.resolve(true);
} else {
proxy.on('proxyReq', (proxyReq)=>{
proxyReq.on('close', ()=>{
if (!finished) {
finished = true;
detached.resolve(true);
}
});
});
proxy.web(req, res, {
buffer: reqBody
});
}
// When the proxy finishes proxying the request, shut down the proxy.
return detached.promise.finally(()=>{
proxy.close();
});
}
//# sourceMappingURL=proxy-request.js.map