Clean Architecture and Dependency Injection

package main

import (
	"errors"
	"fmt"
)

// ===== Domain layer: business rules only. No database, no HTTP, no imports from other layers.

const DailyLimit = 25000 // taka

var (
	ErrInsufficient = errors.New("insufficient balance")
	ErrDailyLimit   = fmt.Errorf("over daily limit %d", DailyLimit)
)

// Account is an entity (and a small aggregate): its rules live with its data.
type Account struct {
	ID        string
	balance   int
	sentToday int
}

func (a *Account) Withdraw(amount int) error {
	if a.sentToday+amount > DailyLimit {
		return ErrDailyLimit
	}
	if amount > a.balance {
		return ErrInsufficient
	}
	a.balance -= amount
	a.sentToday += amount
	return nil
}

func (a *Account) Deposit(amount int) { a.balance += amount }
func (a *Account) Balance() int       { return a.balance }

// ===== Application layer: use cases. It owns the interface it needs (the "port").

type AccountRepo interface {
	Get(id string) (*Account, error)
	Save(a *Account) error
}

type TransferService struct{ repo AccountRepo } // dependency injected, never created here

func NewTransferService(repo AccountRepo) *TransferService { return &TransferService{repo: repo} }

func (s *TransferService) Transfer(from, to string, amount int) error {
	src, err := s.repo.Get(from)
	if err != nil {
		return err
	}
	dst, err := s.repo.Get(to)
	if err != nil {
		return err
	}
	if err := src.Withdraw(amount); err != nil { // the rule lives in the domain
		return err
	}
	dst.Deposit(amount)
	if err := s.repo.Save(src); err != nil {
		return err
	}
	return s.repo.Save(dst)
}

// ===== Infrastructure layer: one implementation of the port. Postgres would be another.

type MemoryRepo struct{ rows map[string]Account }

func (m *MemoryRepo) Get(id string) (*Account, error) {
	a, ok := m.rows[id]
	if !ok {
		return nil, fmt.Errorf("account %s not found", id)
	}
	return &a, nil // a copy: changes count only after Save
}

func (m *MemoryRepo) Save(a *Account) error { m.rows[a.ID] = *a; return nil }

// ===== main: the composition root wires the layers together.

func main() {
	repo := &MemoryRepo{rows: map[string]Account{
		"A-1": {ID: "A-1", balance: 20000},
		"A-2": {ID: "A-2", balance: 2000},
	}}
	svc := NewTransferService(repo)

	cases := []struct {
		from, to string
		amount   int
	}{{"A-1", "A-2", 5000}, {"A-1", "A-2", 30000}, {"A-1", "A-2", 20000}, {"A-1", "A-9", 500}}
	for _, c := range cases {
		if err := svc.Transfer(c.from, c.to, c.amount); err != nil {
			fmt.Printf("transfer %5d %s -> %s: refused: %v\n", c.amount, c.from, c.to, err)
		} else {
			fmt.Printf("transfer %5d %s -> %s: ok\n", c.amount, c.from, c.to)
		}
	}
	a1, _ := repo.Get("A-1")
	a2, _ := repo.Get("A-2")
	fmt.Printf("balances: A-1 %d, A-2 %d\n", a1.Balance(), a2.Balance())
}

from __future__ import annotations

import copy
from typing import Protocol

# ===== Domain layer: business rules only. No database, no HTTP, no imports from other layers.

DAILY_LIMIT = 25000  # taka


class DomainError(Exception):
    pass


class Account:
    """An entity (and a small aggregate): its rules live with its data."""

    def __init__(self, id: str, balance: int):
        self.id = id
        self._balance = balance
        self._sent_today = 0

    def withdraw(self, amount: int) -> None:
        if self._sent_today + amount > DAILY_LIMIT:
            raise DomainError(f"over daily limit {DAILY_LIMIT}")
        if amount > self._balance:
            raise DomainError("insufficient balance")
        self._balance -= amount
        self._sent_today += amount

    def deposit(self, amount: int) -> None:
        self._balance += amount

    @property
    def balance(self) -> int:
        return self._balance


# ===== Application layer: use cases. It owns the interface it needs (the "port").

class AccountRepo(Protocol):
    def get(self, id: str) -> Account: ...
    def save(self, a: Account) -> None: ...


class TransferService:
    def __init__(self, repo: AccountRepo):  # dependency injected, never created here
        self.repo = repo

    def transfer(self, frm: str, to: str, amount: int) -> None:
        src, dst = self.repo.get(frm), self.repo.get(to)
        src.withdraw(amount)  # the rule lives in the domain
        dst.deposit(amount)
        self.repo.save(src)
        self.repo.save(dst)


