@wener/utils 1.1.15 → 1.1.17

package/src/servers/createFetchWithProxy.ts

@@ -1,12 +1,3 @@
-import { FetchLike } from '../fetch';
-import { createFetchWithProxyByNodeFetch } from '../server';
 import { createFetchWithProxyByUndici } from './createFetchWithProxyByUndici';
 
-export function createFetchWithProxy({ proxy, fetch }: { proxy?: string; fetch?: FetchLike }): FetchLike {
-  if (!proxy) {
-    return fetch || globalThis.fetch;
-  }
-  return parseInt(process.versions.node) >= 18
-    ? createFetchWithProxyByUndici({ proxy, fetch })
-    : createFetchWithProxyByNodeFetch({ proxy, fetch });
-}
+export const createFetchWithProxy = createFetchWithProxyByUndici;

package/src/servers/createFetchWithProxyByUndici.ts

@@ -1,12 +1,14 @@
-import { MaybePromise } from 'rollup';
+import { MaybePromise } from '../asyncs/MaybePromise';
 import { FetchLike } from '../fetch';
 
 export function createFetchWithProxyByUndici({
   proxy,
+  token: _token,
   fetch,
   undici,
 }: {
   proxy?: string;
+  token?: string;
   fetch?: FetchLike;
   undici?: MaybePromise<{ fetch: any; ProxyAgent: any }>;
 } = {}): FetchLike {
@@ -14,21 +16,47 @@ export function createFetchWithProxyByUndici({
     return fetch || globalThis.fetch;
   }
   let agent: any;
+  // https://github.com/nodejs/undici/blob/main/docs/best-practices/proxy.md
   return async (...args) => {
-    const init: RequestInit & { duplex?: string; dispatcher?: any } = (args[1] ||= {});
-    if (init.body instanceof ReadableStream) {
-      // https://github.com/nodejs/node/issues/46221
-      init.duplex ||= 'half';
+    const init = (args[1] ||= {}) as RequestInit & {
+      duplex?: string;
+      dispatcher?: any;
+    };
+    {
+      const body = init.body;
+      if (typeof body === 'object' && body && (body instanceof ReadableStream || Symbol.asyncIterator in body)) {
+        // request.duplex must be set if request.body is ReadableStream or Async Iterables
+        init.duplex ||= 'half';
+      }
     }
     if (!agent) {
+      let uri = proxy;
+      let token = _token;
+      {
+        let u: URL | undefined;
+        try {
+          u = new URL(proxy);
+        } catch (e) {}
+        if (!token && u && (u.username || u.password)) {
+          token = `Basic ${btoa(`${u.username || ''}:${u.password}`)}`;
+          u.username = '';
+          u.password = '';
+          uri = u.toString();
+        }
+      }
       // if in next use 'next/dist/compiled/undici'
       undici ||= import('undici');
       const mod = await undici;
-      const ProxyAgent = mod.ProxyAgent;
-      fetch ||= mod.fetch;
-      agent = new ProxyAgent(proxy);
+      const ProxyAgent = mod.ProxyAgent as new (_: any) => any;
+      fetch ||= mod.fetch as FetchLike;
+      // https://github.com/nodejs/undici/blob/main/docs/api/ProxyAgent.md
+      agent = new ProxyAgent({
+        uri,
+        token,
+      });
       // https://github.com/nodejs/node/issues/43187#issuecomment-1134634174
       // (global as any)[Symbol.for('undici.globalDispatcher.1')] = agent;
+      // fixme should unwrap error https://github.com/nodejs/undici/issues/1248
     }
     init.dispatcher = agent;
     return await fetch!(...args);

package/src/servers/createFetchWithRetry.ts

@@ -0,0 +1,95 @@
+import { FetchLike } from '../fetch';
+import { getGlobalThis } from '../isomorphics/getGlobalThis';
+
+type RequestDelayFunction = (attempt: number, error: Error | null, response: Response | null) => number;
+type RequestRetryOnFunction = (
+  attempt: number,
+  error: Error | null,
+  response: Response | null,
+) => boolean | Promise<boolean>;
+
+export interface FetchWithRetryOptions {
+  fetch?: FetchLike;
+  retries?: number;
+  retryDelay?: number | RequestDelayFunction;
+  retryOn?: number[] | RequestRetryOnFunction;
+}
+
+export function createFetchWithRetry({
+  fetch = getGlobalThis().fetch,
+  retries = 3,
+  retryDelay = 1000,
+  retryOn = [],
+}: FetchWithRetryOptions = {}): FetchLike {
+  // https://github.com/jonbern/fetch-retry/blob/master/index.js
+
+  return function fetchRetry(input: string | Request, init?: RequestInit) {
+    return new Promise(function (resolve, reject) {
+      var wrappedFetch = function (attempt: number) {
+        // As of node 18, this is no longer needed since node comes with native support for fetch:
+        /* istanbul ignore next */
+        var _input = typeof Request !== 'undefined' && input instanceof Request ? input.clone() : input;
+        fetch(_input, init)
+          .then(function (response) {
+            if (Array.isArray(retryOn) && retryOn.indexOf(response.status) === -1) {
+              resolve(response);
+            } else if (typeof retryOn === 'function') {
+              try {
+                return Promise.resolve(retryOn(attempt, null, response))
+                  .then(function (retryOnResponse) {
+                    if (retryOnResponse) {
+                      retry(attempt, null, response);
+                    } else {
+                      resolve(response);
+                    }
+                  })
+                  .catch(reject);
+              } catch (error) {
+                reject(error);
+              }
+            } else {
+              if (attempt < retries) {
+                retry(attempt, null, response);
+              } else {
+                resolve(response);
+              }
+            }
+            return;
+          })
+          .catch(function (error) {
+            if (typeof retryOn === 'function') {
+              try {
+                // eslint-disable-next-line no-undef
+                Promise.resolve(retryOn(attempt, error, null))
+                  .then(function (retryOnResponse) {
+                    if (retryOnResponse) {
+                      retry(attempt, error, null);
+                    } else {
+                      reject(error);
+                    }
+                  })
+                  .catch(function (error) {
+                    reject(error);
+                  });
+              } catch (error) {
+                reject(error);
+              }
+            } else if (attempt < retries) {
+              retry(attempt, error, null);
+            } else {
+              reject(error);
+            }
+          });
+      };
+
+      function retry(attempt: number, error: any, response: Response | null) {
+        let delay = typeof retryDelay === 'function' ? retryDelay(attempt, error, response) : retryDelay;
+        setTimeout(function () {
+          wrappedFetch(++attempt);
+        }, delay);
+      }
+
+      wrappedFetch(0);
+    });
+  };
+}

package/src/servers/md5.ts

@@ -0,0 +1,5 @@
+import { createHash } from 'node:crypto';
+
+export function md5(input: Buffer | string) {
+  return createHash('md5').update(input).digest('hex') as string;
+}

package/lib/servers/createFetchWithProxyByNodeFetch.js

@@ -1,38 +0,0 @@
-import { getGlobalThis } from '../isomorphics/getGlobalThis.js';
-
-function createFetchWithProxyByNodeFetch({
-  proxy,
-  fetch
-} = {}) {
-  const globalThis = getGlobalThis();
-  if (!proxy) {
-    return fetch || globalThis.fetch;
-  }
-  let agent;
-  const Request = globalThis.Request;
-  let NodeRequest;
-  let NodeFetch;
-  return async (url, init) => {
-    if (!agent) {
-      const { default: createHttpsProxyAgent } = await import('https-proxy-agent');
-      agent = createHttpsProxyAgent(proxy);
-    }
-    if (!NodeRequest) {
-      ({ Request: NodeRequest, default: NodeFetch } = await import('node-fetch'));
-    }
-    fetch || (fetch = NodeFetch);
-    if (url instanceof Request) {
-      return fetch(new Request(url, { agent }));
-    }
-    if (url instanceof NodeRequest) {
-      return fetch(new NodeRequest(url, { agent }));
-    }
-    return fetch(url, {
-      ...init,
-      agent
-    });
-  };
-}
-
-export { createFetchWithProxyByNodeFetch };
-//# sourceMappingURL=createFetchWithProxyByNodeFetch.js.map

package/lib/servers/createFetchWithProxyByNodeFetch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"createFetchWithProxyByNodeFetch.js","sources":["../../src/servers/createFetchWithProxyByNodeFetch.ts"],"sourcesContent":["import { type FetchLike } from '../fetch';\nimport { getGlobalThis } from '../isomorphics/getGlobalThis';\n\nexport function createFetchWithProxyByNodeFetch({\n  proxy,\n  fetch,\n}: { proxy?: string; fetch?: FetchLike } = {}): FetchLike {\n  const globalThis = getGlobalThis();\n  if (!proxy) {\n    return fetch || globalThis.fetch;\n  }\n\n  let agent: any;\n  const Request = globalThis.Request;\n  let NodeRequest: any;\n  let NodeFetch: any;\n  return async (url, init?: RequestInit) => {\n    if (!agent) {\n      const { default: createHttpsProxyAgent } = await import('https-proxy-agent');\n      agent = (createHttpsProxyAgent as any)(proxy);\n    }\n\n    // node-fetch 才可以，node v18 fetch 不支持\n    if (!NodeRequest) {\n      ({ Request: NodeRequest, default: NodeFetch } = await import('node-fetch'));\n    }\n\n    fetch ||= NodeFetch;\n\n    if (url instanceof Request) {\n      return (fetch as any)(new Request(url, { agent } as any));\n    }\n    if ((url as any) instanceof NodeRequest) {\n      return (fetch as any)(new NodeRequest(url, { agent } as any));\n    }\n    return (fetch as any)(url, {\n      ...init,\n      agent,\n    } as any);\n  };\n}\n"],"names":[],"mappings":";;AAGO,SAAS,+BAAgC,CAAA;AAAA,EAC9C,KAAA;AAAA,EACA,KAAA;AACF,CAAA,GAA2C,EAAe,EAAA;AACxD,EAAA,MAAM,aAAa,aAAc,EAAA,CAAA;AACjC,EAAA,IAAI,CAAC,KAAO,EAAA;AACV,IAAA,OAAO,SAAS,UAAW,CAAA,KAAA,CAAA;AAAA,GAC7B;AAEA,EAAI,IAAA,KAAA,CAAA;AACJ,EAAA,MAAM,UAAU,UAAW,CAAA,OAAA,CAAA;AAC3B,EAAI,IAAA,WAAA,CAAA;AACJ,EAAI,IAAA,SAAA,CAAA;AACJ,EAAO,OAAA,OAAO,KAAK,IAAuB,KAAA;AACxC,IAAA,IAAI,CAAC,KAAO,EAAA;AACV,MAAA,MAAM,EAAE,OAAS,EAAA,qBAAA,EAA0B,GAAA,MAAM,OAAO,mBAAmB,CAAA,CAAA;AAC3E,MAAA,KAAA,GAAS,sBAA8B,KAAK,CAAA,CAAA;AAAA,KAC9C;AAGA,IAAA,IAAI,CAAC,WAAa,EAAA;AAChB,MAAC,CAAA,EAAE,SAAS,WAAa,EAAA,OAAA,EAAS,WAAc,GAAA,MAAM,OAAO,YAAY,CAAA,EAAA;AAAA,KAC3E;AAEA,IAAU,KAAA,KAAA,KAAA,GAAA,SAAA,CAAA,CAAA;AAEV,IAAA,IAAI,eAAe,OAAS,EAAA;AAC1B,MAAA,OAAQ,MAAc,IAAI,OAAA,CAAQ,KAAK,EAAE,KAAA,EAAc,CAAC,CAAA,CAAA;AAAA,KAC1D;AACA,IAAA,IAAK,eAAuB,WAAa,EAAA;AACvC,MAAA,OAAQ,MAAc,IAAI,WAAA,CAAY,KAAK,EAAE,KAAA,EAAc,CAAC,CAAA,CAAA;AAAA,KAC9D;AACA,IAAA,OAAQ,MAAc,GAAK,EAAA;AAAA,MACzB,GAAG,IAAA;AAAA,MACH,KAAA;AAAA,KACM,CAAA,CAAA;AAAA,GACV,CAAA;AACF;;;;"}