@deepkit/http 1.0.1-alpha.16 → 1.0.1-alpha.160

package/dist/esm/index.d.ts

@@ -1,10 +1,14 @@
-export * from './src/decorator';
-export * from './src/http';
-export * from './src/model';
-export * from './src/logger';
-export * from './src/router';
-export * from './src/static-serving';
-export * from './src/kernel';
-export * from './src/module';
-export * from './src/module.config';
-export * from './src/controllers';
+export * from './src/decorator.js';
+export * from './src/http.js';
+export * from './src/http-app.js';
+export * from './src/model.js';
+export * from './src/logger.js';
+export * from './src/router.js';
+export * from './src/static-serving.js';
+export * from './src/kernel.js';
+export * from './src/module.js';
+export * from './src/module.config.js';
+export * from './src/controllers.js';
+export * from './src/middleware.js';
+export * from './src/filter.js';
+export * from './src/utils.js';

package/dist/esm/index.js

@@ -1,11 +1,15 @@
-export * from './src/decorator';
-export * from './src/http';
-export * from './src/model';
-export * from './src/logger';
-export * from './src/router';
-export * from './src/static-serving';
-export * from './src/kernel';
-export * from './src/module';
-export * from './src/module.config';
-export * from './src/controllers';
+export * from './src/decorator.js';
+export * from './src/http.js';
+export * from './src/http-app.js';
+export * from './src/model.js';
+export * from './src/logger.js';
+export * from './src/router.js';
+export * from './src/static-serving.js';
+export * from './src/kernel.js';
+export * from './src/module.js';
+export * from './src/module.config.js';
+export * from './src/controllers.js';
+export * from './src/middleware.js';
+export * from './src/filter.js';
+export * from './src/utils.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC"}

package/dist/esm/src/controllers.d.ts

@@ -1,6 +1,13 @@
 import { ClassType } from '@deepkit/core';
+import { InjectorModule } from '@deepkit/injector';
 export declare class HttpControllers {
-    readonly controllers: ClassType[];
-    constructor(controllers: ClassType[]);
-    add(controller: ClassType): void;
+    readonly controllers: {
+        controller: ClassType;
+        module: InjectorModule<any>;
+    }[];
+    constructor(controllers?: {
+        controller: ClassType;
+        module: InjectorModule<any>;
+    }[]);
+    add(controller: ClassType, module: InjectorModule<any>): void;
 }

package/dist/esm/src/controllers.js

