elysia 0.4.14 → 0.5.0-beta.0

package/dist/cjs/index.d.ts

@@ -0,0 +1,445 @@
+/// <reference types="bun-types" />
+import type { Serve, Server } from 'bun';
+import { SCHEMA, EXPOSED, DEFS } from './utils';
+import type { Context } from './context';
+import type { ElysiaWSOptions, WSTypedSchema } from './ws';
+import type { Handler, BeforeRequestHandler, TypedRoute, ElysiaInstance, ElysiaConfig, HTTPMethod, InternalRoute, BodyParser, ErrorHandler, TypedSchema, LocalHook, LocalHandler, LifeCycle, LifeCycleEvent, LifeCycleStore, VoidLifeCycle, AfterRequestHandler, IsAny, OverwritableTypeRoute, MergeSchema, ListenCallback, NoReturnHandler, MaybePromise, IsNever, Prettify, TypedWSRouteToEden, UnwrapSchema, ExtractPath, TypedSchemaToRoute, DeepWritable } from './types';
+import { Static, type TSchema } from '@sinclair/typebox';
+import type { ValidationError, ParseError, NotFoundError, InternalServerError } from './error';
+import type { Permission } from '@elysiajs/fn';
+export default class Elysia<Instance extends ElysiaInstance = ElysiaInstance> {
+    config: ElysiaConfig;
+    store: Instance['store'];
+    meta: Instance['meta'];
+    protected decorators: ElysiaInstance['request'];
+    event: LifeCycleStore<Instance>;
+    server: Server | null;
+    private $schema;
+    private router;
+    protected routes: InternalRoute<Instance>[];
+    private staticRouter;
+    private wsRouter;
+    private lazyLoadModules;
+    constructor(config?: Partial<ElysiaConfig>);
+    private _addHandler;
+    onStart(handler: VoidLifeCycle<Instance>): this;
+    onRequest<Route extends OverwritableTypeRoute = TypedRoute>(handler: BeforeRequestHandler<Route, Instance>): this;
+    onParse(parser: BodyParser<any, Instance>): this;
+    onTransform<Route extends OverwritableTypeRoute = TypedRoute>(handler: NoReturnHandler<Route, Instance>): this;
+    onBeforeHandle<Route extends OverwritableTypeRoute = TypedRoute>(handler: Handler<Route, Instance>): this;
+    onAfterHandle<Route extends OverwritableTypeRoute = TypedRoute>(handler: AfterRequestHandler<Route, Instance>): this;
+    onError(errorHandler: ErrorHandler): this;
+    onStop(handler: VoidLifeCycle<Instance>): this;
+    on<Event extends LifeCycleEvent = LifeCycleEvent>(type: Event, handler: LifeCycle<Instance>[Event]): this;
+    group<NewElysia extends Elysia<any> = Elysia<any>, Prefix extends string = string>(prefix: Prefix, run: (group: Elysia<{
+        request: Instance['request'];
+        store: Omit<Instance['store'], typeof SCHEMA> & ElysiaInstance['store'];
+        schema: Instance['schema'];
+        meta: Omit<Instance['meta'], typeof SCHEMA> & ElysiaInstance['meta'];
+    }>) => NewElysia): NewElysia extends Elysia<infer NewInstance> ? Elysia<{
+        request: Instance['request'];
+        schema: Instance['schema'];
+        store: Instance['store'];
+        meta: Instance['meta'] & (Omit<NewInstance['meta'], typeof SCHEMA> & Record<typeof SCHEMA, {
+            [key in keyof NewInstance['meta'][typeof SCHEMA] as key extends `${infer Rest}` ? `${Prefix}${Rest}` : key]: NewInstance['meta'][typeof SCHEMA][key];
+        }>);
+    }> : this;
+    group<Schema extends TypedSchema<Exclude<keyof Instance['meta'][typeof DEFS], number | symbol>>, NewElysia extends Elysia<any> = Elysia<any>, Prefix extends string = string>(prefix: Prefix, schema: LocalHook<Schema, Instance>, run: (group: Elysia<{
+        request: Instance['request'];
+        store: Omit<Instance['store'], typeof SCHEMA> & ElysiaInstance['store'];
+        schema: Schema & Instance['schema'];
+        meta: Omit<Instance['meta'], typeof SCHEMA> & ElysiaInstance['meta'];
+    }>) => NewElysia): NewElysia extends Elysia<infer NewInstance> ? Elysia<{
+        request: Instance['request'];
+        schema: Instance['schema'];
+        store: Instance['store'];
+        meta: Instance['meta'] & (Omit<NewInstance['meta'], typeof SCHEMA> & Record<typeof SCHEMA, {
+            [key in keyof NewInstance['meta'][typeof SCHEMA] as key extends `${infer Rest}` ? `${Prefix}${Rest}` : key]: NewInstance['meta'][typeof SCHEMA][key];
+        }>);
+    }> : this;
+    guard<Schema extends TypedSchema<Exclude<keyof Instance['meta'][typeof DEFS], number | symbol>> = {}, NewElysia extends Elysia<any> = Elysia<any>>(hook: LocalHook<Schema, Instance>, run: (group: Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Schema & Instance['schema'];
+        meta: Instance['meta'];
+    }>) => NewElysia): NewElysia extends Elysia<infer NewInstance> ? Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Instance['meta'] & NewInstance['schema'];
+    }> : this;
+    use<NewElysia extends MaybePromise<Elysia<any>> = Elysia<any>, Params extends Elysia = Elysia<any>, LazyLoadElysia extends never | ElysiaInstance = never>(plugin: MaybePromise<(app: Params extends Elysia<infer ParamsInstance> ? IsAny<ParamsInstance> extends true ? this : Params : Params) => MaybePromise<NewElysia>> | Promise<{
+        default: (elysia: Elysia<any>) => MaybePromise<Elysia<LazyLoadElysia>>;
+    }>): IsNever<LazyLoadElysia> extends false ? Elysia<{
+        request: Instance['request'] & LazyLoadElysia['request'];
+        store: Instance['store'] & LazyLoadElysia['store'];
+        schema: Instance['schema'] & LazyLoadElysia['schema'];
+        meta: Instance['meta'] & LazyLoadElysia['meta'];
+    }> : NewElysia extends Elysia<infer NewInstance> ? IsNever<NewInstance> extends true ? Elysia<Instance> : Elysia<{
+        request: Instance['request'] & NewInstance['request'];
+        store: Instance['store'] & NewInstance['store'];
+        schema: Instance['schema'] & NewInstance['schema'];
+        meta: Instance['meta'] & NewInstance['meta'];
+    }> : NewElysia extends Promise<Elysia<infer NewInstance>> ? Elysia<{
+        request: Instance['request'] & NewInstance['request'];
+        store: Instance['store'] & NewInstance['store'];
+        schema: Instance['schema'] & NewInstance['schema'];
+        meta: Instance['meta'] & NewInstance['meta'];
+    }> : this;
+    if<Condition extends boolean, NewElysia extends MaybePromise<Elysia<any>> = Elysia<any>, Params extends Elysia = Elysia<any>, LazyLoadElysia extends never | ElysiaInstance = never>(condition: Condition, run: MaybePromise<(app: Params extends Elysia<infer ParamsInstance> ? IsAny<ParamsInstance> extends true ? this : Params : Params) => MaybePromise<NewElysia>> | Promise<{
+        default: (elysia: Elysia<any>) => MaybePromise<Elysia<LazyLoadElysia>>;
+    }>): IsNever<LazyLoadElysia> extends false ? Elysia<{
+        request: Instance['request'] & LazyLoadElysia['request'];
+        store: Instance['store'] & LazyLoadElysia['store'];
+        schema: Instance['schema'] & LazyLoadElysia['schema'];
+        meta: Instance['meta'] & LazyLoadElysia['meta'];
+    }> : NewElysia extends Elysia<infer NewInstance> ? IsNever<NewInstance> extends true ? Elysia<Instance> : Elysia<{
+        request: Instance['request'] & NewInstance['request'];
+        store: Instance['store'] & NewInstance['store'];
+        schema: Instance['schema'] & NewInstance['schema'];
+        meta: Instance['meta'] & NewInstance['meta'];
+    }> : NewElysia extends Promise<Elysia<infer NewInstance>> ? Elysia<{
+        request: Instance['request'] & NewInstance['request'];
+        store: Instance['store'] & NewInstance['store'];
+        schema: Instance['schema'] & NewInstance['schema'];
+        meta: Instance['meta'] & NewInstance['meta'];
+    }> : this;
+    get<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                get: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    post<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                post: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    put<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>>>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                put: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    patch<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>> = {}>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                patch: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    delete<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>> = {}>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                delete: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    options<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>> = {}>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                options: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    all<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>> = {}>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                all: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    head<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>> = {}>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                head: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    trace<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>> = {}>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                trace: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    connect<Path extends string, Handler extends LocalHandler<Schema, Instance, Path>, Schema extends TypedSchema<Extract<keyof Instance['meta'][typeof DEFS], string>> = {}>(path: Path, handler: Handler, hook?: LocalHook<Schema, Instance, Path>): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                connect: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    ws<Path extends string = '', Schema extends TypedSchema = {}>(path: Path, options: Path extends '' ? never : this extends Elysia<infer Instance> ? ElysiaWSOptions<Path, Schema extends WSTypedSchema ? Schema : WSTypedSchema, Instance['meta'][typeof DEFS]> : never): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Instance['meta'] & Record<typeof SCHEMA, Record<Path, {
+            [method in 'subscribe']: TypedWSRouteToEden<Schema, Instance['meta'][typeof DEFS], Path>;
+        }>>;
+    }>;
+    route<Schema extends TypedSchema<Exclude<keyof Instance['meta'][typeof DEFS], number | symbol>> = {}, Method extends HTTPMethod = HTTPMethod, Path extends string = string, Handler extends LocalHandler<Schema, Instance, Path> = LocalHandler<Schema, Instance, Path>>(method: Method, path: Path, handler: Handler, { config, ...hook }?: LocalHook<Schema, Instance, Path> & {
+        config: {
+            allowMeta?: boolean;
+        };
+    }): Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED]> & Record<typeof SCHEMA, Prettify<Instance['meta'][typeof SCHEMA] & {
+            [path in Path]: {
+                [method in Method]: {
+                    body: UnwrapSchema<Schema['body'], Instance['meta'][typeof DEFS]>;
+                    headers: UnwrapSchema<Schema['headers'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    query: UnwrapSchema<Schema['query'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : undefined;
+                    params: UnwrapSchema<Schema['params'], Instance['meta'][typeof DEFS]> extends infer Result ? Result extends Record<string, any> ? Result : undefined : Record<ExtractPath<Path>, string>;
+                    response: Schema['response'] extends TSchema | string ? {
+                        '200': UnwrapSchema<Schema['response'], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : Schema['response'] extends Record<string, TSchema | string> ? {
+                        [key in keyof Schema['response']]: UnwrapSchema<Schema['response'][key], Instance['meta'][typeof DEFS], ReturnType<Handler>>;
+                    } : {
+                        '200': ReturnType<Handler>;
+                    };
+                };
+            };
+        }>>;
+    }>;
+    state<const Key extends string | number | symbol, const Value>(name: Key, value: Value): Elysia<{
+        store: Instance['store'] & {
+            [key in Key]: Value;
+        };
+        request: Instance['request'];
+        schema: Instance['schema'];
+        meta: Instance['meta'];
+    }>;
+    state<const NewStore extends Record<string, unknown>>(store: NewStore): Elysia<{
+        store: Instance['store'] & DeepWritable<NewStore>;
+        request: Instance['request'];
+        schema: Instance['schema'];
+        meta: Instance['meta'];
+    }>;
+    decorate<const Name extends string, const Value>(name: Name, value: Value): Elysia<{
+        store: Instance['store'];
+        request: Instance['request'] & {
+            [key in Name]: Value;
+        };
+        schema: Instance['schema'];
+        meta: Instance['meta'];
+    }>;
+    decorate<const Decorators extends Record<string, unknown>>(name: Decorators): Elysia<{
+        store: Instance['store'];
+        request: Instance['request'] & DeepWritable<Decorators>;
+        schema: Instance['schema'];
+        meta: Instance['meta'];
+    }>;
+    derive<Returned extends Object = Object>(transform: (context: Context<TypedSchemaToRoute<Instance['schema'], Instance['meta'][typeof DEFS]>, Instance['store']> & Instance['request']) => MaybePromise<Returned> extends {
+        store: any;
+    } ? never : Returned): Elysia<{
+        store: Instance['store'];
+        request: Instance['request'] & Awaited<Returned>;
+        schema: Instance['schema'];
+        meta: Instance['meta'];
+    }>;
+    fn<PluginInstalled extends boolean = IsAny<Permission> extends true ? false : true, T extends PluginInstalled extends true ? Record<string, unknown> | ((app: Instance['request'] & {
+        store: Instance['store'];
+        permission: Permission;
+    }) => Record<string, unknown>) : "Please install '@elysiajs/fn' before using Elysia Fn" = PluginInstalled extends true ? Record<string, unknown> | ((app: Instance['request'] & {
+        store: Instance['store'];
+        permission: Permission;
+    }) => Record<string, unknown>) : "Please install '@elysiajs/fn' before using Elysia Fn">(value: T): PluginInstalled extends true ? Elysia<{
+        store: Instance['store'];
+        request: Instance['request'];
+        schema: Instance['schema'];
+        meta: Record<typeof DEFS, Instance['meta'][typeof DEFS]> & Record<typeof EXPOSED, Instance['meta'][typeof EXPOSED] & (T extends (store: any) => infer Returned ? Returned : T)> & Record<typeof SCHEMA, Instance['meta'][typeof SCHEMA]>;
+    }> : this;
+    schema<Schema extends TypedSchema<Exclude<keyof Instance['meta'][typeof DEFS], number | symbol>> = TypedSchema<Exclude<keyof Instance['meta'][typeof DEFS], number | symbol>>, NewInstance = Elysia<{
+        request: Instance['request'];
+        store: Instance['store'];
+        schema: MergeSchema<Schema, Instance['schema']>;
+        meta: Instance['meta'];
+    }>>(schema: Schema): NewInstance;
+    handle: (request: Request) => Promise<Response>;
+    compile: () => this;
+    fetch(request: Request): MaybePromise<Response>;
+    handleError: (request: Request, error: Error | ValidationError | ParseError | NotFoundError | InternalServerError, set: Context['set']) => Promise<Response>;
+    listen: (options: string | number | Partial<Serve>, callback?: ListenCallback) => this;
+    stop: () => Promise<void>;
+    get modules(): Promise<Elysia<any>[]>;
+    model<Name extends string, Model extends TSchema>(name: Name, model: Model): Elysia<{
+        store: Instance['store'];
+        request: Instance['request'];
+        schema: Instance['schema'];
+        meta: Instance['meta'] & Record<typeof DEFS, {
+            [name in Name]: Static<Model>;
+        }>;
+    }>;
+    model<Recorder extends Record<string, TSchema>>(record: Recorder): Elysia<{
+        store: Instance['store'];
+        request: Instance['request'];
+        schema: Instance['schema'];
+        meta: Instance['meta'] & Record<typeof DEFS, {
+            [key in keyof Recorder]: Static<Recorder[key]>;
+        }>;
+    }>;
+}
+export { Elysia };
+export { t } from './custom-types';
+export { ws } from './ws';
+export { SCHEMA, DEFS, EXPOSED, getSchemaValidator, mergeDeep, mergeHook, mergeObjectArray, getResponseSchemaValidator } from './utils';
+export { ParseError, NotFoundError, ValidationError, InternalServerError } from './error';
+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, ExtractPath, IsPathParameter, IsAny, IsNever, UnknownFallback, WithArray, ObjectValues, MaybePromise, MergeIfNotNull, ElysiaDefaultMeta, AnyTypedSchema, DeepMergeTwoTypes } from './types';

