@zdavison/nestjs-rpc-toolkit 0.0.11 → 0.0.13

package/dist/generators/rpc-types-generator.js

@@ -47,8 +47,11 @@ class RpcTypesGenerator {
         this.packageFiles = new Map();
         this.expandedPackages = [];
         this.fileToModuleMap = new Map();
+        // Load configuration
         this.config = this.loadConfig();
+        // Expand wildcard patterns in package paths
         this.expandedPackages = this.expandPackagePaths(this.config.packages);
+        // Initialize a separate project for each package
         this.expandedPackages.forEach(packagePath => {
             this.initializePackageProject(packagePath);
         });
@@ -57,6 +60,7 @@ class RpcTypesGenerator {
         const expandedPaths = [];
         for (const packagePath of packagePaths) {
             if (packagePath.includes('*')) {
+                // Use glob to expand wildcard patterns
                 const matches = glob_1.glob.sync(packagePath, {
                     cwd: this.options.rootDir
                 }).filter(match => {
@@ -66,9 +70,11 @@ class RpcTypesGenerator {
                 expandedPaths.push(...matches);
             }
             else {
+                // Regular path, add as-is
                 expandedPaths.push(packagePath);
             }
         }
+        // Filter out duplicates and ensure all paths exist
         const uniquePaths = [...new Set(expandedPaths)];
         return uniquePaths.filter(packagePath => {
             const fullPath = path.join(this.options.rootDir, packagePath);
@@ -81,21 +87,26 @@ class RpcTypesGenerator {
     }
     initializePackageProject(packagePath) {
         const fullPath = path.join(this.options.rootDir, packagePath);
+        // Find all TypeScript files in this package
         const files = glob_1.glob.sync('src/**/*.ts', {
             cwd: fullPath,
             absolute: true
         });
         this.packageFiles.set(packagePath, files);
+        // Find the most appropriate tsconfig for this package
         const tsConfigPath = this.findTsConfigForPackage(fullPath);
+        // Create a project for this package
         const project = new ts_morph_1.Project({
             tsConfigFilePath: tsConfigPath,
         });
+        // Add source files to the project
         files.forEach(file => {
             project.addSourceFileAtPath(file);
         });
         this.projects.set(packagePath, project);
     }
     findTsConfigForPackage(packagePath) {
+        // Check for package-specific tsconfig files in order of preference
         const possibleConfigs = [
             path.join(packagePath, 'tsconfig.json'),
             path.join(packagePath, 'tsconfig.build.json'),
@@ -105,15 +116,17 @@ class RpcTypesGenerator {
                 return configPath;
             }
         }
+        // Fall back to searching for root tsconfig files
         const rootConfigs = [
-            path.join(this.options.rootDir, 'tsconfig.base.json'),
             path.join(this.options.rootDir, 'tsconfig.json'),
+            path.join(this.options.rootDir, 'tsconfig.base.json'),
         ];
         for (const configPath of rootConfigs) {
             if (fs.existsSync(configPath)) {
                 return configPath;
             }
         }
+        // If no tsconfig found, create a minimal one in memory
         throw new Error(`No tsconfig found for package ${packagePath}. Please ensure the package has a tsconfig.json or the root has tsconfig.base.json/tsconfig.json`);
     }
     loadConfig() {
@@ -124,15 +137,18 @@ class RpcTypesGenerator {
     }
     generate() {
         console.log(`🔍 Scanning ${this.projects.size} packages for RPC methods...`);
+        // First pass: scan for RPC methods to establish module mapping
         this.projects.forEach((project, packagePath) => {
             const sourceFiles = project.getSourceFiles();
             const relevantFiles = sourceFiles.filter(sf => !sf.getFilePath().includes('node_modules') &&
                 !sf.getFilePath().includes('/dist/'));
             console.log(`   📦 ${packagePath}: scanning ${relevantFiles.length} TypeScript files`);
+            // First, find all RPC methods to establish file-to-module mapping
             relevantFiles.forEach(sourceFile => {
                 this.scanForRpcMethods(sourceFile);
             });
         });
+        // Second pass: extract interfaces/DTOs with correct module associations
         this.projects.forEach((project) => {
             const sourceFiles = project.getSourceFiles();
             const relevantFiles = sourceFiles.filter(sf => !sf.getFilePath().includes('node_modules') &&
@@ -142,6 +158,7 @@ class RpcTypesGenerator {
                 this.extractTypesFromFile(sourceFile);
             });
         });
+        // Generate the aggregated types file
         this.generateTypesFile();
     }
     scanForRpcMethods(sourceFile) {
@@ -150,9 +167,12 @@ class RpcTypesGenerator {
                 const method = node;
                 const rpcMethod = this.processMethod(method, sourceFile);
                 if (rpcMethod) {
+                    // Map this file to the module determined by the RPC pattern
                     const module = rpcMethod.module;
+                    // Map the entire directory to this module (since DTOs might be in separate files)
                     const dir = path.dirname(sourceFile.getFilePath());
                     this.fileToModuleMap.set(dir, module);
+                    // Also map parent src directory for this module
                     const srcDir = dir.replace(/\/[^\/]+$/, '');
                     if (srcDir.endsWith('/src')) {
                         this.fileToModuleMap.set(srcDir, module);
@@ -169,17 +189,22 @@ class RpcTypesGenerator {
             else if (node.getKind() === ts_morph_1.ts.SyntaxKind.ClassDeclaration) {
                 this.extractClassAsInterface(node, sourceFile);
             }
+            else if (node.getKind() === ts_morph_1.ts.SyntaxKind.TypeAliasDeclaration) {
+                this.extractTypeAlias(node, sourceFile);
+            }
         });
     }
     extractInterface(interfaceDeclaration, sourceFile) {
         const name = interfaceDeclaration.getName();
         const source = interfaceDeclaration.getText();
         const moduleName = this.getModuleForFile(sourceFile.getFilePath());
+        const jsDoc = this.extractJsDoc(interfaceDeclaration);
         if (name && this.isRelevantInterface(name) && !this.isInternalType(name)) {
             this.interfaces.set(name, {
                 name,
                 source,
-                module: moduleName
+                module: moduleName,
+                jsDoc
             });
         }
     }
@@ -187,28 +212,78 @@ class RpcTypesGenerator {
         const name = classDeclaration.getName();
         if (!name || !this.isRelevantInterface(name) || this.isInternalType(name))
             return;
+        // Extract generic type parameters from class
+        const typeParameters = classDeclaration.getTypeParameters();
+        const typeParamsStr = typeParameters.length > 0
+            ? `<${typeParameters.map((tp) => {
+                const tpName = tp.getName();
+                const constraint = tp.getConstraint();
+                const defaultType = tp.getDefault();
+                let result = tpName;
+                if (constraint) {
+                    result += ` extends ${constraint.getText()}`;
+                }
+                if (defaultType) {
+                    result += ` = ${defaultType.getText()}`;
+                }
+                return result;
+            }).join(', ')}>`
+            : '';
+        // Extract DTO classes as interfaces
         const properties = classDeclaration.getProperties()
             .filter((prop) => !prop.hasModifier(ts_morph_1.ts.SyntaxKind.PrivateKeyword))
             .map((prop) => {
             const propName = prop.getName();
+            // Get the type as declared in the source, not the resolved type
             let propType = 'any';
             const typeNode = prop.getTypeNode();
             if (typeNode) {
                 propType = typeNode.getText();
             }
             else {
+                // Fallback: try to get a simple representation of the type
                 const fullType = prop.getType().getText();
+                // Clean up the type string - remove import paths and keep it simple
                 propType = this.cleanTypeString(fullType);
             }
-            return `  ${propName}: ${propType};`;
+            // Extract JSDoc for the property
+            const propJsDoc = this.extractJsDoc(prop);
+            const propJsDocStr = propJsDoc ? `${propJsDoc}\n` : '';
+            return `${propJsDocStr}  ${propName}: ${propType};`;
         });
         if (properties.length > 0) {
-            const source = `export interface ${name} {\n${properties.join('\n')}\n}`;
+            // Extract JSDoc for the class
+            const classJsDoc = this.extractJsDoc(classDeclaration);
+            const classJsDocStr = classJsDoc ? `${classJsDoc}\n` : '';
+            const source = `${classJsDocStr}export interface ${name}${typeParamsStr} {\n${properties.join('\n')}\n}`;
             const moduleName = this.getModuleForFile(sourceFile.getFilePath());
             this.interfaces.set(name, {
                 name,
                 source,
-                module: moduleName
+                module: moduleName,
+                jsDoc: classJsDoc
+            });
+        }
+    }
+    extractTypeAlias(typeAliasDeclaration, sourceFile) {
+        const name = typeAliasDeclaration.getName();
+        let source = typeAliasDeclaration.getText();
+        const moduleName = this.getModuleForFile(sourceFile.getFilePath());
+        const jsDoc = this.extractJsDoc(typeAliasDeclaration);
+        // Ensure the source has export keyword
+        if (!source.startsWith('export ')) {
+            source = `export ${source}`;
+        }
+        // Prepend JSDoc if available
+        if (jsDoc) {
+            source = `${jsDoc}\n${source}`;
+        }
+        if (name && this.isRelevantInterface(name) && !this.isInternalType(name)) {
+            this.interfaces.set(name, {
+                name,
+                source,
+                module: moduleName,
+                jsDoc
             });
         }
     }
@@ -216,10 +291,13 @@ class RpcTypesGenerator {
         return !this.isInternalType(name);
     }
     getModuleForFile(filePath) {
+        // Check if this file's directory has been mapped to a module
         const dir = path.dirname(filePath);
+        // First check exact directory match
         if (this.fileToModuleMap.has(dir)) {
             return this.fileToModuleMap.get(dir);
         }
+        // Check parent directories (DTOs might be in subdirectories)
         let currentDir = dir;
         while (currentDir.includes('/src')) {
             if (this.fileToModuleMap.has(currentDir)) {
@@ -230,12 +308,14 @@ class RpcTypesGenerator {
         return 'unknown';
     }
     isInternalType(name) {
+        // Filter out generator internal types
         return name === 'InterfaceDefinition' ||
             name === 'RpcMethodInfo' ||
             name === 'RpcGenerationConfig' ||
             name === 'GeneratorOptions';
     }
     processMethod(method, sourceFile) {
+        // Check for @RpcMethod decorator
         const rpcDecorator = method.getDecorators().find(decorator => {
             const decoratorName = decorator.getName();
             return decoratorName === 'RpcMethod';
@@ -243,6 +323,7 @@ class RpcTypesGenerator {
         if (!rpcDecorator)
             return null;
         const methodName = method.getName() || 'unknown';
+        // Check if this method is in a class with @RpcController decorator
         const classDeclaration = method.getParent();
         let rpcControllerDecorator = null;
         if (classDeclaration && 'getDecorators' in classDeclaration) {
@@ -250,9 +331,11 @@ class RpcTypesGenerator {
                 return decorator.getName() === 'RpcController';
             });
         }
+        // Only process methods from classes with @RpcController decorator
         if (!rpcControllerDecorator) {
-            return null;
+            return null; // Skip methods not in @RpcController classes
         }
+        // Generate module prefix like the @RpcController decorator does
         let modulePrefix;
         const args = rpcControllerDecorator.getArguments();
         if (args.length > 0 && args[0]) {
@@ -261,25 +344,42 @@ class RpcTypesGenerator {
                 modulePrefix = arg.getLiteralValue();
             }
             else {
+                // Fallback to class name inference
                 const className = method.getParent()?.getSymbol()?.getName() || 'unknown';
                 modulePrefix = className.replace(/(Service|Application|Handler|Repository)$/, '').toLowerCase();
             }
         }
         else {
+            // @RpcController() without arguments - infer from class name
             const className = method.getParent()?.getSymbol()?.getName() || 'unknown';
             modulePrefix = className.replace(/(Service|Application|Handler|Repository)$/, '').toLowerCase();
         }
+        // Generate the pattern
         const pattern = `${modulePrefix}.${methodName}`;
+        // All patterns should now be prefixed (module.method), so extract module
         if (!pattern.includes('.')) {
             console.warn(`⚠️  RPC pattern '${pattern}' should have module prefix. This might be from an older decorator.`);
             return null;
         }
         const moduleName = pattern.split('.')[0];
+        // Extract parameter information
         const paramTypes = method.getParameters().map(param => ({
             name: param.getName(),
             type: this.cleanTypeString(param.getType().getText()),
         }));
+        // Extract return type
         const returnType = this.cleanReturnType(method.getReturnType().getText());
+        // Extract generic type parameters
+        const typeParameters = method.getTypeParameters().map(tp => {
+            const name = tp.getName();
+            const constraint = tp.getConstraint();
+            if (constraint) {
+                return `${name} extends ${constraint.getText()}`;
+            }
+            return name;
+        });
+        // Extract JSDoc comment
+        const jsDocComment = this.extractJsDoc(method);
         const rpcMethod = {
             pattern,
             methodName,
@@ -287,17 +387,22 @@ class RpcTypesGenerator {
             paramTypes,
             returnType,
             sourceFile: sourceFile.getFilePath(),
+            typeParameters: typeParameters.length > 0 ? typeParameters : undefined,
+            jsDoc: jsDocComment,
         };
         this.rpcMethods.push(rpcMethod);
         return rpcMethod;
     }
-    extractPattern(arg) {
-        if (arg && typeof arg.getLiteralValue === 'function') {
-            return arg.getLiteralValue();
-        }
-        return null;
+    extractJsDoc(node) {
+        const jsDocs = node.getJsDocs();
+        if (!jsDocs || jsDocs.length === 0)
+            return undefined;
+        // Get the full text of the JSDoc comment
+        const jsDocText = jsDocs.map((doc) => doc.getText()).join('\n');
+        return jsDocText;
     }
     generateTypesFile() {
+        // Group methods by module
         const moduleGroups = this.rpcMethods.reduce((groups, method) => {
             if (!groups[method.module]) {
                 groups[method.module] = [];
@@ -305,6 +410,7 @@ class RpcTypesGenerator {
             groups[method.module].push(method);
             return groups;
         }, {});
+        // Group interfaces by module
         const interfacesByModule = new Map();
         this.interfaces.forEach(interfaceDef => {
             if (!interfacesByModule.has(interfaceDef.module)) {
@@ -312,25 +418,56 @@ class RpcTypesGenerator {
             }
             interfacesByModule.get(interfaceDef.module).push(interfaceDef);
         });
+        // Generate separate file for each module
         Object.entries(moduleGroups).forEach(([moduleName, methods]) => {
             this.generateModuleTypesFile(moduleName, methods, interfacesByModule.get(moduleName) || []);
         });
+        // Generate the main types file that composes all modules
         this.generateMainTypesFile(moduleGroups);
     }
     generateModuleTypesFile(moduleName, methods, interfaces) {
+        // Collect all type names referenced in RPC methods
         const referencedTypes = new Set();
+        const genericTypeParamNames = new Set();
         methods.forEach(method => {
+            // Track generic type parameter names to exclude from imports
+            if (method.typeParameters) {
+                method.typeParameters.forEach(typeParam => {
+                    // Extract just the parameter name (before 'extends' if present)
+                    const paramName = typeParam.split(' ')[0];
+                    genericTypeParamNames.add(paramName);
+                });
+            }
+            // Extract types from parameters
             method.paramTypes.forEach(param => {
                 this.extractTypeNames(param.type).forEach(typeName => {
-                    referencedTypes.add(typeName);
+                    if (!genericTypeParamNames.has(typeName)) {
+                        referencedTypes.add(typeName);
+                    }
                 });
             });
+            // Extract types from return type
             this.extractTypeNames(method.returnType).forEach(typeName => {
-                referencedTypes.add(typeName);
+                if (!genericTypeParamNames.has(typeName)) {
+                    referencedTypes.add(typeName);
+                }
             });
+            // Extract types from generic type parameters (constraints only)
+            if (method.typeParameters) {
+                method.typeParameters.forEach(typeParam => {
+                    this.extractTypeNames(typeParam).forEach(typeName => {
+                        if (!genericTypeParamNames.has(typeName)) {
+                            referencedTypes.add(typeName);
+                        }
+                    });
+                });
+            }
         });
+        // Include interfaces that are actually referenced, from this module or others
         const referencedInterfaces = [];
+        // First add interfaces from this module
         interfaces.filter(interfaceDef => referencedTypes.has(interfaceDef.name)).forEach(interfaceDef => referencedInterfaces.push(interfaceDef));
+        // Then add interfaces from other modules that are referenced
         this.interfaces.forEach(interfaceDef => {
             if (referencedTypes.has(interfaceDef.name) &&
                 interfaceDef.module !== moduleName &&
@@ -339,10 +476,15 @@ class RpcTypesGenerator {
             }
         });
         const moduleInterfaces = referencedInterfaces.map(interfaceDef => interfaceDef.source).join('\n\n');
+        // Generate domain interface for this module
         const domainMethodDefinitions = methods.map(method => {
             const methodNameWithoutModule = method.methodName;
             const paramsType = this.generateParamsType(method.paramTypes);
-            return `  ${methodNameWithoutModule}(params: ${paramsType}): Promise<${method.returnType}>;`;
+            const typeParams = method.typeParameters && method.typeParameters.length > 0
+                ? `<${method.typeParameters.join(', ')}>`
+                : '';
+            const jsDocComment = method.jsDoc ? `${method.jsDoc}\n` : '';
+            return `${jsDocComment}  ${methodNameWithoutModule}${typeParams}(params: ${paramsType}): Promise<${method.returnType}>;`;
         }).join('\n');
         const domainInterface = `// Domain interface for ${moduleName} module
 export interface ${this.toCamelCase(moduleName)}Domain {
@@ -358,22 +500,46 @@ ${moduleInterfaces}
 
 ${domainInterface}
 `;
+        // Write to configured output directory
         const outputPath = path.join(this.options.rootDir, this.config.outputDir, `${moduleName}.rpc.gen.ts`);
         fs.writeFileSync(outputPath, fileContent, 'utf8');
     }
     generateMainTypesFile(moduleGroups) {
         const hasModules = Object.keys(moduleGroups).length > 0;
+        // Generate imports from module files - include domain interfaces and types
         const moduleImports = Object.keys(moduleGroups).map(moduleName => {
+            // Collect all types referenced in this module's methods
             const referencedTypes = new Set();
+            const genericTypeParamNames = new Set();
             moduleGroups[moduleName].forEach(method => {
+                // Track generic type parameter names to exclude from imports
+                if (method.typeParameters) {
+                    method.typeParameters.forEach(typeParam => {
+                        const paramName = typeParam.split(' ')[0];
+                        genericTypeParamNames.add(paramName);
+                    });
+                }
                 method.paramTypes.forEach(param => {
                     this.extractTypeNames(param.type).forEach(typeName => {
-                        referencedTypes.add(typeName);
+                        if (!genericTypeParamNames.has(typeName)) {
+                            referencedTypes.add(typeName);
+                        }
                     });
                 });
                 this.extractTypeNames(method.returnType).forEach(typeName => {
-                    referencedTypes.add(typeName);
+                    if (!genericTypeParamNames.has(typeName)) {
+                        referencedTypes.add(typeName);
+                    }
                 });
+                if (method.typeParameters) {
+                    method.typeParameters.forEach(typeParam => {
+                        this.extractTypeNames(typeParam).forEach(typeName => {
+                            if (!genericTypeParamNames.has(typeName)) {
+                                referencedTypes.add(typeName);
+                            }
+                        });
+                    });
+                }
             });
             const typesList = Array.from(referencedTypes).filter(type => !this.isBuiltInType(type) && !this.isInternalType(type));
             const imports = [`${this.toCamelCase(moduleName)}Domain`];
@@ -382,17 +548,40 @@ ${domainInterface}
             }
             return `import { ${imports.join(', ')} } from './${moduleName}.rpc.gen';`;
         }).join('\n');
+        // Generate selective re-exports to avoid type conflicts
         const moduleReExports = Object.keys(moduleGroups).map(moduleName => {
+            // Collect all types referenced in this module's methods
             const referencedTypes = new Set();
+            const genericTypeParamNames = new Set();
             moduleGroups[moduleName].forEach(method => {
+                // Track generic type parameter names to exclude from exports
+                if (method.typeParameters) {
+                    method.typeParameters.forEach(typeParam => {
+                        const paramName = typeParam.split(' ')[0];
+                        genericTypeParamNames.add(paramName);
+                    });
+                }
                 method.paramTypes.forEach(param => {
                     this.extractTypeNames(param.type).forEach(typeName => {
-                        referencedTypes.add(typeName);
+                        if (!genericTypeParamNames.has(typeName)) {
+                            referencedTypes.add(typeName);
+                        }
                     });
                 });
                 this.extractTypeNames(method.returnType).forEach(typeName => {
-                    referencedTypes.add(typeName);
+                    if (!genericTypeParamNames.has(typeName)) {
+                        referencedTypes.add(typeName);
+                    }
                 });
+                if (method.typeParameters) {
+                    method.typeParameters.forEach(typeParam => {
+                        this.extractTypeNames(typeParam).forEach(typeName => {
+                            if (!genericTypeParamNames.has(typeName)) {
+                                referencedTypes.add(typeName);
+                            }
+                        });
+                    });
+                }
             });
             const typesList = Array.from(referencedTypes).filter(type => !this.isBuiltInType(type) && !this.isInternalType(type));
             const exports = [`${this.toCamelCase(moduleName)}Domain`];
@@ -401,12 +590,20 @@ ${domainInterface}
             }
             return `export { ${exports.join(', ')} } from './${moduleName}.rpc.gen';`;
         }).join('\n');
+        // Generate common type re-exports from their original modules
         const commonTypeExports = this.generateCommonTypeExports(moduleGroups);
+        // Generate RPC client interface using imported domain interfaces
+        // Always export IRpcClient to avoid import errors, even when empty
         const rpcClientInterface = hasModules ? `
 // Domain-scoped RPC client interface
 export interface IRpcClient {
 ${Object.keys(moduleGroups).map(moduleName => `  ${moduleName}: ${this.toCamelCase(moduleName)}Domain;`).join('\n')}
-}` : '';
+}` : `
+// Empty RPC client interface (no RPC methods found yet)
+// Run the type generator after adding @RpcMethod decorators to populate this
+export interface IRpcClient {
+  // No RPC domains available
+}`;
         const fileContent = `// Auto-generated RPC types from all modules
 // Do not edit this file manually - it will be overwritten
 //
@@ -430,7 +627,9 @@ ${rpcClientInterface}
 // const user = await rpc.user.findOne({ id: 'user123' });
 // const products = await rpc.product.findByOwner({ ownerId: 'user123' });
 `;
+        // Write to configured output directory
         const outputPath = path.join(this.options.rootDir, this.config.outputDir, 'all.rpc.gen.ts');
+        // Ensure directory exists
         const outputDir = path.dirname(outputPath);
         if (!fs.existsSync(outputDir)) {
             fs.mkdirSync(outputDir, { recursive: true });
@@ -456,20 +655,19 @@ ${rpcClientInterface}
         return `{ ${paramStrings.join('; ')} }`;
     }
     cleanReturnType(returnType) {
+        // Remove Promise wrapper if present
         let cleanType = returnType;
         const promiseMatch = returnType.match(/Promise<(.+)>/);
         if (promiseMatch) {
             cleanType = promiseMatch[1];
         }
+        // Remove all import paths and use simple type names
         cleanType = cleanType.replace(/import\("[^"]*"\)\./g, '');
         return cleanType;
     }
     cleanTypeString(typeStr) {
+        // Remove import paths and keep only the type name
         let cleanType = typeStr.replace(/import\("[^"]*"\)\./g, '');
-        cleanType = cleanType.replace(/CreateUserDto/g, 'CreateUserDto');
-        cleanType = cleanType.replace(/CreateProductDto/g, 'CreateProductDto');
-        cleanType = cleanType.replace(/UpdateUserDto/g, 'Partial<CreateUserDto>');
-        cleanType = cleanType.replace(/UpdateProductDto/g, 'Partial<CreateProductDto>');
         return cleanType;
     }
     toCamelCase(str) {
@@ -477,10 +675,13 @@ ${rpcClientInterface}
     }
     extractTypeNames(typeString) {
         const typeNames = new Set();
+        // Match type names (letters, numbers, underscore, $)
+        // This regex will match identifiers that could be type names
         const typeNameRegex = /\b[A-Z][a-zA-Z0-9_$]*\b/g;
         const matches = typeString.match(typeNameRegex);
         if (matches) {
             matches.forEach(match => {
+                // Exclude built-in types and common generic types
                 if (!this.isBuiltInType(match)) {
                     typeNames.add(match);
                 }
@@ -493,22 +694,53 @@ ${rpcClientInterface}
             'Array', 'Object', 'String', 'Number', 'Boolean',
             'Promise', 'Date', 'RegExp', 'Error', 'Map', 'Set',
             'Record', 'Partial', 'Required', 'Readonly', 'Pick', 'Omit',
+            // Node.js types that shouldn't be imported
             'Buffer', 'Stream', 'EventEmitter', 'Socket',
+            // DOM types that shouldn't be imported
             'HTMLElement', 'Document', 'Window', 'Event', 'FileList', 'File', 'Blob',
+            // TypeScript utility types
             'Function', 'CallbackFunction'
         ];
         return builtInTypes.includes(typeName);
     }
     generateCommonTypeExports(moduleGroups) {
+        // Find types that are used across modules and determine their "primary" module
         const typeToModulesMap = new Map();
         const typeToOriginalModule = new Map();
+        // Track which types are used by which modules
         Object.entries(moduleGroups).forEach(([moduleName, methods]) => {
+            const genericTypeParamNames = new Set();
             methods.forEach(method => {
+                // Track generic type parameter names to exclude
+                if (method.typeParameters) {
+                    method.typeParameters.forEach(typeParam => {
+                        const paramName = typeParam.split(' ')[0];
+                        genericTypeParamNames.add(paramName);
+                    });
+                }
+                // Extract types from parameters and return types
                 const allTypes = new Set();
                 method.paramTypes.forEach(param => {
-                    this.extractTypeNames(param.type).forEach(typeName => allTypes.add(typeName));
+                    this.extractTypeNames(param.type).forEach(typeName => {
+                        if (!genericTypeParamNames.has(typeName)) {
+                            allTypes.add(typeName);
+                        }
+                    });
                 });
-                this.extractTypeNames(method.returnType).forEach(typeName => allTypes.add(typeName));
+                this.extractTypeNames(method.returnType).forEach(typeName => {
+                    if (!genericTypeParamNames.has(typeName)) {
+                        allTypes.add(typeName);
+                    }
+                });
+                if (method.typeParameters) {
+                    method.typeParameters.forEach(typeParam => {
+                        this.extractTypeNames(typeParam).forEach(typeName => {
+                            if (!genericTypeParamNames.has(typeName)) {
+                                allTypes.add(typeName);
+                            }
+                        });
+                    });
+                }
                 allTypes.forEach(typeName => {
                     if (!typeToModulesMap.has(typeName)) {
                         typeToModulesMap.set(typeName, new Set());
@@ -517,11 +749,13 @@ ${rpcClientInterface}
                 });
             });
         });
+        // Find the original module for each type
         this.interfaces.forEach(interfaceDef => {
             if (!typeToOriginalModule.has(interfaceDef.name)) {
                 typeToOriginalModule.set(interfaceDef.name, interfaceDef.module);
             }
         });
+        // Generate exports for types that are used across multiple modules
         const exports = [];
         typeToModulesMap.forEach((modules, typeName) => {
             if (modules.size > 1 && typeToOriginalModule.has(typeName)) {