fix(esbuild): Avoid "Import 'default' will always be undefined" warning

When using @sentry/esbuild-plugin with an entry point that has no
default export (common for Express.js apps), the proxy module generates
`export default OriginalModule.default` which triggers esbuild's
"import-is-undefined" warning.

Fix by wrapping the default export access in a function call, which
prevents esbuild's static analysis from detecting the potentially
missing default while still correctly forwarding it when present.

Fixes #747

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: queelius

packages/esbuild-plugin/src/index.ts

@@ -253,10 +253,15 @@ export function sentryEsbuildPlugin(userOptions: Options = {}): any {
           return {
             loader: "js",
             pluginName,
+            // We wrap the default export access in a function call to prevent esbuild's
+            // static analysis from generating an "Import 'default' will always be undefined"
+            // warning when the original module has no default export. The function wrapper
+            // is transparent and correctly forwards the default export when it exists.
             contents: `
               import "_sentry-debug-id-injection-stub";
-              import * as OriginalModule from ${JSON.stringify(originalPath)};
-              export default OriginalModule.default;
+              import * as _sentry_original_module from ${JSON.stringify(originalPath)};
+              var _sentry_default_export = (function(m) { return m.default; })(_sentry_original_module);
+              export { _sentry_default_export as default };
               export * from ${JSON.stringify(originalPath)};`,
             resolveDir: originalResolveDir,
           };

packages/esbuild-plugin/test/no-default-export-warning.test.ts

@@ -0,0 +1,151 @@
+import { sentryEsbuildPlugin } from "../src";
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import * as esbuild from "esbuild";
+import * as path from "path";
+import * as fs from "fs";
+import * as os from "os";
+
+describe("esbuild proxy module default export handling", () => {
+  let tmpDir: string;
+
+  beforeAll(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sentry-esbuild-test-"));
+  });
+
+  afterAll(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("should build successfully without warnings when entry point has no default export", async () => {
+    const inputFile = path.join(tmpDir, "no-default.ts");
+    fs.writeFileSync(
+      inputFile,
+      [
+        'import * as path from "path";',
+        'console.log("No default export here", path.sep);',
+        "",
+      ].join("\n")
+    );
+
+    const outDir = path.join(tmpDir, "out-no-default");
+    const result = await esbuild.build({
+      entryPoints: [inputFile],
+      sourcemap: true,
+      bundle: true,
+      outdir: outDir,
+      platform: "node",
+      plugins: [
+        sentryEsbuildPlugin({
+          telemetry: false,
+          release: { name: "test-release", create: false },
+        }),
+      ],
+      write: true,
+    });
+
+    // If esbuild version is new enough, warnings about "Import 'default' will always be
+    // undefined" will be captured in result.warnings. On older esbuild versions this array
+    // may be empty regardless, so the test at least verifies no build errors occur.
+    const importUndefinedWarnings = (result.warnings || []).filter(
+      (w) =>
+        w.text.includes("Import") &&
+        w.text.includes("default") &&
+        w.text.includes("undefined")
+    );
+
+    expect(importUndefinedWarnings).toHaveLength(0);
+  });
+
+  it("should preserve default export when the entry point has one", async () => {
+    const inputFile = path.join(tmpDir, "with-default.ts");
+    fs.writeFileSync(
+      inputFile,
+      [
+        "export const foo = 42;",
+        'export default function main() { return "hello"; }',
+        "",
+      ].join("\n")
+    );
+
+    const outDir = path.join(tmpDir, "out-with-default");
+    const result = await esbuild.build({
+      entryPoints: [inputFile],
+      sourcemap: true,
+      bundle: true,
+      outdir: outDir,
+      platform: "node",
+      format: "esm",
+      plugins: [
+        sentryEsbuildPlugin({
+          telemetry: false,
+          release: { name: "test-release", create: false },
+        }),
+      ],
+      write: true,
+    });
+
+    // Should produce no warnings
+    const importUndefinedWarnings = (result.warnings || []).filter(
+      (w) =>
+        w.text.includes("Import") &&
+        w.text.includes("default") &&
+        w.text.includes("undefined")
+    );
+    expect(importUndefinedWarnings).toHaveLength(0);
+
+    // Verify the output contains the default export function
+    const outputFiles = fs.readdirSync(outDir).filter((f) => f.endsWith(".js"));
+    expect(outputFiles.length).toBeGreaterThan(0);
+
+    const outputContent = fs.readFileSync(
+      path.join(outDir, outputFiles[0] as string),
+      "utf-8"
+    );
+    expect(outputContent).toContain("main");
+  });
+
+  it("should preserve named exports when the entry point has no default export", async () => {
+    const inputFile = path.join(tmpDir, "named-only.ts");
+    fs.writeFileSync(
+      inputFile,
+      ['export const foo = 42;', 'export const bar = "hello";', ""].join("\n")
+    );
+
+    const outDir = path.join(tmpDir, "out-named-only");
+    const result = await esbuild.build({
+      entryPoints: [inputFile],
+      sourcemap: true,
+      bundle: true,
+      outdir: outDir,
+      platform: "node",
+      format: "esm",
+      plugins: [
+        sentryEsbuildPlugin({
+          telemetry: false,
+          release: { name: "test-release", create: false },
+        }),
+      ],
+      write: true,
+    });
+
+    // Should produce no warnings
+    const importUndefinedWarnings = (result.warnings || []).filter(
+      (w) =>
+        w.text.includes("Import") &&
+        w.text.includes("default") &&
+        w.text.includes("undefined")
+    );
+    expect(importUndefinedWarnings).toHaveLength(0);
+
+    // Verify the output contains the named exports
+    const outputFiles = fs.readdirSync(outDir).filter((f) => f.endsWith(".js"));
+    expect(outputFiles.length).toBeGreaterThan(0);
+
+    const outputContent = fs.readFileSync(
+      path.join(outDir, outputFiles[0] as string),
+      "utf-8"
+    );
+    expect(outputContent).toContain("foo");
+    expect(outputContent).toContain("bar");
+  });
+});