elysia 0.2.0-beta.0 → 0.2.0-beta.1

package/dist/context.d.ts

@@ -13,4 +13,4 @@ export interface Context<Route extends TypedRoute = TypedRoute, Store extends El
         redirect?: string;
     };
 }
-export type PreContext<Store extends Elysia['store'] = Elysia['store']> = Omit<Context<{}, Store>, 'query' | 'params' | 'body'>;
+export type PreContext<Route extends TypedRoute = TypedRoute, Store extends Elysia['store'] = Elysia['store']> = Omit<Context<Route, Store>, 'query' | 'params' | 'body'>;

package/dist/index.d.ts

@@ -17,8 +17,8 @@ export default class Elysia<Instance extends ElysiaInstance = ElysiaInstance> {
     constructor(config?: Partial<ElysiaConfig>);
     private _addHandler;
     onStart(handler: VoidLifeCycle<Instance>): this;
-    onRequest(handler: BeforeRequestHandler<Instance['store']>): this;
-    onParse(parser: BodyParser): this;
+    onRequest<Route extends OverwritableTypeRoute = TypedRoute>(handler: BeforeRequestHandler<Route, Instance>): this;
+    onParse(parser: BodyParser<any, Instance>): this;
     onTransform<Route extends OverwritableTypeRoute = TypedRoute>(handler: NoReturnHandler<Route, Instance>): this;
     onBeforeHandle<Route extends OverwritableTypeRoute = TypedRoute>(handler: Handler<Route, Instance>): this;
     onAfterHandle<Route extends OverwritableTypeRoute = TypedRoute>(handler: AfterRequestHandler<Route, Instance>): this;

package/dist/index.js

@@ -268,14 +268,24 @@ export default class Elysia {
             status: 200,
             headers: {}
         };
+        let context;
+        if (this.decorators) {
+            context = clone(this.decorators);
+            context.request = request;
+            context.set = set;
+            context.store = this.store;
+        }
+        else {
+            context = {
+                set,
+                store: this.store,
+                request
+            };
+        }
         try {
             for (let i = 0; i < this.event.request.length; i++) {
                 const onRequest = this.event.request[i];
-                let response = onRequest({
-                    request,
-                    store: this.store,
-                    set
-                });
+                let response = onRequest(context);
                 if (response instanceof Promise)
                     response = await response;
                 response = mapEarlyResponse(response, set);
@@ -291,12 +301,16 @@ export default class Elysia {
                 this.fallbackRoute[request.method];
             if (!handler)
                 throw new Error('NOT_FOUND');
+            const hooks = handler.hooks;
             let body;
             if (request.method !== 'GET') {
-                const contentType = request.headers.get('content-type');
+                let contentType = request.headers.get('content-type');
                 if (contentType) {
+                    const index = contentType.indexOf(';');
+                    if (index !== -1)
+                        contentType = contentType.slice(0, index);
                     for (let i = 0; i < this.event.parse.length; i++) {
-                        let temp = this.event.parse[i](request, contentType);
+                        let temp = this.event.parse[i](context, contentType);
                         if (temp instanceof Promise)
                             temp = await temp;
                         if (temp) {
@@ -304,7 +318,7 @@ export default class Elysia {
                             break;
                         }
                     }
-                    if (body === undefined)
+                    if (body === undefined) {
                         switch (contentType) {
                             case 'application/json':
                                 body = await request.json();
@@ -312,29 +326,16 @@ export default class Elysia {
                             case 'text/plain':
                                 body = await request.text();
                                 break;
+                            case 'application/x-www-form-urlencoded':
+                                body = mapQuery(await request.text(), null);
+                                break;
                         }
+                    }
                 }
             }
-            const hooks = handler.hooks;
-            let context;
-            if (this.decorators) {
-                context = clone(this.decorators);
-                context.request = request;
-                context.body = body;
-                context.set = set;
-                context.store = this.store;
-                context.params = route?.params || {};
-                context.query = mapQuery(request.url, index);
-            }
-            else
-                context = {
-                    request,
-                    body,
-                    set,
-                    store: this.store,
-                    params: route?.params || {},
-                    query: mapQuery(request.url, index)
-                };
+            context.body = body;
+            context.params = route?.params || {};
+            context.query = mapQuery(request.url, index);
             for (let i = 0; i < hooks.transform.length; i++) {
                 const operation = hooks.transform[i](context);
                 if (operation instanceof Promise)
@@ -376,18 +377,8 @@ export default class Elysia {
             let response = handler.handle(context);
             if (response instanceof Promise)
                 response = await response;
-            if (handler.validator?.response)
-                if (response instanceof Response) {
-                    let res;
-                    if (handler.validator.response.schema.type === 'object')
-                        res = await response.clone().json();
-                    else
-                        res = await response.clone().text();
-                    if (handler.validator.response.Check(res) === false)
-                        throw createValidationError('response', handler.validator.response, response);
-                }
-                else if (handler.validator.response.Check(response) === false)
-                    throw createValidationError('response', handler.validator.response, response);
+            if (handler.validator?.response?.Check(response) === false)
+                throw createValidationError('response', handler.validator.response, response);
             for (let i = 0; i < hooks.afterHandle.length; i++) {
                 let newResponse = hooks.afterHandle[i](context, response);
                 if (newResponse instanceof Promise)

package/dist/types.d.ts

@@ -24,11 +24,11 @@ export type NoReturnHandler<Route extends TypedRoute = TypedRoute, Instance exte
 export type LifeCycleEvent = 'start' | 'request' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'error' | 'stop';
 export type ListenCallback = ((server: Server) => void) | ((server: Server) => Promise<void>);
 export type VoidLifeCycle<Instance extends ElysiaInstance = ElysiaInstance> = ((app: Elysia<Instance>) => void) | ((app: Elysia<Instance>) => Promise<void>);
-export type BodyParser = (request: Request, contentType: string) => any | Promise<any>;
+export type BodyParser<Route extends TypedRoute = TypedRoute, Instance extends ElysiaInstance = ElysiaInstance> = (context: PreContext<Route, Instance['store']> & Instance['request'], contentType: string) => any | Promise<any>;
 export interface LifeCycle<Instance extends ElysiaInstance = ElysiaInstance> {
     start: VoidLifeCycle<Instance>;
-    request: BeforeRequestHandler;
-    parse: BodyParser;
+    request: BeforeRequestHandler<any, Instance>;
+    parse: BodyParser<any, Instance>;
     transform: NoReturnHandler<any, Instance>;
     beforeHandle: Handler<any, Instance>;
     afterHandle: AfterRequestHandler<any, Instance>;
@@ -38,15 +38,15 @@ export interface LifeCycle<Instance extends ElysiaInstance = ElysiaInstance> {
 export type AfterRequestHandler<Route extends TypedRoute = TypedRoute, Instance extends ElysiaInstance = ElysiaInstance> = (context: Context<Route, Instance['store']> & Instance['request'], response: Route['response']) => Route['response'] | Promise<Route['response']> | Response;
 export interface LifeCycleStore<Instance extends ElysiaInstance = ElysiaInstance> {
     start: VoidLifeCycle<Instance>[];
-    request: BeforeRequestHandler[];
-    parse: BodyParser[];
+    request: BeforeRequestHandler<any, Instance>[];
+    parse: BodyParser<any, Instance>[];
     transform: NoReturnHandler<any, Instance>[];
     beforeHandle: Handler<any, Instance>[];
     afterHandle: AfterRequestHandler<any, Instance>[];
     error: ErrorHandler[];
     stop: VoidLifeCycle<Instance>[];
 }
-export type BeforeRequestHandler<Store extends ElysiaInstance['store'] = ElysiaInstance['store']> = (context: PreContext<Store>) => any;
+export type BeforeRequestHandler<Route extends TypedRoute = TypedRoute, Instance extends ElysiaInstance = ElysiaInstance> = (context: PreContext<Route, Instance['store']> & Instance['request']) => any;
 export interface RegisteredHook<Instance extends ElysiaInstance = ElysiaInstance> {
     schema?: TypedSchema;
     transform: NoReturnHandler<any, Instance>[];

package/dist/utils.d.ts

@@ -6,7 +6,7 @@ export declare const mergeObjectArray: <T>(a: T | T[], b: T | T[]) => T[];
 export declare const mergeHook: (a: LocalHook<any> | LifeCycleStore<any>, b: LocalHook<any>) => RegisteredHook<any>;
 export declare const clone: <T extends Object | any[] = Object | any[]>(value: T) => T;
 export declare const getPath: (url: string, queryIndex?: number) => string;
-export declare const mapQuery: (url: string, queryIndex?: number) => Record<string, string>;
+export declare const mapQuery: (url: string, queryIndex?: number | null) => Record<string, string>;
 export declare const mergeDeep: <A extends Object = Object, B extends Object = Object>(target: A, source: B) => DeepMergeTwoTypes<A, B>;
 export declare const createValidationError: (type: string, validator: TypeCheck<any>, value: any) => Error;
 export declare const getSchemaValidator: <Schema extends TSchema | undefined = undefined>(schema: Schema, additionalProperties?: boolean) => TypeCheck<NonNullable<Schema>> | undefined;

package/dist/utils.js

@@ -38,27 +38,30 @@ export const mapQuery = (url, queryIndex = url.indexOf('?')) => {
     if (queryIndex === -1)
         return {};
     const query = {};
-    let paths = url.slice(queryIndex);
+    if (queryIndex)
+        url = url.slice(queryIndex);
+    else
+        url = ';' + url;
     while (true) {
-        const sep = paths.indexOf('&', 4);
+        const sep = url.indexOf('&', 4);
         if (sep === -1) {
-            const equal = paths.indexOf('=');
-            let value = paths.slice(equal + 1);
+            const equal = url.indexOf('=');
+            let value = url.slice(equal + 1);
             const hashIndex = value.indexOf('#');
             if (hashIndex !== -1)
-                value = value.substring(0, hashIndex);
-            if (value.indexOf('%') !== -1)
+                value = value.slice(0, hashIndex);
+            if (value.includes('%'))
                 value = decodeURI(value);
-            query[paths.slice(1, equal)] = decodeURI(value);
+            query[url.slice(1, equal)] = value;
             break;
         }
-        const path = paths.slice(0, sep);
+        const path = url.slice(0, sep);
         const equal = path.indexOf('=');
         let value = path.slice(equal + 1);
-        if (value.indexOf('%') !== -1)
+        if (value.includes('%'))
             value = decodeURI(value);
         query[path.slice(1, equal)] = value;
-        paths = paths.slice(sep);
+        url = url.slice(sep);
     }
     return query;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elysia",
   "description": "Fast, and friendly Bun web framework",
-  "version": "0.2.0-beta.0",
+  "version": "0.2.0-beta.1",
   "author": {
     "name": "saltyAom",
     "url": "https://github.com/SaltyAom",