@@ -1,9 +1,13 @@
+/*@ts-ignore*/
+import { __ΩClassType } from '@deepkit/core';
+import { InjectorModule } from '@deepkit/injector';
 export class HttpControllers {
-    constructor(controllers) {
+    constructor(controllers = []) {
         this.controllers = controllers;
     }
-    add(controller) {
-        this.controllers.push(controller);
+    add(controller, module) {
+        this.controllers.push({ controller, module });
     }
 }
+HttpControllers.__type = [() => __ΩClassType, 'controller', () => InjectorModule, 'module', 'controllers', () => [], 'constructor', () => __ΩClassType, () => InjectorModule, 'add', 'HttpControllers', 'PPn!4"P"7#4$MF2%:9>&"0\'Pn(2"P"7)2$"0*5w+'];
 //# sourceMappingURL=controllers.js.map

package/dist/esm/src/controllers.js.map

@@ -1 +1 @@
-{"version":3,"file":"controllers.js","sourceRoot":"","sources":["../../../src/controllers.ts"],"names":[],"mappings":"AAEA,MAAM,OAAO,eAAe;IACxB,YAA4B,WAAwB;QAAxB,gBAAW,GAAX,WAAW,CAAa;IACpD,CAAC;IAEM,GAAG,CAAC,UAAqB;QAC5B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;IACtC,CAAC;CACJ"}
+{"version":3,"file":"controllers.js","sourceRoot":"","sources":["../../../src/controllers.ts"],"names":[],"mappings":";6BAA0B,eAAe;AACzC,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAEnD,MAAM,OAAO,eAAe;IACxB,YAA4B,cAAsE,EAAE;QAAxE,gBAAW,GAAX,WAAW,CAA6D;IACpG,CAAC;IAEM,GAAG,CAAC,UAAqB,EAAE,MAA2B;QACzD,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,EAAC,UAAU,EAAE,MAAM,EAAC,CAAC,CAAC;IAChD,CAAC"}

package/dist/esm/src/decorator.d.ts

@@ -1,20 +1,25 @@
 import { ClassType } from '@deepkit/core';
-import { ClassDecoratorResult, PropertyDecoratorResult } from '@deepkit/type';
-export interface ControllerOptions {
-    name: string;
-}
-declare class HttpController {
+import { ClassDecoratorResult, DecoratorAndFetchSignature, DualDecorator, ExtractApiDataType, ExtractClass, PropertyDecoratorFn, ReceiveType, SerializationOptions, Serializer, Type, UnionToIntersection } from '@deepkit/type';
+import { RouteParameterResolver } from './router.js';
+import { HttpMiddleware, HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
+type HttpActionMiddleware = (() => HttpMiddlewareConfig) | ClassType<HttpMiddleware> | HttpMiddlewareFn;
+export declare class HttpController {
     baseUrl: string;
-    protected actions: Set<HttpAction>;
+    actions: Set<HttpAction>;
     groups: string[];
+    middlewares: (() => HttpMiddlewareConfig)[];
+    resolverForToken: Map<any, ClassType>;
+    resolverForParameterName: Map<string, ClassType>;
+    private actionsProcessed;
     getUrl(action: HttpAction): string;
     addAction(action: HttpAction): void;
     getActions(): Set<HttpAction>;
+    removeAction(methodName: string): void;
     getAction(methodName: string): HttpAction;
 }
 export declare class HttpActionParameter {
     name: string;
-    type?: 'body' | 'query';
+    type?: 'body' | 'query' | 'queries';
     /**
      * undefined = propertyName, '' === root, else given path
      */
@@ -26,40 +31,87 @@ export declare class HttpAction {
     description: string;
     category: string;
     path: string;
-    httpMethod: string;
+    httpMethods: string[];
     methodName: string;
     groups: string[];
-    parameterRegularExpressions: {
-        [name: string]: any;
-    };
-    /**
-     * This is only filled when the user used @http.body() for example on an method argument.
-     */
-    parameters: {
-        [name: string]: HttpActionParameter;
-    };
+    serializer?: Serializer;
+    middlewares: (() => HttpMiddlewareConfig)[];
+    serializationOptions?: SerializationOptions;
+    resolverForToken: Map<any, ClassType>;
+    resolverForParameterName: Map<string, ClassType>;
     /**
      * An arbitrary data container the user can use to store app specific settings/values.
      */
     data: Map<any, any>;
-    throws: {
-        errorType: ClassType;
-        message?: string;
+    responses: {
+        statusCode: number;
+        description: string;
+        type?: Type;
     }[];
 }
-export declare class HttpDecorator {
+export declare class HttpControllerDecorator {
     t: HttpController;
     controller(baseUrl?: string): void;
-    groupAll(...group: string[]): void;
+    group(...group: string[]): void;
+    middleware(...middlewares: HttpActionMiddleware[]): void;
+    /**
+     * Adds a parameter resolver for parameters based on the class type. Use .resolveParameterByName() for name-based resolving.
+     *
+     * ```typescript
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
+     * }
+     *
+     * @http.resolveParameter(User, UserResolver)
+     * class MyController {
+     *
+     *     @http.GET()
+     *     myAction(user: User) {
+     *     }
+     * }
+     *
+     * new App({providers: [UserResolver]}).run();
+     * ```
+     */
+    resolveParameter(classType: ClassType | string | any, resolver: ClassType<RouteParameterResolver>): void;
+    /**
+     * Adds a parameter resolver for parameters based on its name. Use .resolveParameter() for class-based resolving.
+     *
+     * ```typescript
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
+     * }
+     *
+     * @http.resolveParameterByName('user', UserResolver)
+     * class MyController {
+     *
+     *     @http.GET()
+     *     myAction(user: User) {
+     *     }
+     * }
+     *
+     * new App({providers: [UserResolver]}).run();
+     * ```
+     */
+    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>): void;
     setAction(action: HttpAction): void;
 }
-export declare const httpClass: ClassDecoratorResult<typeof HttpDecorator>;
+export declare const httpClass: ClassDecoratorResult<typeof HttpControllerDecorator>;
+export declare function getActions(target: ClassType): HttpAction[];
 export declare class HttpActionDecorator {
     t: HttpAction;
-    onDecorator(target: ClassType, property: string): void;
+    onDecorator(target: ClassType, property: string | undefined, parameterIndexOrDescriptor?: any): void;
     name(name: string): void;
-    setParameter(name: string, parameter: HttpActionParameter): void;
     description(description: string): void;
+    serialization(options: SerializationOptions): void;
+    serializer(serializer: Serializer): void;
+    middleware(...middlewares: HttpActionMiddleware[]): void;
     /**
      * Allows to change the HttpAction object and composite multiple properties into one function.
      *
@@ -91,78 +143,100 @@ export declare class HttpActionDecorator {
      *    assets() {}
      * }
      * ```
-    */
+     */
     data(name: string, value: any): void;
     category(category: string): void;
     group(...group: string[]): void;
     GET(path?: string): void;
+    HEAD(path?: string): void;
     POST(path?: string): void;
     PUT(path?: string): void;
     DELETE(path?: string): void;
+    OPTIONS(path?: string): void;
+    TRACE(path?: string): void;
+    PATCH(path?: string): void;
     ANY(path?: string): void;
-    throws(errorType: ClassType, message?: string): void;
-    regexp(parameterName: string, regex: any): void;
-}
-declare class HttpActionParameterDecorator {
-    t: HttpActionParameter;
-    onDecorator(target: ClassType, propertyName?: string, parameterIndex?: number): void;
     /**
-     * Marks the argument as body parameter. Data from the client sent in the body
-     * will be tried to parsed (JSON/form data) and deserialized to the defined type.
-     * Make sure the class type as a schema assigned.
+     * Adds additional information about what HTTP status codes are available in this route.
+     * You can add additionally a description and a response body type.
+     *
+     * The type is used for serialization for responses with the given statusCode.
+     *
+     * This information is available in Deepkit API console.
+     *
+     * ```typescript
+     *
+     * http.GET().response<boolean>(200, 'All ok')
+     *
+     * interface User {
+     *     username: string;
+     * }
+     * http.GET().response<User>(200, 'User object')
+     *
+     * interface HttpErrorMessage {
+     *     error: string;
+     * }
+     * http.GET().response<HttpErrorMessage>(500, 'Error')
+     * ```
+     */
+    response<T>(statusCode: number, description?: string, type?: ReceiveType<T>): void;
+    /**
+     * Adds a parameter resolver for parameters based on the class type. Use .resolveParameterByName() for name-based resolving.
      *
-     * @example
      * ```typescript
-     * class MyActionBody {
-     *     @t name!: string;
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
      * }
      *
-     * class Controller {
+     * class MyController {
      *     @http.GET()
-     *     myAction(@http.body() body: MyActionBody) {
-     *         console.log('body', body.name);
+     *     @http.resolveParameter(User, UserResolver)
+     *     myAction(user: User) {
      *     }
      * }
+     *
+     * new App({providers: [UserResolver]}).run();
      * ```
      */
-    body(): void;
-    query(path?: string): void;
-    get optional(): void;
+    resolveParameter(classType: ClassType | string | any, resolver: ClassType<RouteParameterResolver>): void;
     /**
-     * Marks the argument as query parameter. Data from the query string is parsed
-     * and deserialized to the defined type.
-     * Define a `path` if you want to parse a subset of the query string only.
+     * Adds a parameter resolver for parameters based on its name. Use .resolveParameter() for class-based resolving.
      *
-     * Note: Make sure the defined parameter type has optional properties,
-     * otherwise it's always required to pass a query string.
-     *
-     * @example
      * ```typescript
-     * class MyActionQueries {
-     *     @t.optional name?: string;
+     *
+     * class UserResolver {
+     *     resolve(context: RouteParameterResolverContext): any | Promise<any> {
+     *         return new User();
+     *     }
      * }
      *
-     * class Controller {
-     *     @http.GET('my-action')
-     *     myAction(@http.queries() query: MyActionQueries) {
-     *         console.log('query', query.name);
+     * class MyController {
+     *     @http.GET()
+     *     @http.resolveParameterByName('user', UserResolver)
+     *     myAction(user: User) {
      *     }
      * }
      *
-     * // Open via, e.g.
-     * // -> /my-action?name=Peter
+     * new App({providers: [UserResolver]}).run();
      * ```
-     *
      */
-    queries(path?: string): void;
+    resolveParameterByName(name: string, resolver: ClassType<RouteParameterResolver>): void;
 }
-export declare const httpAction: PropertyDecoratorResult<typeof HttpActionDecorator>;
-export declare const httpActionParameter: PropertyDecoratorResult<typeof HttpActionParameterDecorator>;
-export declare const http: Pick<import("@deepkit/type").FluidDecorator<HttpDecorator, import("@deepkit/type").ClassDecoratorFn> & ((classType: ClassType<any>) => void) & {
-    _fetch: (classType: ClassType<any>) => HttpController | undefined;
-} & import("@deepkit/type").FluidDecorator<HttpActionDecorator, import("@deepkit/type").PropertyDecoratorFn> & ((prototype: object, property: string, parameterIndexOrDescriptor?: any) => void) & {
-    _fetch: (classType: ClassType<any>, property: string, parameterIndexOrDescriptor?: any) => HttpAction | undefined;
-} & import("@deepkit/type").FluidDecorator<HttpActionParameterDecorator, import("@deepkit/type").PropertyDecoratorFn> & {
-    _fetch: (classType: ClassType<any>, property: string, parameterIndexOrDescriptor?: any) => HttpActionParameter | undefined;
-}, "name" | "t" | "onDecorator" | "description" | "data" | "ANY" | "regexp" | "throws" | "body" | "query" | "GET" | "controller" | "groupAll" | "setAction" | "POST" | "PUT" | "DELETE" | "setParameter" | "use" | "category" | "group" | "optional" | "queries">;
+type HttpActionFluidDecorator<T, D extends Function> = {
+    [name in keyof T]: name extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => D & HttpActionFluidDecorator<T, D> : T[name] extends (...args: infer K) => any ? (...args: K) => D & HttpActionFluidDecorator<T, D> : D & HttpActionFluidDecorator<T, D> & {
+        _data: ExtractApiDataType<T>;
+    };
+};
+type HttpActionPropertyDecoratorResult = HttpActionFluidDecorator<ExtractClass<typeof HttpActionDecorator>, PropertyDecoratorFn> & DecoratorAndFetchSignature<typeof HttpActionDecorator, PropertyDecoratorFn>;
+export declare const httpAction: HttpActionPropertyDecoratorResult;
+type HttpMerge<U> = {
+    [K in keyof U]: K extends 'response' ? <T2>(statusCode: number, description?: string, type?: ReceiveType<T2>) => PropertyDecoratorFn & U : U[K] extends ((...a: infer A) => infer R) ? R extends DualDecorator ? (...a: A) => PropertyDecoratorFn & R & U : (...a: A) => R : never;
+};
+type MergedHttp<T extends any[]> = HttpMerge<Omit<UnionToIntersection<T[number]>, '_fetch' | 't'>>;
+export type HttpDecorator = PropertyDecoratorFn & HttpActionFluidDecorator<HttpActionDecorator, PropertyDecoratorFn>;
+export declare const http: MergedHttp<[typeof httpClass, typeof httpAction]>;
 export {};
+export declare type __ΩHttpDecorator = any[];