elysia 0.2.0 → 0.2.1

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 } 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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elysia",
   "description": "Fast, and friendly Bun web framework",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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/context.js

@@ -1 +0,0 @@
-export {};

package/dist/error.js

@@ -1,7 +0,0 @@
-const errorCodeToStatus = new Map();
-errorCodeToStatus.set('INTERNAL_SERVER_ERROR', 500);
-errorCodeToStatus.set('NOT_FOUND', 404);
-errorCodeToStatus.set('VALIDATION', 400);
-const knownErrors = new Set(errorCodeToStatus.keys());
-export const mapErrorCode = (error) => knownErrors.has(error) ? error : 'UNKNOWN';
-export const mapErrorStatus = (error) => errorCodeToStatus.get(error) ?? 500;

package/dist/handler.js

@@ -1,173 +0,0 @@
-const isNotEmpty = (obj) => {
-    for (const x in obj)
-        return true;
-    return false;
-};
-export const mapEarlyResponse = (response, set) => {
-    if (set.redirect)
-        return Response.redirect(set.redirect, {
-            headers: set.headers
-        });
-    if (isNotEmpty(set.headers) || set.status !== 200)
-        switch (typeof response) {
-            case 'string':
-                return new Response(response, {
-                    status: set.status,
-                    headers: set.headers
-                });
-            case 'object':
-                if (response instanceof Error)
-                    return errorToResponse(response, set.headers);
-                if (response instanceof Response) {
-                    for (const key in set.headers)
-                        response.headers.append(key, set.headers[key]);
-                    return response;
-                }
-                if (response instanceof Blob)
-                    return new Response(response, {
-                        status: set.status,
-                        headers: set.headers
-                    });
-                if (!set.headers['Content-Type'])
-                    set.headers['Content-Type'] = 'application/json';
-                return new Response(JSON.stringify(response), {
-                    status: set.status,
-                    headers: set.headers
-                });
-            case 'function':
-                if (response instanceof Blob)
-                    return new Response(response, {
-                        status: set.status,
-                        headers: set.headers
-                    });
-                for (const key in set.headers)
-                    response.headers.append(key, set.headers[key]);
-                return response;
-            case 'number':
-            case 'boolean':
-                return new Response(response.toString(), {
-                    status: set.status,
-                    headers: set.headers
-                });
-            default:
-                break;
-        }
-    else
-        switch (typeof response) {
-            case 'string':
-                return new Response(response);
-            case 'object':
-                if (response instanceof Response)
-                    return response;
-                if (response instanceof Error)
-                    return errorToResponse(response, set.headers);
-                if (response instanceof Blob)
-                    return new Response(response);
-                return new Response(JSON.stringify(response), {
-                    headers: {
-                        'content-type': 'application/json'
-                    }
-                });
-            case 'function':
-                if (response instanceof Blob)
-                    return new Response(response);
-                return response;
-            case 'number':
-            case 'boolean':
-                return new Response(response.toString());
-            default:
-                break;
-        }
-};
-export const mapResponse = (response, set) => {
-    if (set.redirect)
-        return Response.redirect(set.redirect, {
-            headers: set.headers
-        });
-    if (isNotEmpty(set.headers) || set.status !== 200)
-        switch (typeof response) {
-            case 'string':
-                return new Response(response, {
-                    status: set.status,
-                    headers: set.headers
-                });
-            case 'object':
-                if (response instanceof Error)
-                    return errorToResponse(response, set.headers);
-                if (response instanceof Response) {
-                    for (const key in set.headers)
-                        response.headers.append(key, set.headers[key]);
-                    return response;
-                }
-                if (response instanceof Blob)
-                    return new Response(response, {
-                        status: set.status,
-                        headers: set.headers
-                    });
-                if (!set.headers['Content-Type'])
-                    set.headers['Content-Type'] = 'application/json';
-                return new Response(JSON.stringify(response), {
-                    status: set.status,
-                    headers: set.headers
-                });
-            case 'function':
-                if (response instanceof Blob)
-                    return new Response(response, {
-                        status: set.status,
-                        headers: set.headers
-                    });
-                return response();
-            case 'number':
-            case 'boolean':
-                return new Response(response.toString(), {
-                    status: set.status,
-                    headers: set.headers
-                });
-            case 'undefined':
-                return new Response('', {
-                    status: set.status,
-                    headers: set.headers
-                });
-            default:
-                return new Response(response, {
-                    status: set.status,
-                    headers: set.headers
-                });
-        }
-    else
-        switch (typeof response) {
-            case 'string':
-                return new Response(response);
-            case 'object':
-                if (response instanceof Response)
-                    return response;
-                if (response instanceof Error)
-                    return errorToResponse(response, set.headers);
-                if (response instanceof Blob)
-                    return new Response(response);
-                return new Response(JSON.stringify(response), {
-                    headers: {
-                        'content-type': 'application/json'
-                    }
-                });
-            case 'function':
-                if (response instanceof Blob)
-                    return new Response(response);
-                return response();
-            case 'number':
-            case 'boolean':
-                return new Response(response.toString());
-            case 'undefined':
-                return new Response('');
-            default:
-                return new Response(response);
-        }
-};
-export const errorToResponse = (error, headers) => new Response(JSON.stringify({
-    name: error?.name,
-    message: error?.message,
-    cause: error?.cause
-}), {
-    status: 500,
-    headers
-});

