env-plugin 0.5.6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 lumos934
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { program } from "commander";
+import { EnvManage } from "../dist/index.js";
+
+program
+  .description("Environment management tool")
+  .name("envm")
+  // 添加命令行选项
+  .option("-p, --port <number>", "specify the port number", Number)
+  .option("-a, --api-prefix <string>", "specify the API prefix", String)
+  .option("-c, --cookie-suffix <string>", "specify the cookie suffix", String)
+  .option(
+    "-l, --log-level <string>",
+    "specify the log level (info, debug, warn, error)",
+    String
+  )
+  .action((options) => {
+    const envMangePlugin = new EnvManage(options);
+    envMangePlugin.startIndependent();
+  });
+
+program.parse();

package/dist/Container.js

@@ -0,0 +1,55 @@
+import { EnvController } from "./controllers/EnvController.js";
+import { DevServerController } from "./controllers/DevServerController.js";
+import { RouteRuleController } from "./controllers/RouteRuleController.js";
+import { PasswordController } from "./controllers/PasswordController.js";
+import { EnvRepo } from "./repositories/EnvRepo.js";
+import { EnvService } from "./service/EnvService.js";
+import { DevServerService } from "./service/DevServerService.js";
+import { DevServerRepo } from "./repositories/DevServerRepo.js";
+import { RouteRuleRepo } from "./repositories/RouteRuleRepo.js";
+import { RouteRuleService } from "./service/RouteRuleService.js";
+import { PasswordRepo } from "./repositories/PasswordRepo.js";
+import { PasswordService } from "./service/PasswordService.js";
+import { ProxyAutoStarter } from "./service/ProxyAutoStarterService.js";
+class Container {
+    constructor() {
+        this.dependencies = new Map();
+        // 环境和服务的注册
+        const envRepo = new EnvRepo();
+        const devServerRepo = new DevServerRepo();
+        const routeRuleRepo = new RouteRuleRepo();
+        const passwordRepo = new PasswordRepo();
+        // configIns.initConfig();
+        this.register("envService", new EnvService(envRepo, devServerRepo, routeRuleRepo));
+        this.register("envController", new EnvController(this.get("envService")));
+        // 开发服务器服务和控制器的注册
+        this.register("devServerService", new DevServerService(devServerRepo, envRepo));
+        this.register("devServerController", new DevServerController(this.get("devServerService")));
+        // 路由规则服务和控制器的注册
+        this.register("routeRuleService", new RouteRuleService(routeRuleRepo, envRepo));
+        this.register("routeRuleController", new RouteRuleController(this.get("routeRuleService")));
+        // 密码服务和控制器的注册
+        this.register("passwordService", new PasswordService(passwordRepo));
+        this.register("passwordController", new PasswordController(this.get("passwordService")));
+        setTimeout(() => {
+            new ProxyAutoStarter(envRepo, this.get("envService"), routeRuleRepo);
+        }, 5000);
+    }
+    static getInstance() {
+        if (!this.instance) {
+            this.instance = new Container();
+        }
+        return this.instance;
+    }
+    register(key, value) {
+        this.dependencies.set(key, value);
+        return this;
+    }
+    get(key) {
+        if (!this.dependencies.has(key)) {
+            throw new Error(`Dependency ${key} not found`);
+        }
+        return this.dependencies.get(key);
+    }
+}
+export { Container };

package/dist/Plugin.js

@@ -0,0 +1,25 @@
+import { createUnplugin } from "unplugin";
+import { EnvManage } from "./index.js";
+let hasBeenCalled = false;
+export const unpluginFactory = (options) => {
+    const envMangePlugin = new EnvManage(options);
+    return {
+        name: "unplugin-envm",
+        buildStart() {
+            if (hasBeenCalled) {
+                return;
+            }
+            hasBeenCalled = true;
+            envMangePlugin.startIndependent();
+        },
+    };
+};
+export const unpluginEnvm = /* #__PURE__ */ createUnplugin(unpluginFactory);
+export default unpluginEnvm;
+export const envmVitePlugin = unpluginEnvm.vite;
+export const envmRollupPlugin = unpluginEnvm.rollup;
+export const envmRolldownPlugin = unpluginEnvm.rolldown;
+export const envmWebpackPlugin = unpluginEnvm.webpack;
+export const envmRspackPlugin = unpluginEnvm.rspack;
+export const envmEsbuildPlugin = unpluginEnvm.esbuild;
+export const envmFarmPlugin = unpluginEnvm.farm;

