dependecnyInversion.ts

/**
 * Dependency Inversion Principle - CORRECT Implementation
 *
 * The Dependency Inversion Principle states that:
 * 1. High-level modules should not depend on low-level modules. Both should depend on abstractions.
 * 2. Abstractions should not depend on details. Details should depend on abstractions.
 *
 * This example demonstrates the CORRECT approach where:
 * - DBService is the abstraction (interface/abstract class)
 * - Both high-level (UserService, DBPersistence) and low-level (PostgresDatbase, DynamoDB)
 *   modules depend on the DBService abstraction
 * - Dependencies are injected through constructors (Dependency Injection)
 */

/**
 * Abstraction: DBService interface
 * This is the contract that all database implementations must follow
 * Both high-level and low-level modules depend on this abstraction
 */
abstract class DBService {
    abstract saveToDb(data : string): void;
}


/**
 * Low-level module: PostgreSQL database implementation
 * CORRECT: Implements the DBService abstraction
 * The concrete implementation depends on the abstraction, not the other way around
 */
class PostgresDatbase extends DBService{
    public saveToDb(data : string) : void {
        console.log("Saving ", data ,"to - PostgrsDB");
    }
}

/**
 * Low-level module: DynamoDB database implementation
 * CORRECT: Implements the DBService abstraction
 * The concrete implementation depends on the abstraction, not the other way around
 */
class DynamoDB extends DBService{
    public saveToDb(data: string) : void {
        console.log("Saving ", data, "to - DynamoDB");
    }
}

/**
 * High-level module: Database persistence layer
 * CORRECT: Depends on the DBService abstraction, not concrete implementations
 *
 * Benefits:
 * - Can work with ANY database that implements DBService
 * - Easy to test with mock implementations
 * - No need to modify this class when adding new databases
 */
class DBPersistence {
    // Dependency Injection: DBService is injected through constructor
    constructor(public dbService : DBService){}

    public saveToDb(data : string):void {
        this.dbService.saveToDb(data)
    }
}


/**
 * High-level module: UserService
 * CORRECT: Depends on the DBService abstraction, not concrete implementations
 *
 * Benefits of this approach:
 * 1. Loose coupling: UserService doesn't know about specific database implementations
 * 2. Easy to test: Can inject mock DBService for unit testing
 * 3. Flexible: Can easily switch databases by injecting different implementations
 * 4. Follows Open/Closed Principle: Can add new databases without modifying UserService
 * 5. Single responsibility: UserService only handles user logic, not database specifics
 */
class UserService {

    /**
     * Constructor uses Dependency Injection
     * CORRECT: Accepts DBService abstraction instead of creating concrete instances
     * This inverts the dependency - UserService no longer controls which database is used
     */
    constructor(public username : string, public dbService : DBService){}

    /**
     * Store data using the injected database service
     * This method works with ANY database that implements DBService
     */
    public storeDataToDb(): void {
        this.dbService.saveToDb(this.username);
    }


}

// Create concrete database instances
const postgresDb = new PostgresDatbase()

const dynamoDb = new DynamoDB()

// Dependency Injection in action: UserService receives the database dependency
// We can easily switch from postgresDb to dynamoDb without changing UserService
const userService : UserService = new UserService("Sulaiman", postgresDb);
userService.storeDataToDb();