@velajs/vela 1.18.0 → 1.19.1

package/dist/http/argument-resolver.js

@@ -1,89 +0,0 @@
-import { getCookie } from "hono/cookie";
-import { ParamType } from "../constants.js";
-import { instantiate } from "./instantiate.js";
-const PARAM_EXTRACTORS = new Map([
-    [
-        ParamType.PARAM,
-        (c, p)=>p.name ? c.req.param(p.name) : c.req.param()
-    ],
-    [
-        ParamType.QUERY,
-        (c, p)=>p.name ? c.req.query(p.name) : c.req.query()
-    ],
-    [
-        ParamType.BODY,
-        async (c, p)=>{
-            let body;
-            try {
-                body = await c.req.json();
-            } catch  {
-                return undefined;
-            }
-            return p.name && body !== null && typeof body === 'object' ? body[p.name] : body;
-        }
-    ],
-    [
-        ParamType.HEADERS,
-        (c, p)=>p.name ? c.req.header(p.name) : c.req.header()
-    ],
-    [
-        ParamType.REQUEST,
-        (c)=>c
-    ],
-    [
-        ParamType.RESPONSE,
-        (c)=>c
-    ],
-    [
-        ParamType.COOKIE,
-        (c, p)=>p.name ? getCookie(c, p.name) : getCookie(c)
-    ],
-    [
-        ParamType.RAW_BODY,
-        async (c)=>new Uint8Array(await c.req.arrayBuffer())
-    ]
-]);
-// Pulls handler arguments from the request, applies shared pipes (global +
-// controller + method) and then per-param pipes. Empty paramMetadata returns
-// `[c]` to match the old direct-Hono-handler shape — a back-compat behavior
-// the framework's tests rely on.
-export class ArgumentResolver {
-    ipExtractor;
-    constructor(ipExtractor){
-        this.ipExtractor = ipExtractor;
-    }
-    async extract(c, paramMetadata, pipes, requestContainer, paramTypes) {
-        if (paramMetadata.length === 0) {
-            return [
-                c
-            ];
-        }
-        const maxIndex = paramMetadata.at(-1).index;
-        const args = new Array(maxIndex + 1).fill(undefined);
-        for (const param of paramMetadata){
-            let value = await this.extractParam(c, param);
-            const metadata = {
-                type: param.type,
-                data: param.name,
-                metatype: param.metatype ?? paramTypes?.[param.index]
-            };
-            for (const pipe of pipes){
-                value = await pipe.transform(value, metadata);
-            }
-            if (param.pipes && param.pipes.length > 0) {
-                for (const paramPipe of param.pipes){
-                    const pipeInstance = instantiate(paramPipe, requestContainer);
-                    value = await pipeInstance.transform(value, metadata);
-                }
-            }
-            args[param.index] = value;
-        }
-        return args;
-    }
-    extractParam(c, param) {
-        if (param.type === ParamType.IP) return this.ipExtractor(c);
-        const extractor = PARAM_EXTRACTORS.get(param.type);
-        if (extractor) return extractor(c, param);
-        return param.factory ? param.factory(param.name, c) : undefined;
-    }
-}

package/dist/http/decorators.d.ts

