env-plugin 0.5.6

package/dist/controllers/RouteRuleController.js

@@ -0,0 +1,106 @@
+import { envLogger } from "../utils/logger.js";
+/**
+ * 路由规则控制器
+ * 负责处理与路由规则相关的HTTP请求，作为请求入口层：
+ * - 解析并验证请求参数
+ * - 调用对应的服务层方法处理业务逻辑
+ * - 格式化并返回响应结果
+ * - 统一错误处理
+ */
+class RouteRuleController {
+    /**
+     * 构造函数 - 注入路由规则服务实例
+     * @param private readonly routeRuleService - 路由规则服务实例，处理核心业务逻辑
+     */
+    constructor(routeRuleService) {
+        this.routeRuleService = routeRuleService;
+    }
+    /**
+     * 获取指定环境的路由规则列表
+     * @description 处理查询指定环境所有路由规则的GET请求
+     * @param req - Express请求对象，包含环境ID（在params中）
+     * @param res - Express响应对象，用于返回路由规则列表
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleGetList(req, res, next) {
+        try {
+            const envId = req.params.envId;
+            envLogger.info({ envId }, "接收路由规则列表查询请求");
+            // 调用服务层获取数据
+            const list = this.routeRuleService.handleGetByEnvId(envId);
+            // 返回成功响应（包含列表数据）
+            res.success({ list, total: list.length });
+        }
+        catch (error) {
+            envLogger.error(error, "路由规则列表查询请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 新增路由规则
+     * @description 处理创建新路由规则的POST请求
+     * @param req - Express请求对象，包含待创建的路由规则数据（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleAdd(req, res, next) {
+        try {
+            // 验证请求数据
+            const routeRuleData = req.dto;
+            envLogger.info({ routeRuleData }, "接收新增路由规则请求");
+            // 调用服务层处理业务
+            const newRule = this.routeRuleService.handleAdd(routeRuleData);
+            // 返回成功响应
+            res.success({ message: "路由规则添加成功", data: newRule });
+        }
+        catch (error) {
+            envLogger.error(error, "新增路由规则请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 更新路由规则
+     * @description 处理更新路由规则的POST/PUT请求
+     * @param req - Express请求对象，包含待更新的路由规则数据（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleUpdate(req, res, next) {
+        try {
+            // 验证请求数据
+            const routeRuleData = req.dto;
+            envLogger.info({ routeRuleData }, "接收更新路由规则请求");
+            // 调用服务层处理业务
+            const updatedRule = this.routeRuleService.handleUpdate(routeRuleData);
+            // 返回成功响应
+            res.success({ message: "路由规则更新成功", data: updatedRule });
+        }
+        catch (error) {
+            envLogger.error(error, "更新路由规则请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 删除路由规则
+     * @description 处理删除路由规则的POST/DELETE请求
+     * @param req - Express请求对象，包含待删除路由规则的ID（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleDelete(req, res, next) {
+        try {
+            // 验证请求数据
+            const routeRuleData = req.dto;
+            envLogger.info({ routeRuleData }, "接收删除路由规则请求");
+            // 调用服务层处理业务
+            this.routeRuleService.handleDelete(routeRuleData);
+            // 返回成功响应
+            res.success({ message: "路由规则删除成功" });
+        }
+        catch (error) {
+            envLogger.error(error, "删除路由规则请求处理失败");
+            next(error);
+        }
+    }
+}
+export { RouteRuleController };

package/dist/dto/BaseRes.js

@@ -0,0 +1 @@
+export {};

package/dist/dto/EnvDTO.js

@@ -0,0 +1,4 @@
+export class EnvDTO {
+    constructor() {
+    }
+}

package/dist/index.js

@@ -0,0 +1,108 @@
+import portfinder from "portfinder";
+import http from "http";
+import PostProxyServer from "./PostProxyServer.js";
+import { getConfig, loadConfig } from "./utils/ResolveConfig.js";
+import { startDatabase } from "./repositories/database.js";
+import { initLoggers, logger } from "./utils/logger.js";
+class EnvManage {
+    get config() {
+        return getConfig();
+    }
+    constructor(options = {}) {
+        try {
+            loadConfig(options);
+            initLoggers(this.config.logLevel);
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error("❌ 配置加载失败，服务启动失败，", error.message);
+            }
+            process.exit(1);
+        }
+    }
+    async startIndependent() {
+        logger.info(this.config, "Starting EnvManage...");
+        // 检查端口是否被占用
+        try {
+            await this.checkPortAsync();
+            logger.info(`端口 ${this.config.port} 可用，启动服务...`);
+            await startDatabase();
+            new PostProxyServer();
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                logger.error(error, "启动失败");
+            }
+            process.exit(1);
+        }
+    }
+    /**
+     * 判断端口是否被占用，如果被占用的，查询是否已经启动
+     * @returns
+     */
+    async checkPortAsync() {
+        const result = await this.isPortOccupied(this.config.port);
+        if (result) {
+            try {
+                await this.checkIsRunning();
+            }
+            catch (error) {
+                logger.error(error, "端口被占用，且不是 envm 服务");
+            }
+            throw new Error(`envm 服务已经在端口 ${this.config.port} 启动，请勿重复启动！`);
+        }
+    }
+    /**
+     *
+     * @param port 查询端口是否被占用
+     * @returns
+     */
+    isPortOccupied(port) {
+        return portfinder
+            .getPortPromise({
+            port: port,
+            stopPort: port,
+        })
+            .then(() => {
+            return false;
+        })
+            .catch(() => {
+            return true;
+        });
+    }
+    /**
+     * 查询端口，中启动的服务是否为 envm
+     * @returns
+     */
+    checkIsRunning() {
+        const options = {
+            hostname: "127.0.0.1",
+            port: this.config.port,
+            path: `${this.config.apiPrefix}/are-you-ok`,
+            method: "GET",
+        };
+        return new Promise((resolve, reject) => {
+            const req = http.request(options, (res) => {
+                const statusCode = res.statusCode || 0;
+                if (statusCode < 200 || statusCode >= 300) {
+                    reject(new Error(`请求失败，状态码: ${res.statusCode}`));
+                    return;
+                }
+                let responseData = "";
+                res.on("data", (chunk) => {
+                    responseData += chunk;
+                });
+                res.on("end", () => {
+                    const result = JSON.parse(responseData);
+                    logger.info(result, "收到已启动的代理服务返回的消息");
+                    resolve(result);
+                });
+            });
+            req.on("error", (error) => {
+                reject(error);
+            });
+            req.end();
+        });
+    }
+}
+export { EnvManage };

