feat(graph): rework dependency traversal with graphology DAG (#13)

Author: DaxServer

ARCHITECTURE.md

@@ -1,8 +1,8 @@
 {
   "name": "@daxserver/validation-schema-codegen",
   "version": "0.1.0",
-  "main": "src/ts-morph-codegen.ts",
-  "module": "src/ts-morph-codegen.ts",
+  "main": "src/index.ts",
+  "module": "src/index.ts",
   "devDependencies": {
     "@eslint/js": "^9.34.0",
     "@prettier/sync": "^0.6.1",

package.json

@@ -0,0 +1,77 @@
+import {
+  createSourceFileFromInput,
+  type InputOptions,
+} from '@daxserver/validation-schema-codegen/input-handler'
+import { TypeBoxPrinter } from '@daxserver/validation-schema-codegen/printer/typebox-printer'
+import { DependencyTraversal } from '@daxserver/validation-schema-codegen/traverse/dependency-traversal'
+import type { TraversedNode } from '@daxserver/validation-schema-codegen/traverse/types'
+import { Node, Project, SourceFile, ts } from 'ts-morph'
+
+const createOutputFile = (hasGenericInterfaces: boolean) => {
+  const newSourceFile = new Project().createSourceFile('output.ts', '', {
+    overwrite: true,
+  })
+
+  // Add imports
+  const namedImports = [
+    'Type',
+    {
+      name: 'Static',
+      isTypeOnly: true,
+    },
+  ]
+
+  if (hasGenericInterfaces) {
+    namedImports.push({
+      name: 'TSchema',
+      isTypeOnly: true,
+    })
+  }
+
+  newSourceFile.addImportDeclaration({
+    moduleSpecifier: '@sinclair/typebox',
+    namedImports,
+  })
+
+  return newSourceFile
+}
+
+const printSortedNodes = (sortedTraversedNodes: TraversedNode[], newSourceFile: SourceFile) => {
+  const printer = new TypeBoxPrinter({
+    newSourceFile,
+    printer: ts.createPrinter(),
+  })
+
+  // Process nodes in topological order
+  for (const traversedNode of sortedTraversedNodes) {
+    printer.printNode(traversedNode)
+  }
+
+  return newSourceFile.getFullText()
+}
+
+export const generateCode = ({ sourceCode, filePath, ...options }: InputOptions): string => {
+  // Create source file from input
+  const sourceFile = createSourceFileFromInput({
+    sourceCode,
+    filePath,
+    ...options,
+  })
+
+  // Create dependency traversal and start traversal
+  const dependencyTraversal = new DependencyTraversal()
+  const traversedNodes = dependencyTraversal.startTraversal(sourceFile)
+
+  // Check if any interfaces have generic type parameters
+  const hasGenericInterfaces = traversedNodes.some(
+    (t) => Node.isInterfaceDeclaration(t.node) && t.node.getTypeParameters().length > 0,
+  )
+
+  // Create output file with proper imports
+  const newSourceFile = createOutputFile(hasGenericInterfaces)
+
+  // Print sorted nodes to output
+  const result = printSortedNodes(traversedNodes, newSourceFile)
+
+  return result
+}

src/index.ts

@@ -1,30 +1,20 @@
-import { ExportGetableNode, Node, SourceFile, ts } from 'ts-morph'
+import { Node, SourceFile, ts } from 'ts-morph'
 
 export interface BaseParserOptions {
   newSourceFile: SourceFile
   printer: ts.Printer
   processedTypes: Set<string>
-  exportEverything?: boolean
 }
 
 export abstract class BaseParser {
   protected newSourceFile: SourceFile
   protected printer: ts.Printer
   protected processedTypes: Set<string>
-  protected exportEverything: boolean
 
   constructor(options: BaseParserOptions) {
     this.newSourceFile = options.newSourceFile
     this.printer = options.printer
     this.processedTypes = options.processedTypes
-    this.exportEverything = options.exportEverything ?? false
-  }
-
-  protected getIsExported(node: ExportGetableNode, isImported: boolean = false): boolean {
-    if (this.exportEverything) {
-      return true
-    }
-    return isImported ? false : node.hasExportKeyword()
   }
 
   abstract parse(node: Node): void

src/parsers/base-parser.ts

@@ -4,28 +4,37 @@ import { EnumDeclaration, VariableDeclarationKind } from 'ts-morph'
 
 export class EnumParser extends BaseParser {
   parse(enumDeclaration: EnumDeclaration): void {
-    const typeName = enumDeclaration.getName()
-    const enumText = enumDeclaration.getText()
-    const isExported = this.getIsExported(enumDeclaration)
-    this.newSourceFile.addStatements(isExported ? `export ${enumText}` : enumText)
+    const enumName = enumDeclaration.getName()
+    const schemaName = `${enumName}Schema`
+
+    this.newSourceFile.addEnum({
+      name: enumName,
+      isExported: true,
+      members: enumDeclaration.getMembers().map((member) => ({
+        name: member.getName(),
+        value: member.hasInitializer() ? member.getValue() : undefined,
+      })),
+    })
+
+    // Generate TypeBox type
+    const typeboxType = `Type.Enum(${enumName})`
 
     this.newSourceFile.addVariableStatement({
-      isExported,
+      isExported: true,
       declarationKind: VariableDeclarationKind.Const,
       declarations: [
         {
-          name: typeName,
-          initializer: `Type.Enum(${typeName})`,
+          name: schemaName,
+          initializer: typeboxType,
         },
       ],
     })
 
     addStaticTypeAlias(
       this.newSourceFile,
-      typeName,
+      schemaName,
       this.newSourceFile.compilerNode,
       this.printer,
-      isExported,
     )
   }
 }

src/parsers/parse-enums.ts

@@ -6,25 +6,10 @@ import { FunctionDeclaration, ts, VariableDeclarationKind } from 'ts-morph'
 
 export class FunctionDeclarationParser extends BaseParser {
   parse(functionDecl: FunctionDeclaration): void {
-    this.parseWithImportFlag(functionDecl, false)
-  }
-
-  parseWithImportFlag(functionDecl: FunctionDeclaration, isImported: boolean): void {
-    this.parseFunctionWithImportFlag(functionDecl, isImported)
-  }
-
-  private parseFunctionWithImportFlag(
-    functionDecl: FunctionDeclaration,
-    isImported: boolean,
-  ): void {
     const functionName = functionDecl.getName()
-    if (!functionName) {
-      return
-    }
+    if (!functionName) return
 
-    if (this.processedTypes.has(functionName)) {
-      return
-    }
+    if (this.processedTypes.has(functionName)) return
     this.processedTypes.add(functionName)
 
     // Get function parameters and return type
@@ -70,10 +55,8 @@ export class FunctionDeclarationParser extends BaseParser {
       this.newSourceFile.compilerNode,
     )
 
-    const isExported = this.getIsExported(functionDecl, isImported)
-
     this.newSourceFile.addVariableStatement({
-      isExported,
+      isExported: true,
       declarationKind: VariableDeclarationKind.Const,
       declarations: [
         {
@@ -88,7 +71,6 @@ export class FunctionDeclarationParser extends BaseParser {
       functionName,
       this.newSourceFile.compilerNode,
       this.printer,
-      isExported,
     )
   }
 }

src/parsers/parse-function-declarations.ts

@@ -10,17 +10,6 @@ import {
 
 export class InterfaceParser extends BaseParser {
   parse(interfaceDecl: InterfaceDeclaration): void {
-    this.parseWithImportFlag(interfaceDecl, false)
-  }
-
-  parseWithImportFlag(interfaceDecl: InterfaceDeclaration, isImported: boolean): void {
-    this.parseInterfaceWithImportFlag(interfaceDecl, isImported)
-  }
-
-  private parseInterfaceWithImportFlag(
-    interfaceDecl: InterfaceDeclaration,
-    isImported: boolean,
-  ): void {
     const interfaceName = interfaceDecl.getName()
 
     if (this.processedTypes.has(interfaceName)) {
@@ -30,17 +19,16 @@ export class InterfaceParser extends BaseParser {
     this.processedTypes.add(interfaceName)
 
     const typeParameters = interfaceDecl.getTypeParameters()
-    const isExported = this.getIsExported(interfaceDecl, isImported)
 
     // Check if interface has type parameters (generic)
     if (typeParameters.length > 0) {
-      this.parseGenericInterface(interfaceDecl, isExported)
+      this.parseGenericInterface(interfaceDecl)
     } else {
-      this.parseRegularInterface(interfaceDecl, isExported)
+      this.parseRegularInterface(interfaceDecl)
     }
   }
 
-  private parseRegularInterface(interfaceDecl: InterfaceDeclaration, isExported: boolean): void {
+  private parseRegularInterface(interfaceDecl: InterfaceDeclaration): void {
     const interfaceName = interfaceDecl.getName()
 
     // Generate TypeBox type definition
@@ -52,7 +40,7 @@ export class InterfaceParser extends BaseParser {
     )
 
     this.newSourceFile.addVariableStatement({
-      isExported,
+      isExported: true,
       declarationKind: VariableDeclarationKind.Const,
       declarations: [
         {
@@ -67,11 +55,10 @@ export class InterfaceParser extends BaseParser {
       interfaceName,
       this.newSourceFile.compilerNode,
       this.printer,
-      isExported,
     )
   }
 
-  private parseGenericInterface(interfaceDecl: InterfaceDeclaration, isExported: boolean): void {
+  private parseGenericInterface(interfaceDecl: InterfaceDeclaration): void {
     const interfaceName = interfaceDecl.getName()
     const typeParameters = interfaceDecl.getTypeParameters()
 
@@ -85,7 +72,7 @@ export class InterfaceParser extends BaseParser {
 
     // Add the function declaration
     this.newSourceFile.addVariableStatement({
-      isExported,
+      isExported: true,
       declarationKind: VariableDeclarationKind.Const,
       declarations: [
         {
@@ -96,14 +83,10 @@ export class InterfaceParser extends BaseParser {
     })
 
     // Add generic type alias: type A<T extends TSchema> = Static<ReturnType<typeof A<T>>>
-    this.addGenericTypeAlias(interfaceName, typeParameters, isExported)
+    this.addGenericTypeAlias(interfaceName, typeParameters)
   }
 
-  private addGenericTypeAlias(
-    name: string,
-    typeParameters: TypeParameterDeclaration[],
-    isExported: boolean,
-  ): void {
+  private addGenericTypeAlias(name: string, typeParameters: TypeParameterDeclaration[]): void {
     // Create type parameters for the type alias
     const typeParamDeclarations = typeParameters.map((typeParam) => {
       const paramName = typeParam.getName()
@@ -152,7 +135,7 @@ export class InterfaceParser extends BaseParser {
     )
 
     this.newSourceFile.addTypeAlias({
-      isExported,
+      isExported: true,
       name,
       typeParameters: typeParamDeclarations.map((tp) =>
         this.printer.printNode(ts.EmitHint.Unspecified, tp, this.newSourceFile.compilerNode),

src/parsers/parse-interfaces.ts

@@ -6,18 +6,12 @@ import { ts, TypeAliasDeclaration, VariableDeclarationKind } from 'ts-morph'
 
 export class TypeAliasParser extends BaseParser {
   parse(typeAlias: TypeAliasDeclaration): void {
-    this.parseWithImportFlag(typeAlias, false)
+    this.parseWithImportFlag(typeAlias)
   }
 
-  parseWithImportFlag(typeAlias: TypeAliasDeclaration, isImported: boolean): void {
+  parseWithImportFlag(typeAlias: TypeAliasDeclaration): void {
     const typeName = typeAlias.getName()
 
-    if (this.processedTypes.has(typeName)) {
-      return
-    }
-
-    this.processedTypes.add(typeName)
-
     const typeNode = typeAlias.getTypeNode()
     const typeboxTypeNode = typeNode ? getTypeBoxType(typeNode) : makeTypeCall('Any')
     const typeboxType = this.printer.printNode(
@@ -26,10 +20,8 @@ export class TypeAliasParser extends BaseParser {
       this.newSourceFile.compilerNode,
     )
 
-    const isExported = this.getIsExported(typeAlias, isImported)
-
     this.newSourceFile.addVariableStatement({
-      isExported,
+      isExported: true,
       declarationKind: VariableDeclarationKind.Const,
       declarations: [
         {
@@ -39,12 +31,6 @@ export class TypeAliasParser extends BaseParser {
       ],
     })
 
-    addStaticTypeAlias(
-      this.newSourceFile,
-      typeName,
-      this.newSourceFile.compilerNode,
-      this.printer,
-      isExported,
-    )
+    addStaticTypeAlias(this.newSourceFile, typeName, this.newSourceFile.compilerNode, this.printer)
   }
 }