fix(retry-plugin): implement error handling in getRemoteEntry to avoid throw RUNTIME_008 error on console (#4064)

Author: danpeen

apps/router-demo/router-host-2000/src/runtime-plugin/retry.ts

@@ -2,7 +2,7 @@ import { RetryPlugin } from '@module-federation/retry-plugin';
 
 const retryPlugin = () =>
   RetryPlugin({
-    retryTimes: 3,
+    retryTimes: 4,
     retryDelay: 1000,
     onRetry: (params) => {
       console.log('onRetry', params);
@@ -13,19 +13,19 @@ const retryPlugin = () =>
     onError: (params) => {
       console.log('onError', params);
     },
-    manifestDomains: [
-      'https://m1.example.com',
-      'https://m2.example.com',
-      'https://m3.example.com',
-    ],
-    domains: [
-      'http://localhost:2011',
-      'http://localhost:2021',
-      'http://localhost:2031',
-    ],
-    addQuery: ({ times, originalQuery }) => {
-      return `${originalQuery}&retry=${times}&retryTimeStamp=${new Date().valueOf()}`;
-    },
+    // manifestDomains: [
+    //   'https://m1.example.com',
+    //   'https://m2.example.com',
+    //   'https://m3.example.com',
+    // ],
+    // domains: [
+    //   'http://localhost:2011',
+    //   'http://localhost:2021',
+    //   'http://localhost:2031',
+    // ],
+    // addQuery: ({ times, originalQuery }) => {
+    //   return `${originalQuery}&retry=${times}&retryTimeStamp=${new Date().valueOf()}`;
+    // },
     fetchOptions: {
       method: 'GET',
     },

packages/retry-plugin/__tests__/retry.spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, vi } from 'vitest';
 import { fetchRetry } from '../src/fetch-retry';
 import { scriptRetry } from '../src/script-retry';
-import { ERROR_ABANDONED } from '../src/constant';
+import { ERROR_ABANDONED, RUNTIME_008 } from '../src/constant';
 
 const mockFetch = vi.fn();
 global.fetch = mockFetch;
@@ -53,7 +53,7 @@ describe('Retry Plugin', () => {
           retryTimes: 2,
           retryDelay: 10,
         }),
-      ).rejects.toThrow(ERROR_ABANDONED);
+      ).rejects.toThrow(RUNTIME_008);
 
       expect(mockFetch).toHaveBeenCalledTimes(3); // 1 initial + 2 retries
     });

packages/retry-plugin/src/constant.ts

@@ -2,3 +2,4 @@ export const defaultRetries = 3;
 export const defaultRetryDelay = 1000;
 export const PLUGIN_IDENTIFIER = '[ Module Federation RetryPlugin ]';
 export const ERROR_ABANDONED = 'The request failed and has now been abandoned';
+export const RUNTIME_008 = 'RUNTIME-008';

packages/retry-plugin/src/fetch-retry.ts

@@ -4,6 +4,7 @@ import {
   defaultRetryDelay,
   PLUGIN_IDENTIFIER,
   ERROR_ABANDONED,
+  RUNTIME_008,
 } from './constant';
 import logger from './logger';
 import { getRetryUrl, combineUrlDomainWithPathQuery } from './utils';
@@ -83,11 +84,13 @@ async function fetchRetry(
           `${PLUGIN_IDENTIFIER}: retry failed, no retries left for url: ${requestUrl}`,
         );
       }
