Update proxy.js

src/core/proxy.js

@@ -1,16 +1,15 @@
 const got = require("got");
 const CookieHandler = require("../lib/cookies");
-const {setHeaders, setAgent} = require("../lib/options");
+const { setHeaders, setAgent } = require("../lib/options");
 const type = require("../util/types");
 
 // Responsible for applying proxy
 const requestHandler = async (request, proxy, overrides = {}) => {
-    // Reject non http(s) URI schemes
     if (!request.url().startsWith("http") && !request.url().startsWith("https")) {
-        request.continue(); return;
+        request.continue();
+        return;
     }
     const cookieHandler = new CookieHandler(request);
-    // Request options for GOT accounting for overrides
     const options = {
         cookieJar: await cookieHandler.getCookies(),
         method: overrides.method || request.method(),
@@ -21,12 +20,10 @@ const requestHandler = async (request, proxy, overrides = {}) => {
         maxRedirects: 15,
         throwHttpErrors: false,
         ignoreInvalidCookies: true,
-        followRedirect: false
+        followRedirect: false,
     };
     try {
         const response = await got(overrides.url || request.url(), options);
-        // Set cookies manually because "set-cookie" doesn't set all cookies (?)
-        // Perhaps related to https://github.com/puppeteer/puppeteer/issues/5364
         const setCookieHeader = response.headers["set-cookie"];
         if (setCookieHeader) {
             await cookieHandler.setCookies(setCookieHeader);
@@ -35,7 +32,7 @@ const requestHandler = async (request, proxy, overrides = {}) => {
         await request.respond({
             status: response.statusCode,
             headers: response.headers,
-            body: response.body
+            body: response.body,
         });
     } catch (error) {
         await request.abort();
@@ -44,52 +41,55 @@ const requestHandler = async (request, proxy, overrides = {}) => {
 
 // For reassigning proxy of page
 const removeRequestListener = (page, listenerName) => {
-    const eventName = "request";
-    const listeners = page.eventsMap.get(eventName);
-    if (listeners) {
-        const i = listeners.findIndex((listener) => {
-            return listener.name === listenerName
-        });
-        listeners.splice(i, 1);
-        if (!listeners.length) {
-            page.eventsMap.delete(eventName);
-        }
-    }
+    page.removeListener("request", page[listenerName]);
 };
 
+// Define listeners directly on the page object
 const useProxyPer = {
-    // Call this if request object passed
     HTTPRequest: async (request, data) => {
         let proxy, overrides;
-        // Separate proxy and overrides
         if (type(data) === "object") {
             if (Object.keys(data).length !== 0) {
                 proxy = data.proxy;
                 delete data.proxy;
                 overrides = data;
             }
-        } else {proxy = data}
-        // Skip request if proxy omitted
-        if (proxy) {await requestHandler(request, proxy, overrides)}
-        else {request.continue(overrides)}
+        } else {
+            proxy = data;
+        }
+        if (proxy) {
+            await requestHandler(request, proxy, overrides);
+        } else {
+            request.continue(overrides);
+        }
     },
 
-    // Call this if page object passed
-    CDPPage: async (page, proxy) => {
+    CdpPage: async (page, proxy) => {
         await page.setRequestInterception(true);
         const listener = "$ppp_requestListener";
         removeRequestListener(page, listener);
-        const f = {[listener]: async (request) => {
+        page[listener] = async request => {
             await requestHandler(request, proxy);
-        }};
-        if (proxy) {page.on("request", f[listener])}
-        else {await page.setRequestInterception(false)}
-    }
-}
+        };
+        if (proxy) {
+            page.on("request", page[listener]);
+        } else {
+            await page.setRequestInterception(false);
+        }
+    },
+};
 
 // Main function
 const useProxy = async (target, data) => {
-    useProxyPer[target.constructor.name](target, data);
+    try {
+        const targetType = target.constructor.name;
+        if (!useProxyPer[targetType]) {
+            throw new TypeError(`No proxy handler found for target type: ${targetType}`);
+        }
+        await useProxyPer[targetType](target, data);
+    } catch (error) {
+        console.error("Unhandled Rejection at:", error);
+    }
 };
 
-module.exports = useProxy;
+module.exports = useProxy;