@mvx/mvc/fesm2017/mvc.js

@mvx/mvc is mvc framework on server, base on koa, @tsdi frameworks

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var tslib = _interopDefault(require('tslib'));
var ioc = _interopDefault(require('@tsdi/ioc'));
var boot = _interopDefault(require('@tsdi/boot'));
var stream = _interopDefault(require('stream'));
var fs = _interopDefault(require('fs'));
var path = _interopDefault(require('path'));
var aop = _interopDefault(require('@tsdi/aop'));
var koaJson = _interopDefault(require('koa-json'));
var platformServer = _interopDefault(require('@tsdi/platform-server'));
var koaBodyparser = _interopDefault(require('koa-bodyparser'));
var koaLogger = _interopDefault(require('koa-logger'));
var koaStatic = _interopDefault(require('koa-static'));
var koaViews = _interopDefault(require('koa-views'));
var koaHelmet = _interopDefault(require('koa-helmet'));
var koaCompose = _interopDefault(require('koa-compose'));
var https = _interopDefault(require('https'));
var koa = _interopDefault(require('koa'));
var core = _interopDefault(require('@tsdi/core'));
var logs = _interopDefault(require('@tsdi/logs'));
var platformServerBoot = _interopDefault(require('@tsdi/platform-server-boot'));
var platformServerLogs = _interopDefault(require('@tsdi/platform-server-logs'));
var http = _interopDefault(require('http'));
var koaMount = _interopDefault(require('koa-mount'));

function unwrapExports (x) {
	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
}

function createCommonjsModule(fn, module) {
	return module = { exports: {} }, fn(module, module.exports), module.exports;
}

var IContext = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ContextToken = void 0;

/**
 * mvc service middleware context.
 */
exports.ContextToken = ioc.tokenId('MVC_SERVICE_CONTEXT');


});

unwrapExports(IContext);
var IContext_1 = IContext.ContextToken;

var IConfiguration = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConfigurationToken = void 0;

/**
 * configuration token.
 */
exports.ConfigurationToken = new ioc.InjectToken('MVX_Configuration');


});

unwrapExports(IConfiguration);
var IConfiguration_1 = IConfiguration.ConfigurationToken;

var exps = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.routeSart = void 0;
exports.routeSart = /^\//;


});

unwrapExports(exps);
var exps_1 = exps.routeSart;

var RequestMethod_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.parseRequestMethod = exports.methodToString = exports.RequestMethod = void 0;

/**
 * request method.
 */
var RequestMethod;
(function (RequestMethod) {
    /**
     * Get method.
     */
    RequestMethod[RequestMethod["Get"] = 1] = "Get";
    /**
     * Post method.
     */
    RequestMethod[RequestMethod["Post"] = 2] = "Post";
    /**
     * Put method.
     */
    RequestMethod[RequestMethod["Put"] = 3] = "Put";
    /**
     * Delete method.
     */
    RequestMethod[RequestMethod["Delete"] = 4] = "Delete";
    /**
     * Options method.
     */
    RequestMethod[RequestMethod["Options"] = 5] = "Options";
    /**
     * Head method.
     */
    RequestMethod[RequestMethod["Head"] = 6] = "Head";
    /**
     * Patch method.
     */
    RequestMethod[RequestMethod["Patch"] = 7] = "Patch";
})(RequestMethod = exports.RequestMethod || (exports.RequestMethod = {}));
/**
 * convert method to string.
 *
 * @export
 * @param {RequestMethod} [method]
 * @returns {string}
 */
function methodToString(method) {
    if (ioc.isString(method)) {
        return method.toUpperCase();
    }
    switch (method) {
        case RequestMethod.Get:
            return 'GET';
        case RequestMethod.Post:
            return 'POST';
        case RequestMethod.Put:
            return 'PUT';
        case RequestMethod.Delete:
            return 'DELETE';
        case RequestMethod.Options:
            return 'OPTIONS';
        case RequestMethod.Head:
            return 'HEAD';
        case RequestMethod.Patch:
            return 'PATCH';
        default:
            return '';
    }
}
exports.methodToString = methodToString;
/**
 * parse string to RequestMethod
 *
 * @export
 * @param {string} [method]
 * @returns {RequestMethod}
 */
function parseRequestMethod(method) {
    method = (method || '').toUpperCase();
    switch (method) {
        case 'GET':
            return RequestMethod.Get;
        case 'POST':
            return RequestMethod.Post;
        case 'PUT':
            return RequestMethod.Put;
        case 'DELETE':
            return RequestMethod.Delete;
        case 'OPTIONS':
            return RequestMethod.Options;
        case 'HEAD':
            return RequestMethod.Head;
        case 'PATCH':
            return RequestMethod.Patch;
        default:
            return null;
    }
}
exports.parseRequestMethod = parseRequestMethod;


});

unwrapExports(RequestMethod_1);
var RequestMethod_2 = RequestMethod_1.parseRequestMethod;
var RequestMethod_3 = RequestMethod_1.methodToString;
var RequestMethod_4 = RequestMethod_1.RequestMethod;

var decorators = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Put = exports.Post = exports.Patch = exports.Delete = exports.Get = exports.Options = exports.Head = exports.Route = exports.createRouteDecorator = exports.Middleware = exports.Cors = exports.createCorsDecorator = exports.Controller = exports.Authorization = exports.MvcModule = void 0;




/**
 * MvcModule Decorator, definde class as mvc module.
 *
 * @MvcModule
 */
exports.MvcModule = boot.createDIModuleDecorator('MvcModule', null, (metadata) => {
    // static main.
    if (ioc.isClass(metadata.type) && ioc.isFunction(metadata.type['main'])) {
        setTimeout(() => {
            metadata.type['main'](metadata);
        }, 100);
    }
    return metadata;
});
/**
 * Authorization decorator, define class or method need auth check.
 *
 * @Authorization
 */
