fix(esbuild): ensure debug IDs are injected alongside moduleMetadata

Author: logaretm

packages/esbuild-plugin/src/index.ts

@@ -42,6 +42,14 @@ function esbuildReleaseInjectionPlugin(injectionCode: string): UnpluginOptions {
   };
 }
 
+// Shared set to track entry points that have been wrapped by the metadata plugin.
+// This allows the debug ID plugin to know when an import is coming from a metadata proxy.
+const metadataProxyEntryPoints = new Set<string>();
+
+// Set to track which paths have already been wrapped with debug ID injection.
+// This prevents the debug ID plugin from wrapping the same module multiple times.
+const debugIdWrappedPaths = new Set<string>();
+
 function esbuildDebugIdInjectionPlugin(logger: Logger): UnpluginOptions {
   const pluginName = "sentry-esbuild-debug-id-injection-plugin";
   const stubNamespace = "sentry-debug-id-stub";
@@ -58,33 +66,60 @@ function esbuildDebugIdInjectionPlugin(logger: Logger): UnpluginOptions {
         }
 
         onResolve({ filter: /.*/ }, (args) => {
-          if (args.kind !== "entry-point") {
+          // We want to inject debug IDs into entry points. However, when the module metadata
+          // injection plugin is also active, it intercepts entry points first and creates a
+          // proxy module that re-imports the original entry point. In that case, we need to
+          // also intercept those imports (which have kind === "import-statement") and inject
+          // debug IDs there too.
+          const isEntryPoint = args.kind === "entry-point";
+
+          // Check if this import is coming from a metadata proxy module.
+          // The metadata plugin registers entry points it wraps in the shared Set.
+          const isImportFromMetadataProxy =
+            args.kind === "import-statement" &&
+            args.importer !== undefined &&
+            metadataProxyEntryPoints.has(args.importer);
+
+          if (!isEntryPoint && !isImportFromMetadataProxy) {
             return;
-          } else {
-            // Injected modules via the esbuild `inject` option do also have `kind == "entry-point"`.
-            // We do not want to inject debug IDs into those files because they are already bundled into the entrypoints
-            if (initialOptions.inject?.includes(args.path)) {
-              return;
-            }
+          }
 
-            return {
-              pluginName,
-              // needs to be an abs path, otherwise esbuild will complain
-              path: path.isAbsolute(args.path) ? args.path : path.join(args.resolveDir, args.path),
-              pluginData: {
-                isProxyResolver: true,
-                originalPath: args.path,
-                originalResolveDir: args.resolveDir,
-              },
-              // We need to add a suffix here, otherwise esbuild will mark the entrypoint as resolved and won't traverse
-              // the module tree any further down past the proxy module because we're essentially creating a dependency
-              // loop back to the proxy module.
-              // By setting a suffix we're telling esbuild that the entrypoint and proxy module are two different things,
-              // making it re-resolve the entrypoint when it is imported from the proxy module.
-              // Super confusing? Yes. Works? Apparently... Let's see.
-              suffix: "?sentryProxyModule=true",
-            };
+          // Injected modules via the esbuild `inject` option do also have `kind == "entry-point"`.
+          // We do not want to inject debug IDs into those files because they are already bundled into the entrypoints
+          if (initialOptions.inject?.includes(args.path)) {
+            return;
           }
+
+          const resolvedPath = path.isAbsolute(args.path)
+            ? args.path
+            : path.join(args.resolveDir, args.path);
+
+          // Check if we've already wrapped this path. This can happen when both the metadata
+          // plugin and debug ID plugin are active - the debug ID proxy imports the original
+          // module, and since its importer path matches the metadata proxy entry point,
+          // we might try to wrap it again. Prevent this by tracking wrapped paths.
+          if (debugIdWrappedPaths.has(resolvedPath)) {
+            return;
+          }
+          debugIdWrappedPaths.add(resolvedPath);
+
+          return {
+            pluginName,
+            // needs to be an abs path, otherwise esbuild will complain
+            path: resolvedPath,
+            pluginData: {
+              isProxyResolver: true,
+              originalPath: args.path,
+              originalResolveDir: args.resolveDir,
+            },
+            // We need to add a suffix here, otherwise esbuild will mark the entrypoint as resolved and won't traverse
+            // the module tree any further down past the proxy module because we're essentially creating a dependency
+            // loop back to the proxy module.
+            // By setting a suffix we're telling esbuild that the entrypoint and proxy module are two different things,
+            // making it re-resolve the entrypoint when it is imported from the proxy module.
+            // Super confusing? Yes. Works? Apparently... Let's see.
+            suffix: "?sentryProxyModule=true",
+          };
         });
 
         onLoad({ filter: /.*/ }, (args) => {
@@ -152,10 +187,19 @@ function esbuildModuleMetadataInjectionPlugin(injectionCode: string): UnpluginOp
               return;
             }
 
+            const resolvedPath = path.isAbsolute(args.path)
+              ? args.path
+              : path.join(args.resolveDir, args.path);
+
+            // Register this entry point so the debug ID plugin knows to wrap imports from
+            // this proxy module. This is needed because the debug ID plugin runs after us and
+            // needs to know when an import is coming from our proxy module.
+            metadataProxyEntryPoints.add(resolvedPath);
+
             return {
               pluginName,
               // needs to be an abs path, otherwise esbuild will complain
-              path: path.isAbsolute(args.path) ? args.path : path.join(args.resolveDir, args.path),
+              path: resolvedPath,
               pluginData: {
                 isMetadataProxyResolver: true,
                 originalPath: args.path,