${name}_COMPANION_SERVER_ONLY
{text}
; } +export default ${helper}({ + messages: { + client: v.object({ text: v.string() }), + server: v.object({ html: v.string() }), + }, + async onMessage(ctx, event) { + const element =Hello <JSX>
`, + }); + } finally { + const closed = new Promise{basename('/private/${name}_COMPANION_SERVER_ONLY')}
) })); +export const actions = { save: defineHandler(c => c.html(renderToStaticMarkup(${name}_COMPANION_ACTION_ONLY))) };`, + ); + } + } + + const dev = await startServer( + (port) => + spawn('vp', ['dev', '--host', '127.0.0.1', '--port', String(port), '--strictPort'], { + cwd: root, + stdio: ['ignore', 'pipe', 'pipe'], + }), + 20_000, + ); + servers.push(dev.child); + bases.dev = dev.base; + devTypes = readFileSync(join(root, '.void/routes.d.ts'), 'utf8'); + + const build = spawn.sync('vp', ['build'], { + cwd: root, + env: { ...process.env, NODE_ENV: 'production' }, + encoding: 'utf8', + timeout: 60_000, + maxBuffer: 10 * 1024 * 1024, + }); + expect(build.status, `${build.stdout ?? ''}${build.stderr ?? ''}`).toBe(0); + const prod = await startServer( + (port) => + spawn(process.execPath, ['dist/ssr/index.js'], { + cwd: root, + stdio: ['ignore', 'pipe', 'pipe'], + env: { ...process.env, NODE_ENV: 'production', PORT: String(port) }, + }), + 20_000, + ); + servers.push(prod.child); + bases.prod = prod.base; + }); + + afterAll(async () => { + await Promise.all(servers.map((child) => killChild(child))); + playground?.cleanup(); + }); + + it.each(httpExtensions.flatMap((ext) => ['dev', 'prod'].map((env) => ({ ext, env }))))( + 'executes .$ext HTTP handlers and selects environment routes in $env', + async ({ ext, env }) => { + const response = await fetch(`${bases[env]}/${ext}/jsx`); + expect(response.status).toBe(200); + expect(response.headers.get('content-type')).toContain('text/html'); + expect(await response.text()).toBe('${name}_COMPANION_SERVER_ONLY
Loaded
;'); + + const scan = await scanPages(TMP); + expect(scan.pages).toHaveLength(1); + expect(scan.pages[0]).toMatchObject({ + pattern: '/web.server', + componentPath: `web.server.${ext}`, + serverPath: 'web.server.server.jsx', + methods: ['loader'], + }); + const manifest = generateComponentManifest(scan, '/project/pages'); + expect(manifest).toContain(`/project/pages/web.server.${ext}`); + expect(manifest).not.toContain('web.server.server.jsx'); + }, + ); + + it.each( + ['tsx', 'jsx'].flatMap((serverExt) => + ['foo.tsx', 'foo.island.tsx', 'foo.jsx', 'foo.vue', 'foo.svelte', 'foo.md'].map( + (component) => ({ component, serverExt }), + ), + ), + )( + 'keeps the .server.$serverExt companion of $component out of page discovery and component manifests', + async ({ component, serverExt }) => { + writeFile(component, ''); + writeFile( + `foo.server.${serverExt}`, + `export const loader = () => ({ html:Loaded
}); +export const actions = { save: () =>Saved
}; +export const revalidate = 60; +export const prerender = false; +export const ssr = true;`, + ); + writeFile(`orphan.server.${serverExt}`, 'export const loader = () =>Orphan
;'); + writeFile('layout.tsx', 'export default () => null;'); + writeFile(`layout.server.${serverExt}`, 'export const helper = () =>Server
;'); + writeFile('_layouts/marketing.tsx', 'export default () => null;'); + writeFile( + `_layouts/marketing.server.${serverExt}`, + 'export const helper = () =>Server
;', + ); + + const scan = await scanPages(TMP); + expect(scan.pages).toHaveLength(1); + expect(scan.pages[0]).toMatchObject({ + pattern: '/foo', + componentPath: component, + serverPath: `foo.server.${serverExt}`, + methods: ['loader', 'actions'], + revalidate: 60, + prerenderMode: 'disabled', + ssrMode: 'server', + }); + expect(scan.layouts.map((layout) => layout.filePath)).toEqual(['layout.tsx']); + expect(scan.namedLayouts.map((layout) => layout.filePath)).toEqual([ + '_layouts/marketing.tsx', + ]); + const manifest = generateComponentManifest(scan, '/project/pages'); + expect(manifest).toContain(`/project/pages/${component}`); + expect(manifest).not.toContain('.server.'); + const { dts } = generateRouteTypes( + { routes: [], middleware: [], jobs: [], queues: [], pages: scan }, + join(TMP, 'routes'), + join(TMP, '.void'), + join(TMP, 'pages'), + ); + expect(dts).toContain('"/foo": {'); + expect(dts).toContain(`typeof import("../pages/foo.server.${serverExt}")`); + expect(dts).not.toContain('"/foo.server"'); + }, + ); + it('detects actions (plural) export from .server.ts', async () => { writeFile('settings.vue', '{kv.get('report')}
;`, + ); + writeFileSync( + join(root, `src/pages/report.server.${serverExt}`), + `import { storage } from 'void/storage'; export const loader = () =>{storage.list()}
;`, + ); + + expect(inferProjectBindings(root, { environment: 'dev' })).toMatchObject({ + needsKV: false, + needsR2: true, + }); + expect(inferProjectBindings(root, { environment: 'prod' })).toMatchObject({ + needsKV: true, + needsR2: true, + }); + }, + ); + + it.each(['', 'src', 'app'])('infers .well-known bindings under sourceDir=%s', (sourceDir) => { + const root = createTempRoot(); + if (sourceDir) { + writeFileSync(join(root, 'void.json'), JSON.stringify({ sourceDir })); + } + const routesDir = join(root, sourceDir, 'routes', '.well-known'); + mkdirSync(join(routesDir, '_helpers'), { recursive: true }); + writeFileSync( + join(routesDir, 'status.dev.tsx'), + "import { kv } from 'void/kv'; export const GET = () =>{kv.get('status')}
;", + ); + writeFileSync( + join(routesDir, 'status.prod.jsx'), + "import { storage } from 'void/storage'; export const GET = () =>{storage.list()}
;", + ); + writeFileSync( + join(routesDir, 'events.dev.ws.jsx'), + "import { db } from 'void/db'; export default defineWebSocket({ onMessage: () =>{db.select()}
});", ); writeFileSync( - join(root, 'routes', 'api', 'events.dev.ws.ts'), - "import { defineLiveStream } from 'void/live';", + join(routesDir, '_helpers', 'stream.prod.tsx'), + "import { defineLiveStream } from 'void/live'; export const Stream = () =>Stream
;", ); - expect(inferProjectBindings(root, undefined, ['routes']).needsR2).toBe(true); - expect(inferProjectBindings(root, { environment: 'dev' }, ['routes']).needsR2).toBe(true); - const production = inferProjectBindings(root, { environment: 'prod' }, ['routes']); - expect(production.needsR2).toBe(false); - expect(production.needsLive).toBe(false); + expect(inferProjectBindings(root, { environment: 'dev' })).toMatchObject({ + needsKV: true, + needsR2: false, + needsD1: true, + needsLive: true, + }); + expect(inferProjectBindings(root, { environment: 'prod' })).toMatchObject({ + needsKV: false, + needsR2: true, + needsD1: false, + needsLive: true, + }); + expect(inferProjectBindings(root)).toMatchObject({ + needsKV: true, + needsR2: true, + needsD1: true, + needsLive: true, + }); + }); + + it('keeps unrelated hidden directories out of .well-known inference', () => { + const root = createTempRoot(); + for (const directory of [ + 'routes/.cache', + 'routes/.well-known/.cache', + 'routes/nested/.well-known', + 'pages/.well-known', + ]) { + mkdirSync(join(root, directory), { recursive: true }); + writeFileSync(join(root, directory, 'hidden.tsx'), "import { storage } from 'void/storage';"); + } + writeFileSync( + join(root, 'routes/.well-known/status.tsx'), + "import { kv } from 'void/kv'; export const GET = () =>Status
;", + ); + + expect(inferProjectBindings(root)).toMatchObject({ needsKV: true, needsR2: false }); + expect(inferProjectBindings(root, undefined, ['pages']).needsKV).toBe(false); + }); + + it('infers .well-known bindings in the configured source fallback with custom scan directories', () => { + const root = createTempRoot(); + writeFileSync(join(root, 'void.json'), JSON.stringify({ sourceDir: 'app' })); + mkdirSync(join(root, 'app/routes/.well-known'), { recursive: true }); + writeFileSync( + join(root, 'app/routes/.well-known/status.prod.jsx'), + "import { kv } from 'void/kv'; export const GET = () =>Status
;", + ); + + expect(inferProjectBindings(root, { environment: 'prod' }, ['server']).needsKV).toBe(true); + expect(inferProjectBindings(root, { environment: 'dev' }, ['server']).needsKV).toBe(false); + }); + + it.each(['tsx', 'jsx'])('keeps bindings from underscored route helpers in .%s', (ext) => { + const root = createTempRoot(); + mkdirSync(join(root, 'routes/_components'), { recursive: true }); + mkdirSync(join(root, 'routes/components'), { recursive: true }); + writeFileSync( + join(root, `routes/_components/Toolbar.prod.${ext}`), + "import { kv } from 'void/kv'; export const Toolbar = () =>Toolbar
;", + ); + writeFileSync( + join(root, `routes/components/_Toolbar.dev.${ext}`), + "import { storage } from 'void/storage'; export const Toolbar = () =>Toolbar
;", + ); + writeFileSync( + join(root, `routes/_helper.prod.ws.${ext}`), + "import { db } from 'void/db'; export const helper = () =>Helper
;", + ); + + for (const environment of ['dev', 'prod'] as const) { + expect(inferProjectBindings(root, { environment })).toMatchObject({ + needsKV: true, + needsR2: true, + needsD1: true, + }); + } }); it('keeps bindings from non-route files with environment-like suffixes', () => { @@ -113,7 +247,8 @@ describe('inferProjectBindings', () => { mkdirSync(join(root, 'routes'), { recursive: true }); mkdirSync(join(root, 'queues'), { recursive: true }); writeFileSync(join(root, 'queues', 'sync.dev.ts'), "import { storage } from 'void/storage';"); - writeFileSync(join(root, 'routes', 'helper.dev.tsx'), "import { kv } from 'void/kv';"); + mkdirSync(join(root, 'pages'), { recursive: true }); + writeFileSync(join(root, 'pages', 'helper.dev.server.tsx'), "import { kv } from 'void/kv';"); const result = inferProjectBindings(root, { environment: 'prod' }); expect(result.needsR2).toBe(true); diff --git a/packages/void/test/unit/plugin-route-binding-environment.test.ts b/packages/void/test/unit/plugin-route-binding-environment.test.ts index fb7d53a5b..ed271330f 100644 --- a/packages/void/test/unit/plugin-route-binding-environment.test.ts +++ b/packages/void/test/unit/plugin-route-binding-environment.test.ts @@ -25,17 +25,20 @@ afterEach(() => { } }); -function createProject(): string { +function createProject(ext: string, sourceDir = ''): string { const root = mkdtempSync(join(tmpdir(), 'void-route-binding-env-')); roots.push(root); - mkdirSync(join(root, 'routes', 'api'), { recursive: true }); + mkdirSync(join(root, sourceDir, 'routes', 'api'), { recursive: true }); writeFileSync(join(root, 'package.json'), JSON.stringify({ type: 'module' })); writeFileSync( join(root, 'void.json'), - JSON.stringify({ worker: { compatibility_date: '2026-02-24' } }), + JSON.stringify({ + sourceDir: sourceDir || undefined, + worker: { compatibility_date: '2026-02-24' }, + }), ); writeFileSync( - join(root, 'routes', 'api', 'debug.dev.ts'), + join(root, sourceDir, 'routes', 'api', `debug.dev.${ext}`), `import { db } from 'void/db'; import { kv } from 'void/kv'; import { storage } from 'void/storage'; @@ -69,34 +72,96 @@ async function generatedBindings( } describe('environment-specific route binding inference', () => { - it('does not emit production bindings for imports exclusive to a dev route', async () => { - const root = createProject(); - const config = await generatedBindings(root, { command: 'build', mode: 'production' }); - - expect(config.d1_databases).toBeUndefined(); - expect(config.kv_namespaces).toBeUndefined(); - expect(config.r2_buckets).toBeUndefined(); - expect(config.ai).toBeUndefined(); - }); - - it('keeps the same bindings when serving the dev route', async () => { - const root = createProject(); - const config = await generatedBindings(root, { command: 'serve', mode: 'development' }); - - expect(config.d1_databases).toBeDefined(); - expect(config.kv_namespaces).toBeDefined(); - expect(config.r2_buckets).toBeDefined(); - }); - - it('does not emit container or live Durable Object bindings from a dev route', async () => { - const root = createProject(); - writeFileSync( - join(root, 'routes', 'api', 'debug.dev.ts'), - "import { getSandbox } from 'void/sandbox'; import { defineLiveStream } from 'void/live'; export const GET = () => ({ getSandbox, defineLiveStream });", - ); - - const config = await generatedBindings(root, { command: 'build', mode: 'production' }); - expect(config.containers).toBeUndefined(); - expect(config.durable_objects).toBeUndefined(); - }); + it.each([ + { ext: 'tsx', sourceDir: '' }, + { ext: 'jsx', sourceDir: 'src' }, + ])( + 'emits .well-known and helper bindings in .$ext under sourceDir=$sourceDir', + async ({ ext, sourceDir }) => { + const root = createProject(ext, sourceDir); + const routesDir = join(root, sourceDir, 'routes'); + rmSync(join(routesDir, 'api', `debug.dev.${ext}`)); + mkdirSync(join(routesDir, '.well-known')); + mkdirSync(join(routesDir, '_components')); + writeFileSync( + join(routesDir, '.well-known', `status.prod.${ext}`), + "import { kv } from 'void/kv'; export const GET = () =>{kv.get('status')}
;", + ); + writeFileSync( + join(routesDir, '_components', `Toolbar.prod.${ext}`), + "import { storage } from 'void/storage'; export const Toolbar = () =>Toolbar
;", + ); + + const development = await generatedBindings(root, { command: 'serve', mode: 'development' }); + expect(development.kv_namespaces).toBeUndefined(); + expect(development.r2_buckets).toBeDefined(); + const production = await generatedBindings(root, { command: 'build', mode: 'production' }); + expect(production.kv_namespaces).toBeDefined(); + expect(production.r2_buckets).toBeDefined(); + }, + ); + + it.each(['tsx', 'jsx'])( + 'emits JSX WebSocket bindings only in the selected environment for .ws.%s', + async (ext) => { + const root = createProject(ext); + rmSync(join(root, 'routes', 'api', `debug.dev.${ext}`)); + writeFileSync( + join(root, 'routes', 'api', `debug.dev.ws.${ext}`), + `import { kv } from 'void/kv'; +import { defineWebSocket } from 'void/ws'; +export default defineWebSocket({ onMessage() { return{kv.get('debug')}
; } });`, + ); + + const production = await generatedBindings(root, { command: 'build', mode: 'production' }); + expect(production.kv_namespaces).toBeUndefined(); + expect(production.durable_objects).toBeUndefined(); + + const development = await generatedBindings(root, { command: 'serve', mode: 'development' }); + expect(development.kv_namespaces).toBeDefined(); + expect(development.durable_objects).toEqual({ + bindings: [{ name: 'ApiDebugWs', class_name: 'ApiDebugWs' }], + }); + }, + ); + + it.each(['ts', 'tsx', 'jsx'])( + 'does not emit production bindings for a dev .%s route', + async (ext) => { + const root = createProject(ext); + const config = await generatedBindings(root, { command: 'build', mode: 'production' }); + + expect(config.d1_databases).toBeUndefined(); + expect(config.kv_namespaces).toBeUndefined(); + expect(config.r2_buckets).toBeUndefined(); + expect(config.ai).toBeUndefined(); + }, + ); + + it.each(['ts', 'tsx', 'jsx'])( + 'keeps the same bindings when serving the dev .%s route', + async (ext) => { + const root = createProject(ext); + const config = await generatedBindings(root, { command: 'serve', mode: 'development' }); + + expect(config.d1_databases).toBeDefined(); + expect(config.kv_namespaces).toBeDefined(); + expect(config.r2_buckets).toBeDefined(); + }, + ); + + it.each(['ts', 'tsx', 'jsx'])( + 'does not emit container or live bindings from a dev .%s route', + async (ext) => { + const root = createProject(ext); + writeFileSync( + join(root, 'routes', 'api', `debug.dev.${ext}`), + "import { getSandbox } from 'void/sandbox'; import { defineLiveStream } from 'void/live'; export const GET = () => ({ getSandbox, defineLiveStream });", + ); + + const config = await generatedBindings(root, { command: 'build', mode: 'production' }); + expect(config.containers).toBeUndefined(); + expect(config.durable_objects).toBeUndefined(); + }, + ); }); diff --git a/packages/void/test/unit/scan.test.ts b/packages/void/test/unit/scan.test.ts index b572b778c..6f8025d20 100644 --- a/packages/void/test/unit/scan.test.ts +++ b/packages/void/test/unit/scan.test.ts @@ -2,6 +2,7 @@ import { mkdirSync, writeFileSync, rmSync } from 'node:fs'; import { join } from 'node:path'; import { describe, expect, it, beforeEach, afterEach } from 'vite-plus/test'; import { analyzeApplication } from '../../src/application-routing.ts'; +import { generateRouteTypes } from '../../src/codegen/route-types.ts'; import { readConfig } from '../../src/config.ts'; import type { RouteEnvironment } from '../../src/router/parse-filename.ts'; import { scanRoutePatternsSync } from '../../src/router/scan.ts'; @@ -65,6 +66,53 @@ describe('scanRoutes', () => { expect(result.jobs).toEqual([]); }); + it.each( + ['tsx', 'jsx'].flatMap((ext) => + ([undefined, 'dev', 'prod'] as const).map((environment) => ({ ext, environment })), + ), + )( + 'discovers .$ext handlers and generates types for environment=$environment', + async ({ ext, environment }) => { + createFile(`routes/api/hello.${ext}`, 'export const GET = () =>Dev
;'); + createFile(`routes/api/env.prod.${ext}`, 'export const POST = () =>Prod
;'); + createFile(`routes/.well-known/status.${ext}`, 'export const GET = () =>OK
;'); + createFile(`routes/_private.${ext}`, 'export const GET = () =>Private
;'); + createFile(`routes/.cache/ignored.${ext}`); + + const result = await scanRoutes(TMP, { environment }); + const expected = [ + `.well-known/status.${ext}`, + ...(environment !== 'prod' ? [`api/env.dev.${ext}`] : []), + ...(environment !== 'dev' ? [`api/env.prod.${ext}`] : []), + `api/hello.${ext}`, + ]; + expect(result.routes.map((route) => route.filePath).sort()).toEqual(expected); + expect(result.routes.find((route) => route.pattern === '/api/hello')?.methods).toEqual([ + 'GET', + ]); + const { dts } = generateRouteTypes(result, join(TMP, 'routes'), join(TMP, '.void')); + expect(dts).toContain('"/api/hello": {'); + for (const file of expected) { + expect(dts).toContain(`typeof import("../routes/${file}")`); + } + if (environment) { + expect(dts).not.toContain(`env.${environment === 'dev' ? 'prod' : 'dev'}.${ext}`); + } + }, + ); + + it.each(['tsx', 'jsx'])('keeps .%s out of cron and queue discovery', async (ext) => { + createFile(`routes/hello.${ext}`, 'export const GET = () =>Hello
;'); + createFile(`crons/sync.${ext}`, 'export const cron = "0 * * * *"; export default () => {};'); + createFile(`queues/emails.${ext}`, 'export default async () => {};'); + + const result = await scanRoutes(TMP); + expect(result.routes.map((route) => route.filePath)).toEqual([`hello.${ext}`]); + expect(result.jobs).toEqual([]); + expect(result.queues).toEqual([]); + }); + it('discovers conventions under explicit sourceDir only', async () => { createFile('void.json', JSON.stringify({ sourceDir: 'src' })); createFile('routes/api/root.ts', 'export const GET = () => {}'); @@ -268,6 +316,24 @@ export default () => {};`, expect(dev.websockets?.map((r) => r.filePath)).toEqual(['chat.dev.ws.ts']); expect(prod.websockets?.map((r) => r.filePath)).toEqual(['chat.prod.ws.ts']); }); + + it('discovers all WebSocket route extensions separately from HTTP handlers', async () => { + createFile('routes/tsx.tsx', 'export const GET = () =>TSX
;'); + createFile('routes/jsx.jsx', 'export const GET = () =>JSX
;'); + for (const ext of ['ts', 'mts', 'js', 'mjs', 'tsx', 'jsx']) { + createFile(`routes/chat-${ext}.ws.${ext}`, 'export default defineWebSocket({});'); + } + const result = await scanRoutes(TMP); + expect(result.websockets?.map((route) => route.filePath).sort()).toEqual([ + 'chat-js.ws.js', + 'chat-jsx.ws.jsx', + 'chat-mjs.ws.mjs', + 'chat-mts.ws.mts', + 'chat-ts.ws.ts', + 'chat-tsx.ws.tsx', + ]); + expect(result.routes.map((route) => route.pattern)).toEqual(['/jsx', '/tsx']); + }); }); describe('sync scanners', () => { diff --git a/packages/void/test/unit/websocket-scan.test.ts b/packages/void/test/unit/websocket-scan.test.ts index e04d1d373..f9ffd4f1a 100644 --- a/packages/void/test/unit/websocket-scan.test.ts +++ b/packages/void/test/unit/websocket-scan.test.ts @@ -31,6 +31,43 @@ function createRoot(): string { return root; } +describe('JSX WebSocket discovery', () => { + it.each( + ['tsx', 'jsx'].flatMap((ext) => + (['defineRoom', 'defineWebSocket'] as const).map((helper) => ({ ext, helper })), + ), + )('discovers .$ext $helper routes and filters environments', ({ ext, helper }) => { + const root = createRoot(); + const source = `export default ${helper}({ onBeforeConnect() { returnSign in
; } });`; + createRoute(root, `chat/[room].dev.ws.${ext}`, source); + createRoute(root, `chat/[room].prod.ws.${ext}`, source); + createRoute(root, `.well-known/status.ws.${ext}`, `export default ${helper}({});`); + createRoute(root, `_private.ws.${ext}`, source); + createRoute(root, `_private/hidden.ws.${ext}`, source); + createRoute(root, `.cache/ignored.ws.${ext}`, source); + + for (const environment of ['dev', 'prod'] as const) { + expect(scanWebSocketRoutesSync(root, undefined, environment)).toEqual([ + expect.objectContaining({ + filePath: `.well-known/status.ws.${ext}`, + pattern: '/.well-known/status', + }), + expect.objectContaining({ + filePath: `chat/[room].${environment}.ws.${ext}`, + pattern: '/chat/:room', + params: ['room'], + env: environment, + className: 'ChatRoomWs', + bindingName: 'ChatRoomWs', + mode: helper === 'defineRoom' ? 'room' : 'socket', + hasAuthGate: true, + }), + ]); + } + expect(scanWebSocketRoutesSync(root)).toHaveLength(3); + }); +}); + describe('WebSocket resource names', () => { it.each([ ['chat/[room].ws.ts', 'chat-room', 'ChatRoomWs'], @@ -39,6 +76,10 @@ describe('WebSocket resource names', () => { ['API_chat/roomID.ws.mjs', 'API-chat-roomID', 'APIChatRoomIDWs'], ['[...].ws.ts', 'WebSocket', 'WebSocketWs'], ['chat\\[room].ws.ts', 'chat-room', 'ChatRoomWs'], + ['chat/[room].ws.tsx', 'chat-room', 'ChatRoomWs'], + ['chat/[room].dev.ws.jsx', 'chat-room', 'ChatRoomWs'], + ['(admin)/API/[...IDs].prod.ws.tsx', 'API-IDs', 'APIIDsWs'], + ['chat\\[room].ws.jsx', 'chat-room', 'ChatRoomWs'], ])('preserves legacy identity for %s', (path, name, className) => { expect(inferWebSocketResourceName(path)).toBe(name); expect(deriveWebSocketClassName(path)).toBe(className);