spiceflow 1.0.2 → 1.0.4

package/src/elysia-fork/context.ts

@@ -1,7 +1,7 @@
 import type {
 	StatusMap,
 	InvertedStatusMap,
-	redirect as Redirect
+	redirect as Redirect,
 } from './utils.js'
 
 import type {
@@ -9,9 +9,10 @@ import type {
 	Prettify,
 	ResolvePath,
 	SingletonBase,
-	HTTPHeaders
+	HTTPHeaders,
 } from './types.js'
-import { error } from './error.js'
+
+import { TypedRequest } from '../spiceflow.js'
 
 type InvertedStatusMapKey = keyof InvertedStatusMap
 
@@ -27,10 +28,10 @@ export type ErrorContext<
 		derive: {}
 		resolve: {}
 	},
-	Path extends string = ''
+	Path extends string = '',
 > = Prettify<
 	{
-		body: Route['body']
+		// body: Route['body']
 		query: undefined extends Route['query']
 			? Record<string, string | undefined>
 			: Route['query']
@@ -58,10 +59,10 @@ export type ErrorContext<
 		 *
 		 * @example '/id/:id'
 		 */
-		route: string
-		request: Request
+		// route: string
+		request: TypedRequest<Route['body']>
 		store: Singleton['store']
-		response: Route['response']
+		// response: Route['response']
 	} & Singleton['decorator'] &
 		Singleton['derive'] &
 		Singleton['resolve']
@@ -75,11 +76,13 @@ export type Context<
 		derive: {}
 		resolve: {}
 	},
-	Path extends string = ''
+	Path extends string = '',
 > = Prettify<
 	{
-		body: Route['body']
-
+		// body: Route['body']
+		query: undefined extends Route['query']
+			? Record<string, string | undefined>
+			: Route['query']
 		params: undefined extends Route['params']
 			? Path extends `${string}/${':' | '*'}${string}`
 				? ResolvePath<Path>
@@ -127,44 +130,11 @@ export type Context<
 		 *
 		 * @example '/id/:id'
 		 */
-		route: string
-		request: Request
+		// route: string
+		request: TypedRequest<Route['body']>
 		store: Singleton['store']
 		response?: Route['response']
-	} & ({} extends Route['response']
-		? {
-				error: typeof error
-		  }
-		: {
-				error: <
-					const Code extends
-						| keyof Route['response']
-						| InvertedStatusMap[Extract<
-								InvertedStatusMapKey,
-								keyof Route['response']
-						  >],
-					const T extends Code extends keyof Route['response']
-						? Route['response'][Code]
-						: Code extends keyof StatusMap
-						? // @ts-ignore StatusMap[Code] always valid because Code generic check
-						  Route['response'][StatusMap[Code]]
-						: never
-				>(
-					code: Code,
-					response: T
-				) => {
-					// [ELYSIA_RESPONSE]: Code extends keyof StatusMap
-					// 	? StatusMap[Code]
-					// 	: Code
-					response: T
-					_type: {
-						[ERROR_CODE in Code extends keyof StatusMap
-							? StatusMap[Code]
-							: Code]: T
-					}
-				}
-		  }) &
-		Singleton['decorator'] &
+	} & Singleton['decorator'] &
 		Singleton['derive'] &
 		Singleton['resolve']
 >
@@ -176,7 +146,7 @@ export type PreContext<
 		store: {}
 		derive: {}
 		resolve: {}
-	}
+	},
 > = Prettify<
 	{
 		store: Singleton['store']
@@ -191,6 +161,6 @@ export type PreContext<
 		// 	redirect?: string
 		// }
 
-		error: typeof error
+		// error: typeof error
 	} & Singleton['decorator']
 >

package/src/elysia-fork/error.ts

@@ -1,8 +1,4 @@
-import type { TSchema } from '@sinclair/typebox'
-import { Value } from '@sinclair/typebox/value'
-import type { TypeCheck, ValueError } from '@sinclair/typebox/compiler'
 
-import { StatusMap, InvertedStatusMap } from './utils'
 
 // ? Cloudflare worker support
 const env =
