webserv/src/core/upgrade.js

a quick, flexible, fully typed development server

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
(function (factory) {
    if (typeof module === "object" && typeof module.exports === "object") {
        var v = factory(require, exports);
        if (v !== undefined) module.exports = v;
    }
    else if (typeof define === "function" && define.amd) {
        define(["require", "exports"], factory);
    }
})(function (require, exports) {
    "use strict";
    Object.defineProperty(exports, "__esModule", { value: true });
    function isUpgrade(value) {
        return value && typeof value === 'object' && typeof value.run === 'function' && typeof value.test === 'function';
    }
    exports.upgrade = ({ guards = [], upgrade, errorHandler }) => {
        const handler = Array.isArray(upgrade) ? exports.multiupgrade(upgrade) : upgrade;
        function test(request) {
            return __awaiter(this, void 0, void 0, function* () {
                try {
                    for (let guard of guards) {
                        if (!(yield guard(request))) {
                            return false;
                        }
                    }
                    return true;
                }
                catch (e) {
                    if (errorHandler) {
                        errorHandler(e);
                        return false;
                    }
                    throw e;
                }
            });
        }
        const run = (request, socket, head) => __awaiter(void 0, void 0, void 0, function* () {
            try {
                return yield handler(request, socket, head);
            }
            catch (e) {
                if (errorHandler) {
                    errorHandler(e);
                }
                else {
                    throw e;
                }
            }
        });
        return {
            run,
            test
        };
    };
    exports.multiupgrade = (list) => {
        const upgrades = list.map((item) => (isUpgrade(item) ? item : exports.upgrade(item)));
        return (request, socket, head) => __awaiter(void 0, void 0, void 0, function* () {
            for (let upgrade of upgrades) {
                if (yield upgrade.test(request)) {
                    return yield upgrade.run(request, socket, head);
                }
            }
        });
    };
});
//# sourceMappingURL=upgrade.js.map