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

package/dist/base.js

@@ -5,34 +5,19 @@ const require_constants = require('./constants.js');
 const require_utils = require('./utils.js');
 const require_type_bridge = require('./type/bridge.js');
 const require_universal_env = require('./universal/env.js');
+const require_compile_aot = require('./compile/aot.js');
+const require_compile_handler_index = require('./compile/handler/index.js');
 const require_ws_route = require('./ws/route.js');
 const require_adapter_bun_index = require('./adapter/bun/index.js');
 const require_handler_fetch = require('./handler/fetch.js');
-const require_compile_handler_index = require('./compile/handler/index.js');
 let memoirist = require("memoirist");
 memoirist = require_runtime.__toESM(memoirist);
 
 //#region src/base.ts
 const useNodesBuffer = [];
-const isPlainObject = (v) => {
-	if (!v || typeof v !== "object" || Array.isArray(v)) return false;
-	const proto = Object.getPrototypeOf(v);
-	return proto === Object.prototype || proto === null;
-};
-function clonePlainDecorators(source, seen = /* @__PURE__ */ new WeakMap()) {
-	const existing = seen.get(source);
-	if (existing) return existing;
-	const out = require_utils.nullObject();
-	seen.set(source, out);
-	for (const key in source) {
-		const value = source[key];
-		out[key] = isPlainObject(value) ? clonePlainDecorators(value, seen) : value;
-	}
-	return out;
-}
 var Elysia = class Elysia {
-	#hasPlugin = false;
-	#hasGlobal = false;
+	#hasPlugin;
+	#hasGlobal;
 	#ready;
 	#pending = 0;
 	#error;
@@ -53,6 +38,7 @@ var Elysia = class Elysia {
 	}
 	#compiled;
 	#cachedRoutes;
+	#hasMapResponse;
 	constructor(config) {
 		this["~config"] = config;
 		this["~Prefix"] = config?.prefix;
@@ -173,23 +159,8 @@ var Elysia = class Elysia {
 	#onBranch(type, scopeOrFn, fn) {
 		return fn ? this.#on(type, fn, scopeOrFn) : this.#on(type, scopeOrFn);
 	}
-	on(...args) {
-		if (args.length === 2) {
-			const [event, fn] = args;
-			if (event === "parse" && typeof fn === "string") {
-				const named = this["~ext"]?.parser?.[fn];
-				return this.#onBranch("parse", named ?? fn);
-			}
-			return this.#onBranch(event, fn);
-		}
-		if (args.length === 3) {
-			const [scope, event, fn] = args;
-			return this.#onBranch(event, scope, fn);
-		}
-		return this;
-	}
-	request(scopeOrFn, fn) {
-		return this.#onBranch("request", scopeOrFn, fn);
+	request(fn) {
+		return this.#on("request", fn, "global");
 	}
 	parse(scopeOrFnOrName, fn) {
 		if (fn === void 0 && typeof scopeOrFnOrName === "string") {
@@ -204,10 +175,24 @@ var Elysia = class Elysia {
 		parsers[name] = fn;
 		return this;
 	}
-	onStart(_listener) {
-		return this;
-	}
-	onStop(_listener) {
+	/**
+	* ### 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) {
+		const arr = this.#ext.setup ??= [];
+		if (Array.isArray(handler)) arr.push(...handler);
+		else arr.push(handler);
 		return this;
 	}
 	transform(scopeOrFn, fn) {
@@ -228,6 +213,7 @@ var Elysia = class Elysia {
 		return this.#onBranch("afterHandle", scopeOrFn, fn);
 	}
 	mapResponse(scopeOrFn, fn) {
+		this.#hasMapResponse = true;
 		return this.#onBranch("mapResponse", scopeOrFn, fn);
 	}
 	afterResponse(scopeOrFn, fn) {
@@ -289,15 +275,7 @@ var Elysia = class Elysia {
 		}
 	}
 	guard() {
-		if (arguments.length === 1) {
-			const arg = arguments[0];
-			let scope = "local";
-			if (arg && typeof arg === "object" && "as" in arg && arg.as) {
-				scope = arg.as;
-				delete arg.as;
-			}
-			return this.#guard(scope, arg);
-		}
+		if (arguments.length === 1) return this.#guard("local", arguments[0]);
 		if (arguments.length === 2) {
 			if (typeof arguments[1] === "function") return this.group("", arguments[0], arguments[1]);
 			return this.#guard(arguments[0], arguments[1]);
@@ -354,9 +332,8 @@ var Elysia = class Elysia {
 		const finalize = () => {
 			const childFlat = require_utils.flattenChain(child["~hookChain"]);
 			const lifted = require_utils.nullObject();
-			if (childFlat?.request) lifted.request = childFlat.request;
 			if (childFlat?.parse) lifted.parse = childFlat.parse;
-			if (lifted.request || lifted.parse) this.#pushHook(lifted);
+			if (lifted.parse) this.#pushHook(lifted);
 			return child;
 		};
 		if (child.pending) return this.#useAsync(child.modules.then(finalize));
@@ -394,7 +371,7 @@ var Elysia = class Elysia {
 		return this;
 	}
 	macro(macro) {
-		if (typeof macro === "function") throw new Error("Use `.macro({ name: fn })` instead of `.macro(fn)`");
+		if (typeof macro === "function") throw new Error("use `.macro({ name: fn })` instead of `.macro(fn)`");
 		const ext = this.#ext;
 		const m = ext.macro ??= require_utils.nullObject();
 		for (const key in macro) if (typeof macro[key] === "object") macro[key] = require_utils.hookToGuard(macro[key]);
@@ -490,7 +467,8 @@ var Elysia = class Elysia {
 			for (const plugin of app) this.#use(plugin);
 			return this;
 		}
-		if (app !== this && app.pending) return this.#useAsync(app.modules.then(() => app));
+		if (app === this) return this;
+		if (app.pending) return this.#useAsync(app.modules.then(() => app));
 		this.#use(app);
 		return this;
 	}
@@ -556,11 +534,12 @@ var Elysia = class Elysia {
 			}
 		}
 		const hookChain = app["~hookChain"];
+		if (!this.#hasMapResponse && app.#hasMapResponse) this.#hasMapResponse = true;
 		if (app["~ext"]) {
-			const { decorator, store, headers, models, parser, macro, error, hoc } = app["~ext"];
+			const { decorator, store, headers, models, parser, macro, error, hoc, setup, cleanup } = app["~ext"];
 			const ext = this["~ext"] ??= require_utils.nullObject();
 			if (decorator) {
-				const cloned = clonePlainDecorators(decorator);
+				const cloned = require_utils.clonePlainDecorators(decorator);
 				if (ext.decorator) require_utils.mergeDeep(ext.decorator, cloned);
 				else ext.decorator = Object.assign(require_utils.nullObject(), cloned);
 			}
@@ -579,6 +558,12 @@ var Elysia = class Elysia {
 			if (hoc) if (ext.hoc) {
 				for (const fn of hoc) if (!ext.hoc.includes(fn)) ext.hoc.push(fn);
 			} else ext.hoc = hoc.slice();
+			if (setup) if (ext.setup) {
+				for (const fn of setup) if (!ext.setup.includes(fn)) ext.setup.push(fn);
+			} else ext.setup = setup.slice();
+			if (cleanup) if (ext.cleanup) {
+				for (const fn of cleanup) if (!ext.cleanup.includes(fn)) ext.cleanup.push(fn);
+			} else ext.cleanup = cleanup.slice();
 		}
 		if (app.#hasPlugin || app.#hasGlobal || hookChain) {
 			let pluginEvents;
@@ -829,18 +814,23 @@ var Elysia = class Elysia {
 	}
 	#initMap() {
 		this["~map"] ??= {
-			GET: require_utils.nullObject(),
-			POST: require_utils.nullObject(),
-			PUT: require_utils.nullObject(),
-			DELETE: require_utils.nullObject(),
-			PATCH: require_utils.nullObject(),
-			HEAD: require_utils.nullObject(),
-			OPTIONS: require_utils.nullObject()
+			GET: void 0,
+			POST: void 0,
+			PUT: void 0,
+			DELETE: void 0,
+			PATCH: void 0,
+			HEAD: void 0,
+			OPTIONS: void 0
 		};
 	}
 	compile() {
 		this["~config"] ??= require_utils.nullObject();
 		this["~config"].precompile = true;
+		this.#routerBuilt = false;
+		if (require_compile_aot.Capture.isCapturing()) {
+			this.#compiled = void 0;
+			this.#fetchFn = void 0;
+		}
 		this.fetch;
 		return this;
 	}
@@ -867,6 +857,7 @@ var Elysia = class Elysia {
 		};
 	}
 	#saveHandler(method, path, handler) {
+		if (require_constants.isDynamicRegex.test(path)) return;
 		this.#initMap();
 		const map = this["~map"][require_utils.mapMethodBack(method)] ??= require_utils.nullObject();
 		map[path] = handler;
@@ -911,9 +902,9 @@ var Elysia = class Elysia {
 			for (let i = 0; i < length; i++) if (require_utils.mapMethodBack(this.#history[i][0]) === "HEAD") (explicitHead ??= /* @__PURE__ */ new Set()).add(this.#history[i][1]);
 		}
 		const wrapHeadHandler = Elysia.#wrapHeadHandler;
-		const strict = !!this["~config"]?.strictPath;
+		const preferLoosePath = this["~config"]?.strictPath !== true;
 		let explicitPaths;
-		if (!strict) {
+		if (preferLoosePath && this["~config"]?.distinctPath) {
 			explicitPaths = /* @__PURE__ */ new Map();
 			for (let i = 0; i < length; i++) {
 				const route = this.#history[i];
@@ -936,7 +927,7 @@ var Elysia = class Elysia {
 				const ws = require_ws_route.buildWSRoute(route, this);
 				const handler = ws[0];
 				const options = ws[1];
-				if (require_constants.isDynamicRegex.test(path)) (this["~router"] ??= new memoirist.default()).add("WS", path, handler, false);
+				if (require_constants.isDynamicRegex.test(path)) (this["~router"] ??= new memoirist.default({ loosePath: preferLoosePath })).add("WS", path, handler, false);
 				else {
 					this.#initMap();
 					const wsMap = this["~map"]["WS"] ??= require_utils.nullObject();
@@ -963,51 +954,70 @@ var Elysia = class Elysia {
 			let staticResponse;
 			const maybeStatic = buildStatic && typeof route[2] !== "function";
 			if (maybeStatic) {
-				staticResponse = require_compile_handler_index.buildNativeStaticResponse(route, this);
+				staticResponse = require_compile_handler_index.buildNativeStaticResponse(route, this, this.#hasMapResponse);
 				if (staticResponse) {
-					const target = this["~staticResponse"] ??= require_utils.nullObject();
-					(target[path] ??= require_utils.nullObject())[method] = staticResponse;
+					const target = this["~staticResponse"] ??= {
+						GET: void 0,
+						POST: void 0,
+						PUT: void 0,
+						DELETE: void 0,
+						PATCH: void 0,
+						HEAD: void 0,
+						OPTIONS: void 0
+					};
+					(target[method] ??= require_utils.nullObject())[path] = staticResponse;
 					if (!this["~config"]?.strictPath) {
 						const loose = require_utils.getLoosePath(path);
-						if (!explicitPaths?.get(method)?.has(loose)) (target[loose] ??= require_utils.nullObject())[method] = staticResponse;
+						if (!explicitPaths?.get(method)?.has(loose)) (target[method] ??= require_utils.nullObject())[loose] = staticResponse;
 					}
 				}
 			}
 			const sharedStatic = maybeStatic && staticResponse instanceof Response ? staticResponse : void 0;
 			const autoHead = enableAutoHead && method === "GET" && !explicitHead?.has(path);
-			const registerPattern = (registerMain, registerHead, handler, headHandler, registerLoose) => {
-				const explicitMain = explicitPaths?.get(method);
-				const add = (p) => {
-					registerMain(p, handler);
-					if (headHandler) registerHead(p, headHandler);
-					if (registerLoose) {
-						const loose = require_utils.getLoosePath(p);
-						if (loose !== p && !explicitMain?.has(loose)) {
-							registerMain(loose, handler);
-							if (headHandler) registerHead(loose, headHandler);
-						}
-					}
-				};
-				add(path);
-				if (require_constants.needEncodeRegex.test(path)) {
-					const encoded = encodeURI(path);
-					if (encoded !== path) add(encoded);
+			const isDynamic = require_constants.isDynamicRegex.test(path);
+			const registerLoose = !isDynamic && preferLoosePath && (path.length === 0 || path.charCodeAt(path.length - 1) === 47);
+			const explicitMain = registerLoose ? explicitPaths?.get(method) : void 0;
+			if (!isDynamic && !require_constants.needEncodeRegex.test(path) && !registerLoose) {
+				const map = methods[method] ??= require_utils.nullObject();
+				const handler = this.handler(i, precompile, route, sharedStatic);
+				map[path] = handler;
+				if (autoHead) {
+					const head = methods["HEAD"] ??= require_utils.nullObject();
+					head[path] = wrapHeadHandler(handler);
 				}
-			};
-			if (require_constants.isDynamicRegex.test(path)) {
-				const router = this["~router"] ??= new memoirist.default();
+				continue;
+			}
+			const variants = [path];
+			if (require_constants.needEncodeRegex.test(path)) {
+				const encoded = encodeURI(path);
+				if (encoded !== path) variants.push(encoded);
+			}
+			const paths = [];
+			for (let v = 0; v < variants.length; v++) {
+				const p = variants[v];
+				paths.push(p);
+				if (registerLoose) {
+					const loose = require_utils.getLoosePath(p);
+					if (loose !== p && !explicitMain?.has(loose)) paths.push(loose);
+				}
+			}
+			if (isDynamic) {
+				const router = this["~router"] ??= new memoirist.default({ loosePath: preferLoosePath });
 				const handler = this.handler(i, precompile, void 0, sharedStatic);
-				registerPattern((p, h) => router.add(method, p, h, false), (p, h) => router.add("HEAD", p, h, false), handler, autoHead ? wrapHeadHandler(handler) : void 0, false);
+				const headHandler = autoHead ? wrapHeadHandler(handler) : void 0;
+				for (let p = 0; p < paths.length; p++) {
+					router.add(method, paths[p], handler, false);
+					if (headHandler) router.add("HEAD", paths[p], headHandler, false);
+				}
 			} else {
 				const map = methods[method] ??= require_utils.nullObject();
 				const handler = this.handler(i, precompile, route, sharedStatic);
 				const headHandler = autoHead ? wrapHeadHandler(handler) : void 0;
 				const head = autoHead ? methods["HEAD"] ??= require_utils.nullObject() : void 0;
-				registerPattern((p, h) => {
-					map[p] = h;
-				}, (p, h) => {
-					head[p] = h;
-				}, handler, headHandler, !strict);
+				for (let p = 0; p < paths.length; p++) {
+					map[paths[p]] = handler;
+					if (headHandler) head[paths[p]] = headHandler;
+				}
 			}
 		}
 	}
@@ -1032,13 +1042,33 @@ var Elysia = class Elysia {
 		return this;
 	}
 	wrap(callback) {
-		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built, so it will not take effect. Register .wrap() before .listen() or before accessing .fetch/.handle.");
+		if (this.#fetchFn) console.warn("[Elysia] .wrap() was called after the fetch handler was built");
 		const ext = this.#ext;
 		(ext.hoc ??= []).push(callback);
 		return 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) {
+		const arr = this.#ext.cleanup ??= [];
+		if (Array.isArray(handler)) arr.push(...handler);
+		else arr.push(handler);
+		return 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
@@ -1049,6 +1079,12 @@ var Elysia = class Elysia {
 		if (!server) return;
 		const r = server.stop?.(closeActiveConnections);
 		this.server = void 0;
+		const handlers = this["~ext"]?.cleanup;
+		const fire = handlers ? () => {
+			for (let i = 0; i < handlers.length; i++) handlers[i](this);
+		} : void 0;
+		if (r && typeof r.then === "function") return fire ? r.then(fire) : r;
+		fire?.();
 		return r;
 	}
 };