## Cấu trúc dự án chi tiết

```
.
├── cmd/                    # Điểm vào ứng dụng
│   └── api/                # API server
│       └── main.go         # File main khởi động ứng dụng
├── global/                 # Biến toàn cục và cấu trúc cấu hình
│   └── global.go           # Định nghĩa các biến và cấu trúc toàn cục
├── internal/               # Mã nguồn nội bộ
│   ├── controllers/        # Xử lý request và response
│   │   └── user_controller.go  # Controller xử lý các request liên quan đến user
│   ├── initialize/         # Khởi tạo các thành phần của ứng dụng
│   │   ├── loadconfig.go   # Đọc cấu hình từ file .env
│   │   ├── logger.go       # Khởi tạo logger
│   │   ├── mysql.go        # Khởi tạo kết nối MySQL
│   │   └── run.go          # Điểm khởi động chính của ứng dụng
│   ├── models/             # Định nghĩa các model dữ liệu
│   │   └── user.go         # Model User
│   ├── repositories/       # Tương tác với cơ sở dữ liệu
│   │   └── user_repository.go  # Repository xử lý dữ liệu user
│   ├── routers/            # Định nghĩa các router
│   │   ├── router_group.go # Nhóm các router
│   │   └── user/           # Router liên quan đến user
│   │       ├── router_group.go  # Nhóm các router user
│   │       └── user_router.go   # Định nghĩa các endpoint user
│   ├── services/           # Xử lý logic nghiệp vụ
│   │   └── user_service.go # Service xử lý logic liên quan đến user
│   └── wire/               # Dependency injection với Google Wire
│       ├── injector.go     # Định nghĩa các injector
│       ├── wire.go         # Định nghĩa các provider
│       └── wire_gen.go     # File được tạo tự động bởi Wire
├── logs/                   # Thư mục chứa log
├── .air.toml               # Cấu hình cho Air (hot-reload)
├── .env                    # Biến môi trường
├── Dockerfile              # Cấu hình Docker cho môi trường production
├── Dockerfile.dev          # Cấu hình Docker cho môi trường phát triển
├── Makefile                # Các lệnh make
└── docker-compose.yml, docker-compose.dev.yml  # Cấu hình Docker Compose
```

## Quy tắc đặt tên file

Dự án tuân theo các quy tắc đặt tên file sau để đảm bảo tính nhất quán:

1. **Sử dụng dấu gạch dưới (_) để phân tách các từ** trong tên file, ví dụ: `user_controller.go`, `user_repository.go`.

2. **Tên file mô tả rõ chức năng** của file đó:
   - Controllers: `<entity>_controller.go` (ví dụ: `user_controller.go`)
   - Services: `<entity>_service.go` (ví dụ: `user_service.go`)
   - Repositories: `<entity>_repository.go` (ví dụ: `user_repository.go`)
   - Routers: `<entity>_router.go` (ví dụ: `user_router.go`)
   - Models: `<entity>.go` (ví dụ: `user.go`)

3. **File khởi tạo và cấu hình** sử dụng tên mô tả chức năng:
   - `loadconfig.go`: Đọc cấu hình
   - `logger.go`: Khởi tạo logger
   - `mysql.go`: Khởi tạo kết nối MySQL
   - `run.go`: Điểm khởi động ứng dụng

4. **File Wire** tuân theo quy ước của Google Wire:
   - `wire.go`: Định nghĩa các provider
   - `injector.go`: Định nghĩa các injector
   - `wire_gen.go`: File được tạo tự động bởi Wire

## Kiến trúc ứng dụng

Ứng dụng được tổ chức theo kiến trúc phân lớp:

1. **Controllers**: Xử lý request và response, gọi các service để thực hiện logic nghiệp vụ.
2. **Services**: Chứa logic nghiệp vụ, gọi các repository để tương tác với dữ liệu.
3. **Repositories**: Tương tác trực tiếp với cơ sở dữ liệu, thực hiện các thao tác CRUD.
4. **Models**: Định nghĩa cấu trúc dữ liệu.
5. **Routers**: Định nghĩa các endpoint API và kết nối với controllers.
6. **Wire**: Quản lý dependency injection, kết nối các thành phần lại với nhau.

## Dependency Injection với Google Wire

Dự án sử dụng Google Wire để quản lý dependency injection. Các thành phần chính:

1. **Provider**: Định nghĩa cách tạo các dependency (trong `wire.go`).
2. **Injector**: Định nghĩa cách kết nối các dependency (trong `injector.go`).
3. **Wire Gen**: File được tạo tự động bởi Wire, chứa code khởi tạo dependency (trong `wire_gen.go`).

Để cập nhật file `wire_gen.go` sau khi thay đổi các provider hoặc injector:

```bash
cd internal/wire
go run github.com/google/wire/cmd/wire
```

## Môi trường phát triển (Development)

### Phương pháp 1: Sử dụng Docker Compose cho toàn bộ stack

Phương pháp này sử dụng Docker Compose để chạy cả ứng dụng Go và MySQL, với hot-reload được hỗ trợ bởi Air.

```bash
# Khởi động môi trường phát triển
docker-compose -f docker-compose.dev.yml up -d

# Xem logs
docker-compose -f docker-compose.dev.yml logs -f

# Dừng môi trường phát triển
docker-compose -f docker-compose.dev.yml down
```

### Phương pháp 2: Chạy ứng dụng Go trực tiếp, MySQL trong Docker

```bash
# Khởi động MySQL trong Docker
make docker-run

# Chạy ứng dụng với hot-reload
make watch

# Hoặc chạy ứng dụng thông thường
make run

# Dừng MySQL
make docker-down
```

## Môi trường sản xuất (Production)

### Phương pháp 1: Sử dụng Docker Compose

```bash
# Khởi động môi trường sản xuất
docker-compose up -d

# Xem logs
docker-compose logs -f

# Dừng môi trường sản xuất
docker-compose down
```