@module-federation/retry-plugin 0.18.3 → 0.19.0

package/dist/esm/index.js

@@ -5,141 +5,343 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 var defaultRetries = 3;
 var defaultRetryDelay = 1e3;
 var PLUGIN_IDENTIFIER = "[ Module Federation RetryPlugin ]";
+var ERROR_ABANDONED = "The request failed and has now been abandoned";
 
 // packages/retry-plugin/src/logger.ts
 import { createLogger } from "@module-federation/sdk";
 var logger = createLogger(PLUGIN_IDENTIFIER);
 var logger_default = logger;
 
+// packages/retry-plugin/src/utils.ts
+function rewriteWithNextDomain(currentUrl, domains) {
+  if (!domains || domains.length === 0)
+    return null;
+  try {
+    const u = new URL(currentUrl);
+    const currentHostname = u.hostname;
+    const currentPort = u.port;
+    const currentHost = `${currentHostname}${currentPort ? `:${currentPort}` : ""}`;
+    const normalized = domains.map((d) => {
+      try {
+        const du = new URL(d.startsWith("http") ? d : `https://${d}`);
+        return {
+          hostname: du.hostname,
+          port: du.port,
+          protocol: du.protocol
+        };
+      } catch {
+        return {
+          hostname: d,
+          port: "",
+          protocol: u.protocol
+        };
+      }
+    }).filter((d) => !!d.hostname);
+    if (normalized.length === 0)
+      return null;
+    let idx = -1;
+    for (let i = normalized.length - 1; i >= 0; i--) {
+      const candHost = `${normalized[i].hostname}${normalized[i].port ? `:${normalized[i].port}` : ""}`;
+      if (candHost === currentHost) {
+        idx = i;
+        break;
+      }
+    }
+    const total = normalized.length;
+    for (let step = 1; step <= total; step++) {
+      const nextIdx = ((idx >= 0 ? idx : -1) + step) % total;
+      const candidate = normalized[nextIdx];
+      const candidateHost = `${candidate.hostname}${candidate.port ? `:${candidate.port}` : ""}`;
+      if (candidateHost !== currentHost) {
+        u.hostname = candidate.hostname;
+        if (candidate.port !== void 0 && candidate.port !== null && candidate.port !== "") {
+          u.port = candidate.port;
+        } else {
+          u.port = "";
+        }
+        u.protocol = candidate.protocol || u.protocol;
+        return u.toString();
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+__name(rewriteWithNextDomain, "rewriteWithNextDomain");
+function appendRetryCountQuery(url, retryIndex, key = "retryCount") {
+  try {
+    const u = new URL(url);
+    u.searchParams.delete(key);
+    u.searchParams.set(key, String(retryIndex));
+    return u.toString();
+  } catch {
+    return url;
+  }
+}
+__name(appendRetryCountQuery, "appendRetryCountQuery");
+function getRetryUrl(baseUrl, opts = {}) {
+  const { domains, addQuery, retryIndex = 0, queryKey = "retryCount" } = opts;
+  let cleanBaseUrl = baseUrl;
+  try {
+    const urlObj = new URL(baseUrl);
+    urlObj.searchParams.delete(queryKey);
+    cleanBaseUrl = urlObj.toString();
+  } catch {
+  }
+  let nextUrl = rewriteWithNextDomain(cleanBaseUrl, domains) ?? cleanBaseUrl;
+  if (retryIndex > 0 && addQuery) {
+    try {
+      const u = new URL(nextUrl);
+      const originalUrl = new URL(baseUrl);
+      originalUrl.searchParams.delete(queryKey);
+      const originalQuery = originalUrl.search.startsWith("?") ? originalUrl.search.slice(1) : originalUrl.search;
+      if (typeof addQuery === "function") {
+        const newQuery = addQuery({
+          times: retryIndex,
+          originalQuery
+        });
+        u.search = newQuery ? `?${newQuery.replace(/^\?/, "")}` : "";
+        nextUrl = u.toString();
+      } else if (addQuery === true) {
+        u.searchParams.delete(queryKey);
+        u.searchParams.set(queryKey, String(retryIndex));
+        nextUrl = u.toString();
+      }
+    } catch {
+      if (addQuery === true) {
+        nextUrl = appendRetryCountQuery(nextUrl, retryIndex, queryKey);
+      }
+    }
+  }
+  return nextUrl;
+}
+__name(getRetryUrl, "getRetryUrl");
+function combineUrlDomainWithPathQuery(domainUrl, pathQueryUrl) {
+  try {
+    const domainUrlObj = new URL(domainUrl);
+    const pathQueryUrlObj = new URL(pathQueryUrl);
+    domainUrlObj.pathname = pathQueryUrlObj.pathname;
+    domainUrlObj.search = pathQueryUrlObj.search;
+    return domainUrlObj.toString();
+  } catch {
+    return pathQueryUrl;
+  }
+}
+__name(combineUrlDomainWithPathQuery, "combineUrlDomainWithPathQuery");
+
 // packages/retry-plugin/src/fetch-retry.ts
-async function fetchWithRetry({ url, options = {}, retryTimes = defaultRetries, retryDelay = defaultRetryDelay, fallback }) {
+async function fetchRetry(params, lastRequestUrl, originalTotal) {
+  const {
+    url,
+    fetchOptions = {},
+    retryTimes = defaultRetries,
+    retryDelay = defaultRetryDelay,
+    // List of retry domains when resource loading fails. In the domains array, the first item is the default domain for static resources, and the subsequent items are backup domains. When a request to a domain fails, the system will find that domain in the array and replace it with the next domain in the array.
+    domains,
+    // Whether to add query parameters during resource retry to avoid being affected by browser and CDN cache. When set to true, retry=${times} will be added to the query, requesting in the order of retry=1, retry=2, retry=3.
+    addQuery,
+    onRetry,
+    onSuccess,
+    onError
+  } = params;
+  if (!url) {
+    throw new Error(`${PLUGIN_IDENTIFIER}: url is required in fetchWithRetry`);
+  }
+  const total = originalTotal ?? params.retryTimes ?? defaultRetries;
+  const isFirstAttempt = !lastRequestUrl;
+  let baseUrl = url;
+  if (!isFirstAttempt && lastRequestUrl) {
+    baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, url);
+  }
+  let requestUrl = baseUrl;
+  if (!isFirstAttempt) {
+    requestUrl = getRetryUrl(baseUrl, {
+      domains,
+      addQuery,
+      retryIndex: total - retryTimes,
+      queryKey: "retryCount"
+    });
+  }
   try {
-    const response = await fetch(url, options);
+    if (!isFirstAttempt && retryDelay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, retryDelay));
+    }
+    const response = await fetch(requestUrl, fetchOptions);
     const responseClone = response.clone();
     if (!response.ok) {
-      throw new Error(`Server error\uFF1A${response.status}`);
+      throw new Error(`${PLUGIN_IDENTIFIER}: Request failed: ${response.status} ${response.statusText || ""} | url: ${requestUrl}`);
     }
     await responseClone.json().catch((error) => {
-      throw new Error(`Json parse error: ${error}, url is: ${url}`);
+      throw new Error(`${PLUGIN_IDENTIFIER}: JSON parse failed: ${error?.message || String(error)} | url: ${requestUrl}`);
     });
+    if (!isFirstAttempt) {
+      onSuccess && requestUrl && onSuccess({
+        domains,
+        url: requestUrl,
+        tagName: "fetch"
+      });
+    }
     return response;
   } catch (error) {
     if (retryTimes <= 0) {
-      logger_default.log(`${PLUGIN_IDENTIFIER}: retry failed after ${retryTimes} times for url: ${url}, now will try fallbackUrl url`);
-      if (fallback && typeof fallback === "function") {
-        return fetchWithRetry({
-          url: fallback(url),
-          options,
-          retryTimes: 0,
-          retryDelay: 0
+      const attemptedRetries = total - retryTimes;
+      if (!isFirstAttempt && attemptedRetries > 0) {
+        onError && onError({
+          domains,
+          url: requestUrl,
+          tagName: "fetch"
         });
+        logger_default.log(`${PLUGIN_IDENTIFIER}: retry failed, no retries left for url: ${requestUrl}`);
       }
-      if (error instanceof Error && error.message.includes("Json parse error")) {
-        throw error;
-      }
-      throw new Error(`${PLUGIN_IDENTIFIER}: The request failed three times and has now been abandoned`);
+      throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED}`);
     } else {
-      retryDelay > 0 && await new Promise((resolve) => setTimeout(resolve, retryDelay));
-      logger_default.log(`Trying again. Number of retries available\uFF1A${retryTimes - 1}`);
-      return await fetchWithRetry({
-        url,
-        options,
-        retryTimes: retryTimes - 1,
-        retryDelay,
-        fallback
+      const nextIndex = total - retryTimes + 1;
+      const predictedBaseUrl = combineUrlDomainWithPathQuery(requestUrl, url);
+      const predictedNextUrl = getRetryUrl(predictedBaseUrl, {
+        domains,
+        addQuery,
+        retryIndex: nextIndex,
+        queryKey: "retryCount"
+      });
+      onRetry && onRetry({
+        times: nextIndex,
+        domains,
+        url: predictedNextUrl,
+        tagName: "fetch"
       });
+      logger_default.log(`${PLUGIN_IDENTIFIER}: Trying again. Number of retries left: ${retryTimes - 1}`);
+      return await fetchRetry({
+        ...params,
+        retryTimes: retryTimes - 1
+      }, requestUrl, total);
     }
   }
 }
-__name(fetchWithRetry, "fetchWithRetry");
+__name(fetchRetry, "fetchRetry");
 
-// packages/retry-plugin/src/util.ts
-function scriptCommonRetry({ scriptOption, moduleInfo, retryFn, beforeExecuteRetry = /* @__PURE__ */ __name(() => {
+// packages/retry-plugin/src/script-retry.ts
+function scriptRetry({ retryOptions, retryFn, beforeExecuteRetry = /* @__PURE__ */ __name(() => {
 }, "beforeExecuteRetry") }) {
-  return async function(...args) {
-    let retryResponse;
-    const { retryTimes = defaultRetries, retryDelay = defaultRetryDelay } = scriptOption || {};
-    if (scriptOption?.moduleName && scriptOption?.moduleName.some((m) => moduleInfo.name === m || moduleInfo?.alias === m) || scriptOption?.moduleName === void 0) {
-      let attempts = 0;
-      while (attempts - 1 < retryTimes) {
-        try {
-          beforeExecuteRetry();
-          retryResponse = await retryFn(...args);
-          break;
-        } catch (error) {
-          attempts++;
-          if (attempts - 1 >= retryTimes) {
-            scriptOption?.cb && await new Promise((resolve) => scriptOption?.cb && scriptOption?.cb(resolve, error));
-            throw error;
-          }
-          logger_default.log(`${PLUGIN_IDENTIFIER}: script resource retrying ${attempts} times`);
+  return async function(params) {
+    let retryWrapper;
+    let lastError;
+    let lastRequestUrl;
+    let originalUrl;
+    const { retryTimes = defaultRetries, retryDelay = defaultRetryDelay, domains, addQuery, onRetry, onSuccess, onError } = retryOptions || {};
+    let attempts = 0;
+    while (attempts < retryTimes) {
+      try {
+        beforeExecuteRetry();
+        if (retryDelay > 0) {
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }
+        const retryIndex = attempts + 1;
+        retryWrapper = await retryFn({
+          ...params,
+          getEntryUrl: (url) => {
+            if (!originalUrl) {
+              originalUrl = url;
+            }
+            let baseUrl = originalUrl;
+            if (lastRequestUrl) {
+              baseUrl = combineUrlDomainWithPathQuery(lastRequestUrl, originalUrl);
+            }
+            const next = getRetryUrl(baseUrl, {
+              domains,
+              addQuery,
+              retryIndex,
+              queryKey: "retryCount"
+            });
+            onRetry && onRetry({
+              times: retryIndex,
+              domains,
+              url: next,
+              tagName: "script"
+            });
+            lastRequestUrl = next;
+            return next;
+          }
+        });
+        onSuccess && lastRequestUrl && onSuccess({
+          domains,
+          url: lastRequestUrl,
+          tagName: "script"
+        });
+        break;
+      } catch (error) {
+        lastError = error;
+        attempts++;
+        if (attempts >= retryTimes) {
+          onError && lastRequestUrl && onError({
+            domains,
+            url: lastRequestUrl,
+            tagName: "script"
+          });
+          throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED}`);
+        }
       }
     }
-    return retryResponse;
+    return retryWrapper;
   };
 }
-__name(scriptCommonRetry, "scriptCommonRetry");
+__name(scriptRetry, "scriptRetry");
 
 // packages/retry-plugin/src/index.ts
-var RetryPlugin = /* @__PURE__ */ __name(({ fetch: fetchOption, script: scriptOption }) => ({
-  name: "retry-plugin",
-  async fetch(url, options) {
-    const _options = {
-      ...options,
-      ...fetchOption?.options
-    };
-    if (fetchOption) {
-      if (fetchOption.url) {
-        if (url === fetchOption?.url) {
-          return fetchWithRetry({
-            url: fetchOption.url,
-            options: _options,
-            retryTimes: fetchOption?.retryTimes,
-            fallback: fetchOption?.fallback
-          });
-        }
-      } else {
-        return fetchWithRetry({
-          url,
-          options: _options,
-          retryTimes: fetchOption?.retryTimes,
-          fallback: fetchOption?.fallback
-        });
-      }
-    }
-    return fetch(url, options);
-  },
-  async loadEntryError({ getRemoteEntry, origin, remoteInfo, remoteEntryExports, globalLoading, uniqueKey }) {
-    if (!scriptOption)
-      return;
-    const retryFn = getRemoteEntry;
-    const beforeExecuteRetry = /* @__PURE__ */ __name(() => delete globalLoading[uniqueKey], "beforeExecuteRetry");
-    const getRemoteEntryRetry = scriptCommonRetry({
-      scriptOption,
-      moduleInfo: remoteInfo,
-      retryFn,
-      beforeExecuteRetry
-    });
-    return getRemoteEntryRetry({
-      origin,
-      remoteInfo,
-      remoteEntryExports
-    });
-  },
-  async getModuleFactory({ remoteEntryExports, expose, moduleInfo }) {
-    if (!scriptOption)
-      return;
-    const retryFn = remoteEntryExports.get;
-    const getRemoteEntryRetry = scriptCommonRetry({
-      scriptOption,
-      moduleInfo,
-      retryFn
-    });
-    return getRemoteEntryRetry(expose);
+var RetryPlugin = /* @__PURE__ */ __name((params) => {
+  if (params?.fetch || params?.script) {
+    logger_default.warn(`${PLUGIN_IDENTIFIER}: fetch or script config is deprecated, please use the new config style. See docs: https://module-federation.io/plugin/plugins/retry-plugin.html`);
   }
-}), "RetryPlugin");
+  const { fetchOptions = {}, retryTimes = defaultRetries, successTimes = 0, retryDelay = defaultRetryDelay, domains = [], manifestDomains = [], addQuery, onRetry, onSuccess, onError } = params || {};
+  return {
+    name: "retry-plugin",
+    async fetch(manifestUrl, options) {
+      return fetchRetry({
+        url: manifestUrl,
+        fetchOptions: {
+          ...options,
+          ...fetchOptions
+        },
+        domains: manifestDomains || domains,
+        addQuery,
+        onRetry,
+        onSuccess,
+        onError,
+        retryTimes,
+        successTimes,
+        retryDelay
+      });
+    },
+    async loadEntryError({ getRemoteEntry, origin, remoteInfo, remoteEntryExports, globalLoading, uniqueKey }) {
+      const beforeExecuteRetry = /* @__PURE__ */ __name(() => {
+        delete globalLoading[uniqueKey];
+      }, "beforeExecuteRetry");
+      const getRemoteEntryRetry = scriptRetry({
+        retryOptions: {
+          retryTimes,
+          retryDelay,
+          domains,
+          addQuery,
+          onRetry,
+          onSuccess,
+          onError
+        },
+        retryFn: getRemoteEntry,
+        beforeExecuteRetry
+      });
+      const result = await getRemoteEntryRetry({
+        origin,
+        remoteInfo,
+        remoteEntryExports
+      });
+      return result;
+    }
+  };
+}, "RetryPlugin");
 export {
-  RetryPlugin
+  RetryPlugin,
+  appendRetryCountQuery,
+  combineUrlDomainWithPathQuery,
+  getRetryUrl,
+  rewriteWithNextDomain
 };

package/dist/index.d.mts

@@ -1,27 +1,110 @@
 import { ModuleFederationRuntimePlugin } from '@module-federation/runtime/types';
 
-interface FetchWithRetryOptions {
-  url?: string;
-  options?: RequestInit;
+type CommonRetryOptions = {
+  /**
+   * retry request options
+   */
+  fetchOptions?: RequestInit;
+  /**
+   * retry times
+   */
   retryTimes?: number;
+  /**
+   * retry success times
+   */
+  successTimes?: number;
+  /**
+   * retry delay
+   */
   retryDelay?: number;
-  fallback?:
-    | (() => string)
-    | ((url: string | URL | globalThis.Request) => string);
-}
+  /**
+   * retry path
+   */
+  getRetryPath?: (url: string) => string;
+  /**
+   * add query parameter
+   */
+  addQuery?:
+    | boolean
+    | ((context: { times: number; originalQuery: string }) => string);
+  /**
+   * retry domains
+   */
+  domains?: string[];
+  /**
+   * retry manifest domains
+   */
+  manifestDomains?: string[];
+  /**
+   * retry callback
+   */
+  onRetry?: ({
+    times,
+    domains,
+    url,
+  }: {
+    times?: number;
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+  /**
+   * retry success callback
+   */
+  onSuccess?: ({
+    domains,
+    url,
+    tagName,
+  }: {
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+  /**
+   * retry failure callback
+   */
+  onError?: ({
+    domains,
+    url,
+    tagName,
+  }: {
+    domains?: string[];
+    url?: string;
+    tagName?: string;
+  }) => void;
+};
 
-interface ScriptWithRetryOptions {
-  retryTimes?: number;
-  retryDelay?: number;
-  moduleName?: Array<string>;
-  cb?: (resolve: (value: unknown) => void, error: any) => void;
-}
+type FetchRetryOptions = {
+  url?: string;
+  fetchOptions?: RequestInit;
+} & CommonRetryOptions;
 
-type RetryPluginParams = {
-  fetch?: FetchWithRetryOptions;
-  script?: ScriptWithRetryOptions;
+type ScriptRetryOptions = {
+  retryOptions: CommonRetryOptions;
+  retryFn: (...args: any[]) => Promise<any> | (() => Promise<any>);
+  beforeExecuteRetry?: (...args: any[]) => void;
 };
 
-declare const RetryPlugin: (params: RetryPluginParams) => ModuleFederationRuntimePlugin;
+declare function rewriteWithNextDomain(currentUrl: string, domains?: string[]): string | null;
+declare function appendRetryCountQuery(url: string, retryIndex: number, key?: string): string;
+declare function getRetryUrl(baseUrl: string, opts?: {
+    domains?: string[];
+    addQuery?: boolean | ((context: {
+        times: number;
+        originalQuery: string;
+    }) => string);
+    retryIndex?: number;
+    queryKey?: string;
+}): string;
+/**
+ * Extract domain/host info from a URL and combine it with path/query from another URL
+ * This is useful for domain rotation while preserving original path and query parameters
+ * @param domainUrl - URL containing the target domain/host
+ * @param pathQueryUrl - URL containing the target path and query parameters
+ * @returns Combined URL with domain from domainUrl and path/query from pathQueryUrl
+ */
+declare function combineUrlDomainWithPathQuery(domainUrl: string, pathQueryUrl: string): string;
+
+declare const RetryPlugin: (params?: CommonRetryOptions) => ModuleFederationRuntimePlugin;
 
-export { type FetchWithRetryOptions, RetryPlugin, type RetryPluginParams, type ScriptWithRetryOptions };
+export { type CommonRetryOptions, type FetchRetryOptions, RetryPlugin, type ScriptRetryOptions, appendRetryCountQuery, combineUrlDomainWithPathQuery, getRetryUrl, rewriteWithNextDomain };