package/dist/PostProxyServer.js

@@ -0,0 +1,85 @@
+import { join } from "path";
+import { WebSocketServer } from "ws";
+import express from "express";
+import expressStaticGzip from "express-static-gzip";
+import { createProxyMiddleware } from "http-proxy-middleware";
+import { getConfig } from "./utils/ResolveConfig.js";
+import { createRouter } from "./routes/index.js";
+import { globalErrorHandler } from "./middleware/globalErrorHandler.js";
+import { responseEnhancer } from "./middleware/responseEnhancer.js";
+const currentModuleUrl = import.meta.url;
+// 转换为文件系统路径
+import { fileURLToPath } from "url";
+const __filename = fileURLToPath(currentModuleUrl); // 当前文件的完整路径
+// 获取目录路径
+import { dirname } from "path";
+const __dirname = dirname(__filename); // 当前文件所在的目录路径
+import { envLogger } from "./utils/logger.js";
+/**
+ * 后置代理服务器---同时也是管理页面的服务器
+ */
+class PostProxyServer {
+    get config() {
+        return getConfig();
+    }
+    constructor(app = express()) {
+        this.app = app;
+        // 代理中间件
+        app.use(this.createPostProxyMiddleware());
+        // 静态资源
+        app.use(expressStaticGzip(join(__dirname, "client"), {}));
+        // 注入资源
+        app.use("/envm-inject", express.static(join(process.cwd(), this.config.injectScriptDir || ""), {}));
+        // 统一处理响应
+        app.use(responseEnhancer);
+        // 初始化管理路由
+        app.use(this.config.apiPrefix, createRouter());
+        // 全局错误处理中间件
+        app.use(globalErrorHandler);
+        // 启动服务器
+        const server = this.startServer();
+        this.registerWs(server);
+    }
+    /**
+     * 启动服务
+     */
+    startServer() {
+        return this.app.listen(this.config.port, () => {
+            envLogger.info(`Post Proxy Middleware is running on http://localhost:${this.config.port}`);
+        });
+    }
+    /**
+     * 注册ws服务用于通知客户端更新
+     * @param server
+     */
+    registerWs(server) {
+        const wss = new WebSocketServer({ noServer: true });
+        server.on("upgrade", (request, socket, head) => {
+            if (request?.url?.startsWith(this.config.apiPrefix)) {
+                wss.handleUpgrade(request, socket, head, () => { });
+            }
+        });
+    }
+    /**
+     * 创建后置服务器 代理转发中间件
+     * @returns
+     */
+    createPostProxyMiddleware() {
+        // 定义路径过滤函数，排除 管理url
+        const pathFilter = (path, req) => {
+            return !!req.headers["x-api-server"];
+        };
+        return createProxyMiddleware({
+            pathFilter,
+            ws: true,
+            changeOrigin: true,
+            router: async (req) => {
+                if (req.headers["x-api-server"]) {
+                    const target = req.headers["x-api-server"];
+                    return target;
+                }
+            },
+        });
+    }
+}
+export default PostProxyServer;

package/dist/client/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="zh">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" href="/favicon.ico" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>ENVM (环境管理)</title>
+    <script type="module" crossorigin src="/assets/index-Bl3B2M1W.js"></script>
+    <link rel="modulepreload" crossorigin href="/assets/vue-BGFZjnqd.js">
+    <link rel="modulepreload" crossorigin href="/assets/element-plus-wndYbaZY.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-nrcddKJg.css">
+  </head>
+  <body>
+    <div id="app"></div>
+  </body>
+</html>

package/dist/constants/responseCode.js

@@ -0,0 +1,27 @@
+/**
+ * Response code constants
+ * @file src/constants/responseCode.ts
+ * @description This file defines the response codes used throughout the application.
+ * @module constants/responseCode
+ */
+export const ResponseCode = {
+    /**
+     * 成功
+     */
+    SUCCESS: 200,
+    /**
+     * 创建成功
+     */
+    CREATED: 201,
+    /**
+     * 请求已接受
+     */
+    BAD_REQUEST: 400,
+    /**
+     * 未授权访问
+     */
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    INTERNAL_ERROR: 500,
+}; // 只读约束

package/dist/controllers/DevServerController.js

