@zdavison/nestjs-rpc-toolkit 0.1.5 → 0.2.0

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

@@ -38,7 +38,6 @@ const ts_morph_1 = require("ts-morph");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const glob_1 = require("glob");
-const package_manager_utils_1 = require("../utils/package-manager.utils");
 class RpcTypesGenerator {
     constructor(options) {
         this.options = options;
@@ -49,12 +48,19 @@ class RpcTypesGenerator {
         this.packageFiles = new Map();
         this.expandedPackages = [];
         this.fileToModuleMap = new Map();
-        // Map of type name -> package it's imported from
-        this.typeToPackageMap = new Map();
-        // Set of all external packages that are imported in generated files
-        this.externalPackagesUsed = new Set();
-        // Map of package name -> version (from source package.json files)
-        this.packageVersionMap = new Map();
+        /** Maps type names to their codec fields (field name -> codec name) */
+        this.codecFields = new Map();
+        /** Pending nested type checks to resolve after all types are processed */
+        this.pendingNestedTypes = new Map();
+        /**
+         * Built-in codec mappings: source type -> { codecName, wireType }
+         * Extensible: add more entries to support additional types.
+         */
+        this.codecMappings = {
+            'Date': { codecName: 'Date', wireType: 'string' },
+            // Future: 'BigInt': { codecName: 'BigInt', wireType: 'string' },
+            // Future: 'Buffer': { codecName: 'Buffer', wireType: 'string' },
+        };
         // Load configuration
         this.config = this.loadConfig();
         // Expand wildcard patterns in package paths
@@ -166,9 +172,33 @@ class RpcTypesGenerator {
                 this.extractTypesFromFile(sourceFile);
             });
         });
+        // Third pass: resolve nested type references (fields that reference types with codec fields)
+        this.resolveNestedTypeReferences();
         // Generate the aggregated types file
         this.generateTypesFile();
     }
