env-plugin 0.5.6

package/dist/repositories/PasswordRepo.js

@@ -0,0 +1,142 @@
+import { getDatabase } from "./database.js";
+import { PasswordDeleteSchema, } from "../types/index.js";
+/**
+ * 密码仓库类
+ * 负责密码相关数据的持久化操作，封装了数据库交互逻辑
+ */
+class PasswordRepo {
+    /**
+     * 获取密码数据集合
+     * @returns 密码数据集合对象
+     */
+    getCollection() {
+        return getDatabase().getCollection("passwords");
+    }
+    /**
+     * 构造函数
+     */
+    constructor() { }
+    /**
+     * 初始化集合索引
+     */
+    initCollection() {
+        const collection = this.getCollection();
+        collection.ensureIndex("id");
+        collection.ensureIndex("envId");
+        collection.ensureIndex("isDefault");
+    }
+    /**
+     * 根据环境ID获取所有密码
+     * @param envId - 环境ID
+     * @returns 该环境的所有密码数组
+     */
+    getByEnvId(envId) {
+        return this.getCollection().find({ envId });
+    }
+    /**
+     * 统计指定环境的密码数量
+     * @param envId - 环境ID
+     * @returns 密码数量
+     */
+    countByEnvId(envId) {
+        return this.getCollection().count({ envId });
+    }
+    /**
+     * 根据ID查询单个密码
+     * @param id - 密码ID
+     * @returns 匹配的密码，若未找到则返回null
+     */
+    findOneById(id) {
+        return this.getCollection().findOne({ id });
+    }
+    /**
+     * 添加新密码
+     * @param password - 要添加的密码完整信息对象
+     */
+    create(password) {
+        this.getCollection().insert(password);
+    }
+    /**
+     * 删除指定密码
+     * @param password - 包含要删除密码ID的对象
+     */
+    delete(password) {
+        const target = PasswordDeleteSchema.safeParse(password);
+        if (!target.success) {
+            throw new Error(`删除密码验证失败: ${JSON.stringify(target.error)}`);
+        }
+        this.getCollection().findAndRemove(target.data);
+    }
+    /**
+     * 删除指定环境的所有密码
+     * @param envId - 环境ID
+     */
+    deleteByEnvId(envId) {
+        this.getCollection().findAndRemove({ envId });
+    }
+    /**
+     * 更新密码信息
+     * @param passwordItem - 包含要更新的密码ID及字段的对象
+     */
+    update(passwordItem) {
+        this.getCollection().findAndUpdate({ id: passwordItem.id }, (pwd) => {
+            if (!pwd) {
+                throw new Error("未找到对应的密码");
+            }
+            Object.assign(pwd, passwordItem);
+            return pwd;
+        });
+    }
+    /**
+     * 检查指定环境是否已存在相同名称的密码
+     * @param envId - 环境ID
+     * @param name - 密码名称
+     * @returns 是否存在重复
+     */
+    existsByEnvIdAndName(envId, name) {
+        const existing = this.getCollection().findOne({
+            envId,
+            name,
+        });
+        return existing !== null;
+    }
+    /**
+     * 获取指定环境的默认密码
+     * @param envId - 环境ID
+     * @returns 默认密码，若未找到则返回null
+     */
+    findDefaultByEnvId(envId) {
+        return this.getCollection().findOne({ envId, isDefault: true });
+    }
+    /**
+     * 设置指定环境的默认密码（先将其他密码的isDefault设为false）
+     * @param envId - 环境ID
+     * @param excludeId - 排除的密码ID（更新时使用）
+     */
+    clearDefaultByEnvId(envId, excludeId) {
+        const query = { envId, isDefault: true };
+        if (excludeId) {
+            query.id = { $ne: excludeId };
+        }
+        this.getCollection().findAndUpdate(query, (pwd) => {
+            if (pwd) {
+                pwd.isDefault = false;
+            }
+            return pwd;
+        });
+    }
+    /**
+     * 检查指定环境是否已存在默认密码
+     * @param envId - 环境ID
+     * @param excludeId - 排除的密码ID（更新时使用）
+     * @returns 是否存在默认密码
+     */
+    hasDefaultPassword(envId, excludeId) {
+        const query = { envId, isDefault: true };
+        if (excludeId) {
+            query.id = { $ne: excludeId };
+        }
+        return this.getCollection().count(query) > 0;
+    }
+}
+export { PasswordRepo };

