@celljs/mvc 3.0.0

package/src/node/annotation/method.ts

@@ -0,0 +1,61 @@
+import { METADATA_KEY } from '../constants';
+import { HttpMethod } from '@celljs/http';
+
+export type StrOrRegex = string | RegExp;
+export type RouteOptions = StrOrRegex | { path: StrOrRegex } | { options: Object, path: StrOrRegex } & Object;
+
+export interface MethodMetadata {
+    options: RouteOptions;
+    target: any;
+    method: string;
+    key: string | symbol;
+    descriptor: TypedPropertyDescriptor<any>;
+}
+
+export function Get(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.GET);
+}
+
+export function Post(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.POST);
+}
+
+export function Put(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.PUT);
+}
+
+export function Patch(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.PATCH);
+}
+
+export function Head(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.HEAD);
+}
+
+export function Delete(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.DELETE);
+}
+
+export function Options(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.OPTIONS);
+}
+
+export function All(options?: RouteOptions): MethodDecorator {
+    return Method(options, HttpMethod.GET, HttpMethod.DELETE, HttpMethod.HEAD, HttpMethod.PATCH, HttpMethod.POST, HttpMethod.PUT, HttpMethod.TRACE, HttpMethod.OPTIONS);
+}
+
+export const Method = function (options: RouteOptions = '', ...methods: string[]): MethodDecorator {
+    return function (target, key, descriptor) {
+        let metadataList: MethodMetadata[] = [];
+
+        if (!Reflect.hasOwnMetadata(METADATA_KEY.controllerMethod, target.constructor)) {
+            Reflect.defineMetadata(METADATA_KEY.controllerMethod, metadataList, target.constructor);
+        } else {
+            metadataList = Reflect.getOwnMetadata(METADATA_KEY.controllerMethod, target.constructor);
+        }
+        for (const method of methods) {
+            const metadata: MethodMetadata = { options, method, target, key, descriptor };
+            metadataList.push(metadata);
+        }
+    };
+};

package/src/node/annotation/param.ts

@@ -0,0 +1,21 @@
+import { METADATA_KEY } from '../constants';
+
+export interface ParamMetadata {
+    name?: string;
+    parameterIndex: number;
+}
+
+export function Param(name?: string): ParameterDecorator {
+    return (t, tk, i) => {
+        applyParamDecorator(t, tk, i, name);
+    };
+}
+
+export function applyParamDecorator(target: any, targetKey: string | symbol | undefined, parameterIndex: number, name?: string): void {
+    if (!targetKey) {
+        return;
+    }
+    const metadatas: ParamMetadata[] = Reflect.getOwnMetadata(METADATA_KEY.controllerParam, target.constructor, targetKey) || [];
+    metadatas.push({ name, parameterIndex });
+    Reflect.defineMetadata(METADATA_KEY.controllerParam, metadatas, target.constructor, targetKey);
+}

package/src/node/annotation/query.ts

@@ -0,0 +1,21 @@
+import { METADATA_KEY } from '../constants';
+
+export interface QueryMetadata {
+    name?: string;
+    parameterIndex: number;
+}
+
+export function Query(name?: string): ParameterDecorator {
+    return (t, tk, i) => {
+        applyQueryDecorator(t, tk, i, name);
+    };
+}
+
+export function applyQueryDecorator(target: any, targetKey: string | symbol | undefined, parameterIndex: number, name?: string): void {
+    if (!targetKey) {
+        return;
+    }
+    const metadatas: QueryMetadata[] = Reflect.getOwnMetadata(METADATA_KEY.controllerQuery, target.constructor, targetKey) || [];
+    metadatas.push({ name, parameterIndex });
+    Reflect.defineMetadata(METADATA_KEY.controllerQuery, metadatas, target.constructor, targetKey);
+}

package/src/node/annotation/req.ts

@@ -0,0 +1,23 @@
+import { METADATA_KEY } from '../constants';
+
+export interface RequestMetadata {
+    parameterIndex: number;
+}
+
+export function Req(): ParameterDecorator {
+    return (t, tk, i) => {
+        applyRequestDecorator(t, tk, i);
+    };
+}
+
+export function applyRequestDecorator(target: any, targetKey: string | symbol | undefined, parameterIndex: number): void {
+    if (!targetKey) {
+        return;
+    }
+    Reflect.defineMetadata(
+        METADATA_KEY.controllerRequest,
+        { parameterIndex } as RequestMetadata,
+        target.constructor,
+        targetKey
+    );
+}