package/dist/cjs/index.js

@@ -0,0 +1,5 @@
+import{nanoid as e}from"nanoid";import{Memoirist as t}from"memoirist";import{mapResponse as r}from"./handler";import{SCHEMA as s,EXPOSED as a,DEFS as o,mergeHook as i,getSchemaValidator as n,getResponseSchemaValidator as h,mergeDeep as u}from"./utils";import{registerSchemaPath as d}from"./schema";import{composeGeneralHandler as l,composeHandler as c}from"./compose";import{ws as p}from"./ws";export default class f{config;store={};meta={[s]:Object.create(null),[o]:Object.create(null),[a]:Object.create(null)};decorators={};event={start:[],request:[],parse:[],transform:[],beforeHandle:[],afterHandle:[],error:[],stop:[]};server=null;$schema=null;router=new t;routes=[];staticRouter={handlers:[],variables:"",map:{}};wsRouter;lazyLoadModules=[];constructor(e){this.config={fn:"/~fn",...e}}_addHandler(e,t,r,a,{allowMeta:u=!1}={allowMeta:!1}){t=""===t?t:47===t.charCodeAt(0)?t:`/${t}`,this.routes.push({method:e,path:t,handler:r,hooks:i({...this.event},a)});let l=this.meta[o];if(a?.type)switch(a.type){case"text":a.type="text/plain";break;case"json":a.type="application/json";break;case"formdata":a.type="multipart/form-data";break;case"urlencoded":a.type="application/x-www-form-urlencoded"}d({schema:this.meta[s],contentType:a?.type,hook:a,method:e,path:t,models:this.meta[o]});let p={body:n(a?.body??this.$schema?.body,l),headers:n(a?.headers??this.$schema?.headers,l,!0),params:n(a?.params??this.$schema?.params,l),query:n(a?.query??this.$schema?.query,l),response:h(a?.response??this.$schema?.response,l)},f=i(this.event,a),m=c({path:t,method:e,hooks:f,validator:p,handler:r,handleError:this.handleError,meta:u?this.meta:void 0});if(-1===t.indexOf(":")&&-1===t.indexOf("*")){let r=this.staticRouter.handlers.length;this.staticRouter.handlers.push(m),this.staticRouter.variables+=`const st${r} = staticRouter.handlers[${r}]
+`,this.staticRouter.map[t]||(this.staticRouter.map[t]=""),this.staticRouter.map[t]+="ALL"===e?`default:
+`:`case '${e}':
+`,this.staticRouter.map[t]+=`return st${r}(ctx)
+`}else this.router.add(e,t,m)}onStart(e){return this.event.start.push(e),this}onRequest(e){return this.event.request.push(e),this}onParse(e){return this.event.parse.splice(this.event.parse.length-1,0,e),this}onTransform(e){return this.event.transform.push(e),this}onBeforeHandle(e){return this.event.beforeHandle.push(e),this}onAfterHandle(e){return this.event.afterHandle.push(e),this}onError(e){return this.event.error.push(e),this}onStop(e){return this.event.stop.push(e),this}on(e,t){switch(e){case"start":this.event.start.push(t);break;case"request":this.event.request.push(t);break;case"parse":this.event.parse.push(t);break;case"transform":this.event.transform.push(t);break;case"beforeHandle":this.event.beforeHandle.push(t);break;case"afterHandle":this.event.afterHandle.push(t);break;case"error":this.event.error.push(t);break;case"stop":this.event.stop.push(t)}return this}group(e,t,r){let s=new f;s.store=this.store,this.wsRouter&&s.use(p());let a="object"==typeof t,n=(a?r:t)(s);return this.decorators=u(this.decorators,s.decorators),n.event.request.length&&(this.event.request=[...this.event.request,...n.event.request]),this.model(n.meta[o]),Object.values(s.routes).forEach(({method:r,path:o,handler:h,hooks:u})=>{if(a){let a=`${e}${o}`,d=s.wsRouter?.find("subscribe",a);if(d){let e=s.wsRouter.history.find(([e,t])=>a===t);if(!e)return;return this.ws(a,e[2])}this._addHandler(r,a,h,i(t,{...u,error:u.error?Array.isArray(u.error)?[...u.error,...n.event.error]:[u.error,...n.event.error]:n.event.error}))}else{let t=`${e}${o}`,a=s.wsRouter?.find("subscribe",t);if(a){let e=s.wsRouter.history.find(([e,t])=>o===t);if(!e)return;return this.ws(t,e[2])}this._addHandler(r,t,h,i(u,{error:n.event.error}))}}),s.wsRouter&&this.wsRouter&&s.wsRouter.history.forEach(([t,r,s])=>{"/"===r?this.wsRouter?.add(t,e,s):this.wsRouter?.add(t,`${e}${r}`,s)}),this}guard(e,t){let r=new f;r.store=this.store,this.wsRouter&&r.use(p());let s=t(r);return this.decorators=u(this.decorators,r.decorators),s.event.request.length&&(this.event.request=[...this.event.request,...s.event.request]),this.model(s.meta[o]),Object.values(r.routes).forEach(({method:t,path:a,handler:o,hooks:n})=>{let h=r.wsRouter?.find("subscribe",a);if(h){let e=r.wsRouter.history.find(([e,t])=>a===t);if(!e)return;return this.ws(a,e[2])}this._addHandler(t,a,o,i(e,{...n,error:n.error?Array.isArray(n.error)?[...n.error,...s.event.error]:[n.error,...s.event.error]:s.event.error}))}),r.wsRouter&&this.wsRouter&&r.wsRouter.history.forEach(([e,t,r])=>{this.wsRouter?.add(e,t,r)}),this}use(e){if(e instanceof Promise)return this.lazyLoadModules.push(e.then(e=>"function"==typeof e?e(this):e.default(this)).then(e=>e.compile())),this;let t=e(this);return t instanceof Promise?(this.lazyLoadModules.push(t),this):t}if(e,t){return e?this.use(t):this}get(e,t,r){return this._addHandler("GET",e,t,r),this}post(e,t,r){return this._addHandler("POST",e,t,r),this}put(e,t,r){return this._addHandler("PUT",e,t,r),this}patch(e,t,r){return this._addHandler("PATCH",e,t,r),this}delete(e,t,r){return this._addHandler("DELETE",e,t,r),this}options(e,t,r){return this._addHandler("OPTIONS",e,t,r),this}all(e,t,r){return this._addHandler("ALL",e,t,r),this}head(e,t,r){return this._addHandler("HEAD",e,t,r),this}trace(e,t,r){return this._addHandler("TRACE",e,t,r),this}connect(e,t,r){return this._addHandler("CONNECT",e,t,r),this}ws(t,r){if(!this.wsRouter)throw Error("Can't find WebSocket. Please register WebSocket plugin first by importing 'elysia/ws'");return this.wsRouter.add("subscribe",t,r),this.get(t,t=>{if(!this.server?.upgrade(t.request,{headers:"function"==typeof r.headers?r.headers(t):r.headers,data:{...t,id:e(),message:n(r.schema?.body,this.meta[o]),transformMessage:r.transform?Array.isArray(r.transformMessage)?r.transformMessage:[r.transformMessage]:[]}}))return t.set.status=400,"Expected a websocket connection"},{parse:r.parse,beforeHandle:r.beforeHandle,transform:r.transform,schema:{headers:r.schema?.headers,params:r.schema?.params,query:r.schema?.query}}),this}route(e,t,r,{config:s,...a}={config:{allowMeta:!1}}){return this._addHandler(e,t,r,a,s),this}state(e,t){return"object"==typeof e?(this.store=u(this.store,e),this):(e in this.store||(this.store[e]=t),this)}decorate(e,t){return"object"==typeof e?(this.decorators=u(this.decorators,e),this):(e in this.decorators||(this.decorators[e]=t),this)}derive(e){return"AsyncFunction"===e.constructor.name?this.onTransform(async t=>{Object.assign(t,await e(t))}):this.onTransform(t=>{Object.assign(t,e(t))})}fn(e){return this.use(async()=>{let{fn:t}=await import("@elysiajs/fn");return t({app:this,value:e,path:this.config.fn})})}schema(e){let t=this.meta[o];return this.$schema={body:n(e.body,t),headers:n(e?.headers,t,!0),params:n(e?.params,t),query:n(e?.query,t),response:n(e?.response,t)},this}handle=async e=>this.fetch(e);compile=()=>(this.fetch=l(this),this);fetch(e){return(this.fetch=l(this))(e)}handleError=async(e,t,s)=>{for(let a=0;a<this.event.error.length;a++){let o=this.event.error[a]({request:e,code:t.code??"UNKNOWN",error:t,set:s});if(o instanceof Promise&&(o=await o),null!=o)return r(o,s)}return new Response(t.message,{headers:s.headers,status:t.status??500})};listen=(e,t)=>{if(!Bun)throw Error("Bun to run");if(this.compile(),"string"==typeof e&&Number.isNaN(e=+e))throw Error("Port must be a numeric value");let r=this.fetch,s=(process.env.ENV??process.env.NODE_ENV)!=="production",a="object"==typeof e?{...this.config.serve,...e,development:s,fetch:r}:{...this.config.serve,port:e,fetch:r};if("production"!==process.env.ENV){let e=`$$Elysia:${a.port}`;globalThis[e]?(this.server=globalThis[e],this.server.reload(a)):globalThis[e]=this.server=Bun.serve(a)}else this.server=Bun.serve(a);for(let e=0;e<this.event.start.length;e++)this.event.start[e](this);return t&&t(this.server),Promise.all(this.lazyLoadModules).then(()=>{Bun.gc(!0)}),this};stop=async()=>{if(!this.server)throw Error("Elysia isn't running. Call `app.listen` to start the server.");this.server.stop();for(let e=0;e<this.event.stop.length;e++)await this.event.stop[e](this)};get modules(){return Promise.all(this.lazyLoadModules)}model(e,t){return"object"==typeof e?Object.entries(e).forEach(([e,t])=>{e in this.meta[o]||(this.meta[o][e]=t)}):this.meta[o][e]=t,this}}export{t}from"./custom-types";export{ws}from"./ws";export{SCHEMA,DEFS,EXPOSED,getSchemaValidator,mergeDeep,mergeHook,mergeObjectArray,getResponseSchemaValidator}from"./utils";export{ParseError,NotFoundError,ValidationError,InternalServerError}from"./error";export{f as Elysia};

