Troubleshooting

This guide covers common issues and their solutions when using dtsx.

Common Issues

Type Resolution Errors

// Error: Cannot find type definition for 'User'
import { User } from './types';

// Solution: Ensure type definition exists
interface User {
  name: string;
  age: number;
}

Import Errors

// Error: Module not found
import { User } from './types';

// Solution: Check file path and extension
import { User } from './types.js';
// or
import { User } from './types/index.js';

Circular Dependencies

// Error: Circular dependency detected
interface Parent {
  children: Child[];
}

interface Child {
  parent: Parent;
}

// Solution: Use type references
interface Parent {
  children: Child[];
}

interface Child {
  parent: Parent;
}

Debugging Techniques

Verbose Logging

// Enable verbose logging
const config = {
  verbose: true,
  // or specific categories
  verbose: ['imports', 'types', 'processing'],
};

Type Tracking

// Track type usage
const config = {
  trackTypes: true,
  trackRelationships: true,
  trackUsage: true,
};

Import Tracking

// Track import usage
const config = {
  trackImports: true,
  trackImportUsage: true,
  trackImportRelationships: true,
};

Performance Profiling

Memory Profiling

// Enable memory profiling
const config = {
  profiling: {
    memory: true,
    // Memory limit in MB
    memoryLimit: 1024,
  },
};

CPU Profiling

// Enable CPU profiling
const config = {
  profiling: {
    cpu: true,
    // CPU sampling interval in ms
    samplingInterval: 100,
  },
};

I/O Profiling

// Enable I/O profiling
const config = {
  profiling: {
    io: true,
    // I/O operations to track
    trackOperations: ['read', 'write'],
  },
};

Type Resolution

Type Inference

// Enable type inference
const config = {
  typeInference: {
    enabled: true,
    // Inference strictness
    strictness: 'strict',
  },
};

Type Checking

// Enable type checking
const config = {
  typeChecking: {
    enabled: true,
    // Type checking strictness
    strictness: 'strict',
  },
};

Type Validation

// Enable type validation
const config = {
  typeValidation: {
    enabled: true,
    // Validation rules
    rules: {
      noAny: true,
      noUnknown: true,
      noImplicitAny: true,
    },
  },
};

Best Practices

1. Error Handling

   • Use try-catch blocks
   • Log errors properly
   • Provide helpful error messages
   • Handle edge cases

2. Debugging

   • Enable verbose logging
   • Use debugging tools
   • Track type usage
   • Monitor performance

3. Performance

   • Profile memory usage
   • Profile CPU usage
   • Profile I/O operations
   • Optimize bottlenecks

4. Type Resolution

   • Use type inference
   • Enable type checking
   • Validate types
   • Handle edge cases