spiceflow 1.0.0 → 1.0.2

package/src/spiceflow.ts

@@ -5,11 +5,13 @@ import { Type } from '@sinclair/typebox'
 export { Type as t }
 
 import {
-	ComposeElysiaResponse,
+	ComposeSpiceflowResponse,
 	CreateEden,
 	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,25 +70,34 @@ 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>
+	validate?: ValidateFunction
+	prefix: string
+
 	// store: Record<any, any>
 }
 /**
  * Router class
  */
-export class Elysia<
+export class Spiceflow<
 	const in out BasePath extends string = '',
 	const in out Scoped extends boolean = true,
 	const in out Singleton extends SingletonBase = {
@@ -95,40 +127,82 @@ export class Elysia<
 		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 validate: ValidateFunction | undefined
+
+		if (isZodSchema(bodySchema)) {
+			let jsonSchema = zodToJsonSchema(bodySchema, {})
+			validate = ajv.compile(jsonSchema)
+		} else if (bodySchema) {
+			// console.log(bodySchema)
+			validate = ajv.compile(bodySchema)
+		}
+
 		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,
+			validate,
+		}
+		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,7 +210,7 @@ export class Elysia<
 				return
 			}
 
-			let data: InternalRouterState = route['store'][method]
+			let data: InternalRoute = route['store'][method]
 			if (data) {
 				// console.log(`route found: ${method} ${path}`, route)
 
@@ -148,7 +222,7 @@ export class Elysia<
 					store: router.store,
 					onErrorHandlers,
 					onRequestHandlers,
-					params
+					params,
 				}
 			}
 		})
@@ -158,8 +232,8 @@ export class Elysia<
 
 	state<const Name extends string | number | symbol, Value>(
 		name: Name,
-		value: Value
-	): Elysia<
+		value: Value,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		{
@@ -189,24 +263,25 @@ export class Elysia<
 	 */
 	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,28 +299,12 @@ export class Elysia<
 		Scoped: false as Scoped,
 		Singleton: {} as Singleton,
 		Definitions: {} as Definitions,
-		Metadata: {} as Metadata
+		Metadata: {} as Metadata,
 	}
 
 	_ephemeral = {} as Ephemeral
 	_volatile = {} as Volatile
 
-	/**
-	 * ### post
-	 * Register handler for path with method [POST]
-	 *
-	 * ---
-	 * @example
-	 * ```typescript
-	 * import { Elysia, t } from 'elysia'
-	 *
-	 * new Elysia()
-	 *     .post('/', () => 'hi')
-	 *     .post('/with-hook', () => 'hi', {
-	 *         response: t.String()
-	 *     })
-	 * ```
-	 */
 	post<
 		const Path extends string,
 		const LocalSchema extends InputSchema<
@@ -265,7 +324,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -279,8 +338,8 @@ export class Elysia<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -297,7 +356,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -307,7 +366,7 @@ export class Elysia<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'POST', path, handler: handler, hook })
+		this.add({ method: 'POST', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -332,7 +391,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -346,8 +405,8 @@ export class Elysia<
 			Definitions['error'],
 			Macro,
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -364,7 +423,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -374,7 +433,7 @@ export class Elysia<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'GET', path, handler: handler, hook })
+		this.add({ method: 'GET', path, handler: handler, hooks: hook })
 		return this as any
 	}
 
@@ -397,7 +456,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -411,8 +470,8 @@ export class Elysia<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -429,7 +488,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -439,7 +498,7 @@ export class Elysia<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'PUT', path, handler: handler, hook })
+		this.add({ method: 'PUT', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -463,7 +522,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -477,8 +536,8 @@ export class Elysia<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -495,7 +554,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -505,7 +564,7 @@ export class Elysia<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'PATCH', path, handler: handler, hook })
+		this.add({ method: 'PATCH', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -529,7 +588,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -543,8 +602,8 @@ export class Elysia<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -561,7 +620,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -571,7 +630,7 @@ export class Elysia<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'DELETE', path, handler: handler, hook })
+		this.add({ method: 'DELETE', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -595,7 +654,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -609,8 +668,8 @@ export class Elysia<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -627,7 +686,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -637,7 +696,7 @@ export class Elysia<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'OPTIONS', path, handler: handler, hook })
+		this.add({ method: 'OPTIONS', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
@@ -661,7 +720,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -675,8 +734,8 @@ export class Elysia<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -693,7 +752,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -704,7 +763,7 @@ export class Elysia<
 		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
@@ -729,7 +788,7 @@ export class Elysia<
 				resolve: Ephemeral['resolve'] & Volatile['resolve']
 			},
 			JoinPath<BasePath, Path>
-		>
+		>,
 	>(
 		path: Path,
 		handler: Handle,
@@ -743,8 +802,8 @@ export class Elysia<
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
-		>
-	): Elysia<
+		>,
+	): Spiceflow<
 		BasePath,
 		Scoped,
 		Singleton,
