feat: override params in beforeResolve()

Author: szymonrybczak

packages/repack/src/modules/ScriptManager/ScriptManager.ts

@@ -1,6 +1,6 @@
 // biome-ignore lint/style/useNodejsImportProtocol: use 'events' module instead of node builtin
 import EventEmitter from 'events';
-import { AsyncSeriesHook } from 'tapable';
+import { AsyncSeriesHook, AsyncSeriesWaterfallHook } from 'tapable';
 import NativeScriptManager, {
   type NormalizedScriptLocator,
 } from './NativeScriptManager.js';
@@ -55,12 +55,6 @@ export interface ResolverOptions {
   key?: string;
 }
 
-interface ScriptHookParams {
-  scriptId: string;
-  caller?: string;
-  error?: Error;
-}
-
 /**
  * A manager to ease resolution, downloading and executing additional code from:
  * - arbitrary JavaScript scripts
@@ -114,15 +108,49 @@ interface ScriptHookParams {
  * ```
  */
 export class ScriptManager extends EventEmitter {
-  hooks: {
-    beforeResolve: AsyncSeriesHook<[ScriptHookParams]>;
-    resolve: AsyncSeriesHook<[ScriptHookParams]>;
-    afterResolve: AsyncSeriesHook<[ScriptHookParams]>;
-    errorResolve: AsyncSeriesHook<[ScriptHookParams]>;
-    beforeLoad: AsyncSeriesHook<[ScriptHookParams]>;
-    load: AsyncSeriesHook<[ScriptHookParams]>;
-    afterLoad: AsyncSeriesHook<[ScriptHookParams]>;
-    errorLoad: AsyncSeriesHook<[ScriptHookParams]>;
+  private resolvers: Array<[string, string | number, ScriptLocatorResolver]> =
+    [];
+  protected cache: Cache = {};
+  private storage?: StorageApi;
+
+  public hooks = {
+    beforeResolve: new AsyncSeriesWaterfallHook<{
+      scriptId: string;
+      caller?: string;
+    }>(['params']),
+    resolve: new AsyncSeriesHook<{ scriptId: string; caller?: string }, void>([
+      'params',
+    ]),
+    afterResolve: new AsyncSeriesHook<
+      { scriptId: string; caller?: string },
+      void
+    >(['params']),
+    errorResolve: new AsyncSeriesHook<
+      {
+        scriptId: string;
+        caller?: string;
+        error: Error;
+      },
+      void
+    >(['params']),
+    beforeLoad: new AsyncSeriesHook<
+      { scriptId: string; caller?: string },
+      void
+    >(['params']),
+    load: new AsyncSeriesHook<{ scriptId: string; caller?: string }, void>([
+      'params',
+    ]),
+    afterLoad: new AsyncSeriesHook<{ scriptId: string; caller?: string }, void>(
+      ['params']
+    ),
+    errorLoad: new AsyncSeriesHook<
+      {
+        scriptId: string;
+        caller?: string;
+        error: Error;
+      },
+      void
+    >(['params']),
   };
 
   static init() {
@@ -135,11 +163,8 @@ export class ScriptManager extends EventEmitter {
     return __webpack_require__.repack.shared.scriptManager!;
   }
 
-  protected cache: Cache = {};
   protected scriptsPromises: ScriptsPromises = {};
   protected cacheInitialized = false;
-  protected resolvers: [string, number, ScriptLocatorResolver][] = [];
-  protected storage?: StorageApi;
 
   /**
    * Constructs instance of `ScriptManager`.
@@ -164,17 +189,6 @@ export class ScriptManager extends EventEmitter {
       );
     }
 
-    this.hooks = {
-      beforeResolve: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-      resolve: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-      afterResolve: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-      errorResolve: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-      beforeLoad: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-      load: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-      afterLoad: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-      errorLoad: new AsyncSeriesHook<[ScriptHookParams]>(['params']),
-    };
-
     __webpack_require__.repack.shared.scriptManager = this;
   }
 
@@ -213,7 +227,7 @@ export class ScriptManager extends EventEmitter {
     this.resolvers = this.resolvers
       .filter(([key]) => key !== uniqueKey)
       .concat([[uniqueKey ?? DEFAULT_RESOLVER_KEY, priority, resolver]])
-      .sort(([, a], [, b]) => b - a);
+      .sort(([, a], [, b]) => Number(b) - Number(a));
   }
 
   /**
@@ -283,41 +297,67 @@ export class ScriptManager extends EventEmitter {
     webpackContext = getWebpackContext(),
     referenceUrl?: string
   ): Promise<Script> {
-    await this.initCache();
+    let finalScriptId = scriptId;
+    let finalCaller = caller;
+
     try {
+      await this.initCache();
+
       if (!this.resolvers.length) {
-        throw new Error(
+        const error = new Error(
           'No script resolvers were added. Did you forget to call `ScriptManager.shared.addResolver(...)`?'
         );
+        await this.hooks.errorResolve.promise({
+          scriptId: finalScriptId,
+          caller: finalCaller,
+          error,
+        });
+        throw error;
       }
 
-      await this.hooks.beforeResolve.promise({ scriptId, caller });
-      this.emit('resolving', { scriptId, caller });
+      const hookResult = await this.hooks.beforeResolve.promise({
+        scriptId,
+        caller,
+      });
+
+      if (hookResult) {
+        finalScriptId = hookResult.scriptId;
+        finalCaller = hookResult.caller;
+      }
+
+      this.emit('resolving', { scriptId: finalScriptId, caller: finalCaller });
 
       // Check if there are any taps in the resolve hook
       const _hasResolveHooks = this.hooks.resolve.taps.length > 0;
 
       let locator: ScriptLocator | undefined;
 
       // if (hasResolveHooks) {
-      await this.hooks.resolve.promise({ scriptId, caller });
+      await this.hooks.resolve.promise({
+        scriptId: finalScriptId,
+        caller: finalCaller,
+      });
       // } else {
       for (const [, , resolve] of this.resolvers) {
-        const resolvedLocator = await resolve(scriptId, caller, referenceUrl);
+        const resolvedLocator = await resolve(
+          finalScriptId,
+          finalCaller,
+          referenceUrl
+        );
         if (resolvedLocator) {
           locator = resolvedLocator;
           break;
         }
+        // }
       }
-      // }
 
       if (!locator) {
         const error = new Error(
-          `No resolver was able to resolve script ${scriptId}`
+          `No resolver was able to resolve script ${finalScriptId}`
         );
         await this.hooks.errorResolve.promise({
-          scriptId,
-          caller,
+          scriptId: finalScriptId,
+          caller: finalCaller,
           error,
         });
         throw error;
@@ -327,15 +367,19 @@ export class ScriptManager extends EventEmitter {
         locator.url = locator.url(webpackContext);
       }
 
-      const script = Script.from({ scriptId, caller }, locator, false);
+      const script = Script.from(
+        { scriptId: finalScriptId, caller: finalCaller },
+        locator,
+        false
+      );
       const cacheKey = script.locator.uniqueId;
 
       // Check if user provided a custom shouldUpdateScript function
       if (locator.shouldUpdateScript) {
         // If so, we need to wait for it to resolve
         const fetch = await locator.shouldUpdateScript(
-          scriptId,
-          caller,
+          finalScriptId,
+          finalCaller,
           script.shouldUpdateCache(this.cache[cacheKey])
         );
 
@@ -344,7 +388,7 @@ export class ScriptManager extends EventEmitter {
           script.locator.fetch = true;
         }
 
-        await this.hooks.resolve.promise({ scriptId, caller });
+        // await this.hooks.resolve.promise({ scriptId: finalScriptId, caller: finalCaller });
         this.emit('resolved', script.toObject());
 
         // if it returns false, we don't need to fetch the script
@@ -358,24 +402,23 @@ export class ScriptManager extends EventEmitter {
         script.locator.fetch = true;
       }
 
-      // Only call resolve hook if it wasn't called during resolution
-      // if (!hasResolveHooks) {
-      await this.hooks.resolve.promise({ scriptId, caller });
-      // }
-      await this.hooks.afterResolve.promise({ scriptId, caller });
+      await this.hooks.afterResolve.promise({
+        scriptId: finalScriptId,
+        caller: finalCaller,
+      });
       this.emit('resolved', script.toObject());
 
       return script;
     } catch (error) {
       await this.hooks.errorResolve.promise({
-        scriptId,
-        caller,
+        scriptId: finalScriptId,
+        caller: finalCaller,
         error: error as Error,
       });
       this.handleError(
         error,
         '[ScriptManager] Failed while resolving script locator:',
-        { scriptId, caller }
+        { scriptId: finalScriptId, caller: finalCaller }
       );
     }
   }
@@ -427,24 +470,30 @@ export class ScriptManager extends EventEmitter {
       );
 
       try {
-        await this.hooks.beforeLoad.promise({ scriptId, caller });
+        await this.hooks.beforeLoad.promise({
+          scriptId: scriptId,
+          caller: caller,
+        });
         this.emit('loading', script.toObject());
 
         const _hasLoadHooks = this.hooks.load.taps.length > 0;
         // if (hasLoadHooks) {
-        await this.hooks.load.promise({ scriptId, caller });
+        await this.hooks.load.promise({ scriptId: scriptId, caller: caller });
         // } else {
         await this.loadScriptWithRetry(scriptId, script.locator);
         // }
 
-        await this.hooks.afterLoad.promise({ scriptId, caller });
+        await this.hooks.afterLoad.promise({
+          scriptId: scriptId,
+          caller: caller,
+        });
         this.emit('loaded', script.toObject());
         await this.updateCache(script);
       } catch (error) {
         const { code } = error as Error & { code: string };
         await this.hooks.errorLoad.promise({
-          scriptId,
-          caller,
+          scriptId: scriptId,
+          caller: caller,
           error: error as Error,
         });
         this.handleError(