spiceflow 1.0.1 → 1.0.3

package/src/spiceflow.test.ts

@@ -1,27 +1,109 @@
 import { test, describe, expect } from 'vitest'
 import { Type } from '@sinclair/typebox'
-import { Spiceflow } from './spiceflow'
+import { bfs, Spiceflow } from './spiceflow'
+import { z } from 'zod'
 
 test('works', async () => {
 	const res = await new Spiceflow()
 		.post('/xxx', () => 'hi')
 		.handle(new Request('http://localhost/xxx', { method: 'POST' }))
 	expect(res.status).toBe(200)
-	expect(await res.text()).toBe(JSON.stringify('hi'))
+	expect(await res.json()).toEqual('hi')
 })
 test('dynamic route', async () => {
 	const res = await new Spiceflow()
 		.post('/ids/:id', () => 'hi')
 		.handle(new Request('http://localhost/ids/xxx', { method: 'POST' }))
 	expect(res.status).toBe(200)
-	expect(await res.text()).toBe(JSON.stringify('hi'))
+	expect(await res.json()).toEqual('hi')
 })
 test('GET dynamic route', async () => {
 	const res = await new Spiceflow()
 		.get('/ids/:id', () => 'hi')
 		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
 	expect(res.status).toBe(200)
-	expect(await res.text()).toBe(JSON.stringify('hi'))
+	expect(await res.json()).toEqual('hi')
+})
+
+test('GET with query, untyped', async () => {
+	const res = await new Spiceflow()
+		.get('/query', ({ query }) => {
+			return query.id
+		})
+		.handle(new Request('http://localhost/query?id=hi', { method: 'GET' }))
+	expect(res.status).toBe(200)
+	expect(await res.json()).toEqual('hi')
+})
+
+test('GET with query, zod, fails validation', async () => {
+	const res = await new Spiceflow()
+		.get(
+			'/query',
+			({ query }) => {
+				return query.id
+			},
+			{
+				query: z.object({
+					id: z.number(),
+				}),
+			},
+		)
+		.handle(new Request('http://localhost/query?id=hi', { method: 'GET' }))
+	expect(res.status).toBe(422)
+})
+
+test('GET with query and zod', async () => {
+	const res = await new Spiceflow()
+		.get(
+			'/query',
+			({ query }) => {
+				return query.id
+				// @ts-expect-error
+				void query.sdfsd
+			},
+			{
+				query: z.object({
+					id: z.string(),
+				}),
+			},
+		)
+		.handle(new Request('http://localhost/query?id=hi', { method: 'GET' }))
+	expect(res.status).toBe(200)
+	expect(await res.json()).toEqual('hi')
+})
+
+test('GET dynamic route, params are typed', async () => {
+	const res = await new Spiceflow()
+		.get('/ids/:id', ({ params }) => {
+			let id = params.id
+			// @ts-expect-error
+			params.sdfsd
+			return id
+		})
+		.handle(new Request('http://localhost/ids/hi', { method: 'GET' }))
+	expect(res.status).toBe(200)
+	expect(await res.json()).toEqual('hi')
+})
+
+test('GET dynamic route, params are typed with schema', async () => {
+	const res = await new Spiceflow()
+		.get(
+			'/ids/:id',
+			({ params }) => {
+				let id = params.id
+				// @ts-expect-error
+				params.sdfsd
+				return id
+			},
+			{
+				params: z.object({
+					id: z.string(),
+				}),
+			},
+		)
+		.handle(new Request('http://localhost/ids/hi', { method: 'GET' }))
+	expect(res.status).toBe(200)
+	expect(await res.json()).toEqual('hi')
 })
 
 test('missing route is not found', async () => {
@@ -48,22 +130,22 @@ test('body is parsed as json', async () => {
 	const res = await new Spiceflow()
 		.state('id', '')
 
-		.post('/post', (c) => {
-			body = c.body
-			// console.log({ body })
+		.post('/post', async (c) => {
+			body = await c.request.json()
+			// console.log({request})
 			return body
 		})
 		.handle(
 			new Request('http://localhost/post', {
 				method: 'POST',
 				headers: {
-					'content-type': 'application/json'
+					'content-type': 'application/json',
 				},
-				body: JSON.stringify({ name: 'John' })
-			})
+				body: JSON.stringify({ name: 'John' }),
+			}),
 		)
 	expect(res.status).toBe(200)
-	expect(await res.text()).toBe(JSON.stringify({ name: 'John' }))
+	expect(await res.json()).toEqual({ name: 'John' })
 })
 
 test('validate body works, request success', async () => {
@@ -71,25 +153,26 @@ test('validate body works, request success', async () => {
 
 		.post(
 			'/post',
-			({ body }) => {
-				// console.log({ body })
+			async ({ request }) => {
+				// console.log({request})
+				let body = await request.json()
 				expect(body).toEqual({ name: 'John' })
 				return 'ok'
 			},
 			{
 				body: Type.Object({
-					name: Type.String()
-				})
-			}
+					name: Type.String(),
+				}),
+			},
 		)
 		.handle(
 			new Request('http://localhost/post', {
 				method: 'POST',
 				headers: {
-					'content-type': 'application/json'
+					'content-type': 'application/json',
 				},
-				body: JSON.stringify({ name: 'John' })
-			})
+				body: JSON.stringify({ name: 'John' }),
+			}),
 		)
 	expect(res.status).toBe(200)
 	expect(await res.text()).toMatchInlineSnapshot(`""ok""`)
@@ -100,29 +183,30 @@ test('validate body works, request fails', async () => {
 
 		.post(
 			'/post',
-			({ body, redirect, error }) => {
-				// console.log({ body })
+			async ({ request, redirect }) => {
+				// console.log({request})
+				let body = await request.json()
 				expect(body).toEqual({ name: 'John' })
 			},
 			{
 				body: Type.Object({
 					name: Type.String(),
-					requiredField: Type.String()
-				})
-			}
+					requiredField: Type.String(),
+				}),
+			},
 		)
 		.handle(
 			new Request('http://localhost/post', {
 				method: 'POST',
 				headers: {
-					'content-type': 'application/json'
+					'content-type': 'application/json',
 				},
-				body: JSON.stringify({ name: 'John' })
-			})
+				body: JSON.stringify({ name: 'John' }),
+			}),
 		)
