elysia 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/compile/handler/params.d.ts

@@ -20,9 +20,6 @@ interface HandlerParamContext {
   cookieConfig: unknown;
   tracers: unknown;
 }
-type Resolver = (c: HandlerParamContext) => unknown;
-/** @internal exported for test/aot/param-descriptor.test.ts */
-declare const handlerParams: () => Record<string, Resolver>;
 declare function resolveHandlerParams(names: string[], c: HandlerParamContext): unknown[];
 //#endregion
-export { handlerParams, resolveHandlerParams };
+export { resolveHandlerParams };

package/dist/compile/handler/params.js

@@ -7,10 +7,10 @@ const require_cookie_utils = require('../../cookie/utils.js');
 const require_handler_utils = require('../../handler/utils.js');
 const require_handler_error = require('../../handler/error.js');
 const require_compile_handler_utils = require('./utils.js');
+const require_compile_handler_static_clone_resolver = require('./static-clone-resolver.js');
 
 //#region src/compile/handler/params.ts
 let _handlerParams;
-/** @internal exported for test/aot/param-descriptor.test.ts */
 const handlerParams = () => _handlerParams ??= {
 	pf: (c) => c.parse.formData,
 	pj: (c) => c.parse.json,
@@ -23,18 +23,22 @@ const handlerParams = () => _handlerParams ??= {
 	qa: (c) => require_compile_handler_utils.getQueryParseChannels(c.vali?.query?.schema)?.array,
 	qo: (c) => require_compile_handler_utils.getQueryParseChannels(c.vali?.query?.schema)?.object,
 	rm: (c) => c.res.map,
-	rc: (c) => c.res.compact ?? c.res.map,
+	rc: (c) => c.res.compact,
 	rid: () => require_utils.requestId,
 	pq: () => require_parse_query.parseQueryFromURL,
 	pe: () => require_error.ParseError,
 	es: () => require_error.ElysiaStatus,
 	rdc: () => require_compile_handler_utils.replaceDeriveContext,
+	dsp: () => require_handler_utils.registerDeriveDisposable,
+	dds: () => require_handler_utils.drainDisposables,
 	emp: () => require_handler_utils.emptyResponse,
 	ea: () => require_compile_handler_utils.armEntryAbort,
 	verr: () => require_error.ValidationError,
 	tee: () => require_adapter_utils.tee,
+	obs: () => require_adapter_utils.observeStream,
 	msh: () => require_adapter_utils.materializeSetHeaders,
 	cr: () => require_compile_handler_utils.cloneResponse,
+	scl: require_compile_handler_static_clone_resolver.staticCloneResolver,
 	pcr: () => require_cookie_utils.parseCookieRaw,
 	pcrs: () => require_cookie_utils.parseCookieRawSync,
 	pcrsg: () => require_cookie_utils.parseCookieRawSigned,
@@ -44,6 +48,10 @@ const handlerParams = () => _handlerParams ??= {
 	scv: () => require_cookie_utils.signCookieValues,
 	va: (c) => c.vali,
 	fe: () => require_handler_utils.forwardError,
+	ie: (c) => {
+		const classes = require_handler_utils.returnedErrorClasses(c.hook, c.root);
+		return classes ? require_handler_utils.forwardErrorOf(classes) : require_handler_utils.forwardError;
+	},
 	fre: () => require_handler_utils.finalizeRouteError,
 	fbr: () => require_handler_error.fallbackResponse,
 	aet: () => require_handler_error.adoptErrorType,
@@ -51,8 +59,6 @@ const handlerParams = () => _handlerParams ??= {
 	ho: (c) => c.hook,
 	tf: (c) => c.hook.transform,
 	bf: (c) => c.hook.beforeHandle,
-	bp: (c) => c.hook["~beforeHandlePrefix"],
-	rbp: () => require_compile_handler_utils.runBeforeHandlePrefix,
 	af: (c) => c.hook.afterHandle,
 	mr: (c) => c.hook.mapResponse,
 	er: (c) => c.hook.error,
@@ -74,5 +80,4 @@ function resolveHandlerParams(names, c) {
 }
 
 //#endregion
-exports.handlerParams = handlerParams;
 exports.resolveHandlerParams = resolveHandlerParams;

package/dist/compile/handler/params.mjs

@@ -1,15 +1,15 @@
 import { requestId } from "../../utils.mjs";
 import { ElysiaStatus, ParseError, ValidationError } from "../../error.mjs";
-import { materializeSetHeaders, normalizeContentType, tee } from "../../adapter/utils.mjs";
+import { materializeSetHeaders, normalizeContentType, observeStream, tee } from "../../adapter/utils.mjs";
 import { parseQueryFromURL } from "../../parse-query.mjs";
 import { buildCookieJar, parseCookieRaw, parseCookieRawDeferred, parseCookieRawLazy, parseCookieRawSigned, parseCookieRawSync, signCookieValues } from "../../cookie/utils.mjs";
-import { emptyResponse, finalizeRouteError, forwardError } from "../../handler/utils.mjs";
+import { drainDisposables, emptyResponse, finalizeRouteError, forwardError, forwardErrorOf, registerDeriveDisposable, returnedErrorClasses } from "../../handler/utils.mjs";
 import { adoptErrorType, fallbackResponse } from "../../handler/error.mjs";
-import { armEntryAbort, cloneResponse, getQueryParseChannels, hasRequestBody, replaceDeriveContext, runBeforeHandlePrefix } from "./utils.mjs";
+import { armEntryAbort, cloneResponse, getQueryParseChannels, hasRequestBody, replaceDeriveContext } from "./utils.mjs";
+import { staticCloneResolver } from "./static-clone-resolver.mjs";
 
 //#region src/compile/handler/params.ts
 let _handlerParams;
-/** @internal exported for test/aot/param-descriptor.test.ts */
 const handlerParams = () => _handlerParams ??= {
 	pf: (c) => c.parse.formData,
 	pj: (c) => c.parse.json,
@@ -22,18 +22,22 @@ const handlerParams = () => _handlerParams ??= {
 	qa: (c) => getQueryParseChannels(c.vali?.query?.schema)?.array,
 	qo: (c) => getQueryParseChannels(c.vali?.query?.schema)?.object,
 	rm: (c) => c.res.map,
-	rc: (c) => c.res.compact ?? c.res.map,
+	rc: (c) => c.res.compact,
 	rid: () => requestId,
 	pq: () => parseQueryFromURL,
 	pe: () => ParseError,
 	es: () => ElysiaStatus,
 	rdc: () => replaceDeriveContext,
+	dsp: () => registerDeriveDisposable,
+	dds: () => drainDisposables,
 	emp: () => emptyResponse,
 	ea: () => armEntryAbort,
 	verr: () => ValidationError,
 	tee: () => tee,
+	obs: () => observeStream,
 	msh: () => materializeSetHeaders,
 	cr: () => cloneResponse,
+	scl: staticCloneResolver,
 	pcr: () => parseCookieRaw,
 	pcrs: () => parseCookieRawSync,
 	pcrsg: () => parseCookieRawSigned,
@@ -43,6 +47,10 @@ const handlerParams = () => _handlerParams ??= {
 	scv: () => signCookieValues,
 	va: (c) => c.vali,
 	fe: () => forwardError,
+	ie: (c) => {
+		const classes = returnedErrorClasses(c.hook, c.root);
+		return classes ? forwardErrorOf(classes) : forwardError;
+	},
 	fre: () => finalizeRouteError,
 	fbr: () => fallbackResponse,
 	aet: () => adoptErrorType,
@@ -50,8 +58,6 @@ const handlerParams = () => _handlerParams ??= {
 	ho: (c) => c.hook,
 	tf: (c) => c.hook.transform,
 	bf: (c) => c.hook.beforeHandle,
-	bp: (c) => c.hook["~beforeHandlePrefix"],
-	rbp: () => runBeforeHandlePrefix,
 	af: (c) => c.hook.afterHandle,
 	mr: (c) => c.hook.mapResponse,
 	er: (c) => c.hook.error,
@@ -73,4 +79,4 @@ function resolveHandlerParams(names, c) {
 }
 
 //#endregion
-export { handlerParams, resolveHandlerParams };
+export { resolveHandlerParams };

package/dist/compile/handler/reconstruct.d.ts

@@ -1,10 +1,10 @@
 import { AnyLocalHook, HTTPMethod } from "../../types.js";
-import { CompiledCookieConfig } from "../../cookie/config.js";
 import { AnyElysia } from "../../base.js";
+import { CompiledCookieConfig } from "../../cookie/config.js";
 
 //#region src/compile/handler/reconstruct.d.ts
 declare abstract class Reconstrct {
-  static validator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string): any;
+  static validator(hook: AnyLocalHook, root: AnyElysia, method: HTTPMethod, path: string, liveOnly?: boolean): any;
   static cookie(hook: AnyLocalHook, root: AnyElysia): CompiledCookieConfig;
   static trace(hook: AnyLocalHook, root: AnyElysia): any;
 }

package/dist/compile/handler/reconstruct.js

@@ -7,9 +7,9 @@ const require_compile_handler_frozen_validator = require('./frozen-validator.js'
 
 //#region src/compile/handler/reconstruct.ts
 var Reconstrct = class {
-	static validator(hook, root, method, path) {
+	static validator(hook, root, method, path, liveOnly = false) {
 		const frozenRoot = require_generation.frozenRootOf(root);
-		if (!require_type_bridge.isBridgeLive()) {
+		if (!liveOnly && !require_type_bridge.isBridgeLive()) {
 			const frozen = require_compile_handler_frozen_validator.buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 		}
@@ -20,7 +20,7 @@ var Reconstrct = class {
 				normalize: frozenRoot["~config"]?.normalize,
 				sanitize: frozenRoot["~config"]?.sanitize,
 				schemas: hook?.schemas,
-				aot: {
+				aot: liveOnly ? void 0 : {
 					method,
 					path
 				},
@@ -28,13 +28,15 @@ var Reconstrct = class {
 			});
 		} catch (error) {
 			if (!require_compile_handler_frozen_validator.isBridgeNotInitialized(error)) throw error;
+			if (liveOnly) throw new Error("Route requires live compilation but the TypeBox bridge is not initialized", { cause: error });
 			const frozen = require_compile_handler_frozen_validator.buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 			throw error;
 		}
 	}
 	static cookie(hook, root) {
-		return require_cookie_config.compileCookieConfig(hook?.cookie, require_generation.frozenRootOf(root)["~config"]?.cookie);
+		const frozenRoot = require_generation.frozenRootOf(root);
+		return require_cookie_config.compileCookieConfig(hook?.cookie, frozenRoot["~config"]?.cookie, frozenRoot["~ext"]?.models, hook?.schemas);
 	}
 	static trace(hook, root) {
 		const traceHandlers = hook?.trace;

package/dist/compile/handler/reconstruct.mjs

@@ -6,9 +6,9 @@ import { buildFrozenRouteValidator, isBridgeNotInitialized } from "./frozen-vali
 
 //#region src/compile/handler/reconstruct.ts
 var Reconstrct = class {
-	static validator(hook, root, method, path) {
+	static validator(hook, root, method, path, liveOnly = false) {
 		const frozenRoot = frozenRootOf(root);
-		if (!isBridgeLive()) {
+		if (!liveOnly && !isBridgeLive()) {
 			const frozen = buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 		}
@@ -19,7 +19,7 @@ var Reconstrct = class {
 				normalize: frozenRoot["~config"]?.normalize,
 				sanitize: frozenRoot["~config"]?.sanitize,
 				schemas: hook?.schemas,
-				aot: {
+				aot: liveOnly ? void 0 : {
 					method,
 					path
 				},
@@ -27,13 +27,15 @@ var Reconstrct = class {
 			});
 		} catch (error) {
 			if (!isBridgeNotInitialized(error)) throw error;
+			if (liveOnly) throw new Error("Route requires live compilation but the TypeBox bridge is not initialized", { cause: error });
 			const frozen = buildFrozenRouteValidator(hook, root, method, path);
 			if (frozen) return frozen;
 			throw error;
 		}
 	}
 	static cookie(hook, root) {
-		return compileCookieConfig(hook?.cookie, frozenRootOf(root)["~config"]?.cookie);
+		const frozenRoot = frozenRootOf(root);
+		return compileCookieConfig(hook?.cookie, frozenRoot["~config"]?.cookie, frozenRoot["~ext"]?.models, hook?.schemas);
 	}
 	static trace(hook, root) {
 		const traceHandlers = hook?.trace;

package/dist/compile/handler/static-clone-resolver.d.ts

@@ -0,0 +1,6 @@
+import { cloneStaticValue } from "./utils.js";
+
+//#region src/compile/handler/static-clone-resolver.d.ts
+declare const staticCloneResolver: () => typeof cloneStaticValue;
+//#endregion
+export { staticCloneResolver };

package/dist/compile/handler/static-clone-resolver.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_compile_handler_utils = require('./utils.js');
+
+//#region src/compile/handler/static-clone-resolver.ts
+const staticCloneResolver = () => require_compile_handler_utils.cloneStaticValue;
+
+//#endregion
+exports.staticCloneResolver = staticCloneResolver;

package/dist/compile/handler/static-clone-resolver.mjs

@@ -0,0 +1,7 @@
+import { cloneStaticValue } from "./utils.mjs";
+
+//#region src/compile/handler/static-clone-resolver.ts
+const staticCloneResolver = () => cloneStaticValue;
+
+//#endregion
+export { staticCloneResolver };

package/dist/compile/handler/utils.d.ts

@@ -1,8 +1,6 @@
 import { CompactBeforeHandlePrefix, DeriveEntry } from "../../utils.js";
-import { AfterResponseHandler, AppHook, ErrorHandler, MaybeArray, TransformHandler } from "../../types.js";
 import { Context } from "../../context.js";
-import { emptyResponse } from "../../handler/utils.js";
-
+import { AfterResponseHandler, AppHook, ErrorHandler, MaybeArray, TransformHandler } from "../../types.js";
 //#region src/compile/handler/utils.d.ts
 type Link = (v: unknown, key: string) => void;
 interface TraceReporter {
@@ -12,6 +10,7 @@ interface TraceReporter {
   };
 }
 declare function cloneResponse(r: unknown): unknown;
+declare function cloneStaticValue(value: unknown): unknown;
 declare function hasRequestBody(request: Request): boolean;
 /**
  * Route-entry abort probe. Mirrors `createFetchHandler`'s `armEager`, but is
@@ -21,25 +20,37 @@ declare function hasRequestBody(request: Request): boolean;
  * @see `../../adapter/origin` for the provenance channel
  */
 declare function armEntryAbort(context: any): any;
-declare const mapTransform: (event: MaybeArray<TransformHandler<any, any, undefined, "local">>, rest?: [isAsync: boolean, report?: TraceReporter | undefined] | undefined, abortGuard?: string) => string;
-declare function extractDeriveKeys(fn: Function): string[] | null;
+declare const mapTransform: (event: MaybeArray<TransformHandler<any, any, undefined, "local">>, rest?: [isAsync: AsyncMode, report?: TraceReporter | undefined, arm?: string | undefined] | undefined, abortGuard?: string, tail?: TailMode) => string;
 declare function replaceDeriveContext(context: any, derivative: any): any;
 declare function deriveModes(hooks: Function[], entries?: readonly DeriveEntry[]): (boolean | undefined)[] | undefined;
-declare function mapBeforeHandle(_hooks: AppHook['beforeHandle'] | AppHook['beforeHandle'][0], derive: readonly DeriveEntry[] | undefined, link: Link, isAsync: boolean, report?: TraceReporter, abortGuard?: string): string;
+declare function mapBeforeHandle(_hooks: AppHook['beforeHandle'] | AppHook['beforeHandle'][0], derive: readonly DeriveEntry[] | undefined, link: Link, isAsync: AsyncMode, report?: TraceReporter, abortGuard?: string, arm?: string): string;
 type BeforeHandleContext = {
   request: Request;
   '~sig'?: AbortSignal;
 };
 declare function runBeforeHandlePrefix(prefix: CompactBeforeHandlePrefix, context: BeforeHandleContext, abort?: 1): any;
 declare function runBeforeHandlePrefixAsync(prefix: CompactBeforeHandlePrefix, context: BeforeHandleContext, abort?: 1): Promise<any>;
-declare const mapAfterHandle: (_hooks: AppHook["afterHandle"] | AppHook["afterHandle"][0], isAsync: boolean, report?: TraceReporter, abortGuard?: string) => string;
-declare const mapMapResponse: (_hooks: AppHook["mapResponse"] | AppHook["mapResponse"][0], isAsync: boolean, report?: TraceReporter, abortGuard?: string) => string;
-declare const mapAfterResponse: (event: MaybeArray<AfterResponseHandler<any, any, undefined, "local">>, rest?: [report?: TraceReporter | undefined] | undefined, abortGuard?: string) => string;
-declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, isAsync: boolean] | undefined, abortGuard?: string) => string;
+declare function mapChainHook(_hooks: Function | Function[], prefix: string, isAsync: AsyncMode, report?: TraceReporter, abortGuard?: string, arm?: string): string;
+declare const mapAfterResponse: (event: MaybeArray<AfterResponseHandler<any, any, undefined, "local">>, rest?: [report?: TraceReporter | undefined] | undefined, abortGuard?: string, tail?: TailMode) => string;
+declare const mapError: (event: MaybeArray<ErrorHandler<any, any, any>>, rest?: [map: string, link: Link, mapResponse: (response: unknown, set: Context["set"], ...params: unknown[]) => unknown, schedule: string, sign: string, isAsync: AsyncMode, arm?: string | undefined] | undefined, abortGuard?: string, tail?: TailMode) => string;
 interface QueryWalkState {
   array: Record<string, 1> | undefined;
   object: Record<string, 1> | undefined;
 }
 declare function getQueryParseChannels(querySchema: any): QueryWalkState | undefined;
+type AsyncMode = boolean | TailMode;
+interface TailMode {
+  async: boolean;
+  n: number;
+  r?: boolean;
+  e?: boolean;
+  live: string;
+  sites: string[];
+}
+declare const asyncTail: (mode: AsyncMode) => TailMode | undefined;
+declare function awaitSite(call: string, fn: Function, isAsync: AsyncMode, target: string, arm?: string): string;
+declare const tailStage: (mode: TailMode, guard?: string) => string;
+declare const tailPlain: (mode: AsyncMode, code: string) => string;
+declare function awaitGuard(fn: Function, isAsync: AsyncMode, target: string, arm?: string): string;
 //#endregion
-export { Link, TraceReporter, armEntryAbort, cloneResponse, deriveModes, emptyResponse, extractDeriveKeys, getQueryParseChannels, hasRequestBody, mapAfterHandle, mapAfterResponse, mapBeforeHandle, mapError, mapMapResponse, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync };
+export { AsyncMode, Link, TailMode, TraceReporter, armEntryAbort, asyncTail, awaitGuard, awaitSite, cloneResponse, cloneStaticValue, deriveModes, getQueryParseChannels, hasRequestBody, mapAfterResponse, mapBeforeHandle, mapChainHook, mapError, mapTransform, replaceDeriveContext, runBeforeHandlePrefix, runBeforeHandlePrefixAsync, tailPlain, tailStage };