package/dist/repositories/RouteRuleRepo.js

@@ -0,0 +1,106 @@
+import { getDatabase } from "./database.js";
+import { RouteRuleDeleteSchema,
+// RouteRuleCreate,
+ } from "../types/index.js";
+/**
+ * 路由规则仓库类
+ * 负责路由规则相关数据的持久化操作，封装了数据库交互逻辑
+ */
+class RouteRuleRepo {
+    /**
+     * 获取路由规则数据集合
+     * @returns 路由规则数据集合对象
+     */
+    getCollection() {
+        return getDatabase().getCollection("routeRules");
+    }
+    /**
+     * 构造函数
+     */
+    constructor() { }
+    /**
+     * 初始化集合索引
+     */
+    initCollection() {
+        const collection = this.getCollection();
+        collection.ensureIndex("id");
+        collection.ensureIndex("envId");
+        collection.ensureIndex("pathPrefix");
+    }
+    /**
+     * 根据环境ID获取所有路由规则
+     * @param envId - 环境ID
+     * @returns 该环境的所有路由规则数组
+     */
+    getByEnvId(envId) {
+        return this.getCollection().find({ envId });
+    }
+    /**
+     * 统计指定环境的路由规则数量
+     * @param envId - 环境ID
+     * @returns 路由规则数量
+     */
+    countByEnvId(envId) {
+        return this.getCollection().count({ envId });
+    }
+    /**
+     * 根据ID查询单个路由规则
+     * @param id - 路由规则ID
+     * @returns 匹配的路由规则，若未找到则返回null
+     */
+    findOneById(id) {
+        return this.getCollection().findOne({ id });
+    }
+    /**
+     * 添加新路由规则
+     * @param routeRule - 要添加的路由规则完整信息对象
+     */
+    create(routeRule) {
+        this.getCollection().insert(routeRule);
+    }
+    /**
+     * 删除指定路由规则
+     * @param routeRule - 包含要删除路由规则ID的对象
+     */
+    delete(routeRule) {
+        const target = RouteRuleDeleteSchema.safeParse(routeRule);
+        if (!target.success) {
+            throw new Error(`删除路由规则验证失败: ${JSON.stringify(target.error)}`);
+        }
+        this.getCollection().findAndRemove(target.data);
+    }
+    /**
+     * 删除指定环境的所有路由规则
+     * @param envId - 环境ID
+     */
+    deleteByEnvId(envId) {
+        this.getCollection().findAndRemove({ envId });
+    }
+    /**
+     * 更新路由规则信息
+     * @param routeRuleItem - 包含要更新的路由规则ID及字段的对象
+     */
+    update(routeRuleItem) {
+        this.getCollection().findAndUpdate({ id: routeRuleItem.id }, (rule) => {
+            if (!rule) {
+                throw new Error("未找到对应的路由规则");
+            }
+            Object.assign(rule, routeRuleItem);
+            return rule;
+        });
+    }
+    /**
+     * 检查指定环境是否已存在相同路径前缀的规则
+     * @param envId - 环境ID
+     * @param pathPrefix - 路径前缀
+     * @returns 是否存在重复
+     */
+    existsByEnvIdAndPathPrefix(envId, pathPrefix) {
+        const existing = this.getCollection().findOne({
+            envId,
+            pathPrefix,
+        });
+        return existing !== null;
+    }
+}
+export { RouteRuleRepo };

package/dist/repositories/database.js

