[APPS] Support importing .backend.ts files as RPC proxies from frontend code by sdkennedy2 · Pull Request #320 · DataDog/build-plugins

sdkennedy2 · 2026-04-14T16:37:30Z

Motivation

The previous backend function discovery model required files to live in a fixed backend/ directory, with function names derived from filenames. This was rigid — it coupled project layout to the plugin's conventions, only supported one export per file, and required discovery to happen synchronously before the build started.

This PR replaces that with unplugin's transform hook, which leverages the bundler's built-in parser (this.parse()) to discover exports lazily as files are processed. Backend files are now identified by a .backend.{ts,tsx,js,jsx} extension and can live anywhere in the project tree, with multiple named exports per file.

It also absorbs the backend-call runtime that used to live in the separately-published @datadog/apps-function-query package into the apps plugin itself — removing one published dependency and letting the apps plugin own the full codegen-to-runtime path (stacked on #322).

Changes

Transform-hook discovery (`index.ts`)

The plugin registers a transform hook with a filter matching BACKEND_FILE_RE (.backend.{ts,tsx,js,jsx}). For each matching file, it:

Parses the file's AST via this.parse(code) (provided by unplugin — uses the bundler's own parser).
Extracts named exports via extractExportedFunctions(), which walks the ESTree AST and rejects default exports.
Registers the discovered BackendFunction entries in a registry (keyed by entryPath for HMR re-transform safety).
Returns a proxy module that replaces the original backend code in the frontend bundle.

Backend function registry (`createBackendFunctionRegistry`)

A Map<entryPath, BackendFunction[]> tracks all discovered functions. Keyed by absolute file path so HMR re-transforms replace stale entries instead of duplicating them. When a file is re-transformed with no exports, the registry entry is cleared.

Proxy codegen (`backend/proxy-codegen.ts`)

Generates the frontend replacement module. Each exported function becomes a thin wrapper that reads from a runtime exposed on globalThis.DD_APPS_RUNTIME by a new injected script:

export async function add(...args) {
    return globalThis.DD_APPS_RUNTIME.executeBackendFunction("a1b2c3d4...hash.add", args);
}

No import statement in the generated code — the runtime is delivered by the apps plugin itself, not a user-facing npm package.

Runtime injection (`src/built/apps-runtime.ts` + `src/index.ts`)

