@yinuo-ngm/server 1.0.20 → 1.0.22

package/lib/routes/config.routes.js

@@ -2,64 +2,88 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = configRoutes;
 const errors_1 = require("@yinuo-ngm/errors");
+const config_1 = require("@yinuo-ngm/config");
 const editor_1 = require("../common/editor");
+const PATCH_OPS = new Set(["set", "remove", "append", "merge"]);
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+function isPatchValid(patch) {
+    if (typeof patch !== "object" || patch === null || Array.isArray(patch)) {
+        return false;
+    }
+    const candidate = patch;
+    if (typeof candidate.op !== "string" || !PATCH_OPS.has(candidate.op)) {
+        return false;
+    }
+    if (typeof candidate.path !== "string") {
+        return false;
+    }
+    if ((candidate.op === "set" || candidate.op === "append" || candidate.op === "merge") &&
+        !hasOwn(candidate, "value")) {
+        return false;
+    }
+    return true;
+}
+function ensureWriteBody(body) {
+    if (!body.type || !body.filePath || !Array.isArray(body.patches)) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "missing body.type/body.filePath/body.patches");
+    }
+    if (!body.patches.every(isPatchValid)) {
+        throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "invalid body.patches[] (require op/path/value)");
+    }
+    return {
+        type: body.type,
+        filePath: body.filePath,
+        patches: body.patches
+    };
+}
 async function configRoutes(fastify) {
-    fastify.get("/catalog/:projectId", async (req) => {
-        const { projectId } = req.params;
-        return await fastify.core.config.getCatalog(projectId);
+    const config = fastify.core.config;
+    fastify.get("/providers", async () => {
+        return config.listProviders();
     });
-    fastify.get("/readDoc/:projectId/:docId", async (req) => {
-        const { projectId, docId } = req.params;
-        return await fastify.core.config.readDoc(projectId, docId);
+    fastify.get("/detect/:projectId", async (req) => {
+        const project = await fastify.core.project.get(req.params.projectId);
+        return config.detect(project.root);
     });
-    fastify.post("/writeDoc/:projectId/:docId", async (req) => {
-        const { projectId, docId } = req.params;
-        const body = req.body;
-        const next = body?.raw ?? body?.data;
-        if (next === undefined) {
-            throw new errors_1.CoreError(errors_1.CoreErrorCodes.CONFIG_WRITE_FAILED, "missing body.raw or body.data", { projectId, docId });
-        }
-        return await fastify.core.config.writeDoc(projectId, docId, next);
+    fastify.get("/doc/:projectId/:type", async (req) => {
+        const project = await fastify.core.project.get(req.params.projectId);
+        return config.read({
+            projectRoot: project.root,
+            type: req.params.type,
+            filePath: req.query.filePath
+        });
     });
-    fastify.post("/openInEditor/:projectId/:docId", async (req) => {
-        try {
-            const { projectId, docId } = req.params;
-            const { filePath } = await fastify.core.config.openDoc(projectId, docId);
-            await (0, editor_1.openFolder)(filePath, { editor: 'code' });
-            return { ok: true };
-        }
-        catch (e) {
-            throw new errors_1.CoreError(errors_1.CoreErrorCodes.EDITOR_LAUNCH_FAILED, e?.message || "openInEditor failed");
-        }
+    fastify.post("/preview/:projectId", async (req) => {
+        const body = ensureWriteBody(req.body ?? {});
+        const project = await fastify.core.project.get(req.params.projectId);
+        return config.preview({
+            projectRoot: project.root,
+            type: body.type,
+            filePath: body.filePath,
+            patches: body.patches
+        });
     });
-    fastify.get("/readSchema/:projectId/:domainId", async (req) => {
-        const { projectId, domainId } = req.params;
-        return await fastify.core.config.readDomainSchema(projectId, domainId);
+    fastify.post("/write/:projectId", async (req) => {
+        const body = ensureWriteBody(req.body ?? {});
+        const project = await fastify.core.project.get(req.params.projectId);
+        return config.write({
+            projectRoot: project.root,
+            type: body.type,
+            filePath: body.filePath,
+            patches: body.patches
+        });
     });
-    fastify.post("/writeSchema/:projectId/:domainId", async (req) => {
-        const { projectId, domainId } = req.params;
-        const body = req.body;
-        const vm = body?.vm;
-        if (vm === undefined) {
-            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "missing body.vm");
+    fastify.post("/openInEditor/:projectId", async (req) => {
+        if (!req.body?.filePath) {
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "missing body.filePath");
         }
-        await fastify.core.config.writeDomainSchema(projectId, domainId, vm);
+        const project = await fastify.core.project.get(req.params.projectId);
+        const absPath = (0, config_1.resolveProjectFile)(project.root, req.body.filePath);
+        await (0, editor_1.openFolder)(absPath, { editor: "code" });
         return {
-            projectId,
-            domainId,
+            filePath: absPath
         };
     });
-    fastify.get("/getDomainSchema/:projectId/:domainId", async (req) => {
-        const { projectId, domainId } = req.params;
-        return await fastify.core.config.getDomainSchemaDoc(projectId, domainId);
-    });
-    fastify.post("/diffSchema/:projectId/:domainId", async (req) => {
-        const { projectId, domainId } = req.params;
-        const body = req.body;
-        const vm = body?.vm;
-        if (vm === undefined) {
-            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "missing body.vm");
-        }
-        return await fastify.core.config.diffDomainSchema(projectId, domainId, vm);
-    });
 }

package/lib/routes/deps.route.js

@@ -1,25 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = depsRoutes;
+const errors_1 = require("@yinuo-ngm/errors");
+function toDepItemDto(item) {
+    return {
+        name: item.name,
+        current: item.current,
+        required: item.required,
+        latest: item.latest,
+        installed: item.installed,
+        hasUpdate: item.hasUpdate,
+        group: item.group,
+    };
+}
+function toProjectDepsMetaDto(meta) {
+    return {
+        packageManager: meta.packageManager,
+        registryOnline: meta.registryOnline,
+        voltaConfig: meta.voltaConfig,
+        enginesNode: meta.enginesNode,
+    };
+}
+function toProjectDepsResultDto(result) {
+    return {
+        dependencies: result.dependencies.map(toDepItemDto),
+        devDependencies: result.devDependencies.map(toDepItemDto),
+        meta: toProjectDepsMetaDto(result.meta),
+    };
+}
 async function depsRoutes(fastify) {
+    const deps = fastify.core.deps;
     fastify.get("/list/:projectId", async (req) => {
         const { projectId } = req.params;
-        const data = await fastify.core.deps.list(projectId);
-        return data;
+        const result = await deps.list(projectId);
+        return toProjectDepsResultDto(result);
     });
     fastify.post("/install/:projectId", async (req) => {
         const { projectId } = req.params;
         const body = req.body;
-        await fastify.core.deps.install(projectId, body);
+        if (!body.name || !body.group || !body.target) {
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "missing required fields: name, group, target");
+        }
+        await deps.install(projectId, {
+            name: body.name,
+            group: body.group,
+            target: body.target,
+            version: body.version,
+        });
         return { ok: true };
     });
     fastify.post("/uninstall/:projectId", async (req) => {
         const { projectId } = req.params;
         const body = req.body;
-        await fastify.core.deps.uninstall(projectId, body);
+        if (!body.name || !body.group) {
+            throw new errors_1.GlobalError(errors_1.GlobalErrorCodes.BAD_REQUEST, "missing required fields: name, group");
+        }
+        await deps.uninstall(projectId, {
+            name: body.name,
+            group: body.group,
+        });
         return { ok: true };
     });
-    fastify.post("/devtools/install/:projectId", async (req) => {
+    fastify.post("/devtools/install/:projectId", async () => {
         return { ok: true };
     });
 }

package/lib/routes/index.js

@@ -10,15 +10,16 @@ const deps_route_1 = __importDefault(require("./deps.route"));
 const fs_routes_1 = __importDefault(require("./fs.routes"));
 const project_routes_1 = __importDefault(require("./project.routes"));
 const rss_routes_1 = __importDefault(require("./rss.routes"));
-const sprite_routes_1 = require("./sprite.routes");
+const sprite_routes_1 = require("./sprite/sprite.routes");
 const system_routes_1 = __importDefault(require("./system.routes"));
 const task_routes_1 = __importDefault(require("./task.routes"));
 const api_client_1 = require("./api-client");
 const nginx_routes_1 = require("./nginx.routes");
 const svn_routes_1 = __importDefault(require("./svn.routes"));
-const sprite_browse_routes_1 = __importDefault(require("./sprite-browse.routes"));
+const sprite_browse_routes_1 = __importDefault(require("./sprite/sprite-browse.routes"));
 const static_files_routes_1 = __importDefault(require("./static-files.routes"));
 const hub_routes_1 = __importDefault(require("./hub.routes"));
+const node_runtime_routes_1 = __importDefault(require("./node-runtime.routes"));
 const node_version_routes_1 = __importDefault(require("./node-version.routes"));
 async function routes(fastify) {
     await fastify.register(system_routes_1.default);
@@ -29,8 +30,8 @@ async function routes(fastify) {
     await fastify.register(config_routes_1.default, { prefix: '/api/config' });
     await fastify.register(dashboard_routes_1.default, { prefix: '/api/dashboard' });
     await fastify.register(rss_routes_1.default, { prefix: '/api/rss' });
-    await fastify.register(sprite_routes_1.spriteRoutes, { prefix: '/api/sprite' });
     await fastify.register(svn_routes_1.default, { prefix: '/api/svn' });
+    await fastify.register(sprite_routes_1.spriteRoutes, { prefix: '/api/sprite' });
     await fastify.register(sprite_browse_routes_1.default, { prefix: '/api/sprite/browse' });
     await fastify.register(static_files_routes_1.default, { prefix: '/api/static' });
     await fastify.register(hub_routes_1.default, { prefix: '/api/hub' });
@@ -42,4 +43,5 @@ async function routes(fastify) {
     await fastify.register(api_client_1.apiClientHubTokenRoutes, { prefix: '/api/client/hub-token' });
     await fastify.register(nginx_routes_1.nginxRoutes, { prefix: '/api/nginx' });
     await fastify.register(node_version_routes_1.default, { prefix: '/api/node-version' });
+    await fastify.register(node_runtime_routes_1.default, { prefix: '/api/node-runtimes' });
 }

package/lib/routes/nginx/nginx-config.routes.js

@@ -9,7 +9,7 @@ function registerNginxConfigRoutes(context) {
             const config = await nginx.config.readMainConfig();
             return reply.send({
                 success: true,
-                config,
+                config: (0, nginx_route_context_1.toNginxConfigDto)(config),
             });
         }
         catch (error) {
@@ -31,7 +31,7 @@ function registerNginxConfigRoutes(context) {
     fastify.post('/config/validate', async (request, reply) => {
         const { content } = request.body;
         const result = await nginx.config.validateConfig(content);
-        return reply.send(result);
+        return reply.send((0, nginx_route_context_1.toNginxConfigValidationDto)(result));
     });
     fastify.get('/config/files', async (_request, reply) => {
         try {
@@ -53,7 +53,7 @@ function registerNginxConfigRoutes(context) {
             if (isMainConfig) {
                 return reply.send({
                     success: true,
-                    config: mainConfig,
+                    config: (0, nginx_route_context_1.toNginxConfigDto)(mainConfig),
                 });
             }
             const content = await nginx.config.readConfigFile(filePath);

package/lib/routes/nginx/nginx-lifecycle.routes.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerNginxLifecycleRoutes = registerNginxLifecycleRoutes;
-const nginx_binding_store_1 = require("../../plugins/nginx.binding.store");
+const core_1 = require("@yinuo-ngm/core");
+const env_1 = require("../../env");
 const nginx_route_context_1 = require("./nginx-route.context");
 function registerNginxLifecycleRoutes(context) {
     const { fastify, nginx } = context;
@@ -9,8 +10,8 @@ function registerNginxLifecycleRoutes(context) {
         const instance = nginx.service.getInstance();
         const status = await nginx.service.getStatus();
         return reply.send({
-            instance,
-            status,
+            instance: (0, nginx_route_context_1.toNginxInstanceDto)(instance),
+            status: (0, nginx_route_context_1.toNginxStatusDto)(status),
         });
     });
     fastify.get('/stats', async (_request, reply) => {
@@ -18,11 +19,11 @@ function registerNginxLifecycleRoutes(context) {
             const instance = nginx.service.getInstance();
             const status = await nginx.service.getStatus();
             const servers = await nginx.server.getAllServers();
-            const enabled = servers.filter(item => item.enabled).length;
+            const enabled = servers.filter((item) => item.enabled).length;
             return reply.send({
                 success: true,
-                instance,
-                status,
+                instance: (0, nginx_route_context_1.toNginxInstanceDto)(instance),
+                status: (0, nginx_route_context_1.toNginxStatusDto)(status),
                 serverSummary: {
                     total: servers.length,
                     enabled,
@@ -39,14 +40,14 @@ function registerNginxLifecycleRoutes(context) {
         try {
             const instance = await nginx.service.bind(path);
             try {
-                await (0, nginx_binding_store_1.savePersistedNginxPath)(instance.path);
+                await (0, core_1.savePersistedNginxPath)(env_1.env.dataDir, instance.path);
             }
             catch (persistError) {
                 fastify.log.warn(`[nginx] binding persisted failed: ${String(persistError)}`);
             }
             return reply.send({
                 success: true,
-                instance,
+                instance: (0, nginx_route_context_1.toNginxInstanceDto)(instance) ?? undefined,
             });
         }
         catch (error) {
@@ -56,7 +57,7 @@ function registerNginxLifecycleRoutes(context) {
     fastify.post('/unbind', async (_request, reply) => {
         nginx.service.unbind();
         try {
-            await (0, nginx_binding_store_1.clearPersistedNginxPath)();
+            await (0, core_1.clearPersistedNginxPath)(env_1.env.dataDir);
         }
         catch (error) {
             fastify.log.warn(`[nginx] clear persisted binding failed: ${String(error)}`);
@@ -67,7 +68,7 @@ function registerNginxLifecycleRoutes(context) {
     });
     fastify.get('/local-ip', async (_request, reply) => {
         const result = await nginx.service.getLocalIp();
-        return reply.send(result);
+        return reply.send((0, nginx_route_context_1.toNginxCommandResultDto)(result));
     });
     fastify.post('/start', async (_request, reply) => {
         const result = await nginx.service.start();
@@ -77,7 +78,7 @@ function registerNginxLifecycleRoutes(context) {
         else {
             fastify.core.sysLog.error({ scope: 'system', source: 'server', text: `[Nginx] 启动失败: ${result.error || '未知错误'}` });
         }
-        return reply.send(result);
+        return reply.send((0, nginx_route_context_1.toNginxCommandResultDto)(result));
     });
     fastify.post('/stop', async (_request, reply) => {
         const result = await nginx.service.stop();
@@ -87,7 +88,7 @@ function registerNginxLifecycleRoutes(context) {
         else {
             fastify.core.sysLog.error({ scope: 'system', source: 'server', text: `[Nginx] 停止失败: ${result.error || '未知错误'}` });
         }
-        return reply.send(result);
+        return reply.send((0, nginx_route_context_1.toNginxCommandResultDto)(result));
     });
     fastify.post('/reload', async (_request, reply) => {
         const result = await nginx.service.reload();
@@ -107,6 +108,6 @@ function registerNginxLifecycleRoutes(context) {
         else {
             fastify.core.sysLog.error({ scope: 'system', source: 'server', text: `[Nginx] 配置检测失败: ${(result.errors || []).join(', ')}` });
         }
-        return reply.send(result);
+        return reply.send((0, nginx_route_context_1.toNginxConfigValidationDto)(result));
     });
 }

package/lib/routes/nginx/nginx-module.routes.js

@@ -9,7 +9,7 @@ function registerNginxModuleRoutes(context) {
             const upstreams = await nginx.module.getUpstreams();
             return reply.send({
                 success: true,
-                upstreams,
+                upstreams: upstreams.map(nginx_route_context_1.toNginxUpstreamDto),
             });
         }
         catch (error) {
@@ -32,7 +32,7 @@ function registerNginxModuleRoutes(context) {
             const certificates = await nginx.module.getSslCertificates();
             return reply.send({
                 success: true,
-                certificates,
+                certificates: certificates.map(nginx_route_context_1.toNginxSslCertificateDto),
             });
         }
         catch (error) {
@@ -55,7 +55,7 @@ function registerNginxModuleRoutes(context) {
             const traffic = await nginx.module.getTrafficConfig();
             return reply.send({
                 success: true,
-                traffic,
+                traffic: (0, nginx_route_context_1.toNginxTrafficConfigDto)(traffic),
             });
         }
         catch (error) {
@@ -78,7 +78,7 @@ function registerNginxModuleRoutes(context) {
             const performance = await nginx.module.getPerformanceConfig();
             return reply.send({
                 success: true,
-                performance,
+                performance: (0, nginx_route_context_1.toNginxPerformanceConfigDto)(performance),
             });
         }
         catch (error) {
@@ -101,7 +101,7 @@ function registerNginxModuleRoutes(context) {
             const settings = await nginx.module.getModuleSettings();
             return reply.send({
                 success: true,
-                settings,
+                settings: (0, nginx_route_context_1.toNginxModuleSettingsDto)(settings),
             });
         }
         catch (error) {
@@ -113,7 +113,7 @@ function registerNginxModuleRoutes(context) {
             const settings = await nginx.module.saveModuleSettings(request.body || {});
             return reply.send({
                 success: true,
-                settings,
+                settings: (0, nginx_route_context_1.toNginxModuleSettingsDto)(settings),
             });
         }
         catch (error) {

package/lib/routes/nginx/nginx-route.context.d.ts

@@ -1,9 +1,24 @@
 import type { FastifyInstance, FastifyReply } from 'fastify';
+import type { NginxApp } from '@yinuo-ngm/nginx';
+import type { NginxCommandResultDto, NginxConfigDto, NginxConfigValidationDto, NginxInstanceDto, NginxLocationDto, NginxModuleSettingsDto, NginxPerformanceConfigDto, NginxServerDto, NginxSslCertificateDto, NginxStatusDto, NginxTrafficConfigDto, NginxUpstreamDto } from '@yinuo-ngm/protocol';
+import type { NginxCommandResult, NginxConfig, NginxConfigValidation, NginxInstance, NginxLocation, NginxModuleSettings, NginxPerformanceConfig, NginxServer, NginxSslCertificate, NginxStatus, NginxTrafficConfig, NginxUpstream } from '@yinuo-ngm/nginx';
 export interface NginxRouteContext {
     fastify: FastifyInstance;
-    nginx: FastifyInstance['nginx'];
+    nginx: NginxApp;
     normalizeFsPath: (filePath: string) => string;
     ensureManageableConfigFile: (rawPath?: string) => Promise<string>;
 }
 export declare function createNginxRouteContext(fastify: FastifyInstance): NginxRouteContext;
 export declare function sendBadRequest(reply: FastifyReply, error: unknown): void;
+export declare function toNginxInstanceDto(instance: NginxInstance | null | undefined): NginxInstanceDto | null;
+export declare function toNginxStatusDto(status: NginxStatus): NginxStatusDto;
+export declare function toNginxConfigDto(config: NginxConfig): NginxConfigDto;
+export declare function toNginxLocationDto(location: NginxLocation): NginxLocationDto;
+export declare function toNginxServerDto(server: NginxServer): NginxServerDto;
+export declare function toNginxCommandResultDto(result: NginxCommandResult): NginxCommandResultDto;
+export declare function toNginxConfigValidationDto(result: NginxConfigValidation): NginxConfigValidationDto;
+export declare function toNginxUpstreamDto(upstream: NginxUpstream): NginxUpstreamDto;
+export declare function toNginxSslCertificateDto(certificate: NginxSslCertificate): NginxSslCertificateDto;
+export declare function toNginxTrafficConfigDto(config: NginxTrafficConfig): NginxTrafficConfigDto;
+export declare function toNginxPerformanceConfigDto(config: NginxPerformanceConfig): NginxPerformanceConfigDto;
+export declare function toNginxModuleSettingsDto(settings: NginxModuleSettings): NginxModuleSettingsDto;

package/lib/routes/nginx/nginx-route.context.js

@@ -2,11 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createNginxRouteContext = createNginxRouteContext;
 exports.sendBadRequest = sendBadRequest;
+exports.toNginxInstanceDto = toNginxInstanceDto;
+exports.toNginxStatusDto = toNginxStatusDto;
+exports.toNginxConfigDto = toNginxConfigDto;
+exports.toNginxLocationDto = toNginxLocationDto;
+exports.toNginxServerDto = toNginxServerDto;
+exports.toNginxCommandResultDto = toNginxCommandResultDto;
+exports.toNginxConfigValidationDto = toNginxConfigValidationDto;
+exports.toNginxUpstreamDto = toNginxUpstreamDto;
+exports.toNginxSslCertificateDto = toNginxSslCertificateDto;
+exports.toNginxTrafficConfigDto = toNginxTrafficConfigDto;
+exports.toNginxPerformanceConfigDto = toNginxPerformanceConfigDto;
+exports.toNginxModuleSettingsDto = toNginxModuleSettingsDto;
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 const errors_1 = require("@yinuo-ngm/errors");
 function createNginxRouteContext(fastify) {
-    const nginx = fastify.nginx;
+    const nginx = fastify.core.nginx;
     const normalizeFsPath = (filePath) => (0, path_1.resolve)(filePath).replace(/\\/g, '/').toLowerCase();
     const ensureManageableConfigFile = async (rawPath) => {
         const filePath = rawPath?.trim();
@@ -50,3 +62,126 @@ function sendBadRequest(reply, error) {
         method: reply.request?.method,
     });
 }
+function toNginxInstanceDto(instance) {
+    if (!instance)
+        return null;
+    return {
+        path: instance.path,
+        version: instance.version,
+        configPath: instance.configPath,
+        prefixPath: instance.prefixPath,
+        isBound: instance.isBound,
+    };
+}
+function toNginxStatusDto(status) {
+    return {
+        isRunning: status.isRunning,
+        pid: status.pid,
+        uptime: status.uptime,
+        activeConnections: status.activeConnections,
+        workerProcesses: status.workerProcesses,
+    };
+}
+function toNginxConfigDto(config) {
+    return {
+        mainConfigPath: config.mainConfigPath,
+        content: config.content,
+        isWritable: config.isWritable,
+    };
+}
+function toNginxLocationDto(location) {
+    return {
+        path: location.path,
+        proxyPass: location.proxyPass,
+        root: location.root,
+        index: location.index,
+        tryFiles: location.tryFiles,
+        rawConfig: location.rawConfig,
+    };
+}
+function toNginxServerDto(server) {
+    return {
+        id: server.id,
+        name: server.name,
+        listen: server.listen,
+        domains: server.domains,
+        root: server.root,
+        index: server.index,
+        locations: (server.locations ?? []).map(toNginxLocationDto),
+        ssl: server.ssl,
+        sslCert: server.sslCert,
+        sslKey: server.sslKey,
+        enabled: server.enabled,
+        extraConfig: server.extraConfig,
+        configText: server.configText,
+        filePath: server.filePath,
+        createdAt: server.createdAt,
+        updatedAt: server.updatedAt,
+        createdBy: server.createdBy,
+        runtimeStatus: server.runtimeStatus,
+    };
+}
+function toNginxCommandResultDto(result) {
+    return {
+        success: result.success,
+        output: result.output,
+        error: result.error,
+        exitCode: result.exitCode,
+    };
+}
+function toNginxConfigValidationDto(result) {
+    return {
+        valid: result.valid,
+        errors: result.errors,
+        warnings: result.warnings,
+    };
+}
+function toNginxUpstreamDto(upstream) {
+    return {
+        id: upstream.id,
+        name: upstream.name,
+        strategy: upstream.strategy,
+        nodes: upstream.nodes,
+        sourceFile: upstream.sourceFile,
+        managed: upstream.managed,
+        readonly: upstream.readonly,
+        health: upstream.health,
+        healthy: upstream.healthy,
+    };
+}
+function toNginxSslCertificateDto(certificate) {
+    return {
+        id: certificate.id,
+        domain: certificate.domain,
+        certPath: certificate.certPath,
+        keyPath: certificate.keyPath,
+        expireAt: certificate.expireAt,
+        status: certificate.status,
+        autoRenew: certificate.autoRenew,
+    };
+}
+function toNginxTrafficConfigDto(config) {
+    return {
+        rateLimitEnabled: config.rateLimitEnabled,
+        rateLimit: config.rateLimit,
+        connLimitEnabled: config.connLimitEnabled,
+        connLimit: config.connLimit,
+        blacklistIps: config.blacklistIps,
+    };
+}
+function toNginxPerformanceConfigDto(config) {
+    return {
+        gzipEnabled: config.gzipEnabled,
+        gzipTypes: config.gzipTypes,
+        keepaliveTimeout: config.keepaliveTimeout,
+        workerProcesses: config.workerProcesses,
+        sendfile: config.sendfile,
+        tcpNopush: config.tcpNopush,
+    };
+}
+function toNginxModuleSettingsDto(settings) {
+    return {
+        backupRetention: settings.backupRetention,
+        configBackupRetention: settings.configBackupRetention,
+    };
+}

package/lib/routes/nginx/nginx-server.routes.js

@@ -74,7 +74,7 @@ function registerNginxServerRoutes(context) {
             }));
             return reply.send({
                 success: true,
-                servers: enriched,
+                servers: enriched.map(nginx_route_context_1.toNginxServerDto),
             });
         }
         catch (error) {
@@ -104,7 +104,7 @@ function registerNginxServerRoutes(context) {
             };
             return reply.send({
                 success: true,
-                server: enriched,
+                server: (0, nginx_route_context_1.toNginxServerDto)(enriched),
             });
         }
         catch (error) {
@@ -120,7 +120,7 @@ function registerNginxServerRoutes(context) {
             const server = await nginx.server.createServer(payload);
             return reply.send({
                 success: true,
-                server,
+                server: (0, nginx_route_context_1.toNginxServerDto)(server),
             });
         }
         catch (error) {
@@ -133,7 +133,7 @@ function registerNginxServerRoutes(context) {
             const server = await nginx.server.updateServer(id, request.body);
             return reply.send({
                 success: true,
-                server,
+                server: (0, nginx_route_context_1.toNginxServerDto)(server),
             });
         }
         catch (error) {
@@ -162,7 +162,7 @@ function registerNginxServerRoutes(context) {
             const server = await nginx.server.restoreDeletedServer(snapshotId);
             return reply.send({
                 success: true,
-                server,
+                server: (0, nginx_route_context_1.toNginxServerDto)(server),
             });
         }
         catch (error) {

package/lib/routes/node-runtime.routes.d.ts

@@ -0,0 +1,2 @@
+import type { FastifyInstance } from "fastify";
+export default function nodeRuntimeRoutes(fastify: FastifyInstance): Promise<void>;