spiceflow 1.1.8 → 1.1.10

package/src/middleware.test.ts

@@ -4,96 +4,96 @@ import { bfs, Spiceflow } from './spiceflow.js'
 import { z } from 'zod'
 
 test('middleware with next changes the response', 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
-		})
-		.get('/ids/:id', () => 'hi')
-		.post('/ids/:id', ({ params: { id } }) => id, {
-			params: z.object({ id: z.string() }),
-		})
-		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
-	expect(res.status).toBe(200)
-	expect(await res.json()).toEqual('hi')
-	expect(res.headers.get('x-test')).toBe('ok')
+  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
+    })
+    .get('/ids/:id', () => 'hi')
+    .post('/ids/:id', ({ params: { id } }) => id, {
+      params: z.object({ id: z.string() }),
+    })
+    .handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual('hi')
+  expect(res.headers.get('x-test')).toBe('ok')
 })
 
 test('middleware with no handlers works', async () => {
-	const res = await new Spiceflow()
-		.use(async ({ request }, next) => {
-			expect(request.method).toBe('GET')
-			// expect(res).toBeInstanceOf(Response)
-			return new Response('ok')
-		})
+  const res = await new Spiceflow()
+    .use(async ({ request }, next) => {
+      expect(request.method).toBe('GET')
+      // expect(res).toBeInstanceOf(Response)
+      return new Response('ok')
+    })
 
-		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
-	expect(res.status).toBe(200)
-	expect(await res.text()).toEqual('ok')
+    .handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+  expect(res.status).toBe(200)
+  expect(await res.text()).toEqual('ok')
 })
 test('middleware calling next() without returning it works', async () => {
-	const res = await new Spiceflow()
-		.use(async ({ request }, next) => {
-			expect(request.method).toBe('GET')
-			// expect(res).toBeInstanceOf(Response)
-			await next()
-		})
-		.use(async ({ request }, next) => {
-			expect(request.method).toBe('GET')
-			// expect(res).toBeInstanceOf(Response)
-			return new Response('"hi"')
-		})
-		.get('/ids/:id', () => 'not hi')
+  const res = await new Spiceflow()
+    .use(async ({ request }, next) => {
+      expect(request.method).toBe('GET')
+      // expect(res).toBeInstanceOf(Response)
+      await next()
+    })
+    .use(async ({ request }, next) => {
+      expect(request.method).toBe('GET')
+      // expect(res).toBeInstanceOf(Response)
+      return new Response('"hi"')
+    })
+    .get('/ids/:id', () => 'not hi')
 
-		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
-	expect(res.status).toBe(200)
-	expect(await res.json()).toEqual('hi')
+    .handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual('hi')
 })
 test('middleware calling next() without returning it, calls handler', async () => {
-	const res = await new Spiceflow()
-		.use(async ({ request }, next) => {
-			expect(request.method).toBe('GET')
-			// expect(res).toBeInstanceOf(Response)
-			await next()
-		})
+  const res = await new Spiceflow()
+    .use(async ({ request }, next) => {
+      expect(request.method).toBe('GET')
+      // expect(res).toBeInstanceOf(Response)
+      await next()
+    })
 
-		.get('/ids/:id', () => 'hi')
+    .get('/ids/:id', () => 'hi')
 
-		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
-	expect(res.status).toBe(200)
-	expect(await res.json()).toEqual('hi')
+    .handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+  expect(res.status).toBe(200)
+  expect(await res.json()).toEqual('hi')
 })
 
 test('middleware state is not shared between requests', async () => {
-	const app = await new Spiceflow()
-		.state('x', -1)
-		.use(async ({ request, state, query }, next) => {
-			state.x = Number(query?.x || -1)
-		})
-		.get('/get', ({ state }) => {
-			return state.x
-		})
-	async function first() {
-		const res = await app.handle(new Request('http://localhost/get?x=1'))
-		expect(res.status).toBe(200)
-		expect(await res.json()).toEqual(1)
-	}
-	async function second() {
-		const res = await app.handle(new Request('http://localhost/get?x=2'))
-		expect(res.status).toBe(200)
-		expect(await res.json()).toEqual(2)
-	}
-	await Promise.all(
-		new Array(100).fill(0).map((_, i) => {
-			if (i % 2 === 0) return first()
-			return second()
-		}),
-	)
+  const app = await new Spiceflow()
+    .state('x', -1)
+    .use(async ({ request, state, query }, next) => {
+      state.x = Number(query?.x || -1)
+    })
+    .get('/get', ({ state }) => {
+      return state.x
+    })
+  async function first() {
+    const res = await app.handle(new Request('http://localhost/get?x=1'))
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual(1)
+  }
+  async function second() {
+    const res = await app.handle(new Request('http://localhost/get?x=2'))
+    expect(res.status).toBe(200)
+    expect(await res.json()).toEqual(2)
+  }
+  await Promise.all(
+    new Array(100).fill(0).map((_, i) => {
+      if (i % 2 === 0) return first()
+      return second()
+    }),
+  )
 })
 
 // test('child app that adds state also adds state in the parent app', async () => {