exports.Authorization = ioc.createClassMethodDecorator('Authorization', [
    (ctx, next) => {
        let arg = ctx.currArg;
        if (ioc.isArray(arg)) {
            ctx.metadata.middlewares = arg;
            ctx.next(next);
        }
        else {
            ctx.metadata.role = arg;
            ctx.next(next);
        }
    },
    (ctx, next) => {
        let arg = ctx.currArg;
        if (ioc.isString(arg)) {
            ctx.metadata.role = arg;
        }
    }
]);
/**
 * Controller decorator, define the class as mvc controller.
 * @Controller
 */
exports.Controller = ioc.createClassDecorator('Controller', [
    (ctx, next) => {
        let arg = ctx.currArg;
        if (ioc.isString(arg)) {
            ctx.metadata.routePrefix = arg;
            ctx.next(next);
        }
    },
    (ctx, next) => {
        let arg = ctx.currArg;
        if (ioc.isArray(arg)) {
            ctx.metadata.middlewares = arg;
            ctx.next(next);
        }
        else {
            ctx.next(next, false);
        }
    }
], (meta) => {
    if (!exps.routeSart.test(meta.routePrefix)) {
        meta.routePrefix = '/' + meta.routePrefix;
    }
}, true);
/**
 * Cors Decorator, define controller class or controller method support cors.
 * @Cors
 * @param name
 * @param actions
 * @param metadataExtends
 */
function createCorsDecorator(name, actions, metadataExtends) {
    return ioc.createClassMethodDecorator(name, [
        ...(actions || []),
        (ctx, next) => {
            let arg = ctx.currArg;
            if (ioc.isString(arg)) {
                ctx.metadata.allowMethods = arg;
                ctx.next(next);
            }
            else if (ioc.isArray(arg)) {
                let allowMethods = arg;
                ctx.metadata.allowMethods = allowMethods.filter(m => !ioc.isUndefined(m) && m !== null);
                ctx.next(next);
            }
        },
        (ctx, next) => {
            let arg = ctx.currArg;
            if (ioc.isNumber(arg)) {
                ctx.metadata.maxAge = arg;
                ctx.next(next);
            }
        },
        (ctx, next) => {
            let arg = ctx.currArg;
            if (ioc.isArray(arg)) {
                let allowHeaders = arg;
                ctx.metadata.allowHeaders = allowHeaders.filter(h => !!h);
                ctx.next(next);
            }
        }
    ], metadataExtends);
}
exports.createCorsDecorator = createCorsDecorator;
/**
 * Cors Decorator, define controller class or controller method support cors.
 * @Cors
 */
exports.Cors = createCorsDecorator('Cors');
/**
 * Middleware Decorator, definde class as mvc middleware.
 *
 * @Middleware
 */
exports.Middleware = ioc.createClassDecorator('Middleware', null, (metadata) => {
    metadata.singleton = true;
    if (metadata.name) {
        metadata.provide = metadata.name;
    }
    if (!metadata.scope) {
        metadata.scope = 'global';
    }
});
/**
 * create route decorator.
 *
 * @export
 * @template T
 * @param {RequestMethod} [method]
 * @param { MetadataExtends<T>} [metaExtends]
 */
function createRouteDecorator(method, actions, metaExtends) {
    return ioc.createMethodDecorator('Route', [
        ...(actions || []),
        (ctx, next) => {
            let arg = ctx.currArg;
            if (ioc.isString(arg)) {
                ctx.metadata.route = arg;
                ctx.next(next);
            }
        },
        (ctx, next) => {
            let arg = ctx.currArg;
            if (ioc.isArray(arg)) {
                ctx.metadata.middlewares = arg;
                ctx.next(next);
            }
            else if (ioc.isString(arg)) {
                ctx.metadata.contentType = arg;
                ctx.next(next);
            }
            else if (ioc.isNumber(arg)) {
                ctx.metadata.method = arg;
            }
        },
        (ctx, next) => {
            let arg = ctx.currArg;
            if (ioc.isNumber(arg)) {
                ctx.metadata.method = arg;
            }
            else {
                ctx.metadata.contentType = arg;
                ctx.next(next);
            }
        },
        (ctx, next) => {
            let arg = ctx.currArg;
            if (ioc.isNumber(arg)) {
                ctx.metadata.method = arg;
            }
        }
    ], metadata => {
        if (metaExtends) {
            metaExtends(metadata);
        }
        if (!exps.routeSart.test(metadata.route)) {
            metadata.route = '/' + metadata.route;
        }
        if (method) {
            metadata.method = method;
        }
        else if (!metadata.method) {
            metadata.method = RequestMethod_1.RequestMethod.Get;
        }
        return metadata;
    });
}
exports.createRouteDecorator = createRouteDecorator;
/**
 * route decorator. define the controller method as an route.
 *
 * @Route
 */
exports.Route = createRouteDecorator();
/**
 * Head decorator. define the route method as head.
 *
 * @Head
 */
exports.Head = createRouteDecorator(RequestMethod_1.RequestMethod.Head);
/**
 * Options decorator. define the route method as an options.
 *
 * @Options
 */
exports.Options = createRouteDecorator(RequestMethod_1.RequestMethod.Options);
/**
 * Get decorator. define the route method as get.
 *
 * @Get
 */
exports.Get = createRouteDecorator(RequestMethod_1.RequestMethod.Get);
/**
 * Delete decorator. define the route method as delete.
 *
 * @Delete
 */
exports.Delete = createRouteDecorator(RequestMethod_1.RequestMethod.Delete);
/**
 * Patch decorator. define the route method as patch.
 *
 * @Patch
 */
exports.Patch = createRouteDecorator(RequestMethod_1.RequestMethod.Patch);
/**
 * Post decorator. define the route method as post.
 *
 * @Post
 */
exports.Post = createRouteDecorator(RequestMethod_1.RequestMethod.Post);
/**
 * Put decorator. define the route method as put.
 *
 * @Put
 */
exports.Put = createRouteDecorator(RequestMethod_1.RequestMethod.Put);


});

