elysia 0.2.1 → 0.2.2

package/dist/context.js

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

package/dist/error.js

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,173 @@
+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.d.ts

@@ -108,6 +108,6 @@ export default class Elysia<Instance extends ElysiaInstance = ElysiaInstance> {
 }
 export { Elysia };
 export { Type as t } from '@sinclair/typebox';
-export { SCHEMA, DEFS, 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

@@ -0,0 +1,488 @@
+import { Raikiri } from 'raikiri';
+import { mapResponse, mapEarlyResponse } from './handler';
+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 = {
+            [SCHEMA]: {},
+            [DEFS]: {}
+        };
+        this.decorators = null;
+        this.event = {
+            start: [],
+            request: [],
+            parse: [],
+            transform: [],
+            beforeHandle: [],
+            afterHandle: [],
+            error: [],
+            stop: []
+        };
+        this.server = null;
+        this.$schema = null;
+        this.router = new Raikiri();
+        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
+            };
+        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.add(method, path.substring(0, path.length - 1), mainHandler);
+            else
+                this.router.add(method, `${path}/`, mainHandler);
+    }
+    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;
+            context.query = {};
+        }
+        else {
+            context = {
+                set,
+                store: this.store,
+                request,
+                query: {}
+            };
+        }
+        try {
+            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 || this.fallbackRoute[request.method];
+            if (!handler)
+                throw new Error('NOT_FOUND');
+            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);
+                    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':
+                                body = await request.json();
+                                break;
+                            case 'text/plain':
+                                body = await request.text();
+                                break;
+                            case 'application/x-www-form-urlencoded':
+                                body = mapQuery(await request.text());
+                                break;
+                        }
+                    }
+                }
+            }
+            context.body = body;
+            context.params = route?.params || {};
+            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) {
+                    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);
+            }
+            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;
+                    }
+                }
+            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);
+            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) {
+            return this.handleError(error, set);
+        }
+    }
+    async handleError(error, set = {
+        headers: {}
+    }) {
+        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');
+        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,
+                ...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(() => {
+            if (!this.server.pendingRequests)
+                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 };
+export { Type as t } from '@sinclair/typebox';
+export { SCHEMA, DEFS, createValidationError, getSchemaValidator, mergeDeep, mergeHook, mergeObjectArray, mapPathnameAndQueryRegEx, mapQuery } from './utils';

package/dist/schema.js

@@ -0,0 +1,109 @@
+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

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

package/dist/utils.js

@@ -0,0 +1,101 @@
+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 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 = decodeURIComponent(value);
+        mapped[part.slice(0, index)] = value;
+    }
+    return mapped;
+};
+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);
+};

package/package.json

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