🔧 fix: custom t.Transform, unwrap macro with hook function

Author: SaltyAom

CHANGELOG.md

@@ -32,6 +32,8 @@ Improvement:
 - refactor `parseQuery` and `parseQueryFromURL`
 - add `config` options to `mount`
 - recompile automatically after async modules is mounted
+- support macro on when hook has function
+- support resolve macro on ws
 
 Bug fix:
 - `Response` returned from `onError` is using octet stream
@@ -47,9 +49,8 @@ Change:
 - `Elysia.mount` now set `detail.hide = true` by default
 
 Breaking Change:
-- Minimum Node version is now `node22` LTS
 - remove `as('plugin')` in favor of `as('scoped')`
-- remove root `index`
+- remove root `index` for Eden Treaty
 - remove `websocket` from `ElysiaAdapter`
 - remove `inference.request`
 

example/a.ts

@@ -1,16 +1,18 @@
-import Elysia, { t } from '../src'
-
-function addTwo(num: number) {
-	return num + 2
-}
+import { Elysia, t } from '../src'
 
 const app = new Elysia()
-	.get('', async ({ query: { foo } }) => addTwo(foo), {
-		query: t.Object({
-			foo: t
-				.Transform(t.String())
-				.Decode((x) => 12)
-				.Encode((x) => x.toString())
-		})
+	.macro({
+		a: {
+			resolve: () => ({
+				a: 'a'
+			})
+		}
+	})
+	.get('/a', ({ a }) => {}, {
+		a: true,
+		beforeHandle: ({ query }) => {}
+	})
+	.ws('/', {
+		a: true,
+		message({ data: { a } }) {}
 	})
-	.listen(1234)

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "elysia",
 	"description": "Ergonomic Framework for Human",
-	"version": "1.3.0-exp.76",
+	"version": "1.3.0-exp.77",
 	"author": {
 		"name": "saltyAom",
 		"url": "https://github.com/SaltyAom",

src/index.ts

@@ -3837,7 +3837,7 @@ export default class Elysia<
 		}
 
 		if (options?.scoped)
-			return this.guard({}, (app) => app.use(plugin as any))
+			return this.guard({} as any, (app) => app.use(plugin as any))
 
 		if (Array.isArray(plugin)) {
 			// eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -5415,16 +5415,20 @@ export default class Elysia<
 				Volatile['schema'],
 				MergeSchema<Ephemeral['schema'], Metadata['schema']>
 			>
-		>
+		>,
+		const Macro extends Metadata['macro']
 	>(
 		path: Path,
 		options: WSLocalHook<
 			LocalSchema,
 			Schema,
 			Singleton & {
 				derive: Ephemeral['derive'] & Volatile['derive']
-				resolve: Ephemeral['resolve'] & Volatile['resolve']
-			}
+				resolve: Ephemeral['resolve'] &
+					Volatile['resolve'] &
+					MacroToContext<Metadata['macroFn'], Macro>
+			},
+			Macro
 		>
 	): Elysia<
 		BasePath,

src/type-system/index.ts

@@ -38,15 +38,23 @@ import {
 	FilesOptions,
 	NonEmptyArray,
 	TForm,
-	TUnionEnum
+	TUnionEnum,
+	ElysiaTransformDecodeBuilder
 } from './types'
 
 import { ELYSIA_FORM_DATA, form } from '../utils'
 import { ValidationError } from '../error'
 import { parseDateTimeEmptySpace } from './format'
 
-const t = Object.assign({}, Type) as Omit<JavaScriptTypeBuilder, 'String'> &
-	typeof ElysiaType
+const t = Object.assign({}, Type) as unknown as Omit<
+	JavaScriptTypeBuilder,
+	'String' | 'Transform'
+> &
+	typeof ElysiaType & {
+		Transform<Type extends TSchema>(
+			type: Type
+		): ElysiaTransformDecodeBuilder<Type>
+	}
 
 createType<TUnionEnum>(
 	'UnionEnum',

src/type-system/types.ts

@@ -3,8 +3,10 @@ import type {
 	NumberOptions,
 	ObjectOptions,
 	SchemaOptions,
+	StaticDecode,
 	TObject,
 	TProperties,
+	TransformKind,
 	TSchema,
 	TUnsafe
 } from '@sinclair/typebox'
@@ -148,3 +150,40 @@ declare module '@sinclair/typebox' {
 			  }) => string | boolean | number | Object | void)
 	}
 }