+    /**
+     * Resolve pending nested type references.
+     * For each type, check if any of its fields reference other types that have codec fields.
+     * If so, add a nested type reference (prefixed with @) to the codec fields.
+     */
+    resolveNestedTypeReferences() {
+        this.pendingNestedTypes.forEach((pendingChecks, typeName) => {
+            pendingChecks.forEach(({ propName, typeName: nestedTypeName }) => {
+                // Check if the referenced type has codec fields
+                if (this.codecFields.has(nestedTypeName)) {
+                    // Add a nested type reference to the parent type's codec fields
+                    let typeCodecFields = this.codecFields.get(typeName);
+                    if (!typeCodecFields) {
+                        typeCodecFields = new Map();
+                        this.codecFields.set(typeName, typeCodecFields);
+                    }
+                    // Use @ prefix to indicate a nested type reference
+                    typeCodecFields.set(propName, `@${nestedTypeName}`);
+                }
+            });
+        });
+    }
     scanForRpcMethods(sourceFile) {
         sourceFile.forEachDescendant((node) => {
             if (node.getKind() === ts_morph_1.ts.SyntaxKind.MethodDeclaration) {
@@ -190,8 +220,6 @@ class RpcTypesGenerator {
         });
     }
     extractTypesFromFile(sourceFile) {
-        // First, extract import information
-        this.extractImports(sourceFile);
         sourceFile.forEachDescendant((node) => {
             if (node.getKind() === ts_morph_1.ts.SyntaxKind.InterfaceDeclaration) {
                 this.extractInterface(node, sourceFile);
@@ -207,64 +235,47 @@ class RpcTypesGenerator {
             }
         });
     }
-    extractImports(sourceFile) {
-        const importDeclarations = sourceFile.getImportDeclarations();
-        importDeclarations.forEach(importDecl => {
-            const moduleSpecifier = importDecl.getModuleSpecifierValue();
-            // Only track imports from packages (not relative imports)
-            if (!moduleSpecifier.startsWith('.') && !moduleSpecifier.startsWith('/')) {
-                const namedImports = importDecl.getNamedImports();
-                namedImports.forEach(namedImport => {
-                    const importedName = namedImport.getName();
-                    this.typeToPackageMap.set(importedName, moduleSpecifier);
-                });
-                // Try to resolve package version from the source file's package.json
-                if (!this.packageVersionMap.has(moduleSpecifier)) {
-                    const version = this.resolvePackageVersion(sourceFile.getFilePath(), moduleSpecifier);
-                    if (version) {
-                        this.packageVersionMap.set(moduleSpecifier, version);
-                    }
-                }
-            }
-        });
-    }
-    resolvePackageVersion(sourceFilePath, packageName) {
-        // Walk up from the source file to find package.json
-        let currentDir = path.dirname(sourceFilePath);
-        while (currentDir !== path.dirname(currentDir)) { // Stop at root
-            const packageJsonPath = path.join(currentDir, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
-                try {
-                    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-                    // Check dependencies and devDependencies
-                    const version = packageJson.dependencies?.[packageName] ||
-                        packageJson.devDependencies?.[packageName];
-                    if (version) {
-                        return version;
-                    }
-                }
-                catch (error) {
-                    // Ignore and continue searching
-                }
-            }
-            currentDir = path.dirname(currentDir);
-        }
-        return null;
-    }
     extractInterface(interfaceDeclaration, sourceFile) {
         const name = interfaceDeclaration.getName();
-        const jsDoc = this.extractJsDoc(interfaceDeclaration);
-        let source = interfaceDeclaration.getText();
-        // Prepend JSDoc if available and not already in source
-        if (jsDoc && !source.startsWith('/**')) {
-            source = `${jsDoc}\n${source}`;
-        }
-        // Ensure the source has export keyword
-        if (!source.includes('export interface')) {
-            source = source.replace(/^(\/\*\*[\s\S]*?\*\/\n)?interface/, '$1export interface');
-        }
         const moduleName = this.getModuleForFile(sourceFile.getFilePath());
+        const jsDoc = this.extractJsDoc(interfaceDeclaration);
         if (name && this.isRelevantInterface(name) && !this.isInternalType(name)) {
+            // Track codec fields and transform the interface source
+            const typeCodecFields = new Map();
+            // Track nested type references (for fields whose type has codec fields)
+            const pendingNestedTypeChecks = [];
+            const properties = interfaceDeclaration.getProperties();
+            let source = interfaceDeclaration.getText();
+            // Check each property for codec-handled types
+            properties.forEach((prop) => {
+                const propName = prop.getName();
+                const typeNode = prop.getTypeNode();
+                if (typeNode) {
+                    const propType = typeNode.getText();
+                    const codecInfo = this.getCodecForType(propType);
+                    if (codecInfo) {
+                        typeCodecFields.set(propName, codecInfo.codecName);
+                        // Replace the type with wire type in the source
+                        const newType = codecInfo.wireType;
+                        source = source.replace(new RegExp(`(${propName}\\s*[?]?\\s*:\\s*)${propType.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`, 'g'), `$1${newType}`);
+                    }
+                    else {
+                        // Check if this is a reference to another type (potential nested type)
+                        const extractedType = this.extractMainTypeName(propType);
+                        if (extractedType && !this.isBuiltInType(extractedType)) {
+                            pendingNestedTypeChecks.push({ propName, typeName: extractedType });
+                        }
+                    }
+                }
+            });
+            // Store codec fields for this type
+            if (typeCodecFields.size > 0) {
+                this.codecFields.set(name, typeCodecFields);
+            }
+            // Store pending nested type checks to resolve after all types are processed
+            if (pendingNestedTypeChecks.length > 0) {
+                this.pendingNestedTypes.set(name, pendingNestedTypeChecks);
+            }
             this.interfaces.set(name, {
                 name,
                 source,
@@ -294,6 +305,10 @@ class RpcTypesGenerator {
                 return result;
             }).join(', ')}>`
             : '';
+        // Track codec fields for this type
+        const typeCodecFields = new Map();
+        // Track nested type references (for fields whose type has codec fields)
+        const pendingNestedTypeChecks = [];
         // Extract DTO classes as interfaces
         const properties = classDeclaration.getProperties()
             .filter((prop) => !prop.hasModifier(ts_morph_1.ts.SyntaxKind.PrivateKeyword))
@@ -311,11 +326,32 @@ class RpcTypesGenerator {
                 // Clean up the type string - remove import paths and keep it simple
                 propType = this.cleanTypeString(fullType);
             }
+            // Check if this type needs a codec and convert to wire type
+            const codecInfo = this.getCodecForType(propType);
+            if (codecInfo) {
+                typeCodecFields.set(propName, codecInfo.codecName);
+                propType = codecInfo.wireType;
+            }
+            else {
+                // Check if this is a reference to another type (potential nested type)
+                const extractedType = this.extractMainTypeName(propType);
+                if (extractedType && !this.isBuiltInType(extractedType)) {
+                    pendingNestedTypeChecks.push({ propName, typeName: extractedType });
+                }
+            }
             // Extract JSDoc for the property
             const propJsDoc = this.extractJsDoc(prop);
             const propJsDocStr = propJsDoc ? `${propJsDoc}\n` : '';
             return `${propJsDocStr}  ${propName}: ${propType};`;
         });
+        // Store codec fields for this type
+        if (typeCodecFields.size > 0) {
+            this.codecFields.set(name, typeCodecFields);
+        }
+        // Store pending nested type checks to resolve after all types are processed
+        if (pendingNestedTypeChecks.length > 0) {
+            this.pendingNestedTypes.set(name, pendingNestedTypeChecks);
+        }
         if (properties.length > 0) {
             // Extract JSDoc for the class
             const classJsDoc = this.extractJsDoc(classDeclaration);
@@ -330,6 +366,27 @@ class RpcTypesGenerator {
             });
         }
     }
+    /**
+     * Check if a type needs a codec and return codec info.
+     * Returns undefined if the type doesn't need a codec.
+     */
+    getCodecForType(typeStr) {
+        const normalized = typeStr.replace(/\s/g, '');
+        // Check each known codec type
+        for (const [sourceType, codecInfo] of Object.entries(this.codecMappings)) {
+            // Match exact type or union with null/undefined
+            if (normalized === sourceType ||
+                normalized.includes(`${sourceType}|`) ||
+                normalized.includes(`|${sourceType}`)) {
+                return {
+                    codecName: codecInfo.codecName,
+                    // Replace the source type with wire type, preserving unions
+                    wireType: typeStr.replace(new RegExp(`\\b${sourceType}\\b`, 'g'), codecInfo.wireType),
+                };
+            }
+        }
+        return undefined;
+    }
     extractTypeAlias(typeAliasDeclaration, sourceFile) {
         const name = typeAliasDeclaration.getName();
         let source = typeAliasDeclaration.getText();
@@ -401,54 +458,6 @@ class RpcTypesGenerator {
             name === 'RpcGenerationConfig' ||
             name === 'GeneratorOptions';
     }
-    collectExternalImports(referencedTypes, genericTypeParamNames) {
-        // Map of package name -> Set of type names to import from that package
-        const externalImports = new Map();
-        const typesToCheck = new Set(referencedTypes);
-        const checkedTypes = new Set();
-        // Recursively collect all external types and their dependencies
-        while (typesToCheck.size > 0) {
-            const currentType = Array.from(typesToCheck)[0];
-            typesToCheck.delete(currentType);
-            checkedTypes.add(currentType);
-            // Skip if it's a built-in type, generic parameter, or internal type
-            if (this.isBuiltInType(currentType) || genericTypeParamNames.has(currentType) || this.isInternalType(currentType)) {
-                continue;
-            }
-            // Check if this type is defined locally (in our interfaces or enums)
-            const isLocalType = this.interfaces.has(currentType) || this.enums.has(currentType);
-            if (!isLocalType && this.typeToPackageMap.has(currentType)) {
-                // This is an external type - add to imports
-                const packageName = this.typeToPackageMap.get(currentType);
-                if (!externalImports.has(packageName)) {
-                    externalImports.set(packageName, new Set());
-                }
-                externalImports.get(packageName).add(currentType);
-                // Check if any of our source interfaces reference this type and extract nested types
-                this.interfaces.forEach(interfaceDef => {
-                    if (interfaceDef.source.includes(currentType)) {
-                        this.extractTypeNames(interfaceDef.source).forEach(nestedType => {
-                            if (!checkedTypes.has(nestedType) && !genericTypeParamNames.has(nestedType)) {
-                                typesToCheck.add(nestedType);
-                            }
-                        });
-                    }
-                });
-            }
-            else if (isLocalType) {
-                // This is a local type - check if it references other external types
-                const localDef = this.interfaces.get(currentType) || this.enums.get(currentType);
-                if (localDef) {
-                    this.extractTypeNames(localDef.source).forEach(nestedType => {
-                        if (!checkedTypes.has(nestedType) && !genericTypeParamNames.has(nestedType)) {
-                            typesToCheck.add(nestedType);
-                        }
-                    });
-                }
-            }
-        }
-        return externalImports;
-    }
     processMethod(method, sourceFile) {
         // Check for @RpcMethod decorator
         const rpcDecorator = method.getDecorators().find(decorator => {
@@ -568,7 +577,7 @@ class RpcTypesGenerator {
         // Generate the main types file that composes all modules
         this.generateMainTypesFile(moduleGroups);
     }
-    generateModuleTypesFile(moduleName, methods, _interfaces, _enums) {
+    generateModuleTypesFile(moduleName, methods, interfaces, enums) {
         // Collect all type names referenced in RPC methods
         const referencedTypes = new Set();
         const genericTypeParamNames = new Set();
@@ -606,62 +615,61 @@ class RpcTypesGenerator {
                 });
             }
         });
-        // Recursively collect all transitive type dependencies (interfaces, type aliases, and enums)
-        // Keep iterating until no new types are discovered
-        const collectedTypes = new Set();
-        let typesToProcess = new Set(referencedTypes);
-        while (typesToProcess.size > 0) {
-            const newTypesToProcess = new Set();
-            typesToProcess.forEach(typeName => {
-                if (collectedTypes.has(typeName) || genericTypeParamNames.has(typeName)) {
-                    return;
-                }
-                collectedTypes.add(typeName);
-                // Check if this type is defined locally (interface or type alias)
-                const interfaceDef = this.interfaces.get(typeName);
-                if (interfaceDef) {
-                    // Extract all type references from this interface/type alias source
-                    this.extractTypeNames(interfaceDef.source).forEach(nestedType => {
-                        if (!collectedTypes.has(nestedType) && !genericTypeParamNames.has(nestedType)) {
-                            newTypesToProcess.add(nestedType);
-                        }
-                    });
-                }
-                // Check if this type is an enum
-                const enumDef = this.enums.get(typeName);
-                if (enumDef) {
-                    // Enums don't have nested type references, but mark as collected
-                }
-            });
-            typesToProcess = newTypesToProcess;
-        }
-        // Update referencedTypes with all collected types
-        collectedTypes.forEach(t => referencedTypes.add(t));
-        // Collect external type imports needed
-        const externalImports = this.collectExternalImports(referencedTypes, genericTypeParamNames);
         // Include enums that are actually referenced, from this module or others
         const referencedEnums = [];
-        // Add all referenced enums
+        // First add enums from this module
+        enums.filter(enumDef => referencedTypes.has(enumDef.name)).forEach(enumDef => referencedEnums.push(enumDef));
+        // Then add enums from other modules that are referenced
         this.enums.forEach(enumDef => {
             if (referencedTypes.has(enumDef.name) &&
+                enumDef.module !== moduleName &&
                 !referencedEnums.some(existing => existing.name === enumDef.name)) {
                 referencedEnums.push(enumDef);
             }
         });
-        // Include interfaces/type aliases that are actually referenced, from this module or others
+        // Include interfaces that are actually referenced, from this module or others
         const referencedInterfaces = [];
-        // Add all referenced interfaces/type aliases
+        // 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 &&
                 !referencedInterfaces.some(existing => existing.name === interfaceDef.name)) {
                 referencedInterfaces.push(interfaceDef);
             }
         });
-        // Sort interfaces/type aliases topologically so dependencies come before dependents
-        const sortedInterfaces = this.topologicalSortTypes(referencedInterfaces, genericTypeParamNames);
+        // Recursively collect type dependencies from referenced interfaces
+        // Keep scanning until no new types are found
+        let prevSize = 0;
+        while (referencedTypes.size !== prevSize) {
+            prevSize = referencedTypes.size;
+            // Scan referenced interfaces for additional type dependencies
+            referencedInterfaces.forEach(interfaceDef => {
+                this.extractTypeNames(interfaceDef.source).forEach(typeName => {
+                    if (!genericTypeParamNames.has(typeName)) {
+                        referencedTypes.add(typeName);
+                    }
+                });
+            });
+            // Re-check interfaces after scanning for dependencies (for nested types)
+            this.interfaces.forEach(interfaceDef => {
+                if (referencedTypes.has(interfaceDef.name) &&
+                    !referencedInterfaces.some(existing => existing.name === interfaceDef.name)) {
+                    referencedInterfaces.push(interfaceDef);
+                }
+            });
+        }
+        // Re-check enums after scanning interfaces for dependencies
+        this.enums.forEach(enumDef => {
+            if (referencedTypes.has(enumDef.name) &&
+                !referencedEnums.some(existing => existing.name === enumDef.name)) {
+                referencedEnums.push(enumDef);
+            }
+        });
         // Enums should come before interfaces that use them
         const moduleEnums = referencedEnums.map(enumDef => enumDef.source).join('\n\n');
-        const moduleInterfaces = sortedInterfaces.map(interfaceDef => interfaceDef.source).join('\n\n');
+        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;
@@ -678,39 +686,136 @@ ${domainMethodDefinitions}
 }`;
         // Build file content with enums before interfaces
         const typesSection = [moduleEnums, moduleInterfaces].filter(section => section.length > 0).join('\n\n');
-        // Generate import statements for external types
-        const importStatements = [];
-        externalImports.forEach((types, packageName) => {
-            const sortedTypes = Array.from(types).sort();
-            importStatements.push(`import { ${sortedTypes.join(', ')} } from '${packageName}';`);
-            // Track that this external package is used
-            this.externalPackagesUsed.add(packageName);
-        });
-        const importsSection = importStatements.length > 0 ? importStatements.join('\n') + '\n\n' : '';
+        // Generate codec field metadata for types in this module only
+        const moduleCodecFields = this.generateCodecFieldsMetadata(moduleName);
         const fileContent = `// Auto-generated RPC types for ${moduleName.charAt(0).toUpperCase() + moduleName.slice(1)} module
 // Do not edit this file manually - it will be overwritten
 //
 // IMPORTANT: All types must be JSON-serializable for TCP transport when extracted to microservices
 
-${importsSection}// ${moduleName.charAt(0).toUpperCase() + moduleName.slice(1)} module types
+// ${moduleName.charAt(0).toUpperCase() + moduleName.slice(1)} module types
 ${typesSection}
 
 ${domainInterface}
+${moduleCodecFields}
 `;
         // Write to configured output directory
         const outputPath = path.join(this.options.rootDir, this.config.outputDir, `${moduleName}.rpc.gen.ts`);
         fs.writeFileSync(outputPath, fileContent, 'utf8');
     }
+    /** Generate codec metadata for types belonging to this module only */
+    generateCodecFieldsMetadata(moduleName) {
+        const codecEntries = [];
+        // Only include types that belong to this module
+        this.codecFields.forEach((fields, typeName) => {
+            const interfaceDef = this.interfaces.get(typeName);
+            if (interfaceDef && interfaceDef.module === moduleName && fields.size > 0) {
+                const fieldEntries = Array.from(fields.entries())
+                    .map(([fieldName, codecName]) => `    ${fieldName}: '${codecName}'`)
+                    .join(',\n');
+                codecEntries.push(`  ${typeName}: {\n${fieldEntries}\n  }`);
+            }
+        });
+        if (codecEntries.length === 0) {
+            return '';
+        }
+        return `
+// Type metadata for automatic codec transformation
+// Maps type names to field -> codec name mappings
+// Used by RPC client for transparent serialization (Date <-> string, etc.)
+export const RpcTypeInfo = {
+${codecEntries.join(',\n')}
+} as const;
+`;
+    }
+    /** Generate function metadata for RPC patterns (params and returns) */
+    generateRpcFunctionInfo(moduleGroups) {
+        const entries = [];
+        Object.values(moduleGroups).forEach(methods => {
+            methods.forEach(method => {
+                // Extract param types that have codec fields
+                const paramEntries = [];
+                method.paramTypes.forEach(param => {
+                    const typeName = this.extractMainTypeName(param.type);
+                    if (typeName && this.codecFields.has(typeName)) {
+                        paramEntries.push(`      ${param.name}: '${typeName}'`);
+                    }
+                });
+                // Extract return type if it has codec fields
+                const returnType = this.extractMainTypeName(method.returnType);
+                const hasReturnCodec = returnType && this.codecFields.has(returnType);
+                // Only include if there are codec fields in params or return
+                if (paramEntries.length > 0 || hasReturnCodec) {
+                    const paramsObj = paramEntries.length > 0
+                        ? `{\n${paramEntries.join(',\n')}\n    }`
+                        : '{}';
+                    const returnsValue = hasReturnCodec ? `'${returnType}'` : 'undefined';
+                    entries.push(`  '${method.pattern}': {\n    params: ${paramsObj},\n    returns: ${returnsValue}\n  }`);
+                }
+            });
+        });
+        if (entries.length === 0) {
+            return '';
+        }
+        return `
+// Function metadata for RPC patterns
+// Maps patterns to their parameter and return type names for codec transformation
+export const RpcFunctionInfo = {
+${entries.join(',\n')}
+} as const;
+
+export type RpcFunctionInfoType = typeof RpcFunctionInfo;
+`;
+    }
+    /** Extract the main type name from a type string (e.g., "User" from "Promise<User>") */
+    extractMainTypeName(typeStr) {
+        // Remove array brackets
+        let type = typeStr.replace(/\[\]/g, '');
+        // Remove Promise wrapper
+        const promiseMatch = type.match(/Promise<(.+)>/);
+        if (promiseMatch) {
+            type = promiseMatch[1];
+        }
+        // Get the first capitalized identifier
+        const match = type.match(/\b([A-Z][a-zA-Z0-9]*)\b/);
+        return match ? match[1] : undefined;
+    }
+    /** Generate imports and re-exports for codec fields from module files */
+    generateCodecFieldReExports(moduleGroups) {
+        const modulesWithCodecFields = [];
+        // Check which modules have codec fields
+        Object.keys(moduleGroups).forEach(moduleName => {
+            // Check if any types in this module have codec fields
+            const moduleTypes = Array.from(this.interfaces.entries())
+                .filter(([_, def]) => def.module === moduleName)
+                .map(([name]) => name);
+            const hasCodecFields = moduleTypes.some(typeName => this.codecFields.has(typeName));
+            if (hasCodecFields) {
+                modulesWithCodecFields.push(moduleName);
+            }
+        });
+        if (modulesWithCodecFields.length === 0) {
+            return { imports: '', exports: '' };
+        }
+        // Generate imports with aliases to avoid conflicts
+        const imports = modulesWithCodecFields
+            .map(mod => `import { RpcTypeInfo as ${this.toCamelCase(mod)}TypeInfo } from './${mod}.rpc.gen';`)
+            .join('\n');
+        // Generate merged export
+        const mergeEntries = modulesWithCodecFields
+            .map(mod => `  ...${this.toCamelCase(mod)}TypeInfo`)
+            .join(',\n');
+        const exports = `
+// Merged type metadata from all modules
+export const RpcTypeInfo = {
+${mergeEntries}
+} as const;
+`;
+        return { imports, exports };
+    }
     generateMainTypesFile(moduleGroups) {
         const hasModules = Object.keys(moduleGroups).length > 0;
-        // Helper to check if a type is external (imported from an npm package)
-        const isExternalType = (typeName) => {
-            return this.typeToPackageMap.has(typeName) &&
-                !this.interfaces.has(typeName) &&
-                !this.enums.has(typeName);
-        };
         // Generate imports from module files - include domain interfaces and types
-        // but EXCLUDE external types (they're imported in module files, not exported)
         const moduleImports = Object.keys(moduleGroups).map(moduleName => {
             // Collect all types referenced in this module's methods
             const referencedTypes = new Set();
@@ -745,8 +850,7 @@ ${domainInterface}
                     });
                 }
             });
-            // Filter out built-in types, internal types, AND external types
-            const typesList = Array.from(referencedTypes).filter(type => !this.isBuiltInType(type) && !this.isInternalType(type) && !isExternalType(type));
+            const typesList = Array.from(referencedTypes).filter(type => !this.isBuiltInType(type) && !this.isInternalType(type));
             const imports = [`${this.toCamelCase(moduleName)}Domain`];
             if (typesList.length > 0) {
                 imports.push(...typesList);
@@ -754,7 +858,6 @@ ${domainInterface}
             return `import { ${imports.join(', ')} } from './${moduleName}.rpc.gen';`;
         }).join('\n');
         // Generate selective re-exports to avoid type conflicts
-        // EXCLUDE external types - they should be imported directly from their packages
         const moduleReExports = Object.keys(moduleGroups).map(moduleName => {
             // Collect all types referenced in this module's methods
             const referencedTypes = new Set();
@@ -789,8 +892,7 @@ ${domainInterface}
                     });
                 }
             });