-      throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED}`);
+      // Throw error with RUNTIME_008 to match loadEntryScript behavior
+      throw new Error(
+        `${RUNTIME_008}: ${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${requestUrl}`,
+      );
     } else {
       // Prepare next retry using the same domain extraction logic
-      const nextIndex = total - retryTimes + 1; // upcoming retry count
-
+      const nextIndex = total - retryTimes + 1;
       // For prediction, use current request URL's domain but original URL's path/query
       const predictedBaseUrl = combineUrlDomainWithPathQuery(requestUrl, url);
 

packages/retry-plugin/src/index.ts

@@ -15,7 +15,7 @@ const RetryPlugin = (
   // @ts-ignore
   if (params?.fetch || params?.script) {
     logger.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`,
+      `${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 {

packages/retry-plugin/src/script-retry.ts

@@ -29,10 +29,12 @@ export function scriptRetry<T extends Record<string, any>>({
     } = retryOptions || {};
 
     let attempts = 0; // number of attempts already performed
-    while (attempts < retryTimes) {
+    const maxAttempts = retryTimes; // maximum number of attempts allowed
+
+    while (attempts < maxAttempts) {
       try {
         beforeExecuteRetry();
-        if (retryDelay > 0) {
+        if (retryDelay > 0 && attempts > 0) {
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }
         const retryIndex = attempts + 1;
@@ -79,11 +81,14 @@ export function scriptRetry<T extends Record<string, any>>({
       } catch (error) {
         lastError = error;
         attempts++;
-        if (attempts >= retryTimes) {
+        if (attempts >= maxAttempts) {
           onError &&
             lastRequestUrl &&
             onError({ domains, url: lastRequestUrl, tagName: 'script' });
-          throw new Error(`${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED}`);
+
+          throw new Error(
+            `${PLUGIN_IDENTIFIER}: ${ERROR_ABANDONED} | url: ${lastRequestUrl || 'unknown'}`,
+          );
         }
       }
     }

packages/runtime-core/src/core.ts

@@ -136,7 +136,7 @@ export class ModuleFederation {
           uniqueKey: string;
         },
       ],
-      Promise<(() => Promise<RemoteEntryExports | undefined>) | undefined>
+      Promise<Promise<RemoteEntryExports | undefined> | undefined>
     >(),
     getModuleFactory: new AsyncHook<
       [

packages/runtime-core/src/module/index.ts

@@ -37,28 +37,12 @@ class Module {
     }
 
     let remoteEntryExports;
-    try {
-      remoteEntryExports = await getRemoteEntry({
-        origin: this.host,
-        remoteInfo: this.remoteInfo,
-        remoteEntryExports: this.remoteEntryExports,
-      });
-    } catch (err) {
-      const uniqueKey = getRemoteEntryUniqueKey(this.remoteInfo);
-      const isScriptLoadError =
-        err instanceof Error && err.message.includes(RUNTIME_008);
-      if (isScriptLoadError) {
-        remoteEntryExports =
-          await this.host.loaderHook.lifecycle.loadEntryError.emit({
-            getRemoteEntry,
-            origin: this.host,
-            remoteInfo: this.remoteInfo,
-            remoteEntryExports: this.remoteEntryExports,
-            globalLoading,
-            uniqueKey,
-          });
-      }
-    }
+
+    remoteEntryExports = await getRemoteEntry({
+      origin: this.host,
+      remoteInfo: this.remoteInfo,
+      remoteEntryExports: this.remoteEntryExports,
+    });
 
     assert(
       remoteEntryExports,

packages/runtime-core/src/utils/load.ts

@@ -237,8 +237,15 @@ export async function getRemoteEntry(params: {
   remoteInfo: RemoteInfo;
   remoteEntryExports?: RemoteEntryExports | undefined;
   getEntryUrl?: (url: string) => string;
+  _inErrorHandling?: boolean; // Add flag to prevent recursion
 }): Promise<RemoteEntryExports | false | void> {
-  const { origin, remoteEntryExports, remoteInfo, getEntryUrl } = params;
+  const {
+    origin,
+    remoteEntryExports,
+    remoteInfo,
+    getEntryUrl,
+    _inErrorHandling = false,
+  } = params;
   const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
   if (remoteEntryExports) {
     return remoteEntryExports;
@@ -272,6 +279,34 @@ export async function getRemoteEntry(params: {
               getEntryUrl,
             })
           : loadEntryNode({ remoteInfo, loaderHook });
+      })
+      .catch(async (err) => {
+        const uniqueKey = getRemoteEntryUniqueKey(remoteInfo);
+        const isScriptLoadError =
+          err instanceof Error && err.message.includes(RUNTIME_008);
+
+        if (isScriptLoadError && !_inErrorHandling) {
+          const wrappedGetRemoteEntry = (
+            params: Parameters<typeof getRemoteEntry>[0],
+          ) => {
+            return getRemoteEntry({ ...params, _inErrorHandling: true });
+          };
+
+          const RemoteEntryExports =
+            await origin.loaderHook.lifecycle.loadEntryError.emit({
+              getRemoteEntry: wrappedGetRemoteEntry,
+              origin,
+              remoteInfo: remoteInfo,
+              remoteEntryExports,
+              globalLoading,
+              uniqueKey,
+            });
+
+          if (RemoteEntryExports) {
+            return RemoteEntryExports;
+          }
+        }
+        throw err;
       });
   }