unwrapExports(decorators);
var decorators_1 = decorators.Put;
var decorators_2 = decorators.Post;
var decorators_3 = decorators.Patch;
var decorators_4 = decorators.Delete;
var decorators_5 = decorators.Get;
var decorators_6 = decorators.Options;
var decorators_7 = decorators.Head;
var decorators_8 = decorators.Route;
var decorators_9 = decorators.createRouteDecorator;
var decorators_10 = decorators.Middleware;
var decorators_11 = decorators.Cors;
var decorators_12 = decorators.createCorsDecorator;
var decorators_13 = decorators.Controller;
var decorators_14 = decorators.Authorization;
var decorators_15 = decorators.MvcModule;

var HttpError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.HttpError = void 0;

/**
 * http error
 *
 * @export
 * @class HttpError
 * @extends {Error}
 */
class HttpError extends Error {
    constructor(status, message) {
        super();
        this.status = status;
        this.message = ioc.isArray(message) ? message.join('\n') : message;
        Error.captureStackTrace(this);
    }
    toString() {
        return `Http Error: ${this.status}, ${this.message}`;
    }
    static ρAnn() {
        return { "name": "HttpError" };
    }
}
exports.HttpError = HttpError;


});

unwrapExports(HttpError_1);
var HttpError_2 = HttpError_1.HttpError;

var BadRequestError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.BadRequestError = void 0;

/**
 * bad request error.
 *
 * @export
 * @class BadRequestError
 * @extends {HttpError}
 */
class BadRequestError extends HttpError_1.HttpError {
    constructor(message = 'Bad Request') {
        super(400, message);
    }
    static ρAnn() {
        return { "name": "BadRequestError" };
    }
}
exports.BadRequestError = BadRequestError;


});

unwrapExports(BadRequestError_1);
var BadRequestError_2 = BadRequestError_1.BadRequestError;

var ForbiddenError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ForbiddenError = void 0;

/**
 * forbidden error.
 *
 * @export
 * @class ForbiddenError
 * @extends {HttpError}
 */
class ForbiddenError extends HttpError_1.HttpError {
    constructor(message = 'Request Forbidden') {
        super(403, message);
    }
    static ρAnn() {
        return { "name": "ForbiddenError" };
    }
}
exports.ForbiddenError = ForbiddenError;


});

unwrapExports(ForbiddenError_1);
var ForbiddenError_2 = ForbiddenError_1.ForbiddenError;

var InternalServerError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.InternalServerError = void 0;

/**
 * internal server error.
 *
 * @export
 * @class InternalServerError
 * @extends {HttpError}
 */
class InternalServerError extends HttpError_1.HttpError {
    constructor(message = 'Internal Server Error') {
        super(500, message);
    }
    static ρAnn() {
        return { "name": "InternalServerError" };
    }
}
exports.InternalServerError = InternalServerError;


});

unwrapExports(InternalServerError_1);
var InternalServerError_2 = InternalServerError_1.InternalServerError;

var MethodNotAllowedError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MethodNotAllowedError = void 0;

/**
 * method not allowed error.
 *
 * @export
 * @class MethodNotAllowedError
 * @extends {HttpError}
 */
class MethodNotAllowedError extends HttpError_1.HttpError {
    constructor(message = 'Method Not Allowed') {
        super(405, message);
    }
    static ρAnn() {
        return { "name": "MethodNotAllowedError" };
    }
}
exports.MethodNotAllowedError = MethodNotAllowedError;


});

unwrapExports(MethodNotAllowedError_1);
var MethodNotAllowedError_2 = MethodNotAllowedError_1.MethodNotAllowedError;

var NotAcceptableError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NotAcceptableError = void 0;

/**
 * not acceptable error.
 *
 * @export
 * @class NotAcceptableError
 * @extends {HttpError}
 */
class NotAcceptableError extends HttpError_1.HttpError {
    constructor(message = 'Not Acceptable') {
        super(406, message);
    }
    static ρAnn() {
        return { "name": "NotAcceptableError" };
    }
}
exports.NotAcceptableError = NotAcceptableError;


});

unwrapExports(NotAcceptableError_1);
var NotAcceptableError_2 = NotAcceptableError_1.NotAcceptableError;

var NotFoundError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.NotFoundError = void 0;

/**
 * not found error.
 *
 * @export
 * @class NotFoundError
 * @extends {HttpError}
 */
class NotFoundError extends HttpError_1.HttpError {
    constructor(message = 'Not Found') {
        super(404, message);
    }
    static ρAnn() {
        return { "name": "NotFoundError" };
    }
}
exports.NotFoundError = NotFoundError;


});

unwrapExports(NotFoundError_1);
var NotFoundError_2 = NotFoundError_1.NotFoundError;

var UnauthorizedError_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.UnauthorizedError = void 0;

/**
 * unauthorized error.
 *
 * @export
 * @class UnauthorizedError
 * @extends {HttpError}
 */
class UnauthorizedError extends HttpError_1.HttpError {
    constructor(message = 'Unauthorized') {
        super(401, message);
    }
    static ρAnn() {
        return { "name": "UnauthorizedError" };
    }
}
exports.UnauthorizedError = UnauthorizedError;


});

unwrapExports(UnauthorizedError_1);
var UnauthorizedError_2 = UnauthorizedError_1.UnauthorizedError;

var errors = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });

tslib.__exportStar(HttpError_1, exports);
tslib.__exportStar(BadRequestError_1, exports);
tslib.__exportStar(ForbiddenError_1, exports);
tslib.__exportStar(InternalServerError_1, exports);
tslib.__exportStar(MethodNotAllowedError_1, exports);
tslib.__exportStar(NotAcceptableError_1, exports);
tslib.__exportStar(NotFoundError_1, exports);
tslib.__exportStar(UnauthorizedError_1, exports);


});

unwrapExports(errors);

var metadata = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });


});

unwrapExports(metadata);

var IMiddleware = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MiddlewareTypes = exports.bindMiddlewareName = exports.isMiddlewareFunc = void 0;

/**
 * middlware check.
 *
 * @export
 * @template T
 * @param {*} target
 * @returns {target is MiddlewareFunc}
 */
