feat(server)!: improve context (#96)

* builders

* handlers

* wip

* fix

* fix docs

* fix tests

* fix naming

Author: dinwwwh

apps/content/content/docs/server/lazy.mdx

@@ -16,7 +16,7 @@ Here's how you can set up and use them:
 ```typescript twoslash
 import { os, call } from '@orpc/server'
 
-const pub = os.context<{ user?: { id: string } } | undefined>()
+const pub = os.context<{ user?: { id: string } }>()
 
 // Define a router with lazy loading
 const router = pub.router({

apps/content/content/docs/server/server-action.mdx

@@ -43,7 +43,7 @@ When calling `.actionable()`, you can pass a context function that provides addi
 import { os } from '@orpc/server'
 import { z } from 'zod'
 
-const pub = os.context<{ db: string } | undefined>()
+const pub = os.context<{ db: string }>()
 
 export const getting = pub
   .input(z.object({

apps/content/examples/server.ts

@@ -3,13 +3,13 @@ import { ORPCError, os } from '@orpc/server'
 import { oz, ZodCoercer } from '@orpc/zod'
 import { z } from 'zod'
 
-export type Context = { user?: { id: string } } | undefined
+export type Context = { user?: { id: string } }
 
 // global pub, authed completely optional
 export const pub = os.context<Context>()
 export const authed = pub.use(({ context, path, next }, input) => {
   /** put auth logic here */
-  return next({})
+  return next()
 })
 
 export const router = pub.router({

packages/openapi/src/adapters/fetch/openapi-handler.ts

@@ -45,7 +45,7 @@ export class OpenAPIHandler<T extends Context> implements FetchHandler<T> {
   }
 
   async handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult> {
-    const context = options?.context as T
+    const context = options?.context ?? {} as T
     const headers = request.headers
     const accept = headers.get('accept') || undefined
 

packages/server/src/adapters/fetch/orpc-handler.ts

@@ -1,6 +1,6 @@
 import type { Hooks } from '@orpc/shared'
+import type { Context } from '../../context'
 import type { Router } from '../../router'
-import type { Context } from '../../types'
 import type { FetchHandler, FetchHandleRest, FetchHandleResult } from './types'
 import { ORPCError } from '@orpc/contract'
 import { executeWithHooks, trim } from '@orpc/shared'
@@ -25,7 +25,7 @@ export class RPCHandler<T extends Context> implements FetchHandler<T> {
   }
 
   async handle(request: Request, ...[options]: FetchHandleRest<T>): Promise<FetchHandleResult> {
-    const context = options?.context as T
+    const context = options?.context ?? {} as T
 
     const execute = async (): Promise<FetchHandleResult> => {
       const url = new URL(request.url)

packages/server/src/adapters/fetch/types.test-d.ts

@@ -1,8 +1,8 @@
 import type { FetchHandler } from './types'
 
 describe('FetchHandler', () => {
-  it('optional context when context is undefinable', () => {
-    const handler = {} as FetchHandler<{ auth: boolean } | undefined>
+  it('optional context when all context is optional', () => {
+    const handler = {} as FetchHandler<{ auth?: boolean }>
 
     handler.handle(new Request('https://example.com'))
     handler.handle(new Request('https://example.com'), { context: { auth: true } })

packages/server/src/adapters/fetch/types.ts

@@ -1,11 +1,14 @@
 import type { HTTPPath } from '@orpc/contract'
-import type { Context } from '../../types'
+import type { Context } from '../../context'
 
 export type FetchHandleOptions<T extends Context> =
   & { prefix?: HTTPPath }
-  & (undefined extends T ? { context?: T } : { context: T })
+  & (Record<never, never> extends T ? { context?: T } : { context: T })
+
+export type FetchHandleRest<T extends Context> =
+  | [options: FetchHandleOptions<T>]
+  | (Record<never, never> extends T ? [] : never)
 
-export type FetchHandleRest<T extends Context> = [options: FetchHandleOptions<T>] | (undefined extends T ? [] : never)
 export type FetchHandleResult = { matched: true, response: Response } | { matched: false, response: undefined }
 
 export interface FetchHandler<T extends Context> {

packages/server/src/adapters/hono/middleware.ts

@@ -1,19 +1,21 @@
 import type { Context as HonoContext, MiddlewareHandler } from 'hono'
-import type { Context } from '../../types'
+import type { Context } from '../../context'
 import type { FetchHandleOptions, FetchHandler } from '../fetch'
 import { value, type Value } from '@orpc/shared'
 
 export type CreateMiddlewareOptions<T extends Context> =
   & Omit<FetchHandleOptions<T>, 'context'>
-  & (undefined extends T ? { context?: Value<T, [HonoContext]> } : { context: Value<T, [HonoContext]> })
+  & (Record<never, never> extends T ? { context?: Value<T, [HonoContext]> } : { context: Value<T, [HonoContext]> })
 
-export type CreateMiddlewareRest<T extends Context> = [options: CreateMiddlewareOptions<T>] | (undefined extends T ? [] : never)
+export type CreateMiddlewareRest<T extends Context> =
+  | [options: CreateMiddlewareOptions<T>]
+  | (Record<never, never> extends T ? [] : never)
 
 export function createMiddleware<T extends Context>(handler: FetchHandler<T>, ...[options]: CreateMiddlewareRest<T>): MiddlewareHandler {
   return async (c, next) => {
-    const context = await value(options?.context, c)
+    const context = await value(options?.context ?? {}, c) as any
 
-    const { matched, response } = await handler.handle(c.req.raw, { ...options, context } as any)
+    const { matched, response } = await handler.handle(c.req.raw, { ...options, context })
 
     if (matched) {
       c.res = response

packages/server/src/adapters/next/serve.ts

@@ -1,13 +1,15 @@
 import type { NextRequest } from 'next/server'
-import type { Context } from '../../types'
+import type { Context } from '../../context'
 import type { FetchHandleOptions, FetchHandler } from '../fetch'
 import { value, type Value } from '@orpc/shared'
 
 export type ServeOptions<T extends Context> =
   & Omit<FetchHandleOptions<T>, 'context'>
-  & (undefined extends T ? { context?: Value<T, [NextRequest]> } : { context: Value<T, [NextRequest]> })
+  & (Record<never, never> extends T ? { context?: Value<T, [NextRequest]> } : { context: Value<T, [NextRequest]> })
 
-export type ServeRest<T extends Context> = [options: ServeOptions<T>] | (undefined extends T ? [] : never)
+export type ServeRest<T extends Context> =
+  | [options: ServeOptions<T>]
+  | (Record<never, never> extends T ? [] : never)
 
 export interface ServeResult {
   GET: (req: NextRequest) => Promise<Response>
@@ -19,7 +21,7 @@ export interface ServeResult {
 
 export function serve<T extends Context>(handler: FetchHandler<T>, ...[options]: ServeRest<T>): ServeResult {
   const main = async (req: NextRequest) => {
-    const context = await value(options?.context, req) as any
+    const context = await value(options?.context ?? {}, req) as any
 
     const { matched, response } = await handler.handle(req, { ...options, context })
 

packages/server/src/adapters/node/orpc-handler.ts

@@ -1,6 +1,6 @@
 import type { ServerResponse } from 'node:http'
+import type { Context } from '../../context'
 import type { Router } from '../../router'
-import type { Context } from '../../types'
 import type { RPCHandlerOptions } from '../fetch/orpc-handler'
 import type { RequestHandler, RequestHandleRest, RequestHandleResult } from './types'
 import { RPCHandler as ORPCFetchHandler } from '../fetch/orpc-handler'
@@ -13,18 +13,18 @@ export class RPCHandler<T extends Context> implements RequestHandler<T> {
     this.orpcFetchHandler = new ORPCFetchHandler(router, options)
   }
 
-  async handle(req: ExpressableIncomingMessage, res: ServerResponse, ...[options]: RequestHandleRest<T>): Promise<RequestHandleResult> {
+  async handle(req: ExpressableIncomingMessage, res: ServerResponse, ...rest: RequestHandleRest<T>): Promise<RequestHandleResult> {
     const request = createRequest(req, res)
 
-    const castedOptions = (options ?? {}) as Exclude<typeof options, undefined>
-
-    const result = await this.orpcFetchHandler.handle(request, castedOptions)
+    const result = await this.orpcFetchHandler.handle(request, ...rest)
 
     if (result.matched === false) {
       return { matched: false }
     }
 
-    await options?.beforeSend?.(result.response, castedOptions.context as T)
+    const context = rest[0]?.context ?? {} as T
+
+    await rest[0]?.beforeSend?.(result.response, context)
 
     await sendResponse(res, result.response)