package/src/node/annotation/res.ts

@@ -0,0 +1,23 @@
+import { METADATA_KEY } from '../constants';
+
+export interface ResponseMetadata {
+    parameterIndex: number;
+}
+
+export function Res(): ParameterDecorator {
+    return (t, tk, i) => {
+        applyResponseDecorator(t, tk, i);
+    };
+}
+
+export function applyResponseDecorator(target: any, targetKey: string | symbol | undefined, parameterIndex: number): void {
+    if (!targetKey) {
+        return;
+    }
+    Reflect.defineMetadata(
+        METADATA_KEY.controllerResponse,
+        { parameterIndex } as ResponseMetadata,
+        target.constructor,
+        targetKey
+    );
+}

package/src/node/annotation/session.ts

@@ -0,0 +1,41 @@
+import { METADATA_KEY } from '../constants';
+
+export interface RequestSessionMetadata {
+    name?: string;
+    parameterIndex: number;
+}
+
+export interface ResponseSessionMetadata {
+    name: string;
+    value: string;
+}
+
+export interface SessionDecorator {
+    (name?: string): ParameterDecorator;
+    (name: string, value: string): MethodDecorator;
+
+}
+
+export const Session = <SessionDecorator>function (name?: string, value?: string) {
+    if (name && value) {
+        return (t: any, tk: string | symbol, d: PropertyDescriptor) => {
+            applyResponseSessionDecorator(t, tk, d, name, value);
+        };
+    } else {
+        return (t: any, tk: string | symbol, i: number) => {
+            applyRequestSessionDecorator(t, tk, i, name);
+        };
+    }
+};
+
+export function applyRequestSessionDecorator(target: any, targetKey: string | symbol, parameterIndex: number, name?: string): void {
+    const metadatas: RequestSessionMetadata[] = Reflect.getOwnMetadata(METADATA_KEY.controllerRequestSession, target.constructor, targetKey) || [];
+    metadatas.push({ name, parameterIndex });
+    Reflect.defineMetadata(METADATA_KEY.controllerRequestSession, metadatas, target.constructor, targetKey);
+}
+
+export function applyResponseSessionDecorator(target: any, targetKey: string | symbol, descriptor: PropertyDescriptor, name: string, value: string): void {
+    const metadatas: ResponseSessionMetadata[] = Reflect.getOwnMetadata(METADATA_KEY.controllerResponseSession, target.constructor, targetKey) || [];
+    metadatas.push({ name, value  });
+    Reflect.defineMetadata(METADATA_KEY.controllerResponseSession, metadatas, target.constructor, targetKey);
+}

package/src/node/annotation/text.ts

@@ -0,0 +1,7 @@
+import { View } from './view';
+
+export const TEXT_VIEW_NAME = 'text';
+
+export function Text(): MethodDecorator {
+    return View(TEXT_VIEW_NAME);
+}

package/src/node/annotation/view.ts

@@ -0,0 +1,16 @@
+import { METADATA_KEY } from '../constants';
+
+export interface ViewMetadata {
+    viewName: string;
+    metadata?: { [key: string]: any };
+}
+
+export function View(viewName: string, metadata?: { [key: string]: any }): MethodDecorator {
+    return (t, k, d) => {
+        applyViewDecorator(t, k, d, viewName, metadata);
+    };
+}
+
+export function applyViewDecorator(target: any, targetKey: string | symbol, descriptor: TypedPropertyDescriptor<any>, viewName: string, metadata?: { [key: string]: any }): void {
+    Reflect.defineMetadata(METADATA_KEY.controllerView, { viewName, metadata }, target.constructor, targetKey);
+}

package/src/node/constants.ts

@@ -0,0 +1,17 @@
+export const METADATA_KEY = {
+    controller: 'cell:controller',
+    controllerMethod: 'cell:controller-method',
+    controllerParam: 'cell:controller-param',
+    controllerRequestHeader: 'cell:controller-request-header',
+    controllerResponseHeader: 'cell:controller-response-header',
+    controllerRequestCookie: 'cell:controller-request-cookie',
+    controllerResponseCookie: 'cell:controller-response-cookie',
+    controllerRequestSession: 'cell:controller-request-session',
+    controllerResponseSession: 'cell:controller-response-session',
+    controllerQuery: 'cell:controller-query',
+    controllerBody: 'cell:controller-body',
+    controllerView: 'cell:controller-view',
+    controllerCatch: 'cell:controller-catch',
+    controllerRequest: 'cell:controller-request',
+    controllerResponse: 'cell:controller-response',
+};