-            // Filter out built-in types, internal types, AND external types
-            const typesList = Array.from(referencedTypes).filter(type => !this.isBuiltInType(type) && !this.isInternalType(type) && !isExternalType(type));
+            const typesList = Array.from(referencedTypes).filter(type => !this.isBuiltInType(type) && !this.isInternalType(type));
             const exports = [`${this.toCamelCase(moduleName)}Domain`];
             if (typesList.length > 0) {
                 exports.push(...typesList);
@@ -799,58 +901,6 @@ ${domainInterface}
         }).join('\n');
         // Generate common type re-exports from their original modules
         const commonTypeExports = this.generateCommonTypeExports(moduleGroups);
-        // Collect all external types used across all modules for direct import/re-export
-        const externalTypesUsed = new Map(); // package -> types
-        Object.values(moduleGroups).forEach(methods => {
-            methods.forEach(method => {
-                const genericTypeParamNames = new Set();
-                if (method.typeParameters) {
-                    method.typeParameters.forEach(typeParam => {
-                        genericTypeParamNames.add(typeParam.split(' ')[0]);
-                    });
-                }
-                // Collect types from params and return type
-                const allTypes = new Set();
-                method.paramTypes.forEach(param => {
-                    this.extractTypeNames(param.type).forEach(t => {
-                        if (!genericTypeParamNames.has(t))
-                            allTypes.add(t);
-                    });
-                });
-                this.extractTypeNames(method.returnType).forEach(t => {
-                    if (!genericTypeParamNames.has(t))
-                        allTypes.add(t);
-                });
-                // Check which are external types
-                allTypes.forEach(typeName => {
-                    if (isExternalType(typeName)) {
-                        const packageName = this.typeToPackageMap.get(typeName);
-                        if (!externalTypesUsed.has(packageName)) {
-                            externalTypesUsed.set(packageName, new Set());
-                        }
-                        externalTypesUsed.get(packageName).add(typeName);
-                    }
-                });
-            });
-        });
-        // Generate import statements for external types
-        const externalImportStatements = [];
-        externalTypesUsed.forEach((types, packageName) => {
-            const sortedTypes = Array.from(types).sort();
-            externalImportStatements.push(`import type { ${sortedTypes.join(', ')} } from '${packageName}';`);
-        });
-        const externalImportsSection = externalImportStatements.length > 0
-            ? externalImportStatements.join('\n') + '\n'
-            : '';
-        // Generate re-export statements for external types
-        const externalReExportStatements = [];
-        externalTypesUsed.forEach((types, packageName) => {
-            const sortedTypes = Array.from(types).sort();
-            externalReExportStatements.push(`export type { ${sortedTypes.join(', ')} } from '${packageName}';`);
-        });
-        const externalReExportsSection = externalReExportStatements.length > 0
-            ? '\n// Re-export external types from their source packages\n' + externalReExportStatements.join('\n')
-            : '';
         // Generate AllRpcMethods type for MessageBus
         const allRpcMethodsType = hasModules
             ? this.generateAllRpcMethodsType(moduleGroups)
