487 lines
15 KiB
TypeScript
487 lines
15 KiB
TypeScript
import * as http from "http";
|
||
import * as https from "https";
|
||
import * as fs from "fs";
|
||
import * as path from "path";
|
||
import * as zlib from "zlib";
|
||
|
||
// 配置文件路径
|
||
const CONFIG_FILE = path.join(__dirname, "config.json");
|
||
|
||
// 定义类型
|
||
interface RouteConfig {
|
||
[route: string]: string;
|
||
}
|
||
|
||
interface AppConfig {
|
||
/** 为 false 时所有请求走代理，不命中 mock 路由；缺省为 true */
|
||
mockEnabled?: boolean;
|
||
cacheConfig: boolean;
|
||
reloadOnChange: boolean;
|
||
defaultContentType: string;
|
||
proxyPort: number;
|
||
targetHost: string;
|
||
/** 代理转发的目标 HTTPS 端口；缺省 443 */
|
||
targetPort?: number;
|
||
}
|
||
|
||
interface ConfigFile {
|
||
routes: RouteConfig;
|
||
config: AppConfig;
|
||
}
|
||
|
||
// 存储当前的路由配置
|
||
let MOCK_ROUTES: RouteConfig = {};
|
||
let CONFIG: AppConfig = {
|
||
cacheConfig: true,
|
||
reloadOnChange: true,
|
||
defaultContentType: "application/json",
|
||
proxyPort: 443,
|
||
targetHost: "localhost",
|
||
targetPort: 443,
|
||
};
|
||
|
||
// 过滤掉以 # 开头的路由（视为注释，不参与 mock）
|
||
function filterActiveRoutes(routes: RouteConfig): RouteConfig {
|
||
const filtered: RouteConfig = {};
|
||
for (const [route, filePath] of Object.entries(routes)) {
|
||
if (route.startsWith("#")) continue;
|
||
filtered[route] = filePath;
|
||
}
|
||
return filtered;
|
||
}
|
||
|
||
// 加载配置文件
|
||
function loadConfig() {
|
||
try {
|
||
if (!fs.existsSync(CONFIG_FILE)) {
|
||
console.warn(`[CONFIG] 配置文件不存在: ${CONFIG_FILE}`);
|
||
console.warn(`[CONFIG] 正在创建默认配置文件...`);
|
||
|
||
// 创建默认配置
|
||
const defaultConfig: ConfigFile = {
|
||
routes: {
|
||
"/api2/test": "mock/test.txt",
|
||
},
|
||
config: {
|
||
cacheConfig: true,
|
||
reloadOnChange: true,
|
||
defaultContentType: "application/json",
|
||
proxyPort: 443,
|
||
targetHost: "localhost",
|
||
targetPort: 443,
|
||
},
|
||
};
|
||
|
||
// 确保mock目录存在
|
||
const mockDir = path.join(__dirname, "mock");
|
||
if (!fs.existsSync(mockDir)) {
|
||
fs.mkdirSync(mockDir, { recursive: true });
|
||
}
|
||
|
||
// 保存配置文件
|
||
fs.writeFileSync(
|
||
CONFIG_FILE,
|
||
JSON.stringify(defaultConfig, null, 2),
|
||
"utf-8",
|
||
);
|
||
console.log(`[CONFIG] 已创建默认配置文件: ${CONFIG_FILE}`);
|
||
|
||
// 加载配置（# 开头的路由视为注释，不参与 mock）
|
||
const configData: ConfigFile = JSON.parse(
|
||
fs.readFileSync(CONFIG_FILE, "utf-8"),
|
||
);
|
||
MOCK_ROUTES = filterActiveRoutes(configData.routes || {});
|
||
CONFIG = configData.config || CONFIG;
|
||
} else {
|
||
const configData: ConfigFile = JSON.parse(
|
||
fs.readFileSync(CONFIG_FILE, "utf-8"),
|
||
);
|
||
MOCK_ROUTES = filterActiveRoutes(configData.routes || {});
|
||
CONFIG = configData.config || CONFIG;
|
||
console.log(
|
||
`[CONFIG] 配置文件已加载，共 ${Object.keys(MOCK_ROUTES).length} 个路由${CONFIG.mockEnabled !== false ? "" : "（mock 已关闭，全部走代理）"}`,
|
||
);
|
||
}
|
||
|
||
// 验证mock文件是否存在
|
||
validateMockFiles();
|
||
} catch (error) {
|
||
console.error(`[CONFIG] 加载配置文件失败:`, error);
|
||
// 使用默认配置
|
||
MOCK_ROUTES = {
|
||
"/api2/user/list": "mock/user_list.txt",
|
||
};
|
||
CONFIG = {
|
||
cacheConfig: true,
|
||
reloadOnChange: true,
|
||
defaultContentType: "application/json",
|
||
proxyPort: 9443,
|
||
targetHost: "devrmtapp.resmart.cn",
|
||
targetPort: 443,
|
||
};
|
||
}
|
||
}
|
||
|
||
// 验证mock文件是否存在
|
||
function validateMockFiles() {
|
||
console.log(`[CONFIG] 验证mock文件...`);
|
||
let missingFiles: Array<{
|
||
route: string;
|
||
filePath: string;
|
||
fullPath: string;
|
||
}> = [];
|
||
|
||
for (const [route, filePath] of Object.entries(MOCK_ROUTES)) {
|
||
const fullPath = path.join(__dirname, filePath);
|
||
if (!fs.existsSync(fullPath)) {
|
||
missingFiles.push({ route, filePath, fullPath });
|
||
console.warn(
|
||
`[CONFIG] 警告: mock文件不存在 - ${filePath} (用于路由: ${route})`,
|
||
);
|
||
}
|
||
}
|
||
|
||
if (missingFiles.length > 0) {
|
||
console.log(
|
||
`[CONFIG] 缺少 ${missingFiles.length} 个mock文件，请创建这些文件`,
|
||
);
|
||
} else {
|
||
console.log(`[CONFIG] 所有mock文件验证通过`);
|
||
}
|
||
}
|
||
|
||
// 检查是否为mock路由的函数
|
||
function isMockRoute(requestPath: string): boolean {
|
||
if (CONFIG.mockEnabled === false) return false;
|
||
return MOCK_ROUTES.hasOwnProperty(requestPath);
|
||
}
|
||
|
||
// 获取mock文件路径
|
||
function getMockFilePath(requestPath: string): string {
|
||
return MOCK_ROUTES[requestPath];
|
||
}
|
||
|
||
function decodeBodyByEncoding(
|
||
bodyBuffer: Buffer,
|
||
contentEncoding?: string,
|
||
): Buffer {
|
||
const encoding = (contentEncoding || "").toLowerCase().trim();
|
||
try {
|
||
if (encoding.includes("gzip")) {
|
||
return zlib.gunzipSync(bodyBuffer);
|
||
}
|
||
if (encoding.includes("br")) {
|
||
return zlib.brotliDecompressSync(bodyBuffer);
|
||
}
|
||
if (encoding.includes("deflate")) {
|
||
return zlib.inflateSync(bodyBuffer);
|
||
}
|
||
} catch (error) {
|
||
console.warn("[MOCK] 解压上游响应失败，按原始内容写入文件", error);
|
||
}
|
||
return bodyBuffer;
|
||
}
|
||
|
||
// 代理服务器
|
||
const proxyServer = http.createServer((clientReq, clientRes) => {
|
||
// 解析客户端请求的 URL
|
||
const parsedUrl = new URL(`http://localhost${clientReq.url!}`);
|
||
const requestPath = parsedUrl.pathname;
|
||
|
||
// 管理接口：保留路径，不参与代理转发
|
||
if (requestPath === "/__reload-config") {
|
||
if (clientReq.method !== "POST") {
|
||
clientRes.writeHead(405, {
|
||
"Content-Type": "application/json",
|
||
Allow: "POST",
|
||
});
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
success: false,
|
||
error: "Method Not Allowed",
|
||
allow: ["POST"],
|
||
}),
|
||
);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const oldCount = Object.keys(MOCK_ROUTES).length;
|
||
loadConfig();
|
||
const newCount = Object.keys(MOCK_ROUTES).length;
|
||
|
||
clientRes.writeHead(200, { "Content-Type": "application/json" });
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
success: true,
|
||
message: "Configuration reloaded successfully",
|
||
routesCount: newCount,
|
||
routesChanged: newCount - oldCount,
|
||
}),
|
||
);
|
||
console.log(
|
||
`[ADMIN] 通过API重新加载配置 (路由数: ${oldCount} -> ${newCount})`,
|
||
);
|
||
} catch (error) {
|
||
clientRes.writeHead(500, { "Content-Type": "application/json" });
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
success: false,
|
||
error: (error as Error).message,
|
||
}),
|
||
);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (requestPath === "/__config") {
|
||
if (clientReq.method !== "GET") {
|
||
clientRes.writeHead(405, {
|
||
"Content-Type": "application/json",
|
||
Allow: "GET",
|
||
});
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
success: false,
|
||
error: "Method Not Allowed",
|
||
allow: ["GET"],
|
||
}),
|
||
);
|
||
return;
|
||
}
|
||
|
||
try {
|
||
clientRes.writeHead(200, { "Content-Type": "application/json" });
|
||
clientRes.end(
|
||
JSON.stringify(
|
||
{
|
||
routes: MOCK_ROUTES,
|
||
config: CONFIG,
|
||
timestamp: new Date().toISOString(),
|
||
totalRoutes: Object.keys(MOCK_ROUTES).length,
|
||
},
|
||
null,
|
||
2,
|
||
),
|
||
);
|
||
} catch (error) {
|
||
clientRes.writeHead(500, { "Content-Type": "application/json" });
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
success: false,
|
||
error: (error as Error).message,
|
||
}),
|
||
);
|
||
}
|
||
return;
|
||
}
|
||
|
||
// 检查是否为需要mock的路由
|
||
if (isMockRoute(requestPath)) {
|
||
const mockFile = getMockFilePath(requestPath);
|
||
console.log(`[MOCK] 拦截路由: ${requestPath} -> 使用文件: ${mockFile}`);
|
||
|
||
try {
|
||
// 构建完整的文件路径
|
||
const mockFilePath = path.join(__dirname, mockFile);
|
||
|
||
// 检查文件是否存在
|
||
if (!fs.existsSync(mockFilePath)) {
|
||
console.warn(`[MOCK] Mock文件不存在，回源并自动生成: ${mockFilePath}`);
|
||
|
||
const targetPort = CONFIG.targetPort ?? 443;
|
||
const options: http.RequestOptions = {
|
||
hostname: CONFIG.targetHost,
|
||
port: targetPort,
|
||
method: clientReq.method,
|
||
path: parsedUrl.pathname + parsedUrl.search,
|
||
headers: {
|
||
...clientReq.headers,
|
||
host: CONFIG.targetHost,
|
||
},
|
||
};
|
||
|
||
const proxyReq = https.request(options, (proxyRes) => {
|
||
const chunks: Buffer[] = [];
|
||
proxyRes.on("data", (chunk: Buffer) => {
|
||
chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
|
||
});
|
||
|
||
proxyRes.on("end", () => {
|
||
const bodyBuffer = Buffer.concat(chunks);
|
||
|
||
try {
|
||
const decodedBuffer = decodeBodyByEncoding(
|
||
bodyBuffer,
|
||
Array.isArray(proxyRes.headers["content-encoding"])
|
||
? proxyRes.headers["content-encoding"][0]
|
||
: proxyRes.headers["content-encoding"],
|
||
);
|
||
const contentType = String(proxyRes.headers["content-type"] || "");
|
||
const toWrite =
|
||
contentType.includes("application/json") ||
|
||
contentType.includes("text/") ||
|
||
contentType.includes("application/xml") ||
|
||
contentType.includes("application/javascript")
|
||
? decodedBuffer.toString("utf-8")
|
||
: decodedBuffer;
|
||
fs.mkdirSync(path.dirname(mockFilePath), { recursive: true });
|
||
fs.writeFileSync(mockFilePath, toWrite);
|
||
console.log(`[MOCK] 已自动写入mock文件: ${mockFilePath}`);
|
||
} catch (writeErr) {
|
||
console.error(`[MOCK] 自动写入mock文件失败: ${mockFilePath}`, writeErr);
|
||
}
|
||
|
||
clientRes.writeHead(proxyRes.statusCode || 200, {
|
||
...proxyRes.headers,
|
||
"X-Mock-Autogenerated": "true",
|
||
"X-Mock-Source": mockFile,
|
||
});
|
||
clientRes.end(bodyBuffer);
|
||
});
|
||
});
|
||
|
||
proxyReq.on("error", (err) => {
|
||
console.error("Proxy request error:", err);
|
||
clientRes.writeHead(500, { "Content-Type": "application/json" });
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
error: "Proxy error",
|
||
route: requestPath,
|
||
file: mockFile,
|
||
message: err.message,
|
||
timestamp: new Date().toISOString(),
|
||
}),
|
||
);
|
||
});
|
||
|
||
clientReq.pipe(proxyReq);
|
||
return;
|
||
}
|
||
|
||
// 读取本地mock文件
|
||
const mockData = fs.readFileSync(mockFilePath, "utf-8");
|
||
|
||
// 设置响应头
|
||
const contentType = CONFIG.defaultContentType || "application/json";
|
||
clientRes.writeHead(200, {
|
||
"Content-Type": contentType,
|
||
"Access-Control-Allow-Origin": "*",
|
||
"Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
|
||
"Access-Control-Allow-Headers": "Content-Type",
|
||
"X-Mock-Source": mockFile,
|
||
"X-Mock-Timestamp": new Date().toISOString(),
|
||
});
|
||
|
||
// 返回mock数据
|
||
clientRes.end(mockData);
|
||
console.log(`[MOCK] 成功返回mock数据: ${mockFile}`);
|
||
} catch (error) {
|
||
console.error(`[MOCK] 读取mock文件失败: ${mockFile}`, error);
|
||
clientRes.writeHead(500, { "Content-Type": "application/json" });
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
error: "Failed to read mock data",
|
||
route: requestPath,
|
||
file: mockFile,
|
||
message: (error as Error).message,
|
||
timestamp: new Date().toISOString(),
|
||
}),
|
||
);
|
||
}
|
||
return; // 直接返回，不转发到目标服务器
|
||
}
|
||
|
||
// 如果不是mock路由，正常代理转发
|
||
console.log(`[PROXY] 转发请求: ${requestPath}`);
|
||
|
||
const targetPort = CONFIG.targetPort ?? 443;
|
||
|
||
// 目标服务器的选项
|
||
const options: http.RequestOptions = {
|
||
hostname: CONFIG.targetHost,
|
||
port: targetPort,
|
||
method: clientReq.method,
|
||
path: parsedUrl.pathname + parsedUrl.search,
|
||
headers: {
|
||
...clientReq.headers,
|
||
host: CONFIG.targetHost,
|
||
},
|
||
};
|
||
|
||
// 创建到目标服务器的 HTTPS 请求
|
||
const proxyReq = https.request(options, (proxyRes) => {
|
||
// 将目标服务器的响应头复制到客户端响应
|
||
clientRes.writeHead(proxyRes.statusCode!, proxyRes.headers);
|
||
// 将目标服务器的响应数据管道传输到客户端
|
||
proxyRes.pipe(clientRes);
|
||
});
|
||
|
||
// 错误处理
|
||
proxyReq.on("error", (err) => {
|
||
console.error("Proxy request error:", err);
|
||
clientRes.writeHead(500, { "Content-Type": "application/json" });
|
||
clientRes.end(
|
||
JSON.stringify({
|
||
error: "Proxy error",
|
||
message: err.message,
|
||
timestamp: new Date().toISOString(),
|
||
}),
|
||
);
|
||
});
|
||
|
||
// 将客户端请求体管道传输到代理请求
|
||
clientReq.pipe(proxyReq);
|
||
});
|
||
|
||
// 初始化：第一次加载配置
|
||
loadConfig();
|
||
|
||
// 如果配置了文件监视，则监听配置文件变化
|
||
if (CONFIG.reloadOnChange) {
|
||
fs.watchFile(CONFIG_FILE, (curr, prev) => {
|
||
console.log(`[CONFIG] 配置文件已修改，重新加载...`);
|
||
try {
|
||
const oldRoutesCount = Object.keys(MOCK_ROUTES).length;
|
||
loadConfig();
|
||
const newRoutesCount = Object.keys(MOCK_ROUTES).length;
|
||
console.log(
|
||
`[CONFIG] 配置重载完成 (路由数: ${oldRoutesCount} -> ${newRoutesCount})`,
|
||
);
|
||
} catch (error) {
|
||
console.error(`[CONFIG] 重新加载配置文件失败:`, error);
|
||
}
|
||
});
|
||
console.log(`[CONFIG] 已启用配置文件监视: ${CONFIG_FILE}`);
|
||
}
|
||
|
||
proxyServer.listen(CONFIG.proxyPort, "0.0.0.0", () => {
|
||
const targetPort = CONFIG.targetPort ?? 443;
|
||
console.log(`========================================`);
|
||
console.log(`代理服务器运行在: http://localhost:${CONFIG.proxyPort}`);
|
||
console.log(
|
||
`目标服务器: https://${CONFIG.targetHost}${targetPort !== 443 ? `:${targetPort}` : ""}`,
|
||
);
|
||
console.log(`配置文件: ${CONFIG_FILE}`);
|
||
console.log(
|
||
`已配置Mock路由: ${Object.keys(MOCK_ROUTES).length} 个${CONFIG.mockEnabled !== false ? "" : "（当前 mockEnabled=false，未生效）"}`,
|
||
);
|
||
console.log(`========================================`);
|
||
console.log(`管理接口:`);
|
||
console.log(
|
||
` GET http://localhost:${CONFIG.proxyPort}/__config 查看当前配置`,
|
||
);
|
||
console.log(
|
||
` POST http://localhost:${CONFIG.proxyPort}/__reload-config 重新加载配置`,
|
||
);
|
||
console.log(`========================================`);
|
||
console.log(`Mock路由列表:`);
|
||
|
||
for (const [route, file] of Object.entries(MOCK_ROUTES)) {
|
||
const filePath = path.join(__dirname, file);
|
||
const exists = fs.existsSync(filePath) ? "✓" : "✗";
|
||
console.log(` ${exists} ${route} -> ${file}`);
|
||
}
|
||
console.log(`========================================`);
|
||
});
|