patch 1.4.19

CHANGELOG.md

@@ -1,3 +1,15 @@
+# 1.4.19 - 9 Dec 2025
+Improvement
+- [#1588](https://github.com/elysiajs/elysia/pull/1588), [#1587](https://github.com/elysiajs/elysia/pull/1587) add seen weakset during mergeDeep
+- [#1607](https://github.com/elysiajs/elysia/issues/1607), [#1606](https://github.com/elysiajs/elysia/issues/1606), [#1139](https://github.com/elysiajs/elysia/issues/1138) data coercion on nested form data
+- [#1609](https://github.com/elysiajs/elysia/issues/1609) calling afterResponse with aot: false
+
+Bug fix:
+- [#1591](https://github.com/elysiajs/elysia/pull/1591), [#1590](https://github.com/elysiajs/elysia/pull/1591) merge set.headers without duplicating Response
+- add set immediate fallback
+- [#1596](https://github.com/elysiajs/elysia/issues/1596) handle context pass to function with sub context
+- [#1597](https://github.com/elysiajs/elysia/issues/1597) safeParse, parse to static type
+
 # 1.4.18 - 4 Dec 2025
 Security:
 - use `JSON.stringify` over custom escape implementation

example/a.ts

@@ -1,22 +1,13 @@
-import { Elysia, t } from '../src'
-import * as z from 'zod'
-import { post, req } from '../test/utils'
+import { t, getSchemaValidator } from '../src'
+import { sucrose } from '../src/sucrose'
 
-const app = new Elysia({
-	cookie: {
-		domain: "\\` + console.log(c.q='pwn2') }) //"
+const v = sucrose({
+	handler: (context) => {
+		console.log('path >>> ', context.path)
+		console.log(context)
+
+		return { id: 'test' }
 	}
 })
-	.get('/', ({ cookie: { session } }) => 'awd')
-
-console.log(app.routes[0].compile().toString())
-
-const root = await app.handle(
-	new Request('http://localhost/', {
-		headers: {
-			Cookie: 'session=1234'
-		}
-	})
-)
 
-console.log(await root.text())
+console.log(v)

src/compose.ts

@@ -19,6 +19,7 @@ import {
 import {
 	ELYSIA_REQUEST_ID,
 	getLoosePath,
+	hasSetImmediate,
 	lifeCycleToFn,
 	randomId,
 	redirect,
@@ -444,6 +445,10 @@ const coerceTransformDecodeError = (
 	`throw error.error ?? new ValidationError('${type}',validator.${type},${value},${allowUnsafeValidationDetails})}` +
 	`}`
 
+const setImmediateFn = hasSetImmediate
+	? 'setImmediate'
+	: 'Promise.resolve().then'
+
 export const composeHandler = ({
 	app,
 	path,
@@ -804,7 +809,7 @@ export const composeHandler = ({
 		let afterResponse = ''
 
 		afterResponse +=
-			`\nsetImmediate(async()=>{` +
+			`\n${setImmediateFn}(async()=>{` +
 			`if(c.responseValue){` +
 			`if(c.responseValue instanceof ElysiaCustomStatusResponse) c.set.status=c.responseValue.code\n` +
 			(hasStream
@@ -1474,21 +1479,26 @@ export const composeHandler = ({
 						if (candidate) {
 							const isFirst = fileUnions.length === 0
 							// Handle case where schema is wrapped in a Union (e.g., ObjectString coercion)
-							let properties = candidate.schema?.properties ?? type.properties
+							let properties =
+								candidate.schema?.properties ?? type.properties
 
 							// If no properties but schema is a Union, try to find the Object in anyOf
 							if (!properties && candidate.schema?.anyOf) {
-								const objectSchema = candidate.schema.anyOf.find((s: any) => s.type === 'object')
+								const objectSchema =
+									candidate.schema.anyOf.find(
+										(s: any) => s.type === 'object'
+									)
 								if (objectSchema) {
 									properties = objectSchema.properties
 								}
 							}
 
 							if (!properties) continue
 
-							const iterator = Object.entries(
-								properties
-							) as [string, TSchema][]
+							const iterator = Object.entries(properties) as [
+								string,
+								TSchema
+							][]
 
 							let validator = isFirst ? '\n' : ' else '
 							validator += `if(fileUnions[${fileUnions.length}].Check(c.body)){`
@@ -1773,7 +1783,7 @@ export const composeHandler = ({
 					(hasTrace || hooks.afterResponse?.length
 						? `afterHandlerStreamListener=stream[2]\n`
 						: '') +
-					`setImmediate(async ()=>{` +
+					`${setImmediateFn}(async ()=>{` +
 					`if(listener)for await(const v of listener){}\n`
 				handleReporter.resolve()
 				fnLiteral += `})` + (maybeAsync ? '' : `})()`) + `}else{`
@@ -2337,7 +2347,7 @@ export const composeGeneralHandler = (app: AnyElysia) => {
 
 		const prefix = app.event.afterResponse.some(isAsync) ? 'async' : ''
 		afterResponse +=
-			`\nsetImmediate(${prefix}()=>{` +
+			`\n${setImmediateFn}(${prefix}()=>{` +
 			`if(c.responseValue instanceof ElysiaCustomStatusResponse) c.set.status=c.responseValue.code\n`
 
 		for (let i = 0; i < app.event.afterResponse.length; i++) {
@@ -2571,7 +2581,7 @@ export const composeErrorHandler = (app: AnyElysia) => {
 
 		let afterResponse = ''
 		const prefix = hooks.afterResponse?.some(isAsync) ? 'async' : ''
-		afterResponse += `\nsetImmediate(${prefix}()=>{`
+		afterResponse += `\n${setImmediateFn}(${prefix}()=>{`
 
 		const reporter = createReport({
 			context: 'context',

src/dynamic-handle.ts

@@ -13,7 +13,7 @@ import { parseQuery } from './parse-query'
 import type { ElysiaTypeCheck } from './schema'
 import type { TypeCheck } from './type-system'
 import type { Handler, LifeCycleStore, SchemaValidator } from './types'
-import { redirect, StatusMap, signCookie } from './utils'
+import { hasSetImmediate, redirect, StatusMap, signCookie } from './utils'
 
 // JIT Handler
 export type DynamicHandler = {
@@ -79,6 +79,8 @@ export const createDynamicHandler = (app: AnyElysia) => {
 			response: unknown
 		}
 
+		let hooks: DynamicHandler['hooks']
+
 		try {
 			if (app.event.request)
 				for (let i = 0; i < app.event.request.length; i++) {
@@ -109,7 +111,8 @@ export const createDynamicHandler = (app: AnyElysia) => {
 				throw new NotFoundError()
 			}
 
-			const { handle, hooks, validator, content, route } = handler.store
+			const { handle, validator, content, route } = handler.store
+			hooks = handler.store.hooks
 
 			let body: string | Record<string, any> | undefined
 			if (request.method !== 'GET' && request.method !== 'HEAD') {
@@ -661,11 +664,22 @@ export const createDynamicHandler = (app: AnyElysia) => {
 			// @ts-expect-error private
 			return app.handleError(context, reportedError)
 		} finally {
-			if (app.event.afterResponse)
-				setImmediate(async () => {
-					for (const afterResponse of app.event.afterResponse!)
-						await afterResponse.fn(context as any)
-				})
+			const afterResponses = hooks!
+				? hooks.afterResponse
+				: app.event.afterResponse
+
+			if (afterResponses) {
+				if (hasSetImmediate)
+					setImmediate(async () => {
+						for (const afterResponse of afterResponses)
+							await afterResponse.fn(context as any)
+					})
+				else
+					Promise.resolve().then(async () => {
+						for (const afterResponse of afterResponses)
+							await afterResponse.fn(context as any)
+					})
+			}
 		}
 	}
 }

src/index.ts

@@ -820,6 +820,7 @@ export default class Elysia<
 					route: path
 				})
 
+
 				const encoded = encodePath(loosePath)
 				if (loosePath !== encoded)
 					this.router.dynamic.add(method, loosePath, {

src/schema.ts

@@ -27,7 +27,8 @@ import type {
 	InputSchema,
 	MaybeArray,
 	StandaloneInputSchema,
-	StandardSchemaV1LikeValidate
+	StandardSchemaV1LikeValidate,
+UnwrapSchema
 } from './types'
 
 import type { StandardSchemaV1Like } from './types'
@@ -40,10 +41,10 @@ export interface ElysiaTypeCheck<T extends TSchema>
 	provider: 'typebox' | 'standard'
 	schema: T
 	config: Object
-	Clean?(v: unknown): T
-	parse(v: unknown): T
+	Clean?(v: unknown): UnwrapSchema<T>
+	parse(v: unknown): UnwrapSchema<T>
 	safeParse(v: unknown):
-		| { success: true; data: T; error: null }
+		| { success: true; data: UnwrapSchema<T>; error: null }
 		| {
 				success: false
 				data: null

src/sucrose.ts

@@ -551,8 +551,36 @@ export const isContextPassToFunction = (
 ) => {
 	// ! Function is passed to another function, assume as all is accessed
 	try {
-		const captureFunction = new RegExp(`\\w\\((.*?)?${context}`, 'gs')
-		captureFunction.test(body)
+		const captureFunction = new RegExp(
+			`\\w\\((?:.*?)?${context}(?:.*?)?\\)`,
+			'gs'
+		)
+		const exactParameter = new RegExp(`${context}(,|\\))`, 'gs')
+
+		const length = body.length
+		let fn
+
+		fn = captureFunction.exec(body) + ''
+		while (
+			captureFunction.lastIndex !== 0 &&
+			captureFunction.lastIndex < length + (fn ? fn.length : 0)
+		) {
+			if (fn && exactParameter.test(fn)) {
+				inference.query = true
+				inference.headers = true
+				inference.body = true
+				inference.cookie = true
+				inference.set = true
+				inference.server = true
+				inference.url = true
+				inference.route = true
+				inference.path = true
+
+				return true
+			}
+
+			fn = captureFunction.exec(body) + ''
+		}
 
 		/*
 		Since JavaScript engine already format the code (removing whitespace, newline, etc.),
@@ -700,7 +728,11 @@ export const sucrose = (
 				code.charCodeAt(0) === 123 &&
 				code.charCodeAt(body.length - 1) === 125
 			)
-				code = code.slice(1, -1)
+				code = code.slice(1, -1).trim()
+
+			console.log(
+				isContextPassToFunction(mainParameter, code, fnInference)
+			)
 
 			if (!isContextPassToFunction(mainParameter, code, fnInference))
 				inferBodyReference(code, aliases, fnInference)

src/utils.ts

@@ -399,6 +399,7 @@ export const lifeCycleToArray = (a: LifeCycleStore) => {
 
 const isBun = typeof Bun !== 'undefined'
 const hasBunHash = isBun && typeof Bun.hash === 'function'
+export const hasSetImmediate = typeof setImmediate === 'function'
 
 // https://stackoverflow.com/a/52171480
 export const checksum = (s: string) => {

test/core/dynamic.test.ts

@@ -694,47 +694,68 @@ describe('Dynamic Mode', () => {
 		})
 	})
 
-	it('handle query array reference in multiple reference format', async () => {
-		const IdsModel = new Elysia().model({
-			name: t.Object({
-				name: t.Array(t.String())
-			})
-		})
-
-		const app = new Elysia({ aot: false })
-			.use(IdsModel)
-			.get('/', ({ query }) => query, {
-				name: 'ids'
-			})
-
-		const data = await app
-			.handle(req('/?names=rapi&names=anis'))
-			.then((x) => x.json())
-
-		expect(data).toEqual({
-			names: ['rapi', 'anis']
-		})
-	})
-
-	it('handle query array reference in multiple reference format', async () => {
-		const IdsModel = new Elysia().model({
-			name: t.Object({
-				name: t.Array(t.String())
-			})
-		})
+	it('call local afterResponse on aot: false', async () => {
+		let called = false
 
 		const app = new Elysia({ aot: false })
-			.use(IdsModel)
-			.get('/', ({ query }) => query, {
-				name: 'ids'
-			})
-
-		const data = await app
-			.handle(req('/?names=rapi&names=anis'))
-			.then((x) => x.json())
-
-		expect(data).toEqual({
-			names: ['rapi', 'anis']
-		})
-	})
+			.guard(
+				{
+					afterResponse: () => {
+						called = true
+					}
+				},
+				(app) => app.get('/test', () => 'afterResponse')
+			)
+			.get('/', () => 'hi')
+
+		const value = await app.handle(req('/test')).then((x) => x.text())
+		await Bun.sleep(6.7)
+
+		expect(value).toBe('afterResponse')
+		expect(called).toBeTrue()
+	})
+
+	// it('handle query array reference in multiple reference format', async () => {
+	// 	const IdsModel = new Elysia().model({
+	// 		name: t.Object({
+	// 			name: t.Array(t.String())
+	// 		})
+	// 	})
+
+	// 	const app = new Elysia({ aot: false })
+	// 		.use(IdsModel)
+	// 		.get('/', ({ query }) => query, {
+	// 			query: 'name'
+	// 		})
+
+	// 	const data = await app
+	// 		.handle(req('/?names=rapi&names=anis'))
+	// 		.then((x) => x.json())
+
+	// 	expect(data).toEqual({
+	// 		names: ['rapi', 'anis']
+	// 	})
+	// })
+
+	// it('handle query array reference in multiple reference format', async () => {
+	// 	const IdsModel = new Elysia().model({
+	// 		name: t.Object({
+	// 			name: t.Array(t.String())
+	// 		})
+	// 	})
+
+	// 	const app = new Elysia({ aot: false })
+	// 		.use(IdsModel)
+	// 		.get('/', ({ query }) => query, {
+	// 			query: 'name'
+	// 		})
+
+	// 	const data = await app
+	// 		.handle(req('/?names=rapi&names=anis'))
+	// 		.then((x) => x.json())
+
+	// 	expect(data).toEqual({
+	// 		names: ['rapi', 'anis']
+	// 	})
+	// })
 })