@@ -761,7 +820,7 @@ export class Elysia<
 							: Schema['params']
 						query: Schema['query']
 						headers: Schema['headers']
-						response: ComposeElysiaResponse<
+						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
@@ -771,17 +830,17 @@ export class Elysia<
 		Ephemeral,
 		Volatile
 	> {
-		this.add({ method: 'HEAD', path, handler: handler, hook })
+		this.add({ method: 'HEAD', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
 
 	/**
-	 * If set to true, other Elysia handler will not inherits global life-cycle, store, decorators from the current instance
+	 * If set to true, other Spiceflow handler will not inherits global life-cycle, store, decorators from the current instance
 	 *
 	 * @default false
 	 */
-	scoped?: Scoped
+	private scoped?: Scoped
 	get _scoped() {
 		return this.scoped as Scoped
 	}
@@ -789,11 +848,11 @@ export class Elysia<
 	// group is not needed, you can add another prefixed app instead
 	// group<
 	// 	const Prefix extends string,
-	// 	const NewElysia extends Elysia<any, any, any, any, any, any, any, any>
+	// 	const NewSpiceflow extends Spiceflow<any, any, any, any, any, any, any, any>
 	// >(
 	// 	prefix: Prefix,
 	// 	run: (
-	// 		group: Elysia<
+	// 		group: Spiceflow<
 	// 			`${BasePath}${Prefix}`,
 	// 			Scoped,
 	// 			Singleton,
@@ -803,14 +862,14 @@ export class Elysia<
 	// 			Ephemeral,
 	// 			Volatile
 	// 		>
-	// 	) => NewElysia
-	// ): Elysia<
+	// 	) => NewSpiceflow
+	// ): Spiceflow<
 	// 	BasePath,
 	// 	Scoped,
 	// 	Singleton,
 	// 	Definitions,
 	// 	Metadata,
-	// 	Prettify<Routes & NewElysia['_routes']>,
+	// 	Prettify<Routes & NewSpiceflow['_routes']>,
 	// 	Ephemeral,
 	// 	Volatile
 	// > {
@@ -825,44 +884,37 @@ export class Elysia<
 	// 	return this
 	// }
 
-	use<const NewElysia extends AnyElysia>(
-		instance: NewElysia
-	): NewElysia['_scoped'] extends false
-		? Elysia<
+	use<const NewSpiceflow extends AnySpiceflow>(
+		instance: NewSpiceflow,
+	): NewSpiceflow['_scoped'] extends false
+		? Spiceflow<
 				BasePath,
 				Scoped,
 				// @ts-expect-error - This is truly ideal
-				Prettify2<Singleton & NewElysia['_types']['Singleton']>,
-				Prettify2<Definitions & NewElysia['_types']['Definitions']>,
-				Prettify2<Metadata & NewElysia['_types']['Metadata']>,
+				Prettify2<Singleton & NewSpiceflow['_types']['Singleton']>,
+				Prettify2<Definitions & NewSpiceflow['_types']['Definitions']>,
+				Prettify2<Metadata & NewSpiceflow['_types']['Metadata']>,
 				BasePath extends ``
-					? Routes & NewElysia['_routes']
-					: Routes & CreateEden<BasePath, NewElysia['_routes']>,
+					? Routes & NewSpiceflow['_routes']
+					: Routes & CreateEden<BasePath, NewSpiceflow['_routes']>,
 				Ephemeral,
-				Prettify2<Volatile & NewElysia['_ephemeral']>
+				Prettify2<Volatile & NewSpiceflow['_ephemeral']>
 		  >
-		: Elysia<
+		: Spiceflow<
 				BasePath,
 				Scoped,
 				Singleton,
 				Definitions,
 				Metadata,
 				BasePath extends ``
-					? Routes & NewElysia['_routes']
-					: Routes & CreateEden<BasePath, NewElysia['_routes']>,
+					? Routes & NewSpiceflow['_routes']
+					: Routes & CreateEden<BasePath, NewSpiceflow['_routes']>,
 				Ephemeral,
 				Volatile
 		  > {
 		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
 	}
 
@@ -881,7 +933,7 @@ export class Elysia<
 				Ephemeral,
 				Volatile
 			>
-		>
+		>,
 	): this {
 		const router = this.routerTree
 
@@ -908,7 +960,7 @@ export class Elysia<
 					resolve: {}
 				}
 			>
-		>
+		>,
 	) {
 		const router = this.routerTree
 		router.onRequestHandlers ??= []
@@ -929,7 +981,7 @@ export class Elysia<
 		const defaultContext = {
 			redirect,
 			error: null,
-			path
+			path,
 		}
 		let onErrorHandlers: OnError[] = []
 		try {
@@ -940,41 +992,44 @@ export class Elysia<
 			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)
+			const { 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 content = route?.hooks?.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 (route.validate) {
+				// TODO move compile to the router
+
+				const valid = route.validate(body)
 				if (!valid) {
-					const error = ajv.errorsText(validate.errors, {
-						separator: '\n'
+					const error = ajv.errorsText(route.validate.errors, {
+						separator: '\n',
 					})
 
 					return new Response(error, {
 						status: 400,
 						headers: {
-							'content-type': 'text/plain'
-						}
+							'content-type': 'text/plain',
+						},
 					})
 				}
 			}
-			if (onReq.length > 0) {
-				for (const handler of onReq) {
+			if (onReqHandlers.length > 0) {
+				for (const handler of onReqHandlers) {
 					const res = await handler({
 						request,
 						response,
 						store,
-						path
+						path,
 					} satisfies Context<any, any, any>)
 					if (res) {
 						return await turnHandlerResultIntoResponse(res)
@@ -991,7 +1046,7 @@ export class Elysia<
 				params: params as any,
 				store,
 				body,
-				path
+				path,
 
 				// platform
 			} satisfies Context<any, any, string>)
@@ -999,7 +1054,7 @@ export class Elysia<
 				return await this.handleStream({
 					generator: res,
 					request,
-					onErrorHandlers
+					onErrorHandlers,
 				})
 			}
 
@@ -1008,11 +1063,11 @@ export class Elysia<
 			let res = await this.runErrorHandlers({
 				onErrorHandlers,
 				error: err,
-				request
+				request,
 			})
 			if (res) return res
 			return new Response(err?.message || 'Internal Server Error', {
-				status: 500
+				status: 500,
 			})
 		}
 	}
@@ -1020,7 +1075,7 @@ export class Elysia<
 	private async runErrorHandlers({
 		onErrorHandlers = [] as OnError[],
 		error: err,
-		request
+		request,
 	}) {
 		if (onErrorHandlers.length === 0) {
 			console.error(`Spiceflow unhandled error:`, err)
@@ -1034,31 +1089,33 @@ export class Elysia<
 		}
 	}
 
+	// 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[]
@@ -1091,9 +1148,9 @@ export class Elysia<
 						controller.enqueue(
 							Buffer.from(
 								`event: message\ndata: ${JSON.stringify(
-									init.value
-								)}\n\n`
-							)
+									init.value,
+								)}\n\n`,
+							),
 						)
 
 					try {
@@ -1104,23 +1161,23 @@ export class Elysia<
 							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`,
+							),
 						)
 					}
 
@@ -1129,24 +1186,24 @@ export class Elysia<
 					} 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,
 }: {
 	content
 	request: Request
@@ -1208,41 +1265,50 @@ 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
 }
-
-function mapBfs(
-	tree: RouterTree,
-	mapper: (node: RouterTree) => RouterTree
-): RouterTree {
+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) {
@@ -1260,7 +1326,23 @@ 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 AnyElysia = Elysia<any, any, any, any, any, any, any, any>
+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)
+	)
+}