+
+export declare class ElysiaTransformDecodeBuilder<T extends TSchema> {
+	private readonly schema
+	constructor(schema: T)
+	Decode<U extends unknown, D extends TransformFunction<StaticDecode<T>, U>>(
+		decode: D
+	): ElysiaTransformEncodeBuilder<T, D>
+}
+export declare class ElysiaTransformEncodeBuilder<
+	T extends TSchema,
+	D extends TransformFunction
+> {
+	private readonly schema
+	private readonly decode
+	constructor(schema: T, decode: D)
+	private EncodeTransform
+	private EncodeSchema
+	Encode<E extends TransformFunction<ReturnType<D>, StaticDecode<T>>>(
+		encode: E
+	): TTransform<T, ReturnType<D>>
+}
+export type TransformFunction<T = any, U = any> = (value: T) => U
+export interface TransformOptions<
+	I extends TSchema = TSchema,
+	O extends unknown = unknown
+> {
+	Decode: TransformFunction<StaticDecode<I>, O>
+	Encode: TransformFunction<O, StaticDecode<I>>
+}
+export interface TTransform<
+	I extends TSchema = TSchema,
+	O extends unknown = unknown
+> extends TSchema {
+	static: O
+	[TransformKind]: TransformOptions<I, O>
+	[key: string]: any
+}

src/types.ts