package/dist/index.js

@@ -1,472 +0,0 @@
-import { Router } from './router';
-import { mapResponse, mapEarlyResponse } from './handler';
-import { mapQuery, clone, mergeHook, mergeDeep, createValidationError, getSchemaValidator, SCHEMA, DEFS, getResponseSchemaValidator } from './utils';
-import { registerSchemaPath } from './schema';
-import { mapErrorCode, mapErrorStatus } from './error';
-export default class Elysia {
-    constructor(config = {}) {
-        this.store = {
-            [SCHEMA]: {},
-            [DEFS]: {}
-        };
-        this.decorators = null;
-        this.event = {
-            start: [],
-            request: [],
-            parse: [],
-            transform: [],
-            beforeHandle: [],
-            afterHandle: [],
-            error: [],
-            stop: []
-        };
-        this.server = null;
-        this.$schema = null;
-        this.router = new Router();
-        this.fallbackRoute = {};
-        this.routes = [];
-        this.lazyLoadModules = [];
-        this.stop = async () => {
-            if (!this.server)
-                throw new Error("Elysia isn't running. Call `app.listen` to start the server.");
-            this.server.stop();
-            for (let i = 0; i < this.event.stop.length; i++)
-                await this.event.stop[i](this);
-        };
-        this.config = {
-            strictPath: false,
-            ...config
-        };
-    }
-    _addHandler(method, path, handler, hook) {
-        path = path.startsWith('/') ? path : `/${path}`;
-        this.routes.push({
-            method,
-            path,
-            handler,
-            hooks: mergeHook(clone(this.event), hook)
-        });
-        const defs = this.store[DEFS];
-        const body = getSchemaValidator(hook?.schema?.body ?? this.$schema?.body, defs);
-        const header = getSchemaValidator(hook?.schema?.headers ?? this.$schema?.headers, defs, true);
-        const params = getSchemaValidator(hook?.schema?.params ?? this.$schema?.params, defs);
-        const query = getSchemaValidator(hook?.schema?.query ?? this.$schema?.query, defs);
-        const response = getResponseSchemaValidator(hook?.schema?.response ?? this.$schema?.response, defs);
-        registerSchemaPath({
-            schema: this.store[SCHEMA],
-            hook,
-            method,
-            path,
-            models: this.store[DEFS]
-        });
-        const validator = body || header || params || query || response
-            ? {
-                body,
-                header,
-                params,
-                query,
-                response
-            }
-            : undefined;
-        if (path === '/*')
-            this.fallbackRoute[method] = {
-                handle: handler,
-                hooks: mergeHook(clone(this.event), hook),
-                validator
-            };
-        this.router.register(path)[method] = {
-            handle: handler,
-            hooks: mergeHook(clone(this.event), hook),
-            validator
-        };
-        if (!this.config.strictPath && path !== '/')
-            if (path.endsWith('/'))
-                this.router.register(path.substring(0, path.length - 1))[method] = this.router.register(path)[method];
-            else
-                this.router.register(`${path}/`)[method] =
-                    this.router.register(path)[method];
-    }
-    onStart(handler) {
-        this.event.start.push(handler);
-        return this;
-    }
-    onRequest(handler) {
-        this.event.request.push(handler);
-        return this;
-    }
-    onParse(parser) {
-        this.event.parse.splice(this.event.parse.length - 1, 0, parser);
-        return this;
-    }
-    onTransform(handler) {
-        this.event.transform.push(handler);
-        return this;
-    }
-    onBeforeHandle(handler) {
-        this.event.beforeHandle.push(handler);
-        return this;
-    }
-    onAfterHandle(handler) {
-        this.event.afterHandle.push(handler);
-        return this;
-    }
-    onError(errorHandler) {
-        this.event.error.push(errorHandler);
-        return this;
-    }
-    onStop(handler) {
-        this.event.stop.push(handler);
-        return this;
-    }
-    on(type, handler) {
-        switch (type) {
-            case 'start':
-                this.event.start.push(handler);
-                break;
-            case 'request':
-                this.event.request.push(handler);
-                break;
-            case 'parse':
-                this.event.parse.push(handler);
-                break;
-            case 'transform':
-                this.event.transform.push(handler);
-                break;
-            case 'beforeHandle':
-                this.event.beforeHandle.push(handler);
-                break;
-            case 'afterHandle':
-                this.event.afterHandle.push(handler);
-                break;
-            case 'error':
-                this.event.error.push(handler);
-                break;
-            case 'stop':
-                this.event.stop.push(handler);
-                break;
-        }
-        return this;
-    }
-    group(prefix, run) {
-        const instance = new Elysia();
-        instance.store = this.store;
-        const sandbox = run(instance);
-        if (sandbox.event.request.length)
-            this.event.request = [
-                ...this.event.request,
-                ...sandbox.event.request
-            ];
-        Object.values(instance.routes).forEach(({ method, path, handler, hooks }) => {
-            this._addHandler(method, `${prefix}${path}`, handler, hooks);
-        });
-        return this;
-    }
-    guard(hook, run) {
-        const instance = new Elysia();
-        instance.store = this.store;
-        const sandbox = run(instance);
-        if (sandbox.event.request.length)
-            this.event.request = [
-                ...this.event.request,
-                ...sandbox.event.request
-            ];
-        Object.values(instance.routes).forEach(({ method, path, handler, hooks: localHook }) => {
-            this._addHandler(method, path, handler, mergeHook(hook, localHook));
-        });
-        return this;
-    }
-    use(plugin) {
-        if (plugin instanceof Promise) {
-            this.lazyLoadModules.push(plugin.then((plugin) => {
-                if (typeof plugin === 'function')
-                    return plugin(this);
-                return plugin.default(this);
-            }));
-            return this;
-        }
-        const instance = plugin(this);
-        if (instance instanceof Promise) {
-            this.lazyLoadModules.push(instance);
-            return this;
-        }
-        return instance;
-    }
-    get(path, handler, hook) {
-        this._addHandler('GET', path, handler, hook);
-        return this;
-    }
-    post(path, handler, hook) {
-        this._addHandler('POST', path, handler, hook);
-        return this;
-    }
-    put(path, handler, hook) {
-        this._addHandler('PUT', path, handler, hook);
-        return this;
-    }
-    patch(path, handler, hook) {
-        this._addHandler('PATCH', path, handler, hook);
-        return this;
-    }
-    delete(path, handler, hook) {
-        this._addHandler('DELETE', path, handler, hook);
-        return this;
-    }
-    options(path, handler, hook) {
-        this._addHandler('OPTIONS', path, handler, hook);
-        return this;
-    }
-    all(path, handler, hook) {
-        this._addHandler('ALL', path, handler, hook);
-        return this;
-    }
-    head(path, handler, hook) {
-        this._addHandler('HEAD', path, handler, hook);
-        return this;
-    }
-    trace(path, handler, hook) {
-        this._addHandler('TRACE', path, handler, hook);
-        return this;
-    }
-    connect(path, handler, hook) {
-        this._addHandler('CONNECT', path, handler, hook);
-        return this;
-    }
-    route(method, path, handler, hook) {
-        this._addHandler(method, path, handler, hook);
-        return this;
-    }
-    state(name, value) {
-        if (!(name in this.store)) {
-            ;
-            this.store[name] = value;
-        }
-        return this;
-    }
-    decorate(name, value) {
-        if (!this.decorators)
-            this.decorators = {};
-        if (!(name in this.decorators))
-            this.decorators[name] = value;
-        return this;
-    }
-    derive(transform) {
-        this.store = mergeDeep(this.store, transform(() => this.store));
-        return this;
-    }
-    inject(transform) {
-        return this.onTransform((context) => {
-            Object.assign(context, transform(context));
-        });
-    }
-    schema(schema) {
-        const defs = this.store[DEFS];
-        this.$schema = {
-            body: getSchemaValidator(schema.body, defs),
-            headers: getSchemaValidator(schema?.headers, defs, true),
-            params: getSchemaValidator(schema?.params, defs),
-            query: getSchemaValidator(schema?.query, defs),
-            response: getSchemaValidator(schema?.response, defs)
-        };
-        return this;
-    }
-    async handle(request) {
-        const set = {
-            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(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);
-            if (!route)
-                throw new Error('NOT_FOUND');
-            const handler = route.store[request.method] ||
-                route.store.ALL ||
-                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');
-                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](context, contentType);
-                        if (temp instanceof Promise)
-                            temp = await temp;
-                        if (temp) {
-                            body = temp;
-                            break;
-                        }
-                    }
-                    if (body === undefined) {
-                        switch (contentType) {
-                            case 'application/json':
-                                body = await request.json();
-                                break;
-                            case 'text/plain':
-                                body = await request.text();
-                                break;
-                            case 'application/x-www-form-urlencoded':
-                                body = mapQuery(await request.text(), null);
-                                break;
-                        }
-                    }
-                }
-            }
-            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 (handler.validator) {
-                const validator = handler.validator;
-                if (validator.headers) {
-                    const _header = {};
-                    for (const key in request.headers)
-                        _header[key] = request.headers.get(key);
-                    if (validator.headers.Check(_header) === false)
-                        throw createValidationError('header', validator.headers, _header);
-                }
-                if (validator.params?.Check(context.params) === false)
-                    throw createValidationError('params', validator.params, context.params);
-                if (validator.query?.Check(context.query) === false)
-                    throw createValidationError('query', validator.query, context.query);
-                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;
-                    }
-                    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;
-            }
-            return mapResponse(response, context.set);
-        }
-        catch (error) {
-            return this.handleError(error, set);
-        }
-    }
-    async handleError(error, set = {
-        headers: {},
-        status: undefined
-    }) {
-        for (let i = 0; i < this.event.error.length; i++) {
-            let response = this.event.error[i]({
-                code: mapErrorCode(error.message),
-                error,
-                set
-            });
-            if (response instanceof Promise)
-                response = await response;
-            if (response !== undefined && response !== null)
-                return mapResponse(response, set);
-        }
-        return new Response(typeof error.cause === 'string' ? error.cause : error.message, {
-            headers: set.headers,
-            status: mapErrorStatus(mapErrorCode(error.message))
-        });
-    }
-    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 serve = typeof options === 'object'
-            ? {
-                ...this.config.serve,
-                ...options,
-                fetch
-            }
-            : {
-                ...this.config.serve,
-                port: options,
-                fetch
-            };
-        const key = `$$Elysia:${serve.port}`;
-        if (globalThis[key]) {
-            this.server = globalThis[key];
-            this.server.reload(serve);
-        }
-        else {
-            globalThis[key] = this.server = Bun.serve(serve);
-        }
-        for (let i = 0; i < this.event.start.length; i++)
-            this.event.start[i](this);
-        if (callback)
-            callback(this.server);
-        Promise.all(this.lazyLoadModules).then(() => {
-            Bun.gc(true);
-        });
-        return this;
-    }
-    get modules() {
-        return Promise.all(this.lazyLoadModules);
-    }
-    setModel(record) {
-        Object.entries(record).forEach(([key, value]) => {
-            if (!(key in this.store[DEFS]))
-                this.store[DEFS][key] = value;
-        });
-        return this;
-    }
-}
-export { Elysia, Router };
-export { Type as t } from '@sinclair/typebox';
-export { SCHEMA, DEFS, getPath, createValidationError, getSchemaValidator } from './utils';

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;
-}

