elysia 1.4.28 → 2.0.0-beta.0

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

@@ -1,9 +1,11 @@
-import type { Context } from '../../context';
-import type { AnyLocalHook, MaybePromise } from '../../types';
-export declare const mapResponse: (response: unknown, set: Context["set"], request?: Request) => Response;
-export declare const mapEarlyResponse: (response: unknown, set: Context["set"], request?: Request) => Response | undefined;
-export declare const mapCompactResponse: (response: unknown, request?: Request) => Response;
-export declare const errorToResponse: (error: Error & {
-    toResponse?(): MaybePromise<Response>;
-}, set?: Context["set"]) => any;
-export declare const createStaticHandler: (handle: unknown, hooks: Partial<AnyLocalHook>, setHeaders?: Context["set"]["headers"]) => (() => Response) | undefined;
+import { MaybePromise } from "../../types.js";
+import { Context } from "../../context.js";
+
+//#region src/adapter/web-standard/handler.d.ts
+declare function mapResponse(response: unknown, set: Context['set'], request?: Request, owned?: boolean): Response;
+declare function mapCompactResponse(response: unknown, request?: Request, owned?: boolean): Response;
+declare function errorToResponse(error: Error & {
+  toResponse?(): MaybePromise<Response>;
+}, set?: Context['set'], request?: Request, owned?: boolean): any;
+//#endregion
+export { errorToResponse, mapCompactResponse, mapResponse };

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

