spiceflow 1.0.1 → 1.0.3

package/src/spiceflow.ts

@@ -10,6 +10,8 @@ import {
 	DefinitionBase,
 	EphemeralType,
 	ErrorHandler,
+	Handler,
+	HTTPMethod,
 	InlineHandler,
 	InputSchema,
 	JoinPath,
@@ -24,20 +26,41 @@ import {
 	RouteBase,
 	RouteSchema,
 	SingletonBase,
-	UnwrapRoute
+	TypeSchema,
+	UnwrapRoute,
 } from './elysia-fork/types.js'
+import addFormats from 'ajv-formats'
+let globalIndex = 0
 
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import OriginalRouter from '@medley/router'
 import { TSchema } from '@sinclair/typebox'
-import Ajv from 'ajv'
+import Ajv, { ValidateFunction } from 'ajv'
 import { Context } from './elysia-fork/context.js'
 import { isAsyncIterable } from './utils.js'
 import { redirect } from './elysia-fork/utils.js'
 import { ValidationError } from './elysia-fork/error.js'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import { z, ZodType } from 'zod'
+
+const ajv = addFormats(new Ajv({ useDefaults: true }), [
+	'date-time',
+	'time',
+	'date',
+	'email',
+	'hostname',
+	'ipv4',
+	'ipv6',
+	'uri',
+	'uri-reference',
+	'uuid',
+	'uri-template',
+	'json-pointer',
+	'relative-json-pointer',
+	'regex',
+])
 
-const ajv = new Ajv()
 // Should be exported from `hono/router`
 
 type P = any
@@ -47,19 +70,31 @@ type AsyncResponse = Response | Promise<Response>
 type OnError = (x: { error: any; request: Request }) => AsyncResponse
 
 type RouterTree = {
+	id: number
 	router: OriginalRouter
 	prefix?: string
 	onRequestHandlers: Function[]
 	onErrorHandlers: OnError[]
 	children: RouterTree[]
+	routes: InternalRoute[]
+	// default store for the router, used as default for context.store
 	store: Record<any, any>
+	currentRoot?: RouterTree
 }
 
 type OnNoMatch = (request: Request, platform: P) => AsyncResponse
 
-type InternalRouterState = {
-	hook: any
-	handler: any
+export type InternalRoute = {
+	method: HTTPMethod
+	path: string
+	handler: InlineHandler<any, any, any>
+	hooks: LocalHook<any, any, any, any, any, any, any>
+	validateBody?: ValidateFunction
+	validateQuery?: ValidateFunction
+	validateParams?: ValidateFunction
+
+	prefix: string
+
 	// store: Record<any, any>
 }
 /**
@@ -95,40 +130,78 @@ export class Spiceflow<
 		derive: {}
 		resolve: {}
 		schema: {}
-	}
+	},
 > {
 	private onNoMatch: OnNoMatch
 	// prefix: BasePath | undefined
-	routerTree: RouterTree
+	private routerTree: RouterTree
+
+	getAllRoutes() {
+		let root = this.routerTree.currentRoot || this.routerTree
+		const allApps = bfs(root) || []
+		const allRoutes = allApps.flatMap((x) => {
+			const prefix = this.getRouteAndParents(x)
+				.map((x) => x.prefix)
+				.reverse()
+				.join('')
+
+			return x.routes.map((x) => ({ ...x, path: prefix + x.path }))
+		})
+		return allRoutes
+	}
 
-	add({
+	private add({
 		method,
 		path,
+		hooks,
+		handler,
 		...rest
-	}: InternalRouterState & {
-		method: string
-		path: string
-	}) {
+	}: Partial<InternalRoute>) {
 		const router = this.routerTree
 		// if (router.prefix) {
 		// 	path = router.prefix + path
 		// }
 
+		let bodySchema: TypeSchema = hooks?.body
+		let validateBody = getValidateFunction(bodySchema)
+		let validateQuery = getValidateFunction(hooks?.query)
+		let validateParams = getValidateFunction(hooks?.params)
+
 		const store = router.router.register(path)
-		store[method] = { ...rest }
+		let route: InternalRoute = {
+			...rest,
+
+			prefix: router.prefix || '',
+			method: (method || '') as any,
+			path: path || '',
+			// prefix,
+			handler: handler!,
+			hooks,
+			validateBody,
+			validateParams,
+			validateQuery,
+		}
+		router.routes.push(route)
+		store[method] = route
 	}
 
 	private match(method: string, path: string) {
-		const result = bfs(this.routerTree, (router) => {
-			if (router.prefix && !path.startsWith(router.prefix)) {
+		let root = this.routerTree
+		const result = bfsFind(this.routerTree, (router) => {
+			router.currentRoot = root
+			let prefix = this.getRouteAndParents(router)
+				.map((x) => x.prefix)
+				.reverse()
+				.join('')
+			if (prefix && !path.startsWith(prefix)) {
 				// console.log(
 				// 	`router prefix: ${router.prefix} does not match path: ${path}`
 				// )
 				return
 			}
 			let pathWithoutPrefix = path
-			if (router.prefix) {
-				pathWithoutPrefix = path.replace(router.prefix, '')
+			if (prefix) {
+				pathWithoutPrefix = path.replace(prefix, '')
 			}
 			// console.log(`router prefix: ${router.prefix} matches path: ${path}`)
 			const route = router.router.find(pathWithoutPrefix)
@@ -136,19 +209,20 @@ export class Spiceflow<
 				return
 			}
 
-			let data: InternalRouterState = route['store'][method]
+			let data: InternalRoute = route['store'][method]
 			if (data) {
 				// console.log(`route found: ${method} ${path}`, route)
 
 				const { onErrorHandlers, onRequestHandlers } = router
 				const params = route['params'] || {}
+
 				return {
 					...data,
 					router,
 					store: router.store,
 					onErrorHandlers,
 					onRequestHandlers,
-					params
+					params,
 				}
 			}
 		})
@@ -158,7 +232,7 @@ export class Spiceflow<
 
 	state<const Name extends string | number | symbol, Value>(
 		name: Name,
-		value: Value
+		value: Value,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -189,24 +263,25 @@ export class Spiceflow<
 	 */
 	constructor(
 		options: {
-			/** Fallback handle if an error is thrown (500 response is default) */
-			// onError?: OnError
+			name?: string
 			scoped?: Scoped
 			onNoMatch?: (request: Request, platform: P) => AsyncResponse
 			basePath?: BasePath
-		} = {}
+		} = {},
 	) {
 		this.scoped = options.scoped
 
 		this.onNoMatch =
 			options.onNoMatch ?? (() => new Response(null, { status: 404 }))
 		this.routerTree = {
+			id: globalIndex++,
 			router: new OriginalRouter(),
 			prefix: options.basePath,
 			onRequestHandlers: [],
 			onErrorHandlers: [],
 			children: [],
-			store: {}
+			store: {},
+			routes: [],
 		}
 
 		// Bind router methods
@@ -224,13 +299,12 @@ export class Spiceflow<
 		Scoped: false as Scoped,
 		Singleton: {} as Singleton,
 		Definitions: {} as Definitions,
-		Metadata: {} as Metadata
+		Metadata: {} as Metadata,
 	}
 
 	_ephemeral = {} as Ephemeral
 	_volatile = {} as Volatile
 
-	
 	post<
 		const Path extends string,
 		const LocalSchema extends InputSchema<
@@ -250,7 +324,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -264,7 +338,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -281,7 +355,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -292,7 +366,7 @@ export class Spiceflow<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'POST', path, handler: handler, hook })
+		this.add({ method: 'POST', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -317,7 +391,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -331,7 +405,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Macro,
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -348,7 +422,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -359,7 +433,7 @@ export class Spiceflow<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'GET', path, handler: handler, hook })
+		this.add({ method: 'GET', path, handler: handler, hooks: hook })
 		return this as any
 	}
 
