@lmcc-dev/mult-fetch-mcp-server 1.1.0 → 1.2.1

package/dist/tests/server/resources.test.js

@@ -3,33 +3,59 @@
  * Co-Author: AI Assistant (Claude)
  * Description: This code was collaboratively developed by Martin and AI Assistant.
  */
-import { ListResourcesRequestSchema, ReadResourceRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { ListResourcesRequestSchema, ReadResourceRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import fs from 'fs';
 import path from 'path';
-// 模拟logger模块
-jest.mock('../../src/lib/logger.js', () => ({
-    log: jest.fn(),
-    getLogFilePath: jest.fn().mockReturnValue('/mock/path/to/debug.log'),
-    clearLogFile: jest.fn(),
+import { vi, describe, it, expect, beforeEach } from 'vitest';
+// 创建模拟logger模块
+const mockLogger = {
+    log: vi.fn(),
+    getLogFilePath: vi.fn().mockReturnValue('/mock/path/to/debug.log'),
+    clearLogFile: vi.fn(),
     COMPONENTS: {
         RESOURCES: 'resources'
     }
-}));
+};
+// 模拟logger模块
+vi.mock('../../src/lib/logger.js', () => {
+    return {
+        default: mockLogger,
+        ...mockLogger
+    };
+});
 // 模拟fs模块
-jest.mock('fs', () => ({
-    readFileSync: jest.fn()
-}));
+vi.mock('fs', () => {
+    return {
+        default: {
+            readFileSync: vi.fn()
+        },
+        readFileSync: vi.fn()
+    };
+});
 // 模拟path模块
-jest.mock('path', () => ({
-    dirname: jest.fn(),
-    resolve: jest.fn(),
-    join: jest.fn(),
-    extname: jest.fn()
-}));
+vi.mock('path', () => {
+    return {
+        default: {
+            dirname: vi.fn(),
+            resolve: vi.fn(),
+            join: vi.fn(),
+            extname: vi.fn()
+        },
+        dirname: vi.fn(),
+        resolve: vi.fn(),
+        join: vi.fn(),
+        extname: vi.fn()
+    };
+});
 // 模拟url模块
-jest.mock('url', () => ({
-    fileURLToPath: jest.fn()
-}));
+vi.mock('url', () => {
+    return {
+        default: {
+            fileURLToPath: vi.fn()
+        },
+        fileURLToPath: vi.fn()
+    };
+});
 // 获取MIME类型函数
 function getMimeType(filePath) {
     const ext = path.extname(filePath).toLowerCase();
@@ -46,6 +72,15 @@ function getMimeType(filePath) {
             return 'text/html';
         case '.css':
             return 'text/css';
+        case '.png':
+            return 'image/png';
+        case '.jpg':
+        case '.jpeg':
+            return 'image/jpeg';
+        case '.gif':
+            return 'image/gif';
+        case '.svg':
+            return 'image/svg+xml';
         case '.txt':
         case '.log':
             return 'text/plain';
@@ -58,7 +93,7 @@ const registerResources = (server) => {
     // 注册资源列表处理程序
     server.setRequestHandler(ListResourcesRequestSchema, async (request) => {
         const debug = request.params?.debug === true;
-        require('../../src/lib/logger.js').log('resources.list.request', debug, { params: request.params }, 'resources');
+        mockLogger.log('resources.list.request', debug, { params: request.params }, 'resources');
         // 返回实际可用的资源列表
         return {
             resources: [
@@ -91,60 +126,60 @@ const registerResources = (server) => {
     server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
         const uri = request.params.uri;
         const debug = request.params?.debug === true;
-        require('../../src/lib/logger.js').log('resources.read.request', debug, { uri }, 'resources');
+        mockLogger.log('resources.read.request', debug, { uri }, 'resources');
         try {
             // 解析URI并读取相应文件
             let filePath = null;
             let content = '';
             // 处理日志文件URI
             if (uri === 'file:///logs/debug') {
-                filePath = require('../../src/lib/logger.js').getLogFilePath();
+                filePath = mockLogger.getLogFilePath();
                 content = fs.readFileSync(filePath, 'utf-8');
             }
-            // 处理清理日志文件URI
             else if (uri === 'file:///logs/clear') {
-                require('../../src/lib/logger.js').clearLogFile();
-                content = '日志文件已清理 (Log file has been cleared)';
+                mockLogger.clearLogFile();
+                content = 'Log file cleared';
+                filePath = '/mock/path/to/clear.log';
             }
-            // 处理文档资源
             else if (uri.startsWith('file:///docs/')) {
-                const resourceName = uri.substring('file:///docs/'.length);
-                filePath = path.join('/mock/path/to', resourceName + '.md');
+                // 处理文档文件URI
+                const docPath = uri.replace('file:///docs/', '');
+                filePath = path.join('/mock/path/to', `${docPath}.md`);
                 content = fs.readFileSync(filePath, 'utf-8');
             }
-            // 处理源代码资源
             else if (uri.startsWith('file:///src/')) {
-                const resourceName = uri.substring('file:///src/'.length);
-                filePath = path.join('/mock/path/to', resourceName + '.ts');
+                // 处理源代码文件URI
+                const srcPath = uri.replace('file:///src/', '');
+                filePath = path.join('/mock/path/to', `${srcPath}.ts`);
                 content = fs.readFileSync(filePath, 'utf-8');
             }
-            // 处理无效URI
             else {
-                throw new Error('Invalid URI');
+                throw new Error(`resources.notFound: ${uri}`);
             }
             // 获取MIME类型
-            const mimeType = getMimeType(filePath || '');
+            const mimeType = getMimeType(filePath);
+            // 返回资源内容
             return {
                 contents: [
                     {
                         uri,
-                        mimeType,
+                        type: mimeType,
                         text: content
                     }
                 ]
             };
         }
         catch (error) {
-            require('../../src/lib/logger.js').log('resources.fileReadError', true, {
+            mockLogger.log('resources.fileReadError', true, {
                 filePath: 'unknown',
                 error: error instanceof Error ? error.message : String(error)
             }, 'resources');
-            throw new Error(`resources.notFound: ${uri}`);
+            throw error;
         }
     });
 };
 // 模拟resources模块
-jest.mock('../../src/lib/server/resources.js', () => ({
+vi.mock('../../src/lib/server/resources.js', () => ({
     registerResources
 }));
 describe('resources模块测试', () => {
@@ -153,10 +188,10 @@ describe('resources模块测试', () => {
     let readResourceHandler;
     beforeEach(() => {
         // 重置所有模拟
-        jest.clearAllMocks();
+        vi.clearAllMocks();
         // 创建模拟Server实例
         server = {
-            setRequestHandler: jest.fn((schema, handler) => {
+            setRequestHandler: vi.fn((schema, handler) => {
                 if (schema === ListResourcesRequestSchema) {
                     listResourcesHandler = handler;
                 }
@@ -182,23 +217,27 @@ describe('resources模块测试', () => {
             expect(response).toHaveProperty('resources');
             expect(Array.isArray(response.resources)).toBe(true);
             expect(response.resources.length).toBe(2);
-            // 验证返回的资源
-            const resourceNames = response.resources.map((r) => r.name);
-            expect(resourceNames).toContain('mult-fetch-mcp:log:debug-log');
-            expect(resourceNames).toContain('mult-fetch-mcp:log:clear-debug-log');
+            // 验证资源列表内容
+            expect(response.resources[0]).toHaveProperty('name', 'mult-fetch-mcp:log:debug-log');
+            expect(response.resources[0]).toHaveProperty('uri', 'file:///logs/debug');
+            expect(response.resources[1]).toHaveProperty('name', 'mult-fetch-mcp:log:clear-debug-log');
+            expect(response.resources[1]).toHaveProperty('uri', 'file:///logs/clear');
             // 验证资源模板
             expect(response).toHaveProperty('resourceTemplates');
             expect(Array.isArray(response.resourceTemplates)).toBe(true);
             expect(response.resourceTemplates.length).toBe(2);
-            const templateNames = response.resourceTemplates.map((t) => t.name);
-            expect(templateNames).toContain('mult-fetch-mcp:src:file');
-            expect(templateNames).toContain('mult-fetch-mcp:docs:file');
+            expect(response.resourceTemplates[0]).toHaveProperty('uriTemplate', 'file:///src/{path}');
+            expect(response.resourceTemplates[1]).toHaveProperty('uriTemplate', 'file:///docs/{path}');
         });
         it('应该处理debug参数', async () => {
-            const request = { params: { debug: true } };
+            const request = {
+                params: {
+                    debug: true
+                }
+            };
             await listResourcesHandler(request);
             // 验证日志调用
-            expect(require('../../src/lib/logger.js').log).toHaveBeenCalledWith('resources.list.request', true, { params: { debug: true } }, 'resources');
+            expect(mockLogger.log).toHaveBeenCalledWith('resources.list.request', true, { params: { debug: true } }, 'resources');
         });
     });
     describe('ReadResourceRequestSchema处理程序', () => {
@@ -217,11 +256,11 @@ describe('resources模块测试', () => {
             expect(response.contents.length).toBe(1);
             // 验证内容
             const content = response.contents[0];
-            expect(content.uri).toBe('file:///logs/debug');
-            expect(content.mimeType).toBe('text/plain');
-            expect(content.text).toBe('Debug log content');
+            expect(content).toHaveProperty('uri', 'file:///logs/debug');
+            expect(content).toHaveProperty('type', 'text/plain');
+            expect(content).toHaveProperty('text', 'Debug log content');
             // 验证getLogFilePath被调用
-            expect(require('../../src/lib/logger.js').getLogFilePath).toHaveBeenCalled();
+            expect(mockLogger.getLogFilePath).toHaveBeenCalled();
             expect(fs.readFileSync).toHaveBeenCalledWith('/mock/path/to/debug.log', 'utf-8');
         });
         it('应该处理清理日志资源', async () => {
@@ -236,10 +275,10 @@ describe('resources模块测试', () => {
             expect(response.contents.length).toBe(1);
             // 验证内容
             const content = response.contents[0];
-            expect(content.uri).toBe('file:///logs/clear');
-            expect(content.text).toContain('日志文件已清理');
+            expect(content).toHaveProperty('uri', 'file:///logs/clear');
+            expect(content).toHaveProperty('text', 'Log file cleared');
             // 验证clearLogFile被调用
-            expect(require('../../src/lib/logger.js').clearLogFile).toHaveBeenCalled();
+            expect(mockLogger.clearLogFile).toHaveBeenCalled();
         });
         it('应该处理文档资源', async () => {
             // 模拟路径和文件内容
@@ -248,7 +287,7 @@ describe('resources模块测试', () => {
             path.extname.mockReturnValue('.md');
             const request = {
                 params: {
-                    uri: 'file:///docs/readme'
+                    uri: 'file:///docs/README'
                 }
             };
             const response = await readResourceHandler(request);
@@ -257,9 +296,9 @@ describe('resources模块测试', () => {
             expect(response.contents.length).toBe(1);
             // 验证内容
             const content = response.contents[0];
-            expect(content.uri).toBe('file:///docs/readme');
-            expect(content.mimeType).toBe('text/markdown');
-            expect(content.text).toBe('# README content');
+            expect(content).toHaveProperty('uri', 'file:///docs/README');
+            expect(content).toHaveProperty('type', 'text/markdown');
+            expect(content).toHaveProperty('text', '# README content');
             // 验证path.join被调用
             expect(path.join).toHaveBeenCalled();
             expect(fs.readFileSync).toHaveBeenCalledWith('/mock/path/to/README.md', 'utf-8');
@@ -280,9 +319,9 @@ describe('resources模块测试', () => {
             expect(response.contents.length).toBe(1);
             // 验证内容
             const content = response.contents[0];
-            expect(content.uri).toBe('file:///src/index');
-            expect(content.mimeType).toBe('text/typescript');
-            expect(content.text).toBe('// Source code');
+            expect(content).toHaveProperty('uri', 'file:///src/index');
+            expect(content).toHaveProperty('type', 'text/typescript');
+            expect(content).toHaveProperty('text', '// Source code');
             // 验证path.join被调用
             expect(path.join).toHaveBeenCalled();
             expect(fs.readFileSync).toHaveBeenCalledWith('/mock/path/to/index.ts', 'utf-8');
@@ -290,7 +329,7 @@ describe('resources模块测试', () => {
         it('应该处理无效的URI', async () => {
             const request = {
                 params: {
-                    uri: 'invalid-uri'
+                    uri: 'invalid://uri'
                 }
             };
             await expect(readResourceHandler(request)).rejects.toThrow('resources.notFound');
@@ -300,17 +339,17 @@ describe('resources模块测试', () => {
             path.join.mockReturnValue('/mock/path/to/file.txt');
             // 模拟文件读取错误
             fs.readFileSync.mockImplementation(() => {
-                throw new Error('File not found');
+                throw new Error('File read error');
             });
             const request = {
                 params: {
-                    uri: 'file:///docs/file'
+                    uri: 'file:///src/error/file'
                 }
             };
-            await expect(readResourceHandler(request)).rejects.toThrow('resources.notFound');
+            await expect(readResourceHandler(request)).rejects.toThrow('File read error');
             // 验证错误日志
-            expect(require('../../src/lib/logger.js').log).toHaveBeenCalledWith('resources.fileReadError', expect.any(Boolean), expect.objectContaining({
-                error: expect.any(String)
+            expect(mockLogger.log).toHaveBeenCalledWith('resources.fileReadError', true, expect.objectContaining({
+                error: 'File read error'
             }), 'resources');
         });
         it('应该处理debug参数', async () => {
@@ -325,34 +364,31 @@ describe('resources模块测试', () => {
             };
             await readResourceHandler(request);
             // 验证日志调用
-            expect(require('../../src/lib/logger.js').log).toHaveBeenCalledWith('resources.read.request', true, { uri: 'file:///logs/debug' }, 'resources');
+            expect(mockLogger.log).toHaveBeenCalledWith('resources.read.request', true, { uri: 'file:///logs/debug' }, 'resources');
         });
     });
     describe('getMimeType函数', () => {
-        it('应该返回正确的MIME类型', async () => {
-            // 测试不同的文件扩展名
+        it('应该返回正确的MIME类型', () => {
             const testExtensions = [
-                { ext: '.md', mime: 'text/markdown' },
-                { ext: '.json', mime: 'application/json' },
-                { ext: '.ts', mime: 'text/typescript' },
-                { ext: '.js', mime: 'text/javascript' },
                 { ext: '.html', mime: 'text/html' },
+                { ext: '.js', mime: 'text/javascript' },
                 { ext: '.css', mime: 'text/css' },
+                { ext: '.json', mime: 'application/json' },
+                { ext: '.png', mime: 'image/png' },
+                { ext: '.jpg', mime: 'image/jpeg' },
+                { ext: '.gif', mime: 'image/gif' },
+                { ext: '.svg', mime: 'image/svg+xml' },
+                { ext: '.md', mime: 'text/markdown' },
                 { ext: '.txt', mime: 'text/plain' },
                 { ext: '.log', mime: 'text/plain' },
+                { ext: '.ts', mime: 'text/typescript' },
                 { ext: '.unknown', mime: 'application/octet-stream' }
             ];
             for (const test of testExtensions) {
                 // 模拟文件路径和内容
                 path.extname.mockReturnValue(test.ext);
-                fs.readFileSync.mockReturnValue('File content');
-                const request = {
-                    params: {
-                        uri: `file:///docs/file${test.ext}`
-                    }
-                };
-                const response = await readResourceHandler(request);
-                expect(response.contents[0].mimeType).toBe(test.mime);
+                const mime = getMimeType(`/path/to/file${test.ext}`);
+                expect(mime).toBe(test.mime);
             }
         });
     });

package/dist/tests/server/tools.test.js

@@ -6,13 +6,14 @@
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { registerTools } from '../../src/lib/server/tools.js';
 import { fetchWithAutoDetect } from '../../src/lib/server/fetcher.js';
+import { vi, describe, test, expect, beforeEach } from 'vitest';
 // 模拟 fetchWithAutoDetect 函数
-jest.mock('../../src/lib/server/fetcher.js', () => ({
-    fetchWithAutoDetect: jest.fn()
+vi.mock('../../src/lib/server/fetcher.js', () => ({
+    fetchWithAutoDetect: vi.fn()
 }));
 // 模拟 logger
-jest.mock('../../src/lib/logger.js', () => ({
-    log: jest.fn(),
+vi.mock('../../src/lib/logger.js', () => ({
+    log: vi.fn(),
     COMPONENTS: {
         TOOLS: 'tools'
     }
@@ -22,9 +23,9 @@ describe('工具注册和调用测试 (Tools Registration and Calling Tests)', (
     let mockSetRequestHandler;
     beforeEach(() => {
         // 重置所有模拟
-        jest.clearAllMocks();
+        vi.clearAllMocks();
         // 创建模拟的 Server 实例
-        mockSetRequestHandler = jest.fn();
+        mockSetRequestHandler = vi.fn();
         mockServer = {
             setRequestHandler: mockSetRequestHandler
         };

package/dist/tests/setup.js

@@ -0,0 +1,36 @@
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+// 导入Vitest的全局函数 (Import Vitest global functions)
+import { beforeAll, afterAll, vi } from 'vitest';
+// 全局模拟设置
+// 将 vi 添加到全局，以便在测试中使用
+global.vi = vi;
+// 为了兼容 Jest 的 jest.fn(), jest.mock() 等
+global.jest = {
+    fn: vi.fn,
+    mock: vi.mock,
+    spyOn: vi.spyOn,
+    clearAllMocks: vi.clearAllMocks,
+    resetAllMocks: vi.resetAllMocks,
+    restoreAllMocks: vi.restoreAllMocks
+};
+// 设置测试环境 (Setup test environment)
+process.env.NODE_ENV = 'test';
+// 模拟控制台输出，避免测试时输出过多日志 (Mock console output to avoid too many logs during testing)
+console.log = vi.fn();
+console.info = vi.fn();
+console.warn = vi.fn();
+console.error = vi.fn();
+// 在所有测试开始前的操作 (Operations before all tests)
+beforeAll(() => {
+    // 全局设置，在所有测试开始前运行
+    // 可以在这里添加全局设置 (Add global setup here)
+});
+// 在所有测试结束后的操作 (Operations after all tests)
+afterAll(() => {
+    // 全局清理，在所有测试结束后运行
+    // 可以在这里添加全局清理 (Add global cleanup here)
+});

package/dist/tests/src/lib/i18n/index.js

@@ -0,0 +1,108 @@
+"use strict";
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSupportedLanguages = exports.hasTranslation = exports.getCurrentLanguage = exports.changeLanguage = exports.t = void 0;
+var i18next_1 = require("i18next");
+var index_js_1 = require("./locales/en/index.js");
+var index_js_2 = require("./locales/zh/index.js");
+// 定义语言资源 (Define language resources)
+var resources = {
+    en: {
+        translation: index_js_1.enTranslation
+    },
+    zh: {
+        translation: index_js_2.zhTranslation
+    }
+};
+/**
+ * 初始化 i18next 配置 (Initialize i18next configuration)
+ */
+var initializeI18n = function () {
+    // 获取当前语言环境 (Get current language environment)
+    var currentLanguage = process.env.MCP_LANG || 'en';
+    // 初始化 i18next (Initialize i18next)
+    i18next_1.default.init({
+        resources: resources,
+        // 优先使用专门的环境变量，其次默认使用英语
+        // (Priority: dedicated environment variable, then default to English)
+        lng: currentLanguage,
+        fallbackLng: 'en',
+        interpolation: {
+            escapeValue: false // 不转义插值 (Don't escape interpolation)
+        },
+        debug: process.env.DEBUG === 'true', // 只在调试模式下启用 i18n 调试 (Enable i18n debug only in debug mode)
+        returnEmptyString: false, // 不返回空字符串 (Don't return empty string)
+        returnNull: false, // 不返回 null (Don't return null)
+        returnObjects: true, // 返回对象 (Return objects)
+        saveMissing: true, // 保存缺失的翻译键 (Save missing translation keys)
+        missingKeyHandler: function (lng, ns, key, fallbackValue) {
+            console.error("[i18n] Missing translation key: ".concat(key, " for language: ").concat(lng));
+        }
+    });
+    console.log("[i18n] Initialized with language: ".concat(currentLanguage));
+    return i18next_1.default;
+};
+// 初始化 i18next 实例 (Initialize i18next instance)
+var i18n = initializeI18n();
+// 导出 i18next 实例 (Export i18next instance)
+exports.default = i18n;
+/**
+ * 翻译函数 - 提供类型安全和错误处理 (Translation function - provides type safety and error handling)
+ * @param key 翻译键 (Translation key)
+ * @param options 翻译选项 (Translation options)
+ * @returns 翻译结果 (Translation result)
+ */
+var t = function (key, options) {
+    try {
+        var result = i18n.t(key, options);
+        // 如果结果与键相同，说明没有找到翻译 (If the result is the same as the key, the translation was not found)
+        if (result === key) {
+            console.warn("[i18n] Translation key not found: ".concat(key));
+        }
+        return result;
+    }
+    catch (error) {
+        console.error("[i18n] Error translating key: ".concat(key), error);
+        return key; // 出错时返回原始键 (Return the original key when an error occurs)
+    }
+};
+exports.t = t;
+/**
+ * 切换语言函数 (Language switching function)
+ * @param lng 目标语言 (Target language)
+ * @returns Promise，解析为切换后的语言 (Promise that resolves to the switched language)
+ */
+var changeLanguage = function (lng) {
+    console.log("[i18n] Changing language to: ".concat(lng));
+    return i18n.changeLanguage(lng).then(function () { return lng; });
+};
+exports.changeLanguage = changeLanguage;
+/**
+ * 获取当前语言函数 (Get current language function)
+ * @returns 当前语言 (Current language)
+ */
+var getCurrentLanguage = function () {
+    return (i18n.language || 'en');
+};
+exports.getCurrentLanguage = getCurrentLanguage;
+/**
+ * 检查键是否存在 (Check if a key exists)
+ * @param key 要检查的键 (Key to check)
+ * @returns 键是否存在 (Whether the key exists)
+ */
+var hasTranslation = function (key) {
+    return i18n.exists(key);
+};
+exports.hasTranslation = hasTranslation;
+/**
+ * 获取所有支持的语言 (Get all supported languages)
+ * @returns 支持的语言数组 (Array of supported languages)
+ */
+var getSupportedLanguages = function () {
+    return Object.keys(resources);
+};
+exports.getSupportedLanguages = getSupportedLanguages;

package/dist/tests/src/lib/i18n/keys/base.js

@@ -0,0 +1,47 @@
+"use strict";
+/**
+ * Author: Martin <lmccc.dev@gmail.com>
+ * Co-Author: AI Assistant (Claude)
+ * Description: This code was collaboratively developed by Martin and AI Assistant.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createResourceKeys = exports.createResourceOperationKeys = exports.createKeyGenerator = void 0;
+/**
+ * 创建键名生成器 - 用于生成特定模块的键名 (Create key name generator - for generating key names for specific modules)
+ * @param module 模块名称 (Module name)
+ * @returns 键名生成函数 (Key name generator function)
+ */
+var createKeyGenerator = function (module) { return function (key) { return "".concat(module, ".").concat(key); }; };
+exports.createKeyGenerator = createKeyGenerator;
+/**
+ * 创建资源操作键 - 用于生成资源操作相关的键 (Create resource operation keys - for generating resource operation related keys)
+ * @param module 模块名称 (Module name)
+ * @param operation 操作名称 (Operation name)
+ * @returns 资源操作键对象 (Resource operation keys object)
+ */
+var createResourceOperationKeys = function (module, operation) {
+    var keyGen = (0, exports.createKeyGenerator)("".concat(module, ".").concat(operation));
+    return {
+        request: keyGen('request'),
+        success: keyGen('success'),
+        error: keyGen('error'),
+        notFound: keyGen('notFound'),
+        duplicate: keyGen('duplicate')
+    };
+};
+exports.createResourceOperationKeys = createResourceOperationKeys;
+/**
+ * 创建资源键 - 用于生成资源相关的键 (Create resource keys - for generating resource related keys)
+ * @param module 模块名称 (Module name)
+ * @returns 资源键对象 (Resource keys object)
+ */
+var createResourceKeys = function (module) {
+    return {
+        list: (0, exports.createResourceOperationKeys)(module, 'list'),
+        get: (0, exports.createResourceOperationKeys)(module, 'get'),
+        create: (0, exports.createResourceOperationKeys)(module, 'create'),
+        update: (0, exports.createResourceOperationKeys)(module, 'update'),
+        delete: (0, exports.createResourceOperationKeys)(module, 'delete')
+    };
+};
+exports.createResourceKeys = createResourceKeys;