Remove discoverBackendFiles, flatten BackendFunctionRef into BackendFunction

Author: sdkennedy2

packages/plugins/apps/src/backend/discovery.test.ts

@@ -2,17 +2,8 @@
 // This product includes software developed at Datadog (https://www.datadoghq.com/).
 // Copyright 2019-Present Datadog, Inc.
 
-import { discoverBackendFiles, extractExportedFunctions } from '@dd/apps-plugin/backend/discovery';
-import { getMockLogger } from '@dd/tests/_jest/helpers/mocks';
+import { extractExportedFunctions } from '@dd/apps-plugin/backend/discovery';
 import type { Program } from 'estree';
-import { globSync } from 'glob';
-
-jest.mock('glob');
-
-const log = getMockLogger();
-const projectRoot = '/project';
-
-const mockedGlobSync = jest.mocked(globSync);
 
 /**
  * Helper to build a minimal ESTree Program node for testing.
@@ -156,55 +147,3 @@ describe('Backend Functions - extractExportedFunctions', () => {
         );
     });
 });
-
-describe('Backend Functions - discoverBackendFiles', () => {
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    test('Should discover .backend.ts files via glob', () => {
-        mockedGlobSync.mockReturnValue([
-            '/project/src/utils/mathUtils.backend.ts',
-            '/project/src/auth/login.backend.ts',
-        ] as any);
-
-        const result = discoverBackendFiles(projectRoot, log);
-
-        expect(result).toEqual([
-            {
-                absolutePath: '/project/src/utils/mathUtils.backend.ts',
-                refPath: 'src/utils/mathUtils',
-            },
-            {
-                absolutePath: '/project/src/auth/login.backend.ts',
-                refPath: 'src/auth/login',
-            },
-        ]);
-    });
-
-    test('Should return empty array when no .backend.ts files exist', () => {
-        mockedGlobSync.mockReturnValue([]);
-
-        const result = discoverBackendFiles(projectRoot, log);
-        expect(result).toEqual([]);
-    });
-
-    test('Should strip .backend.{ext} to form the ref path', () => {
-        mockedGlobSync.mockReturnValue(['/project/mathUtils.backend.tsx'] as any);
-
-        const result = discoverBackendFiles(projectRoot, log);
-        expect(result[0].refPath).toBe('mathUtils');
-    });
-
-    test('Should call globSync with correct pattern and options', () => {
-        mockedGlobSync.mockReturnValue([]);
-
-        discoverBackendFiles(projectRoot, log);
-
-        expect(mockedGlobSync).toHaveBeenCalledWith('**/*.backend.{ts,tsx,js,jsx}', {
-            cwd: projectRoot,
-            ignore: ['**/node_modules/**', '**/dist/**', '**/.dist/**'],
-            absolute: true,
-        });
-    });
-});

packages/plugins/apps/src/backend/discovery.ts

@@ -5,40 +5,26 @@
 import type { Logger } from '@dd/core/types';
 import { createHash } from 'crypto';
 import type { Declaration, Identifier, Program } from 'estree';
-import { globSync } from 'glob';
-import path from 'path';
 import type { AstNode } from 'rollup';
 
