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` instead, using the plugin context's own `parse`.
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 must already have parsed this exact source to
compute `importedIds`, so anything it accepted, its own 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 would
    have 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` entirely, so it is
    unavailable to consumers of the plugin's CJS build.

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

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

Author: sdkennedy2

packages/plugins/apps/src/backend/ast-parsing/parse-module.test.ts

@@ -0,0 +1,43 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import { parseAst } from 'rollup/parseAst';
+
+import { parseBackendModule } from './parse-module';
+
+describe('Backend Functions - parseBackendModule', () => {
+    // `rollup/parseAst` is what Vite 5-7 re-exports as `parseAst`, so it is also
+    // the realistic injected parser here.
+    const cases = [
+        {
+            description: 'parse an ES module',
+            code: `import { a } from './a'; export const b = a;`,
+            expectedBodyTypes: ['ImportDeclaration', 'ExportNamedDeclaration'],
+        },
+        {
+            description: 'parse transpiled JSX, which arrives as plain calls',
+            code: `import { jsx as _jsx } from "react/jsx-runtime"; export const el = _jsx("div", {});`,
+            expectedBodyTypes: ['ImportDeclaration', 'ExportNamedDeclaration'],
+        },
+    ];
+
+    test.each(cases)('Should $description', ({ code, expectedBodyTypes }) => {
+        const program = parseBackendModule(parseAst, code, '/project/a.js');
+
+        expect(program.type).toBe('Program');
+        expect(program.body.map((node) => node.type)).toEqual(expectedBodyTypes);
+    });
+
+    test('Should surface the parser error when the source cannot be parsed', () => {
+        expect(() => parseBackendModule(parseAst, 'const = ;', '/project/broken.js')).toThrow();
+    });
+
+    test('Should reject parser output that is not a Program', () => {
+        const notAProgram = () => ({ type: 'ExpressionStatement' });
+
+        expect(() => parseBackendModule(notAProgram, 'a;', '/project/a.js')).toThrow(
+            'Expected a Program node for /project/a.js, got ExpressionStatement',
+        );
+    });
+});

packages/plugins/apps/src/backend/ast-parsing/parse-module.ts

@@ -0,0 +1,42 @@
+// Unless explicitly stated otherwise all files in this repository are licensed under the MIT License.
+// This product includes software developed at Datadog (https://www.datadoghq.com/).
+// Copyright 2019-Present Datadog, Inc.
+
+import type { Program } from 'estree';
+
+import { ensureProgram } from './type-guards';
+
+/**
+ * Parses a module's source into an ESTree `Program`.
+ *
+ * Structurally compatible with the plugin context's `parse`, which is what gets
+ * passed in. Declared here rather than imported from Rollup so this stays usable
+ * from the bundler-agnostic `backend/` layer, and so the same type covers
+ * Rollup's and Rolldown's separately-declared context types.
+ */
+export type ParseAst = (code: string) => unknown;
+
+/**
+ * Parses a backend module's source, instead of reading the bundler's
+ * `ModuleInfo#ast`.
+ *
+ * Rolldown — the bundler Vite 8 uses by default — stubs that getter to throw
+ * `UNSUPPORTED: ModuleInfo#ast`. Parsing `moduleInfo.code` instead means a
+ * bundler only has to supply the module's source and its resolved dependency
+ * IDs, neither of which Rolldown withholds.
+ *
+ * The parser is a parameter rather than a bundled dependency, and the collector
+ * supplies the plugin context's own `parse`. That keeps this correct by
+ * construction: the bundler must already have parsed this exact source to
+ * compute `importedIds`, so anything it accepted, its own parser accepts here.
+ * A third-party parser could disagree with the bundler; its own cannot.
+ *
+ * It also means no TypeScript-capable parser is needed. `moduleParsed` runs
+ * after `transform`, so types and JSX are already gone — verified on a real
+ * Vite 8 + Rolldown build, where `'x' as string` arrives as `"x"` and `<div/>`
+ * arrives as a `_jsx(...)` call.
+ */
+export function parseBackendModule(parseAst: ParseAst, code: string, moduleId: string): Program {
+    const program = parseAst(code);
+    return ensureProgram(program, moduleId);
+}

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

@@ -13,17 +13,29 @@ interface TypeScriptImportExportMetadata {
 
 type TypeOnlyAwareNode = BaseNode & TypeScriptImportExportMetadata;
 
-export function ensureProgram(node: BaseNode, filePath: string): Program {
+/**
+ * Accepts `unknown` rather than `BaseNode` so it can also narrow the output of
+ * parsers whose node types are declared separately from `estree` (the
+ * TypeScript-ESTree `Program` is structurally an `estree` `Program`, but is not
+ * the same declared type). The runtime check is what 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

@@ -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,
+            },
+        );
     }
 }