@@ -127,152 +127,152 @@ test('middleware state is not shared between requests', async () => {
 // })
 
 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')
+  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[]
-	const res = await new Spiceflow()
-		.use(async ({ request }) => {
-			middlewaresCalled.push('first')
-		})
-		.use(async ({ request }, next) => {
-			middlewaresCalled.push('second')
-			const res = await next()
-			if (res instanceof Response) {
-				res.headers.set('x-test', 'ok')
-			}
-			return res
-		})
-		.get('/ids/:id', () => 'hi')
+  let middlewaresCalled = [] as string[]
+  const res = await new Spiceflow()
+    .use(async ({ request }) => {
+      middlewaresCalled.push('first')
+    })
+    .use(async ({ request }, next) => {
+      middlewaresCalled.push('second')
+      const res = await next()
+      if (res instanceof Response) {
+        res.headers.set('x-test', 'ok')
+      }
+      return res
+    })
+    .get('/ids/:id', () => 'hi')
 
-		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
-	expect(res.status).toBe(200)
-	expect(middlewaresCalled).toEqual(['first', 'second'])
-	expect(await res.json()).toEqual('hi')
-	expect(res.headers.get('x-test')).toBe('ok')
+    .handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+  expect(res.status).toBe(200)
+  expect(middlewaresCalled).toEqual(['first', 'second'])
+  expect(await res.json()).toEqual('hi')
+  expect(res.headers.get('x-test')).toBe('ok')
 })
 test('middleware throws response', async () => {
-	let middlewaresCalled = [] as string[]
-	const res = await new Spiceflow()
-		.use(async ({ request }) => {
-			middlewaresCalled.push('first')
-		})
-		.use(async ({ request }, next) => {
-			middlewaresCalled.push('second')
-			throw new Response('ok')
-		})
-		.get('/ids/:id', () => 'hi')
+  let middlewaresCalled = [] as string[]
+  const res = await new Spiceflow()
+    .use(async ({ request }) => {
+      middlewaresCalled.push('first')
+    })
+    .use(async ({ request }, next) => {
+      middlewaresCalled.push('second')
+      throw new Response('ok')
+    })
+    .get('/ids/:id', () => 'hi')
 
-		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
-	expect(res.status).toBe(200)
-	expect(middlewaresCalled).toEqual(['first', 'second'])
-	expect(await res.text()).toEqual('ok')
+    .handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+  expect(res.status).toBe(200)
+  expect(middlewaresCalled).toEqual(['first', 'second'])
+  expect(await res.text()).toEqual('ok')
 })
 
 test('middleware stops other middlewares', async () => {
-	let middlewaresCalled = [] as string[]
-	const res = await new Spiceflow()
-		.use(async ({ request }) => {
-			middlewaresCalled.push('first')
-			return new Response('ok')
-		})
-		.use(async ({ request }) => {
-			middlewaresCalled.push('second')
-		})
-		.get('/ids/:id', () => 'hi')
+  let middlewaresCalled = [] as string[]
+  const res = await new Spiceflow()
+    .use(async ({ request }) => {
+      middlewaresCalled.push('first')
+      return new Response('ok')
+    })
+    .use(async ({ request }) => {
+      middlewaresCalled.push('second')
+    })
+    .get('/ids/:id', () => 'hi')
 
-		.handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
-	expect(res.status).toBe(200)
-	expect(middlewaresCalled).toEqual(['first'])
-	expect(await res.text()).toEqual('ok')
+    .handle(new Request('http://localhost/ids/xxx', { method: 'GET' }))
+  expect(res.status).toBe(200)
+  expect(middlewaresCalled).toEqual(['first'])
+  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'
-		})
+  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')
+    .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()
-		.use(async (ctx, next) => {
-			middlewaresCalled.push('first')
-			const response = await next()
-			if (response) {
-				const body = await response.text()
-				return new Response(body.toUpperCase(), response)
-			}
-			return response
-		})
-		.use(async (ctx, next) => {
-			middlewaresCalled.push('second')
-			return next()
-		})
-		.get('/test', () => 'hello world')
-		.handle(new Request('http://localhost/test'))
+  let middlewaresCalled = [] as string[]
+  const res = await new Spiceflow()
+    .use(async (ctx, next) => {
+      middlewaresCalled.push('first')
+      const response = await next()
+      if (response) {
+        const body = await response.text()
+        return new Response(body.toUpperCase(), response)
+      }
+      return response
+    })
+    .use(async (ctx, next) => {
+      middlewaresCalled.push('second')
+      return next()
+    })
+    .get('/test', () => 'hello world')
+    .handle(new Request('http://localhost/test'))
 