@@ -22,272 +18,23 @@ export type ELYSIA_RESPONSE = typeof ELYSIA_RESPONSE
 
 export const isProduction = (env?.NODE_ENV ?? env?.ENV) === 'production'
 
-export type SpiceflowErrors =
-	| InternalServerError
-	| NotFoundError
-	| ParseError
-	| ValidationError
-	| InvalidCookieSignature
-
-export const error = <
-	const Code extends number | keyof StatusMap,
-	const T = Code extends keyof InvertedStatusMap
-		? InvertedStatusMap[Code]
-		: Code,
-	const Status extends Code extends keyof StatusMap
-		? StatusMap[Code]
-		: Code = Code extends keyof StatusMap ? StatusMap[Code] : Code
->(
-	code: Code,
-	response?: T
-): {
-	[ELYSIA_RESPONSE]: Status
-	response: T
-	_type: {
-		[ERROR_CODE in Status]: T
-	}
-	error: Error
-} => {
-	const res =
-		response ??
-		(code in InvertedStatusMap
-			? // @ts-expect-error Always correct
-			  InvertedStatusMap[code]
-			: code)
-
-	return {
-		// @ts-expect-error trust me bro
-		[ELYSIA_RESPONSE]: StatusMap[code] ?? code,
-		response: res,
-		_type: undefined as any,
-		error: new Error(res)
-	} as const
-}
-
-export class InternalServerError extends Error {
-	code = 'INTERNAL_SERVER_ERROR'
-	status = 500
-
-	constructor(message?: string) {
-		super(message ?? 'INTERNAL_SERVER_ERROR')
-	}
+export class ValidationError extends Error {
+	code = 'VALIDATION'
+	status = 422
 }
 
 export class NotFoundError extends Error {
 	code = 'NOT_FOUND'
 	status = 404
-
-	constructor(message?: string) {
-		super(message ?? 'NOT_FOUND')
-	}
 }
 
 export class ParseError extends Error {
 	code = 'PARSE'
 	status = 400
-
-	constructor() {
-		super('Failed to parse body')
-	}
-}
-
-export class InvalidCookieSignature extends Error {
-	code = 'INVALID_COOKIE_SIGNATURE'
-	status = 400
-
-	constructor(public key: string, message?: string) {
-		super(message ?? `"${key}" has invalid cookie signature`)
-	}
 }
 
-export const mapValueError = (error: ValueError) => {
-	const { message, path, value, type } = error
-
-	const property = path.slice(1).replaceAll('/', '.')
-	const isRoot = path === ''
-
-	switch (type) {
-		case 42:
-			return {
-				...error,
-				summary: isRoot
-					? `Value should not be provided`
-					: `Property '${property}' should not be provided`
-			}
-
-		case 45:
-			return {
-				...error,
-				summary: isRoot
-					? `Value is missing`
-					: `Property '${property}' is missing`
-			}
-
-		case 50:
-			// Expected string to match 'email' format
-			const quoteIndex = message.indexOf("'")!
-			const format = message.slice(
-				quoteIndex + 1,
-				message.indexOf("'", quoteIndex + 1)
-			)
-
-			return {
-				...error,
-				summary: isRoot
-					? `Value should be an email`
-					: `Property '${property}' should be ${format}`
-			}
-
-		case 54:
-			return {
-				...error,
-				summary: `${message.slice(
-					0,
-					9
-				)} property '${property}' to be ${message.slice(
-					8
-				)} but found: ${value}`
-			}
-
-		case 62:
-			const union = error.schema.anyOf
-				.map((x: Record<string, unknown>) => `'${x?.format ?? x.type}'`)
-				.join(', ')
-
-			return {
-				...error,
-				summary: isRoot
-					? `Value should be one of ${union}`
-					: `Property '${property}' should be one of: ${union}`
-			}
-
-		default:
-			return { summary: message, ...error }
-	}
+export class InternalServerError extends Error {
+	code = 'INTERNAL_SERVER_ERROR'
+	status = 500
 }
 
-export class ValidationError extends Error {
-	code = 'VALIDATION'
-	status = 422
-
-	constructor(
-		public type: string,
-		public validator: TSchema | TypeCheck<any>,
-		public value: unknown
-	) {
-		if (value && typeof value === 'object' && ELYSIA_RESPONSE in value)
-			// @ts-expect-error
-			value = value.response
-
-		const error = isProduction
-			? undefined
-			: 'Errors' in validator
-			? validator.Errors(value).First()
-			: Value.Errors(validator, value).First()
-
-		const customError =
-			error?.schema.error !== undefined
-				? typeof error.schema.error === 'function'
-					? error.schema.error({
-							type,
-							validator,
-							value,
-							get errors() {
-								return [...validator.Errors(value)].map(
-									mapValueError
-								)
-							}
-					  })
-					: error.schema.error
-				: undefined
-
-		const accessor = error?.path || 'root'
-		let message = ''
-
-		if (customError !== undefined) {
-			message =
-				typeof customError === 'object'
-					? JSON.stringify(customError)
-					: customError + ''
-		} else if (isProduction) {
-			message = JSON.stringify({
-				type: 'validation',
-				on: type,
-				summary: mapValueError(error).summary,
-				message: error?.message,
-				found: value
-			})
-		} else {
-			// @ts-ignore private field
-			const schema = validator?.schema ?? validator
-			const errors =
-				'Errors' in validator
-					? [...validator.Errors(value)].map(mapValueError)
-					: [...Value.Errors(validator, value)].map(mapValueError)
-
-			let expected
-
-			try {
-				expected = Value.Create(schema)
-			} catch (error) {
-				expected = {
-					type: 'Could not create expected value',
-					// @ts-expect-error
-					message: error?.message,
-					error
-				}
-			}
-
-			message = JSON.stringify(
-				{
-					type: 'validation',
-					on: type,
-					summary: errors[0]?.summary,
-					property: accessor,
-					message: error?.message,
-					expected,
-					found: value,
-					errors
-				},
-				null,
-				2
-			)
-		}
-
-		super(message)
-
-		Object.setPrototypeOf(this, ValidationError.prototype)
-	}
-
-	get all() {
-		return 'Errors' in this.validator
-			? [...this.validator.Errors(this.value)].map(mapValueError)
-			: // @ts-ignore
-			  [...Value.Errors(this.validator, this.value)].map(mapValueError)
-	}
-
-	static simplifyModel(validator: TSchema | TypeCheck<any>) {
-		// @ts-ignore
-		const model = 'schema' in validator ? validator.schema : validator
-
-		try {
-			return Value.Create(model)
-		} catch {
-			return model
-		}
-	}
-
-	get model() {
-		return ValidationError.simplifyModel(this.validator)
-	}
-
-	toResponse(headers?: Record<string, any>) {
-		return new Response(this.message, {
-			status: 400,
-			headers: {
-				...headers,
-				'content-type': 'application/json'
-			}
-		})
-	}
-}

package/src/elysia-fork/types.ts

@@ -8,6 +8,7 @@ import type {
 	Static,
 	StaticDecode,
 	TAnySchema,
+	TObject,
 	TSchema,
 } from '@sinclair/typebox'
 import type { TypeCheck, ValueError } from '@sinclair/typebox/compiler'
@@ -20,12 +21,11 @@ import type { Context, ErrorContext, PreContext } from './context'
 import {
 	ELYSIA_RESPONSE,
 	InternalServerError,
-	InvalidCookieSignature,
 	NotFoundError,
 	ParseError,
 	ValidationError,
 } from './error'
-import { ZodTypeAny } from 'zod'
+import { ZodTypeAny, ZodObject } from 'zod'
 
 export type MaybeArray<T> = T | T[]
 export type MaybePromise<T> = T | Promise<T>
@@ -174,10 +174,10 @@ export interface MetadataBase {
 
 export interface RouteSchema {
 	body?: unknown
-	headers?: unknown
+	// headers?: unknown
 	query?: unknown
 	params?: unknown
-	cookie?: unknown
+	// cookie?: unknown
 	response?: unknown
 }
 
@@ -187,6 +187,8 @@ type OptionalField = {
 
 export type TypeSchema = TSchema | ZodTypeAny
 
+export type TypeObject = TObject | ZodObject<any, any, any>
+
 export type UnwrapSchema<
 	Schema extends TypeSchema | string | undefined,
 	Definitions extends Record<string, unknown> = {},
@@ -210,8 +212,8 @@ export interface UnwrapRoute<
 > {
 	body: UnwrapSchema<Schema['body'], Definitions>
 	// headers: UnwrapSchema<Schema['headers'], Definitions>
-	// query: UnwrapSchema<Schema['query'], Definitions>
-	// params: UnwrapSchema<Schema['params'], Definitions>
+	query: UnwrapSchema<Schema['query'], Definitions>
+	params: UnwrapSchema<Schema['params'], Definitions>
 	// cookie: UnwrapSchema<Schema['cookie'], Definitions>
 	response: Schema['response'] extends TypeSchema | string
 		? {
@@ -320,8 +322,8 @@ export type HTTPMethod =
 export interface InputSchema<Name extends string = string> {
 	body?: TypeSchema | Name
 	// headers?: TObject | TNull | TUndefined | Name
-	// query?: TObject | TNull | TUndefined | Name
-	// params?: TObject | TNull | TUndefined | Name
+	query?: TypeObject | Name
+	params?: TypeObject | Name
 	// cookie?: TObject | TNull | TUndefined | Name
 	response?:
 		| TypeSchema
@@ -335,10 +337,10 @@ export interface MergeSchema<
 	in out B extends RouteSchema,
 > {
 	body: undefined extends A['body'] ? B['body'] : A['body']
-	headers: undefined extends A['headers'] ? B['headers'] : A['headers']
+	// headers: undefined extends A['headers'] ? B['headers'] : A['headers']
 	query: undefined extends A['query'] ? B['query'] : A['query']
 	params: undefined extends A['params'] ? B['params'] : A['params']
-	cookie: undefined extends A['cookie'] ? B['cookie'] : A['cookie']
+	// cookie: undefined extends A['cookie'] ? B['cookie'] : A['cookie']
 	response: {} extends A['response']
 		? {} extends B['response']
 			? {}
@@ -686,22 +688,22 @@ export type ErrorHandler<
 								Volatile['resolve']
 						>
 			  >
-			| Prettify<
-					{
-						request: Request
-						code: 'INVALID_COOKIE_SIGNATURE'
-						error: Readonly<InvalidCookieSignature>
-					} & NeverKey<
-						Singleton['derive'] &
-							Ephemeral['derive'] &
-							Volatile['derive']
-					> &
-						NeverKey<
-							Singleton['derive'] &
-								Ephemeral['resolve'] &
-								Volatile['resolve']
-						>
-			  >
+			// | Prettify<
+			// 		{
+			// 			request: Request
+			// 			code: 'INVALID_COOKIE_SIGNATURE'
+			// 			error: Readonly<InvalidCookieSignature>
+			// 		} & NeverKey<
+			// 			Singleton['derive'] &
+			// 				Ephemeral['derive'] &
+			// 				Volatile['derive']
+			// 		> &
+			// 			NeverKey<
+			// 				Singleton['derive'] &
+			// 					Ephemeral['resolve'] &
+			// 					Volatile['resolve']
+			// 			>
+			//   >
 			| Prettify<
 					{
 						[K in keyof T]: {

package/src/spiceflow.test.ts

@@ -1,6 +1,7 @@
 import { test, describe, expect } from 'vitest'
 import { Type } from '@sinclair/typebox'
 import { bfs, Spiceflow } from './spiceflow'
+import { z } from 'zod'
 
 test('works', async () => {
 	const res = await new Spiceflow()
@@ -24,6 +25,87 @@ test('GET dynamic route', async () => {
 	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 () => {
 	const res = await new Spiceflow()
 		.get('/ids/:id', () => 'hi')
@@ -48,9 +130,9 @@ 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(
@@ -71,8 +153,9 @@ 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'
 			},
@@ -100,8 +183,9 @@ 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' })
 			},
 			{
@@ -120,7 +204,7 @@ test('validate body works, request fails', async () => {
 				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'"`,
 	)