stix/dist/Library/Middleware/DispatchMiddleware.js

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
Object.defineProperty(exports, "__esModule", { value: true });
const AbstractMiddleware_1 = require("./AbstractMiddleware");
const Response_1 = require("../Response");
const Error_1 = require("../Error");
const debug_1 = require("../../debug");
const decorators_1 = require("../ServiceManager/decorators");
const Logger_1 = require("../Logger");
const debug = debug_1.createDebugLogger('middleware:dispatch');
class DispatchMiddleware extends AbstractMiddleware_1.AbstractMiddleware {
    async pass(ctx, next) {
        if (ctx.state.response) {
            debug('Response found on context, calling next.');
            return next();
        }
        const { controller, action, controllerName } = ctx.state.dispatch;
        debug(`Dispatching ${controllerName}.${action}.`);
        // Route found, controller found... but the action doesn't exist. Or isn't a method.
        if (typeof controller[action] !== 'function') {
            debug(`${controllerName}.${action} not found, calling next.`);
            this.logger.error(`Action "${action}" not found on controller "${controllerName}" for request path "${ctx.path}".`);
            ctx.state.response = this.responseService.serverError().notImplemented();
            return next();
        }
        let response;
        try {
            response = await controller[action](ctx);
            if (!(response instanceof Response_1.Response)) {
                throw new Error_1.InvalidActionResultError([
                    `Action "${controllerName}.${action}" failed to produce a Response instance,`,
                    `instead got type "${typeof response}".`,
                    'Did you forget to add a return statement in front of your response?',
                ].join(' '));
            }
        }
        catch (error) {
            this.logger.error(error.message, error);
            response = this.responseService.serverError().internalServerError(null, null, { error });
        }
        ctx.state.response = response;
        debug(`Dispatched ${controllerName}.${action}, calling next.`);
        next();
    }
}
__decorate([
    decorators_1.inject(Response_1.ResponseService),
    __metadata("design:type", Response_1.ResponseService)
], DispatchMiddleware.prototype, "responseService", void 0);
__decorate([
    decorators_1.inject(Logger_1.LoggerService),
    __metadata("design:type", Logger_1.LoggerService)
], DispatchMiddleware.prototype, "logger", void 0);
exports.DispatchMiddleware = DispatchMiddleware;
//# sourceMappingURL=DispatchMiddleware.js.map