package/dist/middleware/dto.middleware.js

@@ -0,0 +1,38 @@
+import { ZodError } from "zod";
+/**
+ * 类型安全的DTO转换中间件
+ * 将接入参转换为对应的DTO
+ */
+export const toDTO = (schema, source = "body") => {
+    return (req, res, next) => {
+        try {
+            // 从指定来源提取原始数据
+            const rawData = req[source];
+            // 校验并转换数据（ZodType确保类型安全）
+            const validatedData = schema.parse(rawData);
+            // 将转换后的DTO挂载到req对象
+            req.dto = validatedData;
+            next();
+        }
+        catch (err) {
+            // 严格判断Zod错误类型（无any）
+            if (err instanceof ZodError) {
+                // 格式化Zod错误信息
+                const errors = err.issues.map((issue) => ({
+                    field: issue.path.join("."),
+                    message: issue.message,
+                }));
+                return res.status(400).json({
+                    code: 400,
+                    message: errors[0].message || "参数校验失败",
+                    errors,
+                });
+            }
+            // 处理其他未知错误
+            res.status(500).json({
+                code: 500,
+                message: "服务器内部错误",
+            });
+        }
+    };
+};

package/dist/middleware/globalErrorHandler.js

@@ -0,0 +1,42 @@
+import { AppError } from "../utils/errors.js";
+/**
+ * 全局错误处理中间件
+ *
+ * 统一捕获并处理应用中抛出的所有错误（包括自定义错误和系统错误），
+ * 通过响应增强器提供的 res.error() 方法返回标准化错误响应。
+ *
+ * @param {Error} err - 捕获到的错误对象，可能是自定义错误或系统原生错误
+ * @param {Request} req - Express 请求对象
+ * @param {Response} res - Express 响应对象（已通过 responseEnhancer 增强，包含 error 方法）
+ * @returns {void} 无返回值，直接通过 res.error() 发送响应
+ *
+ * @example
+ * // 在 Express 应用中注册
+ * app.use(globalErrorHandler);
+ *
+ * @example
+ * // 抛出错误时会被此中间件捕获
+ * throw new AppError('资源未找到', 404, 10001);
+ */
+export const globalErrorHandler = (err, req, res, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+next) => {
+    // 初始化响应信息
+    let code;
+    let message;
+    let status = 0;
+    // 处理自定义错误（业务已知错误）
+    if (err instanceof AppError) {
+        code = err.code;
+        message = err.message;
+        status = err.status;
+    }
+    else {
+        // 处理系统错误（如TypeError、ReferenceError等未知错误）
+        console.error("系统错误详情:", err); // 记录详细错误日志用于排查
+        code = 500; // 业务状态码：服务器内部错误
+        message = "服务器内部错误"; // 对用户展示的友好信息（避免暴露敏感信息）
+    }
+    // 使用增强的响应方法发送标准化错误响应
+    res.error(message, code, { status });
+};

