class OrderService
{
    public function __construct(
        private UserService $userService,
        private PaymentService $paymentService,
        private InventoryService $inventory,
        private EmailService $emailService
    ) {}
}

@NgModule({
  imports: [CommonModule, UserModule],     // Nhập khẩu rõ ràng
  exports: [OrderComponent, OrderService], // Xuất khẩu rõ ràng
  providers: [OrderService]                // Dịch vụ nội bộ
})
export class OrderModule { }

// Bundle rõ ràng khai báo những gì nó nhập khẩu/xuất khẩu
Import-Package: com.example.user.service
Export-Package: com.example.order.service

class OrderModule implements PowerModule 
{
    public function register(ConfigurableContainerInterface $container): void 
    {
        // Container này chỉ dành cho OrderModule
        $container->set(OrderService::class, OrderService::class);
        $container->set(OrderRepository::class, OrderRepository::class);
        // Các dịch vụ này là riêng tư cho module này theo mặc định
    }
}

class UserModule implements PowerModule, ExportsComponents
{
    public static function exports(): array 
    {
        return [
            UserService::class,  // Chỉ cái này có sẵn cho các module khác
        ];
    }

    public function register(ConfigurableContainerInterface $container): void 
    {
        $container->set(UserService::class, UserService::class);
        $container->set(PasswordHasher::class, PasswordHasher::class); // Riêng tư!
    }
}

class OrderModule implements PowerModule, ImportsComponents
{
    public static function imports(): array 
    {
        return [
            ImportItem::create(UserModule::class, UserService::class),
            ImportItem::create(PaymentModule::class, PaymentService::class),
        ];
    }

    public function register(ConfigurableContainerInterface $container): void 
    {
        // Bây giờ UserService và PaymentService có sẵn để tiêm
        $container->set(OrderService::class, OrderService::class)
            ->addArguments([
                UserService::class,
                PaymentService::class,
            ]);
    }
}

class RoutingSetup implements CanSetupPowerModule
{
    public function setup(PowerModuleSetupDto $dto): void 
    {
        // Điều này chạy cho MỌI module trong quá trình xây dựng ứng dụng
        if ($dto->powerModule instanceof HasRoutes) {
            // Lấy tất cả các route được định nghĩa trong module này và đăng ký chúng với router
            $this->registerRoutes($dto->powerModule, $dto->moduleContainer);
        }
    }
}

// Sử dụng
$app = new ModularAppBuilder(__DIR__)
    ->withModules(UserModule::class, OrderModule::class)
    ->addPowerModuleSetup(new RoutingSetup())  // Mở rộng TẤT CẢ các module với HasRoutes interface
    ->build();

$app = new ModularAppBuilder(__DIR__)
    ->withConfig(Config::forAppRoot(__DIR__))
    ->withModules(
        AuthModule::class,
        UserModule::class, 
        OrderModule::class,
        PaymentModule::class
    )
    ->addPowerModuleSetup(new RoutingSetup())
    ->addPowerModuleSetup(new EventSetup())
    ->build();

// Truy cập bất kỳ dịch vụ nào đã xuất khẩu
$orderService = $app->get(OrderService::class);

Container Gốc
├── Container Module A (cô lập)
├── Container Module B (cô lập)
└── Dịch Vụ Xuất Khẩu (bí danh cho container module)

// Nhóm A sở hữu AuthModule
class AuthModule implements ExportsComponents {
    public static function exports(): array {
        return [
            UserService::class,
            AuthMiddleware::class
        ];
    }
}

// Nhóm B sở hữu OrderModule  
class OrderModule implements ImportsComponents {
    public static function imports(): array {
        return [
            ImportItem::create(AuthModule::class, UserService::class),
        ];
    }
}

// Kiểm tra OrderModule một cách độc lập
$testApp = new ModularAppBuilder(__DIR__)
    ->withModules(
        MockUserModule::class,  // Mô phỏng
        OrderModule::class      // Thực thi thực tế
    )
    ->build();

// Hôm nay: Modular monolith
ImportItem::create(UserModule::class, UserService::class)

// Ngày mai: Gọi API HTTP
ImportItem::create(UserApiModule::class, UserService::class)

// Symfony (các phụ thuộc mờ nhạt trong services.yaml)
class OrderController {
    // Các phụ thuộc được cấu hình trong YAML, không rõ ràng trong mã
}

// PowerModules (các nhập khẩu rõ ràng trong mã)  
class OrderModule implements ImportsComponents {
    public static function imports(): array {
        return [
            ImportItem::create(UserModule::class, UserService::class),
        ];
    }
}

// Laravel (container chia sẻ)
App::bind(OrderService::class, function($app) {
    return new OrderService($app->make(UserService::class));
});

// PowerModules (containers cô lập)
$container->set(OrderService::class, OrderService::class)
    ->addArguments([UserService::class]); // Được giải quyết từ container của module

composer require power-modules/framework

class MyModule implements PowerModule, ExportsComponents
{
    public static function exports(): array
    {
        return [MyService::class];
    }

    public function register(ConfigurableContainerInterface $container): void
    {
        $container->set(MyService::class, MyService::class);
    }
}

$app = new ModularAppBuilder(__DIR__)
    ->withModules(MyModule::class)
    ->build();

$service = $app->get(MyService::class);
// $service đã sẵn sàng để sử dụng, và tính năng tự động hoàn thành của IDE hoạt động!