elysia 1.2.5 → 1.2.7

package/dist/adapter/bun/index.mjs

@@ -89,11 +89,15 @@ const BunAdapter = {
   ws(app, path, options) {
     const { parse, body, response, ...rest } = options;
     const validateMessage = getSchemaValidator(body, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
       // @ts-expect-error private property
       models: app.definitions.type,
       normalize: app.config.normalize
     });
     const validateResponse = getSchemaValidator(response, {
+      // @ts-expect-error private property
+      modules: app.definitions.typebox,
       // @ts-expect-error private property
       models: app.definitions.type,
       normalize: app.config.normalize

package/dist/adapter/types.d.ts

@@ -95,6 +95,12 @@ export interface ElysiaAdapter {
         inject?: Record<string, unknown>;
         mapResponseContext: string;
         validationError: string;
+        /**
+         * Handle thrown error which is instance of Error
+         *
+         * Despite its name of `unknownError`, it also handle named error like `NOT_FOUND`, `VALIDATION_ERROR`
+         * It's named `unknownError` because it also catch unknown error
+         */
         unknownError: string;
     };
     ws?(app: AnyElysia, path: string, handler: AnyWSLocalHook): unknown;

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

@@ -3,7 +3,7 @@ import type { AnyLocalHook } from '../../types';
 export declare const parseSetCookies: (headers: Headers, setCookie: string[]) => Headers;
 export declare function streamResponse(response: Response): AsyncGenerator<string, void, unknown>;
 export declare const handleSet: (set: Context["set"]) => void;
-export declare const mergeResponseWithSetHeaders: (response: Response, set: Context["set"]) => void;
+export declare const mergeResponseWithSetHeaders: (response: Response, set: Context["set"]) => Response;
 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;

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

@@ -165,6 +165,11 @@ const handleSet = (set2) => {
   }
 };
 const mergeResponseWithSetHeaders = (response, set2) => {
+  if (response.status !== set2.status && set2.status !== 200 && (response.status <= 300 || response.status > 400))
+    response = new Response(response.body, {
+      headers: response.headers,
+      status: set2.status
+    });
   let isCookieSet = false;
   if (set2.headers instanceof Headers)
     for (const key of set2.headers.keys()) {
@@ -178,8 +183,7 @@ const mergeResponseWithSetHeaders = (response, set2) => {
   else
     for (const key in set2.headers)
       response.headers.append(key, set2.headers[key]);
-  if (response.status !== set2.status)
-    set2.status = response.status;
+  return response;
 };
 const mapResponse = (response, set2, request) => {
   if (isNotEmpty(set2.headers) || set2.status !== 200 || set2.cookie) {
@@ -223,7 +227,10 @@ const mapResponse = (response, set2, request) => {
         if (!response) return new Response("", set2);
         return Response.json(response, set2);
       case "Response":
-        mergeResponseWithSetHeaders(response, set2);
+        response = mergeResponseWithSetHeaders(
+          response,
+          set2
+        );
         if (response.headers.get("transfer-encoding") === "chunked")
           return handleStream(
             streamResponse(response),
@@ -253,7 +260,10 @@ const mapResponse = (response, set2, request) => {
         return new Response(response, set2);
       default:
         if (response instanceof Response) {
-          mergeResponseWithSetHeaders(response, set2);
+          response = mergeResponseWithSetHeaders(
+            response,
+            set2
+          );
           if (response.headers.get(
             "transfer-encoding"
           ) === "chunked")
@@ -346,7 +356,10 @@ const mapEarlyResponse = (response, set2, request) => {
         if (!response) return;
         return Response.json(response, set2);
       case "Response":
-        mergeResponseWithSetHeaders(response, set2);
+        response = mergeResponseWithSetHeaders(
+          response,
+          set2
+        );
         if (response.headers.get("transfer-encoding") === "chunked")
           return handleStream(
             streamResponse(response),
@@ -376,7 +389,10 @@ const mapEarlyResponse = (response, set2, request) => {
         return new Response(response?.toString(), set2);
       default:
         if (response instanceof Response) {
-          mergeResponseWithSetHeaders(response, set2);
+          response = mergeResponseWithSetHeaders(
+            response,
+            set2
+          );
           if (response.headers.get(
             "transfer-encoding"
           ) === "chunked")

package/dist/bun/index.d.ts

@@ -900,16 +900,16 @@ export default class Elysia<const in out BasePath extends string = '', const in
         macroFn: Metadata['macroFn'];
         parser: Metadata['parser'];
     }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Routes & NewElysia['_routes'], Ephemeral, Volatile>;
-    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Type extends LifeCycleType>(hook: {
+    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Type extends LifeCycleType, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], Macro>>(hook: {
         as: Type;
     } & LocalHook<LocalSchema, Schema, Singleton & {
         derive: Ephemeral['derive'] & Volatile['derive'];
         resolve: Ephemeral['resolve'] & Volatile['resolve'];
-    }, Definitions['error'], Metadata['macro'], keyof Metadata['parser'] & string>): Type extends 'global' ? Elysia<BasePath, {
+    }, Definitions['error'], Macro, keyof Metadata['parser'] & string>): Type extends 'global' ? Elysia<BasePath, {
         decorator: Singleton['decorator'];
         store: Singleton['store'];
         derive: Singleton['derive'];
-        resolve: Singleton['resolve'];
+        resolve: Prettify<Singleton['resolve'] & MacroContext>;
     }, Definitions, {
         schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>>;
         macro: Metadata['macro'];
@@ -917,44 +917,50 @@ export default class Elysia<const in out BasePath extends string = '', const in
         parser: Metadata['parser'];
     }, Routes, Ephemeral, Volatile> : Type extends 'scoped' ? Elysia<BasePath, Singleton, Definitions, Metadata, Routes, {
         derive: Volatile['derive'];
-        resolve: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & MacroContext>;
         schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox']>, Metadata['schema'] & Ephemeral['schema']>>;
     }, Ephemeral> : Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
         derive: Volatile['derive'];
-        resolve: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & MacroContext>;
         schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox']>, Metadata['schema'] & Ephemeral['schema'] & Volatile['schema']>>;
     }>;
-    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>>(hook: LocalHook<LocalSchema, Schema, Singleton & {
+    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], Macro>>(hook: LocalHook<LocalSchema, Schema, Singleton & {
         derive: Ephemeral['derive'] & Volatile['derive'];
-        resolve: Ephemeral['resolve'] & Volatile['resolve'];
-    }, Definitions['error'], Metadata['macro'], keyof Metadata['parser'] & string>): Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
+        resolve: Ephemeral['resolve'] & Volatile['resolve'] & MacroContext;
+    }, Definitions['error'], Macro, keyof Metadata['parser'] & string>): Elysia<BasePath, Singleton, Definitions, Metadata, Routes, Ephemeral, {
         derive: Volatile['derive'];
-        resolve: Volatile['resolve'];
+        resolve: Prettify<Volatile['resolve'] & MacroContext>;
         schema: Prettify<MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, MergeSchema<Volatile['schema'], MergeSchema<Ephemeral['schema'], Metadata['schema']>>>>;
     }>;
-    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const NewElysia extends AnyElysia, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>>(run: (group: Elysia<BasePath, Singleton, Definitions, {
+    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const NewElysia extends AnyElysia, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], Macro>>(run: (group: Elysia<BasePath, {
+        decorator: Singleton['decorator'];
+        store: Singleton['store'];
+        derive: Singleton['derive'];
+        resolve: Singleton['resolve'] & MacroContext;
+    }, Definitions, {
         schema: Prettify<Schema>;
         macro: Metadata['macro'];
         macroFn: Metadata['macroFn'];
         parser: Metadata['parser'];
     }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['_routes']>, Ephemeral, Volatile>;
-    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const NewElysia extends AnyElysia, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Resolutions extends MaybeArray<ResolveHandler<Schema, Singleton & {
-        derive: Ephemeral['derive'] & Volatile['derive'];
-        resolve: Ephemeral['resolve'] & Volatile['resolve'];
-    }>>>(schema: LocalHook<LocalSchema, Schema, Singleton & {
+    guard<const LocalSchema extends InputSchema<keyof UnwrapTypeModule<Definitions['typebox']> & string>, const NewElysia extends AnyElysia, const Schema extends MergeSchema<UnwrapRoute<LocalSchema, Definitions['typebox'], BasePath>, Metadata['schema']>, const Macro extends Metadata['macro'], const MacroContext extends MacroToContext<Metadata['macroFn'], Macro>>(schema: LocalHook<LocalSchema, Schema, Singleton & {
         derive: Ephemeral['derive'] & Volatile['derive'];
         resolve: Ephemeral['resolve'] & Volatile['resolve'];
-    }, Definitions['error'], Metadata['macro'], keyof Metadata['parser'] & string>, run: (group: Elysia<BasePath, {
+    }, Definitions['error'], Macro, keyof Metadata['parser'] & string>, run: (group: Elysia<BasePath, {
         decorator: Singleton['decorator'];
         store: Singleton['store'];
         derive: Singleton['derive'];
-        resolve: Singleton['resolve'] & ResolveResolutions<Resolutions>;
+        resolve: Prettify<Singleton['resolve'] & MacroContext>;
     }, Definitions, {
         schema: Prettify<Schema>;
         macro: Metadata['macro'];
         macroFn: Metadata['macroFn'];
         parser: Metadata['parser'];
-    }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['_routes']>, Ephemeral, Volatile>;
+    }, {}, Ephemeral, Volatile>) => NewElysia): Elysia<BasePath, Singleton, Definitions, Metadata, Prettify<Routes & NewElysia['_routes']>, Ephemeral, {
+        derive: Volatile['derive'];
+        resolve: Prettify<Volatile['resolve'] & MacroContext>;
+        schema: Volatile['schema'];
+    }>;
     /**
      * Inline fn
      */