feat(compiler-config): Implement automatic script target detection and identifier validation

The changes in this commit introduce a new `CompilerConfig` singleton that manages the TypeScript compiler options and script target configuration for the codegen system.

The key changes are:

1. Automatic script target detection: The system now automatically determines the appropriate TypeScript script target from the `ts-morph` Project's compiler options.

2. Identifier validation: Property names in generated TypeBox objects are validated using TypeScript's built-in utilities (`ts.isIdentifierStart()` and `ts.isIdentifierPart()`). This ensures compatibility with the detected script target.

3. Configuration management: The `CompilerConfig` singleton provides a centralized way to manage the script target configuration, allowing it to be overridden per-project as needed.

4. Default behavior: When no explicit target is specified, the system falls back to `ts.ScriptTarget.Latest`, providing maximum compatibility with modern JavaScript features.

5. Integration points: The configuration system is integrated with various components of the codegen system, including the Input Handler, Code Generation, Identifier Utils, and Object Handlers.

These changes improve the overall robustness and flexibility of the codegen system, ensuring that the generated code is compatible with the target JavaScript environment.

Author: DaxServer

docs/compiler-configuration.md

@@ -0,0 +1,46 @@
+# Compiler Configuration
+
+The codegen system automatically adapts to TypeScript compiler options to ensure generated code is compatible with the target JavaScript environment.
+
+## Script Target Detection
+
+The system automatically determines the appropriate TypeScript script target from the ts-morph Project's compiler options
+
+## Identifier Validation
+
+Property names in generated TypeBox objects are validated using TypeScript's built-in utilities:
+
+- `ts.isIdentifierStart()` - validates first character
+- `ts.isIdentifierPart()` - validates remaining characters
+
+The validation respects the detected script target to ensure compatibility:
+
+```typescript
+// With ES5 target
+interface Example {
+  validName: string;        // → validName: Type.String()
+  "invalid-name": number;   // → "invalid-name": Type.Number()
+  "123invalid": boolean;    // → "123invalid": Type.Boolean()
+}
+```
+
+## Configuration Management
+
+The `CompilerConfig` singleton manages script target configuration.
+
+## Default Behavior
+
+When no explicit target is specified:
+
+- Falls back to `ts.ScriptTarget.Latest`
+- Provides maximum compatibility with modern JavaScript features
+- Can be overridden per-project as needed
+
+## Integration Points
+
+The configuration system integrates with:
+
+- **Input Handler** - Initializes config when creating source files
+- **Code Generation** - Uses config for output file creation
+- **Identifier Utils** - Validates property names with correct target
+- **Object Handlers** - Determines property name formatting

docs/handler-system.md

