fix(apps): parse backend module source instead of reading ModuleInfo#ast

The Apps backend module-graph collector read `moduleInfo.ast` in
`moduleParsed`, coupling it to whatever AST the active bundler exposes.
Rolldown — the bundler Vite 8 uses by default — deliberately stubs that
getter to throw `UNSUPPORTED: ModuleInfo#ast`, so any app with a
`.backend.ts` built under Vite 8 (or `rolldown-vite` on Vite 7) failed in
`closeBundle` with an opaque error, after the client bundle had already
succeeded.

Parse `moduleInfo.code` with the plugin context's own `parse` instead. A
bundler then only has to supply the module's source and its resolved
dependency IDs, neither of which Rolldown withholds.

Using the context's parser rather than bundling one keeps this correct by
construction: the bundler already parsed this exact source to compute
`importedIds`, so whatever it accepted, its parser accepts here. A
third-party parser could disagree with the bundler; its own cannot.
Verified `this.parse` is available in `moduleParsed` under both Rollup and
Rolldown 1.1.5.

It also means no TypeScript-capable parser is needed. `moduleParsed` runs
after `transform`, so types and JSX are already gone — verified against a
real Vite 8.1.5 + Rolldown 1.1.5 build, where `'x' as string` arrives as
`"x"` and `<div/>` arrives as a `_jsx(...)` call.

Two alternatives were measured and rejected:

  - Bundling `@typescript-eslint/typescript-estree`. It eagerly requires
    `typescript`, which it declares only as an optional peer, so it needed
    a deferred require to avoid dragging `typescript` into every consumer
    of every published plugin — and it added a dependency to all five of
    them for capability this path never exercises.

  - Injecting Vite's `parseAst` export. Vite maps its `require` condition
    to a reduced CJS entry that omits `parseAst`, so it is unavailable to
    consumers of the plugin's CJS build.

Net dependency footprint is zero: no lockfile change and no change to any
published package.

Also filters before parsing, so `node_modules` files never reach the
parser, and skips modules whose `code` is absent rather than handing a
non-string to it.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sdkennedy2

packages/plugins/apps/src/backend/ast-parsing/type-guards.ts