package/dist/schema.js

@@ -1,109 +0,0 @@
-import { Kind } from '@sinclair/typebox';
-export const toOpenAPIPath = (path) => path
-    .split('/')
-    .map((x) => (x.startsWith(':') ? `{${x.slice(1, x.length)}}` : x))
-    .join('/');
-export const mapProperties = (name, schema, models) => {
-    if (schema === undefined)
-        return [];
-    if (typeof schema === 'string')
-        if (schema in models)
-            schema = models[schema];
-        else
-            throw new Error(`Can't find model ${schema}`);
-    return Object.entries(schema?.properties ?? []).map(([key, value]) => ({
-        ...value,
-        in: name,
-        name: key,
-        type: value?.type,
-        required: schema.required?.includes(key) ?? false
-    }));
-};
-export const registerSchemaPath = ({ schema, path, method, hook, models }) => {
-    path = toOpenAPIPath(path);
-    const bodySchema = hook?.schema?.body;
-    const paramsSchema = hook?.schema?.params;
-    const headerSchema = hook?.schema?.headers;
-    const querySchema = hook?.schema?.query;
-    let responseSchema = hook?.schema?.response;
-    if (typeof responseSchema === 'object') {
-        if (Kind in responseSchema) {
-            const { type, properties, required, ...rest } = responseSchema;
-            responseSchema = {
-                '200': {
-                    ...rest,
-                    schema: {
-                        type,
-                        properties,
-                        required
-                    }
-                }
-            };
-        }
-        else {
-            Object.entries(responseSchema).forEach(([key, value]) => {
-                if (typeof value === 'string') {
-                    const { type, properties, required, ...rest } = models[value];
-                    responseSchema[key] = {
-                        ...rest,
-                        schema: {
-                            $ref: `#/definitions/${value}`
-                        }
-                    };
-                }
-                else {
-                    const { type, properties, required, ...rest } = value;
-                    responseSchema[key] = {
-                        ...rest,
-                        schema: {
-                            type,
-                            properties,
-                            required
-                        }
-                    };
-                }
-            });
-        }
-    }
-    else if (typeof responseSchema === 'string') {
-        const { type, properties, required, ...rest } = models[responseSchema];
-        responseSchema = {
-            '200': {
-                ...rest,
-                schema: {
-                    $ref: `#/definitions/${responseSchema}`
-                }
-            }
-        };
-    }
-    const parameters = [
-        ...mapProperties('header', headerSchema, models),
-        ...mapProperties('path', paramsSchema, models),
-        ...mapProperties('query', querySchema, models)
-    ];
-    if (bodySchema)
-        parameters.push({
-            in: 'body',
-            name: 'body',
-            required: true,
-            schema: typeof bodySchema === 'string'
-                ? {
-                    $ref: `#/definitions/${bodySchema}`
-                }
-                : bodySchema
-        });
-    schema[path] = {
-        ...(schema[path] ? schema[path] : {}),
-        [method.toLowerCase()]: {
-            ...(headerSchema || paramsSchema || querySchema || bodySchema
-                ? { parameters }
-                : {}),
-            ...(responseSchema
-                ? {
-                    responses: responseSchema
-                }
-                : {}),
-            ...hook?.schema?.detail
-        }
-    };
-};

