midway-fatcms 0.0.1-beta.1

package/dist/service/proxyapi/ProxyApiLoadService.js

@@ -0,0 +1,164 @@
+"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 });
+exports.ProxyApiLoadService = void 0;
+const core_1 = require("@midwayjs/core");
+const _ = require("lodash");
+const BaseService_1 = require("../base/BaseService");
+const RouteTrie_1 = require("./RouteTrie");
+const RouteHandler_1 = require("./RouteHandler");
+const CurdProService_1 = require("../curd/CurdProService");
+const SystemTables_1 = require("../../models/SystemTables");
+const keys_1 = require("../../libs/crud-pro/models/keys");
+const functions_1 = require("../../libs/utils/functions");
+const ProxyApiUtils_1 = require("./ProxyApiUtils");
+const WeightedRandom_1 = require("./WeightedRandom");
+const WeightedRoundRobin_1 = require("./WeightedRoundRobin");
+const WorkbenchService_1 = require("../WorkbenchService");
+const exceptions_1 = require("../../libs/crud-pro/exceptions");
+function toUpstreamInfo(config_content) {
+    const obj = (0, functions_1.parseJsonObject)(config_content);
+    if (!obj) {
+        return {
+            balanceStrategy: ProxyApiUtils_1.BALANCE_STRATEGY.ROUND_ROBIN,
+            targetList: [],
+        };
+    }
+    const targetList = _.get(obj, 'data.targetList', []);
+    const balanceStrategy = _.get(obj, 'data.baseInfo.balanceStrategy');
+    if (Array.isArray(targetList)) {
+        const targetListParsed = targetList
+            .map((item) => {
+            return {
+                origin: item.origin,
+                weight: item.weight || 1,
+            };
+        })
+            .filter(item => {
+            const origin = (item === null || item === void 0 ? void 0 : item.origin) || '';
+            return origin.startsWith('http://') || origin.startsWith('https://');
+        });
+        return {
+            balanceStrategy,
+            targetList: targetListParsed,
+        };
+    }
+    return {
+        balanceStrategy: ProxyApiUtils_1.BALANCE_STRATEGY.ROUND_ROBIN,
+        targetList: [],
+    };
+}
+/**
+ * 接口代理。 数据加载
+ */
+let ProxyApiLoadService = class ProxyApiLoadService extends BaseService_1.BaseService {
+    /**
+     * 创建路由树。刷新路由缓存
+     * @param workbench_code
+     */
+    async buildRouteTrie(workbench_code) {
+        const upstreamMap = await this.buildUpstreamMap();
+        const routeTrie = (0, RouteTrie_1.getRouteTrie)(workbench_code);
+        routeTrie.clearRoute();
+        const entities = await this.loadProxyApiEntity(workbench_code, upstreamMap);
+        for (let i = 0; i < entities.length; i++) {
+            const entity = entities[i];
+            if (entity.status === 1) {
+                const path_prefix2 = '/' + entity.upstream_code + entity.path_prefix;
+                routeTrie.addRoute(path_prefix2, new RouteHandler_1.RouteHandler(entity));
+            }
+        }
+        return routeTrie;
+    }
+    async buildUpstreamMap() {
+        //       biz_tag={'upstream'}
+        const res = await this.curdProService.executeCrudByCfg({
+            condition: {
+                biz_tag: 'upstream',
+            },
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_configs,
+            sqlDatabase: SystemTables_1.SystemDbName,
+            sqlDdType: SystemTables_1.SystemDbType,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+        });
+        const upstreamMap = {};
+        const rows = res.getResRows();
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const { config_code, config_content } = row || {};
+            upstreamMap[config_code] = toUpstreamInfo(config_content);
+        }
+        return upstreamMap;
+    }
+    async loadProxyApiEntity(workbench_code, upstreamMap) {
+        const res = await this.curdProService.executeCrudByCfg({
+            condition: {},
+        }, {
+            sqlTable: SystemTables_1.SystemTables.sys_proxyapi,
+            sqlDatabase: SystemTables_1.SystemDbName,
+            sqlDdType: SystemTables_1.SystemDbType,
+            sqlSimpleName: keys_1.KeysOfSimpleSQL.SIMPLE_QUERY,
+        });
+        const rows0 = res.getResRows();
+        const rows = rows0.filter(s => {
+            if (!s.workbench_code_array) {
+                throw new exceptions_1.CommonException('IS_SUPPORT_CURRENT_WORKBENCH', '未配置支持的站点字段');
+            }
+            return this.workbenchService.isMatchWorkbenchCode(s.workbench_code_array, workbench_code);
+        });
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            const upstream_code = row.upstream_code;
+            this.addUpstreamInfo(row, upstream_code, upstreamMap);
+        }
+        return rows;
+    }
+    addUpstreamInfo(row, upstream_code, upstreamMap) {
+        const upstreamInfo = upstreamMap[upstream_code];
+        if (!upstreamInfo) {
+            return;
+        }
+        row.targetIndex = 0;
+        row.targetList = upstreamInfo.targetList || [];
+        row.balanceStrategy = upstreamInfo.balanceStrategy || ProxyApiUtils_1.BALANCE_STRATEGY.ROUND_ROBIN;
+        row.weightedRandom = new WeightedRandom_1.WeightedRandom(upstreamInfo.targetList || []);
+        row.weightedRoundRobin = new WeightedRoundRobin_1.WeightedRoundRobin(upstreamInfo.targetList || []);
+    }
+    async runBySchedule() {
+        const workbenchList = await this.workbenchService.getAllWorkbenchInfoList();
+        for (let i = 0; i < workbenchList.length; i++) {
+            const workbenchInfo = workbenchList[i];
+            try {
+                await this.buildRouteTrie(workbenchInfo.workbench_code);
+            }
+            catch (e) {
+                this.logError('ProxyApiLoadService_runBySchedule', e);
+            }
+        }
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], ProxyApiLoadService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], ProxyApiLoadService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", WorkbenchService_1.WorkbenchService)
+], ProxyApiLoadService.prototype, "workbenchService", void 0);
+ProxyApiLoadService = __decorate([
+    (0, core_1.Provide)()
+], ProxyApiLoadService);
+exports.ProxyApiLoadService = ProxyApiLoadService;