function isMiddlewareFunc(target) {
    return ioc.isFunction(target) && ioc.isString(target.middleName);
}
exports.isMiddlewareFunc = isMiddlewareFunc;
/**
 * bind middleware name.
 *
 * @export
 * @param {Function} middleware
 * @param {string} name
 * @returns {MiddlewareFunc}
 */
function bindMiddlewareName(middleware, name) {
    let middle = middleware;
    middle.middleName = name;
    return middle;
}
exports.bindMiddlewareName = bindMiddlewareName;
/**
 * default middleware types.
 *
 * @export
 * @enum {number}
 */
var MiddlewareTypes;
(function (MiddlewareTypes) {
    MiddlewareTypes["Helmet"] = "helmet";
    MiddlewareTypes["BodyParser"] = "bodyParser";
    MiddlewareTypes["Cors"] = "Cors";
    MiddlewareTypes["Csrf"] = "Csrf";
    MiddlewareTypes["Json"] = "json";
    MiddlewareTypes["Logger"] = "logger";
    MiddlewareTypes["Session"] = "session";
    MiddlewareTypes["Content"] = "content";
    MiddlewareTypes["View"] = "view";
    MiddlewareTypes["Router"] = "router";
})(MiddlewareTypes = exports.MiddlewareTypes || (exports.MiddlewareTypes = {}));


});

unwrapExports(IMiddleware);
var IMiddleware_1 = IMiddleware.MiddlewareTypes;
var IMiddleware_2 = IMiddleware.bindMiddlewareName;
var IMiddleware_3 = IMiddleware.isMiddlewareFunc;

var MvcMiddleware_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.CompositeMiddleware = exports.MvcMiddleware = void 0;



/**
 * middleware
 *
 * @export
 * @abstract
 * @class Middleware
 * @extends {Handle<MvcContext>}
 * @implements {IMiddleware}
 */
class MvcMiddleware extends boot.Handle {
    /**
     * get injector of current message queue.
     */
    getInjector() {
        return this._injector();
    }
    static ρAnn() {
        return { "name": "MvcMiddleware" };
    }
}
tslib.__decorate([
    ioc.Inject(ioc.InjectorProxyToken),
    tslib.__metadata("design:type", Function)
], MvcMiddleware.prototype, "_injector", void 0);
exports.MvcMiddleware = MvcMiddleware;
/**
 * composite middleware.
 *
 * @export
 * @class CompositeMiddleware
 * @extends {Handles<IContext>}
 */
let CompositeMiddleware = class CompositeMiddleware extends boot.Handles {
    /**
     * get injector of current message queue.
     */
    getInjector() {
        return this._injector();
    }
    find(filter) {
        return this.handles.find(item => filter(item));
    }
    /**
     * use handle before
     *
     * @param {HandleType} handle
     * @param {HandleType} [before]
     * @returns {this}
     * @memberof LifeScope
     */
    useBefore(handle, before) {
        if (ioc.isString(before)) {
            let beforehdl = this.find((h) => h.middleName === before);
            super.useBefore(handle, beforehdl);
        }
        else {
            super.useBefore(handle, before);
        }
        return this;
    }
    /**
     * use handle after.
     *
     * @param {HandleType} handle
     * @param {HandleType} [after]
     * @returns {this}
     * @memberof LifeScope
     */
    useAfter(handle, after) {
        if (ioc.isString(after)) {
            let afterhdl = this.find((h) => h.middleName === after);
            super.useAfter(handle, afterhdl);
        }
        else {
            super.useAfter(handle, after);
        }
        return this;
    }
    registerHandle(HandleType) {
        if (ioc.isClass(HandleType)) {
            this.getInjector().registerType(HandleType);
        }
        return this;
    }
    toHandle(handleType) {
        var _a, _b, _c, _d;
        if (handleType instanceof ioc.Action) {
            return handleType.toAction();
        }
        else if (ioc.isClass(handleType)) {
            const ist = (_a = this.getInjector().get(handleType)) !== null && _a !== void 0 ? _a : this.getInjector().getContainer().getTypeReflects().getInjector(handleType).getInstance(handleType);
            return (_b = ist === null || ist === void 0 ? void 0 : ist.toAction) === null || _b === void 0 ? void 0 : _b.call(ist);
        }
        else if (ioc.isToken(handleType)) {
            return (_d = (_c = this.getInjector().get(handleType)) === null || _c === void 0 ? void 0 : _c.toAction) === null || _d === void 0 ? void 0 : _d.call(_c);
        }
        else if (ioc.isFunction(handleType)) {
            return handleType;
        }
        return null;
    }
    static ρAnn() {
        return { "name": "CompositeMiddleware", "params": { "find": ["filter"], "useBefore": ["handle", "before"], "useAfter": ["handle", "after"], "registerHandle": ["HandleType"], "toHandle": ["handleType"] } };
    }
};
tslib.__decorate([
    ioc.Inject(ioc.InjectorProxyToken),
    tslib.__metadata("design:type", Function)
], CompositeMiddleware.prototype, "_injector", void 0);
CompositeMiddleware = tslib.__decorate([
    ioc.Injectable()
], CompositeMiddleware);
exports.CompositeMiddleware = CompositeMiddleware;


});

unwrapExports(MvcMiddleware_1);
var MvcMiddleware_2 = MvcMiddleware_1.CompositeMiddleware;
var MvcMiddleware_3 = MvcMiddleware_1.MvcMiddleware;

var MvcMiddlewares_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MvcMiddlewares = void 0;



/**
 * mvc middlewares.
 *
 * @export
 * @class MvcMiddlewares
 * @extends {CompositeMiddleware}
 */