-	expect(res.status).toBe(400)
+	expect(res.status).toBe(422)
 	expect(await res.text()).toMatchInlineSnapshot(
-		`"data must have required property 'requiredField'"`
+		`"data must have required property 'requiredField'"`,
 	)
 })
 
@@ -163,43 +247,96 @@ test('basPath works', async () => {
 		.get('/ids/:id', () => 'hi')
 		.handle(new Request('http://localhost/one/ids/xxx', { method: 'GET' }))
 	expect(res.status).toBe(200)
-	expect(await res.text()).toBe(JSON.stringify('hi'))
+	expect(await res.json()).toEqual('hi')
 })
 
+test('basPath works with use', async () => {
+	let app = new Spiceflow({ basePath: '/one' }).use(
+		new Spiceflow({})
+			.get('/two', () => 'hi')
+			.use(
+				new Spiceflow({ basePath: '/three' }).get('/four', () => 'hi'),
+			),
+	)
+	{
+		const res = await app.handle(
+			new Request('http://localhost/one/two', { method: 'GET' }),
+		)
+
+		expect(res.status).toBe(200)
+		expect(await res.json()).toEqual('hi')
+	}
+	{
+		const res = await app.handle(
+			new Request('http://localhost/one/three/four', { method: 'GET' }),
+		)
+		expect(res.status).toBe(200)
+		expect(await res.json()).toEqual('hi')
+	}
+})
+
+test('getRouteAndParents', async () => {
+	let app = new Spiceflow({ basePath: '/one' })
+		.get('/ids/:id', () => 'hi')
+		.use(
+			new Spiceflow({ basePath: '/two' }).use(
+				new Spiceflow({ basePath: '/three' }).get('/four', () => 'hi'),
+			),
+		)
+
+	let routers = bfs(app['routerTree'])
+	let last = routers[routers.length - 1]
+
+	expect(app['getRouteAndParents'](last).map((x) => x.prefix))
+		.toMatchInlineSnapshot(`
+			[
+			  "/three",
+			  "/two",
+			  "/one",
+			]
+		`)
+})
 test('use with 2 basPath works', async () => {
 	let oneOnReq = false
 	let twoOnReq = false
+	let onReqCalled: string[] = []
 	const app = await new Spiceflow()
+		.onRequest(({ request }) => {
+			onReqCalled.push('root')
+		})
 		.use(
 			new Spiceflow({ basePath: '/one' })
 				.onRequest(({ request }) => {
 					oneOnReq = true
+					onReqCalled.push('one')
 				})
-				.get('/ids/:id', ({ params }) => params.id)
+				.get('/ids/:id', ({ params }) => params.id),
 		)
 		.use(
 			new Spiceflow({ basePath: '/two' })
 				.onRequest((c) => {
 					twoOnReq = true
+					onReqCalled.push('two')
 				})
-				.get('/ids/:id', ({ params }) => params.id)
+				.get('/ids/:id', ({ params }) => params.id),
 		)
 
 	{
 		const res = await app.handle(
-			new Request('http://localhost/one/ids/one')
+			new Request('http://localhost/one/ids/one'),
 		)
 		expect(res.status).toBe(200)
 
-		expect(await res.text()).toBe(JSON.stringify('one'))
+		expect(await res.json()).toEqual('one')
 	}
+	expect(onReqCalled).toEqual(['root', 'one'])
 	{
 		const res = await app.handle(
-			new Request('http://localhost/two/ids/two')
+			new Request('http://localhost/two/ids/two'),
 		)
 		expect(res.status).toBe(200)
 
-		expect(await res.text()).toBe(JSON.stringify('two'))
+		expect(await res.json()).toEqual('two')
 	}
 	expect(oneOnReq).toBe(true)
 	expect(twoOnReq).toBe(true)
@@ -210,31 +347,31 @@ test('use with nested basPath works', async () => {
 		.use(
 			new Spiceflow({ basePath: '/one' }).get(
 				'/ids/:id',
-				({ params }) => params.id
-			)
+				({ params }) => params.id,
+			),
 		)
 		.use(
 			new Spiceflow({ basePath: '/two' }).use(
 				new Spiceflow({ basePath: '/nested' }).get(
 					'/ids/:id',
-					({ params }) => params.id
-				)
-			)
+					({ params }) => params.id,
+				),
+			),
 		)
 	{
 		const res = await app.handle(
-			new Request('http://localhost/zero/one/ids/one')
+			new Request('http://localhost/zero/one/ids/one'),
 		)
 		expect(res.status).toBe(200)
-		expect(await res.text()).toBe(JSON.stringify('one'))
+		expect(await res.json()).toEqual('one')
 	}
 
 	{
 		const res = await app.handle(
-			new Request('http://localhost/zero/two/nested/ids/nested')
+			new Request('http://localhost/zero/two/nested/ids/nested'),
 		)
 		expect(res.status).toBe(200)
-		expect(await res.text()).toBe(JSON.stringify('nested'))
+		expect(await res.json()).toEqual('nested')
 	}
 })
 
@@ -273,18 +410,18 @@ test('errors inside basPath works', async () => {
 						})
 						.get('/ids/:id', ({ params }) => {
 							throw new Error('error message')
-						})
-				)
+						}),
+				),
 		)
 
 	{
 		const res = await app.handle(
-			new Request('http://localhost/zero/two/nested/ids/nested')
+			new Request('http://localhost/zero/two/nested/ids/nested'),
 		)
-		expect(onErrorTriggered).toEqual(['nested', 'two', 'root'])
-		expect(onReqTriggered).toEqual(['nested', 'two', 'root'])
+		expect(onErrorTriggered).toEqual(['root', 'two', 'nested'])
+		expect(onReqTriggered).toEqual(['root', 'two', 'nested'])
 		expect(res.status).toBe(500)
 		expect(await res.text()).toBe('error message')
-		// expect(await res.text()).toBe(JSON.stringify('nested'))
+		// expect(await res.json()).toEqual('nested'))
 	}
 })