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

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

@@ -1,91 +1,114 @@
 import { ClassType, CompilerContext } from '@deepkit/core';
-import { PropertySchema, ValidationFailedItem } from '@deepkit/type';
-import { HttpRequest, HttpRequestQuery, HttpRequestResolvedParameters } from './model';
-import { BasicInjector, NormalizedProvider, Tag } from '@deepkit/injector';
-import { Logger } from '@deepkit/logger';
-import { TagProviders } from '@deepkit/app';
-import { HttpControllers } from './controllers';
-export declare type RouteParameterResolverForInjector = ((injector: BasicInjector) => any[] | Promise<any[]>);
-declare type ResolvedController = {
+import { ReflectionFunction, ReflectionParameter, SerializationOptions, Serializer, Type } from '@deepkit/type';
+import { HttpDecorator } from './decorator.js';
+import { HttpRequest, HttpRequestPositionedParameters, HttpRequestQuery, HttpRequestResolvedParameters } from './model.js';
+import { InjectorContext, InjectorModule } from '@deepkit/injector';
+import { LoggerInterface } from '@deepkit/logger';
+import { HttpControllers } from './controllers.js';
+import { MiddlewareRegistry } from '@deepkit/app';
+import { HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware.js';
+import { ParameterForRequestParser } from './request-parser.js';
+import { HttpConfig } from './module.config.js';
+export type RouteParameterResolverForInjector = ((injector: InjectorContext) => HttpRequestPositionedParameters | Promise<HttpRequestPositionedParameters>);
+interface ResolvedController {
     parameters: RouteParameterResolverForInjector;
     routeConfig: RouteConfig;
-};
-export interface RouteControllerAction {
-    controller: ClassType;
-    methodName: string;
+    uploadedFiles: {
+        [name: string]: UploadedFile;
+    };
+    middlewares?: (injector: InjectorContext) => {
+        fn: HttpMiddlewareFn;
+        timeout?: number;
+    }[];
 }
-export interface RouteParameterConfig {
-    type?: 'body' | 'query';
+export declare const UploadedFileSymbol: unique symbol;
+export declare class UploadedFile {
+    /**
+     * Validator to ensure the file was provided by the framework, and not the user spoofing it.
+     */
+    validator: typeof UploadedFileSymbol | null;
     /**
-     * undefined = propertyName, '' === root, else given path
+     * The size of the uploaded file in bytes.
      */
-    typePath?: string;
-    optional: boolean;
-    name: string;
+    size: number;
+    /**
+     * The local path this file is being written to. Will be deleted when request is handled.
+     */
+    path: string;
+    /**
+     * The name this file had according to the uploading client.
+     */
+    name: string | null;
+    /**
+     * The mime type of this file, according to the uploading client.
+     */
+    type: string | null;
+    /**
+     * A Date object (or `null`) containing the time this file was last written to.
+     * Mostly here for compatibility with the [W3C File API Draft](http://dev.w3.org/2006/webapi/FileAPI/).
+     */
+    lastModifiedDate: Date | null;
+}
+export interface RouteFunctionControllerAction {
+    type: 'function';
+    module?: InjectorModule<any>;
+    fn: (...args: any[]) => any;
+}
+export interface RouteClassControllerAction {
+    type: 'controller';
+    module?: InjectorModule<any>;
+    controller: ClassType;
+    methodName: string;
 }
+export declare function getRouteActionLabel(action: RouteClassControllerAction | RouteFunctionControllerAction): string;
 export declare class RouteConfig {
     readonly name: string;
-    readonly httpMethod: string;
+    readonly httpMethods: string[];
     readonly path: string;
-    readonly action: RouteControllerAction;
+    readonly action: RouteClassControllerAction | RouteFunctionControllerAction;
+    internal: boolean;
     baseUrl: string;
-    parameterRegularExpressions: {
-        [name: string]: any;
-    };
-    throws: {
-        errorType: ClassType;
-        message?: string;
+    responses: {
+        statusCode: number;
+        description: string;
+        type?: Type;
     }[];
     description: string;
     groups: string[];
     category: string;
+    returnType?: Type;
+    serializationOptions?: SerializationOptions;
+    serializer?: Serializer;
+    /**
+     * When assigned defines where this route came from.
+     */
+    module?: InjectorModule<any>;
+    resolverForToken: Map<any, ClassType>;
+    middlewares: {
+        config: HttpMiddlewareConfig;
+        module?: InjectorModule<any>;
+    }[];
+    resolverForParameterName: Map<string, ClassType>;
     /**
      * An arbitrary data container the user can use to store app specific settings/values.
      */
     data: Map<any, any>;
-    parameters: {
-        [name: string]: RouteParameterConfig;
-    };
-    constructor(name: string, httpMethod: string, path: string, action: RouteControllerAction);
+    constructor(name: string, httpMethods: string[], path: string, action: RouteClassControllerAction | RouteFunctionControllerAction, internal?: boolean);
+    getReflectionFunction(): ReflectionFunction;
+    getSchemaForResponse(statusCode: number): Type | undefined;
     getFullPath(): string;
 }
-/**
- * When this class is injected into a route, then validation errors are not automatically thrown (using onHttpControllerValidationError event),
- * but injected to the route itself. The user is then responsible to handle the errors.
- *
- * Note: The body parameter is still passed, however it might contain now invalid data. The BodyValidation tells what data is invalid.
- */
-export declare class BodyValidation {
-    readonly errors: ValidationFailedItem[];
-    constructor(errors?: ValidationFailedItem[]);
-    hasErrors(prefix?: string): boolean;
-    getErrors(prefix?: string): ValidationFailedItem[];
-    getErrorsForPath(path: string): ValidationFailedItem[];
-    getErrorMessageForPath(path: string): string;
-}
-declare class ParsedRoute {
+export declare class ParsedRoute {
     routeConfig: RouteConfig;
     regex?: string;
-    customValidationErrorHandling?: ParsedRouteParameter;
     pathParameterNames: {
         [name: string]: number;
     };
-    protected parameters: ParsedRouteParameter[];
+    protected parameters: ParameterForRequestParser[];
     constructor(routeConfig: RouteConfig);
-    addParameter(property: PropertySchema, config?: RouteParameterConfig): ParsedRouteParameter;
-    getParameters(): ParsedRouteParameter[];
-    getParameter(name: string): ParsedRouteParameter;
-}
-declare class ParsedRouteParameter {
-    property: PropertySchema;
-    config?: RouteParameterConfig | undefined;
-    regexPosition?: number;
-    constructor(property: PropertySchema, config?: RouteParameterConfig | undefined);
-    get body(): boolean;
-    get query(): boolean;
-    get typePath(): string | undefined;
-    getName(): string;
-    isPartOfPath(): boolean;
+    addParameter(property: ReflectionParameter): ParameterForRequestParser;
+    getParameters(): ParameterForRequestParser[];
+    getParameter(name: string): ParameterForRequestParser;
 }
 export declare function parseRouteControllerAction(routeConfig: RouteConfig): ParsedRoute;
 export declare function dotToUrlPath(dotPath: string): string;
@@ -93,35 +116,105 @@ export interface RouteParameterResolver {
     resolve(context: RouteParameterResolverContext): any | Promise<any>;
 }
 export interface RouteParameterResolverContext {
-    classType: ClassType;
+    token: ClassType | string | symbol | any;
     route: RouteConfig;
     request: HttpRequest;
+    /**
+     * The parameter name (variable name).
+     */
+    name: any;
+    /**
+     * The raw parameter value from the path, if the parameter is defined in the path (e.g. /user/:name).
+     * If not in the path, you have to use `parameters.<name>` instead.
+     */
+    value: any;
     query: HttpRequestQuery;
     parameters: HttpRequestResolvedParameters;
+    type: ReflectionParameter;
 }
-export declare class RouteParameterResolverTag extends Tag<RouteParameterResolver> {
-    provider: NormalizedProvider;
-    classTypes: ClassType[];
-    constructor(provider: NormalizedProvider);
-    forClassType(...classTypes: ClassType[]): this;
+export interface HttpRouterFunctionOptions {
+    path: string;
+    name?: string;
+    methods?: string[];
+    description?: string;
+    category?: string;
+    groups?: string[];
+    /**
+     * An arbitrary data container the user can use to store app specific settings/values.
+     */
+    data?: Record<any, any>;
+    baseUrl?: string;
+    middlewares?: (() => HttpMiddlewareConfig)[];
+    serializer?: Serializer;
+    serializationOptions?: SerializationOptions;
+    resolverForToken?: Map<any, ClassType>;
+    resolverForParameterName?: Map<string, ClassType>;
+    responses?: {
+        statusCode: number;
+        description: string;
+        type?: Type;
+    }[];
+}
+export declare abstract class HttpRouterRegistryFunctionRegistrar {
+    protected defaultOptions: Partial<HttpRouterFunctionOptions>;
+    abstract addRoute(routeConfig: RouteConfig): void;
+    /**
+     * Returns a new registrar object with default options that apply to each registered route through this registrar.
+     *
+     * ```typescript
+     * const registry: HttpRouterRegistry = ...;
+     *
+     * const secretRegistry = registry.forOptions({groups: ['secret']});
+     *
+     * secretRegistry.get('/admin/groups', () => {
+     * });
+     *
+     * secretRegistry.get('/admin/users', () => {
+     * });
+     * ```
+     */
+    forOptions(options: Partial<HttpRouterFunctionOptions>): HttpRouterRegistryFunctionRegistrar;
+    any(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    add(decorator: HttpDecorator, callback: (...args: any[]) => any): void;
+    get(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    post(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    put(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    patch(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    delete(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    options(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    trace(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    head(pathOrOptions: string | HttpRouterFunctionOptions, callback: (...args: any[]) => any): void;
+    private register;
 }
-export declare class Router {
+export declare class HttpRouterRegistry extends HttpRouterRegistryFunctionRegistrar {
+    protected routes: RouteConfig[];
+    private buildId;
+    getBuildId(): number;
+    getRoutes(): RouteConfig[];
+    addRouteForController(controller: ClassType, module: InjectorModule<any>): void;
+    addRoute(routeConfig: RouteConfig): void;
+}
+export declare class HttpRouter {
     private logger;
+    private config;
+    private middlewareRegistry;
+    private registry;
     protected fn?: (request: HttpRequest) => ResolvedController | undefined;
+    protected buildId: number;
     protected resolveFn?: (name: string, parameters: {
         [name: string]: any;
     }) => string;
-    protected routes: RouteConfig[];
-    protected parameterResolverTags: RouteParameterResolverTag[];
-    protected form: any;
-    constructor(controllers: HttpControllers, logger: Logger, tagProviders: TagProviders);
+    constructor(controllers: HttpControllers, logger: LoggerInterface, config: HttpConfig, middlewareRegistry?: MiddlewareRegistry, registry?: HttpRouterRegistry);
     getRoutes(): RouteConfig[];
-    static forControllers(controllers: ClassType[], tagProviders?: TagProviders): Router;
+    static forControllers(controllers: (ClassType | {
+        module: InjectorModule<any>;
+        controller: ClassType;
+    })[], middlewareRegistry?: MiddlewareRegistry, module?: InjectorModule<any>, config?: HttpConfig): HttpRouter;
     protected getRouteCode(compiler: CompilerContext, routeConfig: RouteConfig): string;
     protected getRouteUrlResolveCode(compiler: CompilerContext, routeConfig: RouteConfig): string;
     addRoute(routeConfig: RouteConfig): void;
-    addRouteForController(controller: ClassType): void;
-    protected build(): any;
+    addRouteForController(controller: ClassType, module: InjectorModule<any>): void;
+    protected build(): (request: HttpRequest) => ResolvedController | undefined;
     protected buildUrlResolver(): any;
     resolveUrl(routeName: string, parameters?: {
         [name: string]: any;
@@ -130,3 +223,9 @@ export declare class Router {
     resolve(method: string, url: string): ResolvedController | undefined;
 }
 export {};
+export declare type __ΩRouteParameterResolverForInjector = any[];
+export declare type __ΩRouteFunctionControllerAction = any[];
+export declare type __ΩRouteClassControllerAction = any[];
+export declare type __ΩRouteParameterResolver = any[];
+export declare type __ΩRouteParameterResolverContext = any[];
+export declare type __ΩHttpRouterFunctionOptions = any[];