@@ -382,7 +456,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -396,7 +470,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -413,7 +487,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -424,7 +498,7 @@ export class Spiceflow<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'PUT', path, handler: handler, hook })
+		this.add({ method: 'PUT', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -448,7 +522,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -462,7 +536,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -479,7 +553,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -490,7 +564,7 @@ export class Spiceflow<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'PATCH', path, handler: handler, hook })
+		this.add({ method: 'PATCH', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -514,7 +588,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -528,7 +602,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -545,7 +619,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -556,7 +630,7 @@ export class Spiceflow<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'DELETE', path, handler: handler, hook })
+		this.add({ method: 'DELETE', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -580,7 +654,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -594,7 +668,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -611,7 +685,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -622,7 +696,7 @@ export class Spiceflow<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'OPTIONS', path, handler: handler, hook })
+		this.add({ method: 'OPTIONS', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -646,7 +720,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -660,7 +734,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -677,7 +751,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -689,7 +763,7 @@ export class Spiceflow<
 		Volatile
 	> {
 		for (const method of METHODS) {
-			this.add({ method, path, handler: handler, hook })
+			this.add({ method, path, handler: handler, hooks: hook })
 		}
 
 		return this as any
@@ -714,7 +788,7 @@ export class Spiceflow<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -728,7 +802,7 @@ export class Spiceflow<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
+		>,
 	): Spiceflow<
 		BasePath,
 		Scoped,
@@ -745,7 +819,7 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-						headers: Schema['headers']
+
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
@@ -756,7 +830,7 @@ export class Spiceflow<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'HEAD', path, handler: handler, hook })
+		this.add({ method: 'HEAD', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -766,7 +840,7 @@ export class Spiceflow<
 	 *
 	 * @default false
 	 */
-	scoped?: Scoped
+	private scoped?: Scoped
 	get _scoped() {
 		return this.scoped as Scoped
 	}
@@ -811,7 +885,7 @@ export class Spiceflow<
 	// }
 
 	use<const NewSpiceflow extends AnySpiceflow>(
-		instance: NewSpiceflow
+		instance: NewSpiceflow,
 	): NewSpiceflow['_scoped'] extends false
 		? Spiceflow<
 				BasePath,
@@ -840,14 +914,7 @@ export class Spiceflow<
 		  > {
 		const thisRouter = this.routerTree
 		// TODO use scoped logic to add onRequest and onError on all routers if necessary, add them first
-		this.routerTree.children.push(
-			mapBfs(instance.routerTree, (r) => {
-				return {
-					...r,
-					prefix: (thisRouter.prefix || '') + r.prefix
-				}
-			})
-		)
+		this.routerTree.children.push(instance.routerTree)
 		return this as any
 	}
 
@@ -866,7 +933,7 @@ export class Spiceflow<
 				Ephemeral,
 				Volatile
 			>
-		>
+		>,
 	): this {
 		const router = this.routerTree
 
@@ -893,7 +960,7 @@ export class Spiceflow<
 					resolve: {}
 				}
 			>
-		>
+		>,
 	) {
 		const router = this.routerTree
 		router.onRequestHandlers ??= []
@@ -909,12 +976,13 @@ export class Spiceflow<
 	 */
 	async handle(request: Request, platform?: P): Promise<Response> {
 		platform ??= {} as P
+
 		let u = new URL(request.url)
 		let path = u.pathname + u.search
 		const defaultContext = {
 			redirect,
 			error: null,
-			path
+			path,
 		}
 		let onErrorHandlers: OnError[] = []
 		try {
@@ -925,41 +993,37 @@ export class Spiceflow<
 			if (!route) {
 				return this.onNoMatch(request, platform)
 			}
-			onErrorHandlers = this.getRouteAndParents(route.router).flatMap(
-				(x) => x.onErrorHandlers
-			)
-			const { params, store } = route
-			const onReq = this.getRouteAndParents(route.router).flatMap(
-				(x) => x.onRequestHandlers
-			)
+			onErrorHandlers = this.getRouteAndParents(route.router)
+				.reverse()
+				.flatMap((x) => x.onErrorHandlers)
+			let { params, store: defaultStore } = route
+			const onReqHandlers = this.getRouteAndParents(route.router)
+				.reverse()
+				.flatMap((x) => x.onRequestHandlers)
+			// console.log({ onReqHandlers })
+			let store = { ...defaultStore }
 			// TODO add content type
 
-			let content = route?.hook?.content
-			let body = await getRequestBody({ request, content })
-			let bodySchema: TSchema = route?.hook?.body
-			if (bodySchema) {
-				const validate = ajv.compile(bodySchema)
-				const valid = validate(body)
-				if (!valid) {
-					const error = ajv.errorsText(validate.errors, {
-						separator: '\n'
-					})
+			let content = route?.hooks?.content
+			// let body = await getRequestBody({ request, content })
 
-					return new Response(error, {
-						status: 400,
-						headers: {
-							'content-type': 'text/plain'
-						}
-					})
-				}
+			if (route.validateBody) {
+				// TODO don't clone the request
+				let typedRequest = new TypedRequest(request)
+				typedRequest.validateBody = route.validateBody
+				request = typedRequest
 			}
-			if (onReq.length > 0) {
-				for (const handler of onReq) {
+
+			let query = parseQuery.parse((u.search || '').slice(1))
+
+			if (onReqHandlers.length > 0) {
+				for (const handler of onReqHandlers) {
 					const res = await handler({
 						request,
 						response,
 						store,
-						path
+						path,
+						query,
 					} satisfies Context<any, any, any>)
 					if (res) {
 						return await turnHandlerResultIntoResponse(res)
@@ -967,6 +1031,9 @@ export class Spiceflow<
 				}
 			}
 
+			query = runValidation(query, route.validateQuery)
+			params = runValidation(params, route.validateParams)
+
 			// console.log(route)
 
 			const res = route.handler({
@@ -975,8 +1042,9 @@ export class Spiceflow<
 				response,
 				params: params as any,
 				store,
-				body,
-				path
+				query,
+				// body,
+				path,
 
 				// platform
 			} satisfies Context<any, any, string>)
@@ -984,20 +1052,22 @@ export class Spiceflow<
 				return await this.handleStream({
 					generator: res,
 					request,
-					onErrorHandlers
+					onErrorHandlers,
 				})
 			}
 
 			return await turnHandlerResultIntoResponse(res)
 		} catch (err: any) {
+			if (err instanceof Response) return err
 			let res = await this.runErrorHandlers({
 				onErrorHandlers,
 				error: err,
-				request
+				request,
 			})
 			if (res) return res
+			let status = err?.status ?? 500
 			return new Response(err?.message || 'Internal Server Error', {
-				status: 500
+				status,
 			})
 		}
 	}
@@ -1005,7 +1075,7 @@ export class Spiceflow<
 	private async runErrorHandlers({
 		onErrorHandlers = [] as OnError[],
 		error: err,
-		request
+		request,
 	}) {
 		if (onErrorHandlers.length === 0) {
 			console.error(`Spiceflow unhandled error:`, err)
@@ -1019,31 +1089,33 @@ export class Spiceflow<
 		}
 	}
 
+	// get the route parents, the order is starting from the current router and going up to the root
 	private getRouteAndParents(currentRouter?: RouterTree) {
 		const parents: RouterTree[] = []
 		let current = currentRouter
 
+		let root = this.routerTree.currentRoot || this.routerTree
 		// Perform BFS once to build a parent map
-		const parentMap = new Map<RouterTree, RouterTree>()
-		bfs(this.routerTree, (node) => {
+		const parentMap = new Map<number, RouterTree>()
+		bfsFind(root, (node) => {
 			for (const child of node.children) {
-				parentMap.set(child, node)
+				parentMap.set(child.id, node)
 			}
 		})
 
 		// Traverse the parent map to get the parents
 		while (current) {
-			parents.unshift(current)
-			current = parentMap.get(current)
+			parents.push(current)
+			current = parentMap.get(current.id)
 		}
 
-		return parents.reverse().filter((x) => x !== undefined)
+		return parents.filter((x) => x !== undefined)
 	}
 
-	async handleStream({
+	private async handleStream({
 		onErrorHandlers,
 		generator,
-		request
+		request,
 	}: {
 		generator: Generator | AsyncGenerator
 		onErrorHandlers: OnError[]
@@ -1076,9 +1148,9 @@ export class Spiceflow<
 						controller.enqueue(
 							Buffer.from(
 								`event: message\ndata: ${JSON.stringify(
-									init.value
-								)}\n\n`
-							)
+									init.value,
+								)}\n\n`,
+							),
 						)
 
 					try {
@@ -1089,23 +1161,23 @@ export class Spiceflow<
 							controller.enqueue(
 								Buffer.from(
 									`event: message\ndata: ${JSON.stringify(
-										chunk
-									)}\n\n`
-								)
+										chunk,
+									)}\n\n`,
+								),
 							)
 						}
 					} catch (error: any) {
 						let res = await self.runErrorHandlers({
 							onErrorHandlers: onErrorHandlers,
 							error,
-							request
+							request,
 						})
 						controller.enqueue(
 							Buffer.from(
 								`event: error\ndata: ${JSON.stringify(
-									error.message || error.name || 'Error'
-								)}\n\n`
-							)
+									error.message || error.name || 'Error',
+								)}\n\n`,
+							),
 						)
 					}
 
@@ -1114,74 +1186,74 @@ export class Spiceflow<
 					} catch {
 						// nothing
 					}
-				}
+				},
 			}),
 			{
 				// TODO add headers somehow
 				headers: {
 					// Manually set transfer-encoding for direct response, eg. app.handle, eden
 					'transfer-encoding': 'chunked',
-					'content-type': 'text/event-stream; charset=utf-8'
+					'content-type': 'text/event-stream; charset=utf-8',
 					// ...set?.headers
-				}
-			}
+				},
+			},
 		)
 	}
 }
 
-async function getRequestBody({
-	request,
-	content
-}: {
-	content
-	request: Request
-}) {
-	let body: string | Record<string, any> | undefined
-	if (request.method === 'GET' || request.method === 'HEAD') {
-		return
-	}
+// async function getRequestBody({
+// 	request,
+// 	content,
+// }: {
+// 	content
+// 	request: Request
+// }) {
+// 	let body: string | Record<string, any> | undefined
+// 	if (request.method === 'GET' || request.method === 'HEAD') {
+// 		return
+// 	}
 
-	const contentType =
-		content || request.headers.get('content-type')?.split(';')?.[0]
+// 	const contentType =
+// 		content || request.headers.get('content-type')?.split(';')?.[0]
 
-	if (!contentType) {
-		return
-	}
+// 	if (!contentType) {
+// 		return
+// 	}
 
-	switch (contentType) {
-		case 'application/json':
-			body = (await request.json()) as any
-			break
+// 	switch (contentType) {
+// 		case 'application/json':
+// 			body = (await request.json()) as any
+// 			break
 
-		case 'text/plain':
-			body = await request.text()
-			break
+// 		case 'text/plain':
+// 			body = await request.text()
+// 			break
 
-		case 'application/x-www-form-urlencoded':
-			body = parseQuery.parse(await request.text()) as any
-			break
+// 		case 'application/x-www-form-urlencoded':
+// 			body = parseQuery.parse(await request.text()) as any
+// 			break
 
-		case 'application/octet-stream':
-			body = await request.arrayBuffer()
-			break
+// 		case 'application/octet-stream':
+// 			body = await request.arrayBuffer()
+// 			break
 
-		case 'multipart/form-data':
-			body = {}
+// 		case 'multipart/form-data':
+// 			body = {}
 
-			const form = await request.formData()
-			for (const key of form.keys()) {
-				if (body[key]) continue
+// 			const form = await request.formData()
+// 			for (const key of form.keys()) {
+// 				if (body[key]) continue
 
-				const value = form.getAll(key)
-				if (value.length === 1) body[key] = value[0]
-				else body[key] = value
-			}
+// 				const value = form.getAll(key)
+// 				if (value.length === 1) body[key] = value[0]
+// 				else body[key] = value
+// 			}
 
-			break
-	}
+// 			break
+// 	}
 
-	return body
-}
+// 	return body
+// }
 
 const METHODS = [
 	'ALL',
@@ -1193,41 +1265,59 @@ const METHODS = [
 	'PATCH',
 	'POST',
 	'PUT',
-	'TRACE'
+	'TRACE',
 ] as const
 
 /** HTTP method string */
 export type Method = (typeof METHODS)[number]
 
-function bfs<T>(
+function bfsFind<T>(
 	tree: RouterTree,
-	onNode: (node: RouterTree) => T | undefined | void
+	onNode: (node: RouterTree) => T | undefined | void,
 ): T | undefined {
 	const queue = [tree]
+
 	while (queue.length > 0) {
 		const node = queue.shift()!
+
 		const result = onNode(node)
 		if (result) {
 			return result
 		}
 		queue.push(...node.children)
 	}
-	return undefined
+	return
 }
+export class TypedRequest<T = any> extends Request {
+	validateBody?: ValidateFunction
 
-function mapBfs(
-	tree: RouterTree,
-	mapper: (node: RouterTree) => RouterTree
-): RouterTree {
+	async json(): Promise<T> {
+		const body = (await super.json()) as Promise<T>
+		return runValidation(body, this.validateBody)
+	}
+}
+
+export function bfs(tree: RouterTree) {
 	const queue = [tree]
-	const result: RouterTree = { ...mapper(tree), children: [] }
+	let nodes: RouterTree[] = []
 	while (queue.length > 0) {
 		const node = queue.shift()!
-		const mappedNode = mapper(node)
-		result.children.push(mappedNode)
-		queue.push(...mappedNode.children)
+		if (node) {
+			nodes.push(node)
+		}
+		// const result = onNode(node)
+
+		queue.push(...node.children)
 	}
-	return result
+	return nodes
+}
+function mapTree<T>(
+	tree: RouterTree,
+	mapper: (node: RouterTree) => T,
+): T & { children: (T & { children: any[] })[] } {
+	const mappedNode = mapper(tree) as T & { children: any[] }
+	mappedNode.children = tree.children.map((child) => mapTree(child, mapper))
+	return mappedNode
 }
 
 export async function turnHandlerResultIntoResponse(result: any) {
@@ -1245,7 +1335,46 @@ export async function turnHandlerResultIntoResponse(result: any) {
 	// }
 	// if user returns an object, convert to json
 
-	return new Response(JSON.stringify(result))
+	return new Response(JSON.stringify(result, null, 2), {
+		headers: {
+			'content-type': 'application/json',
+		},
+	})
 }
 
 export type AnySpiceflow = Spiceflow<any, any, any, any, any, any, any, any>
+
+export function isZodSchema(value: unknown): value is ZodType {
+	return (
+		value instanceof z.ZodType ||
+		(typeof value === 'object' &&
+			value !== null &&
+			'parse' in value &&
+			'safeParse' in value &&
+			'optional' in value &&
+			'nullable' in value)
+	)
+}
+
+function getValidateFunction(schema: TypeSchema) {
+	if (isZodSchema(schema)) {
+		let jsonSchema = zodToJsonSchema(schema, {})
+		return ajv.compile(jsonSchema)
+	}
+
+	if (schema) {
+		return ajv.compile(schema)
+	}
+}
+
+function runValidation(value: any, validate?: ValidateFunction) {
+	if (!validate) return value
+	const valid = validate(value)
+	if (!valid) {
+		const error = ajv.errorsText(validate.errors, {
+			separator: '\n',
+		})
+		throw new ValidationError(error)
+	}
+	return value
+}