@@ -0,0 +1,95 @@
+import loki from "lokijs";
+import { logger } from "../utils/logger.js";
+// 声明数据库实例类型（避免全局变量类型模糊）
+let db = null;
+/**
+ * 数据库初始化配置（可抽离为外部配置文件）
+ */
+const DB_CONFIG = {
+    filename: ".envm.data.json",
+    autosave: true,
+    autosaveInterval: 5000, // 注意：5秒，需统一
+    autoload: true,
+};
+/**
+ * 初始化开发环境集合
+ */
+const initEnvmsCollection = (db) => {
+    if (!db.getCollection("envms")) {
+        db.addCollection("envms", {
+            indices: ["apiBaseUrl", "id"],
+            unique: ["apiBaseUrl"],
+        });
+    }
+};
+/**
+ * 初始化开发服务器集合
+ */
+const initDevServerCollection = (db) => {
+    if (!db.getCollection("devServer")) {
+        db.addCollection("devServer", {
+            indices: ["id", "devServerUrl"],
+            unique: ["devServerUrl"],
+        });
+    }
+};
+/**
+ * 初始化路由规则集合
+ */
+const initRouteRulesCollection = (db) => {
+    if (!db.getCollection("routeRules")) {
+        db.addCollection("routeRules", {
+            indices: ["id", "envId", "pathPrefix"],
+        });
+    }
+};
+/**
+ * 初始化密码集合
+ */
+const initPasswordsCollection = (db) => {
+    if (!db.getCollection("passwords")) {
+        db.addCollection("passwords", {
+            indices: ["id", "envId", "isDefault"],
+        });
+    }
+};
+/**
+ * 手动启动数据库（核心函数）
+ * @returns 数据库实例（确保单例）
+ */
+export const startDatabase = () => {
+    // 1. 单例保护：避免重复创建实例
+    if (db)
+        return Promise.resolve(db);
+    // 2. 返回Promise，支持异步等待和错误捕获
+    return new Promise((resolve, reject) => {
+        // 3. 初始化数据库
+        const newDb = new loki(DB_CONFIG.filename, {
+            ...DB_CONFIG,
+            // 4. 加载回调中处理集合初始化
+            autoloadCallback: (err) => {
+                if (err) {
+                    reject(new Error(`数据库加载失败: ${err.message}`));
+                    return;
+                }
+                // 初始化集合
+                initEnvmsCollection(newDb);
+                initDevServerCollection(newDb);
+                initRouteRulesCollection(newDb);
+                initPasswordsCollection(newDb);
+                // 5. 赋值单例并返回
+                db = newDb;
+                logger.info("数据库已加载/初始化");
+                resolve(newDb);
+            },
+        });
+    });
+};
+/**
+ * 获取数据库实例（需在startDatabase后调用）
+ */
+export const getDatabase = () => {
+    if (!db)
+        throw new Error("数据库未启动，请先调用 startDatabase()");
+    return db;
+};

package/dist/routes/index.js

