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

The Apps backend module-graph collector read `moduleInfo.ast` in
`moduleParsed`. Rolldown — the bundler Vite 8 uses by default — 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`, after the client bundle had already succeeded.

Parse `moduleInfo.code` with the plugin context's own `parse` instead.
Rolldown withholds only the pre-built AST; the source and the resolved
dependency IDs are both still available.

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 parses here too. It also means no
TypeScript-capable parser is needed, since `moduleParsed` runs after
`transform` — 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. No new dependency, and `this.parse` returns a node that
is directly assignable, so the previous `as BaseNode` cast goes away.

Filtering with `shouldTraverseCollectedModule` moves ahead of the parse.
`createParsedModuleRecord` applies the same predicate, but only once an AST
exists — checking first avoids parsing every `node_modules` module just to
discard the result, which reading the pre-built AST never cost.

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

Author: sdkennedy2

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

@@ -41,17 +41,24 @@ function extractViteTransform(plugins: PluginOptions[]) {
 }
 
 function emitModuleParsed(
-    config: { plugins?: Array<{ moduleParsed?: (moduleInfo: unknown) => void }> },
+    config: {
+        plugins?: Array<{
+            moduleParsed?: (this: { parse: typeof parseAst }, moduleInfo: unknown) => void;
+        }>;
+    },
     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,52 @@ import { parseAst } from 'rollup/parseAst';
 
 import { createBackendModuleGraphCollector } from './backend-module-graph-collector';
 
+type FakeModuleInfo = { id: string; code?: string | null };
+
+/**
+ * Invokes the hook with a plugin context exposing `parse`, which is where it gets
+ * its parser. `rollup/parseAst` is what Rollup's real context uses.
+ */
+const getEmit = (collector: ReturnType<typeof createBackendModuleGraphCollector>) => {
+    const moduleParsed = collector.plugin.moduleParsed as (
+        this: { parse: typeof parseAst },
+        moduleInfo: unknown,
+    ) => void;
+
+    // Fills the remaining fields in place rather than spreading into a new
+    // object: a spread would drop (or trigger) an `ast` getter, and one case
+    // below depends on that getter surviving intact.
+    return (moduleInfo: FakeModuleInfo, importedIds: string[] = []) =>
+        moduleParsed.call(
+            { parse: parseAst },
+            Object.assign(moduleInfo, {
+                importedIds,
+                importedIdResolutions: importedIds.map((id) => ({ id })),
+            }),
+        );
+};
+
 describe('Backend Functions - backend module graph collector', () => {
-    test('Should collect parsed local module records from Rollup moduleParsed hooks', () => {
+    test('Should collect parsed local module records from moduleParsed hooks', () => {
         const collector = createBackendModuleGraphCollector('/project');
-        const moduleParsed = collector.plugin.moduleParsed as (moduleInfo: unknown) => void;
-
-        moduleParsed({
-            id: '/project/src/backend/actions.backend.js?import',
-            ast: parseAst(`
-                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: [],
-        });
+        const emit = getEmit(collector);
+
+        emit(
+            {
+                id: '/project/src/backend/actions.backend.js?import',
+                code: `
+                    import { getEcho } from './helpers/http.js';
+                    export function run() {
+                        return getEcho();
+                    }
+                `,
+            },
+            ['/project/src/backend/helpers/http.js?import'],
+        );
+        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;' });
+        emit({ id: '/project/src/backend/external.js', code: null });
 
         expect([...collector.getModuleRecords().keys()]).toEqual([
             '/project/src/backend/actions.backend.js',
@@ -55,4 +67,28 @@ describe('Backend Functions - backend module graph collector', () => {
             ],
         });
     });
+
+    test('Should collect records under a bundler that does not support ModuleInfo#ast', () => {
+        const collector = createBackendModuleGraphCollector('/project');
+        const emit = getEmit(collector);
+
+        // Rolldown, the bundler Vite 8 uses by default, keeps `ast` on its
+        // Rollup-compat object but stubs the getter to throw. Reading the
+        // property at all is the failure, so it must throw rather than be absent.
+        const moduleInfo: FakeModuleInfo = Object.defineProperty(
+            { id: '/project/src/backend/actions.backend.ts', code: 'export const id = "conn-1";' },
+            'ast',
+            {
+                get() {
+                    throw new Error('UNSUPPORTED: ModuleInfo#ast');
+                },
+                enumerable: true,
+            },
+        );
+
+        expect(() => emit(moduleInfo)).not.toThrow();
+        expect([...collector.getModuleRecords().keys()]).toEqual([
+            '/project/src/backend/actions.backend.ts',
+        ]);
+    });
 });

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

@@ -2,13 +2,13 @@
 // 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';
 
 const VIRTUAL_MODULE_ID_RE = /^(?:\0|virtual:)/;
@@ -30,10 +30,32 @@ export function createBackendModuleGraphCollector(buildRoot: string): BackendMod
                     return;
                 }
 
+                // `createParsedModuleRecord` applies this same predicate, but
+                // only after the AST exists. Checking it here keeps us from
+                // parsing every `node_modules` module just to discard it.
+                if (!shouldTraverseCollectedModule(moduleId, buildRoot)) {
+                    return;
+                }
+
+                // Parse the source instead of reading `moduleInfo.ast`: Rolldown,
+                // the bundler Vite 8 uses by default, stubs that getter to throw
+                // `UNSUPPORTED: ModuleInfo#ast`. `code` is null for external and
+                // synthetic modules.
+                //
+                // `this.parse` is the bundler's own parser, which already parsed
+                // this exact source to compute `importedIds` — so whatever the
+                // bundler accepted parses here too, and no TypeScript-capable
+                // parser is needed (`moduleParsed` runs after `transform`, so
+                // types and JSX are already gone).
+                if (typeof moduleInfo.code !== 'string') {
+                    return;
+                }
+
+                const parsed = this.parse(moduleInfo.code);
                 const record = createParsedModuleRecord(
                     moduleId,
                     buildRoot,
-                    moduleInfo.ast as BaseNode,
+                    parsed,
                     getStaticDependencyIds(moduleInfo).map(normalizeViteModuleId),
                 );
                 if (!record) {

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

@@ -113,17 +113,24 @@ function mockBuildResult(code: string) {
 }
 
 function emitModuleParsed(
-    config: { plugins?: Array<{ moduleParsed?: (moduleInfo: unknown) => void }> },
+    config: {
+        plugins?: Array<{
+            moduleParsed?: (this: { parse: typeof parseAst }, moduleInfo: unknown) => void;
+        }>;
+    },
     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/index.test.ts

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