package/dist/service/proxyapi/ProxyApiService.d.ts

@@ -0,0 +1,60 @@
+import { Context } from '@midwayjs/koa';
+import { CurdProService } from '../curd/CurdProService';
+import { ProxyApiLoadService } from './ProxyApiLoadService';
+import { ApiBaseService } from '../base/ApiBaseService';
+/**
+ * 接口代理
+ */
+export declare class ProxyApiService extends ApiBaseService {
+    protected ctx: Context;
+    protected curdProService: CurdProService;
+    protected proxyApiLoadService: ProxyApiLoadService;
+    /**
+     * 转发请求
+     * @param current_workbench_code 当前站点
+     * @param upstream_path : 形如/[upstream_code]/[api_path]
+     */
+    handleProxyRequest(current_workbench_code: string, upstream_path: string): Promise<any>;
+    /**
+     * 转发请求
+     * @param proxyApiEntity
+     * @param upstream_path
+     * @private
+     */
+    private _handleProxyRequestForCfg;
+    /**
+     * 处理JSON响应
+     * @param response
+     * @param ctx
+     * @private
+     */
+    private handleResponseTypeJSON;
+    /**
+     * 处理stream响应
+     * @param response
+     * @param ctx
+     * @private
+     */
+    private handleResponseTypeStream;
+    /**
+     * 获取响应的headers数据
+     * @param headers
+     * @private
+     */
+    private toResHeaders;
+    /**
+     * 获取转发到目的服务器的路径
+     * @param upstream_path
+     * @param proxyApiEntity
+     * @private
+     */
+    private toNewPathByMapping;
+    /**
+     * 根据负载均衡策略，选择目标服务器
+     * @param proxyApiEntity
+     * @param ctx
+     * @private
+     */
+    private selectTargetByBalanceStrategy;
+    private setRequestHeaders;
+}

package/dist/service/proxyapi/ProxyApiService.js