@@ -1,417 +1,148 @@
-"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;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
-var handler_exports = {};
-__export(handler_exports, {
-  createStaticHandler: () => createStaticHandler,
-  errorToResponse: () => errorToResponse,
-  mapCompactResponse: () => mapCompactResponse,
-  mapEarlyResponse: () => mapEarlyResponse,
-  mapResponse: () => mapResponse
+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_default_headers = require('../default-headers.js');
+const require_adapter_utils = require('../utils.js');
+
+//#region src/adapter/web-standard/handler.ts
+const textPlainInit = { headers: { "content-type": "text/plain" } };
+function handleElysiaFile(file, set = { headers: require_utils.nullObject() }, request) {
+	const path = file.path;
+	const contentType = require_universal_file.mime[path.slice(path.lastIndexOf(".") + 1).toLowerCase()];
+	const headers = require_adapter_utils.materializeSetHeaders(set);
+	if (contentType) headers["content-type"] = contentType;
+	const stats = file.stats;
+	if (stats) return stats.then((stat) => {
+		const size = stat.size;
+		if (size !== void 0 && set.status !== 206 && set.status !== 304 && set.status !== 412 && set.status !== 416) headers["content-length"] = size;
+		return require_adapter_utils.handleFile(file, set, request, size);
+	});
+	return require_adapter_utils.handleFile(file.value, set, request);
+}
+function mapResponseWithSet(response, set, request, owned) {
+	require_adapter_utils.handleSet(set);
+	const headers = set.headers;
+	switch (response?.constructor?.name) {
+		case "String":
+			if (!require_universal_constants.isBun && !headers["content-type"]) require_adapter_utils.materializeSetHeaders(set)["content-type"] = "text/plain";
+			return new Response(response, set);
+		case "Array": return Response.json(response, set);
+		case "Object":
+			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response), set);
+			if (typeof response?.next === "function") return handleStream(response, set, request, void 0, owned);
+			return Response.json(response, set);
+		case "Number":
+		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString(), set);
+		case "ElysiaFile": return handleElysiaFile(response, set, request);
+		case "File":
+		case "Blob": return require_adapter_utils.handleFile(response, set, request);
+		case "ElysiaStatus":
+			set.status = response.code;
+			if (response.headers) Object.assign(require_adapter_utils.materializeSetHeaders(set), response.headers);
+			return mapResponseWithSet(response.response, set, request, owned);
+		case void 0: return response ? Response.json(response, set) : new Response(null, set);
+		case "Response": return handleResponse(response, set, request, owned);
+		case "Error": return errorToResponse(response, set, request, owned);
+		case "Promise": return response.then((x) => mapResponseWithSet(x, set, request, owned));
+		case "Function": return mapResponseWithSet(response(), set, request, owned);
+		case "FormData": return new Response(response, set);
+		default: return mapFallback(response, set, request, owned);
+	}
+}
+function mapResponse(response, set, request, owned) {
+	const headers = set.headers;
+	if (set.status !== void 0 || set.cookie || headers["\0"] === headers || require_utils.isNotEmpty(headers)) return mapResponseWithSet(response, set, request, owned);
+	if (response instanceof require_error.ElysiaStatus) {
+		set.status = response.code;
+		if (response.headers) Object.assign(set.headers, response.headers);
+		return mapResponse(response.response, set, request, owned);
+	}
+	if (response instanceof Response) return owned ? handleResponse(response, void 0, request, true) : response;
+	if (response instanceof Promise) return response.then((x) => mapResponse(x, set, request, owned));
+	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
+	return mapCompactResponse(response, request, owned);
+}
+const textHeaders = require_universal_constants.isBun ? void 0 : textPlainInit;
+function mapCompactResponse(response, request, owned) {
+	switch (response?.constructor?.name) {
+		case "String": return new Response(response, textHeaders);
+		case "Array": return Response.json(response);
+		case "Object":
+			if (response["~ely-form"]) return new Response(require_utils.formToFormData(response));
+			return Response.json(response);
+		case "Number":
+		case "Boolean": return new Response(typeof response === "boolean" ? response ? "true" : "false" : response.toString());
+		case "ElysiaFile": return handleElysiaFile(response, void 0, request);
+		case "File":
+		case "Blob": return require_adapter_utils.handleFile(response, void 0, request);
+		case "ElysiaStatus": return mapResponse(response.response, {
+			status: response.code,
+			headers: response.headers ? Object.assign(require_utils.nullObject(), response.headers) : require_utils.nullObject()
+		}, request, owned);
+		case void 0: return response ? Response.json(response) : new Response("");
+		case "Response": return owned ? handleResponse(response, void 0, request, true) : response;
+		case "Error": return errorToResponse(response, void 0, request, owned);
+		case "Promise": return response.then((x) => mapCompactResponse(x, request, owned));
+		case "Function": return mapCompactResponse(response(), request, owned);
+		case "FormData": return new Response(response);
+		default: return mapFallback(response, void 0, request, owned);
+	}
+}
+function errorToResponse(error, set, request, owned = false) {
+	if (error?.toResponse) {
+		const targetSet = set ?? { headers: require_utils.nullObject() };
+		const apply = (resolved) => {
+			if (resolved instanceof Response) targetSet.status = resolved.status;
+			return mapResponse(resolved, targetSet, request, owned);
+		};
+		const raw = error.toResponse();
+		return typeof raw?.then === "function" ? raw.then(apply) : apply(raw);
+	}
+	const status = set?.status && set.status !== 200 ? set.status : 500;
+	const body = require_error.internalServerErrorBody(error);
+	body.status = status;
+	const headers = set ? require_adapter_utils.materializeSetHeaders(set) : require_utils.nullObject();
+	headers["content-type"] = require_error.PROBLEM_JSON;
+	return new Response(JSON.stringify(body), {
+		status,
+		headers
+	});
+}
+function mapFallback(response, set, request, owned = false) {
+	if (response instanceof Response) return handleResponse(response, set, request, owned);
+	if (response instanceof Promise) return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
+	if (response instanceof Error) return errorToResponse(response, set, request, owned);
+	if (response instanceof require_error.ElysiaStatus) if (set) {
+		set.status = response.code;
+		if (response.headers) set.headers = {
+			...set.headers,
+			...response.headers
+		};
+		return mapResponse(response.response, set, request, owned);
+	} else return mapResponse(response.response, {
+		status: response.code,
+		headers: response.headers ? { ...response.headers } : {}
+	}, request, owned);
+	if (response instanceof require_universal_file.ElysiaFile) return handleElysiaFile(response, void 0, request);
+	if (typeof response?.next === "function" || response instanceof ReadableStream) return handleStream(response, set, request, void 0, owned);
+	if (typeof response?.then === "function") return response.then((x) => set ? mapResponse(x, set, request, owned) : mapCompactResponse(x, request, owned));
+	if (Array.isArray(response)) return Response.json(response);
+	if (typeof response?.toResponse === "function") return set ? mapResponse(response.toResponse(), set, request, owned) : mapCompactResponse(response.toResponse(), request, owned);
+	if (response?.constructor?.name === "Cookie" && response.jar) return new Response(response.value, set);
+	return new Response(response, set);
+}
+const handleResponse = require_adapter_utils.createResponseHandler({
+	mapResponse,
+	mapCompactResponse
 });