@@ -5,9 +5,7 @@ import type { Serve } from './universal/server'
 
 import {
 	TSchema,
-	TObject,
 	TAnySchema,
-	StaticDecode,
 	OptionalKind,
 	TModule,
 	TImport,
@@ -404,35 +402,31 @@ export type UnwrapSchema<
 	: Schema extends TSchema
 		? Schema extends OptionalField
 			? Partial<
-					StaticDecode<
-						TImport<
-							Definitions & {
-								readonly __elysia: Schema
-							},
-							'__elysia'
-						>
-					>
-				>
-			: StaticDecode<
 					TImport<
 						Definitions & {
 							readonly __elysia: Schema
 						},
 						'__elysia'
-					>
+					>['static']
 				>
+			: TImport<
+					Definitions & {
+						readonly __elysia: Schema
+					},
+					'__elysia'
+				>['static']
 		: Schema extends `${infer Key}[]`
 			? Definitions extends Record<
 					Key,
 					infer NamedSchema extends TAnySchema
 				>
-				? StaticDecode<NamedSchema>[]
-				: StaticDecode<TImport<Definitions, TrimArrayName<Schema>>>[]
+				? NamedSchema['static'][]
+				: TImport<Definitions, TrimArrayName<Schema>>['static'][]
 			: Schema extends string
 				? Definitions extends keyof Schema
 					? // @ts-ignore Definitions is always a Record<string, TAnySchema>
-						StaticDecode<NamedSchema>
-					: StaticDecode<TImport<Definitions, Schema>>
+						NamedSchema['static']
+					: TImport<Definitions, Schema>['static']
 				: unknown
 
 export type UnwrapBodySchema<
@@ -443,35 +437,31 @@ export type UnwrapBodySchema<
 	: Schema extends TSchema
 		? Schema extends OptionalField
 			? Partial<
-					StaticDecode<
-						TImport<
-							Definitions & {
-								readonly __elysia: Schema
-							},
-							'__elysia'
-						>
-					>
-				> | null
-			: StaticDecode<
 					TImport<
 						Definitions & {
 							readonly __elysia: Schema
 						},
 						'__elysia'
-					>
-				>
+					>['static']
+				> | null
+			: TImport<
+					Definitions & {
+						readonly __elysia: Schema
+					},
+					'__elysia'
+				>['static']
 		: Schema extends `${infer Key}[]`
 			? Definitions extends Record<
 					Key,
 					infer NamedSchema extends TAnySchema
 				>
-				? StaticDecode<NamedSchema>[]
-				: StaticDecode<TImport<Definitions, TrimArrayName<Schema>>>[]
+				? NamedSchema['static'][]
+				: TImport<Definitions, TrimArrayName<Schema>>['static'][]
 			: Schema extends string
 				? Definitions extends keyof Schema
 					? // @ts-ignore Definitions is always a Record<string, TAnySchema>
-						StaticDecode<NamedSchema>
-					: StaticDecode<TImport<Definitions, Schema>>
+						NamedSchema['static']
+					: TImport<Definitions, Schema>['static']
 				: unknown
 
 export interface UnwrapRoute<
@@ -1269,7 +1259,7 @@ export type LocalHook<
 	Errors extends { [key in string]: Error },
 	Macro extends BaseMacro,
 	Parser extends keyof any = ''
-> = Macro &
+> = Prettify<Macro> &
 	// Kind of an inference hack, I have no idea why it work either
 	(LocalSchema extends any ? LocalSchema : Prettify<LocalSchema>) & {
 		detail?: DocumentDecoration

src/ws/types.ts

@@ -118,46 +118,48 @@ export type WSParseHandler<Route extends RouteSchema, Context = {}> = (
 	message: unknown
 ) => MaybePromise<Route['body'] | void | undefined>
 
-export type AnyWSLocalHook = WSLocalHook<any, any, any>
+export type AnyWSLocalHook = WSLocalHook<any, any, any, any>
 
 export type WSLocalHook<
 	LocalSchema extends InputSchema,
 	Schema extends RouteSchema,
-	Singleton extends SingletonBase
-> = (LocalSchema extends any ? LocalSchema : Prettify<LocalSchema>) & {
-	detail?: DocumentDecoration
-	/**
-	 * Headers to register to websocket before `upgrade`
-	 */
-	upgrade?: Record<string, unknown> | ((context: Context) => unknown)
-	parse?: MaybeArray<WSParseHandler<Schema>>
+	Singleton extends SingletonBase,
+	Macro extends MetadataBase['macro']
+> = Prettify<Macro> &
+	(LocalSchema extends any ? LocalSchema : Prettify<LocalSchema>) & {
+		detail?: DocumentDecoration
+		/**
+		 * Headers to register to websocket before `upgrade`
+		 */
+		upgrade?: Record<string, unknown> | ((context: Context) => unknown)
+		parse?: MaybeArray<WSParseHandler<Schema>>
 
-	/**
-	 * Transform context's value
-	 */
-	transform?: MaybeArray<TransformHandler<Schema, Singleton>>
-	/**
-	 * Execute before main handler
-	 */
-	beforeHandle?: MaybeArray<OptionalHandler<Schema, Singleton>>
-	/**
-	 * Execute after main handler
-	 */
-	afterHandle?: MaybeArray<OptionalHandler<Schema, Singleton>>
-	/**
-	 * Execute after main handler
-	 */
-	mapResponse?: MaybeArray<MapResponse<Schema, Singleton>>
-	/**
-	 * Execute after response is sent
-	 */
-	afterResponse?: MaybeArray<AfterResponseHandler<Schema, Singleton>>
-	/**
-	 * Catch error
-	 */
-	error?: MaybeArray<ErrorHandler<{}, Schema, Singleton>>
-	tags?: DocumentDecoration['tags']
-} & TypedWebSocketHandler<
+		/**
+		 * Transform context's value
+		 */
+		transform?: MaybeArray<TransformHandler<Schema, Singleton>>
+		/**
+		 * Execute before main handler
+		 */
+		beforeHandle?: MaybeArray<OptionalHandler<Schema, Singleton>>
+		/**
+		 * Execute after main handler
+		 */
+		afterHandle?: MaybeArray<OptionalHandler<Schema, Singleton>>
+		/**
+		 * Execute after main handler
+		 */
+		mapResponse?: MaybeArray<MapResponse<Schema, Singleton>>
+		/**
+		 * Execute after response is sent
+		 */
+		afterResponse?: MaybeArray<AfterResponseHandler<Schema, Singleton>>
+		/**
+		 * Catch error
+		 */
+		error?: MaybeArray<ErrorHandler<{}, Schema, Singleton>>
+		tags?: DocumentDecoration['tags']
+	} & TypedWebSocketHandler<
 		Omit<Context<Schema, Singleton>, 'body'> & {
 			body: never
 		},