@module-federation/retry-plugin 0.0.0-chore-bump-node-22-20260710161714

package/dist/index.d.ts

@@ -0,0 +1,113 @@
+import { ModuleFederationRuntimePlugin } from "@module-federation/runtime";
+
+//#region src/types.d.ts
+type CommonRetryOptions = {
+  /**
+   * retry request options
+   */
+  fetchOptions?: RequestInit;
+  /**
+   * retry times
+   */
+  retryTimes?: number;
+  /**
+   * retry success times
+   */
+  successTimes?: number;
+  /**
+   * retry delay in milliseconds, or a function that returns delay per attempt.
+   * When a function, `attempt` is 1-indexed (the nth retry, not the initial call).
+   */
+  retryDelay?: number | ((attempt: number) => number);
+  /**
+   * 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;
+};
+type FetchRetryOptions = {
+  url?: string;
+  fetchOptions?: RequestInit;
+} & CommonRetryOptions;
+type ScriptRetryOptions = {
+  retryOptions: CommonRetryOptions;
+  retryFn: (...args: any[]) => Promise<any> | (() => Promise<any>);
+  beforeExecuteRetry?: (...args: any[]) => void;
+};
+//#endregion
+//#region src/utils.d.ts
+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;
+//#endregion
+//#region src/index.d.ts
+declare const RetryPlugin: (params?: CommonRetryOptions) => ModuleFederationRuntimePlugin;
+//#endregion
+export { type CommonRetryOptions, type FetchRetryOptions, RetryPlugin, type ScriptRetryOptions, appendRetryCountQuery, combineUrlDomainWithPathQuery, getRetryUrl, rewriteWithNextDomain };

package/dist/index.js

@@ -0,0 +1,312 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _module_federation_sdk = require("@module-federation/sdk");
+
+//#region src/constant.ts
+const defaultRetries = 3;
+const defaultRetryDelay = 1e3;
+const PLUGIN_IDENTIFIER = "[ Module Federation RetryPlugin ]";
+const ERROR_ABANDONED = "The request failed and has now been abandoned";
+const RUNTIME_008 = "RUNTIME-008";
+
+//#endregion
+//#region src/logger.ts
+const logger = (0, _module_federation_sdk.createLogger)(PLUGIN_IDENTIFIER);
+
+//#endregion
+//#region 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--) if (`${normalized[i].hostname}${normalized[i].port ? `:${normalized[i].port}` : ""}` === currentHost) {
+			idx = i;
+			break;
+		}
+		const total = normalized.length;
+		for (let step = 1; step <= total; step++) {
+			const candidate = normalized[((idx >= 0 ? idx : -1) + step) % total];
+			if (`${candidate.hostname}${candidate.port ? `:${candidate.port}` : ""}` !== 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;
+	}
+}
+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;
+	}
+}
+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;
+}
+/**
+* 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
+*/
+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;
+	}
+}
+
+//#endregion
+//#region src/fetch-retry.ts
+function autoParseResponse(url, response) {
+	try {
+		const parsed = new URL(url);
+		if (parsed.pathname.endsWith(".js") || parsed.pathname.endsWith(".cjs") || parsed.pathname.endsWith(".mjs")) return response.text();
+		return response.json();
+	} catch (error) {
+		return response.json();
+	}
+}
+async function fetchRetry(params, lastRequestUrl, originalTotal) {
+	const { url, fetchOptions = {}, retryTimes = defaultRetries, retryDelay = defaultRetryDelay, domains, 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 {
+		if (!isFirstAttempt) {
+			const attemptIndex = total - retryTimes;
+			const delay = typeof retryDelay === "function" ? retryDelay(attemptIndex) : retryDelay;
+			if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+		const response = await fetch(requestUrl, fetchOptions);
+		const responseClone = response.clone();
+		if (!response.ok) throw new Error(`${PLUGIN_IDENTIFIER}: Request failed: ${response.status} ${response.statusText || ""} | url: ${requestUrl}`);
+		await autoParseResponse(requestUrl, responseClone).catch((error) => {
+			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) {
+			const attemptedRetries = total - retryTimes;
+			if (!isFirstAttempt && attemptedRetries > 0) {
+				onError && onError({
+					domains,
+					url: requestUrl,
+					tagName: "fetch"
+				});
+				logger.log(`${PLUGIN_IDENTIFIER}: retry failed, no retries left for url: ${requestUrl}`);
+			}
+			throw new Error(`${RUNTIME_008}: ${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${requestUrl}`);
+		} else {
+			const nextIndex = total - retryTimes + 1;
+			const predictedNextUrl = getRetryUrl(combineUrlDomainWithPathQuery(requestUrl, url), {
+				domains,
+				addQuery,
+				retryIndex: nextIndex,
+				queryKey: "retryCount"
+			});
+			onRetry && onRetry({
+				times: nextIndex,
+				domains,
+				url: predictedNextUrl,
+				tagName: "fetch"
+			});
+			logger.log(`${PLUGIN_IDENTIFIER}: Trying again. Number of retries left: ${retryTimes - 1}`);
+			return await fetchRetry({
+				...params,
+				retryTimes: retryTimes - 1
+			}, requestUrl, total);
+		}
+	}
+}
+
+//#endregion
+//#region src/script-retry.ts
+function scriptRetry({ retryOptions, retryFn, beforeExecuteRetry = () => {} }) {
+	return async function(params) {
+		let retryWrapper;
+		let lastRequestUrl;
+		let originalUrl;
+		const { retryTimes = defaultRetries, retryDelay = defaultRetryDelay, domains, addQuery, onRetry, onSuccess, onError } = retryOptions || {};
+		let attempts = 0;
+		const maxAttempts = retryTimes;
+		while (attempts < maxAttempts) try {
+			beforeExecuteRetry();
+			const delay = typeof retryDelay === "function" ? retryDelay(attempts + 1) : retryDelay;
+			if (delay > 0) await new Promise((resolve) => setTimeout(resolve, delay));
+			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) {
+			attempts++;
+			if (attempts >= maxAttempts) {
+				onError && lastRequestUrl && onError({
+					domains,
+					url: lastRequestUrl,
+					tagName: "script"
+				});
+				throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${lastRequestUrl || "unknown"}`);
+			}
+		}
+		return retryWrapper;
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const RetryPlugin = (params) => {
+	if (params?.fetch || params?.script) logger.warn(`${PLUGIN_IDENTIFIER}: params is ${params}, fetch or script config is deprecated, please use the new config style. See docs: https://module-federation.io/plugin/plugins/retry-plugin.html`);
+	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 = () => {
+				delete globalLoading[uniqueKey];
+			};
+			return await scriptRetry({
+				retryOptions: {
+					retryTimes,
+					retryDelay,
+					domains,
+					addQuery,
+					onRetry,
+					onSuccess,
+					onError
+				},
+				retryFn: getRemoteEntry,
+				beforeExecuteRetry
+			})({
+				origin,
+				remoteInfo,
+				remoteEntryExports
+			});
+		}
+	};
+};
+
+//#endregion
+exports.RetryPlugin = RetryPlugin;
+exports.appendRetryCountQuery = appendRetryCountQuery;
+exports.combineUrlDomainWithPathQuery = combineUrlDomainWithPathQuery;
+exports.getRetryUrl = getRetryUrl;
+exports.rewriteWithNextDomain = rewriteWithNextDomain;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@module-federation/retry-plugin",
+  "version": "0.0.0-chore-bump-node-22-20260710161714",
+  "author": "danpeen <dapeen.feng@gmail.com>",
+  "main": "./dist/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/module-federation/core.git",
+    "directory": "packages/retry-plugin"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist/",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/index.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ]
+    }
+  },
+  "peerDependencies": {
+    "@module-federation/runtime": "0.0.0-chore-bump-node-22-20260710161714"
+  },
+  "devDependencies": {
+    "@module-federation/runtime": "0.0.0-chore-bump-node-22-20260710161714"
+  },
+  "dependencies": {
+    "@module-federation/sdk": "0.0.0-chore-bump-node-22-20260710161714"
+  },
+  "scripts": {
+    "build": "tsdown --config tsdown.config.ts && cp *.md dist",
+    "test": "rstest -u",
+    "lint": "ESLINT_USE_FLAT_CONFIG=false pnpm exec eslint --ignore-pattern node_modules \"**/*.ts\" \"package.json\"",
+    "build-debug": "FEDERATION_DEBUG=true pnpm run build",
+    "pre-release": "pnpm run test && pnpm run build"
+  }
+}