result()

Author: schiller-manuel

e2e/react-start/server-functions/src/routes/middleware/client-conditional.tsx

@@ -13,14 +13,16 @@ const clientConditionalMiddleware = createMiddleware({
   .inputValidator(
     (input: { shouldShortCircuit: boolean; value: string }) => input,
   )
-  .client(async ({ data, next }) => {
+  .client(async ({ data, next, result }) => {
     if (data.shouldShortCircuit) {
-      return {
-        source: 'client-middleware',
-        message: 'Conditional early return from client middleware',
-        condition: 'shouldShortCircuit=true',
-        timestamp: Date.now(),
-      }
+      return result({
+        data: {
+          source: 'client-middleware',
+          message: 'Conditional early return from client middleware',
+          condition: 'shouldShortCircuit=true',
+          timestamp: Date.now(),
+        },
+      })
     }
     // Proceed to server
     return next({

e2e/react-start/server-functions/src/routes/middleware/client-early-return.tsx

@@ -13,12 +13,14 @@ import React from 'react'
  */
 const clientEarlyReturnMiddleware = createMiddleware({
   type: 'function',
-}).client(async () => {
-  return {
-    source: 'client-middleware',
-    message: 'Early return from client middleware',
-    timestamp: Date.now(),
-  }
+}).client(async ({ result }) => {
+  return result({
+    data: {
+      source: 'client-middleware',
+      message: 'Early return from client middleware',
+      timestamp: Date.now(),
+    },
+  })
 })
 
 const serverFn = createServerFn()

e2e/react-start/server-functions/src/routes/middleware/nested-early-return.tsx

@@ -23,13 +23,15 @@ type EarlyReturnInput = {
 // Deepest level - conditionally returns early based on input
 const deepMiddleware = createMiddleware({ type: 'function' })
   .inputValidator((input: EarlyReturnInput) => input)
-  .server(async ({ data, next }) => {
+  .server(async ({ data, next, result }) => {
     if (data.earlyReturnLevel === 'deep') {
-      return {
-        returnedFrom: 'deepMiddleware',
-        message: 'Early return from deepest middleware',
-        level: 3,
-      }
+      return result({
+        data: {
+          returnedFrom: 'deepMiddleware',
+          message: 'Early return from deepest middleware',
+          level: 3,
+        },
+      })
     }
     return next({
       context: {
@@ -41,14 +43,16 @@ const deepMiddleware = createMiddleware({ type: 'function' })
 // Middle level - wraps deep middleware, may also return early
 const middleMiddleware = createMiddleware({ type: 'function' })
   .middleware([deepMiddleware])
-  .server(async ({ data, next, context }) => {
+  .server(async ({ data, next, context, result }) => {
     if (data.earlyReturnLevel === 'middle') {
-      return {
-        returnedFrom: 'middleMiddleware',
-        message: 'Early return from middle middleware',
-        level: 2,
-        deepContext: context,
-      }
+      return result({
+        data: {
+          returnedFrom: 'middleMiddleware',
+          message: 'Early return from middle middleware',
+          level: 2,
+          deepContext: context,
+        },
+      })
     }
     return next({
       context: {
@@ -60,14 +64,16 @@ const middleMiddleware = createMiddleware({ type: 'function' })
 // Outer level - wraps middle middleware, may also return early
 const outerMiddleware = createMiddleware({ type: 'function' })
   .middleware([middleMiddleware])
-  .server(async ({ data, next, context }) => {
+  .server(async ({ data, next, context, result }) => {
     if (data.earlyReturnLevel === 'outer') {
-      return {
-        returnedFrom: 'outerMiddleware',
-        message: 'Early return from outer middleware',
-        level: 1,
-        middleContext: context,
-      }
+      return result({
+        data: {
+          returnedFrom: 'outerMiddleware',
+          message: 'Early return from outer middleware',
+          level: 1,
+          middleContext: context,
+        },
+      })
     }
     return next({
       context: {

e2e/react-start/server-functions/src/routes/middleware/server-conditional.tsx

@@ -13,13 +13,15 @@ const serverConditionalMiddleware = createMiddleware({
   .inputValidator(
     (input: { shouldShortCircuit: boolean; value: string }) => input,
   )
-  .server(async ({ data, next }) => {
+  .server(async ({ data, next, result }) => {
     if (data.shouldShortCircuit) {
-      return {
-        source: 'middleware',
-        message: 'Conditional early return from server middleware',
-        condition: 'shouldShortCircuit=true',
-      }
+      return result({
+        data: {
+          source: 'middleware',
+          message: 'Conditional early return from server middleware',
+          condition: 'shouldShortCircuit=true',
+        },
+      })
     }
     return next({
       context: {

e2e/react-start/server-functions/src/routes/middleware/server-early-return.tsx

@@ -11,11 +11,13 @@ import React from 'react'
  */
 const serverEarlyReturnMiddleware = createMiddleware({
   type: 'function',
-}).server(async () => {
-  return {
-    source: 'middleware',
-    message: 'Early return from server middleware',
-  }
+}).server(async ({ result }) => {
+  return result({
+    data: {
+      source: 'middleware',
+      message: 'Early return from server middleware',
+    },
+  })
 })
 
 const serverFn = createServerFn()
@@ -35,13 +37,15 @@ const serverFn = createServerFn()
  */
 const methodPropertyMiddleware = createMiddleware({
   type: 'function',
-}).server(async () => {
-  return {
-    source: 'middleware',
-    method: 'GET',
-    headers: { 'Content-Type': 'application/json' },
-    message: 'Early return with method property',
-  }
+}).server(async ({ result }) => {
+  return result({
+    data: {
+      source: 'middleware',
+      method: 'GET',
+      headers: { 'Content-Type': 'application/json' },
+      message: 'Early return with method property',
+    },
+  })
 })
 
 const serverFnWithMethodProperty = createServerFn()

packages/start-client-core/src/constants.ts

@@ -11,6 +11,15 @@ export const TSS_SERVER_FUNCTION_FACTORY = Symbol.for(
  */
 export const TSS_MIDDLEWARE_RESULT = Symbol.for('TSS_MIDDLEWARE_RESULT')
 
+/**
+ * Symbol used to mark middleware results that came from calling result().
+ * This allows middleware to explicitly short-circuit the chain with a typed
+ * early return value that gets tracked through the type system.
+ */
+export const TSS_MIDDLEWARE_EARLY_RESULT = Symbol.for(
+  'TSS_MIDDLEWARE_EARLY_RESULT',
+)
+
 export const X_TSS_SERIALIZED = 'x-tss-serialized'
 export const X_TSS_RAW_RESPONSE = 'x-tss-raw'
 export const X_TSS_CONTEXT = 'x-tss-context'