package/src/node/error/error-handler.ts

@@ -0,0 +1,27 @@
+import { ErrorHandler, Context } from '@celljs/web/lib/node';
+import { Component, Autowired, Value } from '@celljs/core';
+import { JsonViewTemplateRenderer } from '../view/view-protocol';
+import { HttpHeaders, MediaType } from '@celljs/http';
+
+@Component(ErrorHandler)
+export class JsonViewErrorHandler implements ErrorHandler {
+
+    @Value('cell.mvc.jsonView.errorHandler.priority?:2000')
+    readonly priority: number;
+
+    @Value('cell.mvc.jsonView.errorHandler.enabled?:true')
+    protected readonly enabled: boolean;
+
+    @Autowired(JsonViewTemplateRenderer)
+    protected readonly jsonViewTemplateRenderer: JsonViewTemplateRenderer;
+
+    async canHandle(ctx: Context, err: Error): Promise<boolean> {
+        return this.enabled;
+    }
+
+    async handle(ctx: Context, err: Error): Promise<void> {
+        ctx.response.setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_UTF8);
+        ctx.response.end(await this.jsonViewTemplateRenderer.render(undefined, err));
+    }
+}
+

package/src/node/error/index.ts

@@ -0,0 +1 @@
+export * from './error-handler';

package/src/node/handler/handler-adapter.ts

@@ -0,0 +1,100 @@
+import { Component, Autowired, Value } from '@celljs/core';
+import { PathResolver, PipeManager } from '@celljs/web';
+import { Context, RequestMatcher, HandlerAdapter, NotFoundAndContinueError } from '@celljs/web/lib/node';
+import { ViewResolver, ResponseResolverProvider, MethodArgsResolverProvider } from '../resolver';
+import { MVC_HANDLER_ADAPTER_PRIORITY, RouteMetadataMatcher } from './handler-protocol';
+import { MVC_PATH } from '../../common';
+
+@Component(HandlerAdapter)
+export class MvcHandlerAdapter implements HandlerAdapter {
+    readonly priority = MVC_HANDLER_ADAPTER_PRIORITY;
+
+    @Autowired(MethodArgsResolverProvider)
+    protected readonly methodArgsResolverProvider: MethodArgsResolverProvider;
+
+    @Autowired(ResponseResolverProvider)
+    protected readonly responseResolverProvider: ResponseResolverProvider;
+
+    @Autowired(ViewResolver)
+    protected readonly viewResolver: ViewResolver;
+
+    @Autowired(RequestMatcher)
+    protected readonly requestMatcher: RequestMatcher;
+
+    @Autowired(PathResolver)
+    protected readonly pathResolver: PathResolver;
+
+    @Autowired(PipeManager)
+    protected readonly pipeManager: PipeManager;
+
+    @Value(MVC_PATH)
+    protected readonly mvcPath: string;
+
+    @Autowired(RouteMetadataMatcher)
+    protected readonly routeMetadataMatcher: RouteMetadataMatcher;
+
+    protected async resolveMethodArgs(metadata: any) {
+        const args: any[] = [];
+        for (const resolver of this.methodArgsResolverProvider.provide()) {
+            await resolver.resolve(metadata, args);
+        }
+        return args;
+    }
+
+    protected async resolveResponse(metadata: any) {
+        for (const resolver of this.responseResolverProvider.provide()) {
+            await resolver.resolve(metadata);
+        }
+    }
+
+    async handle(): Promise<void> {
+        const ctx = Context.getCurrent();
+        const path = ctx.request.path;
+        const routeMetadata = await this.routeMetadataMatcher.match();
+        if (routeMetadata) {
+            await this.doHandle(routeMetadata);
+        } else {
+            throw new NotFoundAndContinueError(`No mapping found: ${ctx.request.method} ${path}`);
+        }
+    }
+
+    protected async doHandle(metadata: any, err?: any): Promise<void> {
+        let args = await this.resolveMethodArgs(metadata);
+        if (err) {
+            args = [err, ...args];
+        }
+        const methodMetadata = metadata.methodMetadata;
+        const target = methodMetadata.target;
+        let model: any;
+        try {
+            await this.pipeManager.apply({ target, method: methodMetadata.key }, args);
+            model = await target[methodMetadata.key](...args);
+        } catch (error) {
+            if (!err) {
+                const errorMetadata = await this.getErrorMetadata(error);
+                if (!errorMetadata.viewMetadata.viewName) {
+                    errorMetadata.viewMetadata.viewName = metadata.viewMetadata.viewName;
+                }
+                await this.doHandle(errorMetadata, error);
+            } else {
+                throw error;
+            }
+        }
+        if (model) {
+            await this.viewResolver.resolve(metadata, model);
+        }
+        await this.resolveResponse(metadata);
+    }
+
+    protected async getErrorMetadata(error: Error) {
+        const routeMetadata = await this.routeMetadataMatcher.match(error);
+        if (routeMetadata) {
+            return routeMetadata;
+        }
+        throw error;
+    }
+
+    async canHandle(): Promise<boolean> {
+        return this.requestMatcher.match(await this.pathResolver.resolve(this.mvcPath));
+    }
+}

