nsgm-cli 2.1.22 → 2.1.23

package/client/utils/common.ts

@@ -25,12 +25,16 @@ export const getLocalApiPrefix = () => {
         protocol = protocol.split(":")[0];
       }
       host = location.hostname;
-      port = location.port || (protocol.indexOf("https") !== -1 ? "443" : "80");
+      port = location.port;
     }
     // 服务器端：直接使用配置中的值，无需额外处理
   }
 
-  localApiPrefix = `${protocol}://${host}:${port}${prefix}`;
+  // 只在非标准端口时才添加端口号
+  const isStandardPort = (protocol === "https" && port === "443") || (protocol === "http" && port === "80") || !port;
+  const portStr = isStandardPort ? "" : `:${port}`;
+
+  localApiPrefix = `${protocol}://${host}${portStr}${prefix}`;
   return localApiPrefix;
 };
 

package/client/utils/fetch.ts

@@ -188,7 +188,7 @@ export const getLocalGraphql = async (query: string, variables: any = {}) => {
           };
 
           const retryResponse = await axios.post(
-            `${getLocalApiPrefix()}/graphql`,
+            `/api/graphql`,
             { query, variables },
             { headers: retryHeaders, withCredentials: true }
           );

package/client/utils/sso.ts

@@ -210,22 +210,32 @@ export const directLogin = (userName: string, userPassword: string, callback: an
   // 使用 encodeURIComponent 处理可能的特殊字符，然后再进行 Base64 编码
   const safeStr = handleXSS(`${userName},${userPassword}`);
   const encodedName = btoa(encodeURIComponent(safeStr));
-  const url = `${getLocalApiPrefix()}/rest/sso/ticketCheck?ticket=XXX&name=${encodedName}`;
+  const apiPrefix = getLocalApiPrefix();
+  const url = `${apiPrefix}/rest/sso/ticketCheck?ticket=XXX&name=${encodedName}`;
+
+  console.warn("[Login] Login URL:", url);
+  console.warn("[Login] Username:", userName);
 
   return fetch(url)
-    .then((response) => response.json())
+    .then((response) => {
+      console.warn("[Login] Response status:", response.status);
+      return response.json();
+    })
     .then((data) => {
+      console.warn("[Login] Response data:", data);
       if (data && data.returnCode === 0) {
         // 登录成功，设置cookie
         if (typeof window !== "undefined") {
+          console.warn("[Login] Login successful");
           storeLogin(data.cookieValue, data.cookieExpire, data.userAttr, callback);
           return { success: true };
         }
       }
+      console.warn("[Login] Login failed, returnCode:", data?.returnCode, "message:", data?.message);
       return { success: false, message: "用户名或密码错误" };
     })
     .catch((error) => {
-      console.error("登录请求失败:", error);
+      console.warn("[Login] Login request failed:", error);
       return { success: false, message: "登录请求失败，请稍后重试" };
     });
 };

package/lib/generate_create.js

@@ -48,6 +48,7 @@ const resolver_generator_1 = require("./generators/resolver-generator");
 const service_generator_1 = require("./generators/service-generator");
 const page_generator_1 = require("./generators/page-generator");
 const file_generator_1 = require("./generators/file-generator");
+const dataloader_generator_1 = require("./generators/dataloader-generator");
 // 常量定义
 const TEMPLATE_FILES = {
     reduxActions: "redux/template/manage/actions.ts",
@@ -207,6 +208,7 @@ const generateDynamicFiles = (controller, action, paths, fields, dictionary) =>
     const resolverGenerator = new resolver_generator_1.ResolverGenerator(controller, action, fields);
     const serviceGenerator = new service_generator_1.ServiceGenerator(controller, action, fields);
     const pageGenerator = new page_generator_1.PageGenerator(controller, action, fields);
+    const dataLoaderGenerator = new dataloader_generator_1.DataLoaderGenerator(controller, action, fields);
     // 根据 dictionary 确定文件生成器的项目路径
     const projectPath = !dictionary || dictionary === "." ? "." : path_1.default.join(constants_1.destFolder, dictionary);
     const fileGenerator = new file_generator_1.FileGenerator(projectPath);
@@ -216,6 +218,11 @@ const generateDynamicFiles = (controller, action, paths, fields, dictionary) =>
     fs_1.default.writeFileSync(paths.destServerModulesResolver, resolverGenerator.generate());
     fs_1.default.writeFileSync(paths.destClientAction, serviceGenerator.generate());
     fs_1.default.writeFileSync(paths.destPagesAction, pageGenerator.generate());
+    // 生成 DataLoader 文件
+    const dataLoaderPath = (0, path_1.resolve)(`${projectPath}/server/dataloaders/${controller}-dataloader.ts`);
+    (0, utils_1.mkdirSync)(path_1.default.dirname(dataLoaderPath));
+    fs_1.default.writeFileSync(dataLoaderPath, dataLoaderGenerator.generate());
+    console.log(`🚀 已生成 DataLoader 文件: ${dataLoaderPath}`);
     // 生成多语言文件
     fileGenerator.generateI18nFiles(controller, action, fields);
 };
