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

package/dist/README.md

@@ -0,0 +1,331 @@
+# @module-federation/retry-plugin
+
+> A robust retry plugin for Module Federation that provides automatic retry mechanisms for failed module requests with domain rotation, cache-busting, and comprehensive error handling.
+
+## Features
+
+- 🔄 **Automatic Retry**: Automatically retries failed fetch and script requests
+- 🌐 **Domain Rotation**: Rotate through multiple domains for better reliability
+- ⚡ **Cache Busting**: Add query parameters to bypass cache issues
+- 📊 **Lifecycle Callbacks**: Comprehensive callbacks for retry events
+- 🎯 **Flexible Configuration**: Highly configurable retry strategies
+- 🔧 **TypeScript Support**: Full TypeScript support with type definitions
+
+## Installation
+
+```bash
+npm install @module-federation/retry-plugin
+# or
+yarn add @module-federation/retry-plugin
+# or
+pnpm add @module-federation/retry-plugin
+```
+
+## Basic Usage
+
+### Runtime Plugin Registration
+
+```ts
+import { createInstance } from '@module-federation/enhanced/runtime';
+import { RetryPlugin } from '@module-federation/retry-plugin';
+
+const mf = createInstance({
+  name: 'host',
+  remotes: [
+    {
+      name: 'remote1',
+      entry: 'http://localhost:2001/mf-manifest.json',
+    },
+  ],
+  plugins: [
+    RetryPlugin({
+      retryTimes: 3,
+      retryDelay: 1000,
+      domains: ['https://cdn1.example.com', 'https://cdn2.example.com'],
+      manifestDomains: ['https://domain1.example.com', 'https://domain2.example.com'],
+      addQuery: ({ times, originalQuery }) => `${originalQuery}&retry=${times}`,
+      onRetry: ({ times, url }) => console.log('Retrying...', times, url),
+      onSuccess: ({ url }) => console.log('Success!', url),
+      onError: ({ url }) => console.log('Failed!', url),
+    }),
+  ],
+});
+```
+
+### Build Plugin Registration
+
+```ts
+// webpack.config.js
+import { ModuleFederationPlugin } from '@module-federation/webpack';
+import { RetryPlugin } from '@module-federation/retry-plugin';
+
+export default {
+  plugins: [
+    new ModuleFederationPlugin({
+      name: 'host',
+      remotes: {
+        remote1: 'remote1@http://localhost:2001/mf-manifest.json',
+      },
+      runtimePlugins: [path.join(__dirname, './src/runtime-plugin/retry.ts')],
+    }),
+  ],
+};
+```
+
+```ts
+// src/runtime-plugin/retry.ts
+import { RetryPlugin } from '@module-federation/retry-plugin';
+
+export default () =>
+  RetryPlugin({
+    retryTimes: 3,
+    retryDelay: 1000,
+    domains: ['https://cdn1.example.com', 'https://cdn2.example.com'],
+    manifestDomains: ['https://domain1.example.com', 'https://domain2.example.com'],
+    addQuery: ({ times, originalQuery }) => `${originalQuery}&retry=${times}`,
+    onRetry: ({ times, url }) => console.log('Retrying...', times, url),
+    onSuccess: ({ url }) => console.log('Success!', url),
+    onError: ({ url }) => console.log('Failed!', url),
+  });
+```
+
+## Configuration Options
+
+### CommonRetryOptions
+
+| Option            | Type                                    | Default     | Description                                                                                      |
+| ----------------- | --------------------------------------- | ----------- | ------------------------------------------------------------------------------------------------ |
+| `retryTimes`      | `number`                                | `3`         | Number of retry attempts                                                                         |
+| `retryDelay`      | `number \| (attempt: number) => number` | `1000`      | Delay between retries in milliseconds, or a function returning delay per 1-indexed retry attempt |
+| `successTimes`    | `number`                                | `0`         | Number of successful requests required                                                           |
+| `domains`         | `string[]`                              | `[]`        | Alternative domains for script resources                                                         |
+| `manifestDomains` | `string[]`                              | `[]`        | Alternative domains for manifest files                                                           |
+| `addQuery`        | `boolean \| function`                   | `false`     | Add query parameters for cache busting                                                           |
+| `fetchOptions`    | `RequestInit`                           | `{}`        | Additional fetch options                                                                         |
+| `onRetry`         | `function`                              | `undefined` | Callback when retry occurs                                                                       |
+| `onSuccess`       | `function`                              | `undefined` | Callback when request succeeds                                                                   |
+| `onError`         | `function`                              | `undefined` | Callback when all retries fail                                                                   |
+
+### addQuery Function
+
+```ts
+addQuery: ({ times, originalQuery }) => {
+  // Add retry count and timestamp for cache busting
+  const separator = originalQuery ? '&' : '?';
+  return `${originalQuery}${separator}retry=${times}&t=${Date.now()}`;
+};
+```
+
+### Callback Functions
+
+```ts
+onRetry: ({ times, domains, url, tagName }) => {
+  console.log(`Retry attempt ${times} for ${url}`);
+  console.log(`Available domains: ${domains?.join(', ')}`);
+},
+
+onSuccess: ({ domains, url, tagName }) => {
+  console.log(`Successfully loaded ${url}`);
+  console.log(`Used domain: ${domains?.[0]}`);
+},
+
+onError: ({ domains, url, tagName }) => {
+  console.error(`Failed to load ${url} after all retries`);
+  console.error(`Tried domains: ${domains?.join(', ')}`);
+}
+```
+
+## Advanced Examples
+
+### Custom Retry Strategy
+
+```ts
+RetryPlugin({
+  retryTimes: 5,
+  retryDelay: (attempt) => 1000 * 2 ** (attempt - 1), // Exponential backoff: 1s, 2s, 4s, ...
+  domains: ['https://cdn1.example.com', 'https://cdn2.example.com', 'https://cdn3.example.com'],
+  manifestDomains: ['https://api1.example.com', 'https://api2.example.com'],
+  addQuery: ({ times, originalQuery }) => {
+    const params = new URLSearchParams(originalQuery);
+    params.set('retry', times.toString());
+    params.set('cache_bust', Date.now().toString());
+    return params.toString();
+  },
+  onRetry: ({ times, url, domains }) => {
+    console.log(`Retry ${times}/5 for ${url}`);
+    console.log(`Trying domain: ${domains?.[times % domains.length]}`);
+  },
+  onSuccess: ({ url, domains }) => {
+    console.log(`✅ Successfully loaded ${url}`);
+    console.log(`✅ Used domain: ${domains?.[0]}`);
+  },
+  onError: ({ url, domains }) => {
+    console.error(`❌ Failed to load ${url} after all retries`);
+    console.error(`❌ Tried all domains: ${domains?.join(', ')}`);
+  },
+});
+```
+
+### Error Handling with Fallback
+
+```ts
+RetryPlugin({
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['https://cdn1.example.com', 'https://cdn2.example.com'],
+  onError: ({ url, domains }) => {
+    // Log error for monitoring
+    console.error('Module loading failed:', { url, domains });
+
+    // Send error to monitoring service
+    if (window.gtag) {
+      window.gtag('event', 'module_load_error', {
+        event_category: 'module_federation',
+        event_label: url,
+        value: domains?.length || 0,
+      });
+    }
+
+    // Show user-friendly error message
+    const errorElement = document.createElement('div');
+    errorElement.className = 'module-load-error';
+    errorElement.innerHTML = `
+      <div style="padding: 16px; border: 1px solid #ffa39e; border-radius: 4px; background: #fff1f0; color: #cf1322;">
+        <h4>Module Loading Failed</h4>
+        <p>Unable to load module: ${url}</p>
+        <p>Please refresh the page to try again.</p>
+      </div>
+    `;
+    document.body.appendChild(errorElement);
+  },
+});
+```
+
+### Production Configuration
+
+```ts
+RetryPlugin({
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['https://cdn1.prod.example.com', 'https://cdn2.prod.example.com', 'https://cdn3.prod.example.com'],
+  manifestDomains: ['https://api1.prod.example.com', 'https://api2.prod.example.com'],
+  addQuery: ({ times, originalQuery }) => {
+    const params = new URLSearchParams(originalQuery);
+    params.set('retry', times.toString());
+    params.set('v', process.env.BUILD_VERSION || '1.0.0');
+    return params.toString();
+  },
+  fetchOptions: {
+    cache: 'no-cache',
+    headers: {
+      'X-Requested-With': 'ModuleFederation',
+    },
+  },
+  onRetry: ({ times, url }) => {
+    // Only log in development
+    if (process.env.NODE_ENV === 'development') {
+      console.log(`Retry ${times} for ${url}`);
+    }
+  },
+  onSuccess: ({ url }) => {
+    // Track successful loads
+    if (window.analytics) {
+      window.analytics.track('module_loaded', { url });
+    }
+  },
+  onError: ({ url, domains }) => {
+    // Send error to monitoring service
+    if (window.errorReporting) {
+      window.errorReporting.captureException(new Error(`Module loading failed: ${url}`), { extra: { domains, url } });
+    }
+  },
+});
+```
+
+## How It Works
+
+1. **Fetch Retry**: Intercepts failed fetch requests for manifest files and retries with domain rotation
+2. **Script Retry**: Intercepts failed script loading and retries with alternative domains
+3. **Domain Rotation**: Cycles through provided domains to find working alternatives
+4. **Cache Busting**: Adds query parameters to prevent cache-related issues
+5. **Lifecycle Hooks**: Provides callbacks for monitoring and debugging
+
+## Error Scenarios Handled
+
+- Network timeouts and connection errors
+- DNS resolution failures
+- Server errors (5xx status codes)
+- CDN failures and regional issues
+- Cache-related loading problems
+- CORS and security policy violations
+
+## Browser Support
+
+- Chrome 60+
+- Firefox 55+
+- Safari 12+
+- Edge 79+
+
+## TypeScript Support
+
+The plugin includes full TypeScript definitions:
+
+```ts
+import { RetryPlugin, type CommonRetryOptions } from '@module-federation/retry-plugin';
+
+const options: CommonRetryOptions = {
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['https://cdn1.example.com'],
+  onRetry: ({ times, url }) => {
+    console.log(`Retry ${times} for ${url}`);
+  },
+};
+
+const plugin = RetryPlugin(options);
+```
+
+## Migration Guide
+
+### From v0.18.x to v0.19.x
+
+The plugin configuration has been simplified. The old `fetch` and `script` configuration objects are deprecated:
+
+```ts
+// ❌ Old way (deprecated)
+RetryPlugin({
+  fetch: {
+    url: 'http://localhost:2008/not-exist-mf-manifest.json',
+    fallback: () => 'http://localhost:2001/mf-manifest.json',
+  },
+  script: {
+    url: 'http://localhost:2001/static/js/async/src_App_tsx.js',
+    customCreateScript: (url, attrs) => {
+      /* ... */
+    },
+  },
+});
+
+// ✅ New way
+RetryPlugin({
+  retryTimes: 3,
+  retryDelay: 1000,
+  domains: ['http://localhost:2001'],
+  manifestDomains: ['http://localhost:2001'],
+  addQuery: ({ times, originalQuery }) => `${originalQuery}&retry=${times}`,
+});
+```
+
+## Contributing
+
+Contributions are welcome! Please read our [contributing guidelines](https://github.com/module-federation/core/blob/main/CONTRIBUTING.md) and submit pull requests to our [GitHub repository](https://github.com/module-federation/core).
+
+## License
+
+`@module-federation/retry-plugin` is [MIT licensed](https://github.com/module-federation/core/blob/main/packages/retry-plugin/LICENSE).
+
+## Related
+
+- [Module Federation Documentation](https://module-federation.io/)
+- [Module Federation Runtime](https://www.npmjs.com/package/@module-federation/runtime)
+- [Module Federation Enhanced](https://www.npmjs.com/package/@module-federation/enhanced)

package/dist/esm/index.js

@@ -0,0 +1,307 @@
+import { createLogger } from "@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 = 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
+export { RetryPlugin, appendRetryCountQuery, combineUrlDomainWithPathQuery, getRetryUrl, rewriteWithNextDomain };