package/src/node/handler/handler-protocol.ts

@@ -0,0 +1,62 @@
+import {
+    StrOrRegex,
+    ParamMetadata,
+    RequestMetadata,
+    QueryMetadata,
+    RequestHeaderMetadata,
+    ResponseHeaderMetadata,
+    RequestCookieMetadata,
+    ResponseCookieMetadata,
+    RequestSessionMetadata,
+    ResponseSessionMetadata,
+    ViewMetadata,
+    MethodMetadata,
+    CatchMetadata,
+    ControllerMetadata,
+    BodyMetadata,
+    ResponseMetadata,
+} from '../annotation';
+import { ErrorType } from '@celljs/core';
+
+export const MVC_HANDLER_ADAPTER_PRIORITY = 2000;
+
+export const RouteProvider = Symbol('RouteProvider');
+export const RouteMetadataMatcher = Symbol('RouteMetadataMatcher');
+
+export interface Route {
+    mapping: Map<string, PathRouteMetadata[]>;
+    errorMapping: Map<ErrorType, ErrorRouteMetadata>;
+}
+
+export interface RouteMetadata {
+    controllerMetadata: ControllerMetadata;
+    methodMetadata: MethodMetadata | CatchMetadata;
+    requestMetadata?: RequestMetadata;
+    responseMetadata?: ResponseMetadata;
+    paramMetadata?: ParamMetadata[];
+    bodyMetadata?: BodyMetadata[];
+    queryMetadata?: QueryMetadata[];
+    requestHeaderMetadata?: RequestHeaderMetadata[];
+    responseHeaderMetadata?: ResponseHeaderMetadata[];
+    requestCookieMetadata?: RequestCookieMetadata[];
+    responseCookieMetadata?: ResponseCookieMetadata[];
+    requestSessionMetadata?: RequestSessionMetadata[];
+    responseSessionMetadata?: ResponseSessionMetadata[];
+    viewMetadata: ViewMetadata;
+}
+
+export interface PathRouteMetadata extends RouteMetadata {
+    path: StrOrRegex;
+}
+
+export interface ErrorRouteMetadata extends RouteMetadata {
+    errorType: ErrorType;
+}
+
+export interface RouteProvider {
+    provide(): Promise<Route>;
+}
+
+export interface RouteMetadataMatcher {
+    match(error?: Error): Promise<RouteMetadata | undefined>;
+}

package/src/node/handler/index.ts

@@ -0,0 +1,5 @@
+export * from './handler-adapter';
+export * from './handler-protocol';
+export * from './route-builder';
+export * from './route-provider';
+export * from './route-metadata-matcher';

package/src/node/handler/route-builder.ts