@@ -1,198 +0,0 @@
-import type { Constructor, PipeType } from '../registry/types';
-import type { ControllerOptions } from './types';
-import type { ExecutionContext } from '../pipeline/types';
-/**
- * Marks a class as a controller.
- * Accepts a path string or an options object with `path` and `version`.
- *
- * @example
- * ```ts
- * @Controller('/users')
- * @Controller({ path: '/users', version: 1 })
- * @Controller({ path: '/users', version: [1, 2] })
- * ```
- */
-export declare function Controller(pathOrOptions?: string | ControllerOptions): ClassDecorator;
-/**
- * Override the version for a specific route method.
- *
- * @example
- * ```ts
- * @Controller({ prefix: '/users', version: 1 })
- * class UserController {
- *   @Get()
- *   listV1() { ... }          // GET /v1/users
- *
- *   @Version(2)
- *   @Get()
- *   listV2() { ... }          // GET /v2/users
- * }
- * ```
- */
-export declare function Version(version: number | number[]): MethodDecorator;
-export declare function getRouteVersion(target: Constructor, propertyKey: string | symbol): number | number[] | undefined;
-/** Per-route options for the HTTP method decorators (`@Get`, `@Post`, …). */
-export interface RouteOptions {
-    /**
-     * A stable, human-readable name for this route. Enables URL generation
-     * (`UrlGeneratorService.urlFor(name, …)`), surfaces on `app.describeRoutes()`,
-     * and — when set — becomes the OpenAPI `operationId`.
-     */
-    name?: string;
-}
-export declare const Get: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Post: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Put: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Patch: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Delete: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Options: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Head: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const All: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Sse: (path?: string, options?: RouteOptions) => MethodDecorator;
-export declare const Param: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Query: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Body: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Headers: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Req: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Injects the Hono `Context` as the response handle.
- * In Hono, request and response state are unified in the `Context` object,
- * so `@Res()` and `@Req()` both return it.
- *
- * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
- *
- * @example
- * ```ts
- * @Get('/set-cookie')
- * handle(@Res() c: Context) {
- *   c.setCookie('session', 'abc123', { httpOnly: true });
- *   return { ok: true };
- * }
- * ```
- */
-export declare const Res: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Ip: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-export declare const Cookie: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
- *
- * - `@Cookie()` — all cookies as an object
- * - `@Cookie('token')` — the value of the `token` cookie
- *
- * @example
- * ```ts
- * @Get('/me')
- * handle(@Cookie('session') session: string) { ... }
- * ```
- */
-export declare const Cookies: (nameOrPipe?: string | PipeType, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Injects the raw request body as a `Uint8Array`.
- * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
- * need the raw bytes before any JSON parsing.
- *
- * @example
- * ```ts
- * @Post('/webhook')
- * async handle(@RawBody() body: Uint8Array) {
- *   const sig = new TextDecoder().decode(body);
- *   // verify HMAC...
- * }
- * ```
- */
-export declare function RawBody(): ParameterDecorator;
-/**
- * Factory for creating custom parameter decorators.
- *
- * @example
- * ```ts
- * const CurrentUser = createParamDecorator(
- *   (data: unknown, ctx: ExecutionContext) => {
- *     const req = ctx.getRequest();
- *     return req.headers.get('x-user-id');
- *   }
- * );
- *
- * // Usage:
- * @Get()
- * handle(@CurrentUser() userId: string) { ... }
- *
- * // With data argument:
- * const Header = createParamDecorator(
- *   (data: string, ctx: ExecutionContext) => {
- *     return ctx.getRequest().headers.get(data);
- *   }
- * );
- *
- * @Get()
- * handle(@Header('x-request-id') requestId: string) { ... }
- * ```
- */
-export declare function createParamDecorator<TData = unknown>(factory: (data: TData, ctx: ExecutionContext) => unknown): (data?: TData, ...pipes: PipeType[]) => ParameterDecorator;
-/**
- * Override the HTTP status code for a handler's response.
- *
- * @example
- * ```ts
- * @Post()
- * @HttpCode(201)
- * create(@Body() data: CreateDto) { return data; }
- * ```
- */
-export declare function HttpCode(statusCode: number): MethodDecorator;
-/**
- * Set a response header declaratively.
- * Can be applied multiple times to set multiple headers.
- *
- * @example
- * ```ts
- * @Get()
- * @Header('Cache-Control', 'no-cache')
- * @Header('X-Custom', 'value')
- * handle() { return { ok: true }; }
- * ```
- */
-export declare function Header(name: string, value: string): MethodDecorator;
-/**
- * Redirect to another URL. The handler's return value can override the URL.
- *
- * @example
- * ```ts
- * @Get('/old')
- * @Redirect('/new', 301)
- * handleOld() {}
- *
- * // Dynamic redirect — return { url, statusCode? } to override
- * @Get('/go')
- * @Redirect('/default')
- * handleGo(@Query('to') to?: string) {
- *   if (to) return { url: to };
- * }
- * ```
- */
-export declare function Redirect(url: string, statusCode?: number): MethodDecorator;
-export declare function getHttpCode(target: Constructor, method: string | symbol): number | undefined;
-export declare function getResponseHeaders(target: Constructor, method: string | symbol): Array<[string, string]>;
-export declare function getRedirect(target: Constructor, method: string | symbol): {
-    url: string;
-    statusCode: number;
-} | undefined;
-/**
- * Composes multiple decorators into one. Applies them in order (top to bottom),
- * matching how stacked decorators behave when written separately.
- *
- * @example
- * ```ts
- * const Auth = (...roles: string[]) => applyDecorators(
- *   UseGuards(JwtGuard, RolesGuard),
- *   SetMetadata('roles', roles),
- * );
- *
- * @Auth('admin')
- * @Get('/admin')
- * handle() { ... }
- * ```
- */
-export type ComposedDecorator = <T>(target: T, propertyKey?: string | symbol, descriptor?: PropertyDescriptor | number) => void;
-export declare function applyDecorators(...decorators: Array<ClassDecorator | MethodDecorator | PropertyDecorator | ParameterDecorator>): ComposedDecorator;
-export declare function isController(target: Constructor): boolean;

package/dist/http/decorators.js

@@ -1,321 +0,0 @@
-import { HttpMethod, ParamType, Scope } from "../constants.js";
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { normalizePath } from "../registry/paths.js";
-import { buildExecutionContext } from "./execution-context.js";
-/**
- * Marks a class as a controller.
- * Accepts a path string or an options object with `path` and `version`.
- *
- * @example
- * ```ts
- * @Controller('/users')
- * @Controller({ path: '/users', version: 1 })
- * @Controller({ path: '/users', version: [1, 2] })
- * ```
- */ export function Controller(pathOrOptions) {
-    return (target)=>{
-        const ctor = target;
-        const path = typeof pathOrOptions === 'string' ? pathOrOptions : pathOrOptions?.path ?? '';
-        const version = typeof pathOrOptions === 'object' ? pathOrOptions?.version : undefined;
-        MetadataRegistry.setControllerPath(ctor, normalizePath(path));
-        if (version !== undefined) {
-            MetadataRegistry.setControllerOptions(ctor, {
-                version
-            });
-        }
-        MetadataRegistry.markInjectable(ctor);
-        MetadataRegistry.setScope(ctor, Scope.SINGLETON);
-    };
-}
-/**
- * Override the version for a specific route method.
- *
- * @example
- * ```ts
- * @Controller({ prefix: '/users', version: 1 })
- * class UserController {
- *   @Get()
- *   listV1() { ... }          // GET /v1/users
- *
- *   @Version(2)
- *   @Get()
- *   listV2() { ... }          // GET /v2/users
- * }
- * ```
- */ export function Version(version) {
-    return (target, propertyKey, _descriptor)=>{
-        const ctor = target.constructor;
-        MetadataRegistry.setRouteVersion(ctor, propertyKey, version);
-        // If route was already registered (decorator ran after @Get), patch it.
-        const route = MetadataRegistry.getRoutes(ctor).find((r)=>r.handlerName === propertyKey);
-        if (route) {
-            route.version = version;
-        }
-    };
-}
-export function getRouteVersion(target, propertyKey) {
-    return MetadataRegistry.getRouteVersion(target, propertyKey);
-}
-function createMethodDecorator(method) {
-    return (path = '', options)=>{
-        return (target, propertyKey, _descriptor)=>{
-            const ctor = target.constructor;
-            const normalizedPath = normalizePath(path);
-            const version = MetadataRegistry.getRouteVersion(ctor, propertyKey);
-            MetadataRegistry.addRoute(ctor, {
-                method: method,
-                path: normalizedPath,
-                handlerName: propertyKey,
-                ...version !== undefined ? {
-                    version
-                } : {},
-                ...options?.name !== undefined ? {
-                    name: options.name
-                } : {}
-            });
-        };
-    };
-}
-export const Get = createMethodDecorator(HttpMethod.GET);
-export const Post = createMethodDecorator(HttpMethod.POST);
-export const Put = createMethodDecorator(HttpMethod.PUT);
-export const Patch = createMethodDecorator(HttpMethod.PATCH);
-export const Delete = createMethodDecorator(HttpMethod.DELETE);
-export const Options = createMethodDecorator(HttpMethod.OPTIONS);
-export const Head = createMethodDecorator(HttpMethod.HEAD);
-export const All = createMethodDecorator(HttpMethod.ALL);
-export const Sse = createMethodDecorator(HttpMethod.GET);
-// Parameter decorators
-const CUSTOM_PARAM_TYPE = 'custom';
-function createBuiltinParamDecorator(type) {
-    return (nameOrPipe, ...pipes)=>{
-        return (target, propertyKey, parameterIndex)=>{
-            if (propertyKey === undefined) {
-                throw new Error('Parameter decorators can only be used on method parameters');
-            }
-            let name;
-            let allPipes;
-            if (typeof nameOrPipe === 'string') {
-                name = nameOrPipe;
-                allPipes = pipes;
-            } else if (nameOrPipe !== undefined) {
-                name = undefined;
-                allPipes = [
-                    nameOrPipe,
-                    ...pipes
-                ];
-            } else {
-                name = undefined;
-                allPipes = pipes;
-            }
-            MetadataRegistry.addParameter(target.constructor, propertyKey, {
-                index: parameterIndex,
-                type,
-                name,
-                ...allPipes.length > 0 ? {
-                    pipes: allPipes
-                } : {}
-            });
-        };
-    };
-}
-export const Param = createBuiltinParamDecorator(ParamType.PARAM);
-export const Query = createBuiltinParamDecorator(ParamType.QUERY);
-export const Body = createBuiltinParamDecorator(ParamType.BODY);
-export const Headers = createBuiltinParamDecorator(ParamType.HEADERS);
-export const Req = createBuiltinParamDecorator(ParamType.REQUEST);
-/**
- * Injects the Hono `Context` as the response handle.
- * In Hono, request and response state are unified in the `Context` object,
- * so `@Res()` and `@Req()` both return it.
- *
- * Use `c.header()`, `c.setCookie()`, `c.redirect()`, etc. for response control.
- *
- * @example
- * ```ts
- * @Get('/set-cookie')
- * handle(@Res() c: Context) {
- *   c.setCookie('session', 'abc123', { httpOnly: true });
- *   return { ok: true };
- * }
- * ```
- */ export const Res = createBuiltinParamDecorator(ParamType.RESPONSE);
-export const Ip = createBuiltinParamDecorator(ParamType.IP);
-export const Cookie = createBuiltinParamDecorator(ParamType.COOKIE);
-/**
- * Injects all cookies as a `Record<string, string>`, or a single cookie value by name.
- *
- * - `@Cookie()` — all cookies as an object
- * - `@Cookie('token')` — the value of the `token` cookie
- *
- * @example
- * ```ts
- * @Get('/me')
- * handle(@Cookie('session') session: string) { ... }
- * ```
- */ export const Cookies = Cookie;
-/**
- * Injects the raw request body as a `Uint8Array`.
- * Useful for webhook HMAC verification (Stripe, GitHub, etc.) where you
- * need the raw bytes before any JSON parsing.
- *
- * @example
- * ```ts
- * @Post('/webhook')
- * async handle(@RawBody() body: Uint8Array) {
- *   const sig = new TextDecoder().decode(body);
- *   // verify HMAC...
- * }
- * ```
- */ export function RawBody() {
-    return (target, propertyKey, parameterIndex)=>{
-        if (propertyKey === undefined) {
-            throw new Error('Parameter decorators can only be used on method parameters');
-        }
-        MetadataRegistry.addParameter(target.constructor, propertyKey, {
-            index: parameterIndex,
-            type: ParamType.RAW_BODY
-        });
-    };
-}
-/**
- * Factory for creating custom parameter decorators.
- *
- * @example
- * ```ts
- * const CurrentUser = createParamDecorator(
- *   (data: unknown, ctx: ExecutionContext) => {
- *     const req = ctx.getRequest();
- *     return req.headers.get('x-user-id');
- *   }
- * );
- *
- * // Usage:
- * @Get()
- * handle(@CurrentUser() userId: string) { ... }
- *
- * // With data argument:
- * const Header = createParamDecorator(
- *   (data: string, ctx: ExecutionContext) => {
- *     return ctx.getRequest().headers.get(data);
- *   }
- * );
- *
- * @Get()
- * handle(@Header('x-request-id') requestId: string) { ... }
- * ```
- */ export function createParamDecorator(factory) {
-    return (data, ...pipes)=>{
-        return (target, propertyKey, parameterIndex)=>{
-            if (propertyKey === undefined) {
-                throw new Error('Parameter decorators can only be used on method parameters');
-            }
-            MetadataRegistry.addParameter(target.constructor, propertyKey, {
-                index: parameterIndex,
-                type: CUSTOM_PARAM_TYPE,
-                name: undefined,
-                factory: (_unused, ctx)=>{
-                    const honoCtx = ctx;
-                    const execCtx = buildExecutionContext(honoCtx, target.constructor, propertyKey);
-                    return factory(data, execCtx);
-                },
-                ...pipes.length > 0 ? {
-                    pipes
-                } : {}
-            });
-        };
-    };
-}
-// Response decorators
-/**
- * Override the HTTP status code for a handler's response.
- *
- * @example
- * ```ts
- * @Post()
- * @HttpCode(201)
- * create(@Body() data: CreateDto) { return data; }
- * ```
- */ export function HttpCode(statusCode) {
-    return (target, propertyKey, _descriptor)=>{
-        MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, {
-            httpCode: statusCode
-        });
-    };
-}
-/**
- * Set a response header declaratively.
- * Can be applied multiple times to set multiple headers.
- *
- * @example
- * ```ts
- * @Get()
- * @Header('Cache-Control', 'no-cache')
- * @Header('X-Custom', 'value')
- * handle() { return { ok: true }; }
- * ```
- */ export function Header(name, value) {
-    return (target, propertyKey, _descriptor)=>{
-        MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, {
-            responseHeaders: [
-                [
-                    name,
-                    value
-                ]
-            ]
-        });
-    };
-}
-/**
- * Redirect to another URL. The handler's return value can override the URL.
- *
- * @example
- * ```ts
- * @Get('/old')
- * @Redirect('/new', 301)
- * handleOld() {}
- *
- * // Dynamic redirect — return { url, statusCode? } to override
- * @Get('/go')
- * @Redirect('/default')
- * handleGo(@Query('to') to?: string) {
- *   if (to) return { url: to };
- * }
- * ```
- */ export function Redirect(url, statusCode = 302) {
-    return (target, propertyKey, _descriptor)=>{
-        MetadataRegistry.setHandlerHttpMeta(target.constructor, propertyKey, {
-            redirect: {
-                url,
-                statusCode
-            }
-        });
-    };
-}
-// Metadata readers (used by RouteManager)
-export function getHttpCode(target, method) {
-    return MetadataRegistry.getHandlerHttpMeta(target, method)?.httpCode;
-}
-export function getResponseHeaders(target, method) {
-    return MetadataRegistry.getHandlerHttpMeta(target, method)?.responseHeaders ?? [];
-}
-export function getRedirect(target, method) {
-    return MetadataRegistry.getHandlerHttpMeta(target, method)?.redirect;
-}
-export function applyDecorators(...decorators) {
-    return (target, propertyKey, descriptor)=>{
-        for (const decorator of decorators){
-            if (propertyKey === undefined && typeof descriptor !== 'number') {
-                decorator(target);
-            } else if (typeof descriptor === 'number') {
-                decorator(target, propertyKey, descriptor);
-            } else {
-                decorator(target, propertyKey, descriptor);
-            }
-        }
-    };
-}
-// Helpers
-export function isController(target) {
-    return MetadataRegistry.getControllerPath(target) !== '' || MetadataRegistry.getRoutes(target).length > 0;
-}