@@ -0,0 +1,78 @@
+// routes/index.ts
+import express, { Router } from "express";
+import * as libCookie from "cookie";
+import { Container } from "../Container.js";
+import { getConfig } from "../utils/ResolveConfig.js";
+import { toDTO } from "../middleware/dto.middleware.js";
+import { EnvPrimarySchema, EnvCreateSchema, EnvUpdateSchema, DevServerCreateSchema, DevServerDeleteSchema, DevServerUpdateSchema, RouteRuleCreateSchema, RouteRuleDeleteSchema, RouteRuleUpdateSchema, PasswordCreateSchema, PasswordDeleteSchema, PasswordUpdateSchema, } from "../types/index.js";
+// 1. 创建各模块路由
+const createEnvRoutes = (controller) => {
+    const router = Router();
+    router.get("/getlist", (...res) => controller.handleGetList(...res));
+    router.post("/add", toDTO(EnvCreateSchema), (...res) => controller.handleAddEnv(...res));
+    router.post("/delete", toDTO(EnvPrimarySchema), (...res) => controller.handleDeleteEnv(...res));
+    router.post("/update", toDTO(EnvUpdateSchema), (...res) => controller.handleUpdateEnv(...res));
+    router.post("/start", toDTO(EnvPrimarySchema), (...res) => controller.handleStartServer(...res));
+    router.post("/stop", toDTO(EnvPrimarySchema), (...res) => controller.handleStopServer(...res));
+    return router;
+};
+const createDevServerRoutes = (controller) => {
+    const router = Router();
+    router.get("/list", (...res) => controller.handleGetDevServerList(...res));
+    router.post("/add", toDTO(DevServerCreateSchema), (...res) => controller.handleCreateDevServer(...res));
+    router.put("/update", toDTO(DevServerUpdateSchema), (...res) => controller.handleUpdateDevServer(...res));
+    router.delete("/", toDTO(DevServerDeleteSchema), (...res) => controller.handleDeleteDevServer(...res));
+    return router;
+};
+const createRouteRuleRoutes = (controller) => {
+    const router = Router();
+    router.get("/list/:envId", (...res) => controller.handleGetList(...res));
+    router.post("/add", toDTO(RouteRuleCreateSchema), (...res) => controller.handleAdd(...res));
+    router.post("/update", toDTO(RouteRuleUpdateSchema), (...res) => controller.handleUpdate(...res));
+    router.post("/delete", toDTO(RouteRuleDeleteSchema), (...res) => controller.handleDelete(...res));
+    return router;
+};
+const createPasswordRoutes = (controller) => {
+    const router = Router();
+    router.get("/list/:envId", (...res) => controller.handleGetList(...res));
+    router.post("/add", toDTO(PasswordCreateSchema), (...res) => controller.handleAdd(...res));
+    router.post("/update", toDTO(PasswordUpdateSchema), (...res) => controller.handleUpdate(...res));
+    router.post("/delete", toDTO(PasswordDeleteSchema), (...res) => controller.handleDelete(...res));
+    return router;
+};
+const createCommonRoutes = () => {
+    const router = Router();
+    router.get("/are-you-ok", (req, res) => res.success({}, "I'm ok!"));
+    router.get("/clear-proxy-cookie", (req, res) => {
+        const cookies = req.headers.cookie;
+        if (cookies) {
+            const cookieArr = libCookie.parse(cookies);
+            Object.keys(cookieArr).forEach((cookieName) => {
+                if (cookieName.endsWith(getConfig().cookieSuffix)) {
+                    res.setHeader("Set-Cookie", `${cookieName}=; max-age=0; path=/`);
+                }
+            });
+        }
+        res.success();
+    });
+    return router;
+};
+// 2. 整合所有路由并导出
+export const createRouter = () => {
+    const rootRouter = Router();
+    // 全局中间件（原 ManageRouter 中的通用中间件）
+    rootRouter.use(express.json());
+    // 依赖注入
+    const container = Container.getInstance();
+    const envController = container.get("envController");
+    const devServerController = container.get("devServerController");
+    const routeRuleController = container.get("routeRuleController");
+    const passwordController = container.get("passwordController");
+    // 挂载模块路由
+    rootRouter.use("/env", createEnvRoutes(envController));
+    rootRouter.use("/server", createDevServerRoutes(devServerController));
+    rootRouter.use("/route-rule", createRouteRuleRoutes(routeRuleController));
+    rootRouter.use("/password", createPasswordRoutes(passwordController));
+    rootRouter.use("/", createCommonRoutes());
+    return rootRouter;
+};

package/dist/service/DevServerService.js

