elysia 0.2.0 → 0.2.2

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="bun-types" />
 import type { Serve, Server } from 'bun';
-import { Router } from './router';
 import { SCHEMA, DEFS } from './utils';
 import type { Context } from './context';
 import type { Handler, BeforeRequestHandler, TypedRoute, ElysiaInstance, ElysiaConfig, HTTPMethod, InternalRoute, BodyParser, ErrorHandler, TypedSchema, LocalHook, LocalHandler, LifeCycle, LifeCycleEvent, LifeCycleStore, VoidLifeCycle, AfterRequestHandler, MergeIfNotNull, IsAny, OverwritableTypeRoute, MergeSchema, ListenCallback, NoReturnHandler, ElysiaRoute, MaybePromise, IsNever } from './types';
@@ -107,8 +106,8 @@ export default class Elysia<Instance extends ElysiaInstance = ElysiaInstance> {
         schema: Instance['schema'];
     }>;
 }
-export { Elysia, Router };
+export { Elysia };
 export { Type as t } from '@sinclair/typebox';
-export { SCHEMA, DEFS, getPath, createValidationError, getSchemaValidator } from './utils';
+export { SCHEMA, DEFS, createValidationError, getSchemaValidator, mergeDeep, mergeHook, mergeObjectArray, mapPathnameAndQueryRegEx, mapQuery } from './utils';
 export type { Context, PreContext } from './context';
 export type { Handler, RegisteredHook, BeforeRequestHandler, TypedRoute, OverwritableTypeRoute, ElysiaInstance, ElysiaConfig, HTTPMethod, ComposedHandler, InternalRoute, BodyParser, ErrorHandler, ErrorCode, TypedSchema, LocalHook, LocalHandler, LifeCycle, LifeCycleEvent, AfterRequestHandler, HookHandler, TypedSchemaToRoute, UnwrapSchema, LifeCycleStore, VoidLifeCycle, SchemaValidator, ElysiaRoute, ExtractPath, IsPathParameter, IsAny, IsNever, UnknownFallback, WithArray, ObjectValues, PickInOrder, MaybePromise, MergeIfNotNull } from './types';

package/dist/index.js

@@ -1,8 +1,9 @@
-import { Router } from './router';
+import { Raikiri } from 'raikiri';
 import { mapResponse, mapEarlyResponse } from './handler';
-import { mapQuery, clone, mergeHook, mergeDeep, createValidationError, getSchemaValidator, SCHEMA, DEFS, getResponseSchemaValidator } from './utils';
+import { mapQuery, clone, mergeHook, mergeDeep, createValidationError, getSchemaValidator, SCHEMA, DEFS, getResponseSchemaValidator, mapPathnameAndQueryRegEx } from './utils';
 import { registerSchemaPath } from './schema';
 import { mapErrorCode, mapErrorStatus } from './error';
