com.jimuwd.xian.registry-proxy 1.0.61 → 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, resToDownstream, upstreamResponse, downstreamReq, 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 {
@@ -196,17 +195,17 @@ async function writeSuccessfulResponse(registryInfo, targetUrl, resToDownstream,
                     }
                 }
             }
-            resToDownstream.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}`);
-                resToDownstream.writeHead(502).end('Empty Upstream Response');
+                resToDownstreamClient.writeHead(502).end('Empty Upstream Response');
             }
             else {
                 // write back to client
-                resToDownstream.writeHead(upstreamResponse.status, safeHeaders);
+                resToDownstreamClient.writeHead(upstreamResponse.status, safeHeaders);
                 // stop transfer if client is closed accidentally.
                 const cleanup = () => {
                     downstreamReq.off('close', cleanup);
@@ -215,27 +214,30 @@ async function writeSuccessfulResponse(registryInfo, targetUrl, resToDownstream,
                 };
                 downstreamReq.on('close', cleanup);
                 // write back body data (chunked probably)
-                // pipe upstream body to client
-                upstreamResponse.body.pipe(resToDownstream, { end: true });
+                // pipe upstream body to downstream client and end when upstream ends.
+                upstreamResponse.body.pipe(resToDownstreamClient, { end: true });
                 upstreamResponse.body
-                    .on('data', (chunk) => logger.info(`chunk transferred size=${chunk.size}`))
+                    .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);
-                    resToDownstream.destroy(new Error(errMsg));
+                    // resToDownstreamClient.destroy(new Error(errMsg));
                 })
                     .on('error', (err) => {
                     const errMsg = `Stream error: ${err.message}`;
                     logger.error(errMsg);
-                    resToDownstream.destroy(new Error(errMsg, { cause: err, }));
+                    resToDownstreamClient.destroy(new Error(errMsg, { cause: err, }));
                 });
             }
         }
     }
     catch (err) {
         logger.error('Failed to write upstreamResponse:', err);
-        if (!resToDownstream.headersSent) {
-            resToDownstream.writeHead(502).end('Internal Server Error');
+        if (!resToDownstreamClient.headersSent) {
+            resToDownstreamClient.writeHead(502).end('Internal Server Error');
         }
     }
 }
@@ -247,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.61",
+  "version": "1.0.63",
   "description": "A lightweight npm registry proxy with fallback support",
   "type": "module",
   "main": "dist/index.js",