@eggjs/tegg-common-util 3.61.0 → 3.62.1

package/README.md

@@ -1,5 +1,140 @@
-# `@eggjs/common-util`
+# @eggjs/tegg-common-util
 
-# Usage
+Common utility functions for tegg framework.
 
-This is an internal tegg library, you probably shouldn't use it directly.
+## ModuleConfigUtil.deduplicateModules
+
+A utility method for deduplicating module references to avoid adding duplicate modules.
+
+### Features
+
+- **Path-based deduplication**: Removes modules with duplicate paths
+- **Name-based deduplication**: Removes modules with duplicate names (throws error if found)
+- **Priority handling**: Prioritizes non-optional modules over optional ones
+- **Error handling**: Throws error for duplicate module names with different paths
+- **Simple API**: No complex options, straightforward behavior
+
+### API
+
+```typescript
+public static deduplicateModules(
+  moduleReferences: readonly ModuleReference[]
+): readonly ModuleReference[]
+```
+
+**Note**: This method does not accept options parameters. The behavior is fixed and optimized for common use cases.
+
+### Behavior
+
+1. **Path Deduplication**: If multiple modules have the same path, only one is kept
+2. **Optional Priority**: When paths are the same, non-optional modules are prioritized over optional ones
+3. **Name Validation**: If modules have the same name but different paths, an error is thrown
+4. **First Occurrence**: When both modules have the same optional status, the first occurrence is kept
+
+### Usage Examples
+
+#### Basic Usage
+
+```typescript
+import { ModuleConfigUtil } from '@eggjs/tegg-common-util';
+
+const modules = [
+  { name: 'module1', path: '/path/to/module1' },
+  { name: 'module2', path: '/path/to/module2' },
+  { name: 'module1', path: '/different/path/to/module1' }, // Will throw error
+];
+
+const result = ModuleConfigUtil.deduplicateModules(modules);
+// Throws Error: Duplicate module name "module1" found
+```
+
+#### With Optional Modules
+
+```typescript
+const modules = [
+  { name: 'module1', path: '/path/to/module1', optional: true },
+  { name: 'module1', path: '/path/to/module1' }, // Non-optional version
+];
+
+const result = ModuleConfigUtil.deduplicateModules(modules);
+// Result: 1 module, non-optional version kept
+```
+
+#### Path Deduplication
+
+```typescript
+const modules = [
+  { name: 'module1', path: '/path/to/module1' },
+  { name: 'module2', path: '/path/to/module1' }, // Same path, different name
+];
+
+const result = ModuleConfigUtil.deduplicateModules(modules);
+// Result: 1 module, first occurrence kept
+```
+
+### Use Cases
+
+#### 1. Plugin/Config Module Scanner
+
+```typescript
+// In ModuleScanner.loadModuleReferences()
+return ModuleConfigUtil.deduplicateModules(allModuleReferences);
+// Automatically handles deduplication with optimal defaults
+```
+
+#### 2. Standalone Runner
+
+```typescript
+// In Runner.getModuleReferences()
+return ModuleConfigUtil.deduplicateModules(allModuleReferences);
+// Simple and reliable deduplication
+```
+
+#### 3. Error Handling
+
+```typescript
+try {
+  const result = ModuleConfigUtil.deduplicateModules(modules);
+} catch (error) {
+  if (error.message.includes('Duplicate module name')) {
+    // Handle duplicate module name error
+    console.error('Configuration error:', error.message);
+  }
+  throw error;
+}
+```
+
+### Benefits
+
+1. **Simplicity**: No complex configuration needed, works out of the box
+2. **Reliability**: Consistent behavior across different use cases
+3. **Performance**: Optimized for common scenarios
+4. **Error Prevention**: Catches configuration errors early
+5. **Maintainability**: Simple API reduces complexity
+
+### Migration from Options-based API
+
+#### Before (Options-based - Not Available)
+```typescript
+// This API never existed in the actual implementation
+const result = ModuleConfigUtil.deduplicateModules(modules, {
+  prioritizeNonOptional: true,
+  allowNameDuplicates: false,
+  logPrefix: '[tegg/config]',
+  logger: customLogger,
+});
+```
+
+#### After (Current Implementation)
+```typescript
+// Current implementation - simple and direct
+const result = ModuleConfigUtil.deduplicateModules(modules);
+// Automatically handles all deduplication logic
+```
+
+### Important Notes
+
+- **No Options**: The method signature is fixed and does not accept configuration options
+- **Error on Name Duplicates**: Duplicate names with different paths will cause an error
+- **Automatic Priority**: Non-optional modules are automatically prioritized over optional ones
+- **Path-based Deduplication**: Same path modules are deduplicated with smart priority handling

package/dist/src/ModuleConfig.d.ts