@@ -0,0 +1,119 @@
+import { CONTROLLER, ControllerMetadata } from '../annotation/controller';
+import { METADATA_KEY } from '../constants';
+import { StrOrRegex, MethodMetadata } from '../annotation/method';
+import { getOwnMetadata, Component, Autowired, Optional, ErrorType, Prioritizeable, getTargetClass } from '@celljs/core';
+import { PathResolver } from '@celljs/web';
+import { CatchMetadata } from '../annotation';
+import { PathRouteMetadata, ErrorRouteMetadata } from './handler-protocol';
+
+@Component()
+export class RouteBuilder {
+
+    @Autowired(CONTROLLER) @Optional()
+    protected readonly controllers: any[] = [];
+
+    @Autowired(PathResolver)
+    protected readonly pathResolver: PathResolver;
+
+    async build() {
+        const mapping: Map<string, PathRouteMetadata[]> = new Map<string, PathRouteMetadata[]>();
+        const errorMapping: Map<ErrorType, any> = new Map<ErrorType, ErrorRouteMetadata>();
+
+        for (const controller of this.controllers) {
+            const targetConstructor = getTargetClass(controller);
+
+            const controllerMetadata = <ControllerMetadata>Reflect.getOwnMetadata(METADATA_KEY.controller, targetConstructor);
+            await this.doBuildRouteMap(mapping, targetConstructor, controller, controllerMetadata);
+            await this.doBuildErrorRouteMap(errorMapping, targetConstructor, controller, controllerMetadata);
+
+        }
+        return {
+            mapping,
+            errorMapping
+        };
+    }
+
+    protected async doBuildRouteMap(mapping: Map<string, PathRouteMetadata[]>, targetConstructor: any, controller: any, controllerMetadata: ControllerMetadata) {
+        const methodMetadata: MethodMetadata[] = getOwnMetadata(
+            METADATA_KEY.controllerMethod,
+            targetConstructor
+        );
+        for (const metadata of methodMetadata) {
+            const routeOptions: any = (typeof metadata.options === 'string' || metadata.options instanceof RegExp) ? { path: metadata.options } : metadata.options;
+            const m = { ...metadata };
+            const method = m.method;
+            m.target = controller;
+            let paths = mapping.get(method);
+            if (!paths) {
+                paths = [];
+                mapping.set(method, paths);
+            }
+            let path: StrOrRegex = routeOptions.path;
+            if (typeof path === 'string' ) {
+                path = await this.pathResolver.resolve(controllerMetadata.path, path);
+            } else if (path instanceof RegExp) {
+                if (controllerMetadata.path) {
+                    path = new RegExp(await this.pathResolver.resolve(controllerMetadata.path, path.source));
+                }
+            }
+            const routeMetadata = {
+                path,
+                controllerMetadata,
+                methodMetadata: m,
+                ...this.doRouteMetadata(targetConstructor, m.key.toString())
+            };
+            paths.push(routeMetadata);
+        }
+
+        for (const [method, paths] of mapping) {
+            const sorted = Prioritizeable.prioritizeAllSync(paths, value => {
+                if (value.path instanceof RegExp) {
+                    return Number.MIN_SAFE_INTEGER + value.path.toString().length;
+                } else if (value.path.includes('*')) {
+                    return value.path.replace('*', '').length;
+                }
+                return value.path.length + 1;
+            }).map(({ value }) => value);
+            mapping.set(method, sorted);
+        }
+    }
+
+    protected async doBuildErrorRouteMap(errorMapping: Map<ErrorType, ErrorRouteMetadata>, targetConstructor: any, controller: any, controllerMetadata: ControllerMetadata) {
+        const methodMetadata: CatchMetadata[] = getOwnMetadata(
+            METADATA_KEY.controllerCatch,
+            targetConstructor
+        );
+        for (const metadata of methodMetadata) {
+            const m = { ...metadata };
+            m.target = controller;
+            for (const errorType of metadata.errorTypes) {
+                errorMapping.set(errorType, {
+                    errorType,
+                    controllerMetadata,
+                    methodMetadata: m,
+                    ...this.doRouteMetadata(targetConstructor, m.key.toString())
+                });
+            }
+        }
+    }
+
+    protected doRouteMetadata(targetConstructor: any, method: string) {
+        const viewMetadata = getOwnMetadata(METADATA_KEY.controllerView, targetConstructor, method);
+        const requestMetadata = getOwnMetadata(METADATA_KEY.controllerRequest, targetConstructor, method);
+        const responseMetadata = getOwnMetadata(METADATA_KEY.controllerResponse, targetConstructor, method);
+        return {
+            requestMetadata: requestMetadata[0],
+            responseMetadata: responseMetadata[0],
+            paramMetadata: getOwnMetadata(METADATA_KEY.controllerParam, targetConstructor, method),
+            bodyMetadata: getOwnMetadata(METADATA_KEY.controllerBody, targetConstructor, method),
+            queryMetadata: getOwnMetadata(METADATA_KEY.controllerQuery, targetConstructor, method),
+            requestHeaderMetadata: getOwnMetadata(METADATA_KEY.controllerRequestHeader, targetConstructor, method),
+            responseHeaderMetadata: getOwnMetadata(METADATA_KEY.controllerResponseHeader, targetConstructor, method),
+            requestCookieMetadata: getOwnMetadata(METADATA_KEY.controllerRequestCookie, targetConstructor, method),
+            responseCookieMetadata: getOwnMetadata(METADATA_KEY.controllerResponseCookie, targetConstructor, method),
+            requestSessionMetadata: getOwnMetadata(METADATA_KEY.controllerRequestSession, targetConstructor, method),
+            responseSessionMetadata: getOwnMetadata(METADATA_KEY.controllerResponseSession, targetConstructor, method),
+            viewMetadata:  viewMetadata.length ? viewMetadata[0] : {}
+        };
+    }
+}

