elysia 0.2.0-beta.1 → 0.2.0-beta.2

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="bun-types" />
 import type { Serve, Server } from 'bun';
+import { Router } from './router';
 import { SCHEMA } 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';
@@ -46,7 +47,7 @@ export default class Elysia<Instance extends ElysiaInstance = ElysiaInstance> {
     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<LazyLoadElysia & Instance> : NewElysia extends Elysia<infer NewInstance> ? IsNever<NewInstance> extends true ? Elysia<Instance> : Elysia<NewInstance & Instance> : NewElysia extends Promise<Elysia<infer NewInstance>> ? Elysia<NewInstance & Instance> : this;
-    get<Schema extends TypedSchema = {}, Path extends string = string, Response = unknown>(path: Path, handler: LocalHandler<Schema, Instance, Path, Response>, hook?: LocalHook<Schema, Instance, Path>): ElysiaRoute<'GET', Schema, Instance, Path, Response>;
+    get<Schema extends TypedSchema = TypedSchema, Path extends string = string, Response = unknown>(path: Path, handler: LocalHandler<Schema, Instance, Path, Response>, hook?: LocalHook<Schema, Instance, Path>): ElysiaRoute<'GET', Schema, Instance, Path, Response>;
     post<Schema extends TypedSchema = {}, Path extends string = string, Response = unknown>(path: Path, handler: LocalHandler<Schema, Instance, Path, Response>, hook?: LocalHook<Schema, Instance, Path>): ElysiaRoute<'POST', Schema, Instance, Path, Response>;
     put<Schema extends TypedSchema = {}, Path extends string = string, Response = unknown>(path: Path, handler: LocalHandler<Schema, Instance, Path, Response>, hook?: LocalHook<Schema, Instance, Path>): ElysiaRoute<'PUT', Schema, Instance, Path, Response>;
     patch<Schema extends TypedSchema = {}, Path extends string = string, Response = unknown>(path: Path, handler: LocalHandler<Schema, Instance, Path, Response>, hook?: LocalHook<Schema, Instance, Path>): ElysiaRoute<'PATCH', Schema, Instance, Path, Response>;
@@ -98,9 +99,8 @@ export default class Elysia<Instance extends ElysiaInstance = ElysiaInstance> {
         schema: {};
     }>>[]>;
 }
-export { Elysia };
+export { Elysia, Router };
 export { Type as t } from '@sinclair/typebox';
 export { SCHEMA, getPath, createValidationError, getSchemaValidator } from './utils';
-export { Router } from './router';
 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 } from './types';
+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

@@ -34,7 +34,6 @@ export default class Elysia {
         };
         this.config = {
             strictPath: false,
-            queryLimit: 48,
             ...config
         };
     }
@@ -259,7 +258,7 @@ export default class Elysia {
             headers: getSchemaValidator(schema?.headers),
             params: getSchemaValidator(schema?.params),
             query: getSchemaValidator(schema?.query),
-            response: getSchemaValidator(schema?.response)
+            response: getSchemaValidator(schema?.response?.['200'] ?? schema.response)
         };
         return this;
     }
@@ -454,7 +453,6 @@ export default class Elysia {
         return Promise.all(this.lazyLoadModules);
     }
 }
-export { Elysia };
+export { Elysia, Router };
 export { Type as t } from '@sinclair/typebox';
 export { SCHEMA, getPath, createValidationError, getSchemaValidator } from './utils';
-export { Router } from './router';

package/dist/schema.d.ts

@@ -1,4 +1,5 @@
 import type { TSchema } from '@sinclair/typebox';
+import type { OpenAPIV2 } from 'openapi-types';
 import type { HTTPMethod, LocalHook } from './types';
 export declare const toOpenAPIPath: (path: string) => string;
 export declare const mapProperties: (name: string, schema: TSchema | undefined) => {
@@ -8,12 +9,12 @@ export declare const mapProperties: (name: string, schema: TSchema | undefined)
     required: any;
 }[];
 export declare const registerSchemaPath: ({ schema, path, method, hook }: {
-    schema: Record<string, Object>;
+    schema: OpenAPIV2.PathsObject;
     path: string;
     method: HTTPMethod;
-    hook?: LocalHook<any, import("./types").ElysiaInstance<{
+    hook?: LocalHook<import("./types").TypedSchema, import("./types").ElysiaInstance<{
         store: Record<typeof import("./utils").SCHEMA, {}>;
         request: {};
         schema: {};
-    }>, string> | undefined;
+    }>, string, import("./types").MergeSchema<import("./types").TypedSchema, {}>> | undefined;
 }) => void;

