🎉 release: 1.2.1

Author: SaltyAom

CHANGELOG.md

@@ -1,3 +1,49 @@
+# 1.2.1 - 23 Dec 2024
+Bug fix:
+- conditional import for fs
+- object macro parameter maybe array
+- optional return for macro
+
+# 1.2.0 - 23 Dec 2024
+Feature:
+- Commitment to Universal Runtime Support
+    - Node Adapter
+    - Web Standard Adapter
+    - Bun Adapter
+    - Universal Utilities
+- Name parser
+- Add resolve support to Macro
+- Improve WebSocket
+    - Support ping, pong and latest Bun feature
+    - Match type declaration with Bun
+    - Support for return, yield
+    - Match Context type
+    - Performance Improvement
+        - Entire rewrite
+        - bind over getter return
+- Infer 422 validation
+- Compilation minification
+- Validation Stuff
+    - t.MaybeArray
+- Typebox Module & Nested model
+    - Inline module
+
+Improvement:
+- Memory Usage
+    - [Internal] Register loosePath in compilation process to reduce memory usage and reduce registration time from O(2n) to O(n)
+- Try to accept and coerce different version of Elysia plugin
+- Event Listener now infers path parameter automatically based on scope
+- Add ‘scoped’ to bulk `as` for casting type to ‘scoped’ similar to ‘plugin’
+
+Change:
+- Update `cookie` to 1.0.1
+- Update TypeBox to 0.33
+- `content-length` now accept number
+
+Breaking Change:
+- [Internal] Remove router internal property static.http.staticHandlers
+- [Internal] Router history compile now link with history composed
+
 # 1.1.27 - 23 Dec 2024
 Bug fix:
 - [#963](https://github.com/elysiajs/elysia/pull/963) array parser on query string when AOT is off

example/a.ts

@@ -1,20 +1,35 @@
 import { Elysia, t } from '../src'
+import { req } from '../test/utils'
 
-export const auth = new Elysia().macro({
-	isAuth(isAuth: boolean) {
-		return {
-			resolve() {
-				return {
-					user: 'saltyaom'
+export const userService = new Elysia({ name: 'user/service' })
+	.macro({
+		isSignIn(enabled: boolean) {
+			if (!enabled) return
+
+			return {
+				beforeHandle({ error, cookie: { token }, store: { session } }) {
+					if (!token.value)
+						return error(401, {
+							success: false,
+							message: 'Unauthorized'
+						})
+
+					const username = session[token.value as unknown as number]
+
+					if (!username)
+						return error(401, {
+							success: false,
+							message: 'Unauthorized'
+						})
 				}
 			}
 		}
-	},
-	role(role: 'admin' | 'user') {
-		return {}
-	}
-})
+	})
+	.get('/', () => 'a', {
+		isSignIn: false
+	})
 
-new Elysia().ws('/ws', {
-	ping: (message) => message
-})
+userService
+	.handle(req('/'))
+	.then((x) => x.text())
+	.then(console.log)

package.json

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

src/index.ts

@@ -3722,7 +3722,13 @@ export default class Elysia<
 		Volatile
 	>
 
-	macro<const NewMacro extends HookMacroFn>(
+	macro<
+		const NewMacro extends HookMacroFn<
+			Metadata['schema'],
+			Singleton,
+			Definitions['error']
+		>
+	>(
 		macro: NewMacro
 	): Elysia<
 		BasePath,

src/types.ts

@@ -1290,36 +1290,26 @@ export type HookMacroFn<
 > = Record<
 	keyof any,
 	(...a: any) => {
-		parse?(fn: MaybeArray<BodyHandler<TypedRoute, Singleton>>): unknown
-		transform?(fn: MaybeArray<VoidHandler<TypedRoute, Singleton>>): unknown
-		// derive?(fn: DeriveHandler<Singleton>): unknown
-		beforeHandle?(
-			fn: MaybeArray<OptionalHandler<TypedRoute, Singleton>>
-		): unknown
-		afterHandle?(
-			fn: MaybeArray<AfterHandler<TypedRoute, Singleton>>
-		): unknown
-		error?(
-			fn: MaybeArray<ErrorHandler<Errors, TypedRoute, Singleton>>
-		): unknown
-		mapResponse?(
-			fn: MaybeArray<MapResponse<TypedRoute, Singleton>>
-		): unknown
-		afterResponse?(
-			fn: MaybeArray<AfterResponseHandler<TypedRoute, Singleton>>
-		): unknown
+		parse?: MaybeArray<BodyHandler<TypedRoute, Singleton>>
+		transform?: MaybeArray<VoidHandler<TypedRoute, Singleton>>
+		beforeHandle?: MaybeArray<OptionalHandler<TypedRoute, Singleton>>
+		afterHandle?: MaybeArray<AfterHandler<TypedRoute, Singleton>>
+		error?: MaybeArray<ErrorHandler<Errors, TypedRoute, Singleton>>
+		mapResponse?: MaybeArray<MapResponse<TypedRoute, Singleton>>
+		afterResponse?: MaybeArray<AfterResponseHandler<TypedRoute, Singleton>>
 		resolve?: MaybeArray<ResolveHandler<TypedRoute, Singleton>>
-	}
+	} | void
 >
 
-export type MacroToProperty<in out T extends BaseMacroFn | HookMacroFn> =
-	Prettify<{
-		[K in keyof T]: T[K] extends Function
-			? T[K] extends (a: infer Params) => any
-				? Params | undefined
-				: T[K]
+export type MacroToProperty<
+	in out T extends BaseMacroFn | HookMacroFn<any, any, any>
+> = Prettify<{
+	[K in keyof T]: T[K] extends Function
+		? T[K] extends (a: infer Params) => any
+			? Params | undefined
 			: T[K]
-	}>
+		: T[K]
+}>
 
 interface MacroOptions {
 	insert?: 'before' | 'after'

src/universal/file.ts

@@ -1,8 +1,9 @@
 /* eslint-disable sonarjs/no-duplicate-string */
-import { createReadStream, statSync, type Stats } from 'fs'
+import { type Stats } from 'fs'
+import { createReadStream, statSync } from './fs'
 
 import { isBun } from './utils'
-import { BunFile } from 'bun'
+import type { BunFile } from 'bun'
 
 export const mime = {
 	aac: 'audio/aac',

src/universal/fs.ts

@@ -0,0 +1,13 @@
+import type * as Fs from 'fs'
+import { env } from './env'
+
+const fs: typeof Fs =
+	typeof process !== 'undefined' && env.NODE_ENV ? require('fs') : {}
+
+const noop = () => {}
+
+export const createReadStream: (typeof Fs)['createReadStream'] =
+	fs.createReadStream ?? noop
+export const statSync: (typeof Fs)['statSync'] = fs.statSync ?? noop
+
+export default fs

test/types/index.ts

@@ -2163,3 +2163,59 @@ type a = keyof {}
 			}
 		)
 }
+
+// Macro
+{
+	const userService = new Elysia({ name: 'user/service' })
+		.state({
+			user: {} as Record<string, string>,
+			session: {} as Record<number, string>
+		})
+		.model({
+			signIn: t.Object({
+				username: t.String({ minLength: 1 }),
+				password: t.String({ minLength: 8 })
+			}),
+			session: t.Cookie(
+				{
+					token: t.Number()
+				},
+				{
+					secrets: 'seia'
+				}
+			),
+			optionalSession: t.Optional(t.Ref('session'))
+		})
+		.macro({
+			isSignIn(enabled: boolean) {
+				if (!enabled) return {}
+
+				return {
+					beforeHandle({
+						error,
+						cookie: { token },
+						store: { session }
+					}) {
+						if (!token.value)
+							return error(401, {
+								success: false,
+								message: 'Unauthorized'
+							})
+
+						expectTypeOf<typeof session>().toEqualTypeOf<
+							Record<number, string>
+						>()
+
+						const username =
+							session[token.value as unknown as number]
+
+						if (!username)
+							return error(401, {
+								success: false,
+								message: 'Unauthorized'
+							})
+					}
+				}
+			}
+		})
+}