spiceflow 1.0.8 → 1.1.1

package/src/spiceflow.ts

@@ -4,13 +4,12 @@ import { Type } from '@sinclair/typebox'
 
 export { Type as t }
 
+import addFormats from 'ajv-formats'
 import {
 	ComposeSpiceflowResponse,
 	CreateEden,
 	DefinitionBase,
-	EphemeralType,
 	ErrorHandler,
-	Handler,
 	HTTPMethod,
 	InlineHandler,
 	InputSchema,
@@ -20,8 +19,7 @@ import {
 	MaybeArray,
 	MergeSchema,
 	MetadataBase,
-	PreHandler,
-	Prettify2,
+	MiddlewareHandler,
 	Reconcile,
 	ResolvePath,
 	RouteBase,
@@ -29,21 +27,18 @@ import {
 	SingletonBase,
 	TypeSchema,
 	UnwrapRoute,
-} from './elysia-fork/types.js'
-import addFormats from 'ajv-formats'
+} from './types.js'
 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, { 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'
+import { zodToJsonSchema } from 'zod-to-json-schema'
+import { Context, MiddlewareContext } from './context.js'
+import { isProduction, NotFoundError, ValidationError } from './error.js'
+import { isAsyncIterable, redirect } from './utils.js'
 
 const ajv = (addFormats.default || addFormats)(
 	new (Ajv.default || Ajv)({ useDefaults: true }),
@@ -67,27 +62,10 @@ const ajv = (addFormats.default || addFormats)(
 
 // Should be exported from `hono/router`
 
-type P = any
-
 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
-
 export type InternalRoute = {
 	method: HTTPMethod
 	path: string
@@ -96,11 +74,20 @@ export type InternalRoute = {
 	validateBody?: ValidateFunction
 	validateQuery?: ValidateFunction
 	validateParams?: ValidateFunction
-
 	prefix: string
 
 	// store: Record<any, any>
 }
+
+type MedleyRouter = {
+	find: (path: string) =>
+		| {
+				store: Record<string, InternalRoute> //
+				params: Record<string, any>
+		  }
+		| undefined
+	register: (path: string | undefined) => Record<string, InternalRoute>
+}
 /**
  * Router class
  */
@@ -108,10 +95,7 @@ export class Spiceflow<
 	const in out BasePath extends string = '',
 	const in out Scoped extends boolean = true,
 	const in out Singleton extends SingletonBase = {
-		decorator: {}
 		store: {}
-		derive: {}
-		resolve: {}
 	},
 	const in out Definitions extends DefinitionBase = {
 		type: {}
@@ -123,30 +107,28 @@ export class Spiceflow<
 		macroFn: {}
 	},
 	const out Routes extends RouteBase = {},
-	// ? scoped
-	const in out Ephemeral extends EphemeralType = {
-		derive: {}
-		resolve: {}
-		schema: {}
-	},
-	// ? local
-	const in out Volatile extends EphemeralType = {
-		derive: {}
-		resolve: {}
-		schema: {}
-	},
 > {
-	private onNoMatch: OnNoMatch
-	// prefix: BasePath | undefined
-	private routerTree: RouterTree
+	private id: number = globalIndex++
+	private router: MedleyRouter = new OriginalRouter()
+	private middlewares: Function[] = []
+	private onErrorHandlers: OnError[] = []
+	private routes: InternalRoute[] = []
+	private defaultStore: Record<any, any> = {}
+	private topLevelApp?: AnySpiceflow
+
+	/** @internal */
+	prefix?: string
 
+	/** @internal */
+	childrenApps: AnySpiceflow[] = []
+
+	/** @internal */
 	getAllRoutes() {
-		let root = this.routerTree.currentRoot || this.routerTree
+		let root = this.topLevelApp || this
 		const allApps = bfs(root) || []
 		const allRoutes = allApps.flatMap((x) => {
-			const prefix = this.getRouteAndParents(x)
+			const prefix = this.getAppAndParents(x)
 				.map((x) => x.prefix)
-				.reverse()
 				.join('')
 
 			return x.routes.map((x) => ({ ...x, path: prefix + x.path }))
@@ -161,73 +143,56 @@ export class Spiceflow<
 		handler,
 		...rest
 	}: 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)
+		const store = this.router.register(path)
 		let route: InternalRoute = {
 			...rest,
-
-			prefix: router.prefix || '',
+			prefix: this.prefix || '',
 			method: (method || '') as any,
 			path: path || '',
-			// prefix,
 			handler: handler!,
 			hooks,
 			validateBody,
 			validateParams,
 			validateQuery,
 		}
-		router.routes.push(route)
-		store[method] = route
+		this.routes.push(route)
+		store[method!] = route
 	}
 
 	private match(method: string, path: string) {
-		let root = this.routerTree
-		const result = bfsFind(this.routerTree, (router) => {
-			router.currentRoot = root
-			let prefix = this.getRouteAndParents(router)
+		let root = this
+		const result = bfsFind(this, (app) => {
+			app.topLevelApp = root
+			let prefix = this.getAppAndParents(app)
 				.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 (prefix) {
 				pathWithoutPrefix = path.replace(prefix, '')
 			}
-			// console.log(`router prefix: ${router.prefix} matches path: ${path}`)
-			const route = router.router.find(pathWithoutPrefix)
-			if (!route) {
+			const medleyRoute = app.router.find(pathWithoutPrefix)
+			if (!medleyRoute) {
 				return
 			}
 
-			let data: InternalRoute = route['store'][method]
-			if (data) {
-				// console.log(`route found: ${method} ${path}`, route)
-
-				const { onErrorHandlers, onRequestHandlers } = router
-				const params = route['params'] || {}
+			let internalRoute: InternalRoute = medleyRoute.store[method]
+			if (internalRoute) {
+				const params = medleyRoute.params || {}
 
-				return {
-					...data,
-					router,
-					store: router.store,
-					onErrorHandlers,
-					onRequestHandlers,
+				const res = {
+					app,
+					internalRoute: internalRoute,
 					params,
 				}
+				return res
 			}
 		})
 
@@ -241,23 +206,18 @@ export class Spiceflow<
 		BasePath,
 		Scoped,
 		{
-			decorator: Singleton['decorator']
 			store: Reconcile<
 				Singleton['store'],
 				{
 					[name in Name]: Value
 				}
 			>
-			derive: Singleton['derive']
-			resolve: Singleton['resolve']
 		},
 		Definitions,
 		Metadata,
-		Routes,
-		Ephemeral,
-		Volatile
+		Routes
 	> {
-		this.routerTree.store[name] = value
+		this.defaultStore[name] = value
 		return this as any
 	}
 
@@ -269,31 +229,13 @@ export class Spiceflow<
 		options: {
 			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: {},
-			routes: [],
-		}
-
-		// Bind router methods
-		// for (const method of METHODS) {
-		// 	this.#routes.set(method as Method, [])
-		// 	const key = method.toLowerCase() as Lowercase<Method>
-		// 	this[key as any] = this.#add.bind(this, method)
-		// }
+		this.prefix = options.basePath
 	}
 
 	_routes: Routes = {} as any
@@ -306,27 +248,15 @@ export class Spiceflow<
 		Metadata: {} as Metadata,
 	}
 
-	_ephemeral = {} as Ephemeral
-	_volatile = {} as Volatile
-
 	post<
 		const Path extends string,
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -335,10 +265,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
@@ -359,16 +286,13 @@ export class Spiceflow<
 							? ResolvePath<Path>
 							: Schema['params']
 						query: Schema['query']
-
 						response: ComposeSpiceflowResponse<
 							Schema['response'],
 							Handle
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		this.add({ method: 'POST', path, handler: handler, hooks: hook })
 
@@ -380,20 +304,11 @@ export class Spiceflow<
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Macro extends Metadata['macro'],
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -402,10 +317,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Macro,
 			JoinPath<BasePath, Path>
@@ -433,9 +345,7 @@ export class Spiceflow<
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		this.add({ method: 'GET', path, handler: handler, hooks: hook })
 		return this as any
@@ -446,19 +356,10 @@ export class Spiceflow<
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -467,10 +368,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
@@ -498,9 +396,7 @@ export class Spiceflow<
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		this.add({ method: 'PUT', path, handler: handler, hooks: hook })
 
@@ -512,19 +408,10 @@ export class Spiceflow<
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -533,10 +420,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
@@ -564,9 +448,7 @@ export class Spiceflow<
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		this.add({ method: 'PATCH', path, handler: handler, hooks: hook })
 
@@ -578,19 +460,10 @@ export class Spiceflow<
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -599,10 +472,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
@@ -630,9 +500,7 @@ export class Spiceflow<
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		this.add({ method: 'DELETE', path, handler: handler, hooks: hook })
 
@@ -644,19 +512,10 @@ export class Spiceflow<
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -665,10 +524,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
@@ -696,9 +552,7 @@ export class Spiceflow<
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		this.add({ method: 'OPTIONS', path, handler: handler, hooks: hook })
 
@@ -710,19 +564,10 @@ export class Spiceflow<
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -731,10 +576,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
@@ -762,9 +604,7 @@ export class Spiceflow<
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		for (const method of METHODS) {
 			this.add({ method, path, handler: handler, hooks: hook })
@@ -778,19 +618,10 @@ export class Spiceflow<
 		const LocalSchema extends InputSchema<
 			keyof Definitions['type'] & string
 		>,
-		const Schema extends MergeSchema<
-			UnwrapRoute<LocalSchema, Definitions['type']>,
-			MergeSchema<
-				Volatile['schema'],
-				MergeSchema<Ephemeral['schema'], Metadata['schema']>
-			>
-		>,
+		const Schema extends UnwrapRoute<LocalSchema, Definitions['type']>,
 		const Handle extends InlineHandler<
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			JoinPath<BasePath, Path>
 		>,
 	>(
@@ -799,10 +630,7 @@ export class Spiceflow<
 		hook?: LocalHook<
 			LocalSchema,
 			Schema,
-			Singleton & {
-				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			},
+			Singleton,
 			Definitions['error'],
 			Metadata['macro'],
 			JoinPath<BasePath, Path>
@@ -830,24 +658,14 @@ export class Spiceflow<
 						>
 					}
 				}
-			>,
-		Ephemeral,
-		Volatile
+			>
 	> {
 		this.add({ method: 'HEAD', path, handler: handler, hooks: hook })
 
 		return this as any
 	}
 
-	/**
-	 * If set to true, other Spiceflow handler will not inherits global life-cycle, store, decorators from the current instance
-	 *
-	 * @default false
-	 */
-	private scoped?: Scoped
-	get _scoped() {
-		return this.scoped as Scoped
-	}
+	private scoped?: Scoped = true as Scoped
 
 	// group is not needed, you can add another prefixed app instead
 	// group<
@@ -900,75 +718,47 @@ export class Spiceflow<
 				Metadata,
 				BasePath extends ``
 					? 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(instance.routerTree)
-		return this as any
-	}
-
-	onError<const Schema extends RouteSchema>(
+					: Routes & CreateEden<BasePath, NewSpiceflow['_routes']>
+		  >
+	use<const Schema extends RouteSchema>(
 		handler: MaybeArray<
-			ErrorHandler<
-				Definitions['error'],
-				MergeSchema<
-					Schema,
-					MergeSchema<
-						Volatile['schema'],
-						MergeSchema<Ephemeral['schema'], Metadata['schema']>
-					>
-				>,
-				Singleton,
-				Ephemeral,
-				Volatile
+			MiddlewareHandler<
+				Schema,
+				{
+					store: Singleton['store']
+				}
 			>
 		>,
-	): this {
-		const router = this.routerTree
-
-		router.onErrorHandlers ??= []
-		router.onErrorHandlers.push(handler as any)
-
+	): this
+
+	use(appOrHandler) {
+		if (appOrHandler instanceof Spiceflow) {
+			this.childrenApps.push(appOrHandler)
+		} else if (typeof appOrHandler === 'function') {
+			this.middlewares ??= []
+			this.middlewares.push(appOrHandler)
+		}
 		return this
 	}
 
-	onRequest<const Schema extends RouteSchema>(
+	onError<const Schema extends RouteSchema>(
 		handler: MaybeArray<
-			PreHandler<
-				MergeSchema<
-					Schema,
-					MergeSchema<
-						Volatile['schema'],
-						MergeSchema<Ephemeral['schema'], Metadata['schema']>
-					>
-				>,
-				{
-					decorator: Singleton['decorator']
-					store: Singleton['store']
-					derive: {}
-					resolve: {}
-				}
-			>
+			ErrorHandler<Definitions['error'], Schema, Singleton>
 		>,
-	) {
-		const router = this.routerTree
-		router.onRequestHandlers ??= []
-		router.onRequestHandlers.push(handler as any)
+	): this {
+		this.onErrorHandlers ??= []
+		this.onErrorHandlers.push(handler as any)
 
 		return this
 	}
+
 	/**
 	 * Pass a request through all matching route handles and return a response
 	 * @param request   The `Request`
 	 * @param platform  Platform specific context {@link Platform}
 	 * @returns The final `Response`
 	 */
-	async handle(request: Request, platform?: P): Promise<Response> {
-		platform ??= {} as P
-
+	async handle(request: Request): Promise<Response> {
 		let u = new URL(request.url, 'http://localhost')
 		let path = u.pathname + u.search
 		const defaultContext = {
@@ -976,79 +766,108 @@ export class Spiceflow<
 			error: null,
 			path,
 		}
+		const root = this.topLevelApp || this
 		let onErrorHandlers: OnError[] = []
 		try {
-			let response: Response | undefined
 			// Get all middleware and method specific routes in order
 
 			const route = this.match(request.method, path)
+
 			if (!route) {
-				return this.onNoMatch(request, platform)
+				const error = new NotFoundError(`${path} not found`)
+				const res = await this.runErrorHandlers({
+					onErrorHandlers,
+					error,
+					request,
+				})
+				if (res) return res
+				return new Response(`Not Found`, {
+					status: 404,
+				})
 			}
-			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)
+			onErrorHandlers = this.getAppsInScope(route.app).flatMap(
+				(x) => x.onErrorHandlers,
+			)
+			let {
+				params,
+				app: { defaultStore },
+			} = route
+			const middlewares = this.getAppsInScope(route.app).flatMap(
+				(x) => x.middlewares,
+			)
 			// console.log({ onReqHandlers })
 			let store = { ...defaultStore }
-			// TODO add content type
 
-			let content = route?.hooks?.content
-			// let body = await getRequestBody({ request, content })
+			let content = route?.internalRoute?.hooks?.content
 
-			if (route.validateBody) {
+			if (route.internalRoute?.validateBody) {
 				// TODO don't clone the request
-				let typedRequest = new TypedRequest(request)
-				typedRequest.validateBody = route.validateBody
+				let typedRequest =
+					request instanceof TypedRequest
+						? request
+						: new TypedRequest(request)
+				typedRequest.validateBody = route.internalRoute?.validateBody
 				request = typedRequest
 			}
 
 			let query = parseQuery.parse((u.search || '').slice(1))
 
-			if (onReqHandlers.length > 0) {
-				for (const handler of onReqHandlers) {
-					const res = await handler({
+			let index = 0
+
+			const next = async () => {
+				if (index < middlewares.length) {
+					const middleware = middlewares[index]
+					index++
+					let context = {
 						request,
-						response,
 						store,
 						path,
 						query,
-					} satisfies Context<any, any, any>)
-					if (res) {
-						return await turnHandlerResultIntoResponse(res)
+						params,
+						redirect,
+					} satisfies MiddlewareContext<any>
+					const result = await middleware(context, next)
+
+					if (!result && index < middlewares.length) {
+						return await next()
+					} else if (result) {
+						return await turnHandlerResultIntoResponse(result)
 					}
 				}
-			}
 
-			query = runValidation(query, route.validateQuery)
-			params = runValidation(params, route.validateParams)
+				query = runValidation(query, route.internalRoute?.validateQuery)
+				params = runValidation(
+					params,
+					route.internalRoute?.validateParams,
+				)
 
-			// console.log(route)
+				// console.log(route)
 
-			const res = route.handler({
-				...defaultContext,
-				request,
-				response,
-				params: params as any,
-				store,
-				query,
-				// body,
-				path,
-
-				// platform
-			} satisfies Context<any, any, string>)
-			if (isAsyncIterable(res)) {
-				return await this.handleStream({
-					generator: res,
+				const res = route.internalRoute?.handler({
+					...defaultContext,
 					request,
-					onErrorHandlers,
-				})
+					params: params as any,
+					redirect,
+					store,
+					query,
+					// body,
+					path,
+
+					// platform
+				} satisfies Context<any, any, any>)
+				if (isAsyncIterable(res)) {
+					return await this.handleStream({
+						generator: res,
+						request,
+						onErrorHandlers,
+					})
+				}
+
+				return await turnHandlerResultIntoResponse(res)
 			}
+			const response = await next()
 
-			return await turnHandlerResultIntoResponse(res)
+			return response
 		} catch (err: any) {
 			if (err instanceof Response) return err
 			let res = await this.runErrorHandlers({
@@ -1081,29 +900,149 @@ 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
+	private getAppAndParents(currentApp?: AnySpiceflow) {
+		let root = this.topLevelApp || this
 
-		let root = this.routerTree.currentRoot || this.routerTree
-		// Perform BFS once to build a parent map
-		const parentMap = new Map<number, RouterTree>()
+		if (!root.childrenApps.length) {
+			return [root]
+		}
+		const parents: AnySpiceflow[] = []
+		let current = currentApp
+
+		const parentMap = new Map<number, AnySpiceflow>()
 		bfsFind(root, (node) => {
-			for (const child of node.children) {
+			for (const child of node.childrenApps) {
 				parentMap.set(child.id, node)
 			}
 		})
 
 		// Traverse the parent map to get the parents
 		while (current) {
-			parents.push(current)
+			parents.unshift(current)
 			current = parentMap.get(current.id)
 		}
 
 		return parents.filter((x) => x !== undefined)
 	}
 
+	private getAppsInScope(currentApp?: AnySpiceflow) {
+		let root = this.topLevelApp || this
+		if (!root.childrenApps.length) {
+			return [root]
+		}
+		const withParents = this.getAppAndParents(currentApp)
+
+		const wantedOrder = bfs(root)
+		const scopeFalseApps = wantedOrder.filter((x) => x.scoped === false)
+		let appsInScope = [] as AnySpiceflow[]
+		for (const app of wantedOrder) {
+			if (scopeFalseApps.includes(app)) {
+				appsInScope.push(app)
+				continue
+			}
+			if (withParents.includes(app)) {
+				appsInScope.push(app)
+				continue
+			}
+		}
+		return appsInScope
+	}
+
+	async listen(port: number, hostname: string = '127.0.0.1') {
+		if (typeof Bun !== 'undefined') {
+			const server = Bun.serve({
+				port,
+				development: !isProduction,
+				hostname,
+				error(error) {
+					console.error(error)
+					return new Response('Internal Server Error', {
+						status: 500,
+					})
+				},
+
+				fetch: async (request) => {
+					const res = await this.handle(request)
+					return res
+				},
+			})
+			console.log(`Listening on http://localhost:${port}`)
+			return server
+		}
+		return this.listenNode(port, hostname)
+	}
+
+	async listenNode(port: number, hostname: string = '0.0.0.0') {
+		const { Readable } = await import('stream')
+		const { createServer } = await import('http')
+
+		const server = createServer(async (req, res) => {
+			const abortController = new AbortController()
+			const { signal } = abortController
+
+			req.on('close', () => abortController.abort())
+			req.on('error', (err) => {
+				abortController.abort()
+			})
+			req.on('aborted', (err) => {
+				abortController.abort()
+			})
+			// this is how you see when a request is aborted in Node.js, laughable
+			res.on('close', function () {
+				let aborted = !res.writableFinished
+				if (aborted) {
+					abortController.abort()
+				}
+			})
+
+			const url = new URL(
+				req.url || '',
+				`http://${req.headers.host || hostname || 'localhost'}`,
+			)
+			const typedRequest = new TypedRequest(url.toString(), {
+				method: req.method,
+				headers: req.headers as HeadersInit,
+				body:
+					req.method !== 'GET' && req.method !== 'HEAD'
+						? (Readable.toWeb(req) as any)
+						: null,
+				signal,
+			})
+
+			try {
+				const response = await this.handle(typedRequest)
+
+				res.statusCode = response.status
+				for (const [key, value] of response.headers) {
+					res.setHeader(key, value)
+				}
+
+				if (response.body) {
+					const reader = response.body.getReader()
+					while (true) {
+						const { done, value } = await reader.read()
+						if (done) break
+						res.write(value)
+					}
+				}
+				res.end()
+			} catch (error) {
+				console.error('Error handling request:', error)
+				res.statusCode = 500
+				res.end('Internal Server Error')
+			}
+		})
+
+		await new Promise((resolve, reject) => {
+			server.listen(port, hostname, () => {
+				console.log(`Listening on http://localhost:${port}`)
+				resolve(null)
+			})
+		})
+
+		return server
+	}
+
 	private async handleStream({
 		onErrorHandlers,
 		generator,
@@ -1264,8 +1203,8 @@ const METHODS = [
 export type Method = (typeof METHODS)[number]
 
 function bfsFind<T>(
-	tree: RouterTree,
-	onNode: (node: RouterTree) => T | undefined | void,
+	tree: AnySpiceflow,
+	onNode: (node: AnySpiceflow) => T | undefined | void,
 ): T | undefined {
 	const queue = [tree]
 
@@ -1276,7 +1215,7 @@ function bfsFind<T>(
 		if (result) {
 			return result
 		}
-		queue.push(...node.children)
+		queue.push(...node.childrenApps)
 	}
 	return
 }
@@ -1289,9 +1228,9 @@ export class TypedRequest<T = any> extends Request {
 	}
 }
 
-export function bfs(tree: RouterTree) {
+export function bfs(tree: AnySpiceflow) {
 	const queue = [tree]
-	let nodes: RouterTree[] = []
+	let nodes: AnySpiceflow[] = []
 	while (queue.length > 0) {
 		const node = queue.shift()!
 		if (node) {
@@ -1299,20 +1238,14 @@ export function bfs(tree: RouterTree) {
 		}
 		// const result = onNode(node)
 
-		queue.push(...node.children)
+		if (node?.childrenApps?.length) {
+			queue.push(...node.childrenApps)
+		}
 	}
 	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) {
+	// if (result === undefined) return new Response('', { status: 404 })
 	// if user returns not a response, convert to json
 	if (result instanceof Response) {
 		return result
@@ -1327,14 +1260,14 @@ export async function turnHandlerResultIntoResponse(result: any) {
 	// }
 	// if user returns an object, convert to json
 
-	return new Response(JSON.stringify(result, null, 2), {
+	return new Response(JSON.stringify(result ?? null, null, 2), {
 		headers: {
 			'content-type': 'application/json',
 		},
 	})
 }
 
-export type AnySpiceflow = Spiceflow<any, any, any, any, any, any, any, any>
+export type AnySpiceflow = Spiceflow<any, any, any, any, any, any>
 
 export function isZodSchema(value: unknown): value is ZodType {
 	return (