elysia - npm Package Compare versions

Comparing version 0.2.0-beta.1 to 0.2.0-beta.2

dist/index.d.ts

 /// <reference types="bun-types" />
 import type { Serve, Server } from 'bun';
+import { Router } from './router';
 import { SCHEMA } from './utils';
@@ -49,3 +50,3 @@ import type { Context } from './context';
     }>): 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>;
@@ -102,7 +103,6 @@ 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>;
 }
-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';

dist/index.js

@@ -37,3 +37,2 @@ import { Router } from './router';
             strictPath: false,
-            queryLimit: 48,
             ...config
@@ -263,3 +262,3 @@ };
             query: getSchemaValidator(schema?.query),
-            response: getSchemaValidator(schema?.response)
+            response: getSchemaValidator(schema?.response?.['200'] ?? schema.response)
         };
@@ -459,5 +458,4 @@ return this;
 }
-export { Elysia };
+export { Elysia, Router };
 export { Type as t } from '@sinclair/typebox';
 export { SCHEMA, getPath, createValidationError, getSchemaValidator } from './utils';
-export { Router } from './router';

dist/schema.d.ts

 import type { TSchema } from '@sinclair/typebox';
+import type { OpenAPIV2 } from 'openapi-types';
 import type { HTTPMethod, LocalHook } from './types';
@@ -11,10 +12,10 @@ export declare const toOpenAPIPath: (path: string) => string;
 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;

dist/schema.js

@@ -18,2 +18,3 @@ export const toOpenAPIPath = (path) => path
     const responseSchema = hook?.schema?.response;
+    const detail = hook?.schema?.detail;
     const parameters = [
@@ -46,5 +47,6 @@ ...mapProperties('header', headerSchema),
                 }
-                : {})
+                : {}),
+            ...detail
         }
     };
 };

dist/types.d.ts

@@ -5,8 +5,10 @@ /// <reference types="bun-types" />
 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>;
@@ -19,7 +21,7 @@ schema?: TypedSchema;
 }> {
-    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>;
@@ -59,20 +61,8 @@ export type LifeCycleEvent = 'start' | 'request' | 'parse' | 'transform' | 'beforeHandle' | 'afterHandle' | 'error' | 'stop';
 }
-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>;
 }
@@ -82,6 +72,8 @@ export type UnwrapSchema<Schema extends TSchema | undefined, Fallback = unknown> = Schema extends NonNullable<Schema> ? Static<NonNullable<Schema>> : Fallback;
     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;
 };
@@ -95,6 +87,6 @@ export type SchemaValidator = {
 };
-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'> & {
@@ -113,20 +105,22 @@ params: Record<ExtractPath<Path>, string>;
 };
-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 {
@@ -153,3 +147,2 @@ body?: unknown;
     strictPath: boolean;
-    queryLimit: number;
     serve?: Partial<Serve>;
@@ -156,0 +149,0 @@ }

package.json

 {
   "name": "elysia",
   "description": "Fast, and friendly Bun web framework",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.2",
   "author": {
@@ -38,13 +38,14 @@ "name": "saltyAom",
   "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"
   }
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

64357

increased by0.84%

Worsened metrics

Dependency count

2

increased by100%

Lines of code

1373

decreased by-0.36%

Dependency changes

• + Addedopenapi-types@^12.1.0

• + Added@sinclair/typebox@0.25.21(transitive)

• + Addedopenapi-types@12.1.3(transitive)

• - Removed@sinclair/typebox@0.25.10(transitive)

• Updated@sinclair/typebox@0.25.21