@@ -868,19 +918,23 @@ ${Object.keys(moduleGroups).map(moduleName => `  ${moduleName}: ${this.toCamelCa
 export interface IRpcClient {
   // No RPC domains available
 }`;
+        // Generate RPC function info (params and returns) for codec transformation
+        const rpcFunctionInfo = this.generateRpcFunctionInfo(moduleGroups);
+        // Generate codec field imports and re-exports from module files
+        const codecFieldImportsAndExports = this.generateCodecFieldReExports(moduleGroups);
         const fileContent = `// Auto-generated RPC types from all modules
 // Do not edit this file manually - it will be overwritten
 //
 // SERIALIZATION REQUIREMENTS:
 // All @RpcMethod parameters and return types must be JSON-serializable for TCP transport.
 // Avoid: functions, callbacks, Buffer, Map/Set, DOM elements, class instances, undefined
-// Prefer: primitives, plain objects, arrays, null (instead of undefined)
+// Prefer: primitives, plain objects, arrays, null (instead of undefined), Date (auto-converted)
 
-${externalImportsSection}${moduleImports}
+${moduleImports}
+${codecFieldImportsAndExports.imports}
 
 // Re-export domain interfaces and types
 ${moduleReExports}
-${externalReExportsSection}
 
 // Re-export common types from their primary modules
 ${commonTypeExports}
@@ -888,12 +942,16 @@ ${commonTypeExports}
 ${allRpcMethodsType}
 
 ${rpcClientInterface}
-
+${codecFieldImportsAndExports.exports}${rpcFunctionInfo}
 // Usage examples:
-// import { TypedRpcClient } from '@modular-monolith/rpc';
+// import { RpcTypeInfo, RpcFunctionInfo } from '@your-org/lib-rpc';
+// import { createRpcClientProxy } from '@zdavison/nestjs-rpc-toolkit';
 //
-// const user = await rpc.user.findOne({ id: 'user123' });
-// const products = await rpc.product.findByOwner({ ownerId: 'user123' });
+// const rpc = createRpcClientProxy(client, {
+//   typeInfo: RpcTypeInfo,
+//   functionInfo: RpcFunctionInfo,
+// });
+// const user = await rpc.user.create({ ... }); // Dates auto-converted
 `;
         // Write to configured output directory
         const outputPath = path.join(this.options.rootDir, this.config.outputDir, 'all.rpc.gen.ts');
@@ -915,64 +973,6 @@ ${rpcClientInterface}
                 console.log(`   📄 ${module}: ${methods.length} methods`);
             });
         }