let MvcMiddlewares = class MvcMiddlewares extends MvcMiddleware_1.CompositeMiddleware {
    /**
     * setup root in koa.
     *
     * @param {MvcContext} mvcContext
     * @memberof MvcMiddlewares
     */
    setup(mvcContext) {
        mvcContext.getKoa().use(async (ctx, next) => {
            ctx.mvcContext = mvcContext;
            if (!ctx.getInjector) {
                ctx.getInjector = () => mvcContext.injector;
            }
            mvcContext.app = ctx.app;
            await this.execute(ctx);
            return await next();
        });
    }
    static ρAnn() {
        return { "name": "MvcMiddlewares", "params": { "setup": ["mvcContext"] } };
    }
};
MvcMiddlewares.ρNPT = true;
MvcMiddlewares = tslib.__decorate([
    ioc.Singleton()
], MvcMiddlewares);
exports.MvcMiddlewares = MvcMiddlewares;


});

unwrapExports(MvcMiddlewares_1);
var MvcMiddlewares_2 = MvcMiddlewares_1.MvcMiddlewares;

var MiddlewareRegister_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MiddlewareRegister = void 0;



/**
 * middleware register.
 *
 * @export
 * @class MiddlewareRegister
 */
let MiddlewareRegister = class MiddlewareRegister {
    constructor() {
        this.map = new Map();
    }
    set(key, val) {
        this.map.set(key, val);
    }
    /**
     * setup middleware.
     *
     * @param {ICoreInjector} injector
     * @memberof MiddlewareRegister
     */
    setup(injector) {
        this.map.forEach((meta, middle) => {
            let middlewares = injector.getInstance(MvcMiddlewares_1.MvcMiddlewares);
            if (meta.regIn) {
                let comp = meta.regIn;
                if (!injector.has(comp)) {
                    injector.register(comp);
                }
                middlewares = injector.get(comp);
            }
            if (meta.before) {
                middlewares.useBefore(middle, meta.before);
            }
            else if (meta.after) {
                middlewares.useAfter(middle, meta.after);
            }
            else {
                middlewares.use(middle);
            }
        });
    }
    static ρAnn() {
        return { "name": "MiddlewareRegister", "params": { "set": ["key", "val"], "setup": ["injector"] } };
    }
};
MiddlewareRegister.ρNPT = true;
tslib.__decorate([
    tslib.__param(0, ioc.Inject(ioc.INJECTOR)),
    tslib.__metadata("design:type", Function),
    tslib.__metadata("design:paramtypes", [Object]),
    tslib.__metadata("design:returntype", void 0)
], MiddlewareRegister.prototype, "setup", null);
MiddlewareRegister = tslib.__decorate([
    ioc.Singleton(),
    tslib.__metadata("design:paramtypes", [])
], MiddlewareRegister);
exports.MiddlewareRegister = MiddlewareRegister;


});

unwrapExports(MiddlewareRegister_1);
var MiddlewareRegister_2 = MiddlewareRegister_1.MiddlewareRegister;

var ResultValue_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResultValue = void 0;
/**
 * controller method return result type.
 *
 * @export
 * @abstract
 * @class ResultValue
 */
class ResultValue {
    constructor(contentType) {
        this.contentType = contentType;
    }
    static ρAnn() {
        return { "name": "ResultValue" };
    }
}
exports.ResultValue = ResultValue;


});

unwrapExports(ResultValue_1);
var ResultValue_2 = ResultValue_1.ResultValue;

var FileResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.FileResult = void 0;





/**
 * controller method return result type of file.
 *
 * @export
 * @class FileResult
 */
class FileResult extends ResultValue_1.ResultValue {
    constructor(file, options) {
        super((options === null || options === void 0 ? void 0 : options.contentType) || 'application/octet-stream');
        this.file = file;
        this.options = options;
    }
    async sendValue(ctx) {
        let file = this.file;
        ctx.type = this.contentType;
        if (this.options && this.options.filename) {
            ctx.attachment(this.options.filename, this.options.disposition);
        }
        let confige = ctx.mvcContext.getConfiguration();
        if (ioc.isString(file)) {
            let filepath = (path.isAbsolute(file) || !confige.baseURL) ? file : path.join(confige.baseURL, file);
            if (fs.existsSync(filepath)) {
                ctx.body = fs.createReadStream(filepath);
            }
        }
        else if (file instanceof Buffer) {
            ctx.body = file;
        }
        else if (file instanceof stream.Stream) {
            ctx.body = file;
        }
    }
    static ρAnn() {
        return { "name": "FileResult" };
    }
}
exports.FileResult = FileResult;


});

unwrapExports(FileResult_1);
var FileResult_2 = FileResult_1.FileResult;

var JsonResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.JsonResult = void 0;

/**
 * controller method return result type of json.
 * context type 'application/json'
 *
 * @export
 * @class JsonResult
 */
class JsonResult extends ResultValue_1.ResultValue {
    constructor(data) {
        super('application/json');
        this.data = data;
    }
    async sendValue(ctx) {
        ctx.type = this.contentType;
        ctx.body = this.data || {};
    }
    static ρAnn() {
        return { "name": "JsonResult" };
    }
}
exports.JsonResult = JsonResult;


});

unwrapExports(JsonResult_1);
var JsonResult_2 = JsonResult_1.JsonResult;

var RedirectResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.RedirectResult = void 0;

/**
 * redirect url
 *
 * @export
 * @class RedirectResult
 * @extends {ResultValue}
 */
class RedirectResult extends ResultValue_1.ResultValue {
    constructor(url, alt) {
        super('text/html');
        this.url = url;
        this.alt = alt;
    }
    async sendValue(ctx) {
        return ctx.redirect(this.url, this.alt);
    }
    static ρAnn() {
        return { "name": "RedirectResult" };
    }
}
exports.RedirectResult = RedirectResult;


});

unwrapExports(RedirectResult_1);
var RedirectResult_2 = RedirectResult_1.RedirectResult;

var ViewResult_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ViewResult = void 0;

/**
 * controller method return result type of view.
 * context type 'text/html'
 *
 * @export
 * @class ViewResult
 */
class ViewResult extends ResultValue_1.ResultValue {
    constructor(name, model) {
        super('text/html');
        this.name = name;
        this.model = model;
    }
    async sendValue(ctx) {
        if (!ctx.render) {
            return Promise.reject('view engin middleware no configed!');
        }
        else {
            ctx.type = this.contentType;
            return ctx.render(this.name, this.model);
        }
    }
    static ρAnn() {
        return { "name": "ViewResult" };
    }
}
exports.ViewResult = ViewResult;


});