package/dist/middleware/responseEnhancer.js

@@ -0,0 +1,52 @@
+/**
+ * 响应增强中间件
+ *
+ * 为 Express 的 Response 对象添加统一格式的 success 和 error 响应方法，
+ * 确保 API 返回数据结构一致，包含状态码、消息、数据和时间戳。
+ *
+ * @param {Request} req - Express 请求对象
+ * @param {Response} res - Express 响应对象
+ * @param {NextFunction} next - Express 下一步中间件函数
+ * @returns {void}
+ */
+export const responseEnhancer = (req, res, next) => {
+    /**
+     * 发送成功响应
+     *
+     * @template T - 响应数据的类型
+     * @param {T} [data] - 成功响应的数据 payload，可为任意类型
+     * @param {string} [message="操作成功"] - 成功提示消息
+     * @param {number} [code=200] - HTTP 状态码，默认 200
+     * @returns {Response} Express 响应对象，支持链式调用
+     * @example
+     * res.success({ id: 1, name: '示例' }, '获取成功', 200);
+     */
+    res.success = function (data, message = "操作成功", code = 200) {
+        return res.status(code).json({
+            code,
+            message,
+            data,
+            timestamp: Date.now(),
+        });
+    };
+    /**
+     * 发送错误响应
+     *
+     * @template T - 错误附加数据的类型
+     * @param {string} [message="操作失败"] - 错误提示消息
+     * @param {number} [code=500] - HTTP 状态码，默认 500
+     * @param {T} [data] - 错误相关的附加数据，可为任意类型
+     * @returns {Response} Express 响应对象，支持链式调用
+     * @example
+     * res.error('参数错误', 400, { invalidFields: ['name'] });
+     */
+    res.error = function (message = "操作失败", code = 500, data) {
+        return res.status(code).json({
+            code,
+            message,
+            data,
+            timestamp: Date.now(),
+        });
+    };
+    next();
+};

package/dist/models/DevServerModel.js

@@ -0,0 +1 @@
+export {};

package/dist/models/EnvModel.js

@@ -0,0 +1,14 @@
+import { v4 as uuidv4 } from "uuid";
+class EnvItemModel {
+    constructor(envItem) {
+        this.status = "stopped";
+        this.id = uuidv4();
+        this.name = envItem.name ?? "";
+        this.description = envItem.description ?? "";
+        this.port = envItem.port ?? "";
+        this.apiBaseUrl = envItem.apiBaseUrl ?? "";
+        this.homePage = envItem.homePage ?? "";
+        this.devServerId = envItem.devServerId ?? "";
+    }
+}
+export { EnvItemModel };

