elysia 1.4.28 → 2.0.0-beta.0

package/dist/adapter/bun/index.js

@@ -1,382 +1,221 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: !0 });
-}, __copyProps = (to, from, except, desc) => {
-  if (from && typeof from == "object" || typeof from == "function")
-    for (let key of __getOwnPropNames(from))
-      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  return to;
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_adapter_index = require('../index.js');
+const require_constants = require('../../constants.js');
+const require_utils = require('../../utils.js');
+const require_adapter_web_standard_index = require('../web-standard/index.js');
+const require_generation = require('../../generation.js');
+const require_adapter_origin = require('../origin.js');
+const require_compile_handler_index = require('../../compile/handler/index.js');
+const require_route_table = require('../../route-table.js');
+
+//#region src/adapter/bun/index.ts
+/**
+* ! This may looks like it would cause race condition, but it is not
+* Bun is single-threaded and synchronous, so the `finally` block will
+* always run before the next request comes in
+* @see ../origin.ts
+*
+* `finally` runs on the synchronous return of `fetch` (the returned promise is
+* not awaited), so the slot is live only for the handler's synchronous prologue
+*/
+const withOrigin = (fetch) => (request, server) => {
+	require_adapter_origin.origin.request = request;
+	try {
+		return fetch(request, server);
+	} finally {
+		require_adapter_origin.origin.request = void 0;
+	}
 };
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var bun_exports = {};
-__export(bun_exports, {
-  BunAdapter: () => BunAdapter,
-  isHTMLBundle: () => isHTMLBundle,
-  removeTrailingPath: () => removeTrailingPath
-});
-module.exports = __toCommonJS(bun_exports);
-var import_web_standard = require('../web-standard/index.js'), import_utils = require('../utils.js'), import_compose = require('./compose.js'), import_handler_native = require('./handler-native.js'), import_cookies = require('../../cookies.js'), import_error = require('../../error.js'), import_schema = require('../../schema.js'), import_utils2 = require('../../utils.js'), import_handler = require('./handler.js'), import_ws = require('../../ws/index.js');
-const optionalParam = /:.+?\?(?=\/|$)/, getPossibleParams = (path) => {
-  const match = optionalParam.exec(path);
-  if (!match) return [path];
-  const routes = [], head = path.slice(0, match.index), param = match[0].slice(0, -1), tail = path.slice(match.index + match[0].length);
-  routes.push(head.slice(0, -1)), routes.push(head + param);
-  for (const fragment of getPossibleParams(tail))
-    fragment && (fragment.startsWith("/:") || routes.push(head.slice(0, -1) + fragment), routes.push(head + param + fragment));
-  return routes;
-}, isHTMLBundle = (handle) => typeof handle == "object" && handle !== null && (handle.toString() === "[object HTMLBundle]" || typeof handle.index == "string"), supportedMethods = {
-  GET: !0,
-  HEAD: !0,
-  OPTIONS: !0,
-  DELETE: !0,
-  PATCH: !0,
-  POST: !0,
-  PUT: !0
-}, mapRoutes = (app) => {
-  if (!app.config.aot || app.config.systemRouter === !1) return;
-  const routes = {}, add = (route, handler) => {
-    const path = encodeURI(route.path);
-    routes[path] ? routes[path][route.method] || (routes[path][route.method] = handler) : routes[path] = {
-      [route.method]: handler
-    };
-  }, tree = app.routeTree;
-  for (const route of app.router.history) {
-    if (typeof route.handler != "function") continue;
-    const method = route.method;
-    if (method === "GET" && `WS_${route.path}` in tree || method === "WS" || route.path.charCodeAt(route.path.length - 1) === 42 || !(method in supportedMethods))
-      continue;
-    if (method === "ALL") {
-      `WS_${route.path}` in tree || (routes[route.path] = route.hooks?.config?.mount ? route.hooks.trace || app.event.trace || // @ts-expect-error private property
-      app.extender.higherOrderFunctions ? (0, import_compose.createBunRouteHandler)(app, route) : route.hooks.mount || route.handler : route.handler);
-      continue;
-    }
-    let compiled;
-    const handler = app.config.precompile ? (0, import_compose.createBunRouteHandler)(app, route) : (request) => compiled ? compiled(request) : (compiled = (0, import_compose.createBunRouteHandler)(app, route))(
-      request
-    );
-    for (const path of getPossibleParams(route.path))
-      add(
-        {
-          method,
-          path
-        },
-        handler
-      );
-  }
-  return routes;
-}, mergeRoutes = (r1, r2) => {
-  if (!r2) return r1;
-  for (const key of Object.keys(r2))
-    if (r1[key] !== r2[key]) {
-      if (!r1[key]) {
-        r1[key] = r2[key];
-        continue;
-      }
-      if (r1[key] && r2[key]) {
-        if (typeof r1[key] == "function" || r1[key] instanceof Response) {
-          r1[key] = r2[key];
-          continue;
-        }
-        r1[key] = {
-          ...r1[key],
-          ...r2[key]
-        };
-      }
-    }
-  return r1;
-}, removeTrailingPath = (routes) => {
-  for (const key of Object.keys(routes))
-    key.length > 1 && key.charCodeAt(key.length - 1) === 47 && (routes[key.slice(0, -1)] = routes[key], delete routes[key]);
-  return routes;
-}, BunAdapter = {
-  ...import_web_standard.WebStandardAdapter,
-  name: "bun",
-  handler: {
-    mapResponse: import_handler.mapResponse,
-    mapEarlyResponse: import_handler.mapEarlyResponse,
-    mapCompactResponse: import_handler.mapCompactResponse,
-    createStaticHandler: import_handler.createStaticHandler,
-    createNativeStaticHandler: import_handler_native.createNativeStaticHandler
-  },
-  composeHandler: {
-    ...import_web_standard.WebStandardAdapter.composeHandler,
-    headers: import_utils2.hasHeaderShorthand ? `c.headers=c.request.headers.toJSON()
-` : `c.headers={}
-for(const [k,v] of c.request.headers.entries())c.headers[k]=v
-`
-  },
-  listen(app) {
-    return (options, callback) => {
-      if (typeof Bun > "u")
-        throw new Error(
-          ".listen() is designed to run on Bun only. If you are running Elysia in other environment please use a dedicated plugin or export the handler via Elysia.fetch"
-        );
-      if (app.compile(), typeof options == "string") {
-        if (!(0, import_utils2.isNumericString)(options))
-          throw new Error("Port must be a numeric value");
-        options = parseInt(options);
-      }
-      const createStaticRoute = (iterator, { withAsync = !1 } = {}) => {
-        const staticRoutes = {}, ops = [];
-        for (let [path, route] of Object.entries(iterator))
-          if (path = encodeURI(path), import_utils2.supportPerMethodInlineHandler) {
-            if (!route) continue;
-            for (const [method, value] of Object.entries(route))
-              if (!(!value || !(method in supportedMethods))) {
-                if (value instanceof Promise) {
-                  withAsync && (staticRoutes[path] || (staticRoutes[path] = {}), ops.push(
-                    value.then((awaited) => {
-                      awaited instanceof Response && (staticRoutes[path][method] = awaited), isHTMLBundle(awaited) && (staticRoutes[path][method] = awaited);
-                    })
-                  ));
-                  continue;
-                }
-                !(value instanceof Response) && !isHTMLBundle(value) || (staticRoutes[path] || (staticRoutes[path] = {}), staticRoutes[path][method] = value);
-              }
-          } else {
-            if (!route) continue;
-            if (route instanceof Promise) {
-              withAsync && (staticRoutes[path] || (staticRoutes[path] = {}), ops.push(
-                route.then((awaited) => {
-                  awaited instanceof Response && (staticRoutes[path] = awaited);
-                })
-              ));
-              continue;
-            }
-            if (!(route instanceof Response)) continue;
-            staticRoutes[path] = route;
-          }
-        return withAsync ? Promise.all(ops).then(() => staticRoutes) : staticRoutes;
-      }, routes = removeTrailingPath(
-        mergeRoutes(
-          mergeRoutes(
-            createStaticRoute(app.router.response),
-            mapRoutes(app)
-          ),
-          // @ts-ignore
-          app.config.serve?.routes
-        )
-      ), serve = typeof options == "object" ? {
-        development: !import_error.isProduction,
-        reusePort: !0,
-        idleTimeout: 30,
-        ...app.config.serve || {},
-        ...options || {},
-        routes,
-        websocket: {
-          ...app.config.websocket || {},
-          ...import_ws.websocket || {},
-          ...options.websocket || {}
-        },
-        fetch: app.fetch
-      } : {
-        development: !import_error.isProduction,
-        reusePort: !0,
-        idleTimeout: 30,
-        ...app.config.serve || {},
-        routes,
-        websocket: {
-          ...app.config.websocket || {},
-          ...import_ws.websocket || {}
-        },
-        port: options,
-        fetch: app.fetch
-      };
-      if (app.server = Bun.serve(serve), app.event.start)
-        for (let i = 0; i < app.event.start.length; i++)
-          app.event.start[i].fn(app);
-      callback && callback(app.server), process.on("beforeExit", async () => {
-        if (app.server && (await app.server.stop?.(), app.server = null, app.event.stop))
-          for (let i = 0; i < app.event.stop.length; i++)
-            app.event.stop[i].fn(app);
-      }), app.promisedModules.then(async () => {
-        app.config.aot, app.compile();
-        const routes2 = removeTrailingPath(
-          mergeRoutes(
-            mergeRoutes(
-              await createStaticRoute(app.router.response, {
-                withAsync: !0
-              }),
-              mapRoutes(app)
-            ),
-            // @ts-ignore
-            app.config.serve?.routes
-          )
-        );
-        app.server?.reload({
-          ...serve,
-          fetch: app.fetch,
-          // @ts-ignore
-          routes: routes2
-        }), Bun?.gc(!1);
-      });
-    };
-  },
-  async stop(app, closeActiveConnections) {
-    if (app.server) {
-      if (await app.server.stop(closeActiveConnections), app.server = null, app.event.stop?.length)
-        for (let i = 0; i < app.event.stop.length; i++)
-          app.event.stop[i].fn(app);
-    } else
-      console.log(
-        "Elysia isn't running. Call `app.listen` to start the server.",
-        new Error().stack
-      );
-  },
-  ws(app, path, options) {
-    const { parse, body, response, ...rest } = options, messageValidator = (0, import_schema.getSchemaValidator)(body, {
-      // @ts-expect-error private property
-      modules: app.definitions.typebox,
-      // @ts-expect-error private property
-      models: app.definitions.type,
-      normalize: app.config.normalize
-    }), validateMessage = messageValidator ? messageValidator.provider === "standard" ? (data) => messageValidator.schema["~standard"].validate(data).issues : (data) => messageValidator.Check(data) === !1 : void 0, responseValidator = (0, import_schema.getSchemaValidator)(response, {
-      // @ts-expect-error private property
-      modules: app.definitions.typebox,
-      // @ts-expect-error private property
-      models: app.definitions.type,
-      normalize: app.config.normalize
-    });
-    app.route(
-      "WS",
-      path,
-      async (context) => {
-        const server = context.server ?? app.server, { set, path: path2, qi, headers, query, params } = context;
-        if (context.validator = responseValidator, options.upgrade)
-          if (typeof options.upgrade == "function") {
-            const temp = options.upgrade(context);
-            temp instanceof Promise && await temp;
-          } else options.upgrade && Object.assign(
-            set.headers,
-            options.upgrade
-          );
-        if (set.cookie && (0, import_utils2.isNotEmpty)(set.cookie)) {
-          const cookie = (0, import_cookies.serializeCookie)(set.cookie);
-          cookie && (set.headers["set-cookie"] = cookie);
-        }
-        set.headers["set-cookie"] && Array.isArray(set.headers["set-cookie"]) && (set.headers = (0, import_utils.parseSetCookies)(
-          new Headers(set.headers),
-          set.headers["set-cookie"]
-        ));
-        const handleResponse = (0, import_ws.createHandleWSResponse)(responseValidator), parseMessage = (0, import_ws.createWSMessageParser)(parse);
-        let _id;
-        if (typeof options.beforeHandle == "function") {
-          const result = options.beforeHandle(context);
-          result instanceof Promise && await result;
-        }
-        const errorHandlers = [
-          ...options.error ? Array.isArray(options.error) ? options.error : [options.error] : [],
-          ...(app.event.error ?? []).map(
-            (x) => typeof x == "function" ? x : x.fn
-          )
-        ].filter((x) => x), hasCustomErrorHandlers = errorHandlers.length > 0, handleErrors = hasCustomErrorHandlers ? async (ws, error) => {
-          for (const handleError of errorHandlers) {
-            let response2 = handleError(
-              Object.assign(context, { error })
-            );
-            if (response2 instanceof Promise && (response2 = await response2), await handleResponse(ws, response2), response2) break;
-          }
-        } : () => {
-        };
-        if (!server?.upgrade(context.request, {
-          headers: (0, import_utils2.isNotEmpty)(set.headers) ? set.headers : void 0,
-          data: {
-            ...context,
-            get id() {
-              return _id || (_id = (0, import_utils2.randomId)());
-            },
-            validator: responseValidator,
-            ping(ws, data) {
-              options.ping?.(ws, data);
-            },
-            pong(ws, data) {
-              options.pong?.(ws, data);
-            },
-            open: async (ws) => {
-              try {
-                await handleResponse(
-                  ws,
-                  options.open?.(
-                    new import_ws.ElysiaWS(ws, context)
-                  )
-                );
-              } catch (error) {
-                handleErrors(ws, error);
-              }
-            },
-            message: async (ws, _message) => {
-              const message = await parseMessage(ws, _message);
-              if (validateMessage && validateMessage(message)) {
-                const validationError = new import_error.ValidationError(
-                  "message",
-                  messageValidator,
-                  message
-                );
-                return hasCustomErrorHandlers ? handleErrors(ws, validationError) : void ws.send(
-                  validationError.message
-                );
-              }
-              try {
-                await handleResponse(
-                  ws,
-                  options.message?.(
-                    new import_ws.ElysiaWS(
-                      ws,
-                      context,
-                      message
-                    ),
-                    message
-                  )
-                );
-              } catch (error) {
-                handleErrors(ws, error);
-              }
-            },
-            drain: async (ws) => {
-              try {
-                await handleResponse(
-                  ws,
-                  options.drain?.(
-                    new import_ws.ElysiaWS(ws, context)
-                  )
-                );
-              } catch (error) {
-                handleErrors(ws, error);
-              }
-            },
-            close: async (ws, code, reason) => {
-              try {
-                await handleResponse(
-                  ws,
-                  options.close?.(
-                    new import_ws.ElysiaWS(ws, context),
-                    code,
-                    reason
-                  )
-                );
-              } catch (error) {
-                handleErrors(ws, error);
-              }
-            }
-          }
-        }))
-          return (0, import_error.status)(400, "Expected a websocket connection");
-      },
-      {
-        ...rest,
-        websocket: options
-      }
-    );
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BunAdapter,
-  isHTMLBundle,
-  removeTrailingPath
+const nativeStaticMethods = new Set([
+	"GET",
+	"POST",
+	"PUT",
+	"DELETE",
+	"PATCH",
+	"HEAD",
+	"OPTIONS"
+]);
+function collectStaticRoutes(app) {
+	if (app["~config"]?.nativeStaticResponse === false) return;
+	app.fetch;
+	const frozenRoot = require_generation.frozenRootOf(app);
+	const fetchLevelHook = require_utils.flattenChain(frozenRoot["~hookChain"]);
+	if (fetchLevelHook?.request?.length || fetchLevelHook?.trace?.length || frozenRoot["~ext"]?.hoc?.length) return;
+	const table = app["~generation"]?.routeTable ?? app["~routeTable"];
+	const length = table?.length ?? 0;
+	if (!table || !length) return;
+	const methods = table.method;
+	const paths = table.path;
+	const handlers = table.handler;
+	let hasCandidate = false;
+	for (let i = 0; i < length; i++) {
+		const h = handlers[i];
+		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
+		if (!nativeStaticMethods.has(methods[i])) continue;
+		hasCandidate = true;
+		break;
+	}
+	if (!hasCandidate) return;
+	const ready = require_utils.nullObject();
+	const strictPath = frozenRoot["~config"]?.strictPath === true;
+	const seen = /* @__PURE__ */ new Map();
+	for (let i = 0; i < length; i++) seen.set(methods[i] + " " + paths[i], i);
+	let explicitPaths;
+	if (!strictPath) {
+		explicitPaths = /* @__PURE__ */ new Map();
+		for (let i = 0; i < length; i++) {
+			const method = methods[i];
+			const path = paths[i];
+			let set = explicitPaths.get(method);
+			if (!set) explicitPaths.set(method, set = /* @__PURE__ */ new Set());
+			set.add(path);
+			if (require_constants.needEncodeRegex.test(path)) {
+				const encoded = encodeURI(path);
+				if (encoded !== path) set.add(encoded);
+			}
+		}
+	}
+	const add = (method, path, value) => {
+		if (require_constants.needEncodeRegex.test(path)) path = encodeURI(path);
+		(ready[path] ??= require_utils.nullObject())[method] = value;
+	};
+	for (let i = 0; i < length; i++) {
+		const method = methods[i];
+		if (method === "WS") continue;
+		const path = paths[i];
+		if (seen.get(method + " " + path) !== i) continue;
+		if (!nativeStaticMethods.has(method)) continue;
+		const h = handlers[i];
+		if (typeof h === "function" || h instanceof Error || h instanceof Promise) continue;
+		const value = require_compile_handler_index.buildNativeStaticResponse(require_route_table.routeRow(table, i), app);
+		if (!value) continue;
+		add(method, path, value);
+		if (!strictPath && !require_constants.isDynamicRegex.test(path)) {
+			const loose = require_utils.getLoosePath(path);
+			if (loose !== path && !explicitPaths?.get(method)?.has(loose)) add(method, loose, value);
+		}
+	}
+	if (!Object.keys(ready).length) return;
+	return [ready, []];
+}
+const BunAdapter = require_adapter_index.createAdapter({
+	name: "bun",
+	runtime: "bun",
+	isWebStandard: true,
+	parse: require_adapter_web_standard_index.WebStandardAdapter.parse,
+	response: require_adapter_web_standard_index.WebStandardAdapter.response,
+	listen(app, options, callback) {
+		const _config = app["~config"]?.serve;
+		const optionsIsObject = typeof options === "object";
+		let live;
+		const gatedFetch = (request, server) => live ? live(request, server) : Promise.resolve(ready).then(() => {
+			if (!live) throw new Error("[Elysia] Server was stopped before it was ready");
+			return live(request, server);
+		});
+		const _options = optionsIsObject ? { ...options } : {
+			port: +options,
+			fetch: gatedFetch
+		};
+		if (optionsIsObject) _options.fetch = gatedFetch;
+		const serve = _config ? {
+			..._config,
+			..._options
+		} : _options;
+		let ready;
+		const build = () => {
+			const fetch = app.fetch;
+			let routes;
+			try {
+				routes = collectStaticRoutes(app);
+			} catch (error) {
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+			}
+			let websocket;
+			if (app["~hasWS"]) {
+				const resolved = require_generation.resolvedWsOf(app);
+				if (!resolved) throw new Error("[Elysia] internal: WebSocket routes are present but no capability provider was resolved");
+				websocket = resolved.config ? Object.assign(resolved.provider.buildGlobalWSHandler(), resolved.config) : resolved.provider.buildGlobalWSHandler();
+			}
+			return {
+				fetch,
+				routes,
+				websocket
+			};
+		};
+		let built;
+		const server = app.server = Bun.serve(serve);
+		const reload = () => {
+			try {
+				server.reload(serve);
+			} catch (error) {
+				if (!serve.routes) throw error;
+				delete serve.routes;
+				console.warn("[Elysia] Native static promotion was skipped:", error);
+				try {
+					server.reload(serve);
+				} catch (fallbackError) {
+					console.error("[Elysia] Failed to reload Bun server:", fallbackError);
+					throw fallbackError;
+				}
+			}
+		};
+		const setup = () => {
+			const onSetup = app["~ext"]?.setup;
+			if (!onSetup) return;
+			let pendingSetups;
+			for (let i = 0; i < onSetup.length; i++) {
+				const result = onSetup[i](app);
+				if (result && typeof result.then === "function") (pendingSetups ??= []).push(result);
+			}
+			if (pendingSetups) return Promise.all(pendingSetups);
+		};
+		const rollback = (error) => {
+			if (app.server !== server) return;
+			try {
+				server.stop(true);
+			} catch (stopError) {
+				console.error(stopError);
+			} finally {
+				app.server = void 0;
+			}
+			const cleanup = app["~ext"]?.cleanup;
+			if (cleanup) for (let i = cleanup.length - 1; i >= 0; i--) try {
+				const result = cleanup[i](app);
+				if (result && typeof result.then === "function") Promise.resolve(result).catch(console.error);
+			} catch (cleanupError) {
+				console.error(cleanupError);
+			}
+			return error;
+		};
+		const publish = () => {
+			if (app.server !== server) return;
+			built ??= build();
+			live = serve.fetch = withOrigin(built.fetch);
+			if (built.websocket) serve.websocket = built.websocket;
+			if (built.routes) serve.routes = built.routes[0];
+			reload();
+			if (callback) callback(server);
+		};
+		const start = () => {
+			if (app.server !== server) return;
+			const setupReady = setup();
+			if (setupReady && typeof setupReady.then === "function") return Promise.resolve(setupReady).then(publish);
+			publish();
+		};
+		try {
+			if (app.pending) ready = app.modules.then(start);
+			else ready = Promise.resolve().then(start);
+			ready.catch((error) => {
+				console.error("[Elysia] listen() failed:", error);
+				return rollback(error);
+			});
+		} catch (error) {
+			rollback(error);
+			throw error;
+		}
+	}
 });
+
+//#endregion
+exports.BunAdapter = BunAdapter;
+exports.collectStaticRoutes = collectStaticRoutes;