-	expect(res.status).toBe(200)
-	expect(middlewaresCalled).toEqual(['first', 'second'])
-	expect(await res.json()).toEqual('HELLO WORLD')
+  expect(res.status).toBe(200)
+  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'))
+  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')
+  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/openapi.test.ts

@@ -4,104 +4,104 @@ import { openapi } from './openapi.js'
 import { z } from 'zod'
 
 test('openapi response', async () => {
-	const app = await new Spiceflow()
-		.use(
-			openapi({
-				documentation: {
-					info: {
-						title: 'Spiceflow Docs',
-						version: '0.0.0',
-					},
-				},
-			}),
-		)
-		.use(
-			new Spiceflow({ basePath: '/one' }).get(
-				'/ids/:id',
-				({ params }) => {
-					if (Math.random() < 0.5) {
-						// TODO add a way to set status
+  const app = await new Spiceflow()
+    .use(
+      openapi({
+        documentation: {
+          info: {
+            title: 'Spiceflow Docs',
+            version: '0.0.0',
+          },
+        },
+      }),
+    )
+    .use(
+      new Spiceflow({ basePath: '/one' }).get(
+        '/ids/:id',
+        ({ params }) => {
+          if (Math.random() < 0.5) {
+            // TODO add a way to set status
 
-						return {
-							message: 'sdf',
-						}
-					}
-					return params.id
-				},
-				{
-					response: {
-						200: z.string(),
-						404: z.object({
-							message: z.string(),
-						}),
-					},
-				},
-			),
-		)
-		.patch(
-			'/addBody',
-			async (c) => {
-				let body = await c.request.json()
-				return body
-			},
-			{
-				body: z.object({
-					name: z.string(),
-				}),
-				response: z.object({
-					name: z.string().optional(),
-				}),
-			},
-		)
-		.get(
-			'/queryParams',
-			async (c) => {
-				const query = c.query
-				return query
-			},
-			{
-				query: z.object({
-					name: z.string(),
-				}),
-				response: z.object({
-					name: z.string().optional(),
-				}),
-			},
-		)
-		.post(
-			'/queryParams',
-			async (c) => {
-				const query = c.query
-				return query
-			},
-			{
-				detail: {
-					description: 'This is a post',
-					operationId: 'postQueryParamsXXX',
-				},
-				body: z.object({
-					name: z.string(),
-				}),
-				response: z.object({
-					name: z.string().optional(),
-				}),
-			},
-		)
-		.use(
-			new Spiceflow({ basePath: '/two' }).get(
-				'/ids/:id',
-				({ params }) => params.id,
-				{
-					params: z.object({
-						id: z.string(),
-					}),
-				},
-			),
-		)
-	const openapiSchema = await app
-		.handle(new Request('http://localhost/openapi'))
-		.then((x) => x.json())
-	expect(openapiSchema).toMatchInlineSnapshot(`
+            return {
+              message: 'sdf',
+            }
+          }
+          return params.id
+        },
+        {
+          response: {
+            200: z.string(),
+            404: z.object({
+              message: z.string(),
+            }),
+          },
+        },
+      ),
+    )
+    .patch(
+      '/addBody',
+      async (c) => {
+        let body = await c.request.json()
+        return body
+      },
+      {
+        body: z.object({
+          name: z.string(),
+        }),
+        response: z.object({
+          name: z.string().optional(),
+        }),
+      },
+    )
+    .get(
+      '/queryParams',
+      async (c) => {
+        const query = c.query
+        return query
+      },
+      {
+        query: z.object({
+          name: z.string(),
+        }),
+        response: z.object({
+          name: z.string().optional(),
+        }),
+      },
+    )
+    .post(
+      '/queryParams',
+      async (c) => {
+        const query = c.query
+        return query
+      },
+      {
+        detail: {
+          description: 'This is a post',
+          operationId: 'postQueryParamsXXX',
+        },
+        body: z.object({
+          name: z.string(),
+        }),
+        response: z.object({
+          name: z.string().optional(),
+        }),
+      },
+    )
+    .use(
+      new Spiceflow({ basePath: '/two' }).get(
+        '/ids/:id',
+        ({ params }) => params.id,
+        {
+          params: z.object({
+            id: z.string(),
+          }),
+        },
+      ),
+    )
+  const openapiSchema = await app
+    .handle(new Request('http://localhost/openapi'))
+    .then((x) => x.json())
+  expect(openapiSchema).toMatchInlineSnapshot(`
 		{
 		  "components": {
 		    "schemas": {},