package/dist/schema.js

@@ -15,6 +15,7 @@ export const registerSchemaPath = ({ schema, path, method, hook }) => {
     const headerSchema = hook?.schema?.headers;
     const querySchema = hook?.schema?.query;
     const responseSchema = hook?.schema?.response;
+    const detail = hook?.schema?.detail;
     const parameters = [
         ...mapProperties('header', headerSchema),
         ...mapProperties('path', paramsSchema),
@@ -42,7 +43,8 @@ export const registerSchemaPath = ({ schema, path, method, hook }) => {
                         }
                     }
                 }
-                : {})
+                : {}),
+            ...detail
         }
     };
 };

package/dist/types.d.ts

@@ -2,12 +2,14 @@
 import type { Elysia } from '.';
 import type { Serve, Server } from 'bun';
 import type { Context, PreContext } from './context';
-import type { Static, TSchema } from '@sinclair/typebox';
+import type { Static, TObject, TSchema } from '@sinclair/typebox';
 import type { TypeCheck } from '@sinclair/typebox/compiler';
 import type { SCHEMA } from './utils';
+import type { OpenAPIV2 } from 'openapi-types';
 export type WithArray<T> = T | T[];
+export type ObjectValues<T extends object> = T[keyof T];
 export interface ElysiaInstance<Instance extends {
-    store?: Record<any, any> & Record<typeof SCHEMA, Record<string, Partial<Record<HTTPMethod, TypedSchema>>>>;
+    store?: Record<any, any> & Record<typeof SCHEMA, Partial<OpenAPIV2.PathsObject>>;
     request?: Record<any, any>;
     schema?: TypedSchema;
 } = {
@@ -15,11 +17,11 @@ export interface ElysiaInstance<Instance extends {
     request: {};
     schema: {};
 }> {
-    request: Instance['request'];
-    store: Instance['store'];
-    schema: Instance['schema'];
+    request: Instance['request'] extends undefined ? Record<typeof SCHEMA, {}> : Instance['request'];
+    store: Instance['store'] extends undefined ? {} : Instance['store'];
+    schema: Instance['schema'] extends undefined ? TypedSchema : Instance['schema'];
 }
-export type Handler<Route extends TypedRoute = TypedRoute, Instance extends ElysiaInstance = ElysiaInstance, CatchResponse = Route['response']> = (context: Context<Route, Instance['store']> & Instance['request']) => Route['response'] extends CatchResponse ? CatchResponse | Promise<CatchResponse> | Response : Route['response'] | Promise<Route['response']> | Response;
+export type Handler<Route extends TypedRoute = TypedRoute, Instance extends ElysiaInstance = ElysiaInstance, CatchResponse = Route['response']> = (context: Context<Route, Instance['store']> & Instance['request']) => Route['response'] extends CatchResponse ? MaybePromise<CatchResponse> | Response : MaybePromise<Route['response']> | Response;
 export type NoReturnHandler<Route extends TypedRoute = TypedRoute, Instance extends ElysiaInstance = ElysiaInstance> = (context: Context<Route, Instance['store']> & Instance['request']) => void | Promise<void>;
 export type LifeCycleEvent = 'start' | 'request' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'error' | 'stop';
 export type ListenCallback = ((server: Server) => void) | ((server: Server) => Promise<void>);
@@ -54,32 +56,22 @@ export interface RegisteredHook<Instance extends ElysiaInstance = ElysiaInstance
     afterHandle: AfterRequestHandler<any, Instance>[];
     error: ErrorHandler[];
 }
