com.jimuwd.xian.registry-proxy 1.0.60 → 1.0.63

package/dist/index.js

@@ -160,8 +160,7 @@ async function fetchFromRegistry(registry, targetUrl, limiter) {
         limiter.release();
     }
 }
-// 修改后的 writeSuccessfulResponse 函数
-async function writeSuccessfulResponse(registryInfo, targetUrl, res, upstreamResponse, req, proxyInfo, proxyPort, registryInfos) {
+async function writeResponseToDownstreamClient(registryInfo, targetUrl, resToDownstreamClient, upstreamResponse, downstreamReq, proxyInfo, proxyPort, registryInfos) {
     if (!upstreamResponse.ok)
         throw new Error("Only 2xx upstream response is supported");
     try {
@@ -184,7 +183,7 @@ async function writeSuccessfulResponse(registryInfo, targetUrl, res, upstreamRes
             // JSON 处理逻辑
             const data = await upstreamResponse.json();
             if (data.versions) {
-                const host = req.headers.host || `localhost:${proxyPort}`;
+                const host = downstreamReq.headers.host || `localhost:${proxyPort}`;
                 const baseUrl = `${proxyInfo.https ? 'https' : 'http'}://${host}${proxyInfo.basePath === '/' ? '' : proxyInfo.basePath}`;
                 for (const versionKey in data.versions) {
                     const packageVersion = data.versions[versionKey];
@@ -196,32 +195,49 @@ async function writeSuccessfulResponse(registryInfo, targetUrl, res, upstreamRes
                     }
                 }
             }
-            res.writeHead(upstreamResponse.status, { "content-type": contentType }).end(JSON.stringify(data));
+            resToDownstreamClient.writeHead(upstreamResponse.status, { "content-type": contentType }).end(JSON.stringify(data));
         }
         else {
             // 二进制流处理
             if (!upstreamResponse.body) {
                 logger.error(`Empty response body from ${targetUrl}`);
-                res.writeHead(502).end('Empty Upstream Response');
+                resToDownstreamClient.writeHead(502).end('Empty Upstream Response');
             }
             else {
                 // write back to client
-                res.writeHead(upstreamResponse.status, safeHeaders);
+                resToDownstreamClient.writeHead(upstreamResponse.status, safeHeaders);
                 // stop transfer if client is closed accidentally.
-                // req.on('close', () => upstreamResponse.body?.unpipe());
+                const cleanup = () => {
+                    downstreamReq.off('close', cleanup);
+                    logger.warn("Stop transfer when client is closed accidentally.");
+                    upstreamResponse.body?.unpipe();
+                };
+                downstreamReq.on('close', cleanup);
                 // write back body data (chunked probably)
+                // pipe upstream body to downstream client and end when upstream ends.
+                upstreamResponse.body.pipe(resToDownstreamClient, { end: true });
                 upstreamResponse.body
-                    .on('data', (chunk) => res.write(chunk))
-                    .on('end', () => res.end())
-                    .on('close', () => res.destroy(new Error(`Upstream server ${registryInfo.normalizedRegistryUrl} closed connection while transferring data on url ${targetUrl}`)))
-                    .on('error', (err) => res.destroy(new Error(`Stream error: ${err.message}`, { cause: err, })));
+                    .on('data', (chunk) => logger.info(`chunk transferred size=${chunk.length}`))
+                    .on('end', () => {
+                    logger.info(`Upstream server ${registryInfo.normalizedRegistryUrl} response.body ended on url ${targetUrl}`);
+                })
+                    .on('close', () => {
+                    const errMsg = `Upstream server ${registryInfo.normalizedRegistryUrl} closed connection while transferring data on url ${targetUrl}`;
+                    logger.error(errMsg);
+                    // resToDownstreamClient.destroy(new Error(errMsg));
+                })
+                    .on('error', (err) => {
+                    const errMsg = `Stream error: ${err.message}`;
+                    logger.error(errMsg);
+                    resToDownstreamClient.destroy(new Error(errMsg, { cause: err, }));
+                });
             }
         }
     }
     catch (err) {
         logger.error('Failed to write upstreamResponse:', err);
-        if (!res.headersSent) {
-            res.writeHead(502).end('Internal Server Error');
+        if (!resToDownstreamClient.headersSent) {
+            resToDownstreamClient.writeHead(502).end('Internal Server Error');
         }
     }
 }
@@ -233,41 +249,41 @@ export async function startProxyServer(proxyConfigPath, localYarnConfigPath, glo
     logger.info('Proxy base path:', basePathPrefixedWithSlash);
     logger.info('HTTPS:', !!proxyInfo.https);
     let proxyPort;
-    const requestHandler = async (req, res) => {
-        if (!req.url || !req.headers.host) {
-            res.writeHead(400).end('Invalid Request');
+    const requestHandler = async (reqFromDownstreamClient, resToDownstreamClient) => {
+        if (!reqFromDownstreamClient.url || !reqFromDownstreamClient.headers.host) {
+            resToDownstreamClient.writeHead(400).end('Invalid Request');
             return;
         }
-        const fullUrl = new URL(req.url, `${proxyInfo.https ? 'https' : 'http'}://${req.headers.host}`);
+        const fullUrl = new URL(reqFromDownstreamClient.url, `${proxyInfo.https ? 'https' : 'http'}://${reqFromDownstreamClient.headers.host}`);
         if (!fullUrl.pathname.startsWith(basePathPrefixedWithSlash)) {
-            res.writeHead(404).end('Not Found');
+            resToDownstreamClient.writeHead(404).end('Not Found');
             return;
         }
         const path = basePathPrefixedWithSlash === '/'
             ? fullUrl.pathname
             : fullUrl.pathname.slice(basePathPrefixedWithSlash.length);
         // 顺序尝试注册表，获取第一个成功响应
-        let successfulResponse = null;
+        let successfulResponseFromUpstream = null;
         let targetRegistry = null;
         let targetUrl = null;
         for (const registry of registryInfos) {
-            if (req.destroyed)
+            if (reqFromDownstreamClient.destroyed)
                 break;
             targetRegistry = registry;
             const search = fullUrl.search || '';
             targetUrl = `${registry.normalizedRegistryUrl}${path}${search}`;
             const okResponseOrNull = await fetchFromRegistry(registry, targetUrl, limiter);
             if (okResponseOrNull) {
-                successfulResponse = okResponseOrNull;
+                successfulResponseFromUpstream = okResponseOrNull;
                 break;
             }
         }
         // 统一回写响应
-        if (successfulResponse) {
-            await writeSuccessfulResponse(targetRegistry, targetUrl, res, successfulResponse, req, proxyInfo, proxyPort, registryInfos);
+        if (successfulResponseFromUpstream) {
+            await writeResponseToDownstreamClient(targetRegistry, targetUrl, resToDownstreamClient, successfulResponseFromUpstream, reqFromDownstreamClient, proxyInfo, proxyPort, registryInfos);
         }
         else {
-            res.writeHead(404).end('All upstream registries failed');
+            resToDownstreamClient.writeHead(404).end('All upstream registries failed');
         }
     };
     let server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.jimuwd.xian.registry-proxy",
-  "version": "1.0.60",
+  "version": "1.0.63",
   "description": "A lightweight npm registry proxy with fallback support",
   "type": "module",
   "main": "dist/index.js",