Inverting Dependencies: A JavaScript Example of the Dependency Inversion Principle

The Dependency Inversion Principle (DIP) is one of the SOLID principles of software design that states that high-level modules should not depend on low-level modules. Instead, both should depend on abstractions. In this article, we will explore the DIP in JavaScript and provide an example of how it can be violated and then fixed.

Violation of the DIP

Let’s take a look at an example of a violation of the DIP:

class Database {
  constructor() {
    this.items = [];
  }

  add(item) {
    this.items.push(item);
  }

  get(id) {
    return this.items.find((item) => item.id === id);
  }
}

class UserController {
  constructor() {
    this.database = new Database();
  }

  createUser(name) {
    const user = { id: Date.now(), name };
    this.database.add(user);
    return user;
  }

  getUser(id) {
    return this.database.get(id);
  }
}

In this example, we have a Database class that manages a collection of items and a UserController class that uses the Database class to create and retrieve users. The UserController class directly depends on the Database class, violating the DIP because the high-level UserController class is depending on the low-level Database class.

Applying The DIP

To fix this violation of the DIP, we need to invert the dependency by using an abstraction. Let’s see how this can be done:

class Database {
  constructor() {
    this.items = [];
  }

  add(item) {
    this.items.push(item);
  }

  get(id) {
    return this.items.find((item) => item.id === id);
  }
}

class DatabaseInterface {
  constructor(database) {
    this.database = database;
  }

  add(item) {
    this.database.add(item);
  }

  get(id) {
    return this.database.get(id);
  }
}

class UserController {
  constructor(databaseInterface) {
    this.databaseInterface = databaseInterface;
  }

  createUser(name) {
    const user = { id: Date.now(), name };
    this.databaseInterface.add(user);
    return user;
  }

  getUser(id) {
    return this.databaseInterface.get(id);
  }
}

In this fixed example, we have created an interface for the Database class, called DatabaseInterface. The UserController class now depends on the DatabaseInterface abstraction, which is implemented by the Database class. By using an abstraction, we have inverted the dependency, and now the low-level Database class depends on the high-level DatabaseInterface abstraction.

Conclusion

The Dependency Inversion Principle is an essential principle in software design. By inverting the dependency between high-level and low-level modules, we can create more modular, flexible, and maintainable code. Violating this principle can lead to code that is difficult to modify and extend and can cause problems down the road. By using an abstraction to decouple high-level and low-level modules, we can make our code more modular and extensible.

Overall, by understanding and implementing all of the SOLID principles in our code, we can write software that is more maintainable, scalable, and flexible.