@@ -0,0 +1,260 @@
+"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 });
+exports.ProxyApiService = void 0;
+const core_1 = require("@midwayjs/core");
+const _ = require("lodash");
+const RouteTrie_1 = require("./RouteTrie");
+const exceptions_1 = require("../../libs/crud-pro/exceptions");
+const devops_1 = require("../../models/devops");
+const CurdProService_1 = require("../curd/CurdProService");
+const axios_1 = require("axios");
+const fatcms_request_1 = require("../../libs/utils/fatcms-request");
+const ProxyApiUtils_1 = require("./ProxyApiUtils");
+const ProxyApiLoadService_1 = require("./ProxyApiLoadService");
+const ApiBaseService_1 = require("../base/ApiBaseService");
+/**
+ * 接口代理
+ */
+let ProxyApiService = class ProxyApiService extends ApiBaseService_1.ApiBaseService {
+    /**
+     * 转发请求
+     * @param current_workbench_code 当前站点
+     * @param upstream_path : 形如/[upstream_code]/[api_path]
+     */
+    async handleProxyRequest(current_workbench_code, upstream_path) {
+        const routeTrie = (0, RouteTrie_1.getRouteTrie)(current_workbench_code);
+        const ss = routeTrie.findLongestMatch(upstream_path);
+        if (!ss) {
+            throw new devops_1.BizException('路径没有匹配到', exceptions_1.Exceptions.CFG_NOT_FOUND);
+        }
+        const handler = _.get(ss, 'handler');
+        const cfgInfo = handler === null || handler === void 0 ? void 0 : handler.cfgInfo;
+        if (!cfgInfo) {
+            throw new devops_1.BizException('路径配置没有匹配到', exceptions_1.Exceptions.CFG_NOT_FOUND);
+        }
+        return this._handleProxyRequestForCfg(cfgInfo, upstream_path);
+    }
+    /**
+     * 转发请求
+     * @param proxyApiEntity
+     * @param upstream_path
+     * @private
+     */
+    async _handleProxyRequestForCfg(proxyApiEntity, upstream_path) {
+        await super.beforeCheckApiAccessibility(ApiBaseService_1.API_BASE_TYPE.PROXY_API, proxyApiEntity);
+        const targetList = proxyApiEntity.targetList;
+        if (!Array.isArray(targetList) || targetList.length === 0) {
+            throw new devops_1.BizException('目标服务器找不到', exceptions_1.Exceptions.CFG_NOT_FOUND);
+        }
+        const ctx = this.ctx;
+        const targetBaseUrl = this.selectTargetByBalanceStrategy(proxyApiEntity, ctx);
+        if (!targetBaseUrl) {
+            throw new devops_1.BizException('目标服务器找不到', exceptions_1.Exceptions.CFG_NOT_FOUND);
+        }
+        const newPath = this.toNewPathByMapping(upstream_path, proxyApiEntity);
+        const targetUrl = new URL(newPath, targetBaseUrl);
+        targetUrl.search = new URLSearchParams(ctx.query).toString();
+        // const response_type: ResponseType = (proxyApiEntity.response_type || 'stream') as any;
+        const response_type = 'stream';
+        try {
+            const headers = {
+                ...ctx.headers,
+                host: targetUrl.host,
+                'content-length': ctx.get('content-length'),
+            };
+            this.setRequestHeaders(headers, proxyApiEntity);
+            const response = await (0, axios_1.default)({
+                method: ctx.method,
+                url: targetUrl.toString(),
+                data: ctx.request.body,
+                headers: headers,
+                responseType: response_type,
+                timeout: proxyApiEntity.timeout_ms || 5 * 60 * 1000,
+                validateStatus: () => true,
+            });
+            ctx.status = response.status;
+            const resHeaders = this.toResHeaders(response.headers);
+            ctx.set({
+                ...resHeaders,
+                'cache-control': 'no-store',
+                'x-proxy-server': 'fatcms-server', // 添加代理标识
+            });
+            if (response_type === 'stream') {
+                return this.handleResponseTypeStream(response, ctx);
+            }
+            else if (response_type === 'json') {
+                return this.handleResponseTypeJSON(response, ctx);
+            }
+            else {
+                this.ctx.body = response.data;
+                return null;
+            }
+        }
+        catch (e) {
+            ctx.contextLogger.error('Proxy request failed ', e);
+            ctx.status = 500;
+            ctx.body = { success: false, message: 'Proxy request failed => ' + e.message };
+        }
+        return null;
+    }
+    /**
+     * 处理JSON响应
+     * @param response
+     * @param ctx
+     * @private
+     */
+    handleResponseTypeJSON(response, ctx) {
+        return Promise.resolve(response.data);
+    }
+    /**
+     * 处理stream响应
+     * @param response
+     * @param ctx
+     * @private
+     */
+    handleResponseTypeStream(response, ctx) {
+        // 流式传输处理
+        return new Promise((resolve, reject) => {
+            response.data
+                .on('data', chunk => {
+                ctx.res.write(chunk);
+            })
+                .on('end', () => {
+                ctx.res.end();
+                resolve();
+            })
+                .on('error', err => {
+                ctx.res.destroy(err);
+                reject(err);
+            });
+            // 处理客户端断开连接
+            ctx.req.on('close', () => {
+                response.data.destroy();
+                reject(new Error('Client disconnected'));
+            });
+        });
+    }
+    /**
+     * 获取响应的headers数据
+     * @param headers
+     * @private
+     */
+    toResHeaders(headers) {
+        if (!headers) {
+            return {};
+        }
+        if (typeof headers.toJSON === 'function') {
+            return headers.toJSON(false);
+        }
+        return headers;
+    }
+    /**
+     * 获取转发到目的服务器的路径
+     * @param upstream_path
+     * @param proxyApiEntity
+     * @private
+     */
+    toNewPathByMapping(upstream_path, proxyApiEntity) {
+        const result = upstream_path.substring(proxyApiEntity.upstream_code.length + 1);
+        this.logInfo('toNewPathByMapping', { upstream_path, result });
+        return result;
+    }
+    /**
+     * 根据负载均衡策略，选择目标服务器
+     * @param proxyApiEntity
+     * @param ctx
+     * @private
+     */
+    selectTargetByBalanceStrategy(proxyApiEntity, ctx) {
+        const targetList = proxyApiEntity.targetList;
+        const strategy = proxyApiEntity.balanceStrategy;
+        if ((0, fatcms_request_1.isEnableDebug)(ctx)) {
+            // 在调试模式下，可以强制指定某台机器。
+            const targetOrigin = (0, fatcms_request_1.getDebugProxyTarget)(ctx);
+            if (typeof targetOrigin === 'string' && targetOrigin.startsWith('http')) {
+                return targetOrigin;
+            }
+        }
+        if (!targetList || targetList.length === 0) {
+            return null;
+        }
+        if (strategy === ProxyApiUtils_1.BALANCE_STRATEGY.WEIGHTED_RANDOM) {
+            const weightedRandom = proxyApiEntity.weightedRandom;
+            const ss = weightedRandom.next();
+            return ss ? ss.origin : null;
+        }
+        else if (strategy === ProxyApiUtils_1.BALANCE_STRATEGY.WEIGHTED_ROUND_ROBIN) {
+            const weightedRoundRobin = proxyApiEntity.weightedRoundRobin;
+            const ss = weightedRoundRobin.next();
+            return ss ? ss.origin : null;
+        }
+        else if (strategy === ProxyApiUtils_1.BALANCE_STRATEGY.USER_SESSION_HASH) {
+            // 根据用户sessionId hash
+            const sessionId = ctx.userSession.getSessionValue('sessionId') || Math.random();
+            proxyApiEntity.targetIndex = (0, ProxyApiUtils_1.stringHashMod)(`${sessionId}`, targetList.length);
+        }
+        else if (strategy === ProxyApiUtils_1.BALANCE_STRATEGY.USER_ACCOUNT_HASH) {
+            // 根据用户accountId hash
+            const accountId = ctx.userSession.getSessionValue('accountId') || Math.random();
+            proxyApiEntity.targetIndex = (0, ProxyApiUtils_1.stringHashMod)(`${accountId}`, targetList.length);
+        }
+        else if (strategy === ProxyApiUtils_1.BALANCE_STRATEGY.IP_HASH) {
+            // 根据用户IP地址hash
+            const ip = ctx.headers['x-real-ip'] || ctx.headers['x-forwarded-for'] || Math.random();
+            proxyApiEntity.targetIndex = (0, ProxyApiUtils_1.stringHashMod)(`${ip}`, targetList.length);
+        }
+        else if (strategy === ProxyApiUtils_1.BALANCE_STRATEGY.RANDOM) {
+            // 随机
+            proxyApiEntity.targetIndex = (0, ProxyApiUtils_1.stringHashMod)(`${Math.random()}`, targetList.length);
+        }
+        else {
+            // 默认，轮训
+            proxyApiEntity.targetIndex = (proxyApiEntity.targetIndex + 1) % targetList.length;
+        }
+        const ss = targetList[proxyApiEntity.targetIndex];
+        return ss ? ss.origin : null;
+    }
+    setRequestHeaders(headers, proxyApiEntity) {
+        const ctx = this.ctx;
+        if (proxyApiEntity.pass_real_ip) {
+            headers['x-real-ip'] = ctx.headers['x-real-ip'];
+            headers['x-forwarded-for'] = ctx.headers['x-forwarded-for'];
+        }
+        if (proxyApiEntity.user_context) {
+            const isLogin = this.ctx.userSession.isLogin();
+            const sessionInfo = this.ctx.userSession.getSessionInfo();
+            headers['x-fatcms-user'] = JSON.stringify({ ...sessionInfo, isLogin });
+        }
+        if (proxyApiEntity.change_host && proxyApiEntity.change_host.length > 0) {
+            headers.host = proxyApiEntity.change_host;
+        }
+        if (proxyApiEntity.change_origin && proxyApiEntity.change_origin.length > 0) {
+            headers.origin = proxyApiEntity.change_origin;
+        }
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", Object)
+], ProxyApiService.prototype, "ctx", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", CurdProService_1.CurdProService)
+], ProxyApiService.prototype, "curdProService", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", ProxyApiLoadService_1.ProxyApiLoadService)
+], ProxyApiService.prototype, "proxyApiLoadService", void 0);
+ProxyApiService = __decorate([
+    (0, core_1.Provide)()
+], ProxyApiService);
+exports.ProxyApiService = ProxyApiService;

