NovaDI

1. Define Interfaces (Domain Layer)

// interfaces.ts - Clean, no DI knowledge
interface ILogger {
  log(message: string): void
  error(message: string): void
}

interface IDatabase {
  query(sql: string): Promise<any>
}

interface IUserService {
  getUser(id: string): Promise<User>
  createUser(data: CreateUserDto): Promise<User>
}

2. Implement Services

// implementations.ts
class ConsoleLogger implements ILogger {
  log(message: string) {
    console.log(`[LOG] ${message}`)
  }
  error(message: string) {
    console.error(`[ERROR] ${message}`)
  }
}

class PostgresDatabase implements IDatabase {
  async query(sql: string) {
    // ... database logic
  }
}

class UserService implements IUserService {
  constructor(
    private logger: ILogger,
    private db: IDatabase
  ) {}

  async getUser(id: string) {
    this.logger.log(`Fetching user ${id}`)
    return this.db.query(`SELECT * FROM users WHERE id = $1`, [id])
  }

  async createUser(data: CreateUserDto) {
    this.logger.log(`Creating user ${data.email}`)
    return this.db.query(`INSERT INTO users ...`, data)
  }
}

3. Configure DI (Infrastructure Layer)

// composition-root.ts - ALL DI config in ONE place
const container = new Container()
  .builder()

  // Register infrastructure services
  .registerType(ConsoleLogger)
    .as<ILogger>()
    .singleInstance()

  .registerType(PostgresDatabase)
    .as<IDatabase>()
    .singleInstance()

  // Register domain services with autowiring
  .registerType(UserService)
    .as<IUserService>()
    .autoWire({
      map: {
        logger: (c) => c.resolveType<ILogger>(),
        db: (c) => c.resolveType<IDatabase>()
      }
    })
    .singleInstance()

  .build()

4. Use in Application

// app.ts
const userService = container.resolveType<IUserService>()

// All dependencies automatically injected!
const user = await userService.getUser('123')
console.log(user)