f2e-server3/lib/middlewares/index.js

f2e-server 3.0

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.combineMiddleware = void 0;
const logger_1 = __importDefault(require("../utils/logger"));
const node_process_1 = require("node:process");
const livereload_1 = __importDefault(require("./livereload"));
const try_files_1 = __importDefault(require("./try_files"));
const proxy_1 = __importDefault(require("./proxy"));
const esbuild_1 = __importDefault(require("./esbuild"));
const less_1 = __importDefault(require("./less"));
const postcss_1 = __importDefault(require("./postcss"));
const auth_1 = __importDefault(require("./auth"));
const alias_1 = __importDefault(require("./alias"));
const include_1 = __importDefault(require("./include"));
const routes_1 = __importDefault(require("./routes"));
const combineMiddleware = async (conf, middlewares) => {
    const onMemoryLoads = [];
    const onMemoryInits = [];
    const beforeRoutes = [];
    const onRoutes = [];
    const buildWatchers = [];
    const onSets = [];
    const onGets = [];
    const buildFilters = [];
    const watchFilters = [];
    const outputFilters = [];
    /** 开始内置中间件加载 */
    middlewares.push(auth_1.default);
    middlewares.push(routes_1.default);
    middlewares.push(include_1.default);
    middlewares.push(alias_1.default);
    middlewares.push(less_1.default);
    middlewares.push(postcss_1.default);
    middlewares.push(esbuild_1.default);
    middlewares.push(proxy_1.default);
    middlewares.push(livereload_1.default);
    /** tryfiles 顺序需要在最后 */
    middlewares.push(try_files_1.default);
    for (let i = 0; i < middlewares.length; i++) {
        const m = middlewares[i];
        const middle = 'execute' in m ? m : (function (m) {
            let middle = undefined;
            if ('middleware' in m) {
                const middlewareName = `f2e-middle-${m.middleware}`;
                try {
                    middle = require(middlewareName);
                    if (middle) {
                        middle.name = middle.name || middlewareName;
                    }
                }
                catch (e) {
                    logger_1.default.error(e);
                    (0, node_process_1.exit)(1);
                }
            }
            return middle;
        })(m);
        if (!middle)
            continue;
        const { mode = ['dev', 'build', 'prod'], name = 'system', execute } = middle;
        if (mode.includes(conf.mode)) {
            const result = await execute(conf);
            if (!result)
                continue;
            const { onMemoryInit, onMemoryLoad, beforeRoute, onRoute, buildWatcher, onSet, onGet, buildFilter, watchFilter, outputFilter } = result;
            onMemoryInit && onMemoryInits.push(onMemoryInit);
            onMemoryLoad && onMemoryLoads.push(onMemoryLoad);
            beforeRoute && beforeRoutes.push(beforeRoute);
            onRoute && onRoutes.push(onRoute);
            buildWatcher && buildWatchers.push(buildWatcher);
            onSet && onSets.push(onSet);
            onGet && onGets.push(onGet);
            buildFilter && buildFilters.push(buildFilter);
            watchFilter && watchFilters.push(watchFilter);
            outputFilter && outputFilters.push(outputFilter);
        }
    }
    return {
        onMemoryInit: async (store) => {
            await Promise.all(onMemoryInits.map(fn => fn?.(store)));
        },
        onMemoryLoad: async (store) => {
            await Promise.all(onMemoryLoads.map(fn => fn?.(store)));
        },
        beforeRoute: async (pathname, ctx) => {
            let _pathname = pathname;
            for (let i = 0; i < beforeRoutes.length; i++) {
                // beforeRoute 返回 false 停止继续
                let res = await beforeRoutes[i](pathname, ctx);
                if (res === false) {
                    return res;
                }
                if (typeof res === 'string') {
                    _pathname = res;
                }
            }
            return _pathname;
        },
        onRoute: async (pathname, ctx) => {
            let _pathname = pathname;
            for (let i = 0; i < onRoutes.length; i++) {
                // onRoute 返回 false 停止继续
                let res = await onRoutes[i](_pathname, ctx);
                if (res === false) {
                    return false;
                }
                if (typeof res === 'string') {
                    _pathname = res;
                }
            }
            return _pathname;
        },
        buildWatcher: (pathname, eventType, build, store) => {
            buildWatchers.map(item => item(pathname, eventType, build, store));
        },
        onSet: async (pathname, data, store) => {
            let result = { data, originPath: pathname, outputPath: pathname };
            for (let i = 0; i < onSets.length; i++) {
                const temp = await onSets[i](result.outputPath, result.data, store);
                result = Object.assign({}, result, temp);
            }
            return {
                ...result,
                originPath: pathname,
            };
        },
        onGet: async (pathname, data, store) => {
            let temp = data;
            for (let i = 0; i < onGets.length; i++) {
                let res = await onGets[i](pathname, temp || data, store);
                temp = res || temp;
            }
            return temp;
        },
        watchFilter: (pathname) => {
            for (let i = 0; i < watchFilters.length; i++) {
                let allow = watchFilters[i](pathname);
                if (allow === false) {
                    return false;
                }
            }
            return true;
        },
        buildFilter: (pathname, size) => {
            for (let i = 0; i < buildFilters.length; i++) {
                let allow = buildFilters[i](pathname, size);
                if (allow === false) {
                    return false;
                }
            }
            return true;
        },
        outputFilter: (pathname, data) => {
            for (let i = 0; i < outputFilters.length; i++) {
                let allow = outputFilters[i](pathname, data);
                if (allow === false) {
                    return false;
                }
            }
            return true;
        }
    };
};
exports.combineMiddleware = combineMiddleware;