package/dist/service/proxyapi/ProxyApiUtils.d.ts

@@ -0,0 +1,15 @@
+export declare const BALANCE_STRATEGY: {
+    ROUND_ROBIN: string;
+    WEIGHTED_ROUND_ROBIN: string;
+    RANDOM: string;
+    WEIGHTED_RANDOM: string;
+    IP_HASH: string;
+    USER_ACCOUNT_HASH: string;
+    USER_SESSION_HASH: string;
+};
+/**
+ * 字符串Hash之后取模
+ * @param str
+ * @param mod
+ */
+export declare function stringHashMod(str: string, mod: number): number;

package/dist/service/proxyapi/ProxyApiUtils.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringHashMod = exports.BALANCE_STRATEGY = void 0;
+const md5 = require("md5");
+exports.BALANCE_STRATEGY = {
+    ROUND_ROBIN: 'ROUND_ROBIN',
+    WEIGHTED_ROUND_ROBIN: 'WEIGHTED_ROUND_ROBIN',
+    RANDOM: 'RANDOM',
+    WEIGHTED_RANDOM: 'WEIGHTED_RANDOM',
+    IP_HASH: 'IP_HASH',
+    USER_ACCOUNT_HASH: 'USER_ACCOUNT_HASH',
+    USER_SESSION_HASH: 'USER_SESSION_HASH', //  根据用户sessionId hash
+};
+/**
+ * 字符串Hash之后取模
+ * @param str
+ * @param mod
+ */
+function stringHashMod(str, mod) {
+    if (!str) {
+        throw new Error('stringHashMod str is required');
+    }
+    const md5Str = md5(str);
+    let sum = 0;
+    for (let i = 0; i < md5Str.length; i++) {
+        const md5StrElement = md5Str.charCodeAt(i);
+        sum = sum + md5StrElement;
+        if (sum >= Number.MAX_SAFE_INTEGER - 10000000) {
+            sum = sum % 10000000;
+        }
+    }
+    return sum % mod;
+}
+exports.stringHashMod = stringHashMod;