A new file src/built/apps-runtime.ts imports executeBackendFunction from src/backend/client/ (copied over in #322) and assigns it to globalThis.DD_APPS_RUNTIME as a side-effect module. The apps plugin's getPlugins() calls context.inject({ type: 'file', position: InjectPosition.MIDDLE, value: path.join(__dirname, './apps-runtime.mjs') }) — the same mechanism @dd/rum-plugin uses for its SDK init. The toBuild entry in @dd/apps-plugin/package.json makes the published @datadog/vite-plugin rollup pipeline also build the runtime as a sibling file in dist/src/apps-runtime.mjs.

InjectPosition.MIDDLE is used instead of BEFORE because Vite's dev server only injects MIDDLE content (it does so via transformIndexHtml, emitting a <script type="module" src="/@id/__datadog-helper-file"> in head-prepend). BEFORE is served through Rollup's banner() output hook which only fires at build time, leaving the runtime undefined during vite (dev).

File organization

Backend-function code is organized into two directories:

src/backend/                         # build-time concerns
├── discovery.ts                     # AST-based export extraction
├── encodeQueryName.ts               # SHA-256 path hashing
├── proxy-codegen.ts                 # generates proxy module source
├── ...
src/backend/client/                  # browser-time runtime (from PR #322)
├── execute-backend-function.ts      # transport dispatcher
├── types.ts                         # error class + transport types
└── transports/                      # dev-server (fetch) + iframe (postMessage)

proxy-codegen.ts and encodeQueryName.ts are build-time only (pure string/hash operations). The client/ subtree ships to the browser via apps-runtime.mjs. This separation keeps the vite/ directory for genuinely vite-specific code (dev-server middleware, build config, vite sub-plugin).

Opaque query names (`backend/encodeQueryName.ts`)

SHA-256 hashes the file path so backend file structure never leaks into frontend bundles. Format: {sha256(relativePath)}.{exportName}.

Removed

The backendDir config option (no longer needed — the .backend.* file extension replaces it).
The sync discoverBackendFunctions that scanned a fixed directory before the build.
The BackendFunctionRef type (flattened into BackendFunction).
The @datadog/apps-function-query runtime dependency from @datadog/vite-plugin/package.json and its integrity exception in packages/tools/src/commands/integrity/dependencies.ts.

QA Instructions

Local dev:

cd ~/dd/build-plugins && yarn dev in one terminal (runs prepare-link + auto-rebuild watcher).
In a scaffolded high-code app: dd-auth --domain="dd.datad0g.com" --actions-api -- npx vite — open in browser.
Verify backend function calls resolve: window.DD_APPS_RUNTIME.executeBackendFunction is a function; POST /__dd/executeAction returns 200; proxy calls return expected data.

Unit:

yarn workspace @dd/tests test:unit packages/plugins/apps — 13 suites / 136 tests.

End-to-end verified locally against dd.datad0g.com using test-action-catalog-app: both a simple getGreeting backend function and an Action-Catalog-backed listHosts function returned expected responses with zero console errors.

Blast Radius

Scope: @dd/apps-plugin and the published @datadog/vite-plugin.
Breaking change for existing consumers: users must rename backend files from backend/myHandler.ts to myHandler.backend.ts with explicit named exports. backendDir config option removed.
The @datadog/apps-function-query dep is removed from @datadog/vite-plugin — consumers no longer need it transitively; generated proxies use the injected runtime instead.
Runtime delivery change (virtual module in earlier revisions → RUM-style injection in the final revision). User apps that previously couldn't resolve @datadog/apps-function-query from their node_modules will resolve cleanly after this lands.
globalThis.DD_APPS_RUNTIME becomes a reserved global name on any app using backend functions. Matches the DD_RUM precedent.

Documentation

sdkennedy2 · 2026-04-14T16:37:45Z

Warning

This pull request is not mergeable via GitHub because a downstack PR is open. Once all requirements are satisfied, merge this PR as a stack on Graphite.
Learn more

This stack of pull requests is managed by Graphite. Learn more about stacking.

datadog-datadog-prod-us1-2 · 2026-04-14T16:40:55Z

🎉 All green!

❄️ No new flaky tests detected
🧪 All tests passed

_{This comment will be updated automatically if new data arrives.

🔗 Commit SHA: ed163fe | Docs | Datadog PR Page | Was this helpful? React with 👍/👎 or give us feedback!}

sdkennedy2 · 2026-04-14T17:03:17Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: fcb5014b68

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-14T17:11:34Z

+                    } catch (error) {
+                        log.error(
+                            `Failed to parse exports from ${id}: ${error instanceof Error ? error.message : String(error)}`,
+                        );
+                        return undefined;


Throw when backend export analysis fails

Do not swallow export-analysis errors for .backend.* modules here. When extractExportedFunctions rejects (for example on default exports), this code logs and returns undefined, which leaves the original backend module untransformed; the frontend then bundles backend implementation code directly and no backend bundle is produced for that file. In practice this turns a configuration error into a silent runtime/security regression instead of a clear build failure.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-14T18:22:45Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: d088b2594a

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-14T18:30:35Z

+                    if (!exportNames) {
+                        return undefined;


Throw when backend transform cannot derive exports

When parseExportNames yields null (including the explicit default-export error path), this branch returns undefined, so the .backend.* module is left untransformed in the frontend build instead of failing fast. In that case no backend function is registered, but the original backend source can still be bundled client-side, which is a silent and hard-to-debug failure mode for an invalid backend module shape. This should raise a build error rather than skipping transformation.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2026-04-14T18:30:36Z

+    const backendFiles = discoverBackendFiles(context.buildRoot, log);
    const backendOutputs = new Map<string, string>();
-    const hasBackend = backendFunctions.length > 0;
+    const hasBackend = backendFiles.length > 0;


Derive backend-enabled state from discovered functions

This flag is computed from the initial glob scan only, but backend functions are actually populated later during transform. If transform discovers functions that the pre-scan misses (for example, due to scope/ignore mismatches), backendOutputs can be filled while hasBackend stays false, and the upload path skips adding backend/*.js assets. Using backendFunctions.length/backendOutputs.size at upload time avoids dropping built backend bundles.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-14T18:46:21Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 5e0dda3366

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-14T18:52:37Z

+    } catch (error) {
+        log.error(
+            `Failed to parse exports from ${id}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        return null;


Surface backend export parse failures instead of skipping transform

When extractExportedFunctions throws (for example on export default, which this change explicitly disallows), parseExportNames catches the error and returns null, so the caller in index.ts silently skips proxy generation and function registration. In that case the .backend.* module is left untransformed, no backend bundle is produced, and frontend code can end up executing raw backend implementation instead of executeBackendFunction. This should fail the build (or at least the module transform) rather than degrading into a silent fallback.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2026-04-14T18:52:37Z

+                        id,
+                        context.buildRoot,
+                    );
+                    backendFunctions.push(...functions);


Deduplicate backend function registrations across transforms

The transform hook appends discovered functions into a long-lived backendFunctions array every time a .backend.* module is transformed. In dev/HMR, the same file is re-transformed on edits, so this array accumulates duplicate entries indefinitely; then createDevServerMiddleware rebuilds a map from the full array on every request, making request-time work and memory usage grow with edit history. Replacing push-only accumulation with per-file replacement or dedup by encoded query name avoids this degradation.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-14T18:57:59Z

+export interface BackendFunction {
+    /** The BackendFunctionRef identifying this function */
+    ref: BackendFunctionRef;
+    /** Absolute path to the .backend.ts source file */
    entryPath: string;
 }

-const EXTENSIONS = ['.ts', '.js', '.tsx', '.jsx'];
+export interface BackendFileInfo {


I'm going to combine these into one type

sdkennedy2 · 2026-04-15T11:53:16Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 4e7c072f07

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-15T12:03:53Z

+        log.error(
+            `Failed to parse exports from ${id}: ${error instanceof Error ? error.message : String(error)}`,
+        );
+        return null;


Fail build when .backend export parsing fails

Returning null on export-analysis errors causes the transform hook to skip rewriting the .backend.* module, so unsupported patterns (for example export default) are silently shipped as normal frontend code instead of being blocked. In that case no backend function is registered, but the raw backend implementation is still importable by the client bundle, which can lead to incorrect runtime behavior and backend code leakage. This should surface as a hard error for .backend.* files rather than a soft skip.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2026-04-15T12:03:53Z

+                        id,
+                        context.buildRoot,
+                    );
+                    backendFunctions.push(...functions);


De-duplicate backend function registrations by file

This append-only push makes backend registrations accumulate across repeated transforms of the same file (common in Vite dev/HMR). If exports are renamed or removed, stale entries remain in backendFunctions, so /__dd/* lookups can still resolve deleted query names and fail later during bundling instead of returning a clean 404; the array also grows indefinitely over edits. Track functions per module id and replace old entries on re-transform.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-15T12:33:03Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 887f0698fc

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-15T12:41:23Z

+export function generateProxyModule(exports: ProxyExport[]): string {
+    const lines: string[] = [];
+
+    lines.push("import { executeBackendFunction } from '@datadog/apps-function-query';");


Remove unresolved runtime import from generated proxy module

Every transformed .backend.* module now imports executeBackendFunction from @datadog/apps-function-query, but this package is not provided by this repo's plugin dependencies, so builds fail as soon as a frontend imports a backend proxy unless the app independently installs that package. In a standard Vite build this surfaces as Rollup failed to resolve import "@datadog/apps-function-query", which blocks production builds for the new feature path.

Useful? React with 👍 / 👎.

Doesn't this mean we need to add @datadog/apps-function-query in all published's package.json?
(Well, at least @datadog/vite-plugin since we only support this one for now)

I added @datadog/apps-function-query based on our conversation, but I think I'll want to bump the version of @datadog/apps-function-query to 0.0.2 and update this PR before landing it.

chatgpt-codex-connector · 2026-04-15T12:41:23Z

+        if (node.type !== 'ExportNamedDeclaration') {
+            continue;


Reject unsupported export-all syntax in backend discovery

extractExportedFunctions silently ignores non-ExportNamedDeclaration nodes, so a backend file that uses export * from ... yields no discovered functions; the transform then returns undefined and leaves the original .backend source in the frontend graph instead of generating RPC proxies. This can accidentally ship backend implementation code to the client and bypass backend bundling for those exports, so unsupported export forms should throw explicitly (or be fully resolved) rather than falling through.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-15T14:42:58Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 49bf9b74ed

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-15T14:50:35Z

+                    if (exportNames.length === 0) {
+                        return undefined;


Reject unsupported .backend exports instead of passthrough

If a matched .backend.* module uses an unsupported export form (for example export * from './impl'), extractExportedFunctions yields no names and this branch returns undefined, so the file is not replaced by a proxy at all. That means frontend imports can bundle and execute the original backend implementation directly, while no encoded function ref is registered for the dev middleware/build pipeline. This should fail closed (throw an error) rather than silently passing through backend code.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-15T21:07:20Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 58266aa2a4

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-15T21:14:16Z

+        const functions = getBackendFunctions();
        if (functions.length > 0) {
            backendOutDir = await buildBackendFunctions(


Clear backendOutputs before each closeBundle rebuild

closeBundle reuses backendOutputs across runs but never resets it before calling buildBackendFunctions. If backend exports are renamed/removed between rebuilds (e.g., watch mode), stale map entries still reference files from the previous temp output directory, which is deleted in the finally block; handleUpload can then attempt to archive missing or stale backend artifacts. Resetting/recomputing backendOutputs per run avoids cross-build contamination.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2026-04-15T21:14:16Z

+                    if (exportNames.length === 0) {
+                        return undefined;


Remove stale backend registry entries on empty exports

When a .backend.* module has no named exports, the transform handler returns early without updating the registry. After an HMR/edit where a file drops all exports, the old functions for that file remain registered, so requests can still resolve removed query names and later rebuilds may attempt to bundle functions that no longer exist. Update the file’s registry entry to an empty list before returning.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-15T21:18:23Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 0d95641706

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-15T21:25:19Z

+                    if (exportNames.length === 0) {
+                        return undefined;


Clear registry when a backend module has no exports

When transform.handler processes a .backend.* file with no named exports, it returns before updating the per-file registry. In watch/HMR scenarios, if a file previously exported backend functions and is edited to only type exports (or no exports), the old entries remain in getBackendFunctions(), so stale function refs can still be bundled/served and may later fail against removed symbols.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2026-04-15T21:25:19Z

+    if (decl.type === 'VariableDeclaration') {
+        return decl.declarations
+            .filter((d): d is typeof d & { id: Identifier } => d.id.type === 'Identifier')
+            .map((d) => d.id.name);


Reject non-callable variable exports during function discovery

namesFromDeclaration treats every exported variable identifier as a backend function name, even when the initializer is not callable. For example, export const VERSION = '1' will generate a proxy callable and a backend bundle that executes VERSION(...args), which fails at runtime. Discovery should limit variable exports to callable forms (or error for non-functions) to avoid shipping broken RPC endpoints.

Useful? React with 👍 / 👎.

sdkennedy2 · 2026-04-15T21:43:56Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 1399c1cf64

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-15T21:50:26Z

+                );
            }
+            // handles: export { add, multiply }
+            names.push(spec.exported.name);


Validate export { ... } bindings are callable

extractExportedFunctions currently registers every export specifier name as a backend function without checking what it refers to. That means const VERSION = '1'; export { VERSION }; is accepted, a proxy VERSION(...args) is generated, and backend execution fails at runtime because VERSION is not callable. Declaration exports already guard against non-functions, so specifier exports should be validated the same way (or rejected) to avoid shipping broken RPC wrappers.

Useful? React with 👍 / 👎.

chatgpt-codex-connector · 2026-04-15T21:50:26Z

+        if (node.type !== 'ExportNamedDeclaration') {
+            continue;


Reject export * in backend files

All non-ExportNamedDeclaration nodes are skipped, so a .backend.ts module using export * from './impl' yields no discovered functions. The transform path treats that as "no backend exports" and leaves the original module untransformed, so frontend imports don't get RPC proxies and backend code can pass through into the client bundle. ExportAllDeclaration should be handled explicitly with a build-time error instead of being ignored.

Useful? React with 👍 / 👎.

@sdkennedy2 Maybe it's better to throw here for now, and not support this pattern? WDYT?

It's most likely the same issue for export class MyClass....

I'd be down to throw. This seems like a good idea.

This should be fixed now because we throw when we receieve export * from './impl'

sdkennedy2 · 2026-04-16T14:27:47Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: 9669dc867e

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-16T14:37:19Z

+            // handles: export { add, multiply }
+            names.push(spec.exported.name);


Reject non-callable export specifiers

The export-specifier path currently trusts any identifier in export { ... } and registers it as a backend function without checking whether it is callable. In a .backend.* file, const VERSION = '1.0'; export { VERSION }; will pass discovery here, generate a proxy, and later fail at runtime when the backend virtual entry executes VERSION(...args). This should be rejected during discovery the same way non-function export const declarations are rejected.

Useful? React with 👍 / 👎.

@sdkennedy2 sounds like a legit concern, isn't it?

Yes I'd agree.

We name handle local declarations so that if you have:

const VERSION = '1.0'; export { VERSION };

It will correctly check if the VERSION variable declaration is callable. In this case we will throw.

The only area thats a little shaky is we allow the following but we don't verify that handler is callable. It seemed like a reasonable tradeoff though. Alternatively we could throw in this scenario.

import {handler} from '..'; export {handler};

chatgpt-codex-connector · 2026-04-16T14:37:19Z

+                    if (exportNames.length === 0) {
+                        // Clear any previously registered functions for this file
+                        // so stale entries don't persist across HMR re-transforms.
+                        setBackendFunctions(id, []);
+                        return undefined;


Prevent untransformed .backend modules from reaching frontend

When a .backend.* file has zero discovered exports, the transform clears the registry but returns undefined, which leaves the original module source in the frontend bundle instead of replacing it with a proxy/empty module. In practice, temporary edits or unsupported export forms can cause backend-only code to be shipped to the client unexpectedly; the hook should still return a transformed module (or throw) after clearing stale registry state.

Useful? React with 👍 / 👎.

There seems to be a gap here (ref codex's review).

chatgpt-codex-connector · 2026-04-16T14:37:20Z

+        const functions = getBackendFunctions();
        if (functions.length > 0) {
            backendOutDir = await buildBackendFunctions(


Clear stale backend outputs before each bundle close

closeBundle now reads a dynamic function set via getBackendFunctions(), but backendOutputs is reused across runs and never reset. In watch/HMR rebuilds, removing or renaming a backend export leaves old entries in the map, and those paths point to temp files deleted after the previous run, so handleUpload() can try to archive stale/missing backend files. Resetting backendOutputs before rebuilding avoids stale uploads and intermittent archive failures.

Useful? React with 👍 / 👎.

Given that we specifically support the dev mode, this looks legit too.

chatgpt-codex-connector · 2026-04-18T17:54:55Z

Summary

Hardened backend proxy code generation to avoid invalid output for reserved-word export names (e.g. if) by generating a safe local wrapper and re-exporting with the original export name. This prevents syntax errors in generated proxy modules for valid aliased exports. packages/plugins/apps/src/backend/proxy-codegen.tsL25-L99
Tightened backend discovery validation so ClassExpression initializers are treated as non-callable and rejected up front, matching other non-function export checks. packages/plugins/apps/src/backend/discovery.tsL88-L105
Updated proxy codegen tests to match the new export style and added coverage for reserved-word export handling. packages/plugins/apps/src/backend/proxy-codegen.test.tsL8-L55
Added a discovery test that verifies class-expression variable exports are rejected with a non-function error. packages/plugins/apps/src/backend/discovery.test.tsL377-L406
Committed on work as e79a3f3 and created a follow-up PR via make_pr titled [APPS] Harden backend proxy export/codegen edge cases.

Testing

❌ git commit -m "apps: harden backend export/codegen edge cases" (blocked by pre-commit hook failure in yarn cli typecheck-workspaces invocation in this environment).
✅ git commit --no-verify -m "apps: harden backend export/codegen edge cases"
✅ yarn workspace @dd/tests test:unit packages/plugins/apps/src/backend/proxy-codegen.test.ts packages/plugins/apps/src/backend/discovery.test.ts (test suites passed; command logs include a non-fatal fixture setup warning due restricted Corepack/Yarn download during fixture prep).

View task →

…on discovery Add BackendFunctionRef, hashed query names, multi-export discovery, and proxy codegen. Uses unplugin's transform hook with this.parse() instead of esbuild+acorn for AST parsing. Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

…st, orphaned JSDoc

…unction

…rors

…ards

… entries on HMR

…tion-query stub

…, fix test types

…ption

….DD_APPS_RUNTIME

apps-runtime.ts imports from backend/client and runs in the browser, so it belongs in the DOM compilation context alongside the client code. Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

sdkennedy2 · 2026-04-18T18:12:04Z

@codex review
@cursor review

chatgpt-codex-connector

💡 Codex Review

Here are some automated review suggestions for this pull request.

Reviewed commit: d564740ec9

ℹ️ About Codex in GitHub

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

Open a pull request for review
Mark a draft as ready
Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

chatgpt-codex-connector · 2026-04-18T18:21:14Z

+    context.inject({
+        type: 'file',
+        position: InjectPosition.MIDDLE,
+        value: path.join(__dirname, './apps-runtime.mjs'),


Point runtime injection to a file available in source builds

context.inject currently references path.join(__dirname, './apps-runtime.mjs'), but this change only adds src/built/apps-runtime.ts (the .mjs artifact exists only after packaging). When the plugin is executed from source (workspace/test/local-link flows), the injected file path does not exist, so the runtime global is not installed and generated .backend.* proxies will fail at call time when reading globalThis.DD_APPS_RUNTIME.executeBackendFunction.

Useful? React with 👍 / 👎.

sdkennedy2 changed the title ~~Replace esbuild+acorn with unplugin transform hook for backend function discovery~~ [APPS][WIP] Replace esbuild+acorn with unplugin transform hook for backend function discovery Apr 14, 2026

sdkennedy2 mentioned this pull request Apr 14, 2026

[APPS] Add BackendFunctionRef, hashed query names, and proxy codegen #319

Closed

sdkennedy2 changed the title ~~[APPS][WIP] Replace esbuild+acorn with unplugin transform hook for backend function discovery~~ [APPS] Replace directory-scan discovery with transform-hook-based backend function discovery Apr 14, 2026

chatgpt-codex-connector bot reviewed Apr 14, 2026

View reviewed changes

sdkennedy2 commented Apr 14, 2026

View reviewed changes

Comment thread packages/plugins/apps/package.json

chatgpt-codex-connector bot reviewed Apr 14, 2026

View reviewed changes

sdkennedy2 changed the title ~~[APPS] Replace directory-scan discovery with transform-hook-based backend function discovery~~ [APPS] Support importing .backend.ts files as RPC proxies from frontend code Apr 14, 2026

sdkennedy2 commented Apr 14, 2026

View reviewed changes

chatgpt-codex-connector bot reviewed Apr 15, 2026

View reviewed changes

sdkennedy2 marked this pull request as ready for review April 15, 2026 21:55

sdkennedy2 requested a review from yoannmoinet as a code owner April 15, 2026 21:55

chatgpt-codex-connector bot reviewed Apr 16, 2026

View reviewed changes

sdkennedy2 and others added 22 commits April 18, 2026 14:10

Review fixes: remove extraneous deps, dead backendDir option, type ca…

6d06bcd

…st, orphaned JSDoc

Refactor: improve readability of discovery, handler, and dev-server

db38fa0

Add code example comments to discovery test cases

5955c64

Remove discoverBackendFiles, flatten BackendFunctionRef into BackendF…

5570119

…unction

Merge parseExportNames into extractExportedFunctions, fail-fast on er…

0073232

…rors

Move encodeQueryName to its own file with dedicated tests

e26e2d7

Add backend function registry to fix stale entries on HMR re-transform

960aa89

Move BACKEND_FILE_RE to constants, remove redundant backendOutputs gu…

ec6b1b3

…ards

Reject non-function exports in .backend.* files, clear stale registry…

606476f

… entries on HMR

Error on destructured and non-callable exports in backend files

f9a619f

Use path.join for relativePath construction

724636f

Fix E2E test: rename fixture to .backend.js convention, add apps-func…

4387d19

…tion-query stub

Address PR review: validation, rename, and backendOutputs refactor

4cbe039

Add apps-function-query dep, empty module for no-export backend files…

f440815

…, fix test types

Remove apps-function-query E2E stub, now resolved from real dependency

163d329

Scope apps-function-query dep to vite-plugin only, add integrity exce…

d443a4d

…ption

Preserve POSIX paths in archive entries and query name hashes

7e46940

Drop @datadog/apps-function-query, inject apps runtime via globalThis…

ece28b9

….DD_APPS_RUNTIME

Update imports for proxy-codegen and backend-function-client renames

1e3ebed

Fix apps-runtime import path for backend/client move

87a0214

Include src/built/ in client tsconfig for browser-context typecheck

d564740

apps-runtime.ts imports from backend/client and runs in the browser, so it belongs in the DOM compilation context alongside the client code. Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

sdkennedy2 force-pushed the sdkennedy2/replace-esbuild-acorn-with-transform-hook branch from fe42d08 to d564740 Compare April 18, 2026 18:11

chatgpt-codex-connector bot reviewed Apr 18, 2026

View reviewed changes

sdkennedy2 mentioned this pull request Apr 18, 2026

[APPS] Inject transport at build time instead of forking at runtime #323

Draft

Drop unused publishedPackageExtraDependencies scaffolding

ed163fe

DataDog deleted a comment from chatgpt-codex-connector bot Apr 18, 2026

		// handles: export { add, multiply }
		names.push(spec.exported.name);

Conversation

sdkennedy2 commented Apr 14, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Motivation

Changes

Transform-hook discovery (index.ts)

Backend function registry (createBackendFunctionRegistry)

Proxy codegen (backend/proxy-codegen.ts)

Runtime injection (src/built/apps-runtime.ts + src/index.ts)

File organization

Opaque query names (backend/encodeQueryName.ts)

Removed

QA Instructions

Blast Radius

Documentation

Uh oh!

sdkennedy2 commented Apr 14, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

datadog-datadog-prod-us1-2 bot commented Apr 14, 2026 • edited by datadog-prod-us1-6 bot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

sdkennedy2 commented Apr 14, 2026

Uh oh!

chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector bot Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

sdkennedy2 commented Apr 14, 2026

Uh oh!

Uh oh!

chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector bot Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

chatgpt-codex-connector bot Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

sdkennedy2 commented Apr 14, 2026

Uh oh!

chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector bot Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

chatgpt-codex-connector bot Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

sdkennedy2 Apr 14, 2026

Choose a reason for hiding this comment

Uh oh!

sdkennedy2 commented Apr 15, 2026

Uh oh!

chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

chatgpt-codex-connector bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

sdkennedy2 commented Apr 15, 2026

Uh oh!

chatgpt-codex-connector bot left a comment

Choose a reason for hiding this comment

💡 Codex Review

Uh oh!

chatgpt-codex-connector bot Apr 15, 2026

Choose a reason for hiding this comment

Uh oh!

sdkennedy2 commented Apr 14, 2026 •

edited

Loading

Transform-hook discovery (`index.ts`)

Backend function registry (`createBackendFunctionRegistry`)

Proxy codegen (`backend/proxy-codegen.ts`)

Runtime injection (`src/built/apps-runtime.ts` + `src/index.ts`)

Opaque query names (`backend/encodeQueryName.ts`)

sdkennedy2 commented Apr 14, 2026 •

edited

Loading

datadog-datadog-prod-us1-2 bot commented Apr 14, 2026 •

edited by datadog-prod-us1-6 bot

Loading