spiceflow 0.0.7 → 1.0.0

package/src/elysia-fork/utils.ts

@@ -0,0 +1,85 @@
+export const StatusMap = {
+	Continue: 100,
+	'Switching Protocols': 101,
+	Processing: 102,
+	'Early Hints': 103,
+	OK: 200,
+	Created: 201,
+	Accepted: 202,
+	'Non-Authoritative Information': 203,
+	'No Content': 204,
+	'Reset Content': 205,
+	'Partial Content': 206,
+	'Multi-Status': 207,
+	'Already Reported': 208,
+	'Multiple Choices': 300,
+	'Moved Permanently': 301,
+	Found: 302,
+	'See Other': 303,
+	'Not Modified': 304,
+	'Temporary Redirect': 307,
+	'Permanent Redirect': 308,
+	'Bad Request': 400,
+	Unauthorized: 401,
+	'Payment Required': 402,
+	Forbidden: 403,
+	'Not Found': 404,
+	'Method Not Allowed': 405,
+	'Not Acceptable': 406,
+	'Proxy Authentication Required': 407,
+	'Request Timeout': 408,
+	Conflict: 409,
+	Gone: 410,
+	'Length Required': 411,
+	'Precondition Failed': 412,
+	'Payload Too Large': 413,
+	'URI Too Long': 414,
+	'Unsupported Media Type': 415,
+	'Range Not Satisfiable': 416,
+	'Expectation Failed': 417,
+	"I'm a teapot": 418,
+	'Misdirected Request': 421,
+	'Unprocessable Content': 422,
+	Locked: 423,
+	'Failed Dependency': 424,
+	'Too Early': 425,
+	'Upgrade Required': 426,
+	'Precondition Required': 428,
+	'Too Many Requests': 429,
+	'Request Header Fields Too Large': 431,
+	'Unavailable For Legal Reasons': 451,
+	'Internal Server Error': 500,
+	'Not Implemented': 501,
+	'Bad Gateway': 502,
+	'Service Unavailable': 503,
+	'Gateway Timeout': 504,
+	'HTTP Version Not Supported': 505,
+	'Variant Also Negotiates': 506,
+	'Insufficient Storage': 507,
+	'Loop Detected': 508,
+	'Not Extended': 510,
+	'Network Authentication Required': 511
+} as const
+
+export const InvertedStatusMap = Object.fromEntries(
+	Object.entries(StatusMap).map(([k, v]) => [v, k])
+) as {
+	[K in keyof StatusMap as StatusMap[K]]: K
+}
+
+export type StatusMap = typeof StatusMap
+export type InvertedStatusMap = typeof InvertedStatusMap
+
+
+
+/**
+ *
+ * @param url URL to redirect to
+ * @param HTTP status code to send,
+ */
+export const redirect = (
+	url: string,
+	status: 301 | 302 | 303 | 307 | 308 = 302
+) => Response.redirect(url, status)
+
+export type redirect = typeof redirect

package/src/spiceflow.test.ts

