elysia 2.0.0-exp.2 → 2.0.0-exp.21

package/dist/adapter/utils.mjs

@@ -1,7 +1,7 @@
 import { hasHeaderShorthand, isBun } from "../universal/constants.mjs";
 import { StatusMap } from "../constants.mjs";
 import { isNotEmpty, nullObject } from "../utils.mjs";
-import { serializeCookie } from "../cookie/utils.mjs";
+import { serializeCookie } from "../cookie/serialize.mjs";
 
 //#region src/adapter/utils.ts
 const setCookie = "set-cookie";
@@ -100,7 +100,7 @@ function responseToSetHeaders(response, set) {
 	} else if (set.headers["content-encoding"]) delete set.headers["content-encoding"];
 	return set;
 }
-const enqueueBinaryChunk = (controller, chunk) => {
+function enqueueBinaryChunk(controller, chunk) {
 	if (chunk instanceof Blob) return chunk.arrayBuffer().then((buffer) => {
 		controller.enqueue(new Uint8Array(buffer));
 		return true;
@@ -118,91 +118,93 @@ const enqueueBinaryChunk = (controller, chunk) => {
 		return true;
 	}
 	return false;
-};
-const createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request, skipFormat) => {
-	let init = generator.next?.();
-	if (set) handleSet(set);
-	if (init instanceof Promise) init = await init;
-	if (init?.value instanceof ReadableStream) generator = init.value;
-	else if (init && (typeof init?.done === "undefined" || init?.done)) {
-		if (set) return mapResponse(init.value, set, request);
-		return mapCompactResponse(init.value, request);
-	}
-	const isSSE = !skipFormat && (init?.value?.sse ?? generator?.sse ?? set?.headers["content-type"]?.startsWith("text/event-stream"));
-	const format = isSSE ? (data) => `data: ${data}\n\n` : (data) => data;
-	const contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value === "object" ? ArrayBuffer.isView(init.value) ? "application/octet-stream" : "application/json" : "text/plain";
-	const headers = set?.headers;
-	if (headers) {
-		if (!headers["transfer-encoding"]) headers["transfer-encoding"] = "chunked";
-		if (!headers["content-type"]) headers["content-type"] = contentType;
-		if (!headers["cache-control"]) headers["cache-control"] = "no-cache";
-	} else set = {
-		status: 200,
-		headers: {
-			"content-type": contentType,
-			"transfer-encoding": "chunked",
-			"cache-control": "no-cache",
-			connection: "keep-alive"
+}
+function createStreamHandler({ mapResponse, mapCompactResponse }) {
+	return async (generator, set, request, skipFormat) => {
+		let init = generator.next?.();
+		if (set) handleSet(set);
+		if (init instanceof Promise) init = await init;
+		if (init?.value instanceof ReadableStream) generator = init.value;
+		else if (init && (typeof init?.done === "undefined" || init?.done)) {
+			if (set) return mapResponse(init.value, set, request);
+			return mapCompactResponse(init.value, request);
 		}
-	};
-	const iterator = typeof generator.next === "function" ? generator : generator[Symbol.asyncIterator]();
-	let end = false;
-	return new Response(new ReadableStream({
-		start(controller) {
-			request?.signal?.addEventListener("abort", () => {
-				end = true;
-				iterator.return?.();
-				try {
-					controller.close();
-				} catch {}
-			});
-			if (!init || init.value instanceof ReadableStream || init.value === void 0 || init.value === null) return;
-			if (init.value.toSSE) controller.enqueue(init.value.toSSE());
-			else if (enqueueBinaryChunk(controller, init.value)) return;
-			else if (typeof init.value === "object") try {
-				controller.enqueue(format(JSON.stringify(init.value)));
-			} catch {
-				controller.enqueue(format(init.value.toString()));
+		const isSSE = !skipFormat && (init?.value?.sse ?? generator?.sse ?? set?.headers["content-type"]?.startsWith("text/event-stream"));
+		const format = isSSE ? (data) => `data: ${data}\n\n` : (data) => data;
+		const contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value === "object" ? ArrayBuffer.isView(init.value) ? "application/octet-stream" : "application/json" : "text/plain";
+		const headers = set?.headers;
+		if (headers) {
+			if (!headers["transfer-encoding"]) headers["transfer-encoding"] = "chunked";
+			if (!headers["content-type"]) headers["content-type"] = contentType;
+			if (!headers["cache-control"]) headers["cache-control"] = "no-cache";
+		} else set = {
+			status: 200,
+			headers: {
+				"content-type": contentType,
+				"transfer-encoding": "chunked",
+				"cache-control": "no-cache",
+				connection: "keep-alive"
 			}
-			else controller.enqueue(format(init.value.toString()));
-		},
-		async pull(controller) {
-			if (end) {
-				try {
-					controller.close();
-				} catch {}
-				return;
-			}
-			try {
-				const { value: chunk, done } = await iterator.next();
-				if (done || end) {
+		};
+		const iterator = typeof generator.next === "function" ? generator : generator[Symbol.asyncIterator]();
+		let end = false;
+		return new Response(new ReadableStream({
+			start(controller) {
+				request?.signal?.addEventListener("abort", () => {
+					end = true;
+					iterator.return?.();
 					try {
 						controller.close();
 					} catch {}
-					return;
-				}
-				if (chunk === void 0 || chunk === null) return;
-				if (chunk.toSSE) controller.enqueue(chunk.toSSE());
-				else if (enqueueBinaryChunk(controller, chunk)) return;
-				else if (typeof chunk === "object") try {
-					controller.enqueue(format(JSON.stringify(chunk)));
+				});
+				if (!init || init.value instanceof ReadableStream || init.value === void 0 || init.value === null) return;
+				if (init.value.toSSE) controller.enqueue(init.value.toSSE());
+				else if (enqueueBinaryChunk(controller, init.value)) return;
+				else if (typeof init.value === "object") try {
+					controller.enqueue(format(JSON.stringify(init.value)));
 				} catch {
-					controller.enqueue(format(chunk.toString()));
+					controller.enqueue(format(init.value.toString()));
+				}
+				else controller.enqueue(format(init.value.toString()));
+			},
+			async pull(controller) {
+				if (end) {
+					try {
+						controller.close();
+					} catch {}
+					return;
 				}
-				else controller.enqueue(format(chunk.toString()));
-			} catch (error) {
-				console.warn(error);
 				try {
-					controller.close();
-				} catch {}
+					const { value: chunk, done } = await iterator.next();
+					if (done || end) {
+						try {
+							controller.close();
+						} catch {}
+						return;
+					}
+					if (chunk === void 0 || chunk === null) return;
+					if (chunk.toSSE) controller.enqueue(chunk.toSSE());
+					else if (enqueueBinaryChunk(controller, chunk)) return;
+					else if (typeof chunk === "object") try {
+						controller.enqueue(format(JSON.stringify(chunk)));
+					} catch {
+						controller.enqueue(format(chunk.toString()));
+					}
+					else controller.enqueue(format(chunk.toString()));
+				} catch (error) {
+					console.warn(error);
+					try {
+						controller.close();
+					} catch {}
+				}
+			},
+			cancel() {
+				end = true;
+				iterator.return?.();
 			}
-		},
-		cancel() {
-			end = true;
-			iterator.return?.();
-		}
-	}), set);
-};
+		}), set);
+	};
+}
 async function* streamResponse(response) {
 	const body = response.body;
 	if (body) yield* body;
@@ -240,7 +242,7 @@ function mergeStatus(responseStatus, setStatus) {
 	if (responseStatus === 200) return setStatus;
 	return responseStatus;
 }
-const createResponseHandler = (handler) => {
+function createResponseHandler(handler) {
 	const handleStream = createStreamHandler(handler);
 	return (response, set, request) => {
 		if (set) {
@@ -264,7 +266,7 @@ const createResponseHandler = (handler) => {
 		if (!newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked") return handleStream(streamResponse(newResponse), responseToSetHeaders(newResponse, set), request, true);
 		return newResponse;
 	};
-};
+}
 /**
 * Split async source into `branches` independent iterators
 *

package/dist/adapter/web-standard/handler.js

@@ -2,13 +2,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_universal_constants = require('../../universal/constants.js');
 const require_universal_file = require('../../universal/file.js');
 const require_utils = require('../../utils.js');
-const require_error = require('../../error.js');
 const require_adapter_utils = require('../utils.js');
+const require_error = require('../../error.js');
 
 //#region src/adapter/web-standard/handler.ts
 function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, request) {
 	const path = file.path;
-	const contentType = require_universal_file.mime[path.slice(path.lastIndexOf(".") + 1)];
+	const contentType = require_universal_file.mime[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
 	const headers = set.headers;
 	if (contentType) headers["content-type"] = contentType;
 	if (file.stats && set.status !== 206 && set.status !== 304 && set.status !== 412 && set.status !== 416) return file.stats.then((stat) => {
@@ -97,7 +97,10 @@ function errorToResponse(error, set) {
 		return typeof raw?.then === "function" ? raw.then(apply) : apply(raw);
 	}
 	const headers = set?.headers ?? require_utils.nullObject();
-	return Response.json({
+	return Response.json(require_error.isProduction() ? {
+		name: error?.name,
+		message: "Internal Server Error"
+	} : {
 		name: error?.name,
 		message: error?.message,
 		cause: error?.cause

package/dist/adapter/web-standard/handler.mjs

@@ -1,13 +1,13 @@
 import { isBun } from "../../universal/constants.mjs";
 import { mime } from "../../universal/file.mjs";
 import { formToFormData, isNotEmpty, nullObject } from "../../utils.mjs";
-import { ElysiaStatus } from "../../error.mjs";
 import { createResponseHandler, createStreamHandler, handleFile, handleSet } from "../utils.mjs";
+import { ElysiaStatus, isProduction } from "../../error.mjs";
 
 //#region src/adapter/web-standard/handler.ts
 function handleElysiaFile(file, set = { headers: nullObject() }, request) {
 	const path = file.path;
-	const contentType = mime[path.slice(path.lastIndexOf(".") + 1)];
+	const contentType = mime[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
 	const headers = set.headers;
 	if (contentType) headers["content-type"] = contentType;
 	if (file.stats && set.status !== 206 && set.status !== 304 && set.status !== 412 && set.status !== 416) return file.stats.then((stat) => {
@@ -96,7 +96,10 @@ function errorToResponse(error, set) {
 		return typeof raw?.then === "function" ? raw.then(apply) : apply(raw);
 	}
 	const headers = set?.headers ?? nullObject();
-	return Response.json({
+	return Response.json(isProduction() ? {
+		name: error?.name,
+		message: "Internal Server Error"
+	} : {
 		name: error?.name,
 		message: error?.message,
 		cause: error?.cause

package/dist/adapter/web-standard/index.d.ts

@@ -1,29 +1,5 @@
-import { ListenCallback, Serve } from "../../universal/server.js";
-import { AnyLocalHook, MaybePromise } from "../../types.js";
-import { Context } from "../../context.js";
-import { AnyElysia } from "../../base.js";
+import { ElysiaAdapterOptions } from "../types.js";
 //#region src/adapter/web-standard/index.d.ts
-declare const WebStandardAdapter: {
-  parse: {
-    default: (context: Context, contentType: string) => string | unknown[] | ArrayBuffer | Record<string, unknown> | Promise<Record<string, unknown>> | Promise<ArrayBuffer> | Promise<string> | Promise<unknown[] | Record<string | number | symbol, undefined>> | undefined;
-    json: (context: Context) => MaybePromise<Record<keyof any, undefined> | unknown[]>;
-    text: (context: Context) => MaybePromise<string>;
-    urlencoded: (context: Context) => MaybePromise<Record<string, string | string[]>>;
-    arrayBuffer: (context: Context) => MaybePromise<ArrayBuffer>;
-    formData: (context: Context) => MaybePromise<Record<string, unknown>>;
-  };
-  name: string;
-  runtime: "node" | "deno" | "bun" | "cloudflare-worker" | "browser" | "vercel" | "netlify" | "lambda" | "fastly" | "edge" | "unknown" | (string & {});
-  isWebStandard: boolean;
-  listen?(app: AnyElysia, options: string | number | Partial<Serve>, callback?: ListenCallback): void;
-  stop?(app: AnyElysia, closeActiveConnections?: boolean): Promise<void>;
-  response: {
-    map(response: unknown, set: Context["set"], ...params: unknown[]): unknown;
-    compact?(response: unknown, ...params: unknown[]): unknown;
-    static?(handle: unknown, hooks: AnyLocalHook, setHeaders?: Context["set"]["headers"], ...params: unknown[]): (() => unknown) | undefined;
-    nativeStatic?(handle: unknown, hooks: AnyLocalHook, set?: Context["set"]): (() => MaybePromise<Response>) | undefined;
-  };
-  fetch?(app: AnyElysia): (request: Request) => MaybePromise<Response>;
-};
+declare const WebStandardAdapter: ElysiaAdapterOptions;
 //#endregion
 export { WebStandardAdapter };

package/dist/adapter/web-standard/index.js

@@ -14,7 +14,18 @@ const WebStandardAdapter = require_adapter_index.createAdapter({
 		formData: (context) => context.request.formData().then(require_adapter_web_standard_utils.formDataToObject),
 		json: (context) => context.request.json(),
 		text: (context) => context.request.text(),
-		urlencoded: (context) => context.request.text().then(require_parse_query.parseQuery)
+		urlencoded: (context) => context.request.text().then(require_parse_query.parseQuery),
+		default(context, contentType) {
+			switch (contentType.charCodeAt(12)) {
+				case 106: return context.request.json();
+				case 120:
+					if (contentType.charCodeAt(13) === 45) return context.request.text().then(require_parse_query.parseQuery);
+					break;
+				case 111: return context.request.arrayBuffer();
+				case 114: return context.request.formData().then(require_adapter_web_standard_utils.formDataToObject);
+				default: if (contentType.charCodeAt(0) === 116) return context.request.text();
+			}
+		}
 	},
 	response: {
 		map: require_adapter_web_standard_handler.mapResponse,

package/dist/adapter/web-standard/index.mjs

@@ -13,7 +13,18 @@ const WebStandardAdapter = createAdapter({
 		formData: (context) => context.request.formData().then(formDataToObject),
 		json: (context) => context.request.json(),
 		text: (context) => context.request.text(),
-		urlencoded: (context) => context.request.text().then(parseQuery)
+		urlencoded: (context) => context.request.text().then(parseQuery),
+		default(context, contentType) {
+			switch (contentType.charCodeAt(12)) {
+				case 106: return context.request.json();
+				case 120:
+					if (contentType.charCodeAt(13) === 45) return context.request.text().then(parseQuery);
+					break;
+				case 111: return context.request.arrayBuffer();
+				case 114: return context.request.formData().then(formDataToObject);
+				default: if (contentType.charCodeAt(0) === 116) return context.request.text();
+			}
+		}
 	},
 	response: {
 		map: mapResponse,

package/dist/base.d.ts

@@ -1,7 +1,7 @@
 import { ElysiaStatus } from "./error.js";
 import { TraceHandler } from "./trace.js";
 import { ListenCallback, Serve, Server } from "./universal/server.js";
-import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, AppEvent, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventFn, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GuardLocalHook, HTTPMethod, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, Macro, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
+import { AddRoute, AddWSRoute, AfterHandler, AfterResponseHandler, AnyErrorConstructor, AnyLocalHook, BodyHandler, CompiledHandler, CreateEden, DefaultEphemeral, DefaultMetadata, DefaultSingleton, DefinitionBase, DocumentDecoration, ElysiaConfig, ElysiaHandlerToResponseSchemaAmbiguous, EphemeralType, ErrorDefinitionEntry, ErrorHandler, EventScope, ExcludeElysiaResponse, ExtractErrorFromHandle, GracefulHandler, GuardLocalHook, HTTPMethod, InlineHandler, InlineHandlerNonMacro, InputSchema, InputSchemaKey, InternalRoute, IntersectIfObjectSchema, JoinPath, LocalHook, Macro, MacroSchemaChannel, MacroToContext, MacroToProperty, MapResponse, MaybeArray, MaybePromise, MergeElysiaInstances, MergeSchema, MergeScopedSchemas, MetadataBase, NonResolvableMacroKey, ObjectMacroDefs, OptionalHandler, PreHandler, Prettify, PublicRoute, ResolveRouteErrors, RouteBase, SingletonBase, TransformHandler, UnionResponseStatus, UnwrapRoute, WrapFn } from "./types.js";
 import { AnySchema } from "./type/types.js";
 import { ChainNode } from "./utils.js";
 import { Context, ErrorContext, LifecycleContext } from "./context.js";
@@ -34,6 +34,8 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     error?: Map<AnyErrorConstructor, string>;
     parser?: Record<string, BodyHandler<any, any>>;
     hoc?: WrapFn<any>[];
+    setup?: GracefulHandler<any>[];
+    cleanup?: GracefulHandler<any>[];
   };
   '~hookChain'?: ChainNode;
   server?: Server;
@@ -43,11 +45,11 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   '~map'?: {
     [method: string]: {
       [path: string]: CompiledHandler;
-    };
+    } | undefined;
   };
   '~staticResponse'?: {
-    [path: string]: {
-      [method: string]: Response | Promise<Response>;
+    [method: string]: {
+      [path: string]: Response | Promise<Response>;
     };
   };
   '~hasWS'?: boolean;
@@ -148,11 +150,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     derive: Singleton['derive'];
   }, Definitions, Metadata, Routes, Ephemeral, Volatile>;
   headers(headers: Record<string, string>): this;
-  on<Event extends AppEvent>(event: Event, fn: EventFn<Event>): this;
   request(fn: MaybeArray<PreHandler<{}, Singleton>>): this;
-  request(scope: 'local', fn: MaybeArray<PreHandler<{}, Singleton>>): this;
-  request(scope: 'plugin', fn: MaybeArray<PreHandler<{}, Singleton>>): this;
-  request(scope: 'global', fn: MaybeArray<PreHandler<{}, Singleton>>): this;
   parse(fn: MaybeArray<BodyHandler<MergeSchema<{}, {}, BasePath>, Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }>>): this;
@@ -176,8 +174,21 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'] & { [name in Name]: BodyHandler<any, any> };
     response: Metadata['response'];
   }, Routes, Ephemeral, Volatile>;
-  onStart(_listener?: unknown): this;
-  onStop(_listener?: unknown): this;
+  /**
+   * ### setup | Life cycle event
+   * Called after server is ready for serving
+   *
+   * ---
+   * @example
+   * ```typescript
+   * new Elysia()
+   *     .setup(({ server }) => {
+   *         console.log("Running at ${server?.url}:${server?.port}")
+   *     })
+   *     .listen(3000)
+   * ```
+   */
+  setup(handler: MaybeArray<GracefulHandler<this>>): this;
   transform(fn: MaybeArray<TransformHandler<MergeSchema<{}, {}, BasePath>, Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'];
   }>>): this;
@@ -496,62 +507,6 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
     parser: Metadata['parser'];
     response: UnionResponseStatus<Metadata['response'], UnionResponseStatus<Ephemeral['response'], Volatile['response']>>;
   }, Routes, DefaultEphemeral, DefaultEphemeral>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, Singleton>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, Singleton>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, Singleton>>>(hook: GuardLocalHook<Input, Schema & MacroContext, Singleton & {
-    derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['response'];
-  }, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    as: 'plugin';
-    schema: 'standalone';
-  }): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, {
-    derive: Ephemeral['derive'] & MacroContext['resolve'];
-    schema: Ephemeral['schema'];
-    schemas: Ephemeral['schemas'] & UnwrapRoute<Input, Definitions['typebox']> & MacroContext;
-    response: UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
-    error: Ephemeral['error'];
-  }, Volatile>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, Singleton>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, Singleton>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, Singleton>>>(hook: GuardLocalHook<Input, Schema & MacroContext, Singleton & {
-    derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['response'];
-  }, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & {
-    as: 'plugin';
-  }): Elysia<BasePath, Scope, Singleton, Definitions, Metadata, Routes, {
-    derive: Ephemeral['derive'] & MacroContext['resolve'];
-    schema: {} extends Pick<Input, Extract<keyof Input, InputSchemaKey>> ? Ephemeral['schema'] : MergeSchema<UnwrapRoute<Input, Definitions['typebox']>, Ephemeral['schema']>;
-    schemas: Ephemeral['schemas'] & MacroContext;
-    response: UnionResponseStatus<Ephemeral['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
-    error: Ephemeral['error'];
-  }, Volatile>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, Singleton>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, Singleton>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, Singleton>>>(hook: GuardLocalHook<Input, Schema & MacroContext, Singleton & {
-    derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['response'];
-  }, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
-    as: 'global';
-    schema: 'standalone';
-  }): Elysia<BasePath, Scope, {
-    decorator: Singleton['decorator'];
-    store: Singleton['store'];
-    derive: Singleton['derive'] & MacroContext['resolve'];
-  }, Definitions, {
-    schema: Metadata['schema'];
-    schemas: Metadata['schemas'] & UnwrapRoute<Input, Definitions['typebox']> & MacroContext;
-    macro: Metadata['macro'];
-    macroFn: Metadata['macroFn'];
-    parser: Metadata['parser'];
-    response: UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
-  }, Routes, Ephemeral, Volatile>;
-  guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, Singleton>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, Singleton>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, Singleton>>>(hook: GuardLocalHook<Input, Schema & MacroContext, Singleton & {
-    derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['response'];
-  }, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle, 'override'> & {
-    as: 'global';
-  }): Elysia<BasePath, Scope, {
-    decorator: Singleton['decorator'];
-    store: Singleton['store'];
-    derive: Singleton['derive'] & MacroContext['resolve'];
-  }, Definitions, {
-    schema: {} extends Pick<Input, Extract<keyof Input, InputSchemaKey>> ? Metadata['schema'] : MergeSchema<UnwrapRoute<Input, Definitions['typebox']>, Metadata['schema']>;
-    schemas: Metadata['schemas'] & MacroContext;
-    macro: Metadata['macro'];
-    macroFn: Metadata['macroFn'];
-    parser: Metadata['parser'];
-    response: UnionResponseStatus<Metadata['response'], ElysiaHandlerToResponseSchemaAmbiguous<BeforeHandle> & ElysiaHandlerToResponseSchemaAmbiguous<AfterHandle> & ElysiaHandlerToResponseSchemaAmbiguous<ErrorHandle> & MacroContext['return']>;
-  }, Routes, Ephemeral, Volatile>;
   guard<const Input extends Metadata['macro'] & InputSchema<keyof Definitions['typebox'] & string>, const Schema extends MergeSchema<UnwrapRoute<Input, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>> & Metadata['schemas'] & Ephemeral['schemas'] & Volatile['schemas'], const MacroContext extends ({} extends Metadata['macroFn'] ? {} : MacroToContext<Metadata['macroFn'], Omit<Input, NonResolvableMacroKey>, Definitions['typebox']>), const BeforeHandle extends MaybeArray<OptionalHandler<Schema, Singleton>>, const AfterHandle extends MaybeArray<AfterHandler<Schema, Singleton>>, const ErrorHandle extends MaybeArray<ErrorHandler<Definitions['error'], Schema, Singleton>>>(hook: GuardLocalHook<Input, Schema & MacroContext, Singleton & {
     derive: Ephemeral['derive'] & Volatile['derive'] & MacroContext['response'];
   }, keyof Metadata['parser'], BeforeHandle, AfterHandle, ErrorHandle> & {
@@ -730,7 +685,7 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
    *     .get('/', ({ user }) => user, { auth: true, role: 'admin' })
    * ```
    */
-  macro<const Body, const Headers, const Query, const Params, const Cookie, const NewMacro>(macro: ObjectMacroDefs<Body, Headers, Query, Params, Cookie, NewMacro, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>, Singleton & {
+  macro<const Body extends MacroSchemaChannel<Definitions>, const Headers extends MacroSchemaChannel<Definitions>, const Query extends MacroSchemaChannel<Definitions>, const Params extends MacroSchemaChannel<Definitions>, const Cookie extends MacroSchemaChannel<Definitions>, const NewMacro>(macro: ObjectMacroDefs<Body, Headers, Query, Params, Cookie, NewMacro, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>, MergeScopedSchemas<Metadata['schemas'], Ephemeral['schemas'], Volatile['schemas']>, Singleton & {
     derive: Partial<Ephemeral['derive'] & Volatile['derive']>;
   }, Definitions, Metadata['macro']>): Elysia<BasePath, Scope, Singleton, Definitions, {
     schema: Metadata['schema'];
@@ -1047,7 +1002,22 @@ declare class Elysia<const in out BasePath extends string = '', const in out Sco
   listen(options: string | number | Partial<Serve>, callback?: ListenCallback): this;
   wrap<T extends (...params: any) => MaybePromise<Response> = (request: Request, ...rest: any[]) => MaybePromise<Response>>(callback: WrapFn<T>): this;
   /**
-   * Stop the underlying server (if any). Mirrors `Server.stop()`.
+   * ### cleanup | Life cycle event
+   * Called after server stop serving request
+   *
+   * ---
+   * @example
+   * ```typescript
+   * new Elysia()
+   *     .cleanup((app) => {
+   *         closeDatabase()
+   *     })
+   * ```
+   */
+  cleanup(handler: MaybeArray<GracefulHandler<this>>): this;
+  /**
+   * Stop the underlying server (if any), running every `cleanup` handler once
+   * it has stopped. Mirrors `Server.stop()`.
    *
    * @param closeActiveConnections Pass `true` to terminate in-flight
    *   requests and WebSocket connections immediately. Defaults to