unwrapExports(ViewResult_1);
var ViewResult_2 = ViewResult_1.ViewResult;

var RouteChecker_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.RouteChecker = void 0;


const urlReg = /\/((\w|%|\.))+\.\w+$/;
const noParms = /\/\s*$/;
const hasParms = /\?\S*$/;
const subStart = /^\s*\/|\?/;
let RouteChecker = class RouteChecker extends ioc.IocCoreService {
    constructor() {
        super(...arguments);
        this.assertUrlRegExp = urlReg;
    }
    isRoute(ctxUrl) {
        return !this.assertUrlRegExp.test(ctxUrl);
    }
    getReqRoute(ctx) {
        let reqUrl = this.vaildify(ctx.url, true);
        let config = ctx.mvcContext.getConfiguration();
        if (config.routePrefix) {
            return reqUrl.replace(config.routePrefix, '');
        }
        return reqUrl;
    }
    vaildify(routePath, foreNull = false) {
        if (foreNull && routePath === '/') {
            routePath = '';
        }
        if (noParms.test(routePath)) {
            routePath = routePath.substring(0, routePath.lastIndexOf('/'));
        }
        if (hasParms.test(routePath)) {
            routePath = routePath.substring(0, routePath.lastIndexOf('?'));
        }
        return routePath;
    }
    isActiveRoute(ctx, route) {
        let routeUrl = this.getReqRoute(ctx);
        if (route === '' || route === routeUrl) {
            return true;
        }
        return routeUrl.startsWith(route) && subStart.test(routeUrl.substring(route.length));
    }
    static ρAnn() {
        return { "name": "RouteChecker", "params": { "isRoute": ["ctxUrl"], "getReqRoute": ["ctx"], "vaildify": ["routePath", "foreNull"], "isActiveRoute": ["ctx", "route"] } };
    }
};
RouteChecker = tslib.__decorate([
    ioc.Singleton()
], RouteChecker);
exports.RouteChecker = RouteChecker;


});

unwrapExports(RouteChecker_1);
var RouteChecker_2 = RouteChecker_1.RouteChecker;

var Route = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.MvcRoute = exports.RouteUrlArgToken = void 0;




exports.RouteUrlArgToken = ioc.tokenId('route_url');
let MvcRoute = class MvcRoute extends MvcMiddleware_1.MvcMiddleware {
    constructor(url) {
        super();
        if (url) {
            this.metaUrl = url;
        }
    }
    get url() {
        if (!this._url) {
            this._url = this.vaildify(this.metaUrl, true);
        }
        return this._url;
    }
    set url(val) {
        this._url = val;
    }
    getChecker() {
        if (!this.checker) {
            this.checker = this.getInjector().get(RouteChecker_1.RouteChecker);
        }
        return this.checker;
    }
    getReqRoute(ctx) {
        return this.getChecker().getReqRoute(ctx);
    }
    vaildify(routePath, foreNull = false) {
        return this.getChecker().vaildify(routePath, foreNull);
    }
    match(ctx) {
        if (ctx.status && ctx.status !== 404) {
            return false;
        }
        return this.getChecker().isActiveRoute(ctx, this.url);
    }
    async execute(ctx, next) {
        if (this.match(ctx)) {
            await this.navigate(ctx, next);
        }
        else {
            return await next();
        }
    }
    toHandle(handleType) {
        var _a, _b, _c, _d;
        if (handleType instanceof ioc.Action) {
            return handleType.toAction();
        }
        else if (ioc.isClass(handleType)) {
            const ist = (_a = this.getInjector().get(handleType)) !== null && _a !== void 0 ? _a : this.getInjector().getContainer().getTypeReflects().getInjector(handleType).getInstance(handleType);
            return (_b = ist === null || ist === void 0 ? void 0 : ist.toAction) === null || _b === void 0 ? void 0 : _b.call(ist);
        }
        else if (ioc.isToken(handleType)) {
            return (_d = (_c = this.getInjector().get(handleType)) === null || _c === void 0 ? void 0 : _c.toAction) === null || _d === void 0 ? void 0 : _d.call(_c);
        }
        else if (ioc.isFunction(handleType)) {
            return handleType;
        }
        return null;
    }
    static ρAnn() {
        return { "name": "MvcRoute", "params": { "constructor": ["url"], "getReqRoute": ["ctx"], "vaildify": ["routePath", "foreNull"], "match": ["ctx"], "execute": ["ctx", "next"], "navigate": ["ctx", "next"], "toHandle": ["handleType"] } };
    }
};
MvcRoute.ρNPT = true;
MvcRoute = tslib.__decorate([
    ioc.Abstract(),
    tslib.__metadata("design:paramtypes", [String])
], MvcRoute);
exports.MvcRoute = MvcRoute;


});

unwrapExports(Route);
var Route_1 = Route.MvcRoute;
var Route_2 = Route.RouteUrlArgToken;

var Router_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.Router = void 0;





let Router = class Router extends MvcMiddleware_1.CompositeMiddleware {
    constructor() {
        super(...arguments);
        this.sorted = false;
    }
    vaild(ctx) {
        return (!ctx.status || ctx.status === 404) && this.isRouteUrl(ctx.url);
    }
    async execute(ctx, next) {
        if (!this.sorted) {
            this.handles = this.handles.sort((a, b) => {
                if (a instanceof Route.MvcRoute && b instanceof Route.MvcRoute) {
                    return (b.url || '').length - (a.url || '').length;
                }
                return -1;
            });
            this.resetFuncs();
            this.sorted = true;
        }
        await super.execute(ctx);
        if (next) {
            return await next();
        }
    }
    getChecker() {
        return this.getInjector().get(RouteChecker_1.RouteChecker);
    }
    isRouteUrl(route) {
        return this.getChecker().isRoute(route);
    }
    routes(...routes) {
        routes.forEach(r => this.use(r));
        this.sorted = false;
        return this;
    }
    static ρAnn() {
        return { "name": "Router", "params": { "vaild": ["ctx"], "execute": ["ctx", "next"], "isRouteUrl": ["route"], "routes": ["routes"] } };
    }
};
Router.ρNPT = true;
Router = tslib.__decorate([
    ioc.Singleton()
], Router);
exports.Router = Router;


});

