feat: Add resolver store for type name management

src/handlers/typebox/type-reference-handler.ts

@@ -1,4 +1,5 @@
 import { BaseTypeHandler } from '@daxserver/validation-schema-codegen/handlers/typebox/base-type-handler'
+import { resolverStore } from '@daxserver/validation-schema-codegen/utils/resolver-store'
 import { getTypeBoxType } from '@daxserver/validation-schema-codegen/utils/typebox-call'
 import { makeTypeCall } from '@daxserver/validation-schema-codegen/utils/typebox-codegen-utils'
 import { Node, ts, TypeReferenceNode } from 'ts-morph'
@@ -13,7 +14,10 @@ export class TypeReferenceHandler extends BaseTypeHandler {
     const typeArguments = node.getTypeArguments()
 
     if (Node.isIdentifier(referencedType)) {
-      const typeName = referencedType.getText()
+      const originalTypeName = referencedType.getText()
+
+      // Use the ResolverStore to get the alias name if available
+      const typeName = resolverStore.resolveAliasName(originalTypeName)
 
       // If there are type arguments, create a function call
       if (typeArguments.length > 0) {

src/parsers/parse-enums.ts

@@ -3,8 +3,8 @@ import { addStaticTypeAlias } from '@daxserver/validation-schema-codegen/utils/a
 import { EnumDeclaration, VariableDeclarationKind } from 'ts-morph'
 
 export class EnumParser extends BaseParser {
-  parse(enumDeclaration: EnumDeclaration): void {
-    const enumName = enumDeclaration.getName()
+  parse(enumDeclaration: EnumDeclaration, aliasName?: string): void {
+    const enumName = aliasName || enumDeclaration.getName()
     const schemaName = `${enumName}Schema`
 
     this.newSourceFile.addEnum({

src/parsers/parse-function-declarations.ts

@@ -5,9 +5,11 @@ import { makeTypeCall } from '@daxserver/validation-schema-codegen/utils/typebox
 import { FunctionDeclaration, ts, VariableDeclarationKind } from 'ts-morph'
 
 export class FunctionDeclarationParser extends BaseParser {
-  parse(functionDecl: FunctionDeclaration): void {
-    const functionName = functionDecl.getName()
-    if (!functionName) return
+  parse(functionDecl: FunctionDeclaration, aliasName?: string): void {
+    const originalFunctionName = functionDecl.getName()
+    if (!originalFunctionName) return
+
+    const functionName = aliasName || originalFunctionName
 
     if (this.processedTypes.has(functionName)) return
     this.processedTypes.add(functionName)

src/parsers/parse-interfaces.ts

@@ -5,8 +5,8 @@ import { getTypeBoxType } from '@daxserver/validation-schema-codegen/utils/typeb
 import { InterfaceDeclaration, ts } from 'ts-morph'
 
 export class InterfaceParser extends BaseParser {
-  parse(interfaceDecl: InterfaceDeclaration): void {
-    const interfaceName = interfaceDecl.getName()
+  parse(interfaceDecl: InterfaceDeclaration, aliasName?: string): void {
+    const interfaceName = aliasName || interfaceDecl.getName()
 
     if (this.processedTypes.has(interfaceName)) return
     this.processedTypes.add(interfaceName)
@@ -15,15 +15,13 @@ export class InterfaceParser extends BaseParser {
 
     // Check if interface has type parameters (generic)
     if (typeParameters.length > 0) {
-      this.parseGenericInterface(interfaceDecl)
+      this.parseGenericInterface(interfaceDecl, interfaceName)
     } else {
-      this.parseRegularInterface(interfaceDecl)
+      this.parseRegularInterface(interfaceDecl, interfaceName)
     }
   }
 
-  private parseRegularInterface(interfaceDecl: InterfaceDeclaration): void {
-    const interfaceName = interfaceDecl.getName()
-
+  private parseRegularInterface(interfaceDecl: InterfaceDeclaration, interfaceName: string): void {
     // Generate TypeBox type definition
     const typeboxTypeNode = getTypeBoxType(interfaceDecl)
     const typeboxType = this.printer.printNode(
@@ -42,8 +40,7 @@ export class InterfaceParser extends BaseParser {
     )
   }
 
-  private parseGenericInterface(interfaceDecl: InterfaceDeclaration): void {
-    const interfaceName = interfaceDecl.getName()
+  private parseGenericInterface(interfaceDecl: InterfaceDeclaration, interfaceName: string): void {
     const typeParameters = interfaceDecl.getTypeParameters()
 
     // Generate TypeBox function definition using the same flow as type aliases

src/parsers/parse-type-aliases.ts

@@ -6,8 +6,8 @@ import { makeTypeCall } from '@daxserver/validation-schema-codegen/utils/typebox
 import { ts, TypeAliasDeclaration } from 'ts-morph'
 
 export class TypeAliasParser extends BaseParser {
-  parse(typeAlias: TypeAliasDeclaration): void {
-    const typeName = typeAlias.getName()
+  parse(typeAlias: TypeAliasDeclaration, aliasName?: string): void {
+    const typeName = aliasName || typeAlias.getName()
 
     if (this.processedTypes.has(typeName)) return
     this.processedTypes.add(typeName)
@@ -16,15 +16,13 @@ export class TypeAliasParser extends BaseParser {
 
     // Check if type alias has type parameters (generic)
     if (typeParameters.length > 0) {
-      this.parseGenericTypeAlias(typeAlias)
+      this.parseGenericTypeAlias(typeAlias, typeName)
     } else {
-      this.parseRegularTypeAlias(typeAlias)
+      this.parseRegularTypeAlias(typeAlias, typeName)
     }
   }
 
-  private parseRegularTypeAlias(typeAlias: TypeAliasDeclaration): void {
-    const typeName = typeAlias.getName()
-
+  private parseRegularTypeAlias(typeAlias: TypeAliasDeclaration, typeName: string): void {
     const typeNode = typeAlias.getTypeNode()
     const typeboxTypeNode = typeNode ? getTypeBoxType(typeNode) : makeTypeCall('Any')
     const typeboxType = this.printer.printNode(
@@ -38,8 +36,7 @@ export class TypeAliasParser extends BaseParser {
     addStaticTypeAlias(this.newSourceFile, typeName, this.newSourceFile.compilerNode, this.printer)
   }
 
-  private parseGenericTypeAlias(typeAlias: TypeAliasDeclaration): void {
-    const typeName = typeAlias.getName()
+  private parseGenericTypeAlias(typeAlias: TypeAliasDeclaration, typeName: string): void {
     const typeParameters = typeAlias.getTypeParameters()
 
     // Generate TypeBox function definition

src/printer/typebox-printer.ts

@@ -37,23 +37,23 @@ export class TypeBoxPrinter {
   }
 
   printNode(traversedNode: TraversedNode): void {
-    const { node } = traversedNode
+    const { node, aliasName } = traversedNode
 
     switch (true) {
       case Node.isTypeAliasDeclaration(node):
-        this.typeAliasParser.parse(node)
+        this.typeAliasParser.parse(node, aliasName)
         break
 
       case Node.isInterfaceDeclaration(node):
-        this.interfaceParser.parse(node)
+        this.interfaceParser.parse(node, aliasName)
         break
 
       case Node.isEnumDeclaration(node):
-        this.enumParser.parse(node)
+        this.enumParser.parse(node, aliasName)
         break
 
       case Node.isFunctionDeclaration(node):
-        this.functionParser.parse(node)
+        this.functionParser.parse(node, aliasName)
         break
 
       default:

src/traverse/dependency-extractor.ts

@@ -1,5 +1,6 @@
 import { NodeGraph } from '@daxserver/validation-schema-codegen/traverse/node-graph'
 import { TypeReferenceExtractor } from '@daxserver/validation-schema-codegen/traverse/type-reference-extractor'
+import { resolverStore } from '@daxserver/validation-schema-codegen/utils/resolver-store'
 import {
   EnumDeclaration,
   FunctionDeclaration,
@@ -11,7 +12,7 @@ import {
 export const extractDependencies = (nodeGraph: NodeGraph, requiredNodeIds: Set<string>): void => {
   const processedNodes = new Set<string>()
   const nodesToProcess = new Set(requiredNodeIds)
-  const typeReferenceExtractor = new TypeReferenceExtractor(nodeGraph)
+  const typeReferenceExtractor = new TypeReferenceExtractor()
 
   // Process nodes iteratively until no new dependencies are found
   while (nodesToProcess.size > 0) {
@@ -44,7 +45,7 @@ export const extractDependencies = (nodeGraph: NodeGraph, requiredNodeIds: Set<s
     const typeReferences = typeReferenceExtractor.extractTypeReferences(nodeToAnalyze)
 
     for (const referencedType of typeReferences) {
-      if (nodeGraph.hasNode(referencedType)) {
+      if (resolverStore.hasQualifiedName(referencedType) && nodeGraph.hasNode(referencedType)) {
         // Only add to required if not already processed
         if (!requiredNodeIds.has(referencedType)) {
           requiredNodeIds.add(referencedType)

src/traverse/dependency-traversal.ts

@@ -8,6 +8,7 @@ import {
   GraphVisualizer,
   type VisualizationOptions,
 } from '@daxserver/validation-schema-codegen/utils/graph-visualizer'
+import { resolverStore } from '@daxserver/validation-schema-codegen/utils/resolver-store'
 import { hasCycle, topologicalSort } from 'graphology-dag'
 import { SourceFile } from 'ts-morph'
 
@@ -16,14 +17,17 @@ export class DependencyTraversal {
   private nodeGraph = new NodeGraph()
   private maincodeNodeIds = new Set<string>()
   private requiredNodeIds = new Set<string>()
-  private importCollector = new ImportCollector(this.fileGraph, this.nodeGraph)
+  private importCollector: ImportCollector
+  constructor() {
+    this.importCollector = new ImportCollector(this.fileGraph, this.nodeGraph)
+  }
 
-  startTraversal(mainSourceFile: SourceFile): TraversedNode[] {
+  startTraversal(sourceFile: SourceFile): TraversedNode[] {
     // Mark main source file nodes as main code
-    addLocalTypes(mainSourceFile, this.nodeGraph, this.maincodeNodeIds, this.requiredNodeIds)
+    addLocalTypes(sourceFile, this.nodeGraph, this.maincodeNodeIds, this.requiredNodeIds)
 
     // Start recursive traversal from imports
-    const importDeclarations = mainSourceFile.getImportDeclarations()
+    const importDeclarations = sourceFile.getImportDeclarations()
     this.importCollector.collectFromImports(importDeclarations)
 
     // Extract dependencies for all nodes
@@ -38,23 +42,30 @@ export class DependencyTraversal {
    * Handles circular dependencies gracefully by falling back to simple node order
    */
   getNodesToPrint(): TraversedNode[] {
-    // Get all nodes in topological order, then filter to only required ones
-    const allNodesInOrder = hasCycle(this.nodeGraph)
-      ? Array.from(this.nodeGraph.nodes())
-      : topologicalSort(this.nodeGraph)
+    // Get all qualified names from resolver store, then apply topological ordering
+    const allQualifiedNames = resolverStore.getAllQualifiedNames()
+
+    // Filter to only required nodes that exist in both resolver store and node graph
+    const requiredQualifiedNames = allQualifiedNames.filter((qualifiedName: string) =>
+      this.requiredNodeIds.has(qualifiedName),
+    )
+
+    // Apply topological ordering only to the required nodes
+    const orderedNodes = hasCycle(this.nodeGraph)
+      ? requiredQualifiedNames
+      : topologicalSort(this.nodeGraph).filter((nodeId: string) =>
+          requiredQualifiedNames.includes(nodeId),
+        )
 
-    const filteredNodes = allNodesInOrder
-      .filter((nodeId: string) => this.requiredNodeIds.has(nodeId))
+    // Map to actual node data
+    const filteredNodes = orderedNodes
       .map((nodeId: string) => this.nodeGraph.getNode(nodeId))
+      .filter((node): node is TraversedNode => node !== null)
 
     return filteredNodes
   }
 
   async visualizeGraph(options: VisualizationOptions = {}): Promise<string> {
     return GraphVisualizer.generateVisualization(this.nodeGraph, options)
   }
-
-  getNodeGraph(): NodeGraph {
-    return this.nodeGraph
-  }
 }

src/traverse/import-collector.ts

@@ -1,6 +1,6 @@
 import { FileGraph } from '@daxserver/validation-schema-codegen/traverse/file-graph'
 import { NodeGraph } from '@daxserver/validation-schema-codegen/traverse/node-graph'
-import { generateQualifiedNodeName } from '@daxserver/validation-schema-codegen/utils/generate-qualified-name'
+import { resolverStore } from '@daxserver/validation-schema-codegen/utils/resolver-store'
 import { ImportDeclaration } from 'ts-morph'
 
 export class ImportCollector {
@@ -20,6 +20,17 @@ export class ImportCollector {
       if (this.fileGraph.hasNode(filePath)) continue
       this.fileGraph.addFile(filePath, moduleSourceFile)
 
+      // Build alias map specific to this import declaration
+      const aliasMap = new Map<string, string>() // originalName -> aliasName
+      const namedImports = importDecl.getNamedImports()
+      for (const namedImport of namedImports) {
+        const originalName = namedImport.getName()
+        const aliasName = namedImport.getAliasNode()?.getText()
+        if (aliasName) {
+          aliasMap.set(originalName, aliasName)
+        }
+      }
+
       const imports = moduleSourceFile.getImportDeclarations()
       const typeAliases = moduleSourceFile.getTypeAliases()
       const interfaces = moduleSourceFile.getInterfaces()
@@ -29,51 +40,87 @@ export class ImportCollector {
       // Add all imported types to the graph
       for (const typeAlias of typeAliases) {
         const typeName = typeAlias.getName()
-        const qualifiedName = generateQualifiedNodeName(typeName, typeAlias.getSourceFile())
+        const qualifiedName = resolverStore.generateQualifiedName(
+          typeName,
+          typeAlias.getSourceFile(),
+        )
+        const aliasName = aliasMap.get(typeName)
         this.nodeGraph.addTypeNode(qualifiedName, {
           node: typeAlias,
           type: 'typeAlias',
           originalName: typeName,
           qualifiedName,
           isImported: true,
           isMainCode: false,
+          aliasName,
+        })
+
+        // Add to ResolverStore during traversal
+        resolverStore.addTypeMapping({
+          originalName: typeName,
+          sourceFile: typeAlias.getSourceFile(),
+          aliasName,
         })
       }
 
       for (const interfaceDecl of interfaces) {
         const interfaceName = interfaceDecl.getName()
-        const qualifiedName = generateQualifiedNodeName(
+        const qualifiedName = resolverStore.generateQualifiedName(
           interfaceName,
           interfaceDecl.getSourceFile(),
         )
+        const aliasName = aliasMap.get(interfaceName)
         this.nodeGraph.addTypeNode(qualifiedName, {
           node: interfaceDecl,
           type: 'interface',
           originalName: interfaceName,
           qualifiedName,
           isImported: true,
           isMainCode: false,
+          aliasName,
+        })
+
+        // Add to ResolverStore during traversal
+        resolverStore.addTypeMapping({
+          originalName: interfaceName,
+          sourceFile: interfaceDecl.getSourceFile(),
+          aliasName,
         })
       }
 
       for (const enumDecl of enums) {
         const enumName = enumDecl.getName()
-        const qualifiedName = generateQualifiedNodeName(enumName, enumDecl.getSourceFile())
+        const qualifiedName = resolverStore.generateQualifiedName(
+          enumName,
+          enumDecl.getSourceFile(),
+        )
+        const aliasName = aliasMap.get(enumName)
         this.nodeGraph.addTypeNode(qualifiedName, {
           node: enumDecl,
           type: 'enum',
           originalName: enumName,
           qualifiedName,
           isImported: true,
           isMainCode: false,
+          aliasName,
+        })
+
+        // Add to ResolverStore during traversal
+        resolverStore.addTypeMapping({
+          originalName: enumName,
+          sourceFile: enumDecl.getSourceFile(),
+          aliasName,
         })
       }
 
       for (const functionDecl of functions) {
         const functionName = functionDecl.getName()
         if (!functionName) continue
 
-        const qualifiedName = generateQualifiedNodeName(functionName, functionDecl.getSourceFile())
+        const qualifiedName = resolverStore.generateQualifiedName(
+          functionName,
+          functionDecl.getSourceFile(),
+        )
         this.nodeGraph.addTypeNode(qualifiedName, {
           node: functionDecl,
           type: 'function',
@@ -82,6 +129,12 @@ export class ImportCollector {
           isImported: true,
           isMainCode: false,
         })
+
+        // Add to ResolverStore during traversal
+        resolverStore.addTypeMapping({
+          originalName: functionName,
+          sourceFile: functionDecl.getSourceFile(),
+        })
       }
 
       // Recursively collect from nested imports (mark as transitive)