-module.exports = __toCommonJS(handler_exports);
-var import_utils = require('../utils.js'), import_file = require('../../universal/file.js'), import_utils2 = require('../../utils.js'), import_cookies = require('../../cookies.js'), import_error = require('../../error.js');
-const handleElysiaFile = (file, set = {
-  headers: {}
-}, request) => {
-  const path = file.path, contentType = import_file.mime[path.slice(path.lastIndexOf(".") + 1)];
-  return contentType && (set.headers["content-type"] = contentType), file.stats && set.status !== 206 && set.status !== 304 && set.status !== 412 && set.status !== 416 ? file.stats.then((stat) => {
-    const size = stat.size;
-    return size !== void 0 && (set.headers["content-range"] = `bytes 0-${size - 1}/${size}`, set.headers["content-length"] = size), (0, import_utils.handleFile)(file.value, set, request);
-  }) : (0, import_utils.handleFile)(file.value, set, request);
-}, mapResponse = (response, set, request) => {
-  if ((0, import_utils2.isNotEmpty)(set.headers) || set.status !== 200 || set.cookie)
-    switch ((0, import_utils.handleSet)(set), response?.constructor?.name) {
-      case "String":
-        return set.headers["content-type"] || (set.headers["content-type"] = "text/plain"), new Response(response, set);
-      case "Array":
-      case "Object":
-        return set.headers["content-type"] || (set.headers["content-type"] = "application/json"), new Response(JSON.stringify(response), set);
-      case "ElysiaFile":
-        return handleElysiaFile(response, set, request);
-      case "File":
-        return (0, import_utils.handleFile)(response, set, request);
-      case "Blob":
-        return (0, import_utils.handleFile)(response, set, request);
-      case "ElysiaCustomStatusResponse":
-        return set.status = response.code, mapResponse(
-          response.response,
-          set,
-          request
-        );
-      case void 0:
-        return response ? new Response(JSON.stringify(response), set) : new Response("", set);
-      case "Response":
-        return handleResponse(response, set, request);
-      case "Error":
-        return errorToResponse(response, set);
-      case "Promise":
-        return response.then(
-          (x) => mapResponse(x, set, request)
-        );
-      case "Function":
-        return mapResponse(response(), set, request);
-      case "Number":
-      case "Boolean":
-        return new Response(
-          response.toString(),
-          set
-        );
-      case "Cookie":
-        return response instanceof import_cookies.Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
-      case "FormData":
-        return new Response(response, set);
-      default:
-        if (response instanceof Response)
-          return handleResponse(response, set, request);
-        if (response instanceof Promise)
-          return response.then((x) => mapResponse(x, set));
-        if (response instanceof Error)
-          return errorToResponse(response, set);
-        if (response instanceof import_error.ElysiaCustomStatusResponse)
-          return set.status = response.code, mapResponse(
-            response.response,
-            set,
-            request
-          );
-        if (
-          // @ts-expect-error
-          typeof response?.next == "function" || response instanceof ReadableStream
-        )
-          return handleStream(response, set, request);
-        if (typeof response?.then == "function")
-          return response.then(
-            (x) => mapResponse(x, set)
-          );
-        if (Array.isArray(response))
-          return new Response(JSON.stringify(response), {
-            headers: {
-              "Content-Type": "application/json"
-            }
-          });
-        if (typeof response?.toResponse == "function")
-          return mapResponse(response.toResponse(), set);
-        if ("charCodeAt" in response) {
-          const code = response.charCodeAt(0);
-          if (code === 123 || code === 91)
-            return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(
-              JSON.stringify(response),
-              set
-            );
-        }
-        return new Response(response, set);
-    }
-  return (
-    // @ts-expect-error
-    typeof response?.next == "function" || response instanceof ReadableStream ? handleStream(response, set, request) : mapCompactResponse(response, request)
-  );
-}, mapEarlyResponse = (response, set, request) => {
-  if (response != null)
-    if ((0, import_utils2.isNotEmpty)(set.headers) || set.status !== 200 || set.cookie)
-      switch ((0, import_utils.handleSet)(set), response?.constructor?.name) {
-        case "String":
-          return set.headers["content-type"] || (set.headers["content-type"] = "text/plain"), new Response(response, set);
-        case "Array":
-        case "Object":
-          return set.headers["content-type"] || (set.headers["content-type"] = "application/json"), new Response(JSON.stringify(response), set);
-        case "ElysiaFile":
-          return handleElysiaFile(response, set, request);
-        case "File":
-          return (0, import_utils.handleFile)(response, set, request);
-        case "Blob":
-          return (0, import_utils.handleFile)(response, set, request);
-        case "ElysiaCustomStatusResponse":
-          return set.status = response.code, mapEarlyResponse(
-            response.response,
-            set,
-            request
-          );
-        case void 0:
-          return response ? new Response(JSON.stringify(response), set) : void 0;
-        case "Response":
-          return handleResponse(response, set, request);
-        case "Promise":
-          return response.then(
-            (x) => mapEarlyResponse(x, set)
-          );
-        case "Error":
-          return errorToResponse(response, set);
-        case "Function":
-          return mapEarlyResponse(response(), set);
-        case "Number":
-        case "Boolean":
-          return new Response(
-            response.toString(),
-            set
-          );
-        case "FormData":
-          return new Response(response);
-        case "Cookie":
-          return response instanceof import_cookies.Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
-        default:
-          if (response instanceof Response)
-            return handleResponse(response, set, request);
-          if (response instanceof Promise)
-            return response.then((x) => mapEarlyResponse(x, set));
-          if (response instanceof Error)
-            return errorToResponse(response, set);
-          if (response instanceof import_error.ElysiaCustomStatusResponse)
-            return set.status = response.code, mapEarlyResponse(
-              response.response,
-              set,
-              request
-            );
-          if (
-            // @ts-expect-error
-            typeof response?.next == "function" || response instanceof ReadableStream
-          )
-            return handleStream(response, set, request);
-          if (typeof response?.then == "function")
-            return response.then(
-              (x) => mapEarlyResponse(x, set)
-            );
-          if (typeof response?.toResponse == "function")
-            return mapEarlyResponse(response.toResponse(), set);
-          if (Array.isArray(response))
-            return new Response(JSON.stringify(response), {
-              headers: {
-                "Content-Type": "application/json"
-              }
-            });
-          if ("charCodeAt" in response) {
-            const code = response.charCodeAt(0);
-            if (code === 123 || code === 91)
-              return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(
-                JSON.stringify(response),
-                set
-              );
-          }
-          return new Response(response, set);
-      }
-    else
-      switch (response?.constructor?.name) {
-        case "String":
-          return set.headers["content-type"] || (set.headers["content-type"] = "text/plain"), new Response(response);
-        case "Array":
-        case "Object":
-          return set.headers["content-type"] || (set.headers["content-type"] = "application/json"), new Response(JSON.stringify(response), set);
-        case "ElysiaFile":
-          return handleElysiaFile(response, set, request);
-        case "File":
-          return (0, import_utils.handleFile)(response, set, request);
-        case "Blob":
-          return (0, import_utils.handleFile)(response, set, request);
-        case "ElysiaCustomStatusResponse":
-          return set.status = response.code, mapEarlyResponse(
-            response.response,
-            set,
-            request
-          );
-        case void 0:
-          return response ? new Response(JSON.stringify(response), {
-            headers: {
-              "content-type": "application/json"
-            }
-          }) : new Response("");
-        case "Response":
-          return response;
-        case "Promise":
-          return response.then((x) => {
-            const r = mapEarlyResponse(x, set);
-            if (r !== void 0) return r;
-          });
-        case "Error":
-          return errorToResponse(response, set);
-        case "Function":
-          return mapCompactResponse(response(), request);
-        case "Number":
-        case "Boolean":
-          return new Response(response.toString());
-        case "Cookie":
-          return response instanceof import_cookies.Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
-        case "FormData":
-          return new Response(response);
-        default:
-          if (response instanceof Response) return response;
-          if (response instanceof Promise)
-            return response.then((x) => mapEarlyResponse(x, set));
-          if (response instanceof Error)
-            return errorToResponse(response, set);
-          if (response instanceof import_error.ElysiaCustomStatusResponse)
-            return set.status = response.code, mapEarlyResponse(
-              response.response,
-              set,
-              request
-            );
-          if (
-            // @ts-expect-error
-            typeof response?.next == "function" || response instanceof ReadableStream
-          )
-            return handleStream(response, set, request);
-          if (typeof response?.then == "function")
-            return response.then(
-              (x) => mapEarlyResponse(x, set)
-            );
-          if (typeof response?.toResponse == "function")
-            return mapEarlyResponse(response.toResponse(), set);
-          if (Array.isArray(response))
-            return new Response(JSON.stringify(response), {
-              headers: {
-                "Content-Type": "application/json"
-              }
-            });
-          if ("charCodeAt" in response) {
-            const code = response.charCodeAt(0);
-            if (code === 123 || code === 91)
-              return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(
-                JSON.stringify(response),
-                set
-              );
-          }
-          return new Response(response);
-      }
-}, mapCompactResponse = (response, request) => {
-  switch (response?.constructor?.name) {
-    case "String":
-      return new Response(response, {
-        headers: {
-          "Content-Type": "text/plain"
-        }
-      });
-    case "Object":
-    case "Array":
-      return new Response(JSON.stringify(response), {
-        headers: {
-          "Content-Type": "application/json"
-        }
-      });
-    case "ElysiaFile":
-      return handleElysiaFile(response, void 0, request);
-    case "File":
-      return (0, import_utils.handleFile)(response, void 0, request);
-    case "Blob":
-      return (0, import_utils.handleFile)(response, void 0, request);
-    case "ElysiaCustomStatusResponse":
-      return mapResponse(
-        response.response,
-        {
-          status: response.code,
-          headers: {}
-        }
-      );
-    case void 0:
-      return response ? new Response(JSON.stringify(response), {
-        headers: {
-          "content-type": "application/json"
-        }
-      }) : new Response("");
-    case "Response":
-      return response;
-    case "Error":
-      return errorToResponse(response);
-    case "Promise":
-      return response.then(
-        (x) => mapCompactResponse(x, request)
-      );
-    // ? Maybe response or Blob
-    case "Function":
-      return mapCompactResponse(response(), request);
-    case "Number":
-    case "Boolean":
-      return new Response(response.toString());
-    case "FormData":
-      return new Response(response);
-    default:
-      if (response instanceof Response) return response;
-      if (response instanceof Promise)
-        return response.then(
-          (x) => mapCompactResponse(x, request)
-        );
-      if (response instanceof Error)
-        return errorToResponse(response);
-      if (response instanceof import_error.ElysiaCustomStatusResponse)
-        return mapResponse(
-          response.response,
-          {
-            status: response.code,
-            headers: {}
-          }
-        );
-      if (
-        // @ts-expect-error
-        typeof response?.next == "function" || response instanceof ReadableStream
-      )
-        return handleStream(response, void 0, request);
-      if (typeof response?.then == "function")
-        return response.then(
-          (x) => mapCompactResponse(x, request)
-        );
-      if (typeof response?.toResponse == "function")
-        return mapCompactResponse(response.toResponse());
-      if (Array.isArray(response))
-        return new Response(JSON.stringify(response), {
-          headers: {
-            "Content-Type": "application/json"
-          }
-        });
-      if ("charCodeAt" in response) {
-        const code = response.charCodeAt(0);
-        if (code === 123 || code === 91)
-          return new Response(JSON.stringify(response), {
-            headers: {
-              "Content-Type": "application/json"
-            }
-          });
-      }
-      return new Response(response);
-  }
-}, errorToResponse = (error, set) => {
-  if (typeof error?.toResponse == "function") {
-    const raw = error.toResponse(), targetSet = set ?? { headers: {}, status: 200, redirect: "" }, apply = (resolved) => (resolved instanceof Response && (targetSet.status = resolved.status), mapResponse(resolved, targetSet));
-    return typeof raw?.then == "function" ? raw.then(apply) : apply(raw);
-  }
-  return new Response(
-    JSON.stringify({
-      name: error?.name,
-      message: error?.message,
-      cause: error?.cause
-    }),
-    {
-      status: set?.status !== 200 ? set?.status ?? 500 : 500,
-      headers: set?.headers
-    }
-  );
-}, createStaticHandler = (handle, hooks, setHeaders = {}) => {
-  if (typeof handle == "function") return;
-  const response = mapResponse(handle, {
-    headers: setHeaders
-  });
-  if (!hooks.parse?.length && !hooks.transform?.length && !hooks.beforeHandle?.length && !hooks.afterHandle?.length)
-    return () => response.clone();
-}, handleResponse = (0, import_utils.createResponseHandler)({
-  mapResponse,
-  mapCompactResponse
-}), handleStream = (0, import_utils.createStreamHandler)({
-  mapResponse,
-  mapCompactResponse
-});
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createStaticHandler,
-  errorToResponse,
-  mapCompactResponse,
-  mapEarlyResponse,
-  mapResponse
+const handleStream = require_adapter_utils.createStreamHandler({
+	mapResponse,
+	mapCompactResponse
 });
+
+//#endregion
+exports.errorToResponse = errorToResponse;
+exports.mapCompactResponse = mapCompactResponse;
+exports.mapResponse = mapResponse;