@@ -302,6 +309,8 @@ const createFiles = (controller, action, dictionary, fields) => {
             paths.destClientServiceController,
             paths.destClientStyledController,
             paths.destServerModulesController,
+            // 添加 DataLoader 目录
+            (0, path_1.resolve)(`${getDestPath(constants_1.destServerPath)}/dataloaders`),
         ];
         createDirectoryStructure(basePaths);
         console.log("Directory structure created");

package/lib/generators/dataloader-generator.d.ts

@@ -0,0 +1,12 @@
+import { BaseGenerator } from "./base-generator";
+/**
+ * DataLoader生成器
+ * 自动生成对应的 DataLoader 文件
+ */
+export declare class DataLoaderGenerator extends BaseGenerator {
+    generate(): string;
+    /**
+     * 生成外键 DataLoader
+     */
+    private generateForeignKeyLoaders;
+}

package/lib/generators/dataloader-generator.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataLoaderGenerator = void 0;
+const base_generator_1 = require("./base-generator");
+/**
+ * DataLoader生成器
+ * 自动生成对应的 DataLoader 文件
+ */
+class DataLoaderGenerator extends base_generator_1.BaseGenerator {
+    generate() {
+        const capitalizedController = this.getCapitalizedController();
+        const selectFields = this.fields.map((f) => f.name).join(", ");
+        // const searchableFields = this.getSearchableFields(); // 暂时注释掉未使用的变量
+        return `import DataLoader from 'dataloader';
+import { executeQuery } from '../utils/common';
+
+/**
+ * ${capitalizedController} DataLoader
+ * 针对 ${this.controller} 表的批量数据加载器，解决 N+1 查询问题
+ */
+export class ${capitalizedController}DataLoader {
+  // 按 ID 批量加载 ${this.controller}
+  public readonly byId: DataLoader<number, any>;
+  
+  // 按名称批量加载 ${this.controller}  
+  public readonly byName: DataLoader<string, any>;
+  
+  // 按名称模糊搜索 ${this.controller}
+  public readonly searchByName: DataLoader<string, any[]>;
+
+  constructor() {
+    // 按 ID 批量加载
+    this.byId = new DataLoader(
+      async (ids: readonly number[]) => {
+        try {
+          console.log(\`🔍 DataLoader: 批量加载 \${ids.length} 个 ${this.controller} by ID\`);
+          
+          const placeholders = ids.map(() => '?').join(',');
+          const sql = \`SELECT ${selectFields} FROM ${this.controller} WHERE id IN (\${placeholders})\`;
+          
+          const results = await executeQuery(sql, [...ids]);
+          
+          // 确保返回顺序与输入 keys 一致，未找到的返回 null
+          return ids.map(id => 
+            results.find((row: any) => 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(
+      async (names: readonly string[]) => {
+        try {
+          console.log(\`🔍 DataLoader: 批量加载 \${names.length} 个 ${this.controller} by name\`);
+          
+          const placeholders = names.map(() => '?').join(',');
+          const sql = \`SELECT ${selectFields} FROM ${this.controller} WHERE name IN (\${placeholders})\`;
+          
+          const results = await executeQuery(sql, [...names]);
+          
+          // 确保返回顺序与输入 keys 一致
+          return names.map(name => 
+            results.find((row: any) => 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(
+      async (searchTerms: readonly string[]) => {
+        try {
+          console.log(\`🔍 DataLoader: 批量搜索 \${searchTerms.length} 个关键词\`);
+          
+          // 对于搜索，我们需要为每个搜索词执行独立的查询
+          const results = await Promise.all(
+            searchTerms.map(async (term) => {
+              const sql = 'SELECT ${selectFields} FROM ${this.controller} WHERE name LIKE ?';
+              return executeQuery(sql, [\`%\${term}%\`]);
+            })
+          );
+          
+          return results;
+        } catch (error) {
+          console.error('DataLoader searchByName 批量搜索失败:', error);
+          throw error;
+        }
+      },
+      {
+        cache: true,
+        maxBatchSize: 20, // 搜索请求较少，降低批量大小
+        batchScheduleFn: callback => setTimeout(callback, 20), // 稍长的等待时间
+      }
+    );
+
+    ${this.generateForeignKeyLoaders()}
+  }
+
+  /**
+   * 清除所有缓存
+   */
+  clearAll(): void {
+    this.byId.clearAll();
+    this.byName.clearAll();
+    this.searchByName.clearAll();
+    console.log('🧹 ${capitalizedController} DataLoader 缓存已清空');
+  }
+
+  /**
+   * 清除特定 ID 的缓存
+   */
+  clearById(id: number): void {
+    this.byId.clear(id);
+  }
+
+  /**
+   * 清除特定名称的缓存
+   */
+  clearByName(name: string): void {
+    this.byName.clear(name);
+  }
+
+  /**
+   * 预加载数据到缓存
+   */
+  prime(id: number, data: any): void {
+    this.byId.prime(id, data);
+    if (data && data.name) {
+      this.byName.prime(data.name, data);
+    }
+  }
+
+  /**
+   * 获取缓存统计信息
+   */
+  getStats() {
+    return {
+      byId: {
+        cacheMap: this.byId.cacheMap?.size || 0,
+        name: '${capitalizedController}.byId'
+      },
+      byName: {
+        cacheMap: this.byName.cacheMap?.size || 0,
+        name: '${capitalizedController}.byName'
+      },
+      searchByName: {
+        cacheMap: this.searchByName.cacheMap?.size || 0,
+        name: '${capitalizedController}.searchByName'
+      }
+    };
+  }
+}
+
+/**
+ * 创建 ${capitalizedController} DataLoader 实例
+ */
+export function create${capitalizedController}DataLoader(): ${capitalizedController}DataLoader {
+  return new ${capitalizedController}DataLoader();
+}`;
+    }
+    /**
+     * 生成外键 DataLoader
+     */
+    generateForeignKeyLoaders() {
+        const foreignKeys = this.fields.filter((f) => f.name.endsWith("_id") && f.name !== "id");
+        if (foreignKeys.length === 0) {
+            return "";
+        }
+        return foreignKeys
+            .map((fk) => {
+            const relatedTable = fk.name.replace("_id", "");
+            const capitalizedRelated = relatedTable.charAt(0).toUpperCase() + relatedTable.slice(1);
+            return `
+    // 按 ${fk.name} 批量加载相关的 ${this.controller}
+    this.by${capitalizedRelated}Id = new DataLoader(
+      async (${fk.name}s: readonly number[]) => {
+        try {
+          console.log(\`🔍 DataLoader: 批量加载 \${${fk.name}s.length} 个 ${this.controller} by ${fk.name}\`);
+          
+          const placeholders = ${fk.name}s.map(() => '?').join(',');
+          const sql = \`SELECT ${this.fields.map((f) => f.name).join(", ")} FROM ${this.controller} WHERE ${fk.name} IN (\${placeholders})\`;
+          
+          const results = await executeQuery(sql, [...${fk.name}s]);
+          
+          // 按外键分组
+          return ${fk.name}s.map(${fk.name} => 
+            results.filter((row: any) => row.${fk.name} === ${fk.name})
+          );
+        } catch (error) {
+          console.error('DataLoader by${capitalizedRelated}Id 批量加载失败:', error);
+          throw error;
+        }
+      },
+      {
+        cache: true,
+        maxBatchSize: 50,
+        batchScheduleFn: callback => setTimeout(callback, 10),
+      }
+    );`;
+        })
+            .join("\n");
+    }
+}
+exports.DataLoaderGenerator = DataLoaderGenerator;

package/lib/generators/resolver-generator.d.ts

@@ -10,5 +10,6 @@ export declare class ResolverGenerator extends BaseGenerator {
     private generateUpdateValidation;
     private generateUpdateValues;
     private generateBatchReturnObject;
-    private generateBatchInsertValues;
+    private generateDataLoaderSearchLogic;
+    private generateNewRecordObject;
 }

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/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 缓存已清空");
+}