package/dist/repositories/DevServerRepo.js

@@ -0,0 +1,101 @@
+import { getDatabase } from "./database.js";
+import { DevServerDeleteSchema, DevServerUpdateSchema, DevServerQuerySchema, DevServerModelSchema, } from "../types/index.js";
+import { AppError } from "../utils/errors.js";
+/**
+ * 开发服务器仓库类
+ * 负责开发服务器相关数据的持久化操作，封装数据库交互逻辑
+ */
+class DevServerRepo {
+    /**
+     * 获取开发服务器数据集合
+     * @returns 开发服务器数据集合对象
+     */
+    getCollection() {
+        return getDatabase().getCollection("devServer");
+    }
+    /**
+     * 获取所有开发服务器信息
+     * @returns 所有开发服务器信息的数组
+     */
+    getAll() {
+        return this.getCollection().find();
+    }
+    /**
+     * 添加新的开发服务器
+     * @param devServer - 要添加的开发服务器信息（不含ID）
+     * @throws {AppError} 当验证失败时抛出错误
+     */
+    addDevServer(devServer) {
+        // 验证输入数据
+        const validationResult = DevServerModelSchema.safeParse(devServer);
+        if (!validationResult.success) {
+            throw new AppError(`添加开发服务器失败：参数验证错误 - ${JSON.stringify(validationResult.error.issues)}`);
+        }
+        this.getCollection().insert(validationResult.data);
+    }
+    /**
+     * 根据ID删除开发服务器
+     * @param devServer - 包含要删除的开发服务器ID的对象
+     * @throws {AppError} 当验证失败或服务器不存在时抛出错误
+     */
+    deleteDevServer(devServer) {
+        // 验证输入数据
+        const validationResult = DevServerDeleteSchema.safeParse(devServer);
+        if (!validationResult.success) {
+            throw new AppError(`删除开发服务器失败：参数验证错误 - ${JSON.stringify(validationResult.error.issues)}`);
+        }
+        // 检查服务器是否存在
+        const existing = this.findOneById(validationResult.data);
+        if (!existing) {
+            throw new AppError(`删除开发服务器失败：服务器【${validationResult.data.id}】不存在`);
+        }
+        this.getCollection().findAndRemove(validationResult.data);
+    }
+    /**
+     * 根据ID查询开发服务器
+     * @param devServer - 包含要查询的开发服务器ID的对象
+     * @returns 匹配的开发服务器信息，若未找到则返回null
+     * @throws {AppError} 当验证失败时抛出错误
+     */
+    findOneById(devServer) {
+        // 验证输入数据
+        const validationResult = DevServerQuerySchema.safeParse(devServer);
+        if (!validationResult.success) {
+            throw new AppError(`查询开发服务器失败：参数验证错误 - ${JSON.stringify(validationResult.error.issues)}`);
+        }
+        return this.getCollection().findOne(validationResult.data);
+    }
+    /**
+     * 根据URL查询开发服务器
+     * @param url - 开发服务器URL
+     * @returns 匹配的开发服务器信息，若未找到则返回null
+     */
+    findOneByUrl(url) {
+        return this.getCollection().findOne({ devServerUrl: url });
+    }
+    /**
+     * 更新开发服务器信息
+     * @param devServer - 包含要更新的开发服务器ID及字段的对象
+     * @throws {AppError} 当验证失败或服务器不存在时抛出错误
+     */
+    update(devServer) {
+        // 验证输入数据
+        const validationResult = DevServerUpdateSchema.safeParse(devServer);
+        if (!validationResult.success) {
+            throw new AppError(`更新开发服务器失败：参数验证错误 - ${JSON.stringify(validationResult.error.issues)}`);
+        }
+        // 检查服务器是否存在
+        const existing = this.findOneById({ id: validationResult.data.id });
+        if (!existing) {
+            throw new AppError(`更新开发服务器失败：服务器【${validationResult.data.id}】不存在`);
+        }
+        this.getCollection().findAndUpdate({ id: validationResult.data.id }, (server) => {
+            if (!server) {
+                throw new AppError(`更新开发服务器失败：服务器【${validationResult.data.id}】不存在`);
+            }
+            Object.assign(server, validationResult.data);
+            return server;
+        });
+    }
+}
+export { DevServerRepo };