# ===== Infrastructure layer: one implementation of the port. Postgres would be another.

class MemoryRepo:
    def __init__(self, accounts: list[Account]):
        self._rows = {a.id: a for a in accounts}

    def get(self, id: str) -> Account:
        if id not in self._rows:
            raise DomainError(f"account {id} not found")
        return copy.deepcopy(self._rows[id])  # a copy: changes count only after save

    def save(self, a: Account) -> None:
        self._rows[a.id] = copy.deepcopy(a)


# ===== The composition root wires the layers together.

repo = MemoryRepo([Account("A-1", 20000), Account("A-2", 2000)])
svc = TransferService(repo)

for frm, to, amount in [("A-1", "A-2", 5000), ("A-1", "A-2", 30000), ("A-1", "A-2", 20000), ("A-1", "A-9", 500)]:
    try:
        svc.transfer(frm, to, amount)
        print(f"transfer {amount:5d} {frm} -> {to}: ok")
    except DomainError as e:
        print(f"transfer {amount:5d} {frm} -> {to}: refused: {e}")

print(f"balances: A-1 {repo.get('A-1').balance}, A-2 {repo.get('A-2').balance}")

// ===== Domain layer: business rules only. No database, no HTTP, no imports from other layers.

const DAILY_LIMIT = 25000; // taka

class DomainError extends Error {}