package/dist/service/proxyapi/RouteHandler.d.ts

@@ -0,0 +1,5 @@
+declare class RouteHandler {
+    cfgInfo: any;
+    constructor(cfgInfo: any);
+}
+export { RouteHandler };

package/dist/service/proxyapi/RouteHandler.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouteHandler = void 0;
+class RouteHandler {
+    constructor(cfgInfo) {
+        this.cfgInfo = cfgInfo;
+    }
+}
+exports.RouteHandler = RouteHandler;

package/dist/service/proxyapi/RouteTrie.d.ts

@@ -0,0 +1,12 @@
+import { RouteHandler } from './RouteHandler';
+declare class RouteTrie {
+    private root;
+    private routeCount;
+    constructor();
+    addRoute(path: string, handler: RouteHandler): void;
+    clearRoute(): void;
+    getRouteCount(): 0;
+    findLongestMatch(path: string): any;
+}
+declare function getRouteTrie(domainCode: string): RouteTrie;
+export { RouteTrie, getRouteTrie };

package/dist/service/proxyapi/RouteTrie.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRouteTrie = exports.RouteTrie = void 0;
+class RouteTrieNode {
+    constructor() {
+        this.children = {}; // 子节点字典
+        this.handler = null; // 路由处理程序
+        this.path = ''; // 完整路由路径
+    }
+}
+class RouteTrie {
+    constructor() {
+        this.root = new RouteTrieNode();
+        this.routeCount = 0;
+    }
+    addRoute(path, handler) {
+        const parts = path.split('/').slice(1); // 去除首部空字符串
+        let node = this.root;
+        parts.forEach(part => {
+            if (!node.children[part]) {
+                node.children[part] = new RouteTrieNode();
+            }
+            node = node.children[part];
+        });
+        // 保存路由处理函数到终点节点
+        node.handler = handler;
+        node.path = path;
+        this.routeCount++;
+    }
+    clearRoute() {
+        this.routeCount = 0;
+        this.root = new RouteTrieNode();
+    }
+    getRouteCount() {
+        return this.routeCount;
+    }
+    findLongestMatch(path) {
+        const parts = path.split('/').slice(1);
+        let node = this.root;
+        let bestMatch = null;
+        parts.forEach(part => {
+            if (node.children[part]) {
+                node = node.children[part];
+                if (node.handler) {
+                    bestMatch = {
+                        path: node.path,
+                        handler: node.handler,
+                    };
+                }
+            }
+        });
+        return bestMatch;
+    }
+}
+exports.RouteTrie = RouteTrie;
+const ROUTE_TRIE_MANAGER = {};
+function getRouteTrie(domainCode) {
+    if (!ROUTE_TRIE_MANAGER[domainCode]) {
+        ROUTE_TRIE_MANAGER[domainCode] = new RouteTrie();
+    }
+    return ROUTE_TRIE_MANAGER[domainCode];
+}
+exports.getRouteTrie = getRouteTrie;

