@deepkit/http 1.0.1-alpha.59 → 1.0.1-alpha.63

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

@@ -1,11 +1,10 @@
-import 'reflect-metadata';
 import { ClassType, CompilerContext } from '@deepkit/core';
-import { JitConverterOptions, PropertySchema, Serializer, ValidationFailedItem } from '@deepkit/type';
+import { ReflectionParameter, SerializationOptions, Serializer, Type } from '@deepkit/type';
 import { HttpRequest, HttpRequestQuery, HttpRequestResolvedParameters } from './model';
-import { InjectorContext, TagRegistry } from '@deepkit/injector';
-import { Logger } from '@deepkit/logger';
+import { InjectorContext, InjectorModule, TagRegistry } from '@deepkit/injector';
+import { LoggerInterface } from '@deepkit/logger';
 import { HttpControllers } from './controllers';
-import { AppModule, MiddlewareRegistry } from '@deepkit/app';
+import { MiddlewareRegistry } from '@deepkit/app';
 import { HttpMiddlewareConfig, HttpMiddlewareFn } from './middleware';
 export declare type RouteParameterResolverForInjector = ((injector: InjectorContext) => any[] | Promise<any[]>);
 interface ResolvedController {
@@ -43,19 +42,10 @@ export declare class UploadedFile {
     lastModifiedDate: Date | null;
 }
 export interface RouteControllerAction {
-    module?: AppModule<any>;
+    module?: InjectorModule<any>;
     controller: ClassType;
     methodName: string;
 }
-export interface RouteParameterConfig {
-    type?: 'body' | 'query' | 'queries';
-    /**
-     * undefined = propertyName, '' === root, else given path
-     */
-    typePath?: string;
-    optional: boolean;
-    name: string;
-}
 export declare class RouteConfig {
     readonly name: string;
     readonly httpMethods: string[];
@@ -63,77 +53,54 @@ export declare class RouteConfig {
     readonly action: RouteControllerAction;
     internal: boolean;
     baseUrl: string;
-    parameterRegularExpressions: {
-        [name: string]: any;
-    };
     responses: {
         statusCode: number;
         description: string;
-        type?: PropertySchema;
+        type?: Type;
     }[];
     description: string;
     groups: string[];
     category: string;
-    /**
-     * This is set when the route action has a manual return type defined using @t.
-     */
-    returnSchema?: PropertySchema;
-    serializationOptions?: JitConverterOptions;
+    returnType?: Type;
+    serializationOptions?: SerializationOptions;
     serializer?: Serializer;
     /**
      * When assigned defines where this route came from.
      */
-    module?: AppModule<any>;
+    module?: InjectorModule<any>;
     resolverForToken: Map<any, ClassType>;
     middlewares: {
         config: HttpMiddlewareConfig;
-        module: AppModule<any>;
+        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, httpMethods: string[], path: string, action: RouteControllerAction, internal?: boolean);
-    getSchemaForResponse(statusCode: number): PropertySchema | undefined;
+    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 {
     routeConfig: RouteConfig;
     regex?: string;
-    customValidationErrorHandling?: ParsedRouteParameter;
     pathParameterNames: {
         [name: string]: number;
     };
     protected parameters: ParsedRouteParameter[];
     constructor(routeConfig: RouteConfig);
-    addParameter(property: PropertySchema, config?: RouteParameterConfig): ParsedRouteParameter;
+    addParameter(property: ReflectionParameter): ParsedRouteParameter;
     getParameters(): ParsedRouteParameter[];
     getParameter(name: string): ParsedRouteParameter;
 }
 declare class ParsedRouteParameter {
-    property: PropertySchema;
-    config?: RouteParameterConfig | undefined;
+    parameter: ReflectionParameter;
     regexPosition?: number;
-    constructor(property: PropertySchema, config?: RouteParameterConfig | undefined);
+    constructor(parameter: ReflectionParameter);
     get body(): boolean;
+    get bodyValidation(): boolean;
+    getType(): Type;
     get query(): boolean;
     get queries(): boolean;
     get typePath(): string | undefined;
@@ -170,16 +137,16 @@ export declare class Router {
     }) => string;
     protected routes: RouteConfig[];
     private parseBody;
-    constructor(controllers: HttpControllers, logger: Logger, tagRegistry: TagRegistry, middlewareRegistry?: MiddlewareRegistry);
+    constructor(controllers: HttpControllers, logger: LoggerInterface, tagRegistry: TagRegistry, middlewareRegistry?: MiddlewareRegistry);
     getRoutes(): RouteConfig[];
     static forControllers(controllers: (ClassType | {
-        module: AppModule<any>;
+        module: InjectorModule<any>;
         controller: ClassType;
-    })[], tagRegistry?: TagRegistry, middlewareRegistry?: MiddlewareRegistry, module?: AppModule<any>): Router;
+    })[], tagRegistry?: TagRegistry, middlewareRegistry?: MiddlewareRegistry, module?: InjectorModule<any>): Router;
     protected getRouteCode(compiler: CompilerContext, routeConfig: RouteConfig): string;
     protected getRouteUrlResolveCode(compiler: CompilerContext, routeConfig: RouteConfig): string;
     addRoute(routeConfig: RouteConfig): void;
-    addRouteForController(controller: ClassType, module: AppModule<any>): void;
+    addRouteForController(controller: ClassType, module: InjectorModule<any>): void;
     protected build(): (request: HttpRequest) => ResolvedController | undefined;
     protected buildUrlResolver(): any;
     resolveUrl(routeName: string, parameters?: {
@@ -189,3 +156,7 @@ export declare class Router {
     resolve(method: string, url: string): ResolvedController | undefined;
 }
 export {};
+export declare type __ΩRouteParameterResolverForInjector = any[];
+export declare type __ΩRouteControllerAction = any[];
+export declare type __ΩRouteParameterResolver = any[];
+export declare type __ΩRouteParameterResolverContext = any[];