Dependency Injection 💉

<?php
// The PROBLEM: a class that creates its own dependency with 'new'.

class MySQLConnection {
    public function query(string $sql): string {
        return "MySQL ran: $sql";
    }
}

class UserService {
    private MySQLConnection $db;

    public function __construct() {
        // ❌ The class reaches out and builds its OWN database.
        //    It is now glued (tightly coupled) to MySQL forever.
        $this->db = new MySQLConnection();
    }

    public function getUsers(): string {
        return $this->db->query("SELECT * FROM users");
    }
}

$service = new UserService();          // no choice about which DB you get
echo $service->getUsers() . "\n";      // MySQL ran: SELECT * FROM users

// Why this hurts:
//  - You can NEVER swap MySQL for PostgreSQL or SQLite.
//  - You can NEVER pass a fake DB in a test (it always hits MySQL).
//  - The dependency is hidden inside the class, not visible to callers.
echo "Locked to MySQL — untestable, unswappable.\n";

MySQL ran: SELECT * FROM users
Locked to MySQL — untestable, unswappable.

<?php
// The FIX: program to an INTERFACE and INJECT the dependency.

// 1) An interface = a contract. "Anything I accept must have query()."
interface Database {
    public function query(string $sql): string;
}

// 2) Real implementations both satisfy the contract.
class MySQLConnection implements Database {
    public function query(string $sql): string { return "MySQL ran: $sql"; }
}
class PostgresConnection implements Database {
    public function query(string $sql): string { return "Postgres ran: $sql"; }
}

class UserService {
    // 3) The dependency is PASSED IN. PHP 8 constructor promotion stores it.
    //    Type-hint the INTERFACE, never a concrete class.
    public function __construct(private Database $db) {}

    public function getUsers(): string {
        return $this->db->query("SELECT * FROM users");
    }
}

// 4) The CALLER decides which database to inject.
$mysql = new UserService(new MySQLConnection());
echo $mysql->getUsers() . "\n";        // MySQL ran: SELECT * FROM users

$postgres = new UserService(new PostgresConnection());
echo $postgres->getUsers() . "\n";     // Postgres ran: SELECT * FROM users

// 5) Tests can inject a fake — no real database needed.
$fake = new class implements Database {
    public function query(string $sql): string { return "FAKE ran: $sql"; }
};
echo (new UserService($fake))->getUsers() . "\n";  // FAKE ran: SELECT * FROM users

MySQL ran: SELECT * FROM users
Postgres ran: SELECT * FROM users
FAKE ran: SELECT * FROM users

<?php
// A small DI CONTAINER: it builds objects so YOU don't have to wire them by hand.

interface Logger { public function log(string $m): string; }

class FileLogger implements Logger {
    public function log(string $m): string { return "[file] $m"; }
}

class Report {
    // Report depends on a Logger contract — it never says 'new FileLogger'.
    public function __construct(private Logger $logger) {}
    public function run(): string { return $this->logger->log("report built"); }
}

class Container {
    private array $bindings = [];   // name => ['factory' => fn, 'shared' => bool]
    private array $shared   = [];   // cached singletons

    // bind() = a NEW object every time you resolve (transient lifetime).
    public function bind(string $id, callable $factory): void {
        $this->bindings[$id] = ['factory' => $factory, 'shared' => false];
    }

    // singleton() = built ONCE, then the same object is reused (shared lifetime).
    public function singleton(string $id, callable $factory): void {
        $this->bindings[$id] = ['factory' => $factory, 'shared' => true];
    }

    public function get(string $id): mixed {
        if (isset($this->shared[$id])) return $this->shared[$id];   // reuse
        $binding  = $this->bindings[$id];
        $instance = ($binding['factory'])($this);                   // build it
        if ($binding['shared']) $this->shared[$id] = $instance;     // cache it
        return $instance;
    }
}

$c = new Container();

// Register HOW to build each service. This is Inversion of Control:
// the container, not Report, owns the wiring.
$c->singleton(Logger::class, fn() => new FileLogger());           // one shared logger
$c->bind(Report::class, fn(Container $c) => new Report($c->get(Logger::class)));

$report = $c->get(Report::class);
echo $report->run() . "\n";                                      // [file] report built

// A singleton hands back the SAME instance every time:
$a = $c->get(Logger::class);
$b = $c->get(Logger::class);
echo "Same logger instance? " . ($a === $b ? "yes" : "no") . "\n";

// A bind() returns a FRESH instance every time:
$r1 = $c->get(Report::class);
$r2 = $c->get(Report::class);
echo "Same report instance? " . ($r1 === $r2 ? "yes" : "no") . "\n";

[file] report built
Same logger instance? yes
Same report instance? no

<?php
// 🎯 YOUR TURN — convert tight coupling into constructor injection.
// Fill in each blank marked ___ , then run it.

interface Mailer {
    public function send(string $to): string;
}

class SmtpMailer implements Mailer {
    public function send(string $to): string { return "Email sent to $to"; }
}

class SignupService {
    // 1) Inject the Mailer instead of building it inside the class.
    //    Type-hint the INTERFACE, not SmtpMailer.
    public function __construct(private ___ $mailer) {}   // 👉 the interface name

    public function register(string $email): string {
        // 2) Use the injected mailer to send to $email.
        return $this->mailer->___($email);                // 👉 the method name
    }
}

// 3) Inject a real SmtpMailer from OUTSIDE the class.
$service = new SignupService(new ___());                  // 👉 the concrete class
echo $service->register("sam@example.com") . "\n";

// ✅ Expected output:
//    Email sent to sam@example.com
?>

Email sent to sam@example.com

<?php
// 🎯 YOUR TURN — register a service and reuse it as a singleton.
// Fill in each blank marked ___ , then run it.

class Container {
    private array $bindings = [];
    private array $shared   = [];
    public function singleton(string $id, callable $factory): void {
        $this->bindings[$id] = $factory;
    }
    public function get(string $id): mixed {
        if (isset($this->shared[$id])) return $this->shared[$id];
        $this->shared[$id] = ($this->bindings[$id])();
        return $this->shared[$id];
    }
}

class Clock {
    public function now(): string { return "tick"; }
}

$c = new Container();

// 1) Register Clock as a singleton. The factory just builds a new Clock.
$c->singleton(Clock::class, fn() => new ___());           // 👉 the class to build

// 2) Resolve it twice out of the container.
$first  = $c->get(Clock::class);
$second = $c->___(Clock::class);                          // 👉 the resolve method

// A singleton must hand back the SAME object both times.
echo ($first === $second ? "same instance" : "different") . "\n";

// ✅ Expected output:
//    same instance
?>

same instance