@@ -17,4 +17,10 @@ export declare class ModuleConfigUtil {
     static readModuleNameSync(moduleDir: string, baseDir?: string): string;
     static loadModuleConfig(moduleDir: string, baseDir?: string, env?: string): Promise<ModuleConfig>;
     static loadModuleConfigSync(moduleDir: string, baseDir?: string, env?: string): ModuleConfig;
+    /**
+     * 去重模块引用，避免重复添加相同的模块
+     * @param moduleReferences 模块引用数组
+     * @return 去重后的模块引用数组
+     */
+    static deduplicateModules(moduleReferences: readonly ModuleReference[]): readonly ModuleReference[];
 }

package/dist/src/ModuleConfig.js

@@ -270,6 +270,70 @@ class ModuleConfigUtil {
         }
         return target;
     }
+    /**
+     * 去重模块引用，避免重复添加相同的模块
+     * @param moduleReferences 模块引用数组
+     * @return 去重后的模块引用数组
+     */
+    static deduplicateModules(moduleReferences) {
+        var _b, _c;
+        const moduleMap = new Map();
+        const nameMap = new Map();
+        for (const moduleRef of moduleReferences) {
+            const key = moduleRef.path;
+            const existingRef = moduleMap.get(key);
+            // 如果路径相同，优先保留非 optional 模块
+            if (existingRef) {
+                // 优先保留非 optional 模块
+                // 将 undefined 视为 false（非可选）
+                const existingOptional = (_b = existingRef.optional) !== null && _b !== void 0 ? _b : false;
+                const currentOptional = (_c = moduleRef.optional) !== null && _c !== void 0 ? _c : false;
+                if (!existingOptional && currentOptional) {
+                    // 保留现有的非 optional 模块，跳过当前的 optional 模块
+                    continue;
+                }
+                else if (existingOptional && !currentOptional) {
+                    // 用非 optional 模块替换现有的 optional 模块
+                    // 在替换之前，先检查新模块的名称是否与已有的其他模块名称冲突
+                    if (existingRef.name !== moduleRef.name) {
+                        const existingByName = nameMap.get(moduleRef.name);
+                        if (existingByName) {
+                            // 如果名称重复但路径不同，直接报错
+                            throw new Error(`Duplicate module name "${moduleRef.name}" found: existing at ${existingByName.path}, duplicate at ${moduleRef.path}`);
+                        }
+                    }
+                    // 确保新模块的 optional 属性为 false
+                    const newModuleRef = {
+                        ...moduleRef,
+                        optional: false,
+                    };
+                    moduleMap.set(key, newModuleRef);
+                    // 同时更新 nameMap
+                    if (nameMap.get(existingRef.name) === existingRef) {
+                        nameMap.delete(existingRef.name);
+                    }
+                    // 如果名称不同，需要更新 nameMap
+                    if (existingRef.name !== newModuleRef.name) {
+                        nameMap.delete(existingRef.name);
+                    }
+                    nameMap.set(newModuleRef.name, newModuleRef);
+                    continue;
+                }
+                // 如果都是 optional 或都是非 optional，保留第一个
+                continue;
+            }
+            // 检查模块名称是否重复
+            const existingByName = nameMap.get(moduleRef.name);
+            if (existingByName) {
+                // 如果名称重复但路径不同，直接报错
+                throw new Error(`Duplicate module name "${moduleRef.name}" found: existing at ${existingByName.path}, duplicate at ${moduleRef.path}`);
+            }
+            // 添加新模块
+            moduleMap.set(key, moduleRef);
+            nameMap.set(moduleRef.name, moduleRef);
+        }
+        return Array.from(moduleMap.values());
+    }
 }
 exports.ModuleConfigUtil = ModuleConfigUtil;
 _a = ModuleConfigUtil, _ModuleConfigUtil_loadOne = async function _ModuleConfigUtil_loadOne(moduleDir, configName) {
@@ -319,4 +383,4 @@ _a = ModuleConfigUtil, _ModuleConfigUtil_loadOne = async function _ModuleConfigU
     const moduleYamlContent = node_fs_1.default.readFileSync(moduleYamlPath, 'utf8');
     return js_yaml_1.default.safeLoad(moduleYamlContent);
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ModuleConfig.js","sourceRoot":"","sources":["../../src/ModuleConfig.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ModuleConfig.js","sourceRoot":"","sources":["../../src/ModuleConfig.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@eggjs/tegg-common-util",
   "description": "common util for tegg",
-  "version": "3.61.0",
+  "version": "3.62.1",
   "keywords": [
     "egg",
     "typescript",
@@ -36,7 +36,7 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "@eggjs/tegg-types": "^3.61.0",
+    "@eggjs/tegg-types": "^3.62.1",
     "extend2": "^1.0.0",
     "globby": "^11.1.0",
     "js-yaml": "^3.14.0"
@@ -52,5 +52,5 @@
     "ts-node": "^10.9.1",
     "typescript": "^5.0.4"
   },
-  "gitHead": "9a4a2db96ad85909b34de22f222950933f95b19a"
+  "gitHead": "cfdf1ca3a8e187679f2046a58258f5104b29a086"
 }