unwrapExports(Router_1);
var Router_2 = Router_1.Router;

var AuthorizationService_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.AuthorizationService = void 0;


let AuthorizationService = class AuthorizationService {
    static ρAnn() {
        return { "name": "AuthorizationService", "params": { "getAuthMiddlewares": ["ctx", "controller", "propertyKey"] } };
    }
};
AuthorizationService = tslib.__decorate([
    ioc.Abstract()
], AuthorizationService);
exports.AuthorizationService = AuthorizationService;


});

unwrapExports(AuthorizationService_1);
var AuthorizationService_2 = AuthorizationService_1.AuthorizationService;

/*!
 * vary
 * Copyright(c) 2014-2017 Douglas Christopher Wilson
 * MIT Licensed
 */

/**
 * Module exports.
 */

var vary_1 = vary;
var append_1 = append;

/**
 * RegExp to match field-name in RFC 7230 sec 3.2
 *
 * field-name    = token
 * token         = 1*tchar
 * tchar         = "!" / "#" / "$" / "%" / "&" / "'" / "*"
 *               / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
 *               / DIGIT / ALPHA
 *               ; any VCHAR, except delimiters
 */

var FIELD_NAME_REGEXP = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;

/**
 * Append a field to a vary header.
 *
 * @param {String} header
 * @param {String|Array} field
 * @return {String}
 * @public
 */

function append (header, field) {
  if (typeof header !== 'string') {
    throw new TypeError('header argument is required')
  }

  if (!field) {
    throw new TypeError('field argument is required')
  }

  // get fields array
  var fields = !Array.isArray(field)
    ? parse(String(field))
    : field;

  // assert on invalid field names
  for (var j = 0; j < fields.length; j++) {
    if (!FIELD_NAME_REGEXP.test(fields[j])) {
      throw new TypeError('field argument contains an invalid header name')
    }
  }

  // existing, unspecified vary
  if (header === '*') {
    return header
  }

  // enumerate current values
  var val = header;
  var vals = parse(header.toLowerCase());

  // unspecified vary
  if (fields.indexOf('*') !== -1 || vals.indexOf('*') !== -1) {
    return '*'
  }

  for (var i = 0; i < fields.length; i++) {
    var fld = fields[i].toLowerCase();

    // append value (case-preserving)
    if (vals.indexOf(fld) === -1) {
      vals.push(fld);
      val = val
        ? val + ', ' + fields[i]
        : fields[i];
    }
  }

  return val
}

/**
 * Parse a vary header into an array.
 *
 * @param {String} header
 * @return {Array}
 * @private
 */

function parse (header) {
  var end = 0;
  var list = [];
  var start = 0;

  // gather tokens
  for (var i = 0, len = header.length; i < len; i++) {
    switch (header.charCodeAt(i)) {
      case 0x20: /*   */
        if (start === end) {
          start = end = i + 1;
        }
        break
      case 0x2c: /* , */
        list.push(header.substring(start, end));
        start = end = i + 1;
        break
      default:
        end = i + 1;
        break
    }
  }

  // final token
  list.push(header.substring(start, end));

  return list
}

/**
 * Mark that a request is varied on a header field.
 *
 * @param {Object} res
 * @param {String|Array} field
 * @public
 */

function vary (res, field) {
  if (!res || !res.getHeader || !res.setHeader) {
    // quack quack
    throw new TypeError('res argument is required')
  }

  // get existing header
  var val = res.getHeader('Vary') || '';
  var header = Array.isArray(val)
    ? val.join(', ')
    : String(val);

  // set new header
  if ((val = append(header, field))) {
    res.setHeader('Vary', val);
  }
}
vary_1.append = append_1;