// An entity (and a small aggregate): its rules live with its data.
class Account {
  readonly id: string;
  #balance: number;
  #sentToday: number;
  constructor(id: string, balance: number, sentToday = 0) {
    this.id = id;
    this.#balance = balance;
    this.#sentToday = sentToday;
  }
  withdraw(amount: number): void {
    if (this.#sentToday + amount > DAILY_LIMIT) throw new DomainError(`over daily limit ${DAILY_LIMIT}`);
    if (amount > this.#balance) throw new DomainError("insufficient balance");
    this.#balance -= amount;
    this.#sentToday += amount;
  }
  deposit(amount: number): void {
    this.#balance += amount;
  }
  get balance(): number {
    return this.#balance;
  }
  // Plain data for storage, so the repository never touches private fields.
  snapshot(): { id: string; balance: number; sentToday: number } {
    return { id: this.id, balance: this.#balance, sentToday: this.#sentToday };
  }
}

// ===== Application layer: use cases. It owns the interface it needs (the "port").

interface AccountRepo {
  get(id: string): Account;
  save(a: Account): void;
}

class TransferService {
  readonly repo: AccountRepo;
  constructor(repo: AccountRepo) {
    this.repo = repo; // dependency injected, never created here
  }
  transfer(from: string, to: string, amount: number): void {
    const src = this.repo.get(from);
    const dst = this.repo.get(to);
    src.withdraw(amount); // the rule lives in the domain
    dst.deposit(amount);
    this.repo.save(src);
    this.repo.save(dst);
  }
}

// ===== Infrastructure layer: one implementation of the port. Postgres would be another.

class MemoryRepo implements AccountRepo {
  readonly #rows = new Map<string, { id: string; balance: number; sentToday: number }>();
  constructor(accounts: Account[]) {
    for (const a of accounts) this.save(a);
  }
  get(id: string): Account {
    const row = this.#rows.get(id);
    if (!row) throw new DomainError(`account ${id} not found`);
    return new Account(row.id, row.balance, row.sentToday); // a copy: changes count only after save
  }
  save(a: Account): void {
    this.#rows.set(a.id, a.snapshot());
  }
}

// ===== The composition root wires the layers together.

const repo = new MemoryRepo([new Account("A-1", 20000), new Account("A-2", 2000)]);
const svc = new TransferService(repo);

const cases: [string, string, number][] = [["A-1", "A-2", 5000], ["A-1", "A-2", 30000], ["A-1", "A-2", 20000], ["A-1", "A-9", 500]];
for (const [from, to, amount] of cases) {
  try {
    svc.transfer(from, to, amount);
    console.log(`transfer ${String(amount).padStart(5)} ${from} -> ${to}: ok`);
  } catch (e) {
    console.log(`transfer ${String(amount).padStart(5)} ${from} -> ${to}: refused: ${(e as Error).message}`);
  }
}
console.log(`balances: A-1 ${repo.get("A-1").balance}, A-2 ${repo.get("A-2").balance}`);

use std::collections::HashMap;

// ===== Domain layer: business rules only. No database, no HTTP, no imports from other layers.

const DAILY_LIMIT: u32 = 25000; // taka

// An entity (and a small aggregate): its rules live with its data.
#[derive(Clone)]
struct Account { id: String, balance: u32, sent_today: u32 }

impl Account {
    fn new(id: &str, balance: u32) -> Self { Account { id: id.into(), balance, sent_today: 0 } }
    fn withdraw(&mut self, amount: u32) -> Result<(), String> {
        if self.sent_today + amount > DAILY_LIMIT { return Err(format!("over daily limit {DAILY_LIMIT}")); }
        if amount > self.balance { return Err("insufficient balance".into()); }
        self.balance -= amount;
        self.sent_today += amount;
        Ok(())
    }
    fn deposit(&mut self, amount: u32) { self.balance += amount; }
    fn balance(&self) -> u32 { self.balance }
}

// ===== Application layer: use cases. It owns the trait it needs (the "port").

trait AccountRepo {
    fn get(&self, id: &str) -> Result<Account, String>;
    fn save(&mut self, a: &Account) -> Result<(), String>;
}

// Generic over the repository: the dependency is injected, never created here.
struct TransferService<R: AccountRepo> { repo: R }

impl<R: AccountRepo> TransferService<R> {
    fn transfer(&mut self, from: &str, to: &str, amount: u32) -> Result<(), String> {
        let mut src = self.repo.get(from)?;
        let mut dst = self.repo.get(to)?;
        src.withdraw(amount)?; // the rule lives in the domain
        dst.deposit(amount);
        self.repo.save(&src)?;
        self.repo.save(&dst)
    }
}

// ===== Infrastructure layer: one implementation of the port. Postgres would be another.

struct MemoryRepo { rows: HashMap<String, Account> }

impl AccountRepo for MemoryRepo {
    fn get(&self, id: &str) -> Result<Account, String> {
        self.rows.get(id).cloned().ok_or(format!("account {id} not found")) // a copy
    }
    fn save(&mut self, a: &Account) -> Result<(), String> { self.rows.insert(a.id.clone(), a.clone()); Ok(()) }
}

// ===== main: the composition root wires the layers together.

fn main() {
    let rows = [Account::new("A-1", 20000), Account::new("A-2", 2000)].into_iter().map(|a| (a.id.clone(), a)).collect();
    let mut svc = TransferService { repo: MemoryRepo { rows } };

    for (from, to, amount) in [("A-1", "A-2", 5000), ("A-1", "A-2", 30000), ("A-1", "A-2", 20000), ("A-1", "A-9", 500)] {
        match svc.transfer(from, to, amount) {
            Ok(()) => println!("transfer {amount:5} {from} -> {to}: ok"),
            Err(e) => println!("transfer {amount:5} {from} -> {to}: refused: {e}"),
        }
    }
    let b = |id| svc.repo.get(id).unwrap().balance();
    println!("balances: A-1 {}, A-2 {}", b("A-1"), b("A-2"));
}

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Main {
    // ===== Domain layer: business rules only. No database, no HTTP, no imports from other layers.

    static final int DAILY_LIMIT = 25000; // taka

    static final class DomainException extends Exception {
        private static final long serialVersionUID = 1L;
        DomainException(String msg) { super(msg); }
    }

    // An entity (and a small aggregate): its rules live with its data.
    static final class Account {
        final String id;
        private int balance, sentToday;

        Account(String id, int balance, int sentToday) { this.id = id; this.balance = balance; this.sentToday = sentToday; }

        void withdraw(int amount) throws DomainException {
            if (sentToday + amount > DAILY_LIMIT) throw new DomainException("over daily limit " + DAILY_LIMIT);
            if (amount > balance) throw new DomainException("insufficient balance");
            balance -= amount;
            sentToday += amount;
        }
        void deposit(int amount) { balance += amount; }
        int balance() { return balance; }
        Account copy() { return new Account(id, balance, sentToday); }
    }

    // ===== Application layer: use cases. It owns the interface it needs (the "port").

    interface AccountRepo {
        Account get(String id) throws DomainException;
        void save(Account a);
    }

    static final class TransferService {
        private final AccountRepo repo;
        TransferService(AccountRepo repo) { this.repo = repo; } // dependency injected, never created here

        void transfer(String from, String to, int amount) throws DomainException {
            Account src = repo.get(from), dst = repo.get(to);
            src.withdraw(amount); // the rule lives in the domain
            dst.deposit(amount);
            repo.save(src);
            repo.save(dst);
        }
    }

    // ===== Infrastructure layer: one implementation of the port. Postgres would be another.

    static final class MemoryRepo implements AccountRepo {
        private final Map<String, Account> rows = new HashMap<>();
        MemoryRepo(List<Account> accounts) { accounts.forEach(this::save); }

        public Account get(String id) throws DomainException {
            Account a = rows.get(id);
            if (a == null) throw new DomainException("account " + id + " not found");
            return a.copy(); // a copy: changes count only after save
        }
        public void save(Account a) { rows.put(a.id, a.copy()); }
    }

    // ===== The composition root wires the layers together.

    record Case(String from, String to, int amount) {}

    public static void main(String[] args) throws DomainException {
        MemoryRepo repo = new MemoryRepo(List.of(new Account("A-1", 20000, 0), new Account("A-2", 2000, 0)));
        TransferService svc = new TransferService(repo);

        for (Case c : List.of(new Case("A-1", "A-2", 5000), new Case("A-1", "A-2", 30000),
                new Case("A-1", "A-2", 20000), new Case("A-1", "A-9", 500))) {
            try {
                svc.transfer(c.from(), c.to(), c.amount());
                System.out.printf("transfer %5d %s -> %s: ok%n", c.amount(), c.from(), c.to());
            } catch (DomainException e) {
                System.out.printf("transfer %5d %s -> %s: refused: %s%n", c.amount(), c.from(), c.to(), e.getMessage());
            }
        }
        System.out.printf("balances: A-1 %d, A-2 %d%n", repo.get("A-1").balance(), repo.get("A-2").balance());
    }
}

#include <cstdio>
#include <map>
#include <stdexcept>
#include <string>
#include <tuple>
#include <vector>

// ===== Domain layer: business rules only. No database, no HTTP, no includes from other layers.

constexpr int kDailyLimit = 25000;  // taka

struct DomainError : std::runtime_error {
    using std::runtime_error::runtime_error;
};

// An entity (and a small aggregate): its rules live with its data.
class Account {
public:
    Account(std::string id, int balance) : id(std::move(id)), balance_(balance) {}
    std::string id;
    void withdraw(int amount) {
        if (sentToday_ + amount > kDailyLimit) throw DomainError("over daily limit " + std::to_string(kDailyLimit));
        if (amount > balance_) throw DomainError("insufficient balance");
        balance_ -= amount;
        sentToday_ += amount;
    }
    void deposit(int amount) { balance_ += amount; }
    int balance() const { return balance_; }

private:
    int balance_, sentToday_ = 0;
};

// ===== Application layer: use cases. It owns the interface it needs (the "port").

class AccountRepo {
public:
    virtual ~AccountRepo() = default;
    virtual Account get(const std::string& id) const = 0;  // returns a copy
    virtual void save(const Account& a) = 0;
};

class TransferService {
public:
    explicit TransferService(AccountRepo& repo) : repo_(repo) {}  // dependency injected, never created here
    void transfer(const std::string& from, const std::string& to, int amount) {
        Account src = repo_.get(from), dst = repo_.get(to);
        src.withdraw(amount);  // the rule lives in the domain
        dst.deposit(amount);
        repo_.save(src);
        repo_.save(dst);
    }

private:
    AccountRepo& repo_;
};

// ===== Infrastructure layer: one implementation of the port. Postgres would be another.

class MemoryRepo : public AccountRepo {
public:
    explicit MemoryRepo(std::vector<Account> accounts) {
        for (auto& a : accounts) save(a);
    }
    Account get(const std::string& id) const override {
        auto it = rows_.find(id);
        if (it == rows_.end()) throw DomainError("account " + id + " not found");
        return it->second;  // a copy: changes count only after save
    }
    void save(const Account& a) override { rows_.insert_or_assign(a.id, a); }

private:
    std::map<std::string, Account> rows_;
};

// ===== main: the composition root wires the layers together.

int main() {
    MemoryRepo repo({Account("A-1", 20000), Account("A-2", 2000)});
    TransferService svc(repo);

    std::vector<std::tuple<std::string, std::string, int>> cases{
        {"A-1", "A-2", 5000}, {"A-1", "A-2", 30000}, {"A-1", "A-2", 20000}, {"A-1", "A-9", 500}};
    for (const auto& [from, to, amount] : cases) {
        try {
            svc.transfer(from, to, amount);
            std::printf("transfer %5d %s -> %s: ok\n", amount, from.c_str(), to.c_str());
        } catch (const DomainError& e) {
            std::printf("transfer %5d %s -> %s: refused: %s\n", amount, from.c_str(), to.c_str(), e.what());
        }
    }
    std::printf("balances: A-1 %d, A-2 %d\n", repo.get("A-1").balance(), repo.get("A-2").balance());
}