package/dist/http/execution-context.d.ts

@@ -1,8 +0,0 @@
-import type { Context } from 'hono';
-import type { Type } from '../container/types';
-import type { ExecutionContext } from '../pipeline/types';
-export declare function buildExecutionContext(c: Context, controller: Type, handlerName: string | symbol): ExecutionContext;
-export declare class VelaMiddlewareHost {
-}
-export declare const VELA_MIDDLEWARE_HANDLER: unique symbol;
-export declare function buildMiddlewareExecutionContext(c: Context): ExecutionContext;

package/dist/http/execution-context.js

@@ -1,35 +0,0 @@
-// Single source of ExecutionContext shape — used by the route pipeline AND
-// by createParamDecorator's deferred factory call.
-export function buildExecutionContext(c, controller, handlerName) {
-    return {
-        getType: ()=>'http',
-        getClass: ()=>controller,
-        getHandler: ()=>handlerName,
-        getContext: ()=>c,
-        getRequest: ()=>c.req.raw,
-        switchToHttp: ()=>({
-                getRequest: ()=>c.req.raw,
-                getResponse: ()=>c
-            }),
-        switchToWs: ()=>{
-            throw new Error('switchToWs() called on an HTTP ExecutionContext. This handler runs over HTTP, not a WebSocket gateway.');
-        }
-    };
-}
-// Sentinel marker exposed via `ExecutionContext.getClass()` when the host is a
-// vela-attached middleware rather than a controller handler. Filters that
-// branch on the calling class (rare) can detect the middleware origin without
-// introducing a separate `getType()` value — `getType()` stays `'http'` for
-// NestJS parity.
-export class VelaMiddlewareHost {
-}
-// Synthesizes an ExecutionContext for an exception thrown inside a
-// vela-attached middleware. There is no controller class or handler method
-// on the call stack at that point, so `getClass()` returns the
-// `VelaMiddlewareHost` marker and `getHandler()` returns the
-// `vela.middleware` symbol — both stable, comparable values that filter
-// authors can pattern-match against if needed.
-export const VELA_MIDDLEWARE_HANDLER = Symbol.for('vela.middleware');
-export function buildMiddlewareExecutionContext(c) {
-    return buildExecutionContext(c, VelaMiddlewareHost, VELA_MIDDLEWARE_HANDLER);
-}