@@ -0,0 +1,189 @@
+import { v4 as uuidv4 } from "uuid";
+import { DevServerQuerySchema, } from "../types/index.js";
+import { AppError } from "../utils/errors.js";
+import { devServerLogger } from "../utils/logger.js";
+/**
+ * 开发服务器服务类
+ * 负责处理开发服务器（devServer）的核心业务逻辑，包括增删改查、关联环境校验等操作
+ * 依赖开发服务器仓库(DevServerRepo)和环境仓库(EnvRepo)实现数据持久化与关联业务处理
+ */
+class DevServerService {
+    /**
+     * 构造函数 - 通过依赖注入初始化仓库实例
+     * @param devServerRepo - 开发服务器仓库实例，用于devServer数据的持久化操作
+     * @param envRepo - 环境仓库实例，用于关联环境的校验与操作
+     */
+    constructor(devServerRepo, envRepo) {
+        this.devServerRepo = devServerRepo;
+        this.envRepo = envRepo;
+    }
+    /**
+     * 添加新开发服务器
+     * 1. 校验输入参数合法性 2. 检查服务器URL是否已存在 3. 生成唯一ID 4. 保存新服务器
+     * @param devServerItem - 待添加的开发服务器信息（不含ID）
+     * @returns {void}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当服务器URL已存在时抛出
+     */
+    handleAddDevServer(devServerItem) {
+        const validData = devServerItem;
+        devServerLogger.info(validData, "准备添加开发服务器");
+        // 检查服务器URL是否已存在（URL作为唯一标识）
+        const existingServer = this.devServerRepo.findOneByUrl(validData.devServerUrl);
+        if (existingServer) {
+            throw new AppError(`添加失败，开发服务器【${existingServer.devServerUrl}】已存在`);
+        }
+        // 生成唯一ID并组装完整服务器信息（默认状态为未关联）
+        const newDevServer = {
+            ...validData,
+            id: uuidv4(),
+        };
+        // 保存开发服务器
+        this.devServerRepo.addDevServer(newDevServer);
+        devServerLogger.info(newDevServer, "开发服务器添加成功");
+    }
+    /**
+     * 删除指定开发服务器
+     * 1. 校验输入参数 2. 检查服务器是否存在 3. 检查是否关联环境（关联则禁止删除） 4. 执行删除
+     * @param devServerItem - 包含待删除服务器ID的对象
+     * @returns {void}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当服务器不存在时抛出
+     * @throws {AppError} 当服务器已关联环境时抛出（避免数据关联异常）
+     */
+    handleDeleteDevServer(devServerItem) {
+        // 参数校验
+        const { id } = devServerItem;
+        devServerLogger.info(devServerItem, "准备删除开发服务器");
+        // 检查服务器是否存在
+        const existingServer = this.devServerRepo.findOneById(devServerItem);
+        if (!existingServer) {
+            throw new AppError(`删除失败，开发服务器【${id}】不存在`);
+        }
+        // 检查服务器是否已关联环境（关联环境时禁止删除，避免环境依赖异常）
+        const linkedEnvs = this.envRepo.findEnvsByDevServerId(id);
+        if (linkedEnvs.length > 0) {
+            throw new AppError(`删除失败，开发服务器【${existingServer.name}】已关联 ${linkedEnvs.length} 个环境，请先解除关联`);
+        }
+        // 执行删除
+        this.devServerRepo.deleteDevServer(devServerItem);
+        devServerLogger.info(devServerItem, "开发服务器删除成功");
+    }
+    /**
+     * 更新开发服务器信息
+     * 1. 校验输入参数 2. 检查服务器是否存在 3. 若更新URL则校验唯一性 4. 执行更新（同步修订号）
+     * @param devServerItem - 包含待更新服务器ID及字段的对象
+     * @returns {void}
+     * @throws {AppError} 当输入参数不合法时抛出
+     * @throws {AppError} 当服务器不存在时抛出
+     * @throws {AppError} 当更新的URL已存在时抛出
+     */
+    handleUpdateDevServer(devServerItem) {
+        // 参数校验
+        const { id } = devServerItem;
+        devServerLogger.info(devServerItem, "准备更新开发服务器");
+        // 检查服务器是否存在
+        const existingServer = this.devServerRepo.findOneById({ id });
+        if (!existingServer) {
+            throw new AppError(`更新失败，开发服务器【${id}】不存在`);
+        }
+        const validData = devServerItem;
+        // 若更新了URL，需校验新URL的唯一性
+        if (validData.devServerUrl &&
+            validData.devServerUrl !== existingServer.devServerUrl) {
+            const conflictServer = this.devServerRepo.findOneByUrl(validData.devServerUrl);
+            if (conflictServer) {
+                throw new AppError(`更新失败，URL【${validData.devServerUrl}】已被其他开发服务器使用`);
+            }
+        }
+        // 组装更新数据（同步元数据修订号）
+        const updatedServer = {
+            ...existingServer,
+            ...validData,
+        };
+        // 执行更新
+        this.devServerRepo.update(updatedServer);
+        devServerLogger.info(updatedServer, "开发服务器更新成功");
+    }
+    /**
+     * 获取所有开发服务器列表
+     * @returns {DevServerModel[]} 开发服务器信息数组
+     */
+    handleGetList() {
+        const list = this.devServerRepo.getAll();
+        devServerLogger.info(`查询到${list.length}个开发服务器`);
+        return list;
+    }
+    /**
+     * 根据ID查询单个开发服务器
+     * @param devServer - 包含待查询服务器ID的对象
+     * @returns {DevServerModel | undefined} 匹配的开发服务器信息（不存在则返回undefined）
+     * @throws {AppError} 当输入参数不合法时抛出
+     */
+    findOneById(devServer) {
+        // 参数校验
+        const validationResult = DevServerQuerySchema.safeParse(devServer);
+        if (!validationResult.success) {
+            throw new AppError(`查询开发服务器失败：参数不合法 - ${JSON.stringify(validationResult.error.issues)}`);
+        }
+        const server = this.devServerRepo.findOneById(validationResult.data);
+        devServerLogger.info(`查询开发服务器【${devServer.id}】结果：${server ? "存在" : "不存在"}`);
+        return server;
+    }
+    /**
+     * 关联开发服务器到环境（更新服务器状态为"linked"）
+     * 1. 校验参数 2. 检查服务器/环境是否存在 3. 更新服务器关联状态
+     * @param devServerId - 开发服务器ID
+     * @param envId - 关联的环境ID
+     * @returns {void}
+     * @throws {AppError} 当参数不合法或资源不存在时抛出
+     */
+    handleLinkToEnv(devServerId, envId) {
+        // 校验ID格式（简化校验，实际可通过Schema补充）
+        if (!devServerId || !envId) {
+            throw new AppError("关联失败：开发服务器ID和环境ID不能为空");
+        }
+        devServerLogger.info(`准备关联开发服务器【${devServerId}】到环境【${envId}】`);
+        // 检查开发服务器是否存在
+        const devServer = this.devServerRepo.findOneById({ id: devServerId });
+        if (!devServer) {
+            throw new AppError(`关联失败，开发服务器【${devServerId}】不存在`);
+        }
+        // 检查环境是否存在
+        const env = this.envRepo.findOneById(envId);
+        if (!env) {
+            throw new AppError(`关联失败，环境【${envId}】不存在`);
+        }
+        // 更新开发服务器状态为"已关联"
+        // this.handleUpdateDevServer({
+        //   id: devServerId,
+        //   status: "linked",
+        //   linkedEnvId: envId, // 记录关联的环境ID（需确保Schema支持该字段）
+        // });
+        devServerLogger.info(`开发服务器【${devServerId}】已成功关联到环境【${envId}】`);
+    }
+    /**
+     * 解除开发服务器与环境的关联（更新服务器状态为"unlinked"）
+     * @param devServerId - 开发服务器ID
+     * @returns {void}
+     * @throws {AppError} 当服务器不存在或参数不合法时抛出
+     */
+    handleUnlinkFromEnv(devServerId) {
+        if (!devServerId) {
+            throw new AppError("解除关联失败：开发服务器ID不能为空");
+        }
+        devServerLogger.info(`准备解除开发服务器【${devServerId}】的环境关联`);
+        const devServer = this.devServerRepo.findOneById({ id: devServerId });
+        if (!devServer) {
+            throw new AppError(`解除关联失败，开发服务器【${devServerId}】不存在`);
+        }
+        // 更新服务器状态为"未关联"，清空关联的环境ID
+        // this.handleUpdateDevServer({
+        //   id: devServerId,
+        //   status: "unlinked",
+        //   linkedEnvId: undefined,
+        // });
+        devServerLogger.info(`开发服务器【${devServerId}】已解除环境关联`);
+    }
+}
+export { DevServerService };