var ControllerRoute_1 = createCommonjsModule(function (module, exports) {
Object.defineProperty(exports, "__esModule", { value: true });
exports.ControllerRoute = exports.RouteControllerMiddlewaresToken = exports.RouteControllerArgToken = exports.isBuffer = void 0;













function isBuffer(target) {
    if (typeof Buffer === 'undefined') {
        return false;
    }
    else {
        return ioc.lang.getClass(target) === Buffer;
    }
}
exports.isBuffer = isBuffer;
const emptyNext = async () => { };
exports.RouteControllerArgToken = ioc.tokenId('ROUTE_CONTRL_ARGS');
exports.RouteControllerMiddlewaresToken = ioc.tokenId('ROUTE_CONTRL_MIDDLEWARES');
const restParms = /^\S*:/;
const isRest = /\/:/;
let ControllerRoute = class ControllerRoute extends Route.MvcRoute {
    constructor(url, controller, middlewares) {
        super(url);
        this.controller = controller;
        this.middlewares = middlewares;
    }
    navigate(ctx, next) {
        if (ctx._isCors) {
            return this.options(ctx, next);
        }
        else {
            return this.navigating(ctx, next);
        }
    }
    async navigating(ctx, next) {
        let meta = this.getRouteMetaData(ctx, RequestMethod_1.parseRequestMethod(ctx.method));
        if (!meta) {
            return await next();
        }
        let middlewares = this.getRouteMiddleware(ctx, meta);
        if (middlewares.length) {
            await this.execFuncs(ctx, middlewares.map(m => this.toHandle(m)).filter(f => !!f));
        }
        await this.invoke(ctx, meta);
        return await next();
    }
    getRouteMiddleware(ctx, meta) {
        let auths = ctx.getInjector().getServices(AuthorizationService_1.AuthorizationService);
        let middlewares = this.middlewares || [];
        if (auths) {
            middlewares = auths.map(auth => auth.getAuthMiddlewares(ctx, this.controller)).reduce((p, c) => p.concat(c), [])
                .concat(middlewares)
                .concat(auths.map(a => a.getAuthMiddlewares(ctx, this.controller, meta.propertyKey)).reduce((p, c) => p.concat(c), []));
        }
        if (meta.middlewares) {
            middlewares = middlewares.concat(meta.middlewares);
        }
        return middlewares;
    }
    async options(ctx, next) {
        var _a, _b;
        let requestOrigin = ctx.get('Origin');
        ctx.vary('Origin');
        if (!requestOrigin) {
            return await next();
        }
        let config = ctx.mvcContext.getConfiguration();
        let options = config.corsOptions || {};
        let origin;
        if (ioc.isFunction(options.origin)) {
            origin = options.origin(ctx);
            if (ioc.isPromise(origin)) {
                origin = await origin;
            }
            if (!origin) {
                return await next();
            }
        }
        else {
            origin = options.origin || requestOrigin;
        }
        let headersSet = {};
        let set = (key, value) => {
            ctx.set(key, value);
            headersSet[key] = value;
        };
        if (ctx.method !== 'OPTIONS') {
            set('Access-Control-Allow-Origin', origin);
            if (options.credentials === true) {
                set('Access-Control-Allow-Credentials', 'true');
            }
            if (options.exposeHeaders) {
                set('Access-Control-Expose-Headers', options.exposeHeaders);
            }
            if (!options.keepHeadersOnError) {
                return await next();
            }
            try {
                await next();
            }
            catch (err) {
                const errHeadersSet = err.headers || {};
                const varyWithOrigin = vary_1.append(errHeadersSet.vary || errHeadersSet.Vary || '', 'Origin');
                delete errHeadersSet.Vary;
                err.headers = Object.assign(Object.assign(Object.assign({}, errHeadersSet), headersSet), { vary: varyWithOrigin });
                ctx.status = err instanceof errors.HttpError ? err.status || 500 : 500;
                ctx.message = err.message || err.toString() || '';
                (_b = (_a = ctx.mvcContext.getLogManager()) === null || _a === void 0 ? void 0 : _a.getLogger()) === null || _b === void 0 ? void 0 : _b.error(err);
            }
        }
        else {
            const coremeta = this.getCorsMeta(ctx, ctx.get('Access-Control-Request-Method'));
            if (!coremeta) {
                ctx.status = 403;
                return await next();
            }
            options = Object.assign(Object.assign({}, options), coremeta);
            ctx.set('Access-Control-Allow-Origin', origin);
            if (options.credentials === true) {
                ctx.set('Access-Control-Allow-Credentials', 'true');
            }
            let maxAge = String(options.maxAge);
            if (maxAge) {
                ctx.set('Access-Control-Max-Age', maxAge);
            }
            let allowsM = ioc.isArray(options.allowMethods) ?
                options.allowMethods.map(m => RequestMethod_1.methodToString(m)).filter(m => !!m).join(',')
                : options.allowMethods;
            if (allowsM) {
                ctx.set('Access-Control-Allow-Methods', allowsM);
            }
            let allowH = ioc.isArray(options.allowHeaders) ? options.allowHeaders.filter(m => !!m).join(',') : options.allowHeaders;
            if (!allowH) {
                allowH = ctx.get('Access-Control-Request-Headers');
            }
            if (allowH) {
                ctx.set('Access-Control-Allow-Headers', allowH);
            }
            ctx.status = 204;
        }
    }
    getCorsMeta(ctx, reqMethod) {
        if (!reqMethod) {
            return null;
        }
        let method = RequestMethod_1.parseRequestMethod(reqMethod);
        let meta = this.getRouteMetaData(ctx, method);
        if (meta && meta.propertyKey) {
            let corsmetas = ioc.getMethodMetadata(decorators.Cors, this.controller)[meta.propertyKey.toString()] || [];
            if (corsmetas.length < 1) {
                corsmetas = ioc.getTypeMetadata(decorators.Cors, this.controller);
            }
            if (corsmetas.length) {
                return corsmetas.find(cor => {
                    if (!cor.allowMethods) {
                        return true;
                    }
                    if (cor.allowMethods) {
                        if (ioc.isString(cor.allowMethods)) {
                            return cor.allowMethods.toUpperCase().indexOf(reqMethod) >= 0;
                        }
                        else if (ioc.isArray(cor.allowMethods)) {
                            return cor.allowMethods.some(c => RequestMethod_1.methodToString(c) === reqMethod);
                        }
                    }
                    return false;
                });
            }
        }
        return null;
    }
    async invoke(ctx, meta) {
        let injector = ctx.mvcContext.injector;
        if (meta && meta.propertyKey) {
            let ctrl = injector.getInstance(this.controller, { provide: IContext.ContextToken, useValue: ctx });
            let reflects = ctx.mvcContext.reflects;
            let providers = await this.createProvider(ctx, ctrl, meta, reflects.getParameters(this.controller, ctrl, meta.propertyKey));
            let result = await injector.invoke(ctrl, meta.propertyKey, ...providers);
            if (ioc.isPromise(result)) {
                result = await result;
            }
            // middleware.
            if (ioc.isFunction(result)) {
                await result(ctx);
            }
            else if (result instanceof MvcMiddleware_1.MvcMiddleware || result instanceof MvcMiddlewares_1.MvcMiddlewares) {
                await result.execute(ctx, emptyNext);
            }
            else if (ioc.isBaseType(result) || ioc.isArray(result) || isBuffer(result)) {
                if (isBuffer(result)) {
                    if (typeof Buffer !== 'undefined') {
                        ctx.body = Buffer.from(result);
                    }
                    else {
                        ctx.body = result;
                    }
                }
                else {
                    ctx.body = result;
                }
                ctx.status = 200;
            }
            else if (ioc.isObject(result)) {
                if (result instanceof ResultValue_1.ResultValue) {
                    await result.sendValue(ctx);
                }
                else {
                    ctx.body = result;
                    ctx.status = 200;
                }
            }
            else {