@@ -0,0 +1,102 @@
+import { devServerLogger } from "../utils/logger.js";
+class DevServerController {
+    constructor(devServerService) {
+        this.devServerService = devServerService;
+    }
+    /**
+     * 处理获取开发服务器列表
+     * @param req
+     * @param res
+     * @param next
+     * @returns
+     */
+    handleGetDevServerList(req, res, next) {
+        try {
+            const list = this.devServerService.handleGetList();
+            res.success({ list });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    /**
+     * 处理获取单个开发服务器详情
+     * @param req
+     * @param res
+     * @param next
+     * @returns
+     */
+    handleGetDevServerById(req, res, next) {
+        try {
+            // 验证请求数据
+            const devServerData = req.dto;
+            devServerLogger.info(devServerData, "接收环境详情查询请求");
+            // 调用服务层获取数据（假设服务层有此方法）
+            const detail = this.devServerService.findOneById(devServerData);
+            if (!detail) {
+                res.error("环境不存在");
+            }
+            // 返回成功响应（包含详情数据）
+            res.success({
+                message: "环境详情查询成功",
+                data: detail,
+            });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    /**
+     * 处理创建开发服务器
+     * @param req
+     * @param res
+     * @param next
+     * @returns
+     */
+    handleCreateDevServer(req, res, next) {
+        try {
+            // 验证请求体
+            const devServerItem = req.body;
+            this.devServerService.handleAddDevServer(devServerItem);
+            res.success("开发服务器创建成功");
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    /**
+     * 处理更新开发服务器
+     * @param req
+     * @param res
+     * @param next
+     * @returns
+     */
+    handleUpdateDevServer(req, res, next) {
+        try {
+            const updateData = req.dto;
+            const updatedServer = this.devServerService.handleUpdateDevServer(updateData);
+            res.success({ message: "开发服务器更新成功", server: updatedServer });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+    /**
+     * 处理删除开发服务器
+     * @param req
+     * @param res
+     * @param next
+     * @returns
+     */
+    handleDeleteDevServer(req, res, next) {
+        try {
+            const devServerData = req.dto;
+            this.devServerService.handleDeleteDevServer(devServerData);
+            res.success({ message: "开发服务器删除成功" });
+        }
+        catch (error) {
+            next(error);
+        }
+    }
+}
+export { DevServerController };

package/dist/controllers/EnvController.js

@@ -0,0 +1,177 @@
+import { envLogger } from "../utils/logger.js";
+/**
+ * 环境控制器
+ * 负责处理与环境相关的HTTP请求，作为请求入口层：
+ * - 解析并验证请求参数
+ * - 调用对应的服务层方法处理业务逻辑
+ * - 格式化并返回响应结果
+ * - 统一错误处理
+ */
+class EnvController {
+    /**
+     * 构造函数 - 注入环境服务实例
+     * @param private readonly envService - 环境服务实例，处理核心业务逻辑
+     */
+    constructor(envService) {
+        this.envService = envService;
+    }
+    /**
+     * 新增环境
+     * @description 处理创建新环境的POST请求
+     * @param req - Express请求对象，包含待创建的环境数据（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleAddEnv(req, res, next) {
+        try {
+            // 验证请求数据
+            const envData = req.dto;
+            envLogger.info({ envData }, "接收新增环境请求");
+            // 调用服务层处理业务
+            this.envService.handleAddEnv(envData);
+            // 返回成功响应
+            res.success();
+        }
+        catch (error) {
+            envLogger.error(error, "新增环境请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 删除环境
+     * @description 处理删除环境的DELETE请求
+     * @param req - Express请求对象，包含待删除环境的ID（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleDeleteEnv(req, res, next) {
+        try {
+            // 验证请求数据
+            const envData = req.dto;
+            envLogger.info({ envData }, "接收删除环境请求");
+            // 调用服务层处理业务
+            this.envService.handleDeleteEnv(envData);
+            // 返回成功响应
+            res.success({ message: "环境删除成功" });
+        }
+        catch (error) {
+            envLogger.error(error, "删除环境请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 更新环境
+     * @description 处理更新环境信息的PUT请求
+     * @param req - Express请求对象，包含待更新的环境数据（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleUpdateEnv(req, res, next) {
+        try {
+            // 验证请求数据
+            const envData = req.dto;
+            envLogger.info({ envData }, "接收更新环境请求");
+            // 调用服务层处理业务
+            this.envService.handleUpdateEnv(envData);
+            // 返回成功响应
+            res.success({ message: "环境更新成功" });
+        }
+        catch (error) {
+            envLogger.error(error, "更新环境请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 获取环境列表
+     * @description 处理查询所有环境的GET请求
+     * @param req - Express请求对象
+     * @param res - Express响应对象，用于返回环境列表
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleGetList(req, res, next) {
+        try {
+            envLogger.info("接收环境列表查询请求");
+            // 调用服务层获取数据
+            const list = this.envService.handleGetList();
+            // 返回成功响应（包含列表数据）
+            res.success({ list, total: list.length });
+        }
+        catch (error) {
+            envLogger.error(error, "环境列表查询请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 获取单个环境详情
+     * @description 处理查询指定环境的GET请求
+     * @param req - Express请求对象，包含待查询环境的ID（在req.dto中）
+     * @param res - Express响应对象，用于返回环境详情
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    handleGetDetail(req, res, next) {
+        try {
+            // 验证请求数据
+            const envData = req.dto;
+            envLogger.info({ envData }, "接收环境详情查询请求");
+            // 调用服务层获取数据（假设服务层有此方法）
+            const detail = this.envService.findOneById(envData.id);
+            if (!detail) {
+                res.error("环境不存在");
+            }
+            // 返回成功响应（包含详情数据）
+            res.success({
+                message: "环境详情查询成功",
+                data: detail,
+            });
+        }
+        catch (error) {
+            envLogger.error(error, "环境详情查询请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 启动代理服务器
+     * @description 处理启动指定环境代理服务的POST请求
+     * @param req - Express请求对象，包含目标环境的ID（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    async handleStartServer(req, res, next) {
+        try {
+            // 验证请求数据
+            const envData = req.dto;
+            envLogger.info({ envData }, "接收启动代理服务器请求");
+            // 调用服务层处理业务（异步操作）
+            await this.envService.handleStartServer(envData);
+            // 返回成功响应
+            res.success();
+        }
+        catch (error) {
+            envLogger.error(error, "启动代理服务器请求处理失败");
+            next(error);
+        }
+    }
+    /**
+     * 停止代理服务器
+     * @description 处理停止指定环境代理服务的POST请求
+     * @param req - Express请求对象，包含目标环境的ID（在req.dto中）
+     * @param res - Express响应对象，用于返回处理结果
+     * @param next - Express下一步中间件函数，用于错误处理
+     */
+    async handleStopServer(req, res, next) {
+        try {
+            // 验证请求数据
+            const envData = req.dto;
+            envLogger.info({ envData }, "接收停止代理服务器请求");
+            // 调用服务层处理业务（异步操作）
+            await this.envService.handleStopServer(envData);
+            // 返回成功响应
+            res.success({ message: "代理服务器停止成功" });
+        }
+        catch (error) {
+            envLogger.error(error, "停止代理服务器请求处理失败");
+            next(error);
+        }
+    }
+}
+export { EnvController };

package/dist/controllers/PasswordController.js

@@ -0,0 +1,106 @@
+import { envLogger } from "../utils/logger.js";
+/**
+ * 密码控制器
+ * 负责处理与密码相关的HTTP请求，作为请求入口层：
+ * - 解析并验证请求参数
+ * - 调用对应的服务层方法处理业务逻辑
+ * - 格式化并返回响应结果
+ * - 统一错误处理
+ */
+class PasswordController {
+    /**
+     * 构造函数 - 注入密码服务实例
+     * @param private readonly passwordService - 密码服务实例，处理核心业务逻辑
+     */
+    constructor(passwordService) {
+        this.passwordService = passwordService;
+    }
+    /**
+     * 获取指定环境的密码列表
+     * @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.passwordService.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 passwordData = req.dto;
+            envLogger.info({ passwordData: { ...passwordData, password: "***" } }, "接收新增密码请求");
+            // 调用服务层处理业务
+            const newPassword = this.passwordService.handleAdd(passwordData);
+            // 返回成功响应
+            res.success({ message: "密码添加成功", data: newPassword });
+        }
+        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 passwordData = req.dto;
+            envLogger.info({ passwordData: { ...passwordData, password: "***" } }, "接收更新密码请求");
+            // 调用服务层处理业务
+            const updatedPassword = this.passwordService.handleUpdate(passwordData);
+            // 返回成功响应
+            res.success({ message: "密码更新成功", data: updatedPassword });
+        }
+        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 passwordData = req.dto;
+            envLogger.info({ passwordData }, "接收删除密码请求");
+            // 调用服务层处理业务
+            this.passwordService.handleDelete(passwordData);
+            // 返回成功响应
+            res.success({ message: "密码删除成功" });
+        }
+        catch (error) {
+            envLogger.error(error, "删除密码请求处理失败");
+            next(error);
+        }
+    }
+}
+export { PasswordController };