@@ -0,0 +1,290 @@
+import { test, describe, expect } from 'vitest'
+import { Type } from '@sinclair/typebox'
+import { Elysia } from './spiceflow'
+
+test('works', async () => {
+	const res = await new Elysia()
+		.post('/xxx', () => 'hi')
+		.handle(new Request('http://localhost/xxx', { method: 'POST' }))
+	expect(res.status).toBe(200)
+	expect(await res.text()).toBe(JSON.stringify('hi'))
+})
+test('dynamic route', async () => {
+	const res = await new Elysia()
+		.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'))
+})
+test('GET dynamic route', async () => {
+	const res = await new Elysia()
+		.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'))
+})
+
+test('missing route is not found', async () => {
+	const res = await new Elysia()
+		.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()
+		.state('id', '')
+		.onRequest(({ store, request }) => {
+			store.id = 'xxx'
+		})
+		.get('/get', ({ store }) => {
+			expect(store.id).toBe('xxx')
+		})
+		.handle(new Request('http://localhost/get'))
+	expect(res.status).toBe(200)
+})
+
+test('body is parsed as json', async () => {
+	let body
+	const res = await new Elysia()
+		.state('id', '')
+
+		.post('/post', (c) => {
+			body = c.body
+			// console.log({ body })
+			return body
+		})
+		.handle(
+			new Request('http://localhost/post', {
+				method: 'POST',
+				headers: {
+					'content-type': 'application/json'
+				},
+				body: JSON.stringify({ name: 'John' })
+			})
+		)
+	expect(res.status).toBe(200)
+	expect(await res.text()).toBe(JSON.stringify({ name: 'John' }))
+})
+
+test('validate body works, request success', async () => {
+	const res = await new Elysia()
+
+		.post(
+			'/post',
+			({ body }) => {
+				// console.log({ body })
+				expect(body).toEqual({ name: 'John' })
+				return 'ok'
+			},
+			{
+				body: Type.Object({
+					name: Type.String()
+				})
+			}
+		)
+		.handle(
+			new Request('http://localhost/post', {
+				method: 'POST',
+				headers: {
+					'content-type': 'application/json'
+				},
+				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()
+
+		.post(
+			'/post',
+			({ body, redirect, error }) => {
+				// console.log({ body })
+				expect(body).toEqual({ name: 'John' })
+			},
+			{
+				body: Type.Object({
+					name: Type.String(),
+					requiredField: Type.String()
+				})
+			}
+		)
+		.handle(
+			new Request('http://localhost/post', {
+				method: 'POST',
+				headers: {
+					'content-type': 'application/json'
+				},
+				body: JSON.stringify({ name: 'John' })
+			})
+		)
+	expect(res.status).toBe(400)
+	expect(await res.text()).toMatchInlineSnapshot(
+		`"data must have required property 'requiredField'"`
+	)
+})
+
+test('run onRequest', async () => {
+	const res = await new Elysia()
+		.onRequest(({ request }) => {
+			expect(request.method).toBe('HEAD')
+			return new Response('ok', { status: 401 })
+		})
+		.onRequest(({ request }) => {
+			expect(request.method).toBe('HEAD')
+			return 'second one'
+		})
+		.head('/ids/:id', () => 'hi')
+		.handle(new Request('http://localhost/ids/zxxx', { method: 'HEAD' }))
+	expect(res.status).toBe(401)
+	expect(await res.text()).toBe('ok')
+})
+
+test('run onRequest', async () => {
+	const res = await new Elysia()
+		.onRequest(({ request }) => {
+			expect(request.method).toBe('HEAD')
+			return new Response('ok', { status: 401 })
+		})
+		.onRequest(({ request }) => {
+			expect(request.method).toBe('HEAD')
+			return 'second one'
+		})
+		.head('/ids/:id', () => 'hi')
+		.handle(new Request('http://localhost/ids/zxxx', { method: 'HEAD' }))
+	expect(res.status).toBe(401)
+	expect(await res.text()).toBe('ok')
+})
+
+test('basPath works', async () => {
+	const res = await new Elysia({ 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'))
+})
+
+test('use with 2 basPath works', async () => {
+	let oneOnReq = false
+	let twoOnReq = false
+	const app = await new Elysia()
+		.use(
+			new Elysia({ basePath: '/one' })
+				.onRequest(({ request }) => {
+					oneOnReq = true
+				})
+				.get('/ids/:id', ({ params }) => params.id)
+		)
+		.use(
+			new Elysia({ basePath: '/two' })
+				.onRequest((c) => {
+					twoOnReq = true
+				})
+				.get('/ids/:id', ({ params }) => params.id)
+		)
+
+	{
+		const res = await app.handle(
+			new Request('http://localhost/one/ids/one')
+		)
+		expect(res.status).toBe(200)
+
+		expect(await res.text()).toBe(JSON.stringify('one'))
+	}
+	{
+		const res = await app.handle(
+			new Request('http://localhost/two/ids/two')
+		)
+		expect(res.status).toBe(200)
+
+		expect(await res.text()).toBe(JSON.stringify('two'))
+	}
+	expect(oneOnReq).toBe(true)
+	expect(twoOnReq).toBe(true)
+})
+
+test('use with nested basPath works', async () => {
+	const app = await new Elysia({ basePath: '/zero' })
+		.use(
+			new Elysia({ basePath: '/one' }).get(
+				'/ids/:id',
+				({ params }) => params.id
+			)
+		)
+		.use(
+			new Elysia({ basePath: '/two' }).use(
+				new Elysia({ basePath: '/nested' }).get(
+					'/ids/:id',
+					({ params }) => params.id
+				)
+			)
+		)
+	{
+		const res = await app.handle(
+			new Request('http://localhost/zero/one/ids/one')
+		)
+		expect(res.status).toBe(200)
+		expect(await res.text()).toBe(JSON.stringify('one'))
+	}
+
+	{
+		const res = await app.handle(
+			new Request('http://localhost/zero/two/nested/ids/nested')
+		)
+		expect(res.status).toBe(200)
+		expect(await res.text()).toBe(JSON.stringify('nested'))
+	}
+})
+
+test('errors inside basPath works', async () => {
+	let onErrorTriggered = [] as string[]
+	let onReqTriggered = [] as string[]
+	const app = await new Elysia({ basePath: '/zero' })
+		.onError(({ error }) => {
+			onErrorTriggered.push('root')
+			// return new Response('root', { status: 500 })
+		})
+		.onRequest(({ request }) => {
+			onReqTriggered.push('root')
+			// return new Response('root', { status: 500 })
+		})
+
+		.use(
+			new Elysia({ basePath: '/two' })
+				.onError(({ error }) => {
+					onErrorTriggered.push('two')
+					// return new Response('two', { status: 500 })
+				})
+				.onRequest(({ request }) => {
+					onReqTriggered.push('two')
+					// return new Response('two', { status: 500 })
+				})
+				.use(
+					new Elysia({ basePath: '/nested' })
+						.onError(({ error }) => {
+							onErrorTriggered.push('nested')
+							// return new Response('nested', { status: 500 })
+						})
+						.onRequest(({ request }) => {
+							onReqTriggered.push('nested')
+							// return new Response('nested', { status: 500 })
+						})
+						.get('/ids/:id', ({ params }) => {
+							throw new Error('error message')
+						})
+				)
+		)
+
+	{
+		const res = await app.handle(
+			new Request('http://localhost/zero/two/nested/ids/nested')
+		)
+		expect(onErrorTriggered).toEqual(['nested', 'two', 'root'])
+		expect(onReqTriggered).toEqual(['nested', 'two', 'root'])
+		expect(res.status).toBe(500)
+		expect(await res.text()).toBe('error message')
+		// expect(await res.text()).toBe(JSON.stringify('nested'))
+	}
+})