@@ -13,17 +13,28 @@ interface TypeScriptImportExportMetadata {
 
 type TypeOnlyAwareNode = BaseNode & TypeScriptImportExportMetadata;
 
-export function ensureProgram(node: BaseNode, filePath: string): Program {
+/**
+ * Accepts `unknown` rather than `BaseNode` so it can narrow the output of a
+ * bundler's `parse`, whose node types are declared separately from `estree` even
+ * though they are structurally the same. The runtime check establishes the
+ * shape, so callers get a validated `estree.Program` without a type assertion.
+ */
+export function ensureProgram(node: unknown, filePath: string): Program {
     if (!isProgramNode(node)) {
-        throw new Error(
-            `Expected a Program node from this.parse() for ${filePath}, got ${node.type}`,
-        );
+        throw new Error(`Expected a Program node for ${filePath}, got ${describeNodeType(node)}`);
     }
     return node;
 }
 
-export function isProgramNode(node: BaseNode): node is Program {
-    return node.type === 'Program';
+export function isProgramNode(node: unknown): node is Program {
+    return typeof node === 'object' && node !== null && 'type' in node && node.type === 'Program';
+}
+
+function describeNodeType(node: unknown): string {
+    if (typeof node === 'object' && node !== null && 'type' in node) {
+        return String(node.type);
+    }
+    return String(node);
 }
 
 export function isStringLiteral(node: unknown): node is StringLiteral {

packages/plugins/apps/src/index.test.ts

@@ -40,18 +40,23 @@ function extractViteTransform(plugins: PluginOptions[]) {
     return (transform as { handler: (code: string, id: string) => Promise<unknown> }).handler;
 }
 
+type ModuleParsedHook = (this: { parse: typeof parseAst }, moduleInfo: unknown) => void;
+
 function emitModuleParsed(
-    config: { plugins?: Array<{ moduleParsed?: (moduleInfo: unknown) => void }> },
+    config: { plugins?: Array<{ moduleParsed?: ModuleParsedHook }> },
     id: string,
     code: string,
     importedIds: string[] = [],
 ) {
     for (const plugin of config.plugins ?? []) {
-        plugin.moduleParsed?.({
-            id,
-            ast: parseAst(code),
-            importedIds,
-        });
+        plugin.moduleParsed?.call(
+            { parse: parseAst },
+            {
+                id,
+                code,
+                importedIds,
+            },
+        );
     }
 }
 

packages/plugins/apps/src/vite/backend-module-graph-collector.test.ts

@@ -6,40 +6,72 @@ import { parseAst } from 'rollup/parseAst';
 
 import { createBackendModuleGraphCollector } from './backend-module-graph-collector';
 
+type FakeModuleInfo = {
+    id: string;
+    code?: string | null;
+    importedIds?: string[];
+    importedIdResolutions?: { id: string }[];
+};
+
+const BUILD_ROOT = '/project';
+
+const getModuleParsed = (buildRoot = BUILD_ROOT) => {
+    const collector = createBackendModuleGraphCollector(buildRoot);
+    const hook = collector.plugin.moduleParsed;
+    if (typeof hook !== 'function') {
+        throw new Error('Expected "moduleParsed" to be a function hook.');
+    }
+
+    // Fills defaults in place rather than spreading into a new object: a spread
+    // would enumerate every property, which reads the `ast` getter that some of
+    // these cases deliberately make throw.
+    const emit = (moduleInfo: FakeModuleInfo) => {
+        const importedIds = moduleInfo.importedIds ?? [];
+        moduleInfo.importedIds = importedIds;
+        if (!('importedIdResolutions' in moduleInfo)) {
+            moduleInfo.importedIdResolutions = importedIds.map((id) => ({ id }));
+        }
+        // Called with a plugin context exposing `parse`, which is where the hook
+        // gets its parser. `rollup/parseAst` is what Rollup's real context uses,
+        // so it is also the realistic stand-in here.
+        // The hook only ever reads the handful of `ModuleInfo` fields modelled
+        // by `FakeModuleInfo`; building a complete `ModuleInfo` would be noise.
+        Reflect.apply(hook, { parse: parseAst }, [moduleInfo]);
+    };
+
+    return { collector, emit };
+};
+
+/**
+ * Rolldown — the bundler Vite 8 uses by default — keeps `ModuleInfo#ast` on its
+ * Rollup-compat object but stubs the getter to throw. Reading the property at
+ * all is the failure, so the getter must throw rather than return undefined.
+ */
+const withUnsupportedAst = (moduleInfo: FakeModuleInfo): FakeModuleInfo =>
+    Object.defineProperty(moduleInfo, 'ast', {
+        get() {
+            throw new Error('UNSUPPORTED: ModuleInfo#ast');
+        },
+        enumerable: true,
+    });
+
 describe('Backend Functions - backend module graph collector', () => {
-    test('Should collect parsed local module records from Rollup moduleParsed hooks', () => {
-        const collector = createBackendModuleGraphCollector('/project');
-        const moduleParsed = collector.plugin.moduleParsed as (moduleInfo: unknown) => void;
+    test('Should collect parsed local module records from moduleParsed hooks', () => {
+        const { collector, emit } = getModuleParsed();
 
-        moduleParsed({
+        emit({
             id: '/project/src/backend/actions.backend.js?import',
-            ast: parseAst(`
+            code: `
                 import { getEcho } from './helpers/http.js';
                 export function run() {
                     return getEcho();
                 }
-            `),
+            `,
             importedIds: ['/project/src/backend/helpers/http.js?import'],
-            importedIdResolutions: [{ id: '/project/src/backend/helpers/http.js?import' }],
-        });
-        moduleParsed({
-            id: '/project/node_modules/package/index.js',
-            ast: parseAst('export const value = true;'),
-            importedIds: [],
-            importedIdResolutions: [],
-        });
-        moduleParsed({
-            id: '\0virtual-helper.js',
-            ast: parseAst('export const value = true;'),
-            importedIds: [],
-            importedIdResolutions: [],
-        });
-        moduleParsed({
-            id: 'virtual:dd-backend-dev:example.js',
-            ast: parseAst('export const value = true;'),
-            importedIds: [],
-            importedIdResolutions: [],
         });
+        emit({ id: '/project/node_modules/package/index.js', code: 'export const value = true;' });
+        emit({ id: '\0virtual-helper.js', code: 'export const value = true;' });
+        emit({ id: 'virtual:dd-backend-dev:example.js', code: 'export const value = true;' });
 
         expect([...collector.getModuleRecords().keys()]).toEqual([
             '/project/src/backend/actions.backend.js',
@@ -55,4 +87,118 @@ describe('Backend Functions - backend module graph collector', () => {
             ],
         });
     });
+
+    test('Should collect records under a bundler that does not support ModuleInfo#ast', () => {
+        const { collector, emit } = getModuleParsed();
+        const moduleInfo = withUnsupportedAst({
+            id: '/project/src/backend/actions.backend.ts',
+            code: `
+                import { getEcho } from './helpers/http';
+                export function run() {
+                    return getEcho();
+                }
+            `,
+            importedIds: ['/project/src/backend/helpers/http.ts'],
+        });
+
+        expect(() => emit(moduleInfo)).not.toThrow();
+        expect(
+            collector.getModuleRecords().get('/project/src/backend/actions.backend.ts'),
+        ).toMatchObject({
+            staticDependencies: [
+                { source: './helpers/http', resolvedId: '/project/src/backend/helpers/http.ts' },
+            ],
+        });
+    });
+
+    test('Should never read ModuleInfo#ast, even for a module it skips', () => {
+        const { emit } = getModuleParsed();
+        const readAst = jest.fn(() => ({ type: 'Program', body: [] }));
+        const moduleInfo: FakeModuleInfo = Object.defineProperty(
+            { id: '/project/src/backend/actions.backend.ts', code: 'export const a = 1;' },
+            'ast',
+            { get: readAst, enumerable: true },
+        );
+
+        emit(moduleInfo);
+        emit(
+            withUnsupportedAst({ id: '/project/node_modules/pkg/index.js', code: 'const a = 1;' }),
+        );
+
+        expect(readAst).not.toHaveBeenCalled();
+    });
+
+    describe('modules it must skip without parsing', () => {
+        // Each of these would throw if the collector parsed it, so reaching the
+        // parser at all is what the assertion catches.
+        const cases = [
+            {
+                description: 'skip a package module rather than parse it',
+                moduleInfo: {
+                    id: '/project/node_modules/package/index.js',
+                    code: 'this is not valid javascript {{{',
+                },
+            },
+            {
+                description: 'skip a module outside the build root',
+                moduleInfo: { id: '/elsewhere/src/thing.ts', code: 'still ((( not valid' },
+            },
+            {
+                description: 'skip a non-source extension',
+                moduleInfo: { id: '/project/src/styles.css', code: '.a { color: red }' },
+            },
+            {
+                description: 'skip a module the bundler reports with null code',
+                moduleInfo: { id: '/project/src/external.ts', code: null },
+            },
+            {
+                description: 'skip a module the bundler reports with no code at all',
+                moduleInfo: { id: '/project/src/undefined.ts' },
+            },
+        ];
+
+        test.each(cases)('Should $description', ({ moduleInfo }) => {
+            const { collector, emit } = getModuleParsed();
+
+            expect(() => emit(moduleInfo)).not.toThrow();
+            expect([...collector.getModuleRecords().keys()]).toEqual([]);
+        });
+    });
+
+    test('Should strip query suffixes from both the module and its dependencies', () => {
+        const { collector, emit } = getModuleParsed();
+
+        emit({
+            id: '/project/src/entry.backend.ts?v=abc123',
+            code: `
+                import { a } from './dep';
+                export const run = () => a;
+            `,
+            importedIds: ['/project/src/dep.ts?v=def456'],
+        });
+
+        expect([...collector.getModuleRecords().keys()]).toEqual(['/project/src/entry.backend.ts']);
+        expect(
+            collector.getModuleRecords().get('/project/src/entry.backend.ts')?.staticDependencies,
+        ).toEqual([{ source: './dep', resolvedId: '/project/src/dep.ts' }]);
+    });
+
+    test('Should fall back to importedIds when the bundler omits importedIdResolutions', () => {
+        const { collector, emit } = getModuleParsed();
+        const id = '/project/src/entry.backend.ts';
+
+        emit({
+            id,
+            code: `
+                import { a } from './dep';
+                export const run = () => a;
+            `,
+            importedIds: ['/project/src/dep.ts'],
+            importedIdResolutions: undefined,
+        });
+
+        expect(collector.getModuleRecords().get(id)?.staticDependencies).toEqual([
+            { source: './dep', resolvedId: '/project/src/dep.ts' },
+        ]);
+    });
 });

packages/plugins/apps/src/vite/backend-module-graph-collector.ts

@@ -2,17 +2,27 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-import type { BaseNode } from 'estree';
 import type { ModuleInfo } from 'rollup';
 import type { Plugin } from 'vite';
 
 import {
     createParsedModuleRecord,
     type ParsedModuleRecord,
+    shouldTraverseCollectedModule,
 } from '../backend/ast-parsing/module-graph';
+import { ensureProgram } from '../backend/ast-parsing/type-guards';
 
 const VIRTUAL_MODULE_ID_RE = /^(?:\0|virtual:)/;
 
+/**
+ * The slice of the plugin context this hook uses. Declared structurally, rather
+ * than using Rollup's `PluginContext`, so the same hook body type-checks against
+ * Rollup's and Rolldown's separately-declared context types.
+ */
+interface ModuleParsedContext {
+    parse: (code: string) => unknown;
+}
+
 export interface BackendModuleGraphCollector {
     plugin: Plugin;
     getModuleRecords: () => ReadonlyMap<string, ParsedModuleRecord>;
@@ -24,17 +34,49 @@ export function createBackendModuleGraphCollector(buildRoot: string): BackendMod
     return {
         plugin: {
             name: 'dd-backend-module-graph-collector',
-            moduleParsed(moduleInfo: ModuleInfo) {
+            moduleParsed(this: ModuleParsedContext, moduleInfo: ModuleInfo) {
                 const moduleId = normalizeViteModuleId(moduleInfo.id);
                 if (isViteVirtualModuleId(moduleId)) {
                     return;
                 }
 
+                // Filter before parsing. `createParsedModuleRecord` applies the
+                // same predicate, but reaching it means we already parsed the
+                // module — which would put every `node_modules` file through the
+                // parser and let an irrelevant syntax error fail the build.
+                if (!shouldTraverseCollectedModule(moduleId, buildRoot)) {
+                    return;
+                }
+
+                // Bundlers report `code: null` for external and synthetic
+                // modules, and there is nothing to parse for those. Checked as a
+                // string rather than against `null` so a bundler that leaves the
+                // field undefined is handled the same way instead of reaching
+                // the parser.
+                const code = moduleInfo.code;
+                if (typeof code !== 'string') {
+                    return;
+                }
+
+                // Parse the source rather than reading `moduleInfo.ast`, which
+                // Rolldown — the bundler Vite 8 uses by default — stubs to throw
+                // `UNSUPPORTED: ModuleInfo#ast`.
+                //
+                // Using the context's own `parse` makes this correct by
+                // construction: the bundler already parsed this exact source to
+                // compute `importedIds`, so whatever it accepted, its parser
+                // accepts here. It also means no TypeScript-capable parser is
+                // needed — `moduleParsed` runs after `transform`, so types and
+                // JSX are already gone.
+                const parsed = this.parse(code);
+                const ast = ensureProgram(parsed, moduleId);
+                const staticDependencyIds =
+                    getStaticDependencyIds(moduleInfo).map(normalizeViteModuleId);
                 const record = createParsedModuleRecord(
                     moduleId,
                     buildRoot,
-                    moduleInfo.ast as BaseNode,
-                    getStaticDependencyIds(moduleInfo).map(normalizeViteModuleId),
+                    ast,
+                    staticDependencyIds,
                 );
                 if (!record) {
                     return;

packages/plugins/apps/src/vite/dev-server.test.ts

@@ -112,18 +112,23 @@ function mockBuildResult(code: string) {
     };
 }
 
+type ModuleParsedHook = (this: { parse: typeof parseAst }, moduleInfo: unknown) => void;
+
 function emitModuleParsed(
-    config: { plugins?: Array<{ moduleParsed?: (moduleInfo: unknown) => void }> },
+    config: { plugins?: Array<{ moduleParsed?: ModuleParsedHook }> },
     id: string,
     code: string,
     importedIds: string[] = [],
 ) {
     for (const plugin of config.plugins ?? []) {
-        plugin.moduleParsed?.({
-            id,
-            ast: parseAst(code),
-            importedIds,
-        });
+        plugin.moduleParsed?.call(
+            { parse: parseAst },
+            {
+                id,
+                code,
+                importedIds,
+            },
+        );
     }
 }