@dazejs/framework/dist/http/middleware/middleware-service.js

Daze.js - A powerful web framework for Node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.MiddlewareService = void 0;
const pipeline_1 = require("../../pipeline");
const symbol_1 = require("../../symbol");
class MiddlewareService {
    constructor(app) {
        this.middlewares = [];
        this.app = app;
    }
    register(middleware, args = []) {
        if (typeof middleware === 'string') {
            this.parseStringMiddleware(middleware, args);
        }
        else if (typeof middleware === 'function') {
            this.parseFunctionMiddleware(middleware, args);
        }
        this.reSortMiddlewaresByOrder();
        return this;
    }
    combineBefore(anotherMiddleware) {
        var _a;
        if (!(anotherMiddleware instanceof MiddlewareService))
            return this;
        const wrappedMiddlewares = (_a = anotherMiddleware.middlewares) === null || _a === void 0 ? void 0 : _a.map(this.wrapperMiddleware);
        this.middlewares.unshift(...wrappedMiddlewares);
        this.reSortMiddlewaresByOrder();
        return this;
    }
    combineAfter(anotherMiddleware) {
        var _a;
        if (!(anotherMiddleware instanceof MiddlewareService))
            return this;
        const wrappedMiddlewares = (_a = anotherMiddleware.middlewares) === null || _a === void 0 ? void 0 : _a.map(this.wrapperMiddleware);
        this.middlewares.push(...wrappedMiddlewares);
        this.reSortMiddlewaresByOrder();
        return this;
    }
    parseStringMiddleware(middlewareName, args = []) {
        const middleware = this.app.get(middlewareName, args);
        if (!middleware)
            return;
        this.parseClassInstanceMiddleware(middleware);
    }
    parseFunctionMiddleware(middleware, args = []) {
        if (middleware.prototype && Reflect.getMetadata('type', middleware) === 'middleware') {
            const _middleware = this.app.get(middleware, args);
            if (!_middleware)
                return;
            this.parseClassInstanceMiddleware(_middleware);
        }
        else {
            this.middlewares.push(this.wrapperMiddleware(middleware));
        }
    }
    parseClassInstanceMiddleware(middleware) {
        this.middlewares.push(this.wrapperMiddleware(middleware));
    }
    wrapperMiddleware(middleware) {
        var _a, _b;
        if ('resolver' in middleware) {
            return middleware;
        }
        else if (typeof middleware === 'function') {
            const order = (_a = Reflect.getMetadata(symbol_1.ProviderType.ORDER, middleware)) !== null && _a !== void 0 ? _a : Number.MAX_SAFE_INTEGER;
            return {
                resolver: middleware,
                order
            };
        }
        else {
            const order = (_b = Reflect.getMetadata(symbol_1.ProviderType.ORDER, middleware.constructor)) !== null && _b !== void 0 ? _b : Number.MAX_SAFE_INTEGER;
            return {
                resolver: async (request, next) => middleware.resolve(request, next),
                order
            };
        }
    }
    reSortMiddlewaresByOrder() {
        this.middlewares.sort((o1, o2) => o1.order - o2.order);
    }
    async handle(request, dispatcher) {
        const result = await (new pipeline_1.Pipeline())
            .send(request)
            .pipe(...this.middlewares.map(o => o.resolver))
            .process(dispatcher);
        return result;
    }
}
exports.MiddlewareService = MiddlewareService;
//# sourceMappingURL=middleware-service.js.map