package/dist/types.js

@@ -1 +0,0 @@
-export {};

package/dist/utils.js

@@ -1,128 +0,0 @@
-import { Kind, Type } from '@sinclair/typebox';
-import { TypeCompiler } from '@sinclair/typebox/compiler';
-export const SCHEMA = Symbol('schema');
-export const DEFS = Symbol('definitions');
-export const mergeObjectArray = (a, b) => [
-    ...(Array.isArray(a) ? a : [a]),
-    ...(Array.isArray(b) ? b : [b])
-];
-export const mergeHook = (a, b) => {
-    const aSchema = 'schema' in a ? a.schema : null;
-    const bSchema = b && 'schema' in b ? b.schema : null;
-    return {
-        schema: aSchema || bSchema
-            ? {
-                body: bSchema?.body ?? aSchema?.body,
-                header: bSchema?.headers ?? aSchema?.headers,
-                params: bSchema?.params ?? aSchema?.params,
-                query: bSchema?.query ?? aSchema?.query,
-                response: bSchema?.response ?? aSchema?.response
-            }
-            : undefined,
-        transform: mergeObjectArray(a.transform ?? [], b?.transform ?? []),
-        beforeHandle: mergeObjectArray(a.beforeHandle ?? [], b?.beforeHandle ?? []),
-        afterHandle: mergeObjectArray(a.afterHandle ?? [], b?.afterHandle ?? []),
-        error: mergeObjectArray(a.error ?? [], b?.error ?? [])
-    };
-};
-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);
-        if (value.includes('%'))
-            value = decodeURI(value);
-        query[path.slice(1, equal)] = value;
-        url = url.slice(sep);
-    }
-    return query;
-};
-const isObject = (item) => item && typeof item === 'object' && !Array.isArray(item);
-export const mergeDeep = (target, source) => {
-    const output = Object.assign({}, target);
-    if (isObject(target) && isObject(source)) {
-        Object.keys(source).forEach((key) => {
-            if (isObject(source[key])) {
-                if (!(key in target))
-                    Object.assign(output, { [key]: source[key] });
-                else
-                    output[key] = mergeDeep(target[key], source[key]);
-            }
-            else {
-                Object.assign(output, { [key]: source[key] });
-            }
-        });
-    }
-    return output;
-};
-export const createValidationError = (type, validator, value) => {
-    const error = validator.Errors(value).next().value;
-    return new Error('VALIDATION', {
-        cause: `Invalid ${type}: '${error?.path?.slice(1) || 'root'}'. ${error.message}`
-    });
-};
-export const getSchemaValidator = (s, models, additionalProperties = false) => {
-    if (!s)
-        return;
-    if (typeof s === 'string' && !(s in models))
-        return;
-    const schema = typeof s === 'string' ? models[s] : s;
-    if (schema.type === 'object' && 'additionalProperties' in schema === false)
-        schema.additionalProperties = additionalProperties;
-    return TypeCompiler.Compile(schema);
-};
-export const getResponseSchemaValidator = (s, models, additionalProperties = false) => {
-    if (!s)
-        return;
-    if (typeof s === 'string' && !(s in models))
-        return;
-    const maybeSchemaOrRecord = typeof s === 'string' ? models[s] : s;
-    const schema = Kind in maybeSchemaOrRecord
-        ? maybeSchemaOrRecord
-        : Type.Union(Object.keys(maybeSchemaOrRecord)
-            .map((key) => {
-            const maybeNameOrSchema = maybeSchemaOrRecord[key];
-            if (typeof maybeNameOrSchema === 'string') {
-                if (maybeNameOrSchema in models) {
-                    const schema = models[maybeNameOrSchema];
-                    return schema;
-                }
-                return undefined;
-            }
-            return maybeNameOrSchema;
-        })
-            .filter((a) => a));
-    if (schema.type === 'object' && 'additionalProperties' in schema === false)
-        schema.additionalProperties = additionalProperties;
-    return TypeCompiler.Compile(schema);
-};