-        // Update output package.json with missing dependencies
-        this.updateOutputPackageJson();
-    }
-    updateOutputPackageJson() {
-        if (this.externalPackagesUsed.size === 0) {
-            return; // No external packages to add
-        }
-        // Find the package.json for the output directory
-        const outputDir = path.join(this.options.rootDir, this.config.outputDir);
-        const packageJsonPath = this.findPackageJsonForOutput(outputDir);
-        if (!packageJsonPath) {
-            console.log(`⚠️  Could not find package.json for output directory ${this.config.outputDir}`);
-            console.log(`   External packages used: ${Array.from(this.externalPackagesUsed).join(', ')}`);
-            return;
-        }
-        try {
-            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-            const dependencies = packageJson.dependencies || {};
-            const missingDeps = [];
-            const addedDeps = {};
-            // Check which external packages are missing
-            this.externalPackagesUsed.forEach(packageName => {
-                if (!dependencies[packageName]) {
-                    missingDeps.push(packageName);
-                    const version = this.packageVersionMap.get(packageName) || 'workspace:*';
-                    addedDeps[packageName] = version;
-                    dependencies[packageName] = version;
-                }
-            });
-            if (missingDeps.length > 0) {
-                // Update package.json with new dependencies
-                packageJson.dependencies = dependencies;
-                // Write back to file with proper formatting
-                fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf-8');
-                console.log(`📦 Updated ${path.relative(this.options.rootDir, packageJsonPath)} with missing dependencies:`);
-                missingDeps.forEach(dep => {
-                    console.log(`   ✓ ${dep}@${addedDeps[dep]}`);
-                });
-                // Detect package manager and show appropriate install command
-                const packageManager = (0, package_manager_utils_1.detectPackageManager)(this.options.rootDir);
-                console.log(`\n⚠️  Please run '${packageManager} install' to install the new dependencies before building.\n`);
-            }
-        }
-        catch (error) {
-            console.error(`❌ Error updating package.json: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    findPackageJsonForOutput(outputDir) {
-        // Walk up from output directory to find package.json
-        let currentDir = outputDir;
-        while (currentDir !== path.dirname(currentDir)) { // Stop at root
-            const packageJsonPath = path.join(currentDir, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
-                return packageJsonPath;
-            }
-            currentDir = path.dirname(currentDir);
-        }
-        return null;
     }
     generateParamsType(params) {
         if (params.length === 0)
@@ -1001,15 +1001,15 @@ ${rpcClientInterface}
     }
     extractTypeNames(typeString) {
         const typeNames = new Set();
-        // Remove JSDoc comments and single-line comments to avoid matching words in comments
-        const codeWithoutComments = typeString
-            .replace(/\/\*\*[\s\S]*?\*\//g, '') // Remove JSDoc comments
-            .replace(/\/\*[\s\S]*?\*\//g, '') // Remove multi-line comments
-            .replace(/\/\/.*$/gm, ''); // Remove single-line comments
+        // Strip JSDoc comments before extracting type names
+        // This prevents matching words in comments (e.g., "User" in "from a user")
+        const withoutJsDoc = typeString
+            .replace(/\/\*\*[\s\S]*?\*\//g, '') // Remove /** ... */ comments
+            .replace(/\/\/[^\n]*/g, ''); // Remove // comments
         // 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 = codeWithoutComments.match(typeNameRegex);
+        const matches = withoutJsDoc.match(typeNameRegex);
         if (matches) {
             matches.forEach(match => {
                 // Exclude built-in types and common generic types
@@ -1131,73 +1131,6 @@ export type AllRpcMethods = {
 ${methodEntries.join('\n')}
 };`;
     }
-    /**
-     * Topologically sort types so that dependencies come before dependents.
-     * This ensures type aliases and interfaces are defined before they are used.
-     */
-    topologicalSortTypes(types, genericTypeParamNames) {
-        if (types.length === 0)
-            return [];
-        // Build a dependency graph
-        const typeNames = new Set(types.map(t => t.name));
-        const dependencies = new Map();
-        types.forEach(typeDef => {
-            const deps = new Set();
-            this.extractTypeNames(typeDef.source).forEach(depName => {
-                // Only consider dependencies that are in our type set and not generic params
-                if (typeNames.has(depName) && depName !== typeDef.name && !genericTypeParamNames.has(depName)) {
-                    deps.add(depName);
-                }
-            });
-            dependencies.set(typeDef.name, deps);
-        });
-        // Kahn's algorithm for topological sort
-        // We want dependencies to come BEFORE dependents
-        const sorted = [];
-        const typeMap = new Map(types.map(t => [t.name, t]));
-        // In-degree = number of dependencies a type has (within our type set)
-        // Types with 0 dependencies should be output first
-        const inDegree = new Map();
-        typeNames.forEach(name => {
-            const deps = dependencies.get(name) || new Set();
-            inDegree.set(name, deps.size);
-        });
-        // Start with types that have no dependencies
-        const queue = [];
-        inDegree.forEach((degree, name) => {
-            if (degree === 0) {
-                queue.push(name);
-            }
-        });
-        while (queue.length > 0) {
-            const name = queue.shift();
-            const typeDef = typeMap.get(name);
-            if (typeDef) {
-                sorted.push(typeDef);
-            }
-            // For each type that depends on this one, decrement its in-degree
-            // (because one of its dependencies has now been processed)
-            typeNames.forEach(dependentName => {
-                const deps = dependencies.get(dependentName);
-                if (deps && deps.has(name)) {
-                    const newDegree = (inDegree.get(dependentName) || 1) - 1;
-                    inDegree.set(dependentName, newDegree);
-                    if (newDegree === 0) {
-                        queue.push(dependentName);
-                    }
-                }
-            });
-        }
-        // If there's a cycle, just append remaining types (they have circular deps)
-        if (sorted.length < types.length) {
-            types.forEach(t => {
-                if (!sorted.includes(t)) {
-                    sorted.push(t);
-                }
-            });
-        }
-        return sorted;
-    }
 }
 exports.RpcTypesGenerator = RpcTypesGenerator;
 //# sourceMappingURL=rpc-types-generator.js.map