ref: Cleanup wranglerConfig

Author: JPeer264

packages/cloudflare/src/vite/wranglerConfig.ts

@@ -1,5 +1,4 @@
-import { existsSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
+import { resolve } from 'node:path';
 import { type Unstable_Config, unstable_readConfig } from 'wrangler';
 
 /**
@@ -30,38 +29,28 @@ export interface WranglerConfig {
 export function resolveWranglerConfig(
   root: string,
   explicitPath?: string,
-): { config: WranglerConfig; configDir: string } | undefined {
-  const configPath = explicitPath
-    ? resolve(root, explicitPath)
-    : ['wrangler.json', 'wrangler.jsonc', 'wrangler.toml'].map(name => resolve(root, name)).find(existsSync);
+): WranglerConfig | undefined {
+  const configPath = explicitPath ? resolve(root, explicitPath) : undefined;
 
-  if (!configPath || !existsSync(configPath)) {
-    return undefined;
-  }
-
-  let raw: Unstable_Config;
   try {
     // `hideWarnings` keeps wrangler's config diagnostics (e.g. missing DO
     // migrations) out of the Vite build output.
-    raw = unstable_readConfig({ config: configPath }, { hideWarnings: true });
-  } catch {
-    return undefined;
-  }
+    const raw = unstable_readConfig({ config: configPath }, { hideWarnings: true }) as Unstable_Config;
 
-  const durableObjects: WranglerConfig['durableObjects'] = [];
-  const seenClassNames = new Set<string>();
-  for (const binding of raw.durable_objects?.bindings ?? []) {
-    // `script_name` bindings reference a class exported by a *different* worker
-    // — there is nothing to wrap in this worker's entry file.
-    if (typeof binding?.class_name !== 'string' || binding.script_name || seenClassNames.has(binding.class_name)) {
-      continue;
+    const durableObjects: WranglerConfig['durableObjects'] = [];
+    const seenClassNames = new Set<string>();
+    for (const binding of raw.durable_objects?.bindings ?? []) {
+      // `script_name` bindings reference a class exported by a *different* worker
+      // — there is nothing to wrap in this worker's entry file.
+      if (typeof binding?.class_name !== 'string' || binding.script_name || seenClassNames.has(binding.class_name)) {
+        continue;
+      }
+      seenClassNames.add(binding.class_name);
+      durableObjects.push({ name: binding.name, className: binding.class_name });
     }
-    seenClassNames.add(binding.class_name);
-    durableObjects.push({ name: binding.name, className: binding.class_name });
-  }
 
-  return {
-    config: { main: raw.main, durableObjects },
-    configDir: dirname(raw.configPath ?? configPath),
-  };
+    return { main: raw.main, durableObjects };
+  } catch {
+    return undefined;
+  }
 }

packages/cloudflare/test/vite/wranglerConfig.test.ts

@@ -1,18 +1,30 @@
-import { mkdtempSync, writeFileSync } from 'node:fs';
+import { mkdtempSync, realpathSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it } from 'vitest';
+import { unstable_readConfig } from 'wrangler';
 import { resolveWranglerConfig } from '../../src/vite/wranglerConfig';
 
+// `resolveWranglerConfig` locates the config via wrangler's own discovery from
+// `process.cwd()` (unless given an explicit path), so each test writes its
+// fixtures to a temp dir and switches the cwd into it. `realpathSync` collapses
+// the macOS `/var` → `/private/var` symlink so path assertions match what
+// wrangler resolves against the (real) cwd.
 function writeTempDir(files: Record<string, string>): string {
-  const dir = mkdtempSync(join(tmpdir(), 'sentry-cf-'));
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'sentry-cf-')));
   for (const [name, content] of Object.entries(files)) {
     writeFileSync(join(dir, name), content);
   }
+  process.chdir(dir);
   return dir;
 }
 
 describe('resolveWranglerConfig', () => {
+  const originalCwd = process.cwd();
+  afterEach(() => {
+    process.chdir(originalCwd);
+  });
+
   it('parses wrangler.toml', () => {
     const dir = writeTempDir({
       'wrangler.toml': [
@@ -27,8 +39,8 @@ describe('resolveWranglerConfig', () => {
     const result = resolveWranglerConfig(dir);
     expect(result).toBeDefined();
     // wrangler resolves `main` to an absolute path against the config dir.
-    expect(result!.config.main).toBe(join(dir, 'src/index.ts'));
-    expect(result!.config.durableObjects).toEqual([{ name: 'MY_DO', className: 'MyDurableObject' }]);
+    expect(result!.main).toBe(join(dir, 'src/index.ts'));
+    expect(result!.durableObjects).toEqual([{ name: 'MY_DO', className: 'MyDurableObject' }]);
   });
 
   it('parses wrangler.json', () => {
@@ -43,8 +55,8 @@ describe('resolveWranglerConfig', () => {
 
     const result = resolveWranglerConfig(dir);
     expect(result).toBeDefined();
-    expect(result!.config.main).toBe(join(dir, 'src/worker.ts'));
-    expect(result!.config.durableObjects).toEqual([{ name: 'DO_A', className: 'A' }]);
+    expect(result!.main).toBe(join(dir, 'src/worker.ts'));
+    expect(result!.durableObjects).toEqual([{ name: 'DO_A', className: 'A' }]);
   });
 
   it('parses wrangler.jsonc (strips comments)', () => {
@@ -65,8 +77,8 @@ describe('resolveWranglerConfig', () => {
 
     const result = resolveWranglerConfig(dir);
     expect(result).toBeDefined();
-    expect(result!.config.main).toBe(join(dir, 'src/index.ts'));
-    expect(result!.config.durableObjects).toEqual([{ name: 'DO', className: 'MyDO' }]);
+    expect(result!.main).toBe(join(dir, 'src/index.ts'));
+    expect(result!.durableObjects).toEqual([{ name: 'DO', className: 'MyDO' }]);
   });
 
   it('parses JSONC with trailing commas', () => {
@@ -84,15 +96,15 @@ describe('resolveWranglerConfig', () => {
     });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.main).toBe(join(dir, 'src/index.ts'));
-    expect(result!.config.durableObjects).toEqual([{ name: 'DO', className: 'MyDO' }]);
+    expect(result!.main).toBe(join(dir, 'src/index.ts'));
+    expect(result!.durableObjects).toEqual([{ name: 'DO', className: 'MyDO' }]);
   });
 
   it('parses TOML single-quoted (literal) strings', () => {
     const dir = writeTempDir({ 'wrangler.toml': "main = 'src/index.ts'" });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.main).toBe(join(dir, 'src/index.ts'));
+    expect(result!.main).toBe(join(dir, 'src/index.ts'));
   });
 
   it('prefers wrangler.json over wrangler.toml (matching wrangler itself)', () => {
@@ -102,7 +114,7 @@ describe('resolveWranglerConfig', () => {
     });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.main).toBe(join(dir, 'from-json.ts'));
+    expect(result!.main).toBe(join(dir, 'from-json.ts'));
   });
 
   it('prefers wrangler.jsonc over wrangler.toml (matching wrangler itself)', () => {
@@ -112,7 +124,7 @@ describe('resolveWranglerConfig', () => {
     });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.main).toBe(join(dir, 'from-jsonc.ts'));
+    expect(result!.main).toBe(join(dir, 'from-jsonc.ts'));
   });
 
   it('handles TOML with commented-out bindings', () => {
@@ -131,7 +143,7 @@ describe('resolveWranglerConfig', () => {
     });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.durableObjects).toEqual([{ name: 'REAL', className: 'RealDO' }]);
+    expect(result!.durableObjects).toEqual([{ name: 'REAL', className: 'RealDO' }]);
   });
 
   it('handles multiple DO bindings', () => {
@@ -150,14 +162,16 @@ describe('resolveWranglerConfig', () => {
     });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.durableObjects).toHaveLength(2);
-    expect(result!.config.durableObjects[0]).toEqual({ name: 'DO_A', className: 'A' });
-    expect(result!.config.durableObjects[1]).toEqual({ name: 'DO_B', className: 'B' });
+    expect(result!.durableObjects).toHaveLength(2);
+    expect(result!.durableObjects[0]).toEqual({ name: 'DO_A', className: 'A' });
+    expect(result!.durableObjects[1]).toEqual({ name: 'DO_B', className: 'B' });
   });
 
-  it('returns undefined when no config exists', () => {
+  it('returns an empty config when no config file is found', () => {
+    // With nothing to discover, wrangler yields a default (empty) config rather
+    // than throwing, so the result is defined but carries no entry or bindings.
     const dir = writeTempDir({});
-    expect(resolveWranglerConfig(dir)).toBeUndefined();
+    expect(resolveWranglerConfig(dir)).toEqual({ main: undefined, durableObjects: [] });
   });
 
   it('returns undefined for explicit non-existent path', () => {
@@ -169,8 +183,7 @@ describe('resolveWranglerConfig', () => {
 
     const result = resolveWranglerConfig(dir, 'custom.toml');
     expect(result).toBeDefined();
-    expect(result!.config.main).toBe(join(dir, 'src/index.ts'));
-    expect(result!.configDir).toBe(dir);
+    expect(result!.main).toBe(join(dir, 'src/index.ts'));
   });
 
   it('returns undefined for an empty config file instead of crashing', () => {
@@ -197,7 +210,7 @@ describe('resolveWranglerConfig', () => {
     });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.durableObjects).toEqual([{ name: 'LOCAL', className: 'LocalDO' }]);
+    expect(result!.durableObjects).toEqual([{ name: 'LOCAL', className: 'LocalDO' }]);
   });
 
   it('uses only the active environment DO bindings (does not union across envs)', () => {
@@ -219,7 +232,7 @@ describe('resolveWranglerConfig', () => {
     });
 
     const result = resolveWranglerConfig(dir);
-    expect(result!.config.durableObjects).toEqual([{ name: 'TOP', className: 'TopDO' }]);
+    expect(result!.durableObjects).toEqual([{ name: 'TOP', className: 'TopDO' }]);
   });
 
   it('honors CLOUDFLARE_ENV for both main and DO bindings', () => {
@@ -240,11 +253,87 @@ describe('resolveWranglerConfig', () => {
     process.env.CLOUDFLARE_ENV = 'staging';
     try {
       const result = resolveWranglerConfig(dir)!;
-      expect(result.config.main).toBe(join(dir, 'src/staging.ts'));
-      expect(result.config.durableObjects).toEqual([{ name: 'STAGING_DO', className: 'StagingDO' }]);
+      expect(result.main).toBe(join(dir, 'src/staging.ts'));
+      expect(result.durableObjects).toEqual([{ name: 'STAGING_DO', className: 'StagingDO' }]);
     } finally {
       if (previous === undefined) delete process.env.CLOUDFLARE_ENV;
       else process.env.CLOUDFLARE_ENV = previous;
     }
   });
 });
+
+// ---------------------------------------------------------------------------
+// What `unstable_readConfig` exposes about service-binding `entrypoint`.
+//
+// These characterize the wrangler API directly (not our wrapper) to justify a
+// design decision: a service binding's `entrypoint` names a *named export on
+// the target worker being bound to*, not an entrypoint this worker exposes.
+// So it cannot, in general, tell auto-wrap which of *this* worker's exports is
+// a handler — with one exception: a self-binding (`service === own name`).
+// ---------------------------------------------------------------------------
+
+describe('unstable_readConfig: service-binding entrypoint semantics', () => {
+  function readConfig(files: Record<string, string>) {
+    const dir = writeTempDir(files);
+    return unstable_readConfig({ config: join(dir, Object.keys(files)[0]!) }, { hideWarnings: true });
+  }
+
+  it('resolves `main` to an absolute path', () => {
+    const raw = readConfig({
+      'wrangler.json': JSON.stringify({ main: 'src/index.ts', compatibility_date: '2024-01-01' }),
+    });
+    // Not the literal `src/index.ts` from the file — wrangler resolves it.
+    expect(raw.main).not.toBe('src/index.ts');
+    expect(raw.main?.endsWith(join('src', 'index.ts'))).toBe(true);
+  });
+
+  it("an outward service binding names the *target* worker's export, not ours", () => {
+    const raw = readConfig({
+      'wrangler.json': JSON.stringify({
+        name: 'worker-a',
+        main: 'src/index.ts',
+        compatibility_date: '2024-01-01',
+        services: [{ binding: 'MY_SVC', service: 'worker-b', entrypoint: 'SomeEntry' }],
+      }),
+    });
+
+    expect(raw.name).toBe('worker-a');
+    // `entrypoint` belongs to `worker-b`, a different worker this build isn't
+    // compiling — nothing in *our* entry file to wrap from this.
+    expect(raw.services).toEqual([{ binding: 'MY_SVC', service: 'worker-b', entrypoint: 'SomeEntry' }]);
+    expect(raw.services?.[0]?.service).not.toBe(raw.name);
+  });
+
+  it('a self-binding (service === own name) does name one of *our* exports', () => {
+    const raw = readConfig({
+      'wrangler.json': JSON.stringify({
+        name: 'worker-self',
+        main: 'src/index.ts',
+        compatibility_date: '2024-01-01',
+        services: [
+          { binding: 'SELF', service: 'worker-self', entrypoint: 'InternalEntry' },
+          { binding: 'OTHER', service: 'worker-x', entrypoint: 'RemoteEntry' },
+        ],
+      }),
+    });
+
+    // Only the self-bound entrypoint is ours; the other points at `worker-x`.
+    const ownEntrypoints = (raw.services ?? []).filter(s => s.service === raw.name).map(s => s.entrypoint);
+    expect(ownEntrypoints).toEqual(['InternalEntry']);
+  });
+
+  it('leaves `name` undefined when the config omits it (no self-binding is derivable)', () => {
+    const raw = readConfig({
+      'wrangler.json': JSON.stringify({
+        main: 'src/index.ts',
+        compatibility_date: '2024-01-01',
+        services: [{ binding: 'S', service: 'x', entrypoint: 'E' }],
+      }),
+    });
+
+    // Without a worker name there is no `service === name` to match against, so
+    // even self-bindings can't be identified.
+    expect(raw.name).toBeUndefined();
+    expect(raw.topLevelName).toBeUndefined();
+  });
+});