+const ASYNC_FN = 'AsyncFunction';
 export default class Elysia {
     constructor(config = {}) {
         this.store = {
@@ -22,7 +23,7 @@ export default class Elysia {
         };
         this.server = null;
         this.$schema = null;
-        this.router = new Router();
+        this.router = new Raikiri();
         this.fallbackRoute = {};
         this.routes = [];
         this.lazyLoadModules = [];
@@ -74,17 +75,17 @@ export default class Elysia {
                 hooks: mergeHook(clone(this.event), hook),
                 validator
             };
-        this.router.register(path)[method] = {
+        const mainHandler = {
             handle: handler,
             hooks: mergeHook(clone(this.event), hook),
             validator
         };
+        this.router.add(method, path, mainHandler);
         if (!this.config.strictPath && path !== '/')
             if (path.endsWith('/'))
-                this.router.register(path.substring(0, path.length - 1))[method] = this.router.register(path)[method];
+                this.router.add(method, path.substring(0, path.length - 1), mainHandler);
             else
-                this.router.register(`${path}/`)[method] =
-                    this.router.register(path)[method];
+                this.router.add(method, `${path}/`, mainHandler);
     }
     onStart(handler) {
         this.event.start.push(handler);
@@ -280,34 +281,38 @@ export default class Elysia {
             context.request = request;
             context.set = set;
             context.store = this.store;
+            context.query = {};
         }
         else {
             context = {
                 set,
                 store: this.store,
-                request
+                request,
+                query: {}
             };
         }
         try {
-            for (let i = 0; i < this.event.request.length; i++) {
-                const onRequest = this.event.request[i];
-                let response = onRequest(context);
-                if (response instanceof Promise)
-                    response = await response;
-                response = mapEarlyResponse(response, set);
-                if (response)
-                    return response;
-            }
-            const index = request.url.indexOf('?', 10);
-            const route = this.router.find(request.url, index);
+            const event = this.event;
+            if (event.request.length)
+                for (let i = 0; i < event.request.length; i++) {
+                    const onRequest = event.request[i];
+                    let response = onRequest(context);
+                    if (onRequest.constructor.name === ASYNC_FN)
+                        response = await response;
+                    response = mapEarlyResponse(response, set);
+                    if (response)
+                        return response;
+                }
+            const fracture = request.url.match(mapPathnameAndQueryRegEx);
+            if (!fracture)
+                throw new Error('NOT_FOUND');
+            const route = this.router.match(request.method, fracture[1]) ||
+                this.router.match('ALL', fracture[1]);
             if (!route)
                 throw new Error('NOT_FOUND');
-            const handler = route.store[request.method] ||
-                route.store.ALL ||
-                this.fallbackRoute[request.method];
+            const handler = route.store || this.fallbackRoute[request.method];
             if (!handler)
                 throw new Error('NOT_FOUND');
-            const hooks = handler.hooks;
             let body;
             if (request.method !== 'GET') {
                 let contentType = request.headers.get('content-type');
@@ -315,15 +320,17 @@ export default class Elysia {
                     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](context, contentType);
-                        if (temp instanceof Promise)
-                            temp = await temp;
-                        if (temp) {
-                            body = temp;
-                            break;
+                    if (event.parse.length)
+                        for (let i = 0; i < event.parse.length; i++) {
+                            const fn = event.parse[i];
+                            let temp = fn(context, contentType);
+                            if (fn.constructor.name === ASYNC_FN)
+                                temp = await temp;
+                            if (temp) {
+                                body = temp;
+                                break;
+                            }
                         }
-                    }
                     if (body === undefined) {
                         switch (contentType) {
                             case 'application/json':
@@ -333,7 +340,7 @@ export default class Elysia {
                                 body = await request.text();
                                 break;
                             case 'application/x-www-form-urlencoded':
-                                body = mapQuery(await request.text(), null);
+                                body = mapQuery(await request.text());
                                 break;
                         }
                     }
@@ -341,12 +348,16 @@ export default class Elysia {
             }
             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)
-                    await operation;
-            }
+            if (fracture[2])
+                context.query = mapQuery(fracture[2]);
+            const hooks = handler.hooks;
+            if (hooks.transform.length)
+                for (let i = 0; i < hooks.transform.length; i++) {
+                    const fn = hooks.transform[i];
+                    const operation = fn(context);
+                    if (fn.constructor.name === ASYNC_FN)
+                        await operation;
+                }
             if (handler.validator) {
                 const validator = handler.validator;
                 if (validator.headers) {
@@ -363,36 +374,41 @@ export default class Elysia {
                 if (validator.body?.Check(body) === false)
                     throw createValidationError('body', validator.body, body);
             }
-            for (let i = 0; i < hooks.beforeHandle.length; i++) {
-                let response = hooks.beforeHandle[i](context);
-                if (response instanceof Promise)
-                    response = await response;
-                if (response !== null && response !== undefined) {
-                    for (let i = 0; i < hooks.afterHandle.length; i++) {
-                        let newResponse = hooks.afterHandle[i](context, response);
-                        if (newResponse instanceof Promise)
-                            newResponse = await newResponse;
-                        if (newResponse)
-                            response = newResponse;
+            if (hooks.beforeHandle.length)
+                for (let i = 0; i < hooks.beforeHandle.length; i++) {
+                    const fn = hooks.beforeHandle[i];
+                    let response = fn(context);
+                    if (fn.constructor.name === ASYNC_FN)
+                        response = await response;
+                    if (response !== null && response !== undefined) {
+                        for (let i = 0; i < hooks.afterHandle.length; i++) {
+                            const fn = hooks.afterHandle[i];
+                            let newResponse = fn(context, response);
+                            if (fn.constructor.name === ASYNC_FN)
+                                newResponse = await newResponse;
+                            if (newResponse)
+                                response = newResponse;
+                        }
+                        const result = mapEarlyResponse(response, context.set);
+                        if (result)
+                            return result;
                     }
-                    const result = mapEarlyResponse(response, context.set);
-                    if (result)
-                        return result;
                 }
-            }
             let response = handler.handle(context);
             if (response instanceof Promise)
                 response = await 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)
-                    newResponse = await newResponse;
-                const result = mapEarlyResponse(newResponse, context.set);
-                if (result)
-                    return result;
-            }
+            if (hooks.afterHandle.length)
+                for (let i = 0; i < hooks.afterHandle.length; i++) {
+                    const afterHandle = hooks.afterHandle[i];
+                    let newResponse = afterHandle(context, response);
+                    if (afterHandle.constructor.name === ASYNC_FN)
+                        newResponse = await newResponse;
+                    const result = mapEarlyResponse(newResponse, context.set);
+                    if (result)
+                        return result;
+                }
             return mapResponse(response, context.set);
         }
         catch (error) {
@@ -400,8 +416,7 @@ export default class Elysia {
         }
     }
     async handleError(error, set = {
-        headers: {},
-        status: undefined
+        headers: {}
     }) {
         for (let i = 0; i < this.event.error.length; i++) {
             let response = this.event.error[i]({
@@ -422,12 +437,12 @@ export default class Elysia {
     listen(options, callback) {
         if (!Bun)
             throw new Error('Bun to run');
-        const fetch = this.handle.bind(this);
         if (typeof options === 'string') {
             options = +options;
             if (Number.isNaN(options))
                 throw new Error('Port must be a numeric value');
         }
+        const fetch = this.handle.bind(this);
         const serve = typeof options === 'object'
             ? {
                 ...this.config.serve,
@@ -452,7 +467,8 @@ export default class Elysia {
         if (callback)
             callback(this.server);
         Promise.all(this.lazyLoadModules).then(() => {
-            Bun.gc(true);
+            if (!this.server.pendingRequests)
+                Bun.gc(true);
         });
         return this;
     }
@@ -467,6 +483,6 @@ export default class Elysia {
         return this;
     }
 }
-export { Elysia, Router };
+export { Elysia };
 export { Type as t } from '@sinclair/typebox';
-export { SCHEMA, DEFS, getPath, createValidationError, getSchemaValidator } from './utils';
+export { SCHEMA, DEFS, createValidationError, getSchemaValidator, mergeDeep, mergeHook, mergeObjectArray, mapPathnameAndQueryRegEx, mapQuery } from './utils';

package/dist/utils.d.ts

@@ -6,8 +6,8 @@ export declare const DEFS: unique symbol;
 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 | null) => Record<string, string>;
+export declare const mapPathnameAndQueryRegEx: RegExp;
+export declare const mapQuery: (url: string) => 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: (s: TSchema | string | undefined, models: Record<string, TSchema>, additionalProperties?: boolean) => TypeCheck<TSchema> | undefined;

package/dist/utils.js

@@ -26,46 +26,19 @@ export const mergeHook = (a, b) => {
     };
 };
 export const clone = (value) => [value][0];
-export const getPath = (url, queryIndex = url.indexOf('?')) => {
-    if (queryIndex === -1) {
-        const fragmentIndex = url.indexOf('#');
-        if (fragmentIndex !== -1)
-            queryIndex = fragmentIndex;
-        else
-            queryIndex = url.length;
-    }
-    return url.substring(url.indexOf('/', 9), queryIndex);
-};
-export const mapQuery = (url, queryIndex = url.indexOf('?')) => {
-    if (queryIndex === -1)
-        return {};
-    const query = {};
-    if (queryIndex)
-        url = url.slice(queryIndex);
-    else
-        url = ';' + url;
-    while (true) {
-        const sep = url.indexOf('&', 4);
-        if (sep === -1) {
-            const equal = url.indexOf('=');
-            let value = url.slice(equal + 1);
-            const hashIndex = value.indexOf('#');
-            if (hashIndex !== -1)
-                value = value.slice(0, hashIndex);
-            if (value.includes('%'))
-                value = decodeURI(value);
-            query[url.slice(1, equal)] = value;
-            break;
-        }
-        const path = url.slice(0, sep);
-        const equal = path.indexOf('=');
-        let value = path.slice(equal + 1);
+export const mapPathnameAndQueryRegEx = /:\/\/[^/]+([^#?]+)(?:\?([^#]+))?/;
+export const mapQuery = (url) => {
+    const mapped = {};
+    const paths = url.split('&');
+    for (let i = 0; i < paths.length; i++) {
+        const part = paths[i];
+        const index = part.indexOf('=');
+        let value = part.slice(index + 1);
         if (value.includes('%'))
-            value = decodeURI(value);
-        query[path.slice(1, equal)] = value;
-        url = url.slice(sep);
+            value = decodeURIComponent(value);
+        mapped[part.slice(0, index)] = value;
     }
-    return query;
+    return mapped;
 };
 const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
 export const mergeDeep = (target, source) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elysia",
   "description": "Fast, and friendly Bun web framework",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "author": {
     "name": "saltyAom",
     "url": "https://github.com/SaltyAom",
@@ -35,8 +35,9 @@
     "release": "npm run build && npm run test && npm publish"
   },
   "dependencies": {
-    "@sinclair/typebox": "0.25.21",
-    "openapi-types": "^12.1.0"
+    "@sinclair/typebox": "^0.25.21",
+    "openapi-types": "^12.1.0",
+    "raikiri": "0.0.0-beta.3"
   },
   "devDependencies": {
     "@types/node": "^18.11.18",
@@ -47,4 +48,4 @@
     "rimraf": "^3.0.2",
     "typescript": "^4.9.4"
   }
-}
+}

package/dist/router.d.ts

@@ -1,26 +0,0 @@
-import type { ComposedHandler } from '../src';
-export interface FindResult {
-    store: Partial<{
-        [k in string]: ComposedHandler;
-    }> & Partial<{
-        wildcardStore?: Map<number, any> | null;
-    }>;
-    params: Record<string, any>;
-}
-export interface ParametricNode {
-    paramName: string;
-    store: Record<string, any> | null;
-    staticChild: Node | null;
-}
-export interface Node {
-    pathPart: string;
-    store: Record<string, any> | null;
-    staticChildren: Map<any, any> | null;
-    parametricChild: ParametricNode | null;
-    wildcardStore: Map<number, any> | null;
-}
-export declare class Router {
-    private _root;
-    register(path: string): FindResult['store'];
-    find(url: string, queryIndex: number): FindResult | null;
-}

package/dist/router.js

@@ -1,201 +0,0 @@
-import { getPath } from './utils';
-function createNode(pathPart, staticChildren) {
-    return {
-        pathPart,
-        store: null,
-        staticChildren: staticChildren !== undefined
-            ? new Map(staticChildren.map((child) => [
-                child.pathPart.charCodeAt(0),
-                child
-            ]))
-            : null,
-        parametricChild: null,
-        wildcardStore: null
-    };
-}
-function cloneNode(node, newPathPart) {
-    return {
-        pathPart: newPathPart,
-        store: node.store,
-        staticChildren: node.staticChildren,
-        parametricChild: node.parametricChild,
-        wildcardStore: node.wildcardStore
-    };
-}
-function createParametricNode(paramName) {
-    return {
-        paramName,
-        store: null,
-        staticChild: null
-    };
-}
-export class Router {
-    constructor() {
-        this._root = createNode('/');
-    }
-    register(path) {
-        if (typeof path !== 'string')
-            throw new TypeError('Route path must be a string');
-        if (path === '' || path[0] !== '/')
-            throw new Error(`Invalid route: ${path}\nRoute path must begin with a "/"`);
-        const endsWithWildcard = path.endsWith('*');
-        if (endsWithWildcard)
-            path = path.slice(0, -1);
-        const staticParts = path.split(/:.+?(?=\/|$)/);
-        const paramParts = path.match(/:.+?(?=\/|$)/g) || [];
-        if (staticParts[staticParts.length - 1] === '')
-            staticParts.pop();
-        let node = this._root;
-        let paramPartsIndex = 0;
-        for (let i = 0; i < staticParts.length; ++i) {
-            let pathPart = staticParts[i];
-            if (i > 0) {
-                const paramName = paramParts[paramPartsIndex++].slice(1);
-                if (node.parametricChild === null)
-                    node.parametricChild = createParametricNode(paramName);
-                else if (node.parametricChild.paramName !== paramName)
-                    throw new Error(`Cannot create route "${path}" with parameter "${paramName}" ` +
-                        'because a route already exists with a different parameter name ' +
-                        `("${node.parametricChild.paramName}") in the same location`);
-                const { parametricChild } = node;
-                if (parametricChild.staticChild === null) {
-                    node = parametricChild.staticChild = createNode(pathPart);
-                    continue;
-                }
-                node = parametricChild.staticChild;
-            }
-            for (let j = 0;;) {
-                if (j === pathPart.length) {
-                    if (j < node.pathPart.length) {
-                        const childNode = cloneNode(node, node.pathPart.slice(j));
-                        Object.assign(node, createNode(pathPart, [childNode]));
-                    }
-                    break;
-                }
-                if (j === node.pathPart.length) {
-                    if (node.staticChildren === null)
-                        node.staticChildren = new Map();
-                    else if (node.staticChildren.has(pathPart.charCodeAt(j))) {
-                        node = node.staticChildren.get(pathPart.charCodeAt(j));
-                        pathPart = pathPart.slice(j);
-                        j = 0;
-                        continue;
-                    }
-                    const childNode = createNode(pathPart.slice(j));
-                    node.staticChildren.set(pathPart.charCodeAt(j), childNode);
-                    node = childNode;
-                    break;
-                }
-                if (pathPart[j] !== node.pathPart[j]) {
-                    const existingChild = cloneNode(node, node.pathPart.slice(j));
-                    const newChild = createNode(pathPart.slice(j));
-                    Object.assign(node, createNode(node.pathPart.slice(0, j), [
-                        existingChild,
-                        newChild
-                    ]));
-                    node = newChild;
-                    break;
-                }
-                ++j;
-            }
-        }
-        if (paramPartsIndex < paramParts.length) {
-            const param = paramParts[paramPartsIndex];
-            const paramName = param.slice(1);
-            if (node.parametricChild === null)
-                node.parametricChild = createParametricNode(paramName);
-            else if (node.parametricChild.paramName !== paramName)
-                throw new Error(`Cannot create route "${path}" with parameter "${paramName}" ` +
-                    'because a route already exists with a different parameter name ' +
-                    `("${node.parametricChild.paramName}") in the same location`);
-            if (node.parametricChild.store === null)
-                node.parametricChild.store = Object.create(null);
-            return node.parametricChild.store;
-        }
-        if (endsWithWildcard) {
-            if (node.wildcardStore === null)
-                node.wildcardStore = Object.create(null);
-            return node.wildcardStore;
-        }
-        if (node.store === null)
-            node.store = Object.create(null);
-        return node.store;
-    }
-    find(url, queryIndex) {
-        url = getPath(url, queryIndex);
-        return matchRoute(url, url.length, this._root, 0);
-    }
-}
-function matchRoute(url, urlLength, node, startIndex) {
-    const pathPart = node.pathPart;
-    const pathPartEndIndex = startIndex + pathPart.length;
-    if (pathPart.length > 1) {
-        if (pathPartEndIndex > urlLength)
-            return null;
-        if (pathPart.length < 15)
-            for (let i = 1, j = startIndex + 1; i < pathPart.length; ++i, ++j) {
-                if (pathPart[i] !== url[j]) {
-                    return null;
-                }
-            }
-        else if (url.slice(startIndex, pathPartEndIndex) !== pathPart)
-            return null;
-    }
-    if (pathPartEndIndex === urlLength) {
-        if (node.store)
-            return {
-                store: node.store,
-                params: {}
-            };
-        if (node.wildcardStore)
-            return {
-                store: node.wildcardStore,
-                params: { '*': '' }
-            };
-        return null;
-    }
-    if (node.staticChildren) {
-        const staticChild = node.staticChildren.get(url.charCodeAt(pathPartEndIndex));
-        if (staticChild !== undefined) {
-            const route = matchRoute(url, urlLength, staticChild, pathPartEndIndex);
-            if (route)
-                return route;
-        }
-    }
-    if (node.parametricChild) {
-        const slashIndex = url.indexOf('/', pathPartEndIndex);
-        if (slashIndex !== pathPartEndIndex) {
-            if (slashIndex === -1 || slashIndex >= urlLength) {
-                if (node.parametricChild.store) {
-                    const params = {};
-                    let paramData = url.slice(pathPartEndIndex, urlLength);
-                    if (paramData.includes('%'))
-                        paramData = decodeURI(paramData);
-                    params[node.parametricChild.paramName] = paramData;
-                    return {
-                        store: node.parametricChild.store,
-                        params
-                    };
-                }
-            }
-            else if (node.parametricChild.staticChild) {
-                const route = matchRoute(url, urlLength, node.parametricChild.staticChild, slashIndex);
-                if (route) {
-                    let paramData = url.slice(pathPartEndIndex, slashIndex);
-                    if (paramData.includes('%'))
-                        paramData = decodeURI(paramData);
-                    route.params[node.parametricChild.paramName] = paramData;
-                    return route;
-                }
-            }
-        }
-    }
-    if (node.wildcardStore)
-        return {
-            store: node.wildcardStore,
-            params: {
-                '*': url.slice(pathPartEndIndex, urlLength)
-            }
-        };
-    return null;
-}