spiceflow 1.0.0 → 1.0.2

package/src/spiceflow.test.ts

@@ -1,37 +1,37 @@
 import { test, describe, expect } from 'vitest'
 import { Type } from '@sinclair/typebox'
-import { Elysia } from './spiceflow'
+import { bfs, Spiceflow } from './spiceflow'
 
 test('works', async () => {
-	const res = await new Elysia()
+	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 Elysia()
+	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 Elysia()
+	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('missing route is not found', async () => {
-	const res = await new Elysia()
+	const res = await new Spiceflow()
 		.get('/ids/:id', () => 'hi')
 		.handle(new Request('http://localhost/zxxx', { method: 'GET' }))
 	expect(res.status).toBe(404)
 })
 test('state works', async () => {
-	const res = await new Elysia()
+	const res = await new Spiceflow()
 		.state('id', '')
 		.onRequest(({ store, request }) => {
 			store.id = 'xxx'
@@ -45,7 +45,7 @@ test('state works', async () => {
 
 test('body is parsed as json', async () => {
 	let body
-	const res = await new Elysia()
+	const res = await new Spiceflow()
 		.state('id', '')
 
 		.post('/post', (c) => {
@@ -57,17 +57,17 @@ test('body is parsed as json', async () => {
 			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 () => {
-	const res = await new Elysia()
+	const res = await new Spiceflow()
 
 		.post(
 			'/post',
@@ -78,25 +78,25 @@ test('validate body works, request success', async () => {
 			},
 			{
 				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""`)
 })
 
 test('validate body works, request fails', async () => {
-	const res = await new Elysia()
+	const res = await new Spiceflow()
 
 		.post(
 			'/post',
@@ -107,27 +107,27 @@ test('validate body works, request fails', async () => {
 			{
 				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(await res.text()).toMatchInlineSnapshot(
-		`"data must have required property 'requiredField'"`
+		`"data must have required property 'requiredField'"`,
 	)
 })
 
 test('run onRequest', async () => {
-	const res = await new Elysia()
+	const res = await new Spiceflow()
 		.onRequest(({ request }) => {
 			expect(request.method).toBe('HEAD')
 			return new Response('ok', { status: 401 })
@@ -143,7 +143,7 @@ test('run onRequest', async () => {
 })
 
 test('run onRequest', async () => {
-	const res = await new Elysia()
+	const res = await new Spiceflow()
 		.onRequest(({ request }) => {
 			expect(request.method).toBe('HEAD')
 			return new Response('ok', { status: 401 })
@@ -159,89 +159,142 @@ test('run onRequest', async () => {
 })
 
 test('basPath works', async () => {
-	const res = await new Elysia({ basePath: '/one' })
+	const res = await new Spiceflow({ basePath: '/one' })
 		.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
-	const app = await new Elysia()
+	let onReqCalled: string[] = []
+	const app = await new Spiceflow()
+		.onRequest(({ request }) => {
+			onReqCalled.push('root')
+		})
 		.use(
-			new Elysia({ basePath: '/one' })
+			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 Elysia({ basePath: '/two' })
+			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)
 })
 
 test('use with nested basPath works', async () => {
-	const app = await new Elysia({ basePath: '/zero' })
+	const app = await new Spiceflow({ basePath: '/zero' })
 		.use(
-			new Elysia({ basePath: '/one' }).get(
+			new Spiceflow({ basePath: '/one' }).get(
 				'/ids/:id',
-				({ params }) => params.id
-			)
+				({ params }) => params.id,
+			),
 		)
 		.use(
-			new Elysia({ basePath: '/two' }).use(
-				new Elysia({ basePath: '/nested' }).get(
+			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')
 	}
 })
 
 test('errors inside basPath works', async () => {
 	let onErrorTriggered = [] as string[]
 	let onReqTriggered = [] as string[]
-	const app = await new Elysia({ basePath: '/zero' })
+	const app = await new Spiceflow({ basePath: '/zero' })
 		.onError(({ error }) => {
 			onErrorTriggered.push('root')
 			// return new Response('root', { status: 500 })
@@ -252,7 +305,7 @@ test('errors inside basPath works', async () => {
 		})
 
 		.use(
-			new Elysia({ basePath: '/two' })
+			new Spiceflow({ basePath: '/two' })
 				.onError(({ error }) => {
 					onErrorTriggered.push('two')
 					// return new Response('two', { status: 500 })
@@ -262,7 +315,7 @@ test('errors inside basPath works', async () => {
 					// return new Response('two', { status: 500 })
 				})
 				.use(
-					new Elysia({ basePath: '/nested' })
+					new Spiceflow({ basePath: '/nested' })
 						.onError(({ error }) => {
 							onErrorTriggered.push('nested')
 							// return new Response('nested', { status: 500 })
@@ -273,18 +326,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'))
 	}
 })