spiceflow 1.1.2 → 1.1.4

package/src/middleware.test.ts

@@ -23,6 +23,22 @@ test('middleware with next changes the response', async () => {
 	expect(await res.json()).toEqual('hi')
 	expect(res.headers.get('x-test')).toBe('ok')
 })
+test('middleware next returns a response even for 404, if there are no routes', async () => {
+	const res = await new Spiceflow()
+		.use(async ({ request }, next) => {
+			expect(request.method).toBe('GET')
+			const res = await next()
+			expect(res).toBeInstanceOf(Response)
+			if (res) {
+				res.headers.set('x-test', 'ok')
+			}
+			return res
+		})
+		.handle(new Request('http://localhost/non-existent', { method: 'GET' }))
+	expect(res.status).toBe(404)
+	expect(res.headers.get('x-test')).toBe('ok')
+	expect(await res.text()).toContain('Not Found')
+})
 
 test('middleware without next runs the next middleware and handler', async () => {
 	let middlewaresCalled = [] as string[]
@@ -82,6 +98,29 @@ test('middleware stops other middlewares', async () => {
 	expect(await res.text()).toEqual('ok')
 })
 
+test('calling next and then returning a new response works', async () => {
+	let middlewaresCalled = [] as string[]
+	const res = await new Spiceflow()
+		.use(async (ctx, next) => {
+			middlewaresCalled.push('first')
+			await next()
+			return new Response('middleware response')
+		})
+		.use(async (ctx, next) => {
+			middlewaresCalled.push('second')
+			return next()
+		})
+		.get('/ids/:id', () => {
+			middlewaresCalled.push('handler')
+			return 'handler response'
+		})
+
+		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+	expect(res.status).toBe(200)
+	expect(middlewaresCalled).toEqual(['first', 'second', 'handler'])
+	expect(await res.text()).toEqual('middleware response')
+})
+
 test('middleware changes handler response body', async () => {
 	let middlewaresCalled = [] as string[]
 	const res = await new Spiceflow()
@@ -105,3 +144,32 @@ test('middleware changes handler response body', async () => {
 	expect(middlewaresCalled).toEqual(['first', 'second'])
 	expect(await res.json()).toEqual('HELLO WORLD')
 })
+
+test('mutating response returned by next without returning it works', async () => {
+	let handlerCalledTimes = 0
+	const res = await new Spiceflow()
+		.use(async (ctx, next) => {
+			const response = await next()
+			if (response) {
+				response.headers.set('X-Custom-Header', 'Modified')
+			}
+			// Not returning the response, letting it pass through
+		})
+		.use(async (ctx, next) => {
+			const response = await next()
+			if (response) {
+				response.headers.set('X-Another-Header', 'Added')
+			}
+		})
+		.get('/test', () => {
+			handlerCalledTimes++
+			return 'hello world'
+		})
+		.handle(new Request('http://localhost/test'))
+
+	expect(res.status).toBe(200)
+	expect(handlerCalledTimes).toBe(1)
+	expect(await res.json()).toBe('hello world')
+	expect(res.headers.get('X-Custom-Header')).toBe('Modified')
+	expect(res.headers.get('X-Another-Header')).toBe('Added')
+})

package/src/spiceflow.test.ts

@@ -28,6 +28,83 @@ test('GET dynamic route', async () => {
 	expect(await res.json()).toEqual('hi')
 })
 
+test('onError does not fire on 404', async () => {
+	let errorFired = false
+	const app = new Spiceflow()
+		.get('/test', () => 'Hello')
+		.onError(() => {
+			errorFired = true
+			return new Response('Error', { status: 500 })
+		})
+
+	const res = await app.handle(
+		new Request('http://localhost/non-existent', { method: 'GET' }),
+	)
+
+	expect(res.status).toBe(404)
+	expect(errorFired).toBe(false)
+	expect(await res.text()).toBe('Not Found')
+})
+
+test('onError fires on validation errors', async () => {
+	let errorMessage = ''
+	const app = new Spiceflow()
+		.post(
+			'/test',
+			async ({ request }) => {
+				await request.json()
+				return 'Success'
+			},
+			{
+				body: z.object({
+					name: z.string(),
+				}),
+			},
+		)
+		.onError(({ error }) => {
+			errorMessage = error.message
+			return new Response('Error', { status: 400 })
+		})
+
+	const res = await app.handle(
+		new Request('http://localhost/test', {
+			method: 'POST',
+			headers: {
+				'Content-Type': 'application/json',
+			},
+			body: JSON.stringify({ name: 1 }), // Invalid type for 'name'
+		}),
+	)
+
+	expect(res.status).toBe(400)
+	expect(errorMessage).toContain('data/name must be string')
+	expect(await res.text()).toBe('Error')
+})
+
+test.todo('HEAD uses GET route, does not add body', async () => {
+	const app = new Spiceflow().get('/ids/:id', () => {
+		console.trace('GET')
+		return {
+			message: 'hi',
+			length: 10,
+		}
+	})
+
+	const res = await app.handle(
+		new Request('http://localhost/ids/xxx', { method: 'HEAD' }),
+	)
+	expect(res.status).toBe(200)
+	// expect(res.headers.get('Content-Length')).toBe('10')
+	expect(await res.text()).toBe('')
+
+	// Compare with GET to ensure HEAD is using GET route
+	const getRes = await app.handle(
+		new Request('http://localhost/ids/xxx', { method: 'GET' }),
+	)
+	expect(getRes.status).toBe(200)
+	expect(await getRes.json()).toEqual({ message: 'hi', length: 10 })
+})
+
 test('GET with query, untyped', async () => {
 	const res = await new Spiceflow()
 		.get('/query', ({ query }) => {
@@ -118,11 +195,11 @@ test('missing route is not found', async () => {
 test('state works', async () => {
 	const res = await new Spiceflow()
 		.state('id', '')
-		.use(({ store, request }) => {
-			store.id = 'xxx'
+		.use(({ state, request }) => {
+			state.id = 'xxx'
 		})
-		.get('/get', ({ store }) => {
-			expect(store.id).toBe('xxx')
+		.get('/get', ({ state: state }) => {
+			expect(state.id).toBe('xxx')
 		})
 		.handle(new Request('http://localhost/get'))
 	expect(res.status).toBe(200)

package/src/spiceflow.ts

@@ -17,7 +17,6 @@ import {
 	JoinPath,
 	LocalHook,
 	MaybeArray,
-	MergeSchema,
 	MetadataBase,
 	MiddlewareHandler,
 	Reconcile,
@@ -30,14 +29,12 @@ import {
 } from './types.js'
 let globalIndex = 0
 
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-// @ts-ignore
 import OriginalRouter from '@medley/router'
 import Ajv, { ValidateFunction } from 'ajv'
 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 { isProduction, ValidationError } from './error.js'
 import { isAsyncIterable, redirect } from './utils.js'
 
 const ajv = (addFormats.default || addFormats)(
@@ -74,9 +71,7 @@ export type InternalRoute = {
 	validateBody?: ValidateFunction
 	validateQuery?: ValidateFunction
 	validateParams?: ValidateFunction
-	prefix: string
-
-	// store: Record<any, any>
+	// prefix: string
 }
 
 type MedleyRouter = {
@@ -88,14 +83,16 @@ type MedleyRouter = {
 		| undefined
 	register: (path: string | undefined) => Record<string, InternalRoute>
 }
-/**
- * Router class
- */
+
+const notFoundHandler = (c) => {
+	return new Response('Not Found', { status: 404 })
+}
+
 export class Spiceflow<
 	const in out BasePath extends string = '',
 	const in out Scoped extends boolean = true,
 	const in out Singleton extends SingletonBase = {
-		store: {}
+		state: {}
 	},
 	const in out Definitions extends DefinitionBase = {
 		type: {}
@@ -113,7 +110,7 @@ export class Spiceflow<
 	private middlewares: Function[] = []
 	private onErrorHandlers: OnError[] = []
 	private routes: InternalRoute[] = []
-	private defaultStore: Record<any, any> = {}
+	private defaultState: Record<any, any> = {}
 	private topLevelApp?: AnySpiceflow
 
 	/** @internal */
@@ -151,7 +148,6 @@ export class Spiceflow<
 		const store = this.router.register(path)
 		let route: InternalRoute = {
 			...rest,
-			prefix: this.prefix || '',
 			method: (method || '') as any,
 			path: path || '',
 			handler: handler!,
@@ -166,6 +162,7 @@ export class Spiceflow<
 
 	private match(method: string, path: string) {
 		let root = this
+		let foundApp: AnySpiceflow | undefined
 		const result = bfsFind(this, (app) => {
 			app.topLevelApp = root
 			let prefix = this.getAppAndParents(app)
@@ -180,10 +177,12 @@ export class Spiceflow<
 			}
 			const medleyRoute = app.router.find(pathWithoutPrefix)
 			if (!medleyRoute) {
+				foundApp = app
 				return
 			}
 
 			let internalRoute: InternalRoute = medleyRoute.store[method]
+
 			if (internalRoute) {
 				const params = medleyRoute.params || {}
 
@@ -194,9 +193,46 @@ export class Spiceflow<
 				}
 				return res
 			}
+			if (method === 'HEAD') {
+				let internalRouteGet: InternalRoute = medleyRoute.store['GET']
+				if (!internalRouteGet?.handler) {
+					return
+				}
+				return {
+					app,
+					internalRoute: {
+						hooks: {},
+						handler: async (c) => {
+							const response = await internalRouteGet.handler(c)
+							if (response instanceof Response) {
+								return new Response('', {
+									status: response.status,
+									statusText: response.statusText,
+									headers: response.headers,
+								})
+							}
+							return new Response(null, { status: 200 })
+						},
+						method,
+						path,
+					} as InternalRoute,
+					params: medleyRoute.params,
+				}
+			}
 		})
 
-		return result
+		return (
+			result || {
+				app: foundApp || root,
+				internalRoute: {
+					hooks: {},
+					handler: notFoundHandler,
+					method,
+					path,
+				} as InternalRoute,
+				params: {},
+			}
+		)
 	}
 
 	state<const Name extends string | number | symbol, Value>(
@@ -206,8 +242,8 @@ export class Spiceflow<
 		BasePath,
 		Scoped,
 		{
-			store: Reconcile<
-				Singleton['store'],
+			state: Reconcile<
+				Singleton['state'],
 				{
 					[name in Name]: Value
 				}
@@ -217,7 +253,7 @@ export class Spiceflow<
 		Metadata,
 		Routes
 	> {
-		this.defaultStore[name] = value
+		this.defaultState[name] = value
 		return this as any
 	}
 
@@ -667,45 +703,6 @@ export class Spiceflow<
 
 	private scoped?: Scoped = true as Scoped
 
-	// group is not needed, you can add another prefixed app instead
-	// group<
-	// 	const Prefix extends string,
-	// 	const NewSpiceflow extends Spiceflow<any, any, any, any, any, any, any, any>
-	// >(
-	// 	prefix: Prefix,
-	// 	run: (
-	// 		group: Spiceflow<
-	// 			`${BasePath}${Prefix}`,
-	// 			Scoped,
-	// 			Singleton,
-	// 			Definitions,
-	// 			Metadata,
-	// 			{},
-	// 			Ephemeral,
-	// 			Volatile
-	// 		>
-	// 	) => NewSpiceflow
-	// ): Spiceflow<
-	// 	BasePath,
-	// 	Scoped,
-	// 	Singleton,
-	// 	Definitions,
-	// 	Metadata,
-	// 	Prettify<Routes & NewSpiceflow['_routes']>,
-	// 	Ephemeral,
-	// 	Volatile
-	// > {
-	// 	let thisRouter = this.routers[0]
-	// 	this.routers.push(
-	// 		...instance.routers.map((r) => ({
-	// 			...r,
-	// 			prefix: (thisRouter.prefix || '') + r.prefix
-	// 		}))
-	// 	)
-
-	// 	return this
-	// }
-
 	use<const NewSpiceflow extends AnySpiceflow>(
 		instance: NewSpiceflow,
 	): IsAny<NewSpiceflow> extends true
@@ -725,7 +722,7 @@ export class Spiceflow<
 			MiddlewareHandler<
 				Schema,
 				{
-					store: Singleton['store']
+					state: Singleton['state']
 				}
 			>
 		>,
@@ -752,12 +749,6 @@ export class Spiceflow<
 		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): Promise<Response> {
 		let u = new URL(request.url, 'http://localhost')
 		let path = u.pathname + u.search
@@ -773,39 +764,27 @@ export class Spiceflow<
 
 			const route = this.match(request.method, path)
 
-			if (!route) {
-				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.getAppsInScope(route.app).flatMap(
 				(x) => x.onErrorHandlers,
 			)
 			let {
 				params,
-				app: { defaultStore },
+				app: { defaultState: defaultStore },
 			} = route
 			const middlewares = this.getAppsInScope(route.app).flatMap(
 				(x) => x.middlewares,
 			)
 			// console.log({ onReqHandlers })
-			let store = { ...defaultStore }
+			let state = { ...defaultStore }
 
 			let content = route?.internalRoute?.hooks?.content
 
 			if (route.internalRoute?.validateBody) {
 				// TODO don't clone the request
 				let typedRequest =
-					request instanceof TypedRequest
+					request instanceof SpiceflowRequest
 						? request
-						: new TypedRequest(request)
+						: new SpiceflowRequest(request)
 				typedRequest.validateBody = route.internalRoute?.validateBody
 				request = typedRequest
 			}
@@ -813,27 +792,31 @@ export class Spiceflow<
 			let query = parseQuery.parse((u.search || '').slice(1))
 
 			let index = 0
-
+			let context = {
+				...defaultContext,
+				request,
+				state,
+				path,
+				query,
+				params,
+				redirect,
+			} satisfies MiddlewareContext<any>
+			let handlerResponse: Response | undefined
 			const next = async () => {
 				if (index < middlewares.length) {
 					const middleware = middlewares[index]
 					index++
-					let context = {
-						request,
-						store,
-						path,
-						query,
-						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)
 					}
 				}
+				if (handlerResponse) {
+					return handlerResponse
+				}
 
 				query = runValidation(query, route.internalRoute?.validateQuery)
 				params = runValidation(
@@ -841,29 +824,18 @@ export class Spiceflow<
 					route.internalRoute?.validateParams,
 				)
 
-				// console.log(route)
-
-				const res = route.internalRoute?.handler({
-					...defaultContext,
-					request,
-					params: params as any,
-					redirect,
-					store,
-					query,
-					// body,
-					path,
-
-					// platform
-				} satisfies Context<any, any, any>)
+				const res = route.internalRoute?.handler(context)
 				if (isAsyncIterable(res)) {
-					return await this.handleStream({
+					handlerResponse = await this.handleStream({
 						generator: res,
 						request,
 						onErrorHandlers,
 					})
+					return handlerResponse
 				}
 
-				return await turnHandlerResultIntoResponse(res)
+				handlerResponse = await turnHandlerResultIntoResponse(res)
+				return handlerResponse
 			}
 			const response = await next()
 
@@ -875,11 +847,13 @@ export class Spiceflow<
 				error: err,
 				request,
 			})
-			if (res) return res
+			if (res instanceof Response) return res
+
 			let status = err?.status ?? 500
-			return new Response(err?.message || 'Internal Server Error', {
+			res ||= new Response(err?.message || 'Internal Server Error', {
 				status,
 			})
+			return res
 		}
 	}
 
@@ -1003,7 +977,7 @@ export class Spiceflow<
 				req.url || '',
 				`http://${req.headers.host || hostname || 'localhost'}`,
 			)
-			const typedRequest = new TypedRequest(url.toString(), {
+			const typedRequest = new SpiceflowRequest(url.toString(), {
 				method: req.method,
 				headers: req.headers as HeadersInit,
 				body:
@@ -1223,7 +1197,7 @@ function bfsFind<T>(
 	}
 	return
 }
-export class TypedRequest<T = any> extends Request {
+export class SpiceflowRequest<T = any> extends Request {
 	validateBody?: ValidateFunction
 
 	async json(): Promise<T> {

package/src/types.test.ts

@@ -48,3 +48,4 @@ test('`use` on Spiceflow return', async () => {
 	expect(res.status).toBe(200)
 	expect(await res.json()).toEqual('hi')
 })
+