nsgm-cli 2.1.21 → 2.1.23

package/lib/server/debug/dataloader-debug.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataLoaderDebugSchema = exports.dataLoaderStatsResolver = void 0;
+exports.createDataLoaderDebugRoutes = createDataLoaderDebugRoutes;
+const dataloader_monitor_1 = require("../utils/dataloader-monitor");
+/**
+ * DataLoader 调试和监控 API
+ * 在开发环境中提供 DataLoader 性能监控接口
+ */
+/**
+ * 获取 DataLoader 统计信息的 GraphQL resolver
+ */
+exports.dataLoaderStatsResolver = {
+    // 查询 DataLoader 统计信息
+    dataLoaderStats: async (_, context) => {
+        try {
+            const health = (0, dataloader_monitor_1.getDataLoaderHealth)(context);
+            const allStats = dataloader_monitor_1.DataLoaderMonitor.getAllStats();
+            return {
+                status: health.status,
+                score: health.score,
+                summary: allStats.summary,
+                loaders: health.loaders,
+                recommendations: health.recommendations,
+                contextStats: health.contextStats,
+                timestamp: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            console.error("获取 DataLoader 统计信息失败:", error);
+            throw error;
+        }
+    },
+    // 重置 DataLoader 统计信息
+    resetDataLoaderStats: async () => {
+        try {
+            dataloader_monitor_1.DataLoaderMonitor.resetStats();
+            return {
+                success: true,
+                message: "DataLoader 统计信息已重置",
+                timestamp: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            console.error("重置 DataLoader 统计信息失败:", error);
+            throw error;
+        }
+    },
+    // 清除 DataLoader 缓存
+    clearDataLoaderCache: async (_, context) => {
+        try {
+            if (context?.dataloaders?.template) {
+                context.dataloaders.template.clearAll();
+            }
+            return {
+                success: true,
+                message: "DataLoader 缓存已清除",
+                timestamp: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            console.error("清除 DataLoader 缓存失败:", error);
+            throw error;
+        }
+    },
+};
+/**
+ * DataLoader 调试 Schema
+ */
+exports.dataLoaderDebugSchema = {
+    query: `
+    dataLoaderStats: DataLoaderStatsResult
+  `,
+    mutation: `
+    resetDataLoaderStats: DataLoaderActionResult
+    clearDataLoaderCache: DataLoaderActionResult
+  `,
+    type: `
+    type DataLoaderStatsResult {
+      status: String
+      score: Int
+      summary: DataLoaderSummary
+      loaders: [DataLoaderEfficiency]
+      recommendations: [String]
+      contextStats: DataLoaderContextStats
+      timestamp: String
+    }
+    
+    type DataLoaderSummary {
+      totalLoaders: Int
+      totalRequests: Int
+      totalBatchRequests: Int
+      totalCacheHits: Int
+      totalCacheMisses: Int
+    }
+    
+    type DataLoaderEfficiency {
+      loader: String
+      hitRate: String
+      batchEfficiency: String
+      averageBatchSize: String
+      totalRequests: Int
+      lastActivity: String
+    }
+    
+    type DataLoaderContextStats {
+      template: DataLoaderCacheInfo
+      timestamp: String
+    }
+    
+    type DataLoaderCacheInfo {
+      byId: DataLoaderCacheDetail
+      byName: DataLoaderCacheDetail
+      searchByName: DataLoaderCacheDetail
+    }
+    
+    type DataLoaderCacheDetail {
+      cacheMap: Int
+      name: String
+    }
+    
+    type DataLoaderActionResult {
+      success: Boolean
+      message: String
+      timestamp: String
+    }
+  `,
+};
+/**
+ * Express 路由：DataLoader 调试接口
+ */
+function createDataLoaderDebugRoutes(app) {
+    // 仅在开发环境中启用调试接口
+    if (process.env.NODE_ENV === "development") {
+        // 获取 DataLoader 统计信息
+        app.get("/debug/dataloader/stats", (_req, res) => {
+            try {
+                const health = (0, dataloader_monitor_1.getDataLoaderHealth)();
+                const allStats = dataloader_monitor_1.DataLoaderMonitor.getAllStats();
+                res.json({
+                    health,
+                    stats: allStats,
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: "Failed to get DataLoader stats",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        // 重置统计信息
+        app.post("/debug/dataloader/reset", (_req, res) => {
+            try {
+                dataloader_monitor_1.DataLoaderMonitor.resetStats();
+                res.json({
+                    success: true,
+                    message: "DataLoader stats reset successfully",
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: "Failed to reset DataLoader stats",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        // 打印性能报告
+        app.post("/debug/dataloader/report", (_req, res) => {
+            try {
+                dataloader_monitor_1.DataLoaderMonitor.printPerformanceReport();
+                res.json({
+                    success: true,
+                    message: "Performance report printed to console",
+                    timestamp: new Date().toISOString(),
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: "Failed to print performance report",
+                    message: error instanceof Error ? error.message : String(error),
+                });
+            }
+        });
+        console.log("🔧 DataLoader 调试接口已启用:");
+        console.log("  GET  /debug/dataloader/stats  - 获取统计信息");
+        console.log("  POST /debug/dataloader/reset  - 重置统计信息");
+        console.log("  POST /debug/dataloader/report - 打印性能报告");
+    }
+}

package/lib/server/graphql.js

@@ -9,6 +9,7 @@ const fs_1 = __importDefault(require("fs"));
 const lodash_1 = __importDefault(require("lodash"));
 const path_1 = require("path");
 const date_1 = __importDefault(require("./plugins/date"));
+const dataloaders_1 = require("./dataloaders");
 // 缓存已生成的 schema 和 resolvers
 let cachedSchema = null;
 let cachedResolvers = null;
@@ -177,6 +178,14 @@ const handler = (command) => {
     return (0, express_1.createHandler)({
         schema: (0, graphql_1.buildSchema)(schemaStr),
         rootValue: resolversV,
+        // 为每个请求创建新的 DataLoader 上下文，确保请求隔离和缓存正确性
+        context: (_req, _params) => {
+            const context = (0, dataloaders_1.createDataLoaderContext)();
+            if (command === "dev") {
+                console.log("🚀 GraphQL DataLoader 上下文已创建");
+            }
+            return context;
+        },
     });
 };
 exports.default = handler;

package/lib/server/utils/dataloader-monitor.d.ts

@@ -0,0 +1,87 @@
+import { DataLoaderContext } from "../dataloaders";
+/**
+ * DataLoader 性能监控和调试工具
+ */
+export declare class DataLoaderMonitor {
+    private static requestStats;
+    /**
+     * 记录 DataLoader 请求统计
+     */
+    static recordRequest(loaderName: string, isBatch: boolean, batchSize?: number): void;
+    /**
+     * 记录缓存命中/未命中
+     */
+    static recordCacheResult(loaderName: string, isHit: boolean): void;
+    /**
+     * 获取所有 DataLoader 统计信息
+     */
+    static getAllStats(): {
+        summary: {
+            totalLoaders: number;
+            totalRequests: number;
+            totalBatchRequests: number;
+            totalCacheHits: number;
+            totalCacheMisses: number;
+        };
+        loaders: {
+            [k: string]: {
+                totalRequests: number;
+                batchRequests: number;
+                cacheHits: number;
+                cacheMisses: number;
+                averageBatchSize: number;
+                lastActivity: Date;
+            };
+        };
+        generatedAt: string;
+    };
+    /**
+     * 获取 DataLoader 缓存效率报告
+     */
+    static getCacheEfficiencyReport(): any[];
+    /**
+     * 重置统计信息
+     */
+    static resetStats(): void;
+    /**
+     * 打印性能报告到控制台
+     */
+    static printPerformanceReport(): void;
+}
+/**
+ * 创建 DataLoader 性能中间件
+ */
+export declare function createDataLoaderPerformanceMiddleware(): (req: any, res: any, next: any) => void;
+/**
+ * 获取 DataLoader 健康状态
+ */
+export declare function getDataLoaderHealth(context?: DataLoaderContext): {
+    status: string;
+    score: number;
+    summary: {
+        totalLoaders: number;
+        totalRequests: number;
+        totalBatchRequests: number;
+        totalCacheHits: number;
+        totalCacheMisses: number;
+    };
+    loaders: any[];
+    recommendations: string[];
+    contextStats: {
+        template: {
+            byId: {
+                cacheMap: any;
+                name: string;
+            };
+            byName: {
+                cacheMap: any;
+                name: string;
+            };
+            searchByName: {
+                cacheMap: any;
+                name: string;
+            };
+        };
+        timestamp: string;
+    } | null;
+};

package/lib/server/utils/dataloader-monitor.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataLoaderMonitor = void 0;
+exports.createDataLoaderPerformanceMiddleware = createDataLoaderPerformanceMiddleware;
+exports.getDataLoaderHealth = getDataLoaderHealth;
+const dataloaders_1 = require("../dataloaders");
+/**
+ * DataLoader 性能监控和调试工具
+ */
+class DataLoaderMonitor {
+    /**
+     * 记录 DataLoader 请求统计
+     */
+    static recordRequest(loaderName, isBatch, batchSize) {
+        const stats = this.requestStats.get(loaderName) || {
+            totalRequests: 0,
+            batchRequests: 0,
+            cacheHits: 0,
+            cacheMisses: 0,
+            averageBatchSize: 0,
+            lastActivity: new Date(),
+        };
+        stats.totalRequests++;
+        if (isBatch) {
+            stats.batchRequests++;
+            if (batchSize) {
+                stats.averageBatchSize = (stats.averageBatchSize + batchSize) / 2;
+            }
+        }
+        stats.lastActivity = new Date();
+        this.requestStats.set(loaderName, stats);
+    }
+    /**
+     * 记录缓存命中/未命中
+     */
+    static recordCacheResult(loaderName, isHit) {
+        const stats = this.requestStats.get(loaderName);
+        if (stats) {
+            if (isHit) {
+                stats.cacheHits++;
+            }
+            else {
+                stats.cacheMisses++;
+            }
+            this.requestStats.set(loaderName, stats);
+        }
+    }
+    /**
+     * 获取所有 DataLoader 统计信息
+     */
+    static getAllStats() {
+        const stats = Object.fromEntries(this.requestStats);
+        return {
+            summary: {
+                totalLoaders: this.requestStats.size,
+                totalRequests: Array.from(this.requestStats.values()).reduce((sum, stat) => sum + stat.totalRequests, 0),
+                totalBatchRequests: Array.from(this.requestStats.values()).reduce((sum, stat) => sum + stat.batchRequests, 0),
+                totalCacheHits: Array.from(this.requestStats.values()).reduce((sum, stat) => sum + stat.cacheHits, 0),
+                totalCacheMisses: Array.from(this.requestStats.values()).reduce((sum, stat) => sum + stat.cacheMisses, 0),
+            },
+            loaders: stats,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    /**
+     * 获取 DataLoader 缓存效率报告
+     */
+    static getCacheEfficiencyReport() {
+        const report = [];
+        this.requestStats.forEach((stats, loaderName) => {
+            const totalCacheRequests = stats.cacheHits + stats.cacheMisses;
+            const hitRate = totalCacheRequests > 0 ? (stats.cacheHits / totalCacheRequests) * 100 : 0;
+            const batchEfficiency = stats.totalRequests > 0 ? (stats.batchRequests / stats.totalRequests) * 100 : 0;
+            report.push({
+                loader: loaderName,
+                hitRate: `${hitRate.toFixed(2)}%`,
+                batchEfficiency: `${batchEfficiency.toFixed(2)}%`,
+                averageBatchSize: stats.averageBatchSize.toFixed(2),
+                totalRequests: stats.totalRequests,
+                lastActivity: stats.lastActivity.toISOString(),
+            });
+        });
+        return report.sort((a, b) => b.totalRequests - a.totalRequests);
+    }
+    /**
+     * 重置统计信息
+     */
+    static resetStats() {
+        this.requestStats.clear();
+        console.log("📊 DataLoader 统计信息已重置");
+    }
+    /**
+     * 打印性能报告到控制台
+     */
+    static printPerformanceReport() {
+        const stats = this.getAllStats();
+        const efficiency = this.getCacheEfficiencyReport();
+        console.log("\n📊 DataLoader 性能报告");
+        console.log("========================");
+        console.log(`总加载器数量: ${stats.summary.totalLoaders}`);
+        console.log(`总请求数: ${stats.summary.totalRequests}`);
+        console.log(`批量请求数: ${stats.summary.totalBatchRequests}`);
+        console.log(`缓存命中数: ${stats.summary.totalCacheHits}`);
+        console.log(`缓存未命中数: ${stats.summary.totalCacheMisses}`);
+        if (stats.summary.totalCacheHits + stats.summary.totalCacheMisses > 0) {
+            const overallHitRate = ((stats.summary.totalCacheHits / (stats.summary.totalCacheHits + stats.summary.totalCacheMisses)) *
+                100).toFixed(2);
+            console.log(`总体缓存命中率: ${overallHitRate}%`);
+        }
+        console.log("\n各加载器效率:");
+        efficiency.forEach((loader) => {
+            console.log(`  ${loader.loader}:`);
+            console.log(`    缓存命中率: ${loader.hitRate}`);
+            console.log(`    批量效率: ${loader.batchEfficiency}`);
+            console.log(`    平均批量大小: ${loader.averageBatchSize}`);
+            console.log(`    总请求数: ${loader.totalRequests}`);
+        });
+        console.log("========================\n");
+    }
+}
+exports.DataLoaderMonitor = DataLoaderMonitor;
+DataLoaderMonitor.requestStats = new Map();
+/**
+ * 创建 DataLoader 性能中间件
+ */
+function createDataLoaderPerformanceMiddleware() {
+    return (req, res, next) => {
+        const startTime = Date.now();
+        // 在响应结束时记录性能数据
+        res.on("finish", () => {
+            const duration = Date.now() - startTime;
+            if (req.body?.query) {
+                const isQuery = req.body.query.trim().toLowerCase().startsWith("query");
+                const isMutation = req.body.query.trim().toLowerCase().startsWith("mutation");
+                if (isQuery || isMutation) {
+                    console.log(`🚀 GraphQL ${isQuery ? "Query" : "Mutation"} 执行时间: ${duration}ms`);
+                    // 每10个请求打印一次性能报告
+                    if (Math.random() < 0.1) {
+                        DataLoaderMonitor.printPerformanceReport();
+                    }
+                }
+            }
+        });
+        next();
+    };
+}
+/**
+ * 获取 DataLoader 健康状态
+ */
+function getDataLoaderHealth(context) {
+    const stats = DataLoaderMonitor.getAllStats();
+    const efficiency = DataLoaderMonitor.getCacheEfficiencyReport();
+    // 计算健康分数
+    let healthScore = 100;
+    efficiency.forEach((loader) => {
+        const hitRate = parseFloat(loader.hitRate);
+        const batchEfficiency = parseFloat(loader.batchEfficiency);
+        // 缓存命中率低于50%扣分
+        if (hitRate < 50) {
+            healthScore -= 10;
+        }
+        // 批量效率低于30%扣分
+        if (batchEfficiency < 30) {
+            healthScore -= 15;
+        }
+    });
+    const status = healthScore >= 80 ? "healthy" : healthScore >= 60 ? "warning" : "critical";
+    return {
+        status,
+        score: Math.max(0, healthScore),
+        summary: stats.summary,
+        loaders: efficiency,
+        recommendations: generateRecommendations(efficiency),
+        contextStats: context ? (0, dataloaders_1.getDataLoaderStats)(context) : null,
+    };
+}
+/**
+ * 生成性能优化建议
+ */
+function generateRecommendations(efficiency) {
+    const recommendations = [];
+    efficiency.forEach((loader) => {
+        const hitRate = parseFloat(loader.hitRate);
+        const batchEfficiency = parseFloat(loader.batchEfficiency);
+        if (hitRate < 50) {
+            recommendations.push(`${loader.loader}: 考虑增加缓存时间或优化查询模式以提高缓存命中率`);
+        }
+        if (batchEfficiency < 30) {
+            recommendations.push(`${loader.loader}: 考虑调整 batchScheduleFn 延迟时间以提高批量效率`);
+        }
+        if (parseFloat(loader.averageBatchSize) < 2) {
+            recommendations.push(`${loader.loader}: 批量大小较小，可能需要优化查询时机`);
+        }
+    });
+    if (recommendations.length === 0) {
+        recommendations.push("DataLoader 性能表现良好，无需优化");
+    }
+    return recommendations;
+}