package/dist/http/handler-executor.d.ts

@@ -1,20 +0,0 @@
-import type { Context } from 'hono';
-import type { Container } from '../container/container';
-import type { Token, Type } from '../container/types';
-import type { CanActivate, ExceptionFilter, NestInterceptor, PipeTransform } from '../pipeline/types';
-import type { FilterType, GuardType, InterceptorType, ParameterMetadata, PipeType } from '../registry/types';
-import type { ArgumentResolver } from './argument-resolver';
-import type { RouteMetadata } from './types';
-export interface HandlerGlobals {
-    guards: Array<GuardType | Token<CanActivate>>;
-    pipes: Array<PipeType | Token<PipeTransform>>;
-    interceptors: Array<InterceptorType | Token<NestInterceptor>>;
-    filters: Array<FilterType | Token<ExceptionFilter>>;
-}
-export declare class HandlerExecutor {
-    private readonly argumentResolver;
-    private readonly getGlobals;
-    private readonly getRequestContainer;
-    constructor(argumentResolver: ArgumentResolver, getGlobals: () => HandlerGlobals, getRequestContainer: (c: Context) => Container);
-    create(route: RouteMetadata, controller: Type, allParamMetadata: Map<string | symbol, ParameterMetadata[]>): (c: Context) => Promise<Response>;
-}