package/dist/repositories/EnvRepo.js

@@ -0,0 +1,121 @@
+import { AppError } from "../utils/errors.js";
+import { getDatabase } from "./database.js";
+import { EnvDeleteSchema, } from "../types/index.js";
+/**
+ * 环境仓库类
+ * 负责环境相关数据的持久化操作，封装了数据库交互逻辑
+ */
+class EnvRepo {
+    /**
+     * 获取环境数据集合
+     * @returns 环境数据集合对象
+     */
+    getCollection() {
+        return getDatabase().getCollection("envms");
+    }
+    /**
+     * 构造函数
+     */
+    constructor() { }
+    /**
+     * 获取所有环境信息
+     * @returns 所有环境信息的数组
+     */
+    getAll() {
+        return this.getCollection().find();
+    }
+    /**
+     * 添加新环境
+     * @param env - 要添加的环境完整信息对象
+     */
+    addEnv(env) {
+        this.getCollection().insert(env);
+    }
+    /**
+     * 删除指定环境
+     * @param env - 包含要删除环境ID的对象
+     * @throws {Error} 当验证失败或删除操作出现问题时抛出错误
+     */
+    deleteEnv(env) {
+        const target = EnvDeleteSchema.safeParse(env);
+        if (!target.success) {
+            throw new AppError(`删除环境验证失败: ${JSON.stringify(target.error)}`);
+        }
+        this.getCollection().findAndRemove(target.data);
+    }
+    /**
+     * 根据ID查询环境信息
+     * @param env - 包含要查询环境ID的对象
+     * @returns 匹配的环境信息对象，若未找到则返回null
+     * @throws {Error} 当验证失败时抛出错误
+     */
+    findOne(env) {
+        return this.getCollection().findOne(env);
+    }
+    /**
+     * 根据ID查询环境信息
+     * @param id - 包含要查询环境ID
+     * @returns 匹配的环境信息对象，若未找到则返回null
+     * @throws {Error} 当验证失败时抛出错误
+     */
+    findOneById(id) {
+        return this.findOne({
+            id,
+        });
+    }
+    /**
+     * 根据devServerID查询数据
+     * @param devServerId
+     * @returns
+     */
+    findEnvsByDevServerId(devServerId) {
+        return this.getCollection().find({
+            devServerId,
+        });
+    }
+    /**
+     * 根据状态查询环境
+     * @param  status  - 环境状态（如'running'、'stopped'等）
+     * @returns 符合条件的环境数组
+     */
+    findAllByStatus(status) {
+        return this.getCollection().find({ status });
+    }
+    /**
+     * 根据 apiBaseUrl 环境信息查找单个环境 新增前用于判断是否重复
+     * @param env 环境信息
+     * @returns 匹配的环境信息或 undefined
+     */
+    findOneByApiBaseUrl(env) {
+        return this.getCollection().findOne({
+            apiBaseUrl: env.apiBaseUrl,
+        });
+    }
+    /**
+     * 根据状态和端口查询
+     * @param env
+     * @returns
+     */
+    findOneByPortAndStatus(env) {
+        return this.getCollection().findOne({
+            port: env.port,
+            status: env.status,
+        });
+    }
+    /**
+     * 更新环境信息
+     * @param envmItem - 包含要更新的环境ID及字段的对象
+     * @throws {AppError} 当未找到对应环境时抛出异常
+     * @throws {Error} 当更新操作出现问题时抛出错误
+     */
+    update(envmItem) {
+        this.getCollection().findAndUpdate({ id: envmItem.id }, (env) => {
+            if (!env) {
+                throw new AppError("未找到对应的环境");
+            }
+            Object.assign(env, envmItem);
+            return env;
+        });
+    }
+}
+export { EnvRepo };