@@ -30,6 +30,14 @@ export abstract class BaseTypeHandler {
 - `ObjectTypeHandler` - { prop: T }
 - `InterfaceTypeHandler` - interface references
 
+Object property names are extracted using the TypeScript compiler API through `PropertySignature.getNameNode()`. The system handles different property name formats:
+
+- **Identifiers** (`prop`) - extracted using `nameNode.getText()` and preserved as identifiers
+- **String literals** (`'prop-name'`, `"prop name"`) - extracted using `nameNode.getLiteralValue()` and validated for identifier compatibility
+- **Numeric literals** (`123`) - extracted using `nameNode.getLiteralValue().toString()` and treated as identifiers
+
+The system uses TypeScript's built-in character validation utilities (`ts.isIdentifierStart` and `ts.isIdentifierPart`) with runtime-determined script targets to determine if property names can be safely used as unquoted identifiers in the generated code. The script target is automatically determined from the ts-morph Project's compiler options, ensuring compatibility with the target JavaScript environment while maintaining optimal output format.
+
 ### Utility Types
 
 - `PartialTypeHandler` - Partial<T>

docs/overview.md

@@ -46,5 +46,6 @@ export type User = Static<typeof User>
 - [architecture.md](./architecture.md) - System architecture
 - [parser-system.md](./parser-system.md) - TypeScript parsing
 - [handler-system.md](./handler-system.md) - Type conversion
+- [compiler-configuration.md](./compiler-configuration.md) - Compiler options and script targets
 - [dependency-management.md](./dependency-management.md) - Dependency analysis
 - [testing.md](./testing.md) - Testing

src/handlers/typebox/object/object-like-base-handler.ts

@@ -1,20 +1,19 @@
 import { BaseTypeHandler } from '@daxserver/validation-schema-codegen/handlers/typebox/base-type-handler'
 import { getTypeBoxType } from '@daxserver/validation-schema-codegen/utils/typebox-call'
+import { isValidIdentifier } from '@daxserver/validation-schema-codegen/utils/identifier-utils'
 import { makeTypeCall } from '@daxserver/validation-schema-codegen/utils/typebox-codegen-utils'
-import { PropertySignature, ts } from 'ts-morph'
+import { Node, PropertySignature, ts } from 'ts-morph'
 
 export abstract class ObjectLikeBaseHandler extends BaseTypeHandler {
   protected processProperties(properties: PropertySignature[]): ts.PropertyAssignment[] {
     const propertyAssignments: ts.PropertyAssignment[] = []
 
     for (const prop of properties) {
-      const propName = prop.getName()
       const propTypeNode = prop.getTypeNode()
 
-      if (!propTypeNode) {
-        continue
-      }
+      if (!propTypeNode) continue
 
+      const outputNameNode = this.extractPropertyNameInfo(prop)
       const valueExpr = getTypeBoxType(propTypeNode)
       const isAlreadyOptional =
         ts.isCallExpression(valueExpr) &&
@@ -26,11 +25,7 @@ export abstract class ObjectLikeBaseHandler extends BaseTypeHandler {
           ? makeTypeCall('Optional', [valueExpr])
           : valueExpr
 
-      const nameNode = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(propName)
-        ? ts.factory.createIdentifier(propName)
-        : ts.factory.createStringLiteral(propName)
-
-      propertyAssignments.push(ts.factory.createPropertyAssignment(nameNode, maybeOptional))
+      propertyAssignments.push(ts.factory.createPropertyAssignment(outputNameNode, maybeOptional))
     }
 
     return propertyAssignments
@@ -41,4 +36,32 @@ export abstract class ObjectLikeBaseHandler extends BaseTypeHandler {
 
     return makeTypeCall('Object', [objectLiteral])
   }
+
+  private extractPropertyNameInfo(prop: PropertySignature): ts.PropertyName {
+    const nameNode = prop.getNameNode()
+    let propName: string
+    let shouldUseIdentifier: boolean
+
+    if (Node.isIdentifier(nameNode)) {
+      // If it was originally an identifier, keep it as an identifier
+      propName = nameNode.getText()
+      shouldUseIdentifier = true
+    } else if (Node.isStringLiteral(nameNode)) {
+      // For quoted properties, get the literal value and check if it can be an identifier
+      propName = nameNode.getLiteralValue()
+      shouldUseIdentifier = isValidIdentifier(propName)
+    } else if (Node.isNumericLiteral(nameNode)) {
+      // Numeric properties can be used as identifiers
+      propName = nameNode.getLiteralValue().toString()
+      shouldUseIdentifier = true
+    } else {
+      // Fallback for any other cases
+      propName = prop.getName()
+      shouldUseIdentifier = isValidIdentifier(propName)
+    }
+
+    return shouldUseIdentifier
+      ? ts.factory.createIdentifier(propName)
+      : ts.factory.createStringLiteral(propName)
+  }
 }

src/index.ts

@@ -5,11 +5,16 @@ import {
 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 { initializeCompilerConfig } from '@daxserver/validation-schema-codegen/utils/compiler-config'
 import type { VisualizationOptions } from '@daxserver/validation-schema-codegen/utils/graph-visualizer'
 import { Node, Project, SourceFile, ts } from 'ts-morph'
 
 const createOutputFile = (hasGenericInterfaces: boolean) => {
-  const newSourceFile = new Project().createSourceFile('output.ts', '', {
+  const project = new Project()
+
+  initializeCompilerConfig(project)
+
+  const newSourceFile = project.createSourceFile('output.ts', '', {
     overwrite: true,
   })
 

src/input-handler.ts

@@ -1,6 +1,7 @@
 import { existsSync, statSync } from 'fs'
 import { dirname, isAbsolute, resolve } from 'path'
 import { Project, SourceFile } from 'ts-morph'
+import { initializeCompilerConfig } from '@daxserver/validation-schema-codegen/utils/compiler-config'
 
 export interface InputOptions {
   filePath?: string
@@ -65,6 +66,10 @@ export const createSourceFileFromInput = (options: InputOptions): SourceFile =>
   validateInputOptions(options)
 
   const project = options.project || new Project()
+  
+  // Initialize compiler configuration from the project
+  initializeCompilerConfig(project)
+  
   const { filePath, sourceCode, callerFile } = options
 
   if (sourceCode) {

src/utils/compiler-config.ts

@@ -0,0 +1,85 @@
+import { Project, ts } from 'ts-morph'
+
+/**
+ * Configuration utility for managing TypeScript compiler options and script targets
+ */
+export class CompilerConfig {
+  private static instance: CompilerConfig | null = null
+  private scriptTarget: ts.ScriptTarget = ts.ScriptTarget.Latest
+
+  private constructor() {}
+
+  /**
+   * Gets the singleton instance of CompilerConfig
+   */
+  static getInstance(): CompilerConfig {
+    if (!CompilerConfig.instance) {
+      CompilerConfig.instance = new CompilerConfig()
+    }
+    return CompilerConfig.instance
+  }
+
+  /**
+   * Initializes the compiler configuration from a ts-morph Project
+   */
+  initializeFromProject(project: Project): void {
+    const compilerOptions = project.getCompilerOptions()
+    this.scriptTarget = this.determineScriptTarget(compilerOptions)
+  }
+
+  /**
+   * Initializes the compiler configuration from TypeScript compiler options
+   */
+  initializeFromCompilerOptions(compilerOptions: ts.CompilerOptions): void {
+    this.scriptTarget = this.determineScriptTarget(compilerOptions)
+  }
+
+  /**
+   * Gets the current script target
+   */
+  getScriptTarget(): ts.ScriptTarget {
+    return this.scriptTarget
+  }
+
+  /**
+   * Sets the script target explicitly
+   */
+  setScriptTarget(target: ts.ScriptTarget): void {
+    this.scriptTarget = target
+  }
+
+  /**
+   * Determines the appropriate script target from compiler options
+   */
+  private determineScriptTarget(compilerOptions: ts.CompilerOptions): ts.ScriptTarget {
+    // If target is explicitly set in compiler options, use it
+    if (compilerOptions.target !== undefined) {
+      return compilerOptions.target
+    }
+
+    // Default fallback based on common configurations
+    // ESNext maps to Latest, ES2022+ maps to ES2022, etc.
+    return ts.ScriptTarget.Latest
+  }
+
+  /**
+   * Resets the configuration to defaults
+   */
+  reset(): void {
+    this.scriptTarget = ts.ScriptTarget.Latest
+  }
+}
+
+/**
+ * Convenience function to get the current script target
+ */
+export const getScriptTarget = (): ts.ScriptTarget => {
+  return CompilerConfig.getInstance().getScriptTarget()
+}
+
+/**
+ * Convenience function to initialize compiler config from a project
+ */
+export const initializeCompilerConfig = (project: Project): void => {
+  CompilerConfig.getInstance().initializeFromProject(project)
+}

src/utils/identifier-utils.ts

@@ -0,0 +1,22 @@
+import { ts } from 'ts-morph'
+import { getScriptTarget } from '@daxserver/validation-schema-codegen/utils/compiler-config'
+
+/**
+ * Validates if a string can be used as a JavaScript identifier using TypeScript's built-in utilities
+ * Uses the runtime-determined script target for validation
+ */
+export const isValidIdentifier = (text: string, scriptTarget?: ts.ScriptTarget): boolean => {
+  if (text.length === 0) return false
+
+  const target = scriptTarget ?? getScriptTarget()
+
+  // First character must be valid identifier start
+  if (!ts.isIdentifierStart(text.charCodeAt(0), target)) return false
+
+  // Remaining characters must be valid identifier parts
+  for (let i = 1; i < text.length; i++) {
+    if (!ts.isIdentifierPart(text.charCodeAt(i), target)) return false
+  }
+
+  return true
+}

tests/handlers/typebox/enums.test.ts

@@ -59,6 +59,31 @@ describe('Enum types', () => {
         `),
       )
     })
+
+    test('with and without value', () => {
+      const sourceFile = createSourceFile(
+        project,
+        `
+          enum A {
+            B,
+            C = 'c',
+          }
+        `,
+      )
+
+      expect(generateFormattedCode(sourceFile)).toBe(
+        formatWithPrettier(`
+          export enum A {
+            B,
+            C = 'c',
+          }
+
+          export const ASchema = Type.Enum(A);
+
+          export type ASchema = Static<typeof ASchema>;
+        `),
+      )
+    })
   })
 
   describe('with exports', () => {
@@ -111,5 +136,30 @@ describe('Enum types', () => {
         `),
       )
     })
+
+    test('with and without value', () => {
+      const sourceFile = createSourceFile(
+        project,
+        `
+          export enum A {
+            B,
+            C = 'c',
+          }
+        `,
+      )
+
+      expect(generateFormattedCode(sourceFile)).toBe(
+        formatWithPrettier(`
+          export enum A {
+            B,
+            C = 'c',
+          }
+
+          export const ASchema = Type.Enum(A);
+
+          export type ASchema = Static<typeof ASchema>;
+        `),
+      )
+    })
   })
 })

tests/handlers/typebox/interface-generics-consistency.test.ts

@@ -54,8 +54,6 @@ describe('Interface Generic Consistency with Type Aliases', () => {
   })
 
   test('complex generic interface should use GenericTypeUtils flow', () => {
-    // This test is designed to fail if the interface parser doesn't use
-    // the same GenericTypeUtils.createGenericArrowFunction flow as type aliases
     const sourceFile = createSourceFile(
       project,
       `