-export interface TypedSchema<Schema extends {
-    body: TSchema;
-    headers: TSchema;
-    query: TSchema;
-    params: TSchema;
-    response: TSchema;
-} = {
-    body: TSchema;
-    headers: TSchema;
-    query: TSchema;
-    params: TSchema;
-    response: TSchema;
-}> {
-    body?: Schema['body'];
-    headers?: Schema['headers'];
-    query?: Schema['query'];
-    params?: Schema['params'];
-    response?: Schema['response'];
+export interface TypedSchema {
+    body?: TSchema;
+    headers?: TObject;
+    query?: TObject;
+    params?: TObject;
+    response?: TSchema | Record<string | '200', TSchema>;
 }
 export type UnwrapSchema<Schema extends TSchema | undefined, Fallback = unknown> = Schema extends NonNullable<Schema> ? Static<NonNullable<Schema>> : Fallback;
 export type TypedSchemaToRoute<Schema extends TypedSchema> = {
     body: UnwrapSchema<Schema['body']>;
-    headers: UnwrapSchema<Schema['headers']> extends Record<string, any> ? UnwrapSchema<Schema['headers']> : undefined;
-    query: UnwrapSchema<Schema['query']> extends Record<string, any> ? UnwrapSchema<Schema['query']> : undefined;
-    params: UnwrapSchema<Schema['params']> extends Record<string, any> ? UnwrapSchema<Schema['params']> : undefined;
-    response: UnwrapSchema<Schema['response']>;
+    headers: UnwrapSchema<Schema['headers']> extends infer Result extends Record<string, any> ? Result : undefined;
+    query: UnwrapSchema<Schema['query']> extends infer Result extends Record<string, any> ? Result : undefined;
+    params: UnwrapSchema<Schema['params']> extends infer Result extends Record<string, any> ? Result : undefined;
+    response: Schema['response'] extends TSchema ? UnwrapSchema<Schema['response']> : Schema['response'] extends {
+        [k in string]: TSchema;
+    } ? UnwrapSchema<ObjectValues<Schema['response']>> : unknown;
 };
 export type SchemaValidator = {
     body?: TypeCheck<any>;
@@ -88,10 +80,10 @@ export type SchemaValidator = {
     params?: TypeCheck<any>;
     response?: TypeCheck<any>;
 };
-export type HookHandler<Schema extends TypedSchema = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string> = Handler<TypedSchemaToRoute<Schema>['params'] extends {} ? Omit<TypedSchemaToRoute<Schema>, 'response'> & {
-    response: void | TypedSchemaToRoute<Schema>['response'];
-} : Omit<Omit<TypedSchemaToRoute<Schema>, 'response'> & {
-    response: void | TypedSchemaToRoute<Schema>['response'];
+export type HookHandler<Schema extends TypedSchema = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string, Typed extends TypedSchemaToRoute<Schema> = TypedSchemaToRoute<Schema>> = Handler<Typed['params'] extends {} ? Omit<Typed, 'response'> & {
+    response: void | Typed['response'];
+} : Omit<Omit<Typed, 'response'> & {
+    response: void | Typed['response'];
 }, 'params'> & {
     params: Record<ExtractPath<Path>, string>;
 }, Instance>;
@@ -105,24 +97,26 @@ export type MergeSchema<A extends TypedSchema, B extends TypedSchema> = {
     params: PickInOrder<PickInOrder<A['params'], B['params']>, undefined>;
     response: PickInOrder<PickInOrder<A['response'], B['response']>, undefined>;
 };
-export interface LocalHook<Schema extends TypedSchema<any> = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string> {
-    schema?: Schema;
-    transform?: WithArray<HookHandler<MergeSchema<Schema, Instance['schema']>, Instance, Path>>;
-    beforeHandle?: WithArray<HookHandler<MergeSchema<Schema, Instance['schema']>, Instance, Path>>;
+export interface LocalHook<Schema extends TypedSchema = TypedSchema, Instance extends ElysiaInstance<any> = ElysiaInstance, Path extends string = string, FinalSchema extends MergeSchema<Schema, Instance['schema']> = MergeSchema<Schema, Instance['schema']>> {
+    schema?: Schema & {
+        detail?: Partial<OpenAPIV2.OperationObject>;
+    };
+    transform?: WithArray<HookHandler<FinalSchema, Instance, Path>>;
+    beforeHandle?: WithArray<HookHandler<FinalSchema, Instance, Path>>;
     afterHandle?: WithArray<AfterRequestHandler<any, Instance>>;
     error?: WithArray<ErrorHandler>;
 }
-export type RouteToSchema<Schema extends TypedSchema<any> = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string> = MergeSchema<Schema, Instance['schema']>['params'] extends NonNullable<Schema['params']> ? TypedSchemaToRoute<MergeSchema<Schema, Instance['schema']>> : Omit<TypedSchemaToRoute<MergeSchema<Schema, Instance['schema']>>, 'params'> & {
+export type RouteToSchema<Schema extends TypedSchema = TypedSchema, Instance extends ElysiaInstance<any> = ElysiaInstance, Path extends string = string, FinalSchema extends MergeSchema<Schema, Instance['schema']> = MergeSchema<Schema, Instance['schema']>> = FinalSchema['params'] extends NonNullable<Schema['params']> ? TypedSchemaToRoute<FinalSchema> : Omit<TypedSchemaToRoute<FinalSchema>, 'params'> & {
     params: Record<ExtractPath<Path>, string>;
 };
-export type ElysiaRoute<Method extends string = string, Schema extends TypedSchema<any> = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string, CatchResponse = unknown> = Elysia<{
+export type ElysiaRoute<Method extends string = string, Schema extends TypedSchema = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string, CatchResponse = unknown, Typed extends RouteToSchema<Schema, Instance, Path> = RouteToSchema<Schema, Instance, Path>> = Elysia<{
     request: Instance['request'];
-    store: Instance['store'] & Record<typeof SCHEMA, Record<Path, Record<Method, RouteToSchema<Schema, Instance, Path> & {
-        response: RouteToSchema<Schema, Instance, Path>['response'] extends CatchResponse ? CatchResponse : RouteToSchema<Schema, Instance, Path>['response'];
+    store: Instance['store'] & Record<typeof SCHEMA, Record<Path, Record<Method, Typed & {
+        response: Typed['response'] extends CatchResponse ? CatchResponse : Typed['response'];
     }>>>;
     schema: Instance['schema'];
 }>;
-export type LocalHandler<Schema extends TypedSchema<any> = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string, CatchResponse = unknown> = Handler<RouteToSchema<Schema, Instance, Path>, Instance, CatchResponse>;
+export type LocalHandler<Schema extends TypedSchema = TypedSchema, Instance extends ElysiaInstance = ElysiaInstance, Path extends string = string, CatchResponse = unknown> = Handler<RouteToSchema<Schema, Instance, Path>, Instance, CatchResponse>;
 export interface TypedRoute {
     body?: unknown;
     headers?: Record<string, any>;
@@ -144,7 +138,6 @@ export type ComposedHandler = {
 };
 export interface ElysiaConfig {
     strictPath: boolean;
-    queryLimit: number;
     serve?: Partial<Serve>;
 }
 export type IsPathParameter<Part> = Part extends `:${infer Parameter}` ? Parameter : never;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "elysia",
   "description": "Fast, and friendly Bun web framework",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.2",
   "author": {
     "name": "saltyAom",
     "url": "https://github.com/SaltyAom",
@@ -35,15 +35,16 @@
     "release": "npm run build && npm run test && npm publish"
   },
   "dependencies": {
-    "@sinclair/typebox": "0.25.10"
+    "@sinclair/typebox": "0.25.21",
+    "openapi-types": "^12.1.0"
   },
   "devDependencies": {
-    "@types/node": "^18.11.10",
-    "@typescript-eslint/eslint-plugin": "^5.45.0",
-    "@typescript-eslint/parser": "^5.45.0",
-    "bun-types": "^0.3.0",
-    "eslint": "^8.29.0",
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.48.2",
+    "@typescript-eslint/parser": "^5.48.2",
+    "bun-types": "^0.5.0",
+    "eslint": "^8.32.0",
     "rimraf": "^3.0.2",
-    "typescript": "^4.9.3"
+    "typescript": "^4.9.4"
   }
 }