nsgm-cli 2.1.21 → 2.1.23

package/lib/generators/resolver-generator.js

@@ -44,34 +44,58 @@ module.exports = {
         }
     },
 
-    // 根据ID获取${this.controller}
-    ${this.controller}Get: async ({ id }) => {
+    // 根据ID获取${this.controller} - 使用 DataLoader 优化
+    ${this.controller}Get: async ({ id }, context) => {
         try {
             const validId = validateId(id);
             
-            const sql = 'SELECT ${selectFields} FROM ${this.controller} WHERE id = ?';
-            const values = [validId];
-
-            console.log('根据ID查询${this.controller}:', { sql, values });
+            console.log('🚀 使用 DataLoader 根据ID查询${this.controller}:', { id: validId });
             
-            const results = await executeQuery(sql, values);
+            // 使用 DataLoader 批量加载，自动去重和缓存
+            const result = await context.dataloaders.${this.controller}.byId.load(validId);
             
-            if (results.length === 0) {
+            if (!result) {
                 throw new Error(\`ID为 \${validId} 的${this.controller}不存在\`);
             }
             
-            return results[0];
+            return result;
         } catch (error) {
             console.error('获取${this.controller}失败:', error.message);
             throw error;
         }
     },
 
-    // 搜索${this.controller}（分页）
-    ${this.controller}Search: async ({ page = 0, pageSize = 10, data = {} }) => {
+    // 批量获取${this.controller} - 新增方法，展示 DataLoader 批量能力
+    ${this.controller}BatchGet: async ({ ids }, context) => {
+        try {
+            if (!Array.isArray(ids) || ids.length === 0) {
+                throw new Error('ID列表不能为空');
+            }
+            
+            // 验证所有ID
+            const validIds = ids.map(id => validateId(id));
+            
+            console.log('🚀 使用 DataLoader 批量查询${this.controller}:', { ids: validIds });
+            
+            // DataLoader 自动批量处理，一次查询获取所有数据
+            const results = await context.dataloaders.${this.controller}.byId.loadMany(validIds);
+            
+            // 过滤掉 null 结果（未找到的记录）
+            return results.filter(result => result !== null && !(result instanceof Error));
+        } catch (error) {
+            console.error('批量获取${this.controller}失败:', error.message);
+            throw error;
+        }
+    },
+
+    // 搜索${this.controller}（分页）- 使用 DataLoader 优化搜索
+    ${this.controller}Search: async ({ page = 0, pageSize = 10, data = {} }, context) => {
         try {
             const { page: validPage, pageSize: validPageSize } = validatePagination(page, pageSize);
             
+            ${this.generateDataLoaderSearchLogic(searchableFields)}
+            
+            // 原始查询方式（作为备用）
             const values = [];
             const countValues = [];
             
@@ -83,7 +107,7 @@ ${searchConditions}
             
             values.push(validPageSize, validPage * validPageSize);
             
-            console.log('搜索${this.controller}:', { sql, values, countSql, countValues });
+            console.log('搜索${this.controller}（备用查询）:', { sql, values, countSql, countValues });
             
             return await executePaginatedQuery(sql, countSql, values, countValues);
         } catch (error) {
@@ -92,8 +116,8 @@ ${searchConditions}
         }
     },
 
-    // 添加${this.controller}
-    ${this.controller}Add: async ({ data }) => {
+    // 添加${this.controller} - 添加 DataLoader 缓存预加载
+    ${this.controller}Add: async ({ data }, context) => {
         try {
 ${this.generateNewValidationCalls(insertFields)}
             
@@ -103,7 +127,16 @@ ${this.generateNewValidationCalls(insertFields)}
             console.log('添加${this.controller}:', { sql, values });
             
             const results = await executeQuery(sql, values);
-            return results.insertId;
+            const insertId = results.insertId;
+            
+            // 预加载新数据到 DataLoader 缓存
+            if (insertId && context?.dataloaders?.${this.controller}) {
+                const newRecord = { id: insertId, ${this.generateNewRecordObject(insertFields)} };
+                context.dataloaders.${this.controller}.prime(insertId, newRecord);
+                console.log('🚀 新${this.controller}已预加载到 DataLoader 缓存:', newRecord);
+            }
+            
+            return insertId;
         } catch (error) {
             console.error('添加${this.controller}失败:', error.message);
             throw error;
@@ -129,7 +162,7 @@ ${this.generateBatchValidation(insertFields)}
             
             const placeholders = validatedDatas.map(() => '(${insertPlaceholders})').join(',');
             const sql = \`INSERT INTO ${this.controller} (${insertFieldNames}) VALUES \${placeholders}\`;
-            const values = validatedDatas.flatMap(data => [${this.generateBatchInsertValues(insertFields)}]);
+            const values = validatedDatas.flatMap(data => [${insertFields.map((f) => `data.${f.name}`).join(", ")}]);
             
             console.log('批量添加${this.controller}:', { sql, values });
             
@@ -141,8 +174,8 @@ ${this.generateBatchValidation(insertFields)}
         }
     },
 
-    // 更新${this.controller}
-    ${this.controller}Update: async ({ id, data }) => {
+    // 更新${this.controller} - 添加 DataLoader 缓存清理
+    ${this.controller}Update: async ({ id, data }, context) => {
         try {
             const validId = validateId(id);
             
@@ -163,6 +196,12 @@ ${this.generateUpdateValidation(insertFields)}
                 throw new Error(\`ID为 \${validId} 的${this.controller}不存在\`);
             }
             
+            // 清除 DataLoader 缓存，确保下次查询获取最新数据
+            if (context?.dataloaders?.${this.controller}) {
+                context.dataloaders.${this.controller}.clearById(validId);
+                console.log('🧹 已清除 DataLoader 缓存:', { id: validId });
+            }
+            
             return true;
         } catch (error) {
             console.error('更新${this.controller}失败:', error.message);
@@ -170,8 +209,8 @@ ${this.generateUpdateValidation(insertFields)}
         }
     },
 
-    // 删除${this.controller}
-    ${this.controller}Delete: async ({ id }) => {
+    // 删除${this.controller} - 添加 DataLoader 缓存清理
+    ${this.controller}Delete: async ({ id }, context) => {
         try {
             const validId = validateId(id);
             
@@ -186,6 +225,12 @@ ${this.generateUpdateValidation(insertFields)}
                 throw new Error(\`ID为 \${validId} 的${this.controller}不存在\`);
             }
             
+            // 清除 DataLoader 缓存
+            if (context?.dataloaders?.${this.controller}) {
+                context.dataloaders.${this.controller}.clearById(validId);
+                console.log('🧹 已清除 DataLoader 缓存:', { id: validId });
+            }
+            
             return true;
         } catch (error) {
             console.error('删除${this.controller}失败:', error.message);
@@ -193,8 +238,8 @@ ${this.generateUpdateValidation(insertFields)}
         }
     },
 
-    // 批量删除${this.controller}
-    ${this.controller}BatchDelete: async ({ ids }) => {
+    // 批量删除${this.controller} - 添加 DataLoader 缓存清理
+    ${this.controller}BatchDelete: async ({ ids }, context) => {
         try {
             if (!Array.isArray(ids) || ids.length === 0) {
                 throw new Error('批量删除的ID列表不能为空');
@@ -220,6 +265,14 @@ ${this.generateUpdateValidation(insertFields)}
                 throw new Error('没有找到要删除的${this.controller}');
             }
             
+            // 批量清除 DataLoader 缓存
+            if (context?.dataloaders?.${this.controller}) {
+                validIds.forEach(id => {
+                    context.dataloaders.${this.controller}.clearById(id);
+                });
+                console.log('🧹 已批量清除 DataLoader 缓存:', { ids: validIds });
+            }
+            
             return true;
         } catch (error) {
             console.error('批量删除${this.controller}失败:', error.message);
@@ -335,8 +388,48 @@ ${this.generateUpdateValidation(insertFields)}
         })
             .join(", ");
     }
-    generateBatchInsertValues(insertFields) {
-        return insertFields.map((f) => `data.${f.name}`).join(", ");
+    // private generateBatchInsertValues(insertFields: any[]): string {
+    //   return insertFields.map((f) => `data.${f.name}`).join(", ");
+    // }
+    generateDataLoaderSearchLogic(searchableFields) {
+        if (searchableFields.length === 0)
+            return "";
+        const nameField = searchableFields.find((f) => f.name === "name");
+        if (!nameField)
+            return "";
+        return `// 如果有名称搜索，尝试使用 DataLoader 搜索缓存
+            if (data.name && data.name.trim() !== '') {
+                console.log('🚀 使用 DataLoader 搜索${this.controller}:', { searchTerm: data.name.trim() });
+                
+                try {
+                    // 使用 DataLoader 进行搜索（这里会缓存搜索结果）
+                    const searchResults = await context.dataloaders.${this.controller}.searchByName.load(data.name.trim());
+                    
+                    // 手动分页处理
+                    const totalCounts = searchResults.length;
+                    const startIndex = validPage * validPageSize;
+                    const endIndex = startIndex + validPageSize;
+                    const items = searchResults.slice(startIndex, endIndex);
+                    
+                    return {
+                        totalCounts,
+                        items
+                    };
+                } catch (dataLoaderError) {
+                    console.warn('DataLoader 搜索失败，回退到直接查询:', dataLoaderError.message);
+                    // 如果 DataLoader 失败，回退到原始查询方式
+                }
+            }`;
+    }
+    generateNewRecordObject(insertFields) {
+        return insertFields
+            .map((f) => {
+            if (f.type === "integer") {
+                return `${f.name}: valid${f.name.charAt(0).toUpperCase() + f.name.slice(1)}`;
+            }
+            return `${f.name}: data.${f.name}`;
+        })
+            .join(", ");
     }
 }
 exports.ResolverGenerator = ResolverGenerator;

package/lib/generators/schema-generator.js

@@ -23,6 +23,7 @@ class SchemaGenerator extends base_generator_1.BaseGenerator {
     query: \`
         ${this.controller}(page: Int, pageSize: Int): ${pluralTypeName}
         ${this.controller}Get(id: Int): ${capitalizedTypeName}
+        ${this.controller}BatchGet(ids: [Int]): [${capitalizedTypeName}]
         ${this.controller}Search(page: Int, pageSize: Int, data: ${capitalizedTypeName}SearchInput): ${pluralTypeName}
     \`,
     mutation: \`

package/lib/index.js

@@ -19,7 +19,6 @@ const path_1 = __importDefault(require("path"));
 const body_parser_1 = __importDefault(require("body-parser"));
 const express_fileupload_1 = __importDefault(require("express-fileupload"));
 const graphql_1 = __importDefault(require("./server/graphql"));
-const config_1 = __importDefault(require("next/config"));
 const cors_1 = __importDefault(require("cors"));
 const express_session_1 = __importDefault(require("express-session"));
 const csrf_1 = require("./server/csrf");
@@ -121,9 +120,10 @@ const startExpress = (options, callback, command = "dev") => {
         server.use((0, express_fileupload_1.default)());
         server.use("/static", express_1.default.static(path_1.default.join(__dirname, "public")));
         server.use("/graphql", (0, graphql_1.default)(command));
-        const nextConfig = (0, config_1.default)();
-        const { publicRuntimeConfig } = nextConfig;
-        const { host, port, prefix } = publicRuntimeConfig;
+        // 从环境变量读取配置
+        const host = process.env.NEXT_PUBLIC_HOST || "localhost";
+        const port = process.env.NEXT_PUBLIC_PORT || "3000";
+        const prefix = process.env.NEXT_PUBLIC_PREFIX || "";
         // 提供 CSRF token 的端点
         server.get("/csrf-token", csrf_1.getCSRFToken);
         if (prefix !== "") {
@@ -148,7 +148,10 @@ const startExpress = (options, callback, command = "dev") => {
 };
 exports.startExpress = startExpress;
 // 使用新的 CLI 架构
-(0, cli_1.runCli)().catch((error) => {
-    console.error("CLI 执行失败:", error);
-    process.exit(1);
-});
+// 仅在非测试环境中执行 CLI
+if (process.env.NODE_ENV !== "test") {
+    (0, cli_1.runCli)().catch((error) => {
+        console.error("CLI 执行失败:", error);
+        process.exit(1);
+    });
+}

package/lib/server/dataloaders/index.d.ts

@@ -0,0 +1,38 @@
+import { TemplateDataLoader } from "./template-dataloader";
+/**
+ * DataLoader 上下文接口
+ */
+export interface DataLoaderContext extends Record<string, unknown> {
+    dataloaders: {
+        template: TemplateDataLoader;
+    };
+}
+/**
+ * 创建 DataLoader 上下文
+ * 每个 GraphQL 请求都会创建新的 DataLoader 实例，确保请求隔离
+ */
+export declare function createDataLoaderContext(): DataLoaderContext;
+/**
+ * DataLoader 统计信息
+ */
+export declare function getDataLoaderStats(context: DataLoaderContext): {
+    template: {
+        byId: {
+            cacheMap: any;
+            name: string;
+        };
+        byName: {
+            cacheMap: any;
+            name: string;
+        };
+        searchByName: {
+            cacheMap: any;
+            name: string;
+        };
+    };
+    timestamp: string;
+};
+/**
+ * 清除所有 DataLoader 缓存
+ */
+export declare function clearAllDataLoaderCache(context: DataLoaderContext): void;

package/lib/server/dataloaders/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDataLoaderContext = createDataLoaderContext;
+exports.getDataLoaderStats = getDataLoaderStats;
+exports.clearAllDataLoaderCache = clearAllDataLoaderCache;
+const template_dataloader_1 = require("./template-dataloader");
+/**
+ * 创建 DataLoader 上下文
+ * 每个 GraphQL 请求都会创建新的 DataLoader 实例，确保请求隔离
+ */
+function createDataLoaderContext() {
+    return {
+        dataloaders: {
+            template: (0, template_dataloader_1.createTemplateDataLoader)(),
+        },
+    };
+}
+/**
+ * DataLoader 统计信息
+ */
+function getDataLoaderStats(context) {
+    return {
+        template: context.dataloaders.template.getStats(),
+        timestamp: new Date().toISOString(),
+    };
+}
+/**
+ * 清除所有 DataLoader 缓存
+ */
+function clearAllDataLoaderCache(context) {
+    context.dataloaders.template.clearAll();
+    console.log("🧹 所有 DataLoader 缓存已清空");
+}

package/lib/server/dataloaders/template-dataloader.d.ts

@@ -0,0 +1,48 @@
+import DataLoader from "dataloader";
+/**
+ * Template DataLoader
+ * 针对 template 表的批量数据加载器，解决 N+1 查询问题
+ */
+export declare class TemplateDataLoader {
+    readonly byId: DataLoader<number, any>;
+    readonly byName: DataLoader<string, any>;
+    readonly searchByName: DataLoader<string, any[]>;
+    constructor();
+    /**
+     * 清除所有缓存
+     */
+    clearAll(): void;
+    /**
+     * 清除特定 ID 的缓存
+     */
+    clearById(id: number): void;
+    /**
+     * 清除特定名称的缓存
+     */
+    clearByName(name: string): void;
+    /**
+     * 预加载数据到缓存
+     */
+    prime(id: number, data: any): void;
+    /**
+     * 获取缓存统计信息
+     */
+    getStats(): {
+        byId: {
+            cacheMap: any;
+            name: string;
+        };
+        byName: {
+            cacheMap: any;
+            name: string;
+        };
+        searchByName: {
+            cacheMap: any;
+            name: string;
+        };
+    };
+}
+/**
+ * 创建 Template DataLoader 实例
+ */
+export declare function createTemplateDataLoader(): TemplateDataLoader;

package/lib/server/dataloaders/template-dataloader.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateDataLoader = void 0;
+exports.createTemplateDataLoader = createTemplateDataLoader;
+const dataloader_1 = __importDefault(require("dataloader"));
+const db_1 = __importDefault(require("../db"));
+/**
+ * Template DataLoader
+ * 针对 template 表的批量数据加载器，解决 N+1 查询问题
+ */
+class TemplateDataLoader {
+    constructor() {
+        // 按 ID 批量加载
+        this.byId = new dataloader_1.default(async (ids) => {
+            try {
+                console.log(`🔍 DataLoader: 批量加载 ${ids.length} 个 template by ID`);
+                const placeholders = ids.map(() => "?").join(",");
+                const sql = `SELECT id, name FROM template WHERE id IN (${placeholders})`;
+                const results = await db_1.default.executeQuery(sql, [...ids]);
+                // 确保返回顺序与输入 keys 一致，未找到的返回 null
+                return ids.map((id) => results.find((row) => row.id === id) || null);
+            }
+            catch (error) {
+                console.error("DataLoader byId 批量加载失败:", error);
+                throw error;
+            }
+        }, {
+            cache: true,
+            maxBatchSize: 100,
+            batchScheduleFn: (callback) => setTimeout(callback, 10), // 10ms 内的请求合并
+        });
+        // 按名称批量加载
+        this.byName = new dataloader_1.default(async (names) => {
+            try {
+                console.log(`🔍 DataLoader: 批量加载 ${names.length} 个 template by name`);
+                const placeholders = names.map(() => "?").join(",");
+                const sql = `SELECT id, name FROM template WHERE name IN (${placeholders})`;
+                const results = await db_1.default.executeQuery(sql, [...names]);
+                // 确保返回顺序与输入 keys 一致
+                return names.map((name) => results.find((row) => row.name === name) || null);
+            }
+            catch (error) {
+                console.error("DataLoader byName 批量加载失败:", error);
+                throw error;
+            }
+        }, {
+            cache: true,
+            maxBatchSize: 50,
+            batchScheduleFn: (callback) => setTimeout(callback, 10),
+        });
+        // 按名称模糊搜索（返回数组）
+        this.searchByName = new dataloader_1.default(async (searchTerms) => {
+            try {
+                console.log(`🔍 DataLoader: 批量搜索 ${searchTerms.length} 个关键词`);
+                // 对于搜索，我们需要为每个搜索词执行独立的查询
+                const results = await Promise.all(searchTerms.map(async (term) => {
+                    const sql = "SELECT id, name FROM template WHERE name LIKE ?";
+                    return db_1.default.executeQuery(sql, [`%${term}%`]);
+                }));
+                return results;
+            }
+            catch (error) {
+                console.error("DataLoader searchByName 批量搜索失败:", error);
+                throw error;
+            }
+        }, {
+            cache: true,
+            maxBatchSize: 20, // 搜索请求较少，降低批量大小
+            batchScheduleFn: (callback) => setTimeout(callback, 20), // 稍长的等待时间
+        });
+    }
+    /**
+     * 清除所有缓存
+     */
+    clearAll() {
+        this.byId.clearAll();
+        this.byName.clearAll();
+        this.searchByName.clearAll();
+        console.log("🧹 Template DataLoader 缓存已清空");
+    }
+    /**
+     * 清除特定 ID 的缓存
+     */
+    clearById(id) {
+        this.byId.clear(id);
+    }
+    /**
+     * 清除特定名称的缓存
+     */
+    clearByName(name) {
+        this.byName.clear(name);
+    }
+    /**
+     * 预加载数据到缓存
+     */
+    prime(id, data) {
+        this.byId.prime(id, data);
+        if (data?.name) {
+            this.byName.prime(data.name, data);
+        }
+    }
+    /**
+     * 获取缓存统计信息
+     */
+    getStats() {
+        return {
+            byId: {
+                cacheMap: this.byId.cacheMap?.size || 0,
+                name: "Template.byId",
+            },
+            byName: {
+                cacheMap: this.byName.cacheMap?.size || 0,
+                name: "Template.byName",
+            },
+            searchByName: {
+                cacheMap: this.searchByName.cacheMap?.size || 0,
+                name: "Template.searchByName",
+            },
+        };
+    }
+}
+exports.TemplateDataLoader = TemplateDataLoader;
+/**
+ * 创建 Template DataLoader 实例
+ */
+function createTemplateDataLoader() {
+    return new TemplateDataLoader();
+}

package/lib/server/debug/dataloader-debug.d.ts

@@ -0,0 +1,63 @@
+import { DataLoaderContext } from "../dataloaders";
+/**
+ * DataLoader 调试和监控 API
+ * 在开发环境中提供 DataLoader 性能监控接口
+ */
+/**
+ * 获取 DataLoader 统计信息的 GraphQL resolver
+ */
+export declare const dataLoaderStatsResolver: {
+    dataLoaderStats: (_: any, context: DataLoaderContext) => Promise<{
+        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;
+        timestamp: string;
+    }>;
+    resetDataLoaderStats: () => Promise<{
+        success: boolean;
+        message: string;
+        timestamp: string;
+    }>;
+    clearDataLoaderCache: (_: any, context: DataLoaderContext) => Promise<{
+        success: boolean;
+        message: string;
+        timestamp: string;
+    }>;
+};
+/**
+ * DataLoader 调试 Schema
+ */
+export declare const dataLoaderDebugSchema: {
+    query: string;
+    mutation: string;
+    type: string;
+};
+/**
+ * Express 路由：DataLoader 调试接口
+ */
+export declare function createDataLoaderDebugRoutes(app: any): void;