fix: change bundler injection point

Was failing to call the onInject method for turbopack'ed modules.

Author: isaacs

packages/server-utils/src/orchestrion/bundler/webpack-loader.ts

@@ -4,10 +4,89 @@
 // needs its own entrypoint/subpath rather than being reachable from another module.
 import codeTransformerLoaderImpl from '@apm-js-collab/code-transformer-bundler-plugins/webpack-loader';
 
-// Explicitly typed so the emitted declaration doesn't reference the bundled devDependency.
-// (Nothing imports this subpath from TS — bundlers load it by file path — so the loose
-// signature is never consumed.)
-const codeTransformerLoader: (this: unknown, code: string, inputSourceMap?: unknown) => void =
-  codeTransformerLoaderImpl;
+// The loader context we rely on beyond the transform itself: `resourcePath` to
+// name the module, `async` for the transformed result, and `_compilation` to
+// tell webpack (present) from Turbopack (absent).
+interface LoaderContext {
+  resourcePath: string;
+  async: () => (error: unknown, code?: string, map?: unknown) => void;
+  _compilation?: unknown;
+}
+
+type LoaderFn = (this: LoaderContext, code: string, inputSourceMap?: unknown) => void;
+
+const upstreamLoader = codeTransformerLoaderImpl as unknown as LoaderFn;
+
+/**
+ * The npm package name for a module path.
+ * Reads the segment after the LAST `node_modules`, so pnpm's nested layout
+ * resolves to the real package. Matches the name that channel integrations
+ * await.
+ */
+function packageNameFromPath(resourcePath: string): string | undefined {
+  const marker = '/node_modules/';
+  const normalized = resourcePath.replace(/\\/g, '/');
+  const index = normalized.lastIndexOf(marker);
+  if (index === -1) {
+    return undefined;
+  }
+
+  const [scopeOrName, name] = normalized.slice(index + marker.length).split('/');
+  if (!scopeOrName) {
+    return undefined;
+  }
+
+  return scopeOrName.startsWith('@') && name ? `${scopeOrName}/${name}` : scopeOrName;
+}
+
+/**
+ * Announce a runtime-injected module the way the runtime `--import` hook does,
+ * so the lazily-registered channel integrations subscribe. Appended to each
+ * transformed module's code, it runs when that module loads.
+ */
+function onInjectSnippet(moduleName: string): string {
+  return (
+    ';(function(){' +
+    'var g=globalThis.__SENTRY_ORCHESTRION__;' +
+    `if(g&&typeof g.onInject==='function')g.onInject(${JSON.stringify(moduleName)});` +
+    '})();\n'
+  );
+}
+
+/**
+ * Wraps the upstream code-transform loader.
+ *
+ * Under Turbopack the transform runs as a loader, but the webpack *plugin* that
+ * emits the `injectDiagnostics` boot banner never runs, because Turbopack takes
+ * loaders, not plugins. That banner is what calls `onInject` for bundled
+ * modules, so without it the channel integrations never learn their module
+ * loaded and never subscribe. When there is no webpack compilation (Turbopack
+ * case), append the `onInject` call to each transformed module here instead.
+ * Under webpack leave it to the banner, so signal fires exactly once per module
+ */
+const codeTransformerLoader: LoaderFn = function (code, inputSourceMap) {
+  if (this._compilation) {
+    upstreamLoader.call(this, code, inputSourceMap);
+    return;
+  }
+
+  const realAsync = this.async.bind(this);
+  const { resourcePath } = this;
+
+  this.async = () => {
+    const callback = realAsync();
+    return (error: unknown, outputCode?: string, outputMap?: unknown): void => {
+      // The upstream loader returns the input code unchanged when it did not
+      // transform the module, so a changed string means a channel-publishing
+      // module we must announce.
+      const transformed = !error && typeof outputCode === 'string' && outputCode !== code;
+      const moduleName = transformed ? packageNameFromPath(resourcePath) : undefined;
+      const finalCode = moduleName ? `${outputCode}${onInjectSnippet(moduleName)}` : outputCode;
+      callback(error, finalCode, outputMap);
+    };
+  };
+
+  upstreamLoader.call(this, code, inputSourceMap);
+};
 
 export default codeTransformerLoader;

packages/server-utils/test/orchestrion/webpack-loader.test.ts

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from 'vitest';
+import loader from '../../src/orchestrion/bundler/webpack-loader';
+
+// Stand in for the upstream code-transform loader: a changed string signals a
+// transformed module, the input unchanged signals a pass-through.
+vi.mock('@apm-js-collab/code-transformer-bundler-plugins/webpack-loader', () => ({
+  default: function (this: { async: () => (e: unknown, c?: string, m?: unknown) => void }, code: string, map: unknown) {
+    const callback = this.async();
+    callback(null, code === 'PASS' ? code : `${code};//transformed`, map);
+  },
+}));
+
+interface Ctx {
+  resourcePath: string;
+  _compilation?: unknown;
+}
+
+function runLoader(ctx: Ctx, code: string): string | undefined {
+  let output: string | undefined;
+  const context = {
+    ...ctx,
+    async: () => (_error: unknown, outCode?: string) => {
+      output = outCode;
+    },
+  };
+  (loader as (this: unknown, code: string) => void).call(context, code);
+  return output;
+}
+
+const IOREDIS = '/app/node_modules/ioredis/built/Redis.js';
+
+describe('orchestrion webpack/Turbopack loader', () => {
+  it('appends the onInject call for a transformed module under Turbopack (no compilation)', () => {
+    const output = runLoader({ resourcePath: IOREDIS }, 'code');
+
+    expect(output).toContain('code;//transformed');
+    expect(output).toContain('g.onInject("ioredis")');
+  });
+
+  it('does not append when webpack runs the plugin banner (compilation present)', () => {
+    const output = runLoader({ resourcePath: IOREDIS, _compilation: {} }, 'code');
+
+    expect(output).toBe('code;//transformed');
+    expect(output).not.toContain('onInject');
+  });
+
+  it('does not append for a pass-through (untransformed) module', () => {
+    const output = runLoader({ resourcePath: IOREDIS }, 'PASS');
+
+    expect(output).toBe('PASS');
+  });
+
+  it.each([
+    ['/app/node_modules/ioredis/built/Redis.js', 'ioredis'],
+    ['/app/node_modules/@redis/client/dist/lib/client/index.js', '@redis/client'],
+    // pnpm's nested layout: the real package is after the LAST node_modules.
+    ['/app/node_modules/.pnpm/ioredis@5.10.1/node_modules/ioredis/built/Redis.js', 'ioredis'],
+  ])('derives the package name from %s as %s', (resourcePath, expected) => {
+    const output = runLoader({ resourcePath }, 'code');
+
+    expect(output).toContain(`g.onInject("${expected}")`);
+  });
+
+  it('does not append when the path has no node_modules segment', () => {
+    const output = runLoader({ resourcePath: '/app/src/index.js' }, 'code');
+
+    expect(output).toBe('code;//transformed');
+    expect(output).not.toContain('onInject');
+  });
+});