feat(ts-morph-codegen): Implement interface processing order (#7)

This change introduces a new utility function `getInterfaceProcessingOrder` that
determines the order in which interfaces should be processed. This is necessary
to ensure that interfaces that depend on other interfaces are processed in the
correct order.

The changes include:

- Importing the `getInterfaceProcessingOrder` function from the
  `@daxserver/validation-schema-codegen/utils/interface-processing-order` module.
- Updating the code that processes interfaces to use the new function to
  determine the processing order.
- Refactoring the interface processing loop to use `forEach` instead of a `for`
  loop.

These changes improve the reliability and maintainability of the code generation
process by ensuring that interfaces are processed in the correct order.

Author: DaxServer

ARCHITECTURE.md

@@ -61,7 +61,7 @@ The main logic for code generation resides in the <mcfile name="ts-morph-codegen
 
 6.  **Type Alias Processing**: The `TypeAliasParser` is instantiated and iterates through all `type alias` declarations in the input `sourceFile`. For each type alias, its underlying type node is converted into a TypeBox-compatible type representation, a TypeBox schema is generated, and a corresponding static type alias is added.
 
-7.  **Interface Processing**: The `InterfaceParser` is instantiated and iterates through all `interface` declarations in the input `sourceFile`. For each interface, its properties and methods are converted into TypeBox object schemas with corresponding static type aliases.
+7.  **Interface Processing**: The `InterfaceParser` is instantiated and iterates through all `interface` declarations in the input `sourceFile`. Interfaces are processed in dependency order to handle inheritance properly. For each interface, its properties and methods are converted into TypeBox object schemas. Interfaces that extend other interfaces are generated using `Type.Intersect` to combine the base interface with additional properties, ensuring proper inheritance semantics.
 
 8.  **Function Declaration Processing**: The `FunctionDeclarationParser` is instantiated and iterates through all function declarations in the input `sourceFile`. For each function, its parameters, optional parameters, and return type are converted into TypeBox function schemas with corresponding static type aliases.
 
@@ -103,6 +103,32 @@ The import resolution process works in two phases:
 
 This approach ensures that complex import scenarios work correctly and generated code compiles without dependency errors.
 
+## Interface Inheritance Support
+
+The codebase provides comprehensive support for TypeScript interface inheritance through a sophisticated dependency resolution and code generation system:
+
+### Dependency-Ordered Processing
+
+Interfaces are processed in dependency order using a topological sort algorithm implemented in <mcfile name="ts-morph-codegen.ts" path="src/ts-morph-codegen.ts"></mcfile>:
+
+1. **Dependency Analysis**: The `getInterfaceProcessingOrder` function analyzes all interfaces to identify inheritance relationships
+2. **Topological Sorting**: Interfaces are sorted to ensure base interfaces are processed before extended interfaces
+3. **Circular Dependency Detection**: The algorithm detects and handles circular inheritance scenarios gracefully
+
+### TypeBox.Composite Generation
+
+Interface inheritance is implemented using TypeBox's `Type.Composite` functionality:
+
+- **Base Interface Reference**: Extended interfaces reference their base interfaces by name as identifiers
+- **Property Combination**: The `InterfaceTypeHandler` generates `Type.Composite([BaseInterface, Type.Object({...})])` for extended interfaces
+- **Type Safety**: Generated code maintains full TypeScript type safety through proper static type aliases
+
+### Implementation Details
+
+- **Heritage Clause Processing**: The <mcfile name="interface-type-handler.ts" path="src/handlers/typebox/object/interface-type-handler.ts"></mcfile> processes `extends` clauses by extracting referenced type names
+- **Identifier Generation**: Base interface references are converted to TypeScript identifiers rather than attempting recursive type resolution
+- **Error Prevention**: The dependency ordering prevents "No handler found for type" errors that occur when extended interfaces are processed before their base interfaces
+
 ## Input Handling System
 
 The <mcfile name="input-handler.ts" path="src/input-handler.ts"></mcfile> module provides flexible input processing capabilities for the code generation system. It supports multiple input methods and handles various edge cases related to file resolution and import validation.
@@ -191,7 +217,7 @@ This directory contains a collection of specialized handler modules, each respon
 **Object-Like Type Handlers** (extend `ObjectLikeBaseHandler`):
 
 - <mcfile name="object-type-handler.ts" path="src/handlers/typebox/object/object-type-handler.ts"></mcfile>: Handles TypeScript object types and type literals.
-- <mcfile name="interface-type-handler.ts" path="src/handlers/typebox/object/interface-type-handler.ts"></mcfile>: Handles TypeScript interface declarations.
+- <mcfile name="interface-type-handler.ts" path="src/handlers/typebox/object/interface-type-handler.ts"></mcfile>: Handles TypeScript interface declarations, including support for interface inheritance using `Type.Composite` to combine base interfaces with extended properties.
 
 **Collection Type Handlers** (extend `CollectionBaseHandler`):
 
@@ -227,6 +253,7 @@ This directory contains a collection of parser classes, each extending the `Base
 - <mcfile name="parse-imports.ts" path="src/parsers/parse-imports.ts"></mcfile>: Implements the `ImportParser` class, responsible for resolving and processing TypeScript import declarations.
 - <mcfile name="parse-type-aliases.ts" path="src/parsers/parse-type-aliases.ts"></mcfile>: Implements the `TypeAliasParser` class, responsible for processing TypeScript `type alias` declarations.
 - <mcfile name="parse-function-declarations.ts" path="src/parsers/parse-function-declarations.ts"></mcfile>: Implements the `FunctionDeclarationParser` class, responsible for processing TypeScript function declarations and converting them to TypeBox function schemas.
+- <mcfile name="parse-interfaces.ts" path="src/parsers/parse-interfaces.ts"></mcfile>: Implements the `InterfaceParser` class, responsible for processing TypeScript interface declarations with support for inheritance through dependency ordering and `Type.Composite` generation.
 
 ### Performance Considerations
 

bun.lock

@@ -6,6 +6,7 @@
       "devDependencies": {
         "@eslint/js": "^9.33.0",
         "@prettier/sync": "^0.6.1",
+        "@sinclair/typebox-codegen": "^0.11.1",
         "@types/bun": "^1.2.20",
         "@typescript-eslint/eslint-plugin": "^8.40.0",
         "@typescript-eslint/parser": "^8.40.0",
@@ -67,6 +68,10 @@
 
     "@prettier/sync": ["@prettier/sync@0.6.1", "", { "dependencies": { "make-synchronized": "^0.8.0" }, "peerDependencies": { "prettier": "*" } }, "sha512-yF9G8vK/LYUTF3Cijd7VC9La3b20F20/J/fgoR4H0B8JGOWnZVZX6+I6+vODPosjmMcpdlUV+gUqJQZp3kLOcw=="],
 
+    "@sinclair/typebox": ["@sinclair/typebox@0.33.22", "", {}, "sha512-auUj4k+f4pyrIVf4GW5UKquSZFHJWri06QgARy9C0t9ZTjJLIuNIrr1yl9bWcJWJ1Gz1vOvYN1D+QPaIlNMVkQ=="],
+
+    "@sinclair/typebox-codegen": ["@sinclair/typebox-codegen@0.11.1", "", { "dependencies": { "@sinclair/typebox": "^0.33.1", "prettier": "^2.8.7", "typescript": "^5.4.5" } }, "sha512-Bckbrf1sJFTIVD88PvI0vWUfE3Sh/6pwu6Jov+6xyMrEqnabOxEFAmPSDWjB1FGPL5C1/HfdScwa1imwAtGi9w=="],
+
     "@ts-morph/common": ["@ts-morph/common@0.27.0", "", { "dependencies": { "fast-glob": "^3.3.3", "minimatch": "^10.0.1", "path-browserify": "^1.0.1" } }, "sha512-Wf29UqxWDpc+i61k3oIOzcUfQt79PIT9y/MWfAGlrkjg6lBC1hwDECLXPVJAhWjiGbfBCxZd65F/LIZF3+jeJQ=="],
 
     "@types/bun": ["@types/bun@1.2.20", "", { "dependencies": { "bun-types": "1.2.20" } }, "sha512-dX3RGzQ8+KgmMw7CsW4xT5ITBSCrSbfHc36SNT31EOUg/LA9JWq0VDdEXDRSe1InVWpd2yLUM1FUF/kEOyTzYA=="],
@@ -313,6 +318,8 @@
 
     "@humanfs/node/@humanwhocodes/retry": ["@humanwhocodes/retry@0.3.1", "", {}, "sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA=="],
 
+    "@sinclair/typebox-codegen/prettier": ["prettier@2.8.8", "", { "bin": { "prettier": "bin-prettier.js" } }, "sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q=="],
+
     "@ts-morph/common/minimatch": ["minimatch@10.0.3", "", { "dependencies": { "@isaacs/brace-expansion": "^5.0.0" } }, "sha512-IPZ167aShDZZUMdRk66cyQAW3qr0WzbHkPdMYa8bzZhlHhO3jALbKdxcaak7W9FfT2rZNpQuUu4Od7ILEpXSaw=="],
 
     "@typescript-eslint/typescript-estree/minimatch": ["minimatch@9.0.5", "", { "dependencies": { "brace-expansion": "^2.0.1" } }, "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow=="],

package.json

@@ -6,13 +6,14 @@
   "devDependencies": {
     "@eslint/js": "^9.33.0",
     "@prettier/sync": "^0.6.1",
+    "@sinclair/typebox-codegen": "^0.11.1",
     "@types/bun": "^1.2.20",
     "@typescript-eslint/eslint-plugin": "^8.40.0",
     "@typescript-eslint/parser": "^8.40.0",
     "eslint": "^9.33.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
     "eslint-plugin-no-relative-import-paths": "^1.6.1",
+    "eslint-plugin-prettier": "^5.5.4",
     "globals": "^16.3.0",
     "jiti": "^2.5.1",
     "prettier": "^3.6.2",

src/handlers/typebox/object/interface-type-handler.ts

@@ -1,4 +1,5 @@
 import { ObjectLikeBaseHandler } from '@daxserver/validation-schema-codegen/handlers/typebox/object/object-like-base-handler'
+import { makeTypeCall } from '@daxserver/validation-schema-codegen/utils/typebox-codegen-utils'
 import { InterfaceDeclaration, Node, ts } from 'ts-morph'
 
 export class InterfaceTypeHandler extends ObjectLikeBaseHandler {
@@ -7,6 +8,32 @@ export class InterfaceTypeHandler extends ObjectLikeBaseHandler {
   }
 
   handle(node: InterfaceDeclaration): ts.Expression {
-    return this.createObjectType(this.processProperties(node.getProperties()))
+    const heritageClauses = node.getHeritageClauses()
+    const baseObjectType = this.createObjectType(this.processProperties(node.getProperties()))
+
+    if (heritageClauses.length === 0) {
+      return baseObjectType
+    }
+
+    const extendedTypes: ts.Expression[] = []
+
+    for (const heritageClause of heritageClauses) {
+      if (heritageClause.getToken() === ts.SyntaxKind.ExtendsKeyword) {
+        for (const typeNode of heritageClause.getTypeNodes()) {
+          // For interface inheritance, we reference the already processed interface by name
+          const referencedTypeName = typeNode.getText()
+          extendedTypes.push(ts.factory.createIdentifier(referencedTypeName))
+        }
+      }
+    }
+
+    if (extendedTypes.length === 0) {
+      return baseObjectType
+    }
+
+    // Create composite with extended types first, then the current interface
+    const allTypes = [...extendedTypes, baseObjectType]
+
+    return makeTypeCall('Composite', [ts.factory.createArrayLiteralExpression(allTypes, true)])
   }
 }

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

@@ -68,7 +68,6 @@ export class TypeBoxTypeHandlers {
     this.syntaxKindHandlers.set(SyntaxKind.TupleType, tupleTypeHandler)
     this.syntaxKindHandlers.set(SyntaxKind.UnionType, unionTypeHandler)
     this.syntaxKindHandlers.set(SyntaxKind.IntersectionType, intersectionTypeHandler)
-    // TypeOperator handling moved to fallback handlers for specific operator types
     this.syntaxKindHandlers.set(SyntaxKind.IndexedAccessType, indexedAccessTypeHandler)
     this.syntaxKindHandlers.set(SyntaxKind.InterfaceDeclaration, interfaceTypeHandler)
     this.syntaxKindHandlers.set(SyntaxKind.FunctionType, functionTypeHandler)

src/ts-morph-codegen.ts

@@ -7,6 +7,7 @@ import { FunctionDeclarationParser } from '@daxserver/validation-schema-codegen/
 import { InterfaceParser } from '@daxserver/validation-schema-codegen/parsers/parse-interfaces'
 import { TypeAliasParser } from '@daxserver/validation-schema-codegen/parsers/parse-type-aliases'
 import { DependencyCollector } from '@daxserver/validation-schema-codegen/utils/dependency-collector'
+import { getInterfaceProcessingOrder } from '@daxserver/validation-schema-codegen/utils/interface-processing-order'
 import { Project, ts } from 'ts-morph'
 
 export interface GenerateCodeOptions extends InputOptions {
@@ -67,34 +68,34 @@ export const generateCode = async ({
   )
 
   // Process all dependencies (both imported and local) in topological order
-  for (const dependency of orderedDependencies) {
+  orderedDependencies.forEach((dependency) => {
     if (!processedTypes.has(dependency.typeAlias.getName())) {
       typeAliasParser.parseWithImportFlag(dependency.typeAlias, dependency.isImported)
     }
-  }
+  })
 
   // Process any remaining local types that weren't included in the dependency graph
   if (exportEverything) {
-    for (const typeAlias of localTypeAliases) {
+    localTypeAliases.forEach((typeAlias) => {
       if (!processedTypes.has(typeAlias.getName())) {
         typeAliasParser.parseWithImportFlag(typeAlias, false)
       }
-    }
+    })
   }
 
   // Process enums
-  sourceFile.getEnums().forEach((enumDeclaration) => {
-    enumParser.parse(enumDeclaration)
+  sourceFile.getEnums().forEach((e) => {
+    enumParser.parse(e)
   })
 
-  // Process interfaces
-  sourceFile.getInterfaces().forEach((interfaceDeclaration) => {
-    interfaceParser.parse(interfaceDeclaration)
+  // Process interfaces in dependency order
+  getInterfaceProcessingOrder(sourceFile.getInterfaces()).forEach((i) => {
+    interfaceParser.parse(i)
   })
 
   // Process function declarations
-  sourceFile.getFunctions().forEach((functionDeclaration) => {
-    functionDeclarationParser.parse(functionDeclaration)
+  sourceFile.getFunctions().forEach((f) => {
+    functionDeclarationParser.parse(f)
   })
 
   return newSourceFile.getFullText()

src/utils/interface-processing-order.ts

@@ -0,0 +1,54 @@
+import { ts, type InterfaceDeclaration } from 'ts-morph'
+
+export const getInterfaceProcessingOrder = (
+  interfaces: InterfaceDeclaration[],
+): InterfaceDeclaration[] => {
+  const interfaceMap = new Map<string, InterfaceDeclaration>()
+  const visited = new Set<string>()
+  const visiting = new Set<string>()
+  const processingOrder: InterfaceDeclaration[] = []
+
+  // Build interface map
+  interfaces.forEach((iface) => {
+    interfaceMap.set(iface.getName(), iface)
+  })
+
+  const visit = (interfaceName: string): void => {
+    if (visited.has(interfaceName) || visiting.has(interfaceName)) {
+      return
+    }
+
+    const iface = interfaceMap.get(interfaceName)
+    if (!iface) {
+      return
+    }
+
+    visiting.add(interfaceName)
+
+    // Process heritage clauses (extends)
+    const heritageClauses = iface.getHeritageClauses()
+    heritageClauses.forEach((heritageClause) => {
+      if (heritageClause.getToken() !== ts.SyntaxKind.ExtendsKeyword) {
+        return
+      }
+
+      heritageClause.getTypeNodes().forEach((typeNode) => {
+        const baseInterfaceName = typeNode.getText()
+        if (interfaceMap.has(baseInterfaceName)) {
+          visit(baseInterfaceName)
+        }
+      })
+    })
+
+    visiting.delete(interfaceName)
+    visited.add(interfaceName)
+    processingOrder.push(iface)
+  }
+
+  // Visit all interfaces
+  interfaces.forEach((iface) => {
+    visit(iface.getName())
+  })
+
+  return processingOrder
+}