elysia 2.0.0-beta.26 → 2.0.0-beta.28

package/dist/base.js

@@ -66,17 +66,11 @@ const toModel = (key, value) => {
 	value.$id ??= key;
 	return value;
 };
-const hookKeys = new Set([
-	...require_utils.schemaProperties,
-	...require_utils.eventProperties,
-	"detail",
-	"tags"
-]);
 const assertScope = (scope) => {
 	if (scope !== void 0 && scope !== "local" && scope !== "plugin" && scope !== "global") throw new Error(`[Elysia] Invalid hook scope ${JSON.stringify(scope)}, expected 'local', 'plugin' or 'global' (1.x 'scoped' is 'plugin')`);
 };
 const hasHookKeys = (value) => {
-	for (const key in value) if (hookKeys.has(key)) return true;
+	for (const key in value) if (require_utils.schemaProperties.has(key) || require_utils.eventProperties.has(key) || key === "detail" || key === "tags") return true;
 	return false;
 };
 function assertSchemaShape(hook, where) {
@@ -95,13 +89,6 @@ function assertSchemaShape(hook, where) {
 		throw new Error(`[Elysia] ${where}: "${key}" is not a schema — use t.Object({ ... })`);
 	}
 }
-/**
-* Every key a single route must answer to, in registration order.
-*
-* `registerLoose` is the caller's call, not this helper's: HTTP gates it on
-* `canRegisterLoose` because its lookup retries the trailing slash, while WS
-* has no such retry and must own both directions outright
-*/
 function expandPaths(path, needsEncode, registerLoose, explicit) {
 	const variants = [path];
 	if (needsEncode) {
@@ -172,31 +159,10 @@ var Elysia = class Elysia {
 	get ["~programId"]() {
 		return this;
 	}
+	static #nextScopeChild;
 	constructor(config) {
-		/**
-		* ! Don't tune
-		*
-		* Interesting JSC internal: These `= undefined` shouldn't be removed
-		*
-		* Inline slots live inside the object cell, so JSC must pick their
-		* count at allocation before any initializer runs
-		*
-		* Its only signal is counting `this.x =` in the ctor body;
-		* class-field initializers compile into a separate hidden function
-		* the guess never sees
-		*
-		* The cell can't grow afterwards, so once inline slots run out every
-		* later property spills into the butterfly, and capacity is by n^2
-		*
-		* Fields run first before ctor (here), so they take the inline slots
-		* these assignments reserve
-		*
-		* Don't omitted field either for monomorphic access
-		*
-		* @see test/memory/instance-footprint.test.ts
-		* Est. overflow 37 -> 21 = butterfly 64 -> 32 slots = 738B -> 450B;
-		* reusing the app as its program identity brings the current cell to ~386B.
-		**/
+		const scopeChild = Elysia.#nextScopeChild;
+		Elysia.#nextScopeChild = void 0;
 		this["~config"] = config;
 		this["~ext"] = void 0;
 		this["~hookChain"] = void 0;
@@ -212,8 +178,7 @@ var Elysia = class Elysia {
 		this["~aotFingerprint"] = void 0;
 		this["~compilerSession"] = void 0;
 		this["~generation"] = void 0;
-		this["~introspect"] = void 0;
-		this["~scopeChild"] = void 0;
+		this["~scopeChild"] = scopeChild;
 		this["~scopeChildren"] = void 0;
 		if (config) {
 			const { prefix, name, seed, adapter } = config;
@@ -222,18 +187,12 @@ var Elysia = class Elysia {
 			if (adapter?.setup) this.#useFn(adapter.setup);
 		} else this["~Prefix"] = void 0;
 	}
-	/**
-	* Every registered route with its merged hooks.
-	* Development shares a frozen cache.
-	* Production rebuilds the list on every read
-	* so its metadata can be released after startup.
-	*/
 	get routes() {
 		const generation = this["~generation"];
 		if (this.#isCacheable && this.cachedGeneration === generation && this.cachedEpoch === mutationEpoch && this.cachedRoutes !== void 0) return this.cachedRoutes;
-		if (this.declaredRoutes === void 0 && this["~routeTable"]?.length) this.#materializeDeclaredRoutes();
-		if (!this.declaredRoutes?.length) return [];
-		const routes = this["~routes"].map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
+		const declared = this["~routes"];
+		if (!declared.length) return [];
+		const routes = declared.map(([method, path, handler, instance, hook, appHook, inheritedChain, macroScope]) => {
 			const merged = require_compile_handler_index.composeRouteHook(instance, hook, appHook, inheritedChain, this, macroScope);
 			require_compile_handler_index.runIntrospect(merged);
 			if (merged?.schemas?.length) for (const entry of merged.schemas) {
@@ -346,7 +305,7 @@ var Elysia = class Elysia {
 			parent,
 			refs,
 			scope,
-			owner: this,
+			owner: this["~scopeChild"] ? this : void 0,
 			origin: this.hash
 		};
 	}
@@ -369,20 +328,6 @@ var Elysia = class Elysia {
 		parsers[name] = fn;
 		return 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) {
 		this.#assertMutable("setup");
 		(this.#ext.setup ??= []).push(...[].concat(handler));
@@ -421,7 +366,7 @@ var Elysia = class Elysia {
 		this.#assertMutable("error");
 		switch (arguments.length) {
 			case 1:
-				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object") return this;
+				if (scopeOrFnOrError && typeof scopeOrFnOrError === "object" && !Array.isArray(scopeOrFnOrError)) throw new Error("[Elysia] .error({ CODE: Class }) was removed in 2.0 — use .error(Class, handler)");
 				return this.#onBranch("error", scopeOrFnOrError);
 			case 2:
 				if (typeof scopeOrFnOrError === "function" && scopeOrFnOrError.prototype instanceof Object) return this.#onErrorClass(scopeOrFnOrError, fnOrError);
@@ -482,14 +427,15 @@ var Elysia = class Elysia {
 		const run = arguments[2];
 		const isSchema = typeof schemaOrRun === "object";
 		const callback = isSchema ? run : schemaOrRun;
-		const child = new Elysia(this["~config"] || prefix ? {
+		const config = this["~config"] || prefix ? {
 			...this["~config"],
 			name: void 0,
 			seed: void 0,
 			as: void 0,
 			prefix
-		} : void 0);
-		child["~scopeChild"] = true;
+		} : void 0;
+		Elysia.#nextScopeChild = true;
+		const child = new Elysia(config);
 		child.scopeParent = this;
 		(this["~scopeChildren"] ??= []).push(child);
 		const src = this["~ext"];
@@ -512,7 +458,6 @@ var Elysia = class Elysia {
 	get #ext() {
 		return this["~ext"] ??= require_utils.nullObject();
 	}
-	/** A group child starts or takes up its parent's table, see `group()` */
 	#table(field) {
 		return this.#ext[field] ??= this.scopeParent ? this.scopeParent.#table(field) : require_utils.nullObject();
 	}
@@ -710,9 +655,7 @@ var Elysia = class Elysia {
 	}
 	#use(app) {
 		let addedByThisCall;
-		const config = app["~config"];
-		if (app["~introspect"] || config?.introspect) this["~introspect"] = true;
-		const name = config?.name;
+		const name = app["~config"]?.name;
 		if (name) {
 			const hash = app.hash;
 			if (this.childrenHash?.has(hash)) return;
@@ -745,10 +688,6 @@ var Elysia = class Elysia {
 		}
 		return addedByThisCall;
 	}
-	/**
-	* Reject a second, unrelated definition of an already-registered macro.
-	* Split out of `#use` for the same reason as `#absorbExt`.
-	*/
 	#assertMacroUnique(app, addedByThisCall) {
 		const incomingMacro = app["~ext"]?.macro;
 		const existingMacro = this["~ext"]?.macro;
@@ -763,14 +702,6 @@ var Elysia = class Elysia {
 			throw new Error(`[Elysia] Macro "${macroName}" can be only define once`);
 		}
 	}
-	/**
-	* Merge the absorbed app's `~ext` container into this one.
-	*
-	* `#use` needed a frame wide enoughfor every local in this block + `#propagateHooks`
-	* JSC pays that width on *entry*, before a single field is read
-	*
-	* Keep the cold blocks in their own frames.
-	*/
 	#absorbExt(app, addedByThisCall) {
 		const source = app["~ext"];
 		const { decorator, store, headers, models, parser, macro, hoc, setup, cleanup, capability } = source;
@@ -857,10 +788,6 @@ var Elysia = class Elysia {
 			}
 		}
 	}
-	/**
-	* Republish the absorbed app's plugin/global hooks onto this instance's chain.
-	* Split out from #use, see #absorbExt
-	*/
 	#propagateHooks(app, hookChain, addedByThisCall) {
 		const nodes = useNodesBuffer;
 		nodes.length = 0;
@@ -920,7 +847,7 @@ var Elysia = class Elysia {
 				delete added.schema;
 				if (dropRequest) delete added.request;
 			}
-			if (require_utils.isNotEmpty(added)) this.#pushChainNode(added, scope, registration, origin, app);
+			if (require_utils.isNotEmpty(added)) this.#pushChainNode(added, scope, registration, origin, scopeChild ? app : void 0);
 		}
 		if (lifting) liftedRequests.set(this, lifting);
 		nodes.length = 0;
@@ -1090,10 +1017,6 @@ var Elysia = class Elysia {
 		if (this["~generation"] === void 0) return;
 		throw new Error(`[Elysia] .${api}() called after the app was sealed by its first request, listen or compile`);
 	}
-	/**
-	* `#assertMutable` for the tables a group child shares with its parents:
-	* a child kept past its callback must not write into a sealed one
-	*/
 	#assertTableMutable(api) {
 		for (let app = this; app; app = app.scopeParent) app.#assertMutable(api);
 	}
@@ -1151,9 +1074,6 @@ var Elysia = class Elysia {
 				return this;
 		}
 	}
-	/**
-	* Registered reusable models (via `.model()`), keyed by name.
-	*/
 	get models() {
 		return this["~ext"]?.models ?? this.scopeParent?.models ?? require_utils.nullObject();
 	}
@@ -1245,10 +1165,6 @@ var Elysia = class Elysia {
 			OPTIONS: void 0
 		};
 	}
-	/**
-	* Force all route handlers to compile immediately (sets `precompile: true`
-	* on the config and triggers a fresh build of the fetch handler).
-	*/
 	compile() {
 		this["~config"] ??= require_utils.nullObject();
 		this["~config"].precompile = true;
@@ -1567,14 +1483,17 @@ var Elysia = class Elysia {
 				break;
 			}
 		}
-		if (hasTypeBoxSchema) try {
-			require_type_bridge.warmTypebox();
-		} catch {}
 		let markDuplicates = false;
+		let eager = false;
 		if (length) {
 			const programId = this["~programId"];
 			if (!require_compile_aot.Compiled.claim(programId, this["~aotFingerprint"] = require_compile_aot.createAotFingerprint())) require_compile_aot.Compiled.assertUncontested(programId);
 			markDuplicates = require_compile_aot.Compiled.hasProgram(programId) || precompile !== true && require_universal_is_production.isProduction() && !require_compile_aot.Capture.isAotBuildEnv();
+			if (hasTypeBoxSchema) try {
+				require_type_bridge.warmTypebox();
+			} catch {
+				if (!require_type_bridge.isBridgeLive() && !require_compile_aot.Compiled.hasProgram(programId)) eager = markDuplicates = true;
+			}
 		}
 		const isLoose = this["~config"]?.strictPath !== true;
 		const collectExplicit = isLoose && table.hasLoose;
@@ -1624,7 +1543,7 @@ var Elysia = class Elysia {
 				}
 				continue;
 			}
-			const lazy = !precompile && !this.compiled?.[i];
+			const lazy = (eager ? (routeFlags & require_route_table.RouteFlag.ExactDuplicate) !== 0 : !precompile) && !this.compiled?.[i];
 			if (lazy) {
 				this.compiled ??= new Array(length);
 				this.jitTable = table;
@@ -1634,14 +1553,14 @@ var Elysia = class Elysia {
 			const registerLoose = isLoose && canRegisterLoose(routePath, isDynamic);
 			if (!isDynamic && !needsEncode && !registerLoose) {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
-				map[routePath] = lazy ? ~i : this.handler(i, precompile, void 0, void 0, table);
+				map[routePath] = lazy ? ~i : this.handler(i, true, void 0, void 0, table);
 				continue;
 			}
 			const paths = expandPaths(routePath, needsEncode, registerLoose, registerLoose ? explicitPaths?.get(routeMethod) : void 0);
 			if (isDynamic) {
 				if (require_utils.isHTMLBundle(table.handler[i])) continue;
 				const router = this["~router"] ??= new memoirist.default({ loosePath: isLoose });
-				const store = lazy ? i : this.handler(i, precompile, void 0, void 0, table);
+				const store = lazy ? i : this.handler(i, true, void 0, void 0, table);
 				for (let p = 0; p < paths.length; p++) router.add(routeMethod, paths[p], store);
 			} else {
 				const map = methods[routeMethod] ??= require_utils.nullObject();
@@ -1649,7 +1568,7 @@ var Elysia = class Elysia {
 					method: routeMethod,
 					paths
 				};
-				const handler = lazy ? ~i : this.handler(i, precompile, void 0, void 0, table);
+				const handler = lazy ? ~i : this.handler(i, true, void 0, void 0, table);
 				for (let p = 0; p < paths.length; p++) map[paths[p]] = handler;
 			}
 		}
@@ -1680,21 +1599,6 @@ var Elysia = class Elysia {
 		if (!require_compile_aot.Capture.isAotBuildEnv()) listen(this, options, callback);
 		return this;
 	}
-	/**
-	* Add a higher order function over Elysia.fetch
-	*
-	* @example
-	* ```ts
-	* const ctx = new AsyncLocalStorage<{ counter: number }>()
-	*
-	* new Elysia()
-	*	.wrap(
-	*		(fetch) => (request, ...rest) =>
-	*			ctx.run({ counter: 0 }, () => fetch(request, ...rest))
-	*	)
-	*	.get('/', () => ctx.getStore())
-	* ```
-	*/
 	wrap(callback) {
 		this.#assertMutable("wrap");
 		if (this.fetchFn && !this.#pending) console.warn("[Elysia] .wrap() was called after the fetch handler was built");
@@ -1703,34 +1607,12 @@ var Elysia = class Elysia {
 		(ext.hocOrigin ??= []).push(this.hash ?? {});
 		return this;
 	}
-	/**
-	* ### cleanup | Life cycle event
-	* Called after server stop serving request
-	*
-	* ---
-	* @example
-	* ```typescript
-	* new Elysia()
-	*     .cleanup((app) => {
-	*         closeDatabase()
-	*     })
-	* ```
-	*/
 	cleanup(handler) {
 		if (this["~ext"]?.cleanupEpoch?.(handler)) return this;
 		this.#assertMutable("cleanup");
 		(this.#ext.cleanup ??= []).push(...[].concat(handler));
 		return this;
 	}
-	/**
-	* Stop the underlying server (if any), then run every `cleanup` handler
-	*
-	* Awaiting `stop()` from inside a `setup`, `cleanup` or WebSocket lifecycle
-	* callback is only supported while that callback is still synchronous
-	*
-	* @param closeActiveConnections Pass `true` to terminate active
-	*   transports. Omit (or pass `false`) to drain safely.
-	*/
 	stop(closeActiveConnections) {
 		const stop = this["~ext"]?.stop;
 		if (stop) return stop(closeActiveConnections);