package/dist/cjs/schema.d.ts

@@ -0,0 +1,15 @@
+import { type TSchema } from '@sinclair/typebox';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { HTTPMethod, LocalHook } from './types';
+export declare const toOpenAPIPath: (path: string) => string;
+export declare const mapProperties: (name: string, schema: TSchema | string | undefined, models: Record<string, TSchema>) => any[];
+export declare const capitalize: (word: string) => string;
+export declare const generateOperationId: (method: string, paths: string) => string;
+export declare const registerSchemaPath: ({ schema, contentType, path, method, hook, models }: {
+    schema: Partial<OpenAPIV3.PathsObject>;
+    contentType?: string | string[] | undefined;
+    path: string;
+    method: HTTPMethod;
+    hook?: LocalHook<any, any> | undefined;
+    models: Record<string, TSchema>;
+}) => void;

package/dist/cjs/schema.js

@@ -0,0 +1 @@
+import{Kind as e}from"@sinclair/typebox";import t from"lodash.clonedeep";export const toOpenAPIPath=e=>e.split("/").map(e=>e.startsWith(":")?`{${e.slice(1,e.length)}}`:e).join("/");export const mapProperties=(e,t,r)=>{if(void 0===t)return[];if("string"==typeof t){if(t in r)t=r[t];else throw Error(`Can't find model ${t}`)}return Object.entries(t?.properties??[]).map(([r,o])=>({...o,in:e,name:r,type:o?.type,required:t.required?.includes(r)??!1}))};let r=(e,t)=>{let r={};for(let o of e)r[o]={schema:"string"==typeof t?{$ref:`#/components/schemas/${t}`}:{...t}};return r};export const capitalize=e=>e.charAt(0).toUpperCase()+e.slice(1);export const generateOperationId=(e,t)=>{let r=e.toLowerCase();if("/"===t)return r+"Index";for(let e of t.split("/"))123===e.charCodeAt(0)?r+="By"+capitalize(e.slice(1,-1)):r+=capitalize(e);return r};export const registerSchemaPath=({schema:o,contentType:i=["application/json","multipart/form-data","text/plain"],path:n,method:p,hook:s,models:a})=>{s&&(s=t(s)),n=toOpenAPIPath(n);let c="string"==typeof i?[i]:i??["application/json"],l=s?.body,d=s?.params,f=s?.headers,m=s?.query,h=s?.response;if("object"==typeof h){if(e in h){let{type:e,properties:t,required:o,...i}=h;h={200:{...i,description:i.description,content:r(c,"object"===e||"array"===e?{type:e,properties:t,required:o}:h)}}}else Object.entries(h).forEach(([e,t])=>{if("string"==typeof t){let{type:o,properties:i,required:n,...p}=a[t];h[e]={...p,description:p.description,content:r(c,t)}}else{let{type:o,properties:i,required:n,...p}=t;h[e]={...p,description:p.description,content:r(c,{type:o,properties:i,required:n})}}})}else if("string"==typeof h){let{type:e,properties:t,required:o,...i}=a[h];h={200:{...i,content:r(c,h)}}}let y=[...mapProperties("header",f,a),...mapProperties("path",d,a),...mapProperties("query",m,a)];o[n]={...o[n]?o[n]:{},[p.toLowerCase()]:{...f||d||m||l?{parameters:y}:{},...h?{responses:h}:{},operationId:s?.detail?.operationId??generateOperationId(p,n),...s?.detail,...l?{requestBody:{content:r(c,"string"==typeof l?{$ref:`#/components/schemas/${l}`}:l)}}:null}}};