orpc-fn 0.1.0 → 0.2.0

package/src/expo.ts

@@ -41,13 +41,17 @@ export function createExpoFetch(options: {
 	fetch: ExpoFetch
 	/** `Platform.OS !== 'web'`. */
 	native: boolean
+	webFetch?: (request: Request, init?: RequestInit) => Promise<Response>
 }) {
 	return async (
 		request: Request,
 		init?: { redirect?: NonNullable<RequestInit['redirect']> }
 	): Promise<Response> => {
 		if (!options.native) {
-			return globalThis.fetch(request, { ...init, credentials: 'include' })
+			return (options.webFetch ?? globalThis.fetch)(request, {
+				...init,
+				credentials: 'include'
+			})
 		}
 		const hasBody = request.method !== 'GET' && request.method !== 'HEAD'
 		const body = hasBody ? await request.arrayBuffer() : undefined
@@ -67,59 +71,60 @@ export function createExpoFetch(options: {
 
 export type CreateExpoLinkOptions<T extends ClientContext> = Omit<
 	CreateRpcLinkOptions<T>,
-	'fetch' | 'headers'
+	'fetch'
 > & {
 	fetch: ExpoFetch
 	native: boolean
-	/** Session cookie, e.g. Better Auth's `authClient.getCookie()`. */
-	getCookie?: () => string | null | undefined
-	/** `expo-origin` header; the server copies it to `origin` (`normalizeExpoOrigin`). */
-	getExpoOrigin?: () => string | null | undefined
-	/** Extra headers on every request. */
-	headers?: () => Record<string, string>
+	/** Explicit browser fetch override; native always uses expo/fetch. */
+	webFetch?: (request: Request, init?: RequestInit) => Promise<Response>
 }
 
-/**
- * `createRpcLink` for Expo: batching, the `expo/fetch` bridge and the headers
- * a Better Auth Expo client sends, so the API sees the same session and
- * origin as `/api/auth` requests.
- *
- * ```ts
- * import { fetch } from 'expo/fetch'
- * import { Platform } from 'react-native'
- *
- * const link = createExpoLink({
- *   url: `${baseUrl}/api/rpc`,
- *   fetch,
- *   native: Platform.OS !== 'web',
- *   getCookie: () => authClient.getCookie(),
- *   getExpoOrigin
- * })
- * ```
- */
+/** Generic streaming bridge with upstream async/context-aware headers. */
 export function createExpoLink<T extends ClientContext = ClientContext>(
 	options: CreateExpoLinkOptions<T>
 ): RPCLink<T> {
-	const {
-		fetch,
-		native,
-		getCookie,
-		getExpoOrigin,
-		headers: extraHeaders,
-		...rest
-	} = options
+	const { fetch, native, webFetch, ...rest } = options
 	return createRpcLink<T>({
 		...rest,
-		fetch: createExpoFetch({ fetch, native }),
-		headers: () => {
-			const headers: Record<string, string> = { ...extraHeaders?.() }
-			const cookie = getCookie?.()
-			if (cookie) headers.Cookie = cookie
-			if (native) {
-				// What @better-auth/expo sends from native, for session and CORS parity.
-				headers['x-skip-oauth-proxy'] = 'true'
-				const origin = getExpoOrigin?.()
-				if (origin) headers['expo-origin'] = origin
+		fetch: createExpoFetch({ fetch, native, ...(webFetch ? { webFetch } : {}) })
+	})
+}
+
+export type CreateBetterAuthExpoLinkOptions<T extends ClientContext> =
+	CreateExpoLinkOptions<T> & {
+		getCookie?: () =>
+			| string
+			| null
+			| undefined
+			| Promise<string | null | undefined>
+		getExpoOrigin?: () =>
+			| string
+			| null
+			| undefined
+			| Promise<string | null | undefined>
+	}
+
+/** Better Auth's native cookie/origin headers, kept behind an explicit preset. */
+export function createBetterAuthExpoLink<
+	T extends ClientContext = ClientContext
+>(options: CreateBetterAuthExpoLinkOptions<T>): RPCLink<T> {
+	const { getCookie, getExpoOrigin, headers: extraHeaders, ...rest } = options
+	return createExpoLink<T>({
+		...rest,
+		headers: async (...args) => {
+			const supplied =
+				typeof extraHeaders === 'function'
+					? await extraHeaders(...args)
+					: await extraHeaders
+			const headers = new Headers(
+				supplied as ConstructorParameters<typeof Headers>[0]
+			)
+			const cookie = await getCookie?.()
+			if (cookie) headers.set('Cookie', cookie)
+			if (options.native) {
+				headers.set('x-skip-oauth-proxy', 'true')
+				const origin = await getExpoOrigin?.()
+				if (origin) headers.set('expo-origin', origin)
 			}
 			return headers
 		}

package/src/hono.ts

@@ -1,4 +1,5 @@
 import { SmartCoercionPlugin } from '@orpc/json-schema'
+import type { OpenAPIGeneratorGenerateOptions } from '@orpc/openapi'
 import { OpenAPIHandler } from '@orpc/openapi/fetch'
 import { OpenAPIReferencePlugin } from '@orpc/openapi/plugins'
 import {
@@ -12,6 +13,7 @@ import type { StandardHandlerPlugin } from '@orpc/server/standard'
 import { ZodToJsonSchemaConverter } from '@orpc/zod/zod4'
 import type { Context as HonoContext, Env, Hono } from 'hono'
 import type { StatusCode } from 'hono/utils/http-status'
+import { REQUEST_TIMING, type InvocationTiming } from './timing.js'
 import { isExpectedClientError } from './expected-client-error.js'
 import type { ProcedureFilter } from './mcp.js'
 
@@ -40,8 +42,7 @@ type ContextOption<E extends Env, R extends AnyRouter> =
 		: { context: ContextFactory<E, R> }
 
 type Path = `/${string}`
-// biome-ignore lint/suspicious/noExplicitAny: plugins are context-agnostic here
-type Plugin = StandardHandlerPlugin<any>
+type Plugin<T extends object> = StandardHandlerPlugin<T>
 
 export type MountOrpcOptions<
 	E extends Env,
@@ -61,8 +62,8 @@ export type MountOrpcOptions<
 		/** Turn JSON strings back into `Date`s etc. for `z.date()` inputs. */
 		smartCoercion?: boolean
 		/** Extra spec fields, e.g. `components.securitySchemes` and `security`. */
-		spec?: Record<string, unknown>
-		plugins?: Plugin[]
+		spec?: Omit<OpenAPIGeneratorGenerateOptions, 'filter'>
+		plugins?: Plugin<InferRouterInitialContext<R>>[]
 	}
 	/** Collapse parallel RPC calls into one HTTP request. Default: true (25 calls). */
 	batch?: boolean | { maxSize: number }
@@ -71,7 +72,7 @@ export type MountOrpcOptions<
 	/** SSE keep-alive comments every N ms (default 15000), or false. */
 	sseKeepAlive?: boolean | number
 	/** Extra RPC plugins (e.g. `CORSPlugin`). */
-	plugins?: Plugin[]
+	plugins?: Plugin<InferRouterInitialContext<R>>[]
 	/** Rewrite request headers before they reach the context (see `normalizeExpoOrigin`). */
 	normalizeHeaders?: (headers: Headers) => Headers
 	/** Time spent before the handler ran, reported as `queue`. */
@@ -116,7 +117,7 @@ export function formatServerTiming(
  * for nginx/Fastly to hold until an idle kill). A copy: some responses (e.g.
  * redirects) have immutable headers.
  */
-function finishHeaders(
+export function finishOrpcHeaders(
 	response: Response,
 	serverTiming: string | undefined
 ): Headers {
@@ -157,14 +158,21 @@ export function mountOrpc<E extends Env, R extends AnyRouter>(
 		error: unknown,
 		{ request }: { request: { url: URL; method: string } }
 	) => {
-		if (isExpectedError(error)) return
-		options.onError?.(error, {
-			url: request.url.pathname,
-			method: request.method
-		})
+		try {
+			if (isExpectedError(error)) return
+			options.onError?.(error, {
+				url: request.url.pathname,
+				method: request.method
+			})
+		} catch {
+			/* Error reporting cannot replace transport outcomes. */
+		}
 	}
 
-	const mount = (prefix: Path, handler: Pick<RPCHandler<object>, 'handle'>) => {
+	const mount = (
+		prefix: Path,
+		handler: Pick<RPCHandler<InferRouterInitialContext<R>>, 'handle'>
+	) => {
 		app.use(`${prefix}/*`, async (c, next) => {
 			const timing: RequestTiming = {}
 			const queueMs = options.queueMs?.(c.req.raw)
@@ -178,24 +186,33 @@ export function mountOrpc<E extends Env, R extends AnyRouter>(
 				? await options.context(c, { headers, timing })
 				: { headers, timing }
 			if (context instanceof Response) return context
+			const invocationTiming: InvocationTiming = { procedureMs: 0, calls: 0 }
 			const { matched, response } = await handler.handle(c.req.raw, {
 				prefix,
-				context: context as object
+				context: {
+					...context,
+					[REQUEST_TIMING]: invocationTiming
+				} as InferRouterInitialContext<R>
 			})
 			if (!matched) return next()
 			const timed = serverTiming
-				? formatServerTiming(performance.now() - started, timing)
+				? formatServerTiming(performance.now() - started, {
+						...timing,
+						handler_ms: invocationTiming.procedureMs
+					})
 				: undefined
 			return c.newResponse(response.body, {
 				// oRPC only produces valid HTTP status codes.
 				status: response.status as StatusCode,
-				headers: finishHeaders(response, timed)
+				headers: finishOrpcHeaders(response, timed)
 			})
 		})
 	}
 
 	if (options.rpcPrefix) {
-		const plugins: Plugin[] = [...(options.plugins ?? [])]
+		const plugins: Plugin<InferRouterInitialContext<R>>[] = [
+			...(options.plugins ?? [])
+		]
 		if (batch) {
 			plugins.push(
 				new BatchHandlerPlugin({
@@ -217,7 +234,9 @@ export function mountOrpc<E extends Env, R extends AnyRouter>(
 		const { openapi } = options
 		const filter = openapi.filter ? { filter: openapi.filter } : {}
 		const converters = [new ZodToJsonSchemaConverter()]
-		const plugins: Plugin[] = [...(openapi.plugins ?? [])]
+		const plugins: Plugin<InferRouterInitialContext<R>>[] = [
+			...(openapi.plugins ?? [])
+		]
 		if (openapi.smartCoercion) {
 			plugins.push(new SmartCoercionPlugin({ schemaConverters: converters }))
 		}

package/src/index.ts

@@ -11,7 +11,7 @@ export {
 	type FnLogger,
 	type LogAttributes
 } from './logger.js'
-export { FN_META_KEY, type FnMeta, readFnMeta } from './meta.js'
+export { defineMeta, FN_META_KEY, type FnMeta, readFnMeta } from './meta.js'
 export type {
 	AttributeValue,
 	OtelApiLike,
@@ -19,7 +19,11 @@ export type {
 	SpanOf,
 	Tracing
 } from './otel.js'
-export { createRouter } from './router.js'
+export {
+	createRouter,
+	createStreamManifest,
+	createStreamManifestAsync
+} from './router.js'
 export type {
 	AnyFnContext,
 	BuilderLike,

package/src/json-schema.ts

@@ -80,3 +80,19 @@ export function passThroughOutputSchema<TOut>(
 		}
 	}
 }
+
+/** Tool protocols permit unions only when every branch accepts an object. */
+export function isObjectJsonSchema(schema: JsonSchema): boolean {
+	if (schema.type === 'object') return true
+	const union = schema.anyOf ?? schema.oneOf
+	return (
+		Array.isArray(union) &&
+		union.length > 0 &&
+		union.every(
+			(branch) =>
+				typeof branch === 'object' &&
+				branch !== null &&
+				isObjectJsonSchema(branch)
+		)
+	)
+}

package/src/live/codec.ts

@@ -9,12 +9,15 @@ const MARKER = 'orpc-fn'
  * intact. Payloads without the envelope are read as plain JSON, so a
  * publisher on the old format keeps working during a rolling deploy.
  */
-export function encodePayload(value: unknown): string {
+export function encodePayload(
+	value: unknown,
+	id: string = crypto.randomUUID()
+): string {
 	const [json, meta, maps, blobs] = serializer.serialize(value)
 	if (maps.length > 0 || blobs.length > 0) {
 		throw new TypeError('orpc-fn: pub/sub events cannot contain files or blobs')
 	}
-	return JSON.stringify({ [MARKER]: 1, json, meta })
+	return JSON.stringify({ [MARKER]: 2, id, json, meta })
 }
 
 export function decodePayload(payload: string): unknown {
@@ -22,10 +25,26 @@ export function decodePayload(payload: string): unknown {
 	if (
 		typeof parsed === 'object' &&
 		parsed !== null &&
-		(parsed as Record<string, unknown>)[MARKER] === 1
+		[1, 2].includes(Number((parsed as Record<string, unknown>)[MARKER]))
 	) {
 		const { json, meta } = parsed as { json: unknown; meta: [] }
 		return serializer.deserialize(json, meta)
 	}
 	return parsed
 }
+
+/** IDs distinguish replay/live overlap; legacy payloads remain readable. */
+export function decodeMessage(payload: string): {
+	id: string | undefined
+	value: unknown
+} {
+	const envelope = JSON.parse(payload) as unknown
+	const id =
+		typeof envelope === 'object' &&
+		envelope !== null &&
+		(envelope as Record<string, unknown>)[MARKER] === 2 &&
+		typeof (envelope as Record<string, unknown>).id === 'string'
+			? (envelope as { id: string }).id
+			: undefined
+	return { id, value: decodePayload(payload) }
+}