-export interface BackendFunctionRef {
+export interface BackendFunction {
     /** Relative path from project root to the .backend.ts file (without extension) */
     path: string;
     /** Exported function name */
     name: string;
-}
-
-export interface BackendFunction {
-    /** The BackendFunctionRef identifying this function */
-    ref: BackendFunctionRef;
     /** Absolute path to the .backend.ts source file */
     entryPath: string;
 }
 
-export interface BackendFileInfo {
-    /** Absolute path to the .backend.ts source file */
-    absolutePath: string;
-    /** Relative path from project root, with .backend.{ext} stripped (used as BackendFunctionRef.path) */
-    refPath: string;
-}
-
 /**
- * Encode a BackendFunctionRef into an opaque query name string.
+ * Encode a BackendFunction into an opaque query name string.
  * Uses the full SHA-256 hash of the path so that backend file structure
  * is never leaked into frontend assets.
  *
  * This is the single source of truth for query name encoding — used by
  * proxy codegen, the production build, and the dev server.
  */
-export function encodeQueryName(ref: BackendFunctionRef): string {
+export function encodeQueryName(ref: Pick<BackendFunction, 'path' | 'name'>): string {
     const pathHash = createHash('sha256').update(ref.path).digest('hex');
     return `${pathHash}.${ref.name}`;
 }
@@ -135,38 +121,3 @@ function namesFromDeclaration(decl: Declaration): string[] {
     }
     return [];
 }
-
-/**
- * Discover backend files by scanning for `*.backend.{ts,tsx,js,jsx}` files
- * anywhere in the project (excluding node_modules, dist, etc.).
- *
- * Returns file info only — no export parsing. Exports are discovered lazily
- * during the `transform` hook when Vite has already stripped TypeScript types.
- *
- * Must be sync because it runs in getPlugins() before the build starts.
- */
-export function discoverBackendFiles(projectRoot: string, log: Logger): BackendFileInfo[] {
-    const pattern = '**/*.backend.{ts,tsx,js,jsx}';
-    const files = globSync(pattern, {
-        cwd: projectRoot,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/.dist/**'],
-        absolute: true,
-    });
-
-    if (files.length === 0) {
-        log.debug(`No .backend.ts files found in ${projectRoot}`);
-        return [];
-    }
-
-    const result: BackendFileInfo[] = [];
-    for (const absolutePath of files) {
-        const relativePath = path.relative(projectRoot, absolutePath);
-        const refPath = relativePath.replace(/\.backend\.\w+$/, '');
-        result.push({ absolutePath, refPath });
-    }
-
-    log.debug(
-        `Discovered ${result.length} backend file(s): ${result.map((f) => f.refPath).join(', ')}`,
-    );
-    return result;
-}

packages/plugins/apps/src/index.ts

@@ -10,7 +10,7 @@ import { createArchive } from './archive';
 import type { Asset } from './assets';
 import { collectAssets } from './assets';
 import type { BackendFunction } from './backend/discovery';
-import { discoverBackendFiles, encodeQueryName, parseExportNames } from './backend/discovery';
+import { encodeQueryName, parseExportNames } from './backend/discovery';
 import { CONFIG_KEY, PLUGIN_NAME } from './constants';
 import { resolveIdentifier } from './identifier';
 import type { AppsOptions } from './types';
@@ -37,9 +37,9 @@ function buildProxyModule(
     const proxyExports: Array<{ exportName: string; queryName: string }> = [];
 
     for (const exportName of exportNames) {
-        const ref = { path: refPath, name: exportName };
-        functions.push({ ref, entryPath: id });
-        proxyExports.push({ exportName, queryName: encodeQueryName(ref) });
+        const func = { path: refPath, name: exportName, entryPath: id };
+        functions.push(func);
+        proxyExports.push({ exportName, queryName: encodeQueryName(func) });
     }
 
     return { functions, proxyCode: generateProxyModule(proxyExports) };
@@ -63,11 +63,7 @@ export const getPlugins: GetPlugins = ({ options, context, bundler }) => {
         return [];
     }
 
-    // Discover backend files (sync — must run before build starts).
-    // Only globs for file paths; exports are discovered lazily during transform.
-    const backendFiles = discoverBackendFiles(context.buildRoot, log);
     const backendOutputs = new Map<string, string>();
-    const hasBackend = backendFiles.length > 0;
 
     // Mutable array populated during transforms as .backend.ts files are processed.
     const backendFunctions: BackendFunction[] = [];
@@ -106,17 +102,18 @@ Either:
 
             // Exclude backend output files from frontend assets if backend is active.
             const backendPaths = new Set(backendOutputs.values());
-            const frontendOnly = hasBackend
-                ? assets.filter((a) => !backendPaths.has(a.absolutePath))
-                : assets;
+            const frontendOnly =
+                backendOutputs.size > 0
+                    ? assets.filter((a) => !backendPaths.has(a.absolutePath))
+                    : assets;
 
             // Prefix all frontend assets with frontend/.
             const allAssets: Asset[] = frontendOnly.map((asset) => ({
                 ...asset,
                 relativePath: `frontend/${asset.relativePath}`,
             }));
 
-            if (hasBackend) {
+            if (backendOutputs.size > 0) {
                 // Build backend assets from the outputs map populated during the build.
                 // Keys are encoded query names ({hash(path)}.{name}).
                 for (const [bundleName, absolutePath] of backendOutputs) {

packages/plugins/apps/src/vite/build-backend-functions.ts

@@ -37,13 +37,9 @@ export async function buildBackendFunctions(
     // Build each function individually so that each output is a single
     // self-contained JS file
     for (const func of functions) {
-        const bundleName = encodeQueryName(func.ref);
+        const bundleName = encodeQueryName(func);
         const virtualId = `${VIRTUAL_PREFIX}${bundleName}`;
-        const virtualContent = generateVirtualEntryContent(
-            func.ref.name,
-            func.entryPath,
-            buildRoot,
-        );
+        const virtualContent = generateVirtualEntryContent(func.name, func.entryPath, buildRoot);
 
         const baseConfig = getBaseBackendBuildConfig(buildRoot, { [virtualId]: virtualContent });
 

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

@@ -17,11 +17,13 @@ const DD_SITE = 'datadoghq.com';
 
 const mockFunctions: BackendFunction[] = [
     {
-        ref: { path: 'backend/greet', name: 'greet' },
+        path: 'backend/greet',
+        name: 'greet',
         entryPath: '/project/backend/greet.backend.ts',
     },
     {
-        ref: { path: 'backend/compute', name: 'compute' },
+        path: 'backend/compute',
+        name: 'compute',
         entryPath: '/project/backend/compute.backend.ts',
     },
 ];
@@ -127,7 +129,7 @@ describe('Dev Server Middleware', () => {
             mockViteBuild.mockResolvedValue(mockBuildResult('// bundled code'));
 
             const req = createMockRequest('/__dd/debugBundle', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
             });
             const res = createMockResponse();
             const next = jest.fn();
@@ -159,7 +161,7 @@ describe('Dev Server Middleware', () => {
                 });
 
             const req = createMockRequest('/__dd/executeAction', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
                 args: ['world'],
             });
             const res = createMockResponse();
@@ -215,7 +217,7 @@ describe('Dev Server Middleware', () => {
             mockViteBuild.mockResolvedValue(mockBuildResult('export function main($) {}'));
 
             const req = createMockRequest('/__dd/debugBundle', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
             });
             const res = createMockResponse();
 
@@ -231,7 +233,7 @@ describe('Dev Server Middleware', () => {
             mockViteBuild.mockResolvedValue(mockBuildResult('// code'));
 
             const req = createMockRequest('/__dd/debugBundle', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
                 args: [1, 2],
             });
             const res = createMockResponse();
@@ -301,7 +303,7 @@ describe('Dev Server Middleware', () => {
                 .reply(403, 'Forbidden');
 
             const req = createMockRequest('/__dd/executeAction', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
                 args: [],
             });
             const res = createMockResponse();
@@ -332,7 +334,7 @@ describe('Dev Server Middleware', () => {
                 });
 
             const req = createMockRequest('/__dd/executeAction', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
                 args: [],
             });
             const res = createMockResponse();
@@ -359,7 +361,7 @@ describe('Dev Server Middleware', () => {
                 });
 
             const req = createMockRequest('/__dd/executeAction', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
                 args: [],
             });
             const res = createMockResponse();
@@ -387,7 +389,7 @@ describe('Dev Server Middleware', () => {
                 });
 
             const req = createMockRequest('/__dd/executeAction', {
-                functionName: encodeQueryName(mockFunctions[0].ref),
+                functionName: encodeQueryName(mockFunctions[0]),
                 args: [],
             });
             const res = createMockResponse();

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

@@ -37,7 +37,7 @@ type AuthConfig = Required<AuthOptionsWithDefaults>;
  * Format a BackendFunction for display in log/error messages.
  */
 function formatRef(func: BackendFunction): string {
-    return `${func.ref.path}/${func.ref.name}`;
+    return `${func.path}/${func.name}`;
 }
 
 /**
@@ -74,7 +74,7 @@ async function bundleBackendFunction(
     const displayName = formatRef(func);
     const virtualId = `${DEV_VIRTUAL_PREFIX}${displayName}`;
     const virtualContent = generateDevVirtualEntryContent(
-        func.ref.name,
+        func.name,
         func.entryPath,
         args,
         projectRoot,
@@ -323,7 +323,7 @@ async function handleExecuteAction(
  * as the browser requests modules — the array grows over time.
  */
 function buildFunctionMap(backendFunctions: BackendFunction[]): Map<string, BackendFunction> {
-    return new Map(backendFunctions.map((f) => [encodeQueryName(f.ref), f]));
+    return new Map(backendFunctions.map((f) => [encodeQueryName(f), f]));
 }
 
 /**

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

@@ -12,17 +12,19 @@ const log = getMockLogger();
 
 const functions: BackendFunction[] = [
     {
-        ref: { path: 'src/backend/myHandler', name: 'myHandler' },
+        path: 'src/backend/myHandler',
+        name: 'myHandler',
         entryPath: '/src/backend/myHandler.backend.ts',
     },
     {
-        ref: { path: 'src/backend/otherFunc', name: 'otherFunc' },
+        path: 'src/backend/otherFunc',
+        name: 'otherFunc',
         entryPath: '/src/backend/otherFunc.backend.ts',
     },
 ];
 
-const bundleName1 = encodeQueryName(functions[0].ref);
-const bundleName2 = encodeQueryName(functions[1].ref);
+const bundleName1 = encodeQueryName(functions[0]);
+const bundleName2 = encodeQueryName(functions[1]);
 
 const mockViteBuild = jest.fn().mockResolvedValue({
     output: [

packages/plugins/apps/src/vite/proxy-codegen.ts

@@ -14,7 +14,7 @@ interface ProxyExport {
  * is replaced with a wrapper that calls `executeBackendFunction` with the
  * pre-computed query name string.
  *
- * The raw BackendFunctionRef (file path) is never present in the generated
+ * The raw backend file path is never present in the generated
  * code — only the hashed query name appears, preventing backend file
  * structure from leaking into frontend bundles.
  *