package/dist/service/proxyapi/WeightedRandom.d.ts

@@ -0,0 +1,9 @@
+import { IUpstreamItem } from '../../models/SystemEntities';
+declare class WeightedRandom {
+    private readonly items;
+    private readonly totalWeight;
+    private readonly cumulativeWeights;
+    constructor(items: IUpstreamItem[]);
+    next(): IUpstreamItem;
+}
+export { WeightedRandom };

package/dist/service/proxyapi/WeightedRandom.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WeightedRandom = void 0;
+class WeightedRandom {
+    constructor(items) {
+        // 预处理累积权重
+        this.cumulativeWeights = [];
+        let runningTotal = 0;
+        for (const item of items) {
+            if (typeof item.weight !== 'number' || item.weight <= 0) {
+                throw new Error('All items must have positive weight');
+            }
+            runningTotal += item.weight;
+            this.cumulativeWeights.push(runningTotal);
+        }
+        this.totalWeight = runningTotal;
+        this.items = items;
+    }
+    next() {
+        // 生成[0, totalWeight)区间的随机数
+        const random = Math.random() * this.totalWeight;
+        // 线性查找命中区间
+        for (let i = 0; i < this.cumulativeWeights.length; i++) {
+            if (random < this.cumulativeWeights[i]) {
+                return this.items[i];
+            }
+        }
+        return this.items[0]; // 兜底返回第一个元素
+    }
+}
+exports.WeightedRandom = WeightedRandom;

package/dist/service/proxyapi/WeightedRoundRobin.d.ts

@@ -0,0 +1,8 @@
+import { IUpstreamItem } from '../../models/SystemEntities';
+declare class WeightedRoundRobin {
+    private readonly totalWeight;
+    private servers;
+    constructor(servers: IUpstreamItem[]);
+    next(): IUpstreamItem;
+}
+export { WeightedRoundRobin };