From 4e434e01bcca891b54579c20eacccfc9d2f9052d Mon Sep 17 00:00:00 2001 From: Sheraff Date: Thu, 22 Oct 2026 08:19:34 +0200 Subject: [PATCH] test(start-plugin-core): run the last middleware rows through Start's middleware chain The fast-tier rows "leaves unrelated SSR middleware chains as written" and "isomorphic, server-only and middleware implementations in one module" called a middleware's .server() with a hand-written next. Each now calls a server fn that uses the middleware (a user of the factory in another module, a createServerFn().middleware([mw]) next to the case), from the client over HTTP and from server code inside a real request, and reads what the middleware put into the handler's context. The env-separation pin "a function middleware validator on a builder variable" called the validator directly. A server fn with that middleware now returns the data the validator gave, called by id through Start's server entry. Co-Authored-By: Claude Opus 5.5 --- .../start-plugin-core/tests/compiler.test.ts | 17 ++++++++++++----- .../start-build-env-separation.test.ts | 8 ++++++-- .../tests/start-compiler-factories.test.ts | 17 ++++++++++++++--- 3 files changed, 32 insertions(+), 10 deletions(-) diff --git a/packages/start-plugin-core/tests/compiler.test.ts b/packages/start-plugin-core/tests/compiler.test.ts index cdeb15a5af..65b6c1c8b1 100644 --- a/packages/start-plugin-core/tests/compiler.test.ts +++ b/packages/start-plugin-core/tests/compiler.test.ts @@ -12,6 +12,7 @@ import { describe, expect, test } from 'vitest' import { callFromClient, + callServerFnThroughCallers, clientOnlyError, fromPage, inPage, @@ -446,15 +447,21 @@ test('leaves unrelated SSR middleware chains as written when a server function f 'auth-wrapper.ts': `import { createMiddleware, createServerFn } from '@tanstack/react-start'; const middleware = createMiddleware({ type: 'function' }).server(({ next }) => next({ context: { role: 'admin' } })); export const factory = createServerFn().middleware([middleware]);`, + // The factory's user: a server fn of another module, whose handler + // gives what the factory's middleware put into its context. + 'uses-factory.ts': `import { factory } from './auth-wrapper'; +export const role = factory.handler(async ({ context }) => context.role);`, }, { file: 'auth-wrapper.ts' }, ) - // The server keeps the middleware chain as written. - const { factory } = await served.ssr('auth-wrapper.ts') - const [middleware] = factory.options.middleware + // The server keeps the middleware chain as written: Start runs it for a + // call of the factory's server fn, from the client (over HTTP) and from + // server code (inside a real request). expect( - middleware.options.server({ next: (result: unknown) => result }), - ).toEqual({ context: { role: 'admin' } }) + await callServerFnThroughCallers(served, 'module.role', undefined, { + file: 'uses-factory.ts', + }), + ).toBe('admin') }) test.each([ diff --git a/packages/start-plugin-core/tests/integration/start-build-env-separation.test.ts b/packages/start-plugin-core/tests/integration/start-build-env-separation.test.ts index 07001c09c4..01e439f874 100644 --- a/packages/start-plugin-core/tests/integration/start-build-env-separation.test.ts +++ b/packages/start-plugin-core/tests/integration/start-build-env-separation.test.ts @@ -255,7 +255,7 @@ export const serverOnly = createServerOnlyFn(() => serverOnlyDep()) // then the server fn's own) and the data its validator gave: a call // over HTTP runs Start's own middleware chain. 'src/middleware-fns.ts': `import { createServerFn } from '@tanstack/react-start' -import { serverMiddleware } from './builder-middleware' +import { serverMiddleware, validatedMiddleware } from './builder-middleware' import { fnMiddleware } from './middleware' type Context = { marker?: string } export const viaFnMiddleware = createServerFn() @@ -267,6 +267,9 @@ export const viaFnMiddleware = createServerFn() export const viaBuilderMiddleware = createServerFn() .middleware([serverMiddleware]) .handler(async ({ context }) => (context as Context).marker) +export const viaBuilderValidator = createServerFn() + .middleware([validatedMiddleware]) + .handler(async ({ data }) => data) export const viaStartMiddleware = createServerFn().handler( async ({ context }) => (context as unknown as Context).marker, ) @@ -313,6 +316,7 @@ export { serverMiddleware, validatedMiddleware } from './builder-middleware' export { fnMiddleware } from './middleware' export { viaBuilderMiddleware, + viaBuilderValidator, viaFnMiddleware, viaStartMiddleware, } from './middleware-fns' @@ -478,7 +482,7 @@ const get = async (path) => { construct: 'a function middleware validator on a builder variable', marker: 'MARK_BUILDER_MIDDLEWARE_VALIDATOR', - run: `return entry.validatedMiddleware.options.validator({})`, + run: `return await callById(serverFnId(entry.viaBuilderValidator))`, expected: 'MARK_BUILDER_MIDDLEWARE_VALIDATOR', }, { diff --git a/packages/start-plugin-core/tests/start-compiler-factories.test.ts b/packages/start-plugin-core/tests/start-compiler-factories.test.ts index e941128e4a..cd53ed524e 100644 --- a/packages/start-plugin-core/tests/start-compiler-factories.test.ts +++ b/packages/start-plugin-core/tests/start-compiler-factories.test.ts @@ -643,19 +643,30 @@ export const mw = createMiddleware().server(async ({ next }) => { 'chart.client.ts': `export const chart = { draw: () => 'drawn' }\n`, 'db.server.ts': `export const db = { x: () => 'x' }\n`, + // The middleware's user: a server fn whose handler gives what the + // middleware put into its context. + 'uses-mw.ts': `import { createServerFn } from '@tanstack/react-start' +import { mw } from './module' +export const value = createServerFn() + .middleware([mw]) + .handler(async ({ context }) => context.value) +`, }, ) await expectClientFree(served) expect(await inPage(served, 'return module.iso()')).toBe('drawn') await expectSsrFree(served) const ssr = await served.ssr() + // The middleware runs in Start's middleware chain: for a call of the + // server fn from the client (over HTTP) and from server code (inside a + // real request). expect([ ssr.iso(), ssr.serverOnly(), - await ssr.mw.options.server({ - next: (options: unknown) => options, + await callServerFnThroughCallers(served, 'module.value', undefined, { + file: 'uses-mw.ts', }), - ]).toEqual(['x', 'x', { context: { value: 'x' } }]) + ]).toEqual(['x', 'x', 'x']) }) // Source: babel-dead-code-elimination "variable" > "within for...in";