Merge branch 'main' into feat/parse-dates-option

Author: SaltyAom

CHANGELOG.md

@@ -1,3 +1,11 @@
+# 1.4.7
+Bug fix:
+- [#247](https://github.com/elysiajs/eden/pull/247), [#246](https://github.com/elysiajs/eden/issues/246) handle network error
+- [#244](https://github.com/elysiajs/eden/issues/244) don't skip index path name
+- [#241](https://github.com/elysiajs/eden/issues/241) prevent freeze from thenable
+- [#236](https://github.com/elysiajs/eden/issues/236) reconcile default headers in type-level
+- [#232](https://github.com/elysiajs/eden/issues/232) accept query array
+
 # 1.4.6 - 23 Dec 2025
 Bug fix:
 - [#235](https://github.com/elysiajs/eden/pull/235) SSE stream parser with partial chunks

bun.lock

@@ -1,36 +1,26 @@
-import { Elysia, t } from 'elysia'
+import { Elysia, sse, t } from 'elysia'
 import { treaty } from '../src'
 
+const model = t.Object({
+    value: t.Number()
+})
+
 const app = new Elysia()
-    .post('/files', ({ body: { files } }) => files.map((file) => file.name), {
-        body: t.Object({
-            files: t.Files()
-        })
-    })
-    .post('/any/file', ({ body: { file } }) => file.name, {
-        body: t.Object({
-            file: t.File({ type: 'image/*' })
+    .get('/', ({ query }) => query, {
+        query: t.Object({
+            minDate: t.Date(),
+            maxDate: t.Date()
         })
     })
-    .post('/png/file', ({ body: { file } }) => file.name, {
-        body: t.Object({
-            file: t.File({ type: 'image/png' })
-        })
-    })
-
-const client = treaty(app)
-type client = typeof client
-
-const filePath1 = `test/public/aris-yuzu.jpg`
-const filePath2 = `test/public/midori.png`
-const filePath3 = `test/public/kyuukurarin.mp4`
+    .listen(3000)
 
-const bunFile1 = Bun.file(filePath1)
-const bunFile2 = Bun.file(filePath2)
-const bunFile3 = Bun.file(filePath3)
+const api = treaty(app)
 
-const { data: files } = await client.files.post({
-    files: bunFile1
+const { data, error } = await api.get({
+	query: {
+		minDate: new Date(),
+		maxDate: new Date()
+    }
 })
 
-console.log(files)
+console.log(data, error)

example/a.ts

@@ -1,6 +1,6 @@
 {
 	"name": "@elysiajs/eden",
-	"version": "1.4.6",
+	"version": "1.4.7",
 	"description": "Fully type-safe Elysia client",
 	"author": {
 		"name": "saltyAom",

package.json

@@ -3,6 +3,7 @@ import type { Elysia } from 'elysia'
 import { EdenFetchError } from '../errors'
 import type { EdenFetch } from './types'
 import { parseStringifiedValue } from '../utils/parsingUtils'
+import { ThrowHttpErrors } from '../types'
 
 export type { EdenFetch } from './types'
 
@@ -30,17 +31,32 @@ const parseResponse = async (response: Response) => {
 	return response.text().then(parseStringifiedValue)
 }
 
-const handleResponse = async (response: Response, retry: () => any) => {
+const shouldThrow = (
+	error: EdenFetchError<number, unknown>,
+	throwHttpErrors?: ThrowHttpErrors
+): boolean => {
+	if (typeof throwHttpErrors === 'function') return throwHttpErrors(error)
+	return throwHttpErrors === true
+}
+
+const handleResponse = async (
+	response: Response,
+	retry: () => any,
+	throwHttpErrors?: ThrowHttpErrors
+) => {
 	const data = await parseResponse(response)
 
-	if (response.status > 300)
+	if (response.status >= 300 || response.status < 200) {
+		const error = new EdenFetchError(response.status, data)
+		if (shouldThrow(error, throwHttpErrors)) throw error
 		return {
 			data: null,
 			status: response.status,
 			headers: response.headers,
 			retry,
-			error: new EdenFetchError(response.status, data)
+			error
 		}
+	}
 
 	return {
 		data,
@@ -56,13 +72,15 @@ export const edenFetch = <App extends Elysia<any, any, any, any, any, any, any>>
 		config?: EdenFetch.Config
 	): EdenFetch.Create<App> =>
 	// @ts-ignore
-	(endpoint: string, { query, params, body, ...options } = {}) => {
+	(endpoint: string, { query, params, body, throwHttpErrors: requestThrowHttpErrors, ...options } = {}) => {
 		if (params)
 			Object.entries(params).forEach(([key, value]) => {
 				endpoint = endpoint.replace(`:${key}`, value as string)
 			})
 
 		const fetch = config?.fetcher || globalThis.fetch
+		// Per-request throwHttpErrors overrides config
+		const resolvedThrowHttpErrors = requestThrowHttpErrors ?? config?.throwHttpErrors
 
         const nonNullishQuery = query
             ? Object.fromEntries(
@@ -100,14 +118,19 @@ export const edenFetch = <App extends Elysia<any, any, any, any, any, any, any>>
 
 	const execute = () =>
 		fetch(requestUrl, init)
-			.then((response) => handleResponse(response, execute))
-			.catch((err) => ({
-				data: null,
-				error: new EdenFetchError(503, err),
-				status: 503,
-				headers: undefined,
-				retry: execute
-			}))
+			.then((response) => handleResponse(response, execute, resolvedThrowHttpErrors))
+			.catch((err) => {
+				if (err instanceof EdenFetchError) throw err
+				const error = new EdenFetchError(503, err)
+				if (shouldThrow(error, resolvedThrowHttpErrors)) throw error
+				return {
+					data: null,
+					error,
+					status: 503,
+					headers: undefined,
+					retry: execute
+				}
+			})
 
 	return execute()
 }

src/fetch/index.ts

@@ -5,7 +5,8 @@ import type {
 	IsUnknown,
 	IsNever,
 	Prettify,
-	TreatyToPath
+	TreatyToPath,
+	ThrowHttpErrors
 } from '../types'
 
 export namespace EdenFetch {
@@ -21,6 +22,7 @@ export namespace EdenFetch {
 
 	export interface Config extends RequestInit {
 		fetcher?: typeof globalThis.fetch
+		throwHttpErrors?: ThrowHttpErrors
 	}
 
 	export type Fn<Schema extends Record<string, any>> = <
@@ -60,7 +62,9 @@ export namespace EdenFetch {
 					}) &
 			(IsUnknown<Route['body']> extends false
 				? { body: Route['body'] }
-				: { body?: unknown })
+				: { body?: unknown }) & {
+          throwHttpErrors?: ThrowHttpErrors
+        }
 	) => Promise<
 		Prettify<
 			| {

src/fetch/types.ts

@@ -10,6 +10,7 @@ import {
     parseStringifiedDate,
     parseStringifiedValue
 } from '../utils/parsingUtils'
+import { ThrowHttpErrors } from '../types'
 
 const method = [
     'get',
@@ -23,6 +24,14 @@ const method = [
     'subscribe'
 ] as const
 
+const shouldThrow = (
+    error: EdenFetchError<number, unknown>,
+    throwHttpErrors?: ThrowHttpErrors
+): boolean => {
+    if (typeof throwHttpErrors === 'function') return throwHttpErrors(error)
+    return throwHttpErrors === true
+}
+
 const locals = ['localhost', '127.0.0.1', '0.0.0.0']
 
 const isServer = typeof FileList === 'undefined'
@@ -213,12 +222,13 @@ const createProxy = (
 ): any =>
     new Proxy(() => {}, {
         get(_, param: string): any {
-            return createProxy(
-                domain,
-                config,
-                param === 'index' ? paths : [...paths, param],
-                elysia
+            if (
+                paths.length === 0 &&
+                (param === 'then' || param === 'catch' || param === 'finally')
             )
+                return undefined
+
+            return createProxy(domain, config, [...paths, param], elysia)
         },
         apply(_, __, [body, options]) {
             if (
@@ -251,29 +261,30 @@ const createProxy = (
 
                 let q = ''
                 if (query) {
-                    const append = (key: string, value: string) => {
-                        q +=
+                    const append = (key: string, value: unknown) => {
+                        // Explicitly exclude null and undefined values from url encoding
+                        // to prevent parsing string "null" / string "undefined"
+						if (value === undefined || value === null) return
+
+						if (value instanceof Date) value = value.toISOString()
+
+						q +=
                             (q ? '&' : '?') +
                             `${encodeURIComponent(key)}=${encodeURIComponent(
-                                value
+                                typeof value === 'object'
+                                    ? JSON.stringify(value)
+                                    : value + ''
                             )}`
                     }
 
                     for (const [key, value] of Object.entries(query)) {
                         if (Array.isArray(value)) {
                             for (const v of value) append(key, v)
-                            continue
-                        }
 
-                        // Explicitly exclude null and undefined values from url encoding
-                        // to prevent parsing string "null" / string "undefined"
-                        if (value === undefined || value === null) continue
-
-                        if (typeof value === 'object') {
-                            append(key, JSON.stringify(value))
                             continue
                         }
-                        append(key, `${value}`)
+
+                        append(key, value)
                     }
                 }
 
@@ -322,6 +333,14 @@ const createProxy = (
                             ? body.fetch
                             : options?.fetch
 
+                    // Per-request throwHttpErrors overrides config
+                    const requestThrowHttpErrors =
+                        isGetOrHead && typeof body === 'object'
+                            ? body.throwHttpErrors
+                            : options?.throwHttpErrors
+                    const resolvedThrowHttpErrors =
+                        requestThrowHttpErrors ?? config.throwHttpErrors
+
                     fetchInit = {
                         ...fetchInit,
                         ...fetchOpts
@@ -498,7 +517,8 @@ const createProxy = (
                         }
                     }
 
-                    if (options?.headers?.['content-type'])
+					if (options?.headers?.['content-type'])
+						// @ts-ignore
                         fetchInit.headers['content-type'] =
                             options?.headers['content-type']
 
@@ -511,9 +531,12 @@ const createProxy = (
                             new Request(url, fetchInit)
                         ) ?? fetcher!(url, fetchInit))
                     } catch (err) {
+                        const error = new EdenFetchError(503, err)
+                        if (shouldThrow(error, resolvedThrowHttpErrors))
+                            throw error
                         return {
                             data: null,
-                            error: new EdenFetchError(503, err),
+                            error,
                             response: undefined,
                             status: 503,
                             headers: undefined
@@ -574,7 +597,8 @@ const createProxy = (
 
                                 return v
                             })
-                            break
+							break
+
                         case 'application/octet-stream':
                             data = await response.arrayBuffer()
                             break
@@ -600,6 +624,8 @@ const createProxy = (
 
                     if (response.status >= 300 || response.status < 200) {
                         error = new EdenFetchError(response.status, data)
+                        if (shouldThrow(error, resolvedThrowHttpErrors))
+                            throw error
                         data = null
                     }
 
@@ -626,11 +652,12 @@ const createProxy = (
     }) as any
 
 export const treaty = <
-    const App extends Elysia<any, any, any, any, any, any, any>
+    const App extends Elysia<any, any, any, any, any, any, any>,
+    const Head extends {} = {}
 >(
     domain: string | App,
-    config: Treaty.Config = {}
-): Treaty.Create<App> => {
+    config: Treaty.Config<Head> = {}
+): Treaty.Create<App, Head> => {
     if (typeof domain === 'string') {
         if (!config.keepDomain) {
             if (!domain.includes('://'))