elysia 1.4.21 → 1.4.22

package/dist/adapter/bun/handler.mjs

@@ -7,161 +7,160 @@ import {
 import { isNotEmpty } from "../../utils.mjs";
 import { Cookie } from "../../cookies.mjs";
 import { ElysiaCustomStatusResponse } from "../../error.mjs";
-const mapResponse = (response, set2, request) => {
-  if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
-    switch (handleSet(set2), response?.constructor?.name) {
+const mapResponse = (response, set, request) => {
+  if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
+    switch (handleSet(set), response?.constructor?.name) {
       case "String":
-        return new Response(response, set2);
+        return new Response(response, set);
       case "Array":
       case "Object":
-        return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
+        return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
       case "ElysiaFile":
-        return handleFile(
-          response.value,
-          set2
-        );
+        return handleFile(response.value, set);
       case "File":
-        return handleFile(response, set2);
+        return handleFile(response, set);
       case "Blob":
-        return handleFile(response, set2);
+        return handleFile(response, set);
       case "ElysiaCustomStatusResponse":
-        return set2.status = response.code, mapResponse(
+        return set.status = response.code, mapResponse(
           response.response,
-          set2,
+          set,
           request
         );
       case void 0:
-        return response ? new Response(JSON.stringify(response), set2) : new Response("", set2);
+        return response ? new Response(JSON.stringify(response), set) : new Response("", set);
       case "Response":
-        return handleResponse(response, set2, request);
+        return handleResponse(response, set, request);
       case "Error":
-        return errorToResponse(response, set2);
+        return errorToResponse(response, set);
       case "Promise":
         return response.then(
-          (x) => mapResponse(x, set2, request)
+          (x) => mapResponse(x, set, request)
         );
       case "Function":
-        return mapResponse(response(), set2, request);
+        return mapResponse(response(), set, request);
       case "Number":
       case "Boolean":
         return new Response(
           response.toString(),
-          set2
+          set
         );
       case "Cookie":
-        return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+        return response instanceof Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
       case "FormData":
-        return new Response(response, set2);
+        return new Response(response, set);
       default:
         if (response instanceof Response)
-          return handleResponse(response, set2, request);
+          return handleResponse(response, set, request);
         if (response instanceof Promise)
-          return response.then((x) => mapResponse(x, set2));
+          return response.then((x) => mapResponse(x, set));
         if (response instanceof Error)
-          return errorToResponse(response, set2);
+          return errorToResponse(response, set);
         if (response instanceof ElysiaCustomStatusResponse)
-          return set2.status = response.code, mapResponse(
+          return set.status = response.code, mapResponse(
             response.response,
-            set2,
+            set,
             request
           );
         if (
           // @ts-expect-error
           typeof response?.next == "function" || response instanceof ReadableStream
         )
-          return handleStream(response, set2, request);
+          return handleStream(response, set, request);
         if (typeof response?.then == "function")
-          return response.then((x) => mapResponse(x, set2));
+          return response.then((x) => mapResponse(x, set));
         if (typeof response?.toResponse == "function")
-          return mapResponse(response.toResponse(), set2);
+          return mapResponse(response.toResponse(), set);
         if ("charCodeAt" in response) {
           const code = response.charCodeAt(0);
           if (code === 123 || code === 91)
-            return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(
+            return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(
               JSON.stringify(response),
-              set2
+              set
             );
         }
-        return new Response(response, set2);
+        return new Response(response, set);
     }
   return (
     // @ts-expect-error
-    typeof response?.next == "function" || response instanceof ReadableStream ? handleStream(response, set2, request) : mapCompactResponse(response, request)
+    typeof response?.next == "function" || response instanceof ReadableStream ? handleStream(response, set, request) : mapCompactResponse(response, request)
   );
-}, mapEarlyResponse = (response, set2, request) => {
+}, mapEarlyResponse = (response, set, request) => {
   if (response != null)
-    if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie)
-      switch (handleSet(set2), response?.constructor?.name) {
+    if (isNotEmpty(set.headers) || set.status !== 200 || set.cookie)
+      switch (handleSet(set), response?.constructor?.name) {
         case "String":
-          return new Response(response, set2);
+          return new Response(response, set);
         case "Array":
         case "Object":
-          return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
+          return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
         case "ElysiaFile":
-          return handleFile(response.value, set2);
+          return handleFile(response.value, set);
         case "File":
-          return handleFile(response, set2);
+          return handleFile(response, set);
         case "Blob":
-          return handleFile(response, set2);
+          return handleFile(response, set);
         case "ElysiaCustomStatusResponse":
-          return set2.status = response.code, mapEarlyResponse(
+          return set.status = response.code, mapEarlyResponse(
             response.response,
-            set2,
+            set,
             request
           );
         case void 0:
-          return response ? new Response(JSON.stringify(response), set2) : void 0;
+          return response ? new Response(JSON.stringify(response), set) : void 0;
         case "Response":
-          return handleResponse(response, set2, request);
+          return handleResponse(response, set, request);
         case "Promise":
           return response.then(
-            (x) => mapEarlyResponse(x, set2)
+            (x) => mapEarlyResponse(x, set)
           );
         case "Error":
-          return errorToResponse(response, set2);
+          return errorToResponse(response, set);
         case "Function":
-          return mapEarlyResponse(response(), set2);
+          return mapEarlyResponse(response(), set);
         case "Number":
         case "Boolean":
           return new Response(
             response.toString(),
-            set2
+            set
           );
         case "FormData":
           return new Response(response);
         case "Cookie":
-          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+          return response instanceof Cookie ? new Response(response.value, set) : new Response(response?.toString(), set);
         default:
           if (response instanceof Response)
-            return handleResponse(response, set2, request);
+            return handleResponse(response, set, request);
           if (response instanceof Promise)
-            return response.then((x) => mapEarlyResponse(x, set2));
+            return response.then((x) => mapEarlyResponse(x, set));
           if (response instanceof Error)
-            return errorToResponse(response, set2);
+            return errorToResponse(response, set);
           if (response instanceof ElysiaCustomStatusResponse)
-            return set2.status = response.code, mapEarlyResponse(
+            return set.status = response.code, mapEarlyResponse(
               response.response,
-              set2,
+              set,
               request
             );
           if (
             // @ts-expect-error
             typeof response?.next == "function" || response instanceof ReadableStream
           )
-            return handleStream(response, set2, request);
+            return handleStream(response, set, request);
           if (typeof response?.then == "function")
-            return response.then((x) => mapEarlyResponse(x, set2));
+            return response.then(
+              (x) => mapEarlyResponse(x, set)
+            );
           if (typeof response?.toResponse == "function")
-            return mapEarlyResponse(response.toResponse(), set2);
+            return mapEarlyResponse(response.toResponse(), set);
           if ("charCodeAt" in response) {
             const code = response.charCodeAt(0);
             if (code === 123 || code === 91)
-              return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(
+              return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(
                 JSON.stringify(response),
-                set2
+                set
               );
           }
-          return new Response(response, set2);
+          return new Response(response, set);
       }
     else
       switch (response?.constructor?.name) {
@@ -169,17 +168,17 @@ const mapResponse = (response, set2, request) => {
           return new Response(response);
         case "Array":
         case "Object":
-          return set2.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set2);
+          return set.headers["content-type"] = "application/json", new Response(JSON.stringify(response), set);
         case "ElysiaFile":
-          return handleFile(response.value, set2);
+          return handleFile(response.value, set);
         case "File":
-          return handleFile(response, set2);
+          return handleFile(response, set);
         case "Blob":
-          return handleFile(response, set2);
+          return handleFile(response, set);
         case "ElysiaCustomStatusResponse":
-          return set2.status = response.code, mapEarlyResponse(
+          return set.status = response.code, mapEarlyResponse(
             response.response,
-            set2,
+            set,
             request
           );
         case void 0:
@@ -192,47 +191,49 @@ const mapResponse = (response, set2, request) => {
           return response;
         case "Promise":
           return response.then((x) => {
-            const r = mapEarlyResponse(x, set2);
+            const r = mapEarlyResponse(x, set);
             if (r !== void 0) return r;
           });
         case "Error":
-          return errorToResponse(response, set2);
+          return errorToResponse(response, set);
         case "Function":
           return mapCompactResponse(response(), request);
         case "Number":
         case "Boolean":
           return new Response(response.toString());
         case "Cookie":
-          return response instanceof Cookie ? new Response(response.value, set2) : new Response(response?.toString(), set2);
+          return response instanceof 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, set2));
+            return response.then((x) => mapEarlyResponse(x, set));
           if (response instanceof Error)
-            return errorToResponse(response, set2);
+            return errorToResponse(response, set);
           if (response instanceof ElysiaCustomStatusResponse)
-            return set2.status = response.code, mapEarlyResponse(
+            return set.status = response.code, mapEarlyResponse(
               response.response,
-              set2,
+              set,
               request
             );
           if (
             // @ts-expect-error
             typeof response?.next == "function" || response instanceof ReadableStream
           )
-            return handleStream(response, set2, request);
+            return handleStream(response, set, request);
           if (typeof response?.then == "function")
-            return response.then((x) => mapEarlyResponse(x, set2));
+            return response.then(
+              (x) => mapEarlyResponse(x, set)
+            );
           if (typeof response?.toResponse == "function")
-            return mapEarlyResponse(response.toResponse(), set2);
+            return mapEarlyResponse(response.toResponse(), set);
           if ("charCodeAt" in response) {
             const code = response.charCodeAt(0);
             if (code === 123 || code === 91)
-              return set2.headers["Content-Type"] || (set2.headers["Content-Type"] = "application/json"), new Response(
+              return set.headers["Content-Type"] || (set.headers["Content-Type"] = "application/json"), new Response(
                 JSON.stringify(response),
-                set2
+                set
               );
           }
           return new Response(response);
@@ -306,7 +307,9 @@ const mapResponse = (response, set2, request) => {
       )
         return handleStream(response, void 0, request);
       if (typeof response?.then == "function")
-        return response.then((x) => mapResponse(x, set));
+        return response.then(
+          (x) => mapCompactResponse(x, request)
+        );
       if (typeof response?.toResponse == "function")
         return mapCompactResponse(response.toResponse());
       if ("charCodeAt" in response) {
@@ -320,9 +323,9 @@ const mapResponse = (response, set2, request) => {
       }
       return new Response(response);
   }
-}, errorToResponse = (error, set2) => {
+}, errorToResponse = (error, set) => {
   if (typeof error?.toResponse == "function") {
-    const raw = error.toResponse(), targetSet = set2 ?? { headers: {}, status: 200, redirect: "" }, apply = (resolved) => (resolved instanceof Response && (targetSet.status = resolved.status), mapResponse(resolved, targetSet));
+    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(
@@ -332,8 +335,8 @@ const mapResponse = (response, set2, request) => {
       cause: error?.cause
     }),
     {
-      status: set2?.status !== 200 ? set2?.status ?? 500 : 500,
-      headers: set2?.headers
+      status: set?.status !== 200 ? set?.status ?? 500 : 500,
+      headers: set?.headers
     }
   );
 }, createStaticHandler = (handle, hooks, setHeaders = {}) => {

package/dist/adapter/bun/index.js

@@ -37,7 +37,7 @@ const optionalParam = /:.+?\?(?=\/|$)/, getPossibleParams = (path) => {
   POST: !0,
   PUT: !0
 }, mapRoutes = (app) => {
-  if (!app.config.aot || !app.config.systemRouter) return;
+  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] = {

package/dist/adapter/bun/index.mjs

@@ -41,7 +41,7 @@ const optionalParam = /:.+?\?(?=\/|$)/, getPossibleParams = (path) => {
   POST: !0,
   PUT: !0
 }, mapRoutes = (app) => {
-  if (!app.config.aot || !app.config.systemRouter) return;
+  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] = {

package/dist/adapter/utils.d.ts

@@ -8,11 +8,11 @@ export declare const responseToSetHeaders: (response: Response, set?: Context["s
     redirect?: string;
     cookie?: Record<string, import("../cookies").ElysiaCookie>;
 };
-type CreateHandlerParameter = {
+interface CreateHandlerParameter {
     mapResponse(response: unknown, set: Context['set'], request?: Request): Response;
     mapCompactResponse(response: unknown, request?: Request): Response;
-};
-export declare const createStreamHandler: ({ mapResponse, mapCompactResponse }: CreateHandlerParameter) => (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request) => Promise<Response>;
+}
+export declare const createStreamHandler: ({ mapResponse, mapCompactResponse }: CreateHandlerParameter) => (generator: Generator | AsyncGenerator | ReadableStream, set?: Context["set"], request?: Request, skipFormat?: boolean) => Promise<Response>;
 export declare function streamResponse(response: Response): AsyncGenerator<string, void, unknown>;
 export declare const handleSet: (set: Context["set"]) => void;
 export declare const createResponseHandler: (handler: CreateHandlerParameter) => (response: Response, set: Context["set"], request?: Request) => any;

package/dist/adapter/utils.js

@@ -88,18 +88,16 @@ const handleFile = (response, set) => {
   for (const [key, value] of response.headers.entries())
     key !== "content-encoding" && key in set.headers && (set.headers[key] = value);
   return set;
-}, allowRapidStream = import_universal.env.ELYSIA_RAPID_STREAM === "true", createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request) => {
+}, allowRapidStream = import_universal.env.ELYSIA_RAPID_STREAM === "true", createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request, skipFormat) => {
   let init = generator.next?.();
   if (set && handleSet(set), init instanceof Promise && (init = await init), init?.value instanceof ReadableStream)
     generator = init.value;
   else if (init && (typeof init?.done > "u" || init?.done))
     return set ? mapResponse(init.value, set, request) : mapCompactResponse(init.value, request);
-  const isSSE = (
-    // @ts-ignore First SSE result is wrapped with sse()
-    init?.value?.sse ?? // @ts-ignore ReadableStream is wrapped with sse()
-    generator?.sse ?? // User explicitly set content-type to SSE
-    set?.headers["content-type"]?.startsWith("text/event-stream")
-  ), format = isSSE ? (data) => `data: ${data}
+  const isSSE = !skipFormat && // @ts-ignore First SSE result is wrapped with sse()
+  (init?.value?.sse ?? // @ts-ignore ReadableStream is wrapped with sse()
+  generator?.sse ?? // User explicitly set content-type to SSE
+  set?.headers["content-type"]?.startsWith("text/event-stream")), format = isSSE ? (data) => `data: ${data}
 
 ` : (data) => data, contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value == "object" ? "application/json" : "text/plain";
   set?.headers ? (set.headers["transfer-encoding"] || (set.headers["transfer-encoding"] = "chunked"), set.headers["content-type"] || (set.headers["content-type"] = contentType), set.headers["cache-control"] || (set.headers["cache-control"] = "no-cache")) : set = {
@@ -227,13 +225,17 @@ const handleSet = (set) => {
       return !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked" ? handleStream(
         streamResponse(newResponse),
         responseToSetHeaders(newResponse, set),
-        request
+        request,
+        !0
+        // skipFormat: don't auto-format SSE for pre-formatted Response
       ) : newResponse;
     }
     return !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked" ? handleStream(
       streamResponse(response),
       responseToSetHeaders(response, set),
-      request
+      request,
+      !0
+      // skipFormat: don't auto-format SSE for pre-formatted Response
     ) : response;
   };
 };

package/dist/adapter/utils.mjs

@@ -64,18 +64,16 @@ const handleFile = (response, set) => {
   for (const [key, value] of response.headers.entries())
     key !== "content-encoding" && key in set.headers && (set.headers[key] = value);
   return set;
-}, allowRapidStream = env.ELYSIA_RAPID_STREAM === "true", createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request) => {
+}, allowRapidStream = env.ELYSIA_RAPID_STREAM === "true", createStreamHandler = ({ mapResponse, mapCompactResponse }) => async (generator, set, request, skipFormat) => {
   let init = generator.next?.();
   if (set && handleSet(set), init instanceof Promise && (init = await init), init?.value instanceof ReadableStream)
     generator = init.value;
   else if (init && (typeof init?.done > "u" || init?.done))
     return set ? mapResponse(init.value, set, request) : mapCompactResponse(init.value, request);
-  const isSSE = (
-    // @ts-ignore First SSE result is wrapped with sse()
-    init?.value?.sse ?? // @ts-ignore ReadableStream is wrapped with sse()
-    generator?.sse ?? // User explicitly set content-type to SSE
-    set?.headers["content-type"]?.startsWith("text/event-stream")
-  ), format = isSSE ? (data) => `data: ${data}
+  const isSSE = !skipFormat && // @ts-ignore First SSE result is wrapped with sse()
+  (init?.value?.sse ?? // @ts-ignore ReadableStream is wrapped with sse()
+  generator?.sse ?? // User explicitly set content-type to SSE
+  set?.headers["content-type"]?.startsWith("text/event-stream")), format = isSSE ? (data) => `data: ${data}
 
 ` : (data) => data, contentType = isSSE ? "text/event-stream" : init?.value && typeof init?.value == "object" ? "application/json" : "text/plain";
   set?.headers ? (set.headers["transfer-encoding"] || (set.headers["transfer-encoding"] = "chunked"), set.headers["content-type"] || (set.headers["content-type"] = contentType), set.headers["cache-control"] || (set.headers["cache-control"] = "no-cache")) : set = {
@@ -203,13 +201,17 @@ const handleSet = (set) => {
       return !newResponse.headers.has("content-length") && newResponse.headers.get("transfer-encoding") === "chunked" ? handleStream(
         streamResponse(newResponse),
         responseToSetHeaders(newResponse, set),
-        request
+        request,
+        !0
+        // skipFormat: don't auto-format SSE for pre-formatted Response
       ) : newResponse;
     }
     return !response.headers.has("content-length") && response.headers.get("transfer-encoding") === "chunked" ? handleStream(
       streamResponse(response),
       responseToSetHeaders(response, set),
-      request
+      request,
+      !0
+      // skipFormat: don't auto-format SSE for pre-formatted Response
     ) : response;
   };
 };

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

@@ -1,7 +1,9 @@
 import type { Context } from '../../context';
-import type { AnyLocalHook } from '../../types';
+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, set?: Context["set"]) => any;
+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;