package/src/node/handler/route-metadata-matcher.ts

@@ -0,0 +1,44 @@
+import { Component, Autowired } from '@celljs/core';
+import { RouteProvider, RouteMetadata, RouteMetadataMatcher } from './handler-protocol';
+import { Context, RequestMatcher } from '@celljs/web/lib/node';
+
+export const PATH_PARMAS_ATTR = 'pathParams';
+
+@Component(RouteMetadataMatcher)
+export class RouteMetadataMatcherImpl implements RouteMetadataMatcher {
+
+    @Autowired(RouteProvider)
+    protected readonly routeProvider: RouteProvider;
+
+    @Autowired(RequestMatcher)
+    protected readonly requestMatcher: RequestMatcher;
+
+    async match(error?: Error): Promise<RouteMetadata | undefined> {
+        const route = await this.routeProvider.provide();
+        if (error) {
+            const metadata = route.errorMapping.get(error.constructor);
+            if (metadata) {
+                return metadata;
+            } else {
+                for (const entry of route.errorMapping) {
+                    if (error instanceof <any>entry[0]) {
+                        return entry[1];
+                    }
+                }
+            }
+        } else {
+            const request = Context.getRequest();
+            const paths = route.mapping.get(request.method!.toUpperCase());
+            if (paths) {
+                for (const pathRouteMetadata of paths) {
+                    const pathParams = await this.requestMatcher.match(pathRouteMetadata.path);
+                    if (pathParams) {
+                        Context.setAttr(PATH_PARMAS_ATTR, pathParams);
+                        return pathRouteMetadata;
+                    }
+                }
+            }
+        }
+    }
+
+}

package/src/node/handler/route-provider.ts

@@ -0,0 +1,27 @@
+import { Component, Autowired, Deferred, PostConstruct } from '@celljs/core';
+import { Route, RouteProvider } from './handler-protocol';
+import { RouteBuilder } from './route-builder';
+
+@Component(RouteProvider)
+export class RouteProviderImpl implements RouteProvider {
+
+    protected route: Route;
+
+    protected routeDeferred = new Deferred<Route>();
+
+    @Autowired(RouteBuilder)
+    protected readonly routeBuilder: RouteBuilder;
+
+    @PostConstruct()
+    protected init() {
+        this.routeBuilder.build().then(route => {
+            this.route = route;
+            this.routeDeferred.resolve(route);
+        });
+    }
+
+    provide(): Promise<Route> {
+        return this.routeDeferred.promise;
+    }
+
+}

package/src/node/index.ts

@@ -0,0 +1,5 @@
+export * from './annotation';
+export * from './handler';
+export * from './resolver';
+export * from './view';
+export * from './error';

package/src/node/module.ts

@@ -0,0 +1,4 @@
+import { autoBind } from '@celljs/core';
+import './index';
+
+export default autoBind();

package/src/node/resolver/index.ts

@@ -0,0 +1,7 @@
+export * from './response-resolver';
+export * from './method-args-resolver';
+export * from './method-args-resolver-provider';
+export * from './resolver-protocol';
+export * from './response-resolver-provider';
+export * from './view-resolver';
+export * from './view-resolver-provider';