From 95d68e9481ef4bebf18f5093123c9bef7c20b113 Mon Sep 17 00:00:00 2001
From: ulflow_phattt2901 <phattt2901@gmail.com>
Date: Thu, 5 Jun 2025 21:21:28 +0700
Subject: [PATCH] Initial commit

---
 .air.toml                                     |  58 ++
 .dockerignore                                 |  62 ++
 .env.example                                  |  32 +
 .feature-flags.json                           |   5 +
 .gitea/commit-template.txt                    |  14 +
 .gitea/hooks/pre-commit                       |  48 ++
 .gitea/hooks/prepare-commit-msg               |  34 +
 .gitea/workflows/ci.yml                       | 126 ++++
 .gitea/workflows/docker.yml                   | 135 ++++
 .gitignore                                    |  50 ++
 Dockerfile                                    | 102 +++
 Dockerfile.local                              |  32 +
 LICENSE                                       |  21 +
 Makefile                                      | 198 ++++++
 Readme.md                                     | 192 ++++++
 cmd/app/main.go                               | 176 +++++
 configs/config.yaml                           |  76 +++
 configs/security.example.yaml                 |  89 +++
 coverage                                      |  24 +
 docker-compose.prod.yml                       |  83 +++
 docker-compose.yml                            |  85 +++
 docs/.obsidian/app.json                       |   1 +
 docs/.obsidian/appearance.json                |   1 +
 docs/.obsidian/core-plugins.json              |  31 +
 docs/.obsidian/workspace.json                 | 184 ++++++
 docs/AUTHENTICATION.md                        | 209 ++++++
 docs/adapter.md                               | 149 +++++
 docs/architecture.md                          | 234 +++++++
 docs/changelog.md                             |  63 ++
 docs/general.md                               |  79 +++
 docs/review.md                                |  80 +++
 docs/roadmap.md                               |  98 +++
 docs/secrets.md                               | 136 ++++
 docs/session_20240524.md                      |  32 +
 docs/spec.md                                  | 130 ++++
 docs/testing.md                               | 119 ++++
 docs/unit-testing.md                          | 174 +++++
 docs/ux.md                                    |  57 ++
 docs/workflow.md                              |  84 +++
 go.mod                                        |  75 +++
 go.sum                                        | 600 ++++++++++++++++++
 .../adapter/persistence/role_repository.go    |  54 ++
 .../adapter/persistence/user_repository.go    | 106 ++++
 internal/domain/role/repository.go            |  24 +
 internal/domain/role/role.go                  |  25 +
 internal/domain/user/repository.go            |  38 ++
 internal/domain/user/user.go                  |  50 ++
 internal/helper/config/load.go                | 131 ++++
 internal/helper/config/types.go               | 100 +++
 internal/helper/database/database.go          | 154 +++++
 internal/helper/feature/feature.go            |  75 +++
 internal/helper/logger/README.md              | 118 ++++
 internal/helper/logger/logger.go              | 291 +++++++++
 internal/helper/logger/logger_test.go         | 252 ++++++++
 internal/pkg/lifecycle/lifecycle.go           | 142 +++++
 internal/service/auth_service.go              | 236 +++++++
 internal/service/auth_service_test.go         | 339 ++++++++++
 internal/transport/http/dto/error_response.go |   8 +
 internal/transport/http/dto/user_dto.go       |  70 ++
 .../transport/http/handler/auth_handler.go    | 149 +++++
 .../http/handler/auth_register_test.go        | 221 +++++++
 .../transport/http/handler/health_handler.go  |  70 ++
 .../http/handler/health_handler_test.go       | 308 +++++++++
 internal/transport/http/middleware/auth.go    | 126 ++++
 .../transport/http/middleware/auth_test.go    | 336 ++++++++++
 internal/transport/http/middleware/logger.go  |  43 ++
 .../transport/http/middleware/middleware.go   |  76 +++
 .../http/middleware/middleware_test.go        | 182 ++++++
 internal/transport/http/router.go             |  91 +++
 internal/transport/http/server.go             | 105 +++
 migrations/000000_initial_extensions.down.sql |   1 +
 migrations/000000_initial_extensions.up.sql   |   1 +
 migrations/000001_create_roles_table.down.sql |   1 +
 migrations/000001_create_roles_table.up.sql   |  14 +
 migrations/000002_create_users_table.down.sql |   1 +
 migrations/000002_create_users_table.up.sql   |  17 +
 .../000003_create_user_roles_table.down.sql   |   1 +
 .../000003_create_user_roles_table.up.sql     |  26 +
 templates/.env.example                        |  32 +
 templates/config.example.yaml                 |  31 +
 tomb.yaml                                     |  55 ++
 81 files changed, 8278 insertions(+)
 create mode 100644 .air.toml
 create mode 100644 .dockerignore
 create mode 100644 .env.example
 create mode 100644 .feature-flags.json
 create mode 100644 .gitea/commit-template.txt
 create mode 100644 .gitea/hooks/pre-commit
 create mode 100644 .gitea/hooks/prepare-commit-msg
 create mode 100644 .gitea/workflows/ci.yml
 create mode 100644 .gitea/workflows/docker.yml
 create mode 100644 .gitignore
 create mode 100644 Dockerfile
 create mode 100644 Dockerfile.local
 create mode 100644 LICENSE
 create mode 100644 Makefile
 create mode 100644 Readme.md
 create mode 100644 cmd/app/main.go
 create mode 100644 configs/config.yaml
 create mode 100644 configs/security.example.yaml
 create mode 100644 coverage
 create mode 100644 docker-compose.prod.yml
 create mode 100644 docker-compose.yml
 create mode 100644 docs/.obsidian/app.json
 create mode 100644 docs/.obsidian/appearance.json
 create mode 100644 docs/.obsidian/core-plugins.json
 create mode 100644 docs/.obsidian/workspace.json
 create mode 100644 docs/AUTHENTICATION.md
 create mode 100644 docs/adapter.md
 create mode 100644 docs/architecture.md
 create mode 100644 docs/changelog.md
 create mode 100644 docs/general.md
 create mode 100644 docs/review.md
 create mode 100644 docs/roadmap.md
 create mode 100644 docs/secrets.md
 create mode 100644 docs/session_20240524.md
 create mode 100644 docs/spec.md
 create mode 100644 docs/testing.md
 create mode 100644 docs/unit-testing.md
 create mode 100644 docs/ux.md
 create mode 100644 docs/workflow.md
 create mode 100644 go.mod
 create mode 100644 go.sum
 create mode 100644 internal/adapter/persistence/role_repository.go
 create mode 100644 internal/adapter/persistence/user_repository.go
 create mode 100644 internal/domain/role/repository.go
 create mode 100644 internal/domain/role/role.go
 create mode 100644 internal/domain/user/repository.go
 create mode 100644 internal/domain/user/user.go
 create mode 100644 internal/helper/config/load.go
 create mode 100644 internal/helper/config/types.go
 create mode 100644 internal/helper/database/database.go
 create mode 100644 internal/helper/feature/feature.go
 create mode 100644 internal/helper/logger/README.md
 create mode 100644 internal/helper/logger/logger.go
 create mode 100644 internal/helper/logger/logger_test.go
 create mode 100644 internal/pkg/lifecycle/lifecycle.go
 create mode 100644 internal/service/auth_service.go
 create mode 100644 internal/service/auth_service_test.go
 create mode 100644 internal/transport/http/dto/error_response.go
 create mode 100644 internal/transport/http/dto/user_dto.go
 create mode 100644 internal/transport/http/handler/auth_handler.go
 create mode 100644 internal/transport/http/handler/auth_register_test.go
 create mode 100644 internal/transport/http/handler/health_handler.go
 create mode 100644 internal/transport/http/handler/health_handler_test.go
 create mode 100644 internal/transport/http/middleware/auth.go
 create mode 100644 internal/transport/http/middleware/auth_test.go
 create mode 100644 internal/transport/http/middleware/logger.go
 create mode 100644 internal/transport/http/middleware/middleware.go
 create mode 100644 internal/transport/http/middleware/middleware_test.go
 create mode 100644 internal/transport/http/router.go
 create mode 100644 internal/transport/http/server.go
 create mode 100644 migrations/000000_initial_extensions.down.sql
 create mode 100644 migrations/000000_initial_extensions.up.sql
 create mode 100644 migrations/000001_create_roles_table.down.sql
 create mode 100644 migrations/000001_create_roles_table.up.sql
 create mode 100644 migrations/000002_create_users_table.down.sql
 create mode 100644 migrations/000002_create_users_table.up.sql
 create mode 100644 migrations/000003_create_user_roles_table.down.sql
 create mode 100644 migrations/000003_create_user_roles_table.up.sql
 create mode 100644 templates/.env.example
 create mode 100644 templates/config.example.yaml
 create mode 100644 tomb.yaml

diff --git a/.air.toml b/.air.toml
new file mode 100644
index 0000000..820a766
--- /dev/null
+++ b/.air.toml
@@ -0,0 +1,58 @@
+# Air Tomb Configuration for ULFlow Starter Kit
+root = "."
+tmp_dir = "tmp"
+
+[build]
+# Just plain old shell command. You could use `make` as well.
+cmd = "go build -o ./tmp/main.exe ./cmd/app"
+# Binary file yields from `cmd`.
+bin = "tmp/main.exe"
+# Customize binary.
+full_bin = "./tmp/main.exe"
+# Watch these filename extensions.
+include_ext = ["go", "tpl", "tmpl", "html"]
+# Ignore these filename extensions or directories.
+exclude_dir = ["assets", "tmp", "vendor", ".git", "node_modules"]
+# Watch these directories if you specified.
+include_dir = []
+# Exclude files.
+exclude_file = []
+# This log file places in your tmp_dir.
+log = "air.log"
+# It's not necessary to trigger build each time file changes if it's too frequent.
+delay = 1000 # ms
+# Stop running old binary when build errors occur.
+stop_on_error = true
+# Send Interrupt signal before killing process (windows does not support this feature)
+send_interrupt = true
+# Delay after sending Interrupt signal
+kill_delay = 500 # ms
+
+[log]
+# Show log time
+time = true
+
+[color]
+# Customize each part's color.
+main = "magenta"
+watcher = "cyan"
+build = "yellow"
+runner = "green"
+
+[misc]
+# Delete tmp directory on exit
+clean_on_exit = true
+
+[screen]
+clear_on_rebuild = true
+keep_scroll = true
+
+[tomb]
+# Enable Tomb for graceful shutdown
+enabled = true
+# Kill signal to use for graceful shutdown
+signal = "SIGTERM"
+# Timeout for graceful shutdown
+timeout = "5s"
+# Path to the tomb config file
+config = "./tomb.yaml"
diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 0000000..da3acec
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,62 @@
+# Version control
+.git
+.gitignore
+.gitattributes
+
+# Build artifacts
+/bin/
+/dist/
+
+# IDE specific files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Environment files (except .env.example)
+.env
+!.env.example
+
+# Log files
+*.log
+logs/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Test files
+*_test.go
+/test/
+/coverage.txt
+
+# Dependency directories
+/vendor/
+/node_modules/
+
+# Local development files
+docker-compose.override.yml
+
+# Build cache
+.cache/
+.air.toml
+
+# Temporary files
+*.tmp
+*.temp
+
+# Local configuration overrides
+configs/local.*
+
+# Documentation
+/docs/
+*.md
+
+# Ignore Dockerfile and docker-compose files (if you're building from source)
+# !Dockerfile
+# !docker-compose*.yml
diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..b7266f9
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,32 @@
+# App Configuration
+APP_NAME="ULFlow Starter Kit"
+APP_VERSION="0.1.0"
+APP_ENVIRONMENT="development"
+APP_TIMEZONE="Asia/Ho_Chi_Minh"
+
+# Logger Configuration
+LOG_LEVEL="info"  # debug, info, warn, error
+
+# Server Configuration
+SERVER_HOST="0.0.0.0"
+SERVER_PORT=3000
+SERVER_READ_TIMEOUT=15
+SERVER_WRITE_TIMEOUT=15
+SERVER_SHUTDOWN_TIMEOUT=30
+
+# Database Configuration
+DB_DRIVER="postgres"
+DB_HOST="localhost"
+DB_PORT=5432
+DB_USERNAME="postgres"
+DB_PASSWORD="your_password_here"
+DB_NAME="ulflow"
+DB_SSLMODE="disable"
+
+# JWT Configuration
+JWT_SECRET="your-32-byte-base64-encoded-secret-key-here"
+JWT_ACCESS_TOKEN_EXPIRE=15     # in minutes
+JWT_REFRESH_TOKEN_EXPIRE=10080  # in minutes (7 days)
+JWT_ALGORITHM="HS256"
+JWT_ISSUER="ulflow-starter-kit"
+JWT_AUDIENCE="ulflow-web"
diff --git a/.feature-flags.json b/.feature-flags.json
new file mode 100644
index 0000000..49be960
--- /dev/null
+++ b/.feature-flags.json
@@ -0,0 +1,5 @@
+{
+		"enable_database": {
+			"enabled": true
+		}
+	}
\ No newline at end of file
diff --git a/.gitea/commit-template.txt b/.gitea/commit-template.txt
new file mode 100644
index 0000000..c1b5a6b
--- /dev/null
+++ b/.gitea/commit-template.txt
@@ -0,0 +1,14 @@
+# <type>: <subject>
+
+# <body>
+
+# <footer>
+
+# Types:
+#   feat     (new feature)
+#   fix      (bug fix)
+#   docs     (documentation changes)
+#   style    (formatting, no code change)
+#   refactor (refactoring code)
+#   test     (adding tests, refactoring tests)
+#   chore    (updating tasks etc; no production code change)
diff --git a/.gitea/hooks/pre-commit b/.gitea/hooks/pre-commit
new file mode 100644
index 0000000..21b4218
--- /dev/null
+++ b/.gitea/hooks/pre-commit
@@ -0,0 +1,48 @@
+#!/bin/sh
+# Pre-commit hook for ULFlow Golang Starter Kit
+# This hook runs linters and checks before allowing a commit
+
+echo "Running pre-commit checks..."
+
+# Check for staged Go files
+STAGED_GO_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep "\.go$")
+
+if [[ "$STAGED_GO_FILES" = "" ]]; then
+  echo "No Go files staged for commit. Skipping Go-specific checks."
+else
+  # Run golangci-lint on staged files
+  echo "Running golangci-lint..."
+  golangci-lint run $STAGED_GO_FILES
+  if [ $? -ne 0 ]; then
+    echo "golangci-lint failed. Please fix the issues before committing."
+    exit 1
+  fi
+
+  # Check for formatting issues
+  echo "Checking Go formatting..."
+  gofmt -l $STAGED_GO_FILES
+  if [ $? -ne 0 ]; then
+    echo "gofmt failed. Please run 'gofmt -w' on your files before committing."
+    exit 1
+  fi
+
+  # Run tests related to staged files
+  echo "Running relevant tests..."
+  go test $(go list ./... | grep -v vendor) -short
+  if [ $? -ne 0 ]; then
+    echo "Tests failed. Please fix the tests before committing."
+    exit 1
+  fi
+fi
+
+# Check for sensitive information in staged files
+echo "Checking for sensitive information..."
+if git diff --cached | grep -E "(API_KEY|SECRET|PASSWORD|TOKEN).*[A-Za-z0-9_/-]{8,}" > /dev/null; then
+  echo "WARNING: Possible sensitive information detected in commit."
+  echo "Please verify you're not committing secrets, credentials or personal data."
+  echo "Press Enter to continue or Ctrl+C to abort the commit."
+  read
+fi
+
+echo "Pre-commit checks passed!"
+exit 0
diff --git a/.gitea/hooks/prepare-commit-msg b/.gitea/hooks/prepare-commit-msg
new file mode 100644
index 0000000..bd8bab2
--- /dev/null
+++ b/.gitea/hooks/prepare-commit-msg
@@ -0,0 +1,34 @@
+#!/bin/sh
+# prepare-commit-msg hook for ULFlow Golang Starter Kit
+# This hook prepares the commit message template
+
+COMMIT_MSG_FILE=$1
+COMMIT_SOURCE=$2
+SHA1=$3
+
+# Only add template if this is not a merge, amend, or rebase
+if [ -z "$COMMIT_SOURCE" ]; then
+  # Check the current branch name to suggest commit type
+  BRANCH_NAME=$(git symbolic-ref --short HEAD)
+  
+  # Extract type from branch name (e.g., feat/123-user-auth -> feat)
+  BRANCH_TYPE=$(echo $BRANCH_NAME | cut -d '/' -f 1)
+  
+  # If branch follows naming convention, prepopulate commit message
+  if [[ "$BRANCH_TYPE" =~ ^(feat|fix|docs|style|refactor|test|chore)$ ]]; then
+    # Get the first line of the current commit message
+    first_line=$(head -n 1 $COMMIT_MSG_FILE)
+    
+    # If the first line doesn't already have the type, prepend it
+    if [[ ! "$first_line" =~ ^$BRANCH_TYPE ]]; then
+      # Read existing commit msg
+      commit_msg=$(cat $COMMIT_MSG_FILE)
+      
+      # Create new commit msg with suggested type
+      echo "$BRANCH_TYPE: " > $COMMIT_MSG_FILE
+      echo "$commit_msg" >> $COMMIT_MSG_FILE
+    fi
+  fi
+fi
+
+exit 0
diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml
new file mode 100644
index 0000000..1f14f1b
--- /dev/null
+++ b/.gitea/workflows/ci.yml
@@ -0,0 +1,126 @@
+name: CI Pipeline
+
+on:
+  push:
+    branches-ignore: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ${{ secrets.RUNNER_LABEL || 'ubuntu-latest' }}
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+          cache-dependency-path: go.sum
+          
+      - name: Lint
+        uses: golangci/golangci-lint-action@v6
+        with:
+          version: latest
+          args: --timeout=5m
+          
+      - name: Notify on failure
+        if: failure()
+        run: echo "::warning::Linting failed. Please fix code style issues."
+          
+  security_scan:
+    name: Security Scan
+    runs-on: ${{ secrets.RUNNER_LABEL || 'ubuntu-latest' }}
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+          cache-dependency-path: go.sum
+          
+      - name: Run Go Vulnerability Check
+        uses: golang/govulncheck-action@v1
+        
+      - name: Notify on security issues
+        if: failure()
+        run: echo "::error::Security vulnerabilities detected. Please review dependencies."
+        
+  test:
+    name: Test
+    runs-on: ${{ secrets.RUNNER_LABEL || 'ubuntu-latest' }}
+    needs: lint
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+          cache-dependency-path: go.sum
+          
+      - name: Install go-junit-report
+        run: go install github.com/jstemmer/go-junit-report@latest
+          
+      - name: Test
+        run: |
+          go test -v -race -coverprofile=coverage.txt -covermode=atomic ./... | tee test-output.log
+          go tool cover -func=coverage.txt
+        
+      - name: Generate test report
+        if: always()
+        run: cat test-output.log | go-junit-report > junit-report.xml
+        
+      - name: Upload coverage
+        uses: codecov/codecov-action@v3
+        
+      - name: Upload test report
+        if: always()
+        uses: actions/upload-artifact@v3
+        with:
+          name: test-reports
+          path: junit-report.xml
+        
+  build:
+    name: Build
+    runs-on: ${{ secrets.RUNNER_LABEL || 'ubuntu-latest' }}
+    needs: [test, security_scan]
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Go
+        uses: actions/setup-go@v5
+        with:
+          go-version: '1.23'
+          cache-dependency-path: go.sum
+          
+      - name: Build
+        run: |
+          APP_VERSION="dev-${{ gitea.sha }}"
+          go build -v -ldflags="-s -w -X main.version=${APP_VERSION}" -o ./bin/app ./cmd/app
+          
+      - name: Upload build artifact
+        uses: actions/upload-artifact@v3
+        with:
+          name: app-binary
+          path: ./bin/api
+          
+      - name: Notify on success
+        if: success()
+        run: echo "::notice::Build successful. Ready for review and testing."
+
+  notify:
+    name: Notification
+    runs-on: ${{ secrets.RUNNER_LABEL || 'ubuntu-latest' }}
+    needs: [lint, test, security_scan, build]
+    if: always()
+    steps:
+      - name: Notify result
+        run: |
+          if [[ "${{ needs.build.result }}" == "success" ]]; then
+            echo "::notice::CI Pipeline completed successfully. Branch is ready for review."
+          else
+            echo "::warning::CI Pipeline failed. Please check the logs for details."
+          fi
diff --git a/.gitea/workflows/docker.yml b/.gitea/workflows/docker.yml
new file mode 100644
index 0000000..da3aadc
--- /dev/null
+++ b/.gitea/workflows/docker.yml
@@ -0,0 +1,135 @@
+name: Docker Build and Deploy
+
+on:
+  push:
+    tags: [ 'v*' ]
+  workflow_run:
+    #workflows: ["CI Pipeline"]
+    branches: [main]
+    types: [completed]
+
+jobs:
+  docker:
+    name: Build and Push Docker Image
+    runs-on: ubuntu-latest
+    if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') || github.event.workflow_run.conclusion == 'success' }}
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+      
+      - name: Login to Gitea Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ secrets.REGISTRY_URL }}
+          username: ${{ secrets.REGISTRY_USERNAME }}
+          password: ${{ secrets.REGISTRY_PASSWORD }}
+      
+      - name: Extract metadata
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: ${{ secrets.REGISTRY_URL }}/${{ gitea.repository }}
+          tags: |
+            type=semver,pattern={{version}}
+            type=ref,event=branch
+            type=sha,format=short
+      
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=registry,ref=${{ secrets.REGISTRY_URL }}/${{ gitea.repository }}:buildcache
+          cache-to: type=registry,ref=${{ secrets.REGISTRY_URL }}/${{ gitea.repository }}:buildcache,mode=max
+      
+      - name: Verify image
+        run: |
+          echo "Image successfully built and pushed with tags: ${{ steps.meta.outputs.tags }}"
+          echo "::notice::Docker image built and pushed successfully."
+
+  deploy:
+    name: Deploy to VPS
+    runs-on: ${{ secrets.DEPLOY_RUNNER || 'ubuntu-latest' }}
+    needs: docker
+    if: ${{ github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v') }}
+    steps:
+      - name: Set image name
+        run: echo "IMAGE_NAME=${{ secrets.REGISTRY_URL }}/${{ secrets.REPOSITORY_PATH }}:${{ gitea.ref_name || 'latest' }}" >> $GITEA_ENV
+      
+      - name: Install Docker CLI
+        run: |
+          apt-get update
+          apt-get install -y docker.io curl
+          docker version
+      
+      - name: Login to Gitea Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ${{ secrets.REGISTRY_URL }}
+          username: ${{ secrets.REGISTRY_USERNAME }}
+          password: ${{ secrets.REGISTRY_PASSWORD }}
+      
+      - name: Deploy to VPS
+        run: |
+          echo "Deploying image: ${{ env.IMAGE_NAME }}"
+          
+          # Pull latest image
+          docker pull ${{ env.IMAGE_NAME }}
+          
+          # Stop and remove existing container
+          docker stop ulflow-api-container || true
+          docker rm ulflow-api-container || true
+          
+          # Run new container
+          docker run -d \
+            --name ${{ secrets.CONTAINER_NAME || 'ulflow-api-container' }} \
+            --network ${{ secrets.DOCKER_NETWORK || 'ulflow-network' }} \
+            --restart always \
+            -p ${{ secrets.APP_PORT || '3000' }}:3000 \
+            -e APP_ENV=${{ secrets.APP_ENV || 'production' }} \
+            -e DB_HOST=${{ secrets.DB_HOST }} \
+            -e DB_USER=${{ secrets.DB_USER }} \
+            -e DB_PASSWORD=${{ secrets.DB_PASSWORD }} \
+            -e DB_NAME=${{ secrets.DB_NAME }} \
+            -e JWT_SECRET_KEY=${{ secrets.JWT_SECRET_KEY }} \
+            -e REFRESH_TOKEN_SECRET=${{ secrets.REFRESH_TOKEN_SECRET }} \
+            -e API_KEY=${{ secrets.API_KEY }} \
+            -e ENCRYPTION_KEY=${{ secrets.ENCRYPTION_KEY }} \
+            --health-cmd "${{ secrets.HEALTH_CMD || 'curl -f http://localhost:3000/health || exit 1' }}" \
+            --health-interval ${{ secrets.HEALTH_INTERVAL || '30s' }} \
+            --memory ${{ secrets.CONTAINER_MEMORY || '1g' }} \
+            --cpus ${{ secrets.CONTAINER_CPU || '1' }} \
+            ${{ env.IMAGE_NAME }}
+      
+      - name: Verify deployment
+        run: |
+          # Wait for container to start
+          sleep 10
+          
+          # Check container is running
+          if docker ps | grep ${{ secrets.CONTAINER_NAME || 'ulflow-api-container' }}; then
+            echo "Container is running"
+          else
+            echo "::error::Container failed to start"
+            docker logs ${{ secrets.CONTAINER_NAME || 'ulflow-api-container' }}
+            exit 1
+          fi
+          
+          # Check health endpoint
+          curl -f http://localhost:${{ secrets.APP_PORT || '3000' }}/health || (echo "::error::Health check failed" && exit 1)
+          
+          echo "::notice::Deployment successful!"
+      
+      - name: Send notification
+        if: always()
+        run: |
+          if [[ "${{ job.status }}" == "success" ]]; then
+            echo "::notice::🚀 Deployment to VPS successful! Version: ${{ gitea.ref_name }}"
+          else
+            echo "::error::❌ Deployment to VPS failed! Check logs for details."
+          fi
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..cfdb4cc
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,50 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+bin/
+tmp/
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+vendor/
+
+# Go workspace file
+go.work
+
+# IDE specific files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment variables
+.env
+
+# Log files
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/
+
+# Air Tomb temporary files
+.air.toml.tmp
+
+# Docker volumes
+docker/data/
+
+# Build artifacts
+dist/
+
+# OS specific files
+.DS_Store
+Thumbs.db
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 0000000..30bdcf2
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,102 @@
+# syntax=docker/dockerfile:1.4
+# Production-ready multi-stage build for server deployment
+
+# Build arguments
+ARG GO_VERSION=1.23.6
+ARG ALPINE_VERSION=3.19
+ARG APP_USER=appuser
+ARG APP_GROUP=appgroup
+
+# --- Builder Stage ---
+FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine AS builder
+
+# Install build dependencies
+RUN apk add --no-cache git make gcc libc-dev
+
+# Set working directory
+WORKDIR /build
+
+# Enable Go modules
+ENV GO111MODULE=on \
+    CGO_ENABLED=0 \
+    GOOS=linux \
+    GOARCH=amd64
+
+# Copy dependency files first for better layer caching
+COPY go.mod go.sum ./
+
+
+# Download dependencies
+RUN --mount=type=cache,target=/go/pkg/mod \
+    go mod download
+
+# Copy source code
+COPY . .
+
+
+# Create the configs directory in the build context
+RUN mkdir -p /build/configs && \
+    cp -r configs/* /build/configs/ 2>/dev/null || :
+
+# Build the application with optimizations
+RUN --mount=type=cache,target=/root/.cache/go-build \
+    go build -ldflags="-w -s -X 'main.Version=$(git describe --tags --always 2>/dev/null || echo 'dev')'" \
+    -o /build/bin/app ./cmd/app
+
+# --- Final Stage ---
+FROM alpine:${ALPINE_VERSION}
+
+# Re-declare ARG to use in this stage
+ARG APP_USER=appuser
+ARG APP_GROUP=appgroup
+ARG APP_HOME=/app
+
+# Set environment variables
+ENV TZ=Asia/Ho_Chi_Minh \
+    APP_USER=${APP_USER} \
+    APP_GROUP=${APP_GROUP} \
+    APP_HOME=${APP_HOME}
+
+# Install runtime dependencies
+RUN apk add --no-cache \
+    ca-certificates \
+    tzdata \
+    tini \
+    && rm -rf /var/cache/apk/*
+
+# Create app user and group
+RUN addgroup -S ${APP_GROUP} && \
+    adduser -S -G ${APP_GROUP} -h ${APP_HOME} -D ${APP_USER}
+
+# Create necessary directories
+RUN mkdir -p ${APP_HOME}/configs ${APP_HOME}/logs ${APP_HOME}/storage
+
+# Switch to app directory
+WORKDIR ${APP_HOME}
+
+# Copy binary and configs from builder
+COPY --from=builder --chown=${APP_USER}:${APP_GROUP} /build/bin/app .
+COPY --from=builder --chown=${APP_USER}:${APP_GROUP} /build/configs ./configs/
+
+# Set file permissions
+RUN chmod +x ./app && \
+    chown -R ${APP_USER}:${APP_GROUP} ${APP_HOME}
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
+    CMD wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1
+
+# Switch to non-root user
+USER ${APP_USER}
+
+# Default command
+CMD ["./app"]
+
+# Expose port
+EXPOSE 3000
+
+# Set environment variable for production
+ENV APP_ENV=production
+
+# Command to run the application
+ENTRYPOINT ["/sbin/tini", "--"]
diff --git a/Dockerfile.local b/Dockerfile.local
new file mode 100644
index 0000000..901398e
--- /dev/null
+++ b/Dockerfile.local
@@ -0,0 +1,32 @@
+# Dockerfile.local
+# Optimized for local development with hot reload
+
+# Build stage
+FROM golang:1.23-alpine AS builder
+
+# Install necessary tools for development
+RUN apk add --no-cache git make gcc libc-dev
+
+# Install Air for hot reload
+RUN go install github.com/cosmtrek/air@latest
+
+# Set working directory
+WORKDIR /app
+
+# Copy go.mod and go.sum files
+COPY go.mod go.sum* ./
+
+# Download dependencies
+RUN go mod download
+
+# Copy the entire project
+COPY . .
+
+# Expose port
+EXPOSE 3000
+
+# Set environment variable for development
+ENV APP_ENV=development
+
+# Command to run the application with hot reload
+CMD ["air", "-c", ".air.toml"]
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..ce6eedd
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ULFlow Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..fcdbe07
--- /dev/null
+++ b/Makefile
@@ -0,0 +1,198 @@
+# ULFlow Golang Starter Kit Makefile
+# Provides common commands for development, testing, and deployment
+
+# Load environment variables from .env file
+ifneq (,$(wildcard ./.env))
+    include .env
+    export
+endif
+
+.PHONY: help init dev test lint build clean docker-build docker-run docker-clean docker-prune docker-compose-up docker-compose-down docker-compose-prod-up docker-compose-prod-down ci setup-git all
+
+# Default target executed when no arguments are given to make.
+default: help
+
+# Show help message for all Makefile commands
+help:
+	@echo "ULFlow Golang Starter Kit"
+	@echo ""
+	@echo "Usage:"
+	@echo "  make <target>"
+	@echo ""
+	@echo "Targets:"
+	@echo "  init          - Initialize project dependencies and tools"
+	@echo "  dev           - Start development server with hot reload (Air Tomb)"
+	@echo "  test          - Run all tests"
+	@echo "  lint          - Run linters and code quality tools"
+	@echo "  build         - Build the application binary"
+	@echo "  clean         - Clean temporary files, build artifacts, and cache"
+	@echo "  docker-build  - Build Docker image"
+	@echo "  docker-run    - Run application in Docker container"
+	@echo "  docker-clean  - Remove project Docker containers"
+	@echo "  docker-prune  - Remove all unused Docker resources"
+	@echo "  docker-compose-up    - Start all services with Docker Compose for local development"
+	@echo "  docker-compose-down  - Stop all services started with Docker Compose"
+	@echo "  docker-compose-prod-up    - Start all services with Docker Compose for production"
+	@echo "  docker-compose-prod-down  - Stop all production services"
+	@echo "  ci            - Run CI workflow locally"
+	@echo "  setup-git     - Configure Git with commit message template and hooks"
+	@echo "  all           - Run lint, test, and build"
+
+# Initialize project dependencies and tools
+init:
+	@echo "Installing project dependencies and tools..."
+	go mod tidy
+	go install github.com/cosmtrek/air@latest
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+	@echo "Creating necessary directories..."
+	mkdir -p tmp
+	mkdir -p logs
+	
+	@echo "Copying .env file if not exists..."
+	@if not exist .env (
+		if exist templates\.env.example (
+			copy templates\.env.example .env
+			@echo "Created .env file from example"
+		) else (
+			@echo "Warning: templates/.env.example not found, skipping .env creation"
+		)
+	) else (
+		@echo ".env file already exists, skipping"
+	)
+	
+	@echo "Initialization complete!"
+
+# Start development server with hot reload
+dev:
+	@echo "Starting development server with Air Tomb..."
+	air
+
+# Run all tests
+test:
+	@echo "Running tests..."
+	go test -v -cover ./...
+
+# Run linters and code quality tools
+lint:
+	@echo "Running linters..."
+	golangci-lint run ./...
+
+# Build the application binary
+build:
+	@echo "Building application..."
+	go build -o bin/app cmd/app/main.go
+
+# Clean temporary files, build artifacts, and cache
+clean:
+	@echo "Cleaning project..."
+	if exist tmp rmdir /s /q tmp
+	if exist bin rmdir /s /q bin
+	if exist logs rmdir /s /q logs
+	go clean -cache -testcache -modcache
+	@echo "Project cleaned!"
+
+# Build Docker image
+docker-build:
+	@echo "Building Docker image..."
+	docker build -t ulflow-starter-kit:latest .
+
+# Run application in Docker container
+docker-run:
+	@echo "Running application in Docker container..."
+	@if not exist .env (
+		@echo "Warning: .env file not found. Running with default environment variables..."
+		docker run -p 3000:3000 ulflow-starter-kit:latest
+	) else (
+		docker run -p 3000:3000 --env-file .env ulflow-starter-kit:latest
+	)
+
+# Run Docker Compose for local development
+docker-compose-up:
+	@echo "Starting all services with Docker Compose for local development..."
+	docker-compose up -d
+	@echo "Services started! API is available at http://localhost:3000"
+
+# Stop Docker Compose services for local development
+docker-compose-down:
+	@echo "Stopping all development services..."
+	docker-compose down
+
+# Run Docker Compose for production
+docker-compose-prod-up:
+	@echo "Starting all services with Docker Compose for production..."
+	docker-compose -f docker-compose.prod.yml up -d
+	@echo "Production services started! API is available at http://localhost:3000"
+
+# Stop Docker Compose services for production
+docker-compose-prod-down:
+	@echo "Stopping all production services..."
+	docker-compose -f docker-compose.prod.yml down
+
+# Setup Git configuration
+setup-git-hooks:
+	@echo "Setting up Git hooks..."
+	git config --local commit.template .gitea/commit-template.txt
+	if not exist .git/hooks mkdir .git/hooks
+	copy /Y .gitea\hooks\pre-commit .git\hooks\ >nul
+	copy /Y .gitea\hooks\prepare-commit-msg .git\hooks\ >nul
+	git config --local core.hooksPath .git/hooks
+	@echo "Git setup complete!"
+
+# Create git message template
+setup-git-message:
+	@echo "Creating Git commit message template..."
+	if not exist .gitea mkdir .gitea
+	mkdir -p .gitea
+	echo "# <type>: <subject>\n\n# <body>\n\n# <footer>\n\n# Types:\n#   feat     (new feature)\n#   fix      (bug fix)\n#   docs     (documentation changes)\n#   style    (formatting, no code change)\n#   refactor (refactoring code)\n#   test     (adding tests, refactoring tests)\n#   chore    (updating tasks etc; no production code change)" > .gitea/commit-template.txt
+	git config --local commit.template .gitea/commit-template.txt
+	@echo "Git commit message template created!"
+
+
+# Prune all unused Docker resources
+docker-prune:
+	@echo "Pruning unused Docker resources..."
+	docker system prune -af --volumes
+	@echo "Docker resources pruned!"
+
+# Run local CI simulation
+ci:
+	@echo "Running CI workflow locally..."
+	make lint
+	make test
+	make build
+	make docker-build
+	@echo "CI simulation completed!"
+
+# Create a new migration
+migrate-create:
+	@read -p "Enter migration name: " name; \
+	migrate create -ext sql -dir migrations -seq $$name
+
+# Run migrations up
+m-up:
+	@echo "Running migrations with user: $(DATABASE_USERNAME)"
+	@echo "Database: $(DATABASE_NAME) on $(DATABASE_HOST):$(DATABASE_PORT)"
+	@echo "Using connection string: postgres://$(DATABASE_USERNAME):*****@$(DATABASE_HOST):$(DATABASE_PORT)/$(DATABASE_NAME)?sslmode=disable"
+	@migrate -path migrations -database "postgres://$(DATABASE_USERNAME):$(DATABASE_PASSWORD)@$(DATABASE_HOST):$(DATABASE_PORT)/$(DATABASE_NAME)?sslmode=disable" up
+
+# Run migrations down
+m-down:
+	@echo "Reverting migrations..."
+	@migrate -path migrations -database "postgres://$(DATABASE_USERNAME):$(DATABASE_PASSWORD)@$(DATABASE_HOST):$(DATABASE_PORT)/$(DATABASE_NAME)?sslmode=disable" down
+
+# Reset database (drop all tables and re-run migrations)
+m-reset: m-down m-up
+	@echo "Database reset complete!"
+
+# Show migration status
+m-status:
+	@migrate -path migrations -database "postgres://$(DATABASE_USERNAME):$(DATABASE_PASSWORD)@$(DATABASE_HOST):$(DATABASE_PORT)/$(DATABASE_NAME)?sslmode=disable" version
+
+# Force migration to specific version (fix dirty state)
+m-force:
+	@echo "Forcing migration to version $(version)..."
+	@migrate -path migrations -database "postgres://$(DATABASE_USERNAME):$(DATABASE_PASSWORD)@$(DATABASE_HOST):$(DATABASE_PORT)/$(DATABASE_NAME)?sslmode=disable" force $(version)
+
+# Run application (default: without hot reload)
+run:
+	go run ./cmd/app/main.go
diff --git a/Readme.md b/Readme.md
new file mode 100644
index 0000000..5dca72f
--- /dev/null
+++ b/Readme.md
@@ -0,0 +1,192 @@
+# ULFlow Golang Starter Kit
+
+<div align="center">
+
+![ULFlow Logo](https://via.placeholder.com/200x80?text=ULFlow)
+
+[![Go Version](https://img.shields.io/badge/Go-1.23-00ADD8.svg)](https://go.dev/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+</div>
+
+## Tổng quan
+
+ULFlow Golang Starter Kit là nền tảng khởi tạo dự án backend cho Team ULFlow, được thiết kế để giúp khởi tạo các dự án trong thời gian ngắn, nhanh chóng mà vẫn đảm bảo các yếu tố cơ bản về kiến trúc, bảo mật và khả năng mở rộng.
+
+### Đặc điểm chính
+
+- **Kiến trúc DDD (Domain Driven Development)** - Customize cho phù hợp với nhu cầu dự án
+- **U-Hierarchy** - Mô hình tổ chức mã nguồn theo các cấp độ logic
+- **Hot Reload** - Phát triển nhanh với Air Tomb
+- **Docker & Docker Compose** - Containerization và orchestration
+- **Gitea Full** - CI/CD, Secret Manager, Registry Image
+- **Postgres** - Cơ sở dữ liệu quan hệ
+
+## Cài đặt
+
+### Yêu cầu hệ thống
+
+- Go 1.23
+- Docker và Docker Compose
+- Git
+
+### Khởi tạo dự án
+
+```bash
+# Clone repository
+git clone [repo-url] my-project
+cd my-project
+
+# Cài đặt dependencies và công cụ
+make init
+
+# Cấu hình môi trường
+cp .env.example .env
+# Chỉnh sửa file .env theo nhu cầu
+
+# Khởi động môi trường phát triển
+make dev
+```
+
+### Sử dụng Docker
+
+Dự án cung cấp hai cấu hình Docker:
+
+#### Môi trường phát triển (Local)
+
+```bash
+# Khởi động tất cả các dịch vụ với Docker Compose
+make docker-compose-up
+
+# Dừng tất cả các dịch vụ
+make docker-compose-down
+
+# Dọn dẹp container sau khi sử dụng
+make docker-clean
+```
+
+Môi trường phát triển bao gồm:
+- API service với hot reload (Air Tomb)
+- PostgreSQL database
+- Gitea (Git Server, CI/CD, Registry)
+- Gitea Runner
+
+#### Môi trường production
+
+```bash
+# Khởi động các dịch vụ cho production
+make docker-compose-prod-up
+
+# Dừng các dịch vụ production
+make docker-compose-prod-down
+```
+
+Môi trường production bao gồm:
+- API service (optimized build)
+- PostgreSQL database
+- Nginx reverse proxy
+
+## Kiến trúc
+
+Dự án sử dụng mô hình DDD (Domain Driven Development) với các thành phần chính:
+
+- **Resource**: Các Aggregate DDD
+- **Transaction**: Các Saga điều phối luồng nghiệp vụ phức tạp
+- **Adapter**: Xử lý giao tiếp với các hệ thống bên ngoài
+- **Helper**: Các thư viện, tiện ích dùng chung
+- **UIUX**: Lớp giao diện người dùng
+
+Thành phần kiến trúc chi tiết (U-Hierarchy):
+
+- **ubit**: Đơn vị logic nhỏ nhất (hàm, type, hằng số)
+- **ubrick**: Tập hợp các `ubit` liên quan
+- **ublock**: Thành phần hoạt động độc lập tương đối
+- **ubundle**: Tính năng hoàn chỉnh cho người dùng
+
+## Cấu trúc thư mục
+
+```
+├── cmd/                # Entry points
+├── pkg/                # Packages
+│   ├── resource/       # Domain resources (DDD Aggregates)
+│   ├── transaction/    # Business workflows
+│   ├── adapter/        # External system interfaces
+│   ├── helper/         # Utilities
+│   └── uiux/           # User interfaces
+├── config/             # Configuration
+├── docs/               # Documentation
+├── scripts/            # Helper scripts
+└── test/               # Tests
+```
+
+## Các lệnh Makefile
+
+```bash
+# Xem danh sách lệnh có sẵn
+make help
+
+# Khởi tạo dự án
+make init
+
+# Chạy môi trường phát triển với Air Tomb
+make dev
+
+# Chạy tests
+make test
+
+# Kiểm tra linting
+make lint
+
+# Build ứng dụng
+make build
+
+# Dọn dẹp tệp tạm
+make clean
+
+# Docker commands
+make docker-build                # Build Docker image
+make docker-run                  # Run container từ image
+make docker-clean                # Dọn dẹp container
+make docker-prune                # Dọn dẹp tất cả tài nguyên Docker không sử dụng
+make docker-compose-up           # Khởi động môi trường phát triển
+make docker-compose-down         # Dừng môi trường phát triển
+make docker-compose-prod-up      # Khởi động môi trường production
+make docker-compose-prod-down    # Dừng môi trường production
+
+# Cấu hình Git
+make setup-git
+```
+
+## Quy trình phát triển
+
+Dự án sử dụng Trunk-Based Development với các quy ước đặt tên nhánh:
+
+- `feat`: Tạo tính năng mới
+- `fix`: Sửa lỗi
+- `docs`: Thay đổi tài liệu
+- `style`: Thay đổi không ảnh hưởng đến logic
+- `refactor`: Refactor code
+- `test`: Thêm hoặc sửa test
+- `chore`: Thay đổi cấu hình hoặc các task không liên quan đến code
+
+Xem thêm chi tiết trong [docs/workflow.md](docs/workflow.md).
+
+## Tài liệu
+
+- [Kiến trúc](docs/architecture.md)
+- [Thông số kỹ thuật](docs/spec.md)
+- [Roadmap](docs/roadmap.md)
+- [Quy trình làm việc](docs/workflow.md)
+- [CI/CD Workflows](docs/workflows.md)
+- [Testing](docs/testing.md)
+- [Adapter](docs/adapter.md)
+- [UX](docs/ux.md)
+- [Changelog](docs/changelog.md)
+
+## Đóng góp
+
+Xem hướng dẫn đóng góp trong [docs/workflow.md](docs/workflow.md).
+
+## Giấy phép
+
+Dự án này được phân phối dưới Giấy phép MIT. Xem file `LICENSE` để biết thêm thông tin.
\ No newline at end of file
diff --git a/cmd/app/main.go b/cmd/app/main.go
new file mode 100644
index 0000000..ecfe87c
--- /dev/null
+++ b/cmd/app/main.go
@@ -0,0 +1,176 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"time"
+
+	"gorm.io/gorm"
+	"starter-kit/internal/helper/config"
+	"starter-kit/internal/helper/database"
+	"starter-kit/internal/helper/feature"
+	"starter-kit/internal/helper/logger"
+	"starter-kit/internal/pkg/lifecycle"
+	"starter-kit/internal/transport/http"
+)
+
+// HTTPService implements the lifecycle.Service interface for the HTTP server
+type HTTPService struct {
+	server *http.Server
+	cfg    *config.Config
+	db     *database.Database
+}
+
+func NewHTTPService(cfg *config.Config, db *database.Database) *HTTPService {
+	return &HTTPService{
+		server: http.NewServer(cfg, db.DB),
+		cfg:    cfg,
+		db:     db,
+	}
+}
+
+func (s *HTTPService) Name() string {
+	return "HTTP Server"
+}
+
+func (s *HTTPService) Start() error {
+	// Tạo channel để nhận lỗi từ goroutine
+	errChan := make(chan error, 1)
+	
+	// Khởi động server trong goroutine
+	go func() {
+		logger.Infof("Đang khởi động %s trên %s:%d...", s.Name(), s.cfg.Server.Host, s.cfg.Server.Port)
+		if err := s.server.Start(); err != nil {
+			logger.WithError(err).Error("Lỗi HTTP server")
+			errChan <- fmt.Errorf("lỗi HTTP server: %w", err)
+			return
+		}
+		errChan <- nil
+	}()
+
+	// Chờ server khởi động hoặc báo lỗi
+	select {
+	case err := <-errChan:
+		return err // Trả về lỗi nếu có
+	case <-time.After(5 * time.Second):
+		// Nếu sau 5 giây không có lỗi, coi như server đã khởi động thành công
+		logger.Infof("%s đã khởi động thành công trên %s:%d", s.Name(), s.cfg.Server.Host, s.cfg.Server.Port)
+		return nil
+	}
+}
+
+func (s *HTTPService) Shutdown(ctx context.Context) error {
+	return s.server.Shutdown(ctx)
+}
+
+func main() {
+	// Initialize config loader
+	configLoader := config.NewConfigLoader()
+
+	// Load configuration
+	cfg, err := configLoader.Load()
+	if err != nil {
+		fmt.Printf("Failed to load configuration: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Initialize logger
+	logger.Init(&logger.LogConfig{
+		Level:        cfg.Logger.Level,
+		Format:       "json",
+		EnableCaller: true,
+		ReportCaller: true,
+	})
+
+	// Initialize feature flags
+	if err := feature.Init(); err != nil {
+		logger.WithError(err).Fatal("Failed to initialize feature flags")
+	}
+
+	// Print application info
+	logger.Infof("Starting %s v%s", cfg.App.Name, cfg.App.Version)
+	logger.Infof("Environment: %s", cfg.App.Environment)
+	logger.Infof("Log Level: %s", cfg.Logger.Level)
+	logger.Infof("Timezone: %s", cfg.App.Timezone)
+
+	// Print server config
+	logger.Infof("Server config: %s:%d", cfg.Server.Host, cfg.Server.Port)
+	logger.Infof("Read Timeout: %d seconds", cfg.Server.ReadTimeout)
+	logger.Infof("Write Timeout: %d seconds", cfg.Server.WriteTimeout)
+	logger.Infof("Shutdown Timeout: %d seconds", cfg.Server.ShutdownTimeout)
+
+	// Create a new lifecycle manager
+	shutdownTimeout := 30 * time.Second // Default shutdown timeout
+	if cfg.Server.ShutdownTimeout > 0 {
+		shutdownTimeout = time.Duration(cfg.Server.ShutdownTimeout) * time.Second
+	}
+	lifecycleMgr := lifecycle.New(shutdownTimeout)
+
+	// Initialize database connection
+	db, err := database.NewConnection(&cfg.Database)
+	if err != nil {
+		logger.WithError(err).Fatal("Failed to connect to database")
+	}
+
+	// Run database migrations
+	if err := database.Migrate(cfg.Database); err != nil {
+		logger.WithError(err).Fatal("Failed to migrate database")
+	}
+
+	// Register database cleanup on shutdown
+	lifecycleMgr.Register(&databaseService{db: db})
+
+	// Initialize HTTP service with database
+	httpService := NewHTTPService(cfg, &database.Database{DB: db})
+	if httpService == nil {
+		logger.Fatal("Failed to create HTTP service")
+	}
+	lifecycleMgr.Register(httpService)
+
+	// Start all services
+	logger.Info("Đang khởi động các dịch vụ...")
+	if err := lifecycleMgr.Start(); err != nil {
+		logger.WithError(err).Fatal("Lỗi nghiêm trọng: Không thể khởi động các dịch vụ")
+	}
+
+	// Handle OS signals for graceful shutdown in a separate goroutine
+	go lifecycleMgr.ShutdownOnSignal()
+
+	// Wait for all services to complete
+	if err := lifecycleMgr.Wait(); err != nil {
+		logger.WithError(err).Error("Service error")
+	}
+
+	// Close feature flags
+	if err := feature.Close(); err != nil {
+		logger.WithError(err).Error("Failed to close feature flags")
+	}
+
+	logger.Info("Application stopped")
+}
+
+// databaseService implements the lifecycle.Service interface for database operations
+type databaseService struct {
+	db *gorm.DB
+}
+
+func (s *databaseService) Name() string {
+	return "Database Service"
+}
+
+func (s *databaseService) Start() error {
+	// Database initialization is handled in main
+	return nil
+}
+
+func (s *databaseService) Shutdown(ctx context.Context) error {
+	if s.db != nil {
+		sqlDB, err := s.db.DB()
+		if err != nil {
+			return fmt.Errorf("failed to get database instance: %w", err)
+		}
+		return sqlDB.Close()
+	}
+	return nil
+}
diff --git a/configs/config.yaml b/configs/config.yaml
new file mode 100644
index 0000000..b4f83d4
--- /dev/null
+++ b/configs/config.yaml
@@ -0,0 +1,76 @@
+app:
+  name: "ULFlow Starter Kit"
+  version: "0.1.0"
+  environment: "development"
+  timezone: "Asia/Ho_Chi_Minh"
+
+logger:
+  level: "info" # debug, info, warn, error
+
+server:
+  host: "0.0.0.0"
+  port: 3000
+  read_timeout: 15
+  write_timeout: 15
+  shutdown_timeout: 30
+  trusted_proxies: []
+  allow_origins:
+    - "*"
+
+database:
+  driver: "postgres"
+  host: "localhost"
+  port: 5432
+  username: "postgres"
+  password: "postgres"
+  database: "ulflow"
+  ssl_mode: "disable"
+  max_open_conns: 25
+  max_idle_conns: 5
+  conn_max_lifetime: 300
+  migration_path: "migrations"
+
+# JWT Configuration
+jwt:
+  # Generate a secure random secret key using: openssl rand -base64 32
+  secret: "ulflow2121_this_is_a_secure_key_for_jwt_signing"
+  # Access Token expiration time in minutes (15 minutes)
+  access_token_expire: 15
+  # Refresh Token expiration time in minutes (7 days = 10080 minutes)
+  refresh_token_expire: 10080
+  # Algorithm for JWT signing (HS256, HS384, HS512, RS256, etc.)
+  algorithm: "HS256"
+  # Issuer for JWT tokens
+  issuer: "ulflow-starter-kit"
+  # Audience for JWT tokens
+  audience: ["ulflow-web"]
+
+# Security configurations
+security:
+  # Rate limiting for authentication endpoints (requests per minute)
+  rate_limit:
+    login: 5
+    register: 3
+    refresh: 10
+  # Password policy
+  password:
+    min_length: 8
+    require_upper: true
+    require_lower: true
+    require_number: true
+    require_special: true
+  # Cookie settings
+  cookie:
+    secure: true
+    http_only: true
+    same_site: "Lax"  # or "Strict" for more security
+    domain: ""  # Set your domain in production
+    path: "/"
+  # CORS settings
+  cors:
+    allowed_origins: ["*"]  # Restrict in production
+    allowed_methods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"]
+    allowed_headers: ["Origin", "Content-Type", "Accept", "Authorization"]
+    exposed_headers: ["Content-Length", "X-Total-Count"]
+    allow_credentials: true
+    max_age: 300  # 5 minutes
diff --git a/configs/security.example.yaml b/configs/security.example.yaml
new file mode 100644
index 0000000..9d39b64
--- /dev/null
+++ b/configs/security.example.yaml
@@ -0,0 +1,89 @@
+# Cấu hình bảo mật cho ứng dụng
+
+# Cấu hình CORS
+cors:
+  # Danh sách các domain được phép truy cập (sử dụng "*" để cho phép tất cả)
+  allowed_origins:
+    - "https://example.com"
+    - "https://api.example.com"
+  
+  # Các phương thức HTTP được phép
+  allowed_methods:
+    - GET
+    - POST
+    - PUT
+    - PATCH
+    - DELETE
+    - OPTIONS
+  
+  # Các header được phép
+  allowed_headers:
+    - Origin
+    - Content-Type
+    - Content-Length
+    - Accept-Encoding
+    - X-CSRF-Token
+    - Authorization
+    - X-Requested-With
+    - X-Request-ID
+  
+  # Các header được phép hiển thị
+  exposed_headers:
+    - Content-Length
+    - X-Total-Count
+  
+  # Cho phép gửi credentials (cookie, authorization headers)
+  allow_credentials: true
+  
+  # Thời gian cache preflight request (ví dụ: 5m, 1h)
+  max_age: 5m
+  
+  # Bật chế độ debug
+  debug: false
+
+# Cấu hình Rate Limiting
+rate_limit:
+  # Số request tối đa trong khoảng thời gian
+  rate: 100
+  
+  # Khoảng thời gian (ví dụ: 1m, 5m, 1h)
+  window: 1m
+  
+  # Danh sách các route được bỏ qua rate limiting
+  excluded_routes:
+    - "/health"
+    - "/metrics"
+
+# Cấu hình Security Headers
+headers:
+  # Bật/tắt security headers
+  enabled: true
+  
+  # Chính sách bảo mật nội dung (Content Security Policy)
+  content_security_policy: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'"
+  
+  # Chính sách bảo mật truy cập tài nguyên (Cross-Origin)
+  cross_origin_resource_policy: "same-origin"
+  cross_origin_opener_policy: "same-origin"
+  cross_origin_embedder_policy: "require-corp"
+  
+  # Chính sách tham chiếu (Referrer-Policy)
+  referrer_policy: "no-referrer-when-downgrade"
+  
+  # Chính sách sử dụng các tính năng trình duyệt (Feature-Policy)
+  feature_policy: "geolocation 'none'; midi 'none'; notifications 'none'; push 'none'; sync-xhr 'none'; microphone 'none'; camera 'none'; magnetometer 'none'; gyroscope 'none'; speaker 'none'; vibrate 'none'; fullscreen 'none'; payment 'none'"
+  
+  # Chính sách bảo vệ clickjacking (X-Frame-Options)
+  frame_options: "DENY"
+  
+  # Chính sách bảo vệ XSS (X-XSS-Protection)
+  xss_protection: "1; mode=block"
+  
+  # Chính sách MIME type sniffing (X-Content-Type-Options)
+  content_type_options: "nosniff"
+  
+  # Chính sách Strict-Transport-Security (HSTS)
+  strict_transport_security: "max-age=31536000; includeSubDomains; preload"
+  
+  # Chính sách Permissions-Policy (thay thế cho Feature-Policy)
+  permissions_policy: "geolocation=(), microphone=(), camera=()"
diff --git a/coverage b/coverage
new file mode 100644
index 0000000..37b91be
--- /dev/null
+++ b/coverage
@@ -0,0 +1,24 @@
+mode: set
+starter-kit/internal/transport/http/handler/auth_handler.go:18.63,22.2 1 1
+starter-kit/internal/transport/http/handler/auth_handler.go:36.48,38.47 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:38.47,41.3 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:44.2,45.16 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:45.16,47.54 1 1
+starter-kit/internal/transport/http/handler/auth_handler.go:47.54,49.4 1 0
+starter-kit/internal/transport/http/handler/auth_handler.go:49.9,51.4 1 1
+starter-kit/internal/transport/http/handler/auth_handler.go:52.3,52.9 1 1
+starter-kit/internal/transport/http/handler/auth_handler.go:56.2,57.42 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:72.45,74.47 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:74.47,77.3 2 0
+starter-kit/internal/transport/http/handler/auth_handler.go:80.2,81.16 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:81.16,84.3 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:87.2,95.33 3 0
+starter-kit/internal/transport/http/handler/auth_handler.go:109.52,115.47 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:115.47,118.3 2 1
+starter-kit/internal/transport/http/handler/auth_handler.go:121.2,122.16 2 0
+starter-kit/internal/transport/http/handler/auth_handler.go:122.16,125.3 2 0
+starter-kit/internal/transport/http/handler/auth_handler.go:128.2,136.33 3 0
+starter-kit/internal/transport/http/handler/auth_handler.go:146.46,149.2 1 0
+starter-kit/internal/transport/http/handler/health_handler.go:19.58,25.2 1 1
+starter-kit/internal/transport/http/handler/health_handler.go:34.53,55.2 3 1
+starter-kit/internal/transport/http/handler/health_handler.go:64.46,70.2 1 1
diff --git a/docker-compose.prod.yml b/docker-compose.prod.yml
new file mode 100644
index 0000000..0364810
--- /dev/null
+++ b/docker-compose.prod.yml
@@ -0,0 +1,83 @@
+version: '3.8'
+
+services:
+  # API Service - Production Configuration
+  api:
+    build:
+      context: .
+      dockerfile: Dockerfile
+    container_name: ulflow-api
+    restart: always
+    ports:
+      - "3000:3000"
+    env_file:
+      - .env
+    environment:
+      - APP_ENV=production
+    depends_on:
+      - postgres
+    networks:
+      - ulflow-network
+    deploy:
+      resources:
+        limits:
+          cpus: '1'
+          memory: 1G
+      restart_policy:
+        condition: on-failure
+        max_attempts: 3
+    healthcheck:
+      test: ["CMD", "wget", "--spider", "-q", "http://localhost:3000/health"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+      start_period: 40s
+
+  # PostgreSQL Database - Production Configuration
+  postgres:
+    image: postgres:15-alpine
+    container_name: ulflow-postgres
+    restart: always
+    environment:
+      POSTGRES_USER: ${DB_USER:-user}
+      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
+      POSTGRES_DB: ${DB_NAME:-ulflow_db}
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    networks:
+      - ulflow-network
+    deploy:
+      resources:
+        limits:
+          cpus: '1'
+          memory: 1G
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${DB_USER:-user} -d ${DB_NAME:-ulflow_db}"]
+      interval: 30s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+
+  # Nginx Reverse Proxy
+  nginx:
+    image: nginx:alpine
+    container_name: ulflow-nginx
+    restart: always
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx/conf.d:/etc/nginx/conf.d
+      - ./nginx/ssl:/etc/nginx/ssl
+      - ./nginx/logs:/var/log/nginx
+    depends_on:
+      - api
+    networks:
+      - ulflow-network
+
+volumes:
+  postgres-data:
+
+networks:
+  ulflow-network:
+    driver: bridge
diff --git a/docker-compose.yml b/docker-compose.yml
new file mode 100644
index 0000000..5fd9abe
--- /dev/null
+++ b/docker-compose.yml
@@ -0,0 +1,85 @@
+version: '3.8'
+
+services:
+  # API Service
+  api:
+    build:
+      context: .
+      dockerfile: Dockerfile.local
+    container_name: ulflow-api
+    restart: unless-stopped
+    ports:
+      - "3000:3000"
+    volumes:
+      - .:/app
+      - go-modules:/go/pkg/mod
+    env_file:
+      - .env
+    depends_on:
+      - postgres
+    networks:
+      - ulflow-network
+
+  # PostgreSQL Database
+  postgres:
+    image: postgres:15-alpine
+    container_name: ulflow-postgres
+    restart: unless-stopped
+    environment:
+      POSTGRES_USER: ${DB_USER:-user}
+      POSTGRES_PASSWORD: ${DB_PASSWORD:-password}
+      POSTGRES_DB: ${DB_NAME:-ulflow_db}
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    networks:
+      - ulflow-network
+
+  # Gitea (Git Server, CI/CD, Registry)
+  gitea:
+    image: gitea/gitea:1.21
+    container_name: ulflow-gitea
+    restart: unless-stopped
+    environment:
+      - USER_UID=1000
+      - USER_GID=1000
+      - GITEA__database__DB_TYPE=postgres
+      - GITEA__database__HOST=postgres:5432
+      - GITEA__database__NAME=gitea
+      - GITEA__database__USER=${DB_USER:-user}
+      - GITEA__database__PASSWD=${DB_PASSWORD:-password}
+    ports:
+      - "3000:3000"
+      - "2222:22"
+    volumes:
+      - gitea-data:/data
+      - /etc/timezone:/etc/timezone:ro
+      - /etc/localtime:/etc/localtime:ro
+    depends_on:
+      - postgres
+    networks:
+      - ulflow-network
+
+  # Gitea Runner for CI/CD
+  gitea-runner:
+    image: gitea/act_runner:latest
+    container_name: ulflow-gitea-runner
+    restart: unless-stopped
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+      - gitea-runner-data:/data
+    depends_on:
+      - gitea
+    networks:
+      - ulflow-network
+
+volumes:
+  postgres-data:
+  gitea-data:
+  gitea-runner-data:
+  go-modules:
+
+networks:
+  ulflow-network:
+    driver: bridge
diff --git a/docs/.obsidian/app.json b/docs/.obsidian/app.json
new file mode 100644
index 0000000..9e26dfe
--- /dev/null
+++ b/docs/.obsidian/app.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/docs/.obsidian/appearance.json b/docs/.obsidian/appearance.json
new file mode 100644
index 0000000..9e26dfe
--- /dev/null
+++ b/docs/.obsidian/appearance.json
@@ -0,0 +1 @@
+{}
\ No newline at end of file
diff --git a/docs/.obsidian/core-plugins.json b/docs/.obsidian/core-plugins.json
new file mode 100644
index 0000000..b977c25
--- /dev/null
+++ b/docs/.obsidian/core-plugins.json
@@ -0,0 +1,31 @@
+{
+  "file-explorer": true,
+  "global-search": true,
+  "switcher": true,
+  "graph": true,
+  "backlink": true,
+  "canvas": true,
+  "outgoing-link": true,
+  "tag-pane": true,
+  "properties": false,
+  "page-preview": true,
+  "daily-notes": true,
+  "templates": true,
+  "note-composer": true,
+  "command-palette": true,
+  "slash-command": false,
+  "editor-status": true,
+  "bookmarks": true,
+  "markdown-importer": false,
+  "zk-prefixer": false,
+  "random-note": false,
+  "outline": true,
+  "word-count": true,
+  "slides": false,
+  "audio-recorder": false,
+  "workspaces": false,
+  "file-recovery": true,
+  "publish": false,
+  "sync": true,
+  "webviewer": false
+}
\ No newline at end of file
diff --git a/docs/.obsidian/workspace.json b/docs/.obsidian/workspace.json
new file mode 100644
index 0000000..4514398
--- /dev/null
+++ b/docs/.obsidian/workspace.json
@@ -0,0 +1,184 @@
+{
+  "main": {
+    "id": "261ce7313e6dd2d1",
+    "type": "split",
+    "children": [
+      {
+        "id": "8cfa998b40f0304e",
+        "type": "tabs",
+        "children": [
+          {
+            "id": "6d1019fb7e553425",
+            "type": "leaf",
+            "state": {
+              "type": "markdown",
+              "state": {
+                "file": "adapter.md",
+                "mode": "source",
+                "source": false
+              },
+              "icon": "lucide-file",
+              "title": "adapter"
+            }
+          }
+        ]
+      }
+    ],
+    "direction": "vertical"
+  },
+  "left": {
+    "id": "f87c78d3a5a321a8",
+    "type": "split",
+    "children": [
+      {
+        "id": "015ce6e570ac0c70",
+        "type": "tabs",
+        "children": [
+          {
+            "id": "6172be51a41d7dc9",
+            "type": "leaf",
+            "state": {
+              "type": "file-explorer",
+              "state": {
+                "sortOrder": "alphabetical",
+                "autoReveal": false
+              },
+              "icon": "lucide-folder-closed",
+              "title": "Trình duyệt tệp"
+            }
+          },
+          {
+            "id": "0564e6c5e875c5e5",
+            "type": "leaf",
+            "state": {
+              "type": "search",
+              "state": {
+                "query": "",
+                "matchingCase": false,
+                "explainSearch": false,
+                "collapseAll": false,
+                "extraContext": false,
+                "sortOrder": "alphabetical"
+              },
+              "icon": "lucide-search",
+              "title": "Tìm kiếm"
+            }
+          },
+          {
+            "id": "d2af93c860305d9b",
+            "type": "leaf",
+            "state": {
+              "type": "bookmarks",
+              "state": {},
+              "icon": "lucide-bookmark",
+              "title": "Đánh dấu"
+            }
+          }
+        ]
+      }
+    ],
+    "direction": "horizontal",
+    "width": 300
+  },
+  "right": {
+    "id": "f08c8c30bdb753d9",
+    "type": "split",
+    "children": [
+      {
+        "id": "a243e45a9db5439d",
+        "type": "tabs",
+        "children": [
+          {
+            "id": "3edc5198b4139609",
+            "type": "leaf",
+            "state": {
+              "type": "backlink",
+              "state": {
+                "file": "general.md",
+                "collapseAll": false,
+                "extraContext": false,
+                "sortOrder": "alphabetical",
+                "showSearch": false,
+                "searchQuery": "",
+                "backlinkCollapsed": false,
+                "unlinkedCollapsed": true
+              },
+              "icon": "links-coming-in",
+              "title": "Liên kết đến của general"
+            }
+          },
+          {
+            "id": "bd56178c8119e62e",
+            "type": "leaf",
+            "state": {
+              "type": "outgoing-link",
+              "state": {
+                "file": "general.md",
+                "linksCollapsed": false,
+                "unlinkedCollapsed": true
+              },
+              "icon": "links-going-out",
+              "title": "Liên kết đi ra từ general"
+            }
+          },
+          {
+            "id": "bc29a86f17a39689",
+            "type": "leaf",
+            "state": {
+              "type": "tag",
+              "state": {
+                "sortOrder": "frequency",
+                "useHierarchy": true,
+                "showSearch": false,
+                "searchQuery": ""
+              },
+              "icon": "lucide-tags",
+              "title": "Tags"
+            }
+          },
+          {
+            "id": "8b998447c8dac66b",
+            "type": "leaf",
+            "state": {
+              "type": "outline",
+              "state": {
+                "file": "general.md",
+                "followCursor": false,
+                "showSearch": false,
+                "searchQuery": ""
+              },
+              "icon": "lucide-list",
+              "title": "Đề cương của general"
+            }
+          }
+        ]
+      }
+    ],
+    "direction": "horizontal",
+    "width": 300,
+    "collapsed": true
+  },
+  "left-ribbon": {
+    "hiddenItems": {
+      "switcher:Mở bộ chuyển đổi nhanh": false,
+      "graph:Mở xem biểu đồ": false,
+      "canvas:Tạo bảng mới": false,
+      "daily-notes:Mở ghi chú hôm nay": false,
+      "templates:Chèn mẫu": false,
+      "command-palette:Mở khay lệnh": false
+    }
+  },
+  "active": "6d1019fb7e553425",
+  "lastOpenFiles": [
+    "workflow.md",
+    "ux.md",
+    "testing.md",
+    "spec.md",
+    "secrets.md",
+    "roadmap.md",
+    "general.md",
+    "adapter.md",
+    "architecture.md",
+    "changelog.md"
+  ]
+}
\ No newline at end of file
diff --git a/docs/AUTHENTICATION.md b/docs/AUTHENTICATION.md
new file mode 100644
index 0000000..1b0ddd7
--- /dev/null
+++ b/docs/AUTHENTICATION.md
@@ -0,0 +1,209 @@
+# Hệ thống Xác thực và Phân quyền
+
+## Mục lục
+1. [Tổng quan](#tổng-quan)
+2. [Luồng xử lý](#luồng-xử-lý)
+   - [Đăng nhập](#đăng-nhập)
+   - [Làm mới token](#làm-mới-token)
+   - [Đăng xuất](#đăng-xuất)
+3. [Các thành phần chính](#các-thành-phần-chính)
+   - [Auth Middleware](#auth-middleware)
+   - [Token Service](#token-service)
+   - [Session Management](#session-management)
+4. [Bảo mật](#bảo-mật)
+5. [Tích hợp](#tích-hợp)
+
+## Tổng quan
+
+Hệ thống xác thực sử dụng JWT (JSON Web Tokens) với cơ chế refresh token để đảm bảo bảo mật. Mỗi phiên đăng nhập sẽ có:
+- Access Token: Có thời hạn ngắn (15-30 phút)
+- Refresh Token: Có thời hạn dài hơn (7-30 ngày)
+- Session ID: Định danh duy nhất cho mỗi phiên
+
+## Luồng xử lý
+
+### Đăng nhập
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant AuthController
+    participant AuthService
+    participant TokenService
+    participant SessionStore
+
+    Client->>AuthController: POST /api/v1/auth/login
+    AuthController->>AuthService: Authenticate(credentials)
+    AuthService->>UserRepository: FindByEmail(email)
+    AuthService->>PasswordUtil: CompareHashAndPassword()
+    AuthService->>TokenService: GenerateTokens(userID, sessionID)
+    TokenService-->>AuthService: tokens
+    AuthService->>SessionStore: Create(session)
+    AuthService-->>AuthController: authResponse
+    AuthController-->>Client: {accessToken, refreshToken, user}
+```
+
+### Làm mới Token
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant AuthController
+    participant TokenService
+    participant SessionStore
+
+    Client->>AuthController: POST /api/v1/auth/refresh
+    AuthController->>TokenService: RefreshToken(refreshToken)
+    TokenService->>SessionStore: Get(sessionID)
+    SessionStore-->>TokenService: session
+    TokenService->>TokenService: ValidateRefreshToken()
+    TokenService->>SessionStore: UpdateLastUsed()
+    TokenService-->>AuthController: newTokens
+    AuthController-->>Client: {accessToken, refreshToken}
+```
+
+### Đăng xuất
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant AuthController
+    participant TokenService
+    participant SessionStore
+
+    Client->>AuthController: POST /api/v1/auth/logout
+    AuthController->>TokenService: ExtractTokenMetadata()
+    TokenService-->>AuthController: tokenClaims
+    AuthController->>SessionStore: Delete(sessionID)
+    AuthController-->>Client: 200 OK
+```
+
+## Các thành phần chính
+
+### Auth Middleware
+
+#### `Authenticate()`
+- **Mục đích**: Xác thực access token trong header Authorization
+- **Luồng xử lý**:
+  1. Lấy token từ header
+  2. Xác thực token
+  3. Kiểm tra session trong store
+  4. Lưu thông tin user vào context
+
+#### `RequireRole(roles ...string)`
+- **Mục đích**: Kiểm tra quyền truy cập dựa trên vai trò
+- **Luồng xử lý**:
+  1. Lấy thông tin user từ context
+  2. Kiểm tra user có vai trò phù hợp không
+  3. Trả về lỗi nếu không có quyền
+
+### Token Service
+
+#### `GenerateTokens(userID, sessionID)`
+- Tạo access token và refresh token
+- Lưu thông tin session
+- Trả về cặp token
+
+#### `ValidateToken(token)`
+- Xác thực chữ ký token
+- Kiểm tra thời hạn
+- Trả về claims nếu hợp lệ
+
+### Session Management
+
+#### `CreateSession(session)`
+- Tạo session mới
+- Lưu vào Redis với TTL
+- Trả về session ID
+
+#### `GetSession(sessionID)`
+- Lấy thông tin session từ Redis
+- Cập nhật thời gian truy cập cuối
+- Trả về session nếu tồn tại
+
+## Bảo mật
+
+1. **Token Storage**
+   - Access Token: Lưu trong memory (không lưu localStorage)
+   - Refresh Token: HttpOnly, Secure, SameSite=Strict cookie
+
+2. **Token Rotation**
+   - Mỗi lần refresh sẽ tạo cặp token mới
+   - Vô hiệu hóa refresh token cũ
+
+3. **Thu hồi token**
+   - Đăng xuất sẽ xóa session
+   - Có thể thu hồi tất cả session của user
+
+## Tích hợp
+
+### Frontend
+
+1. **Xử lý token**
+```javascript
+// Lưu token vào memory
+let accessToken = null;
+
+// Hàm gọi API với token
+export const api = axios.create({
+  baseURL: '/api/v1',
+  headers: {
+    'Content-Type': 'application/json',
+  },
+});
+
+// Thêm interceptor để gắn token
+api.interceptors.request.use(config => {
+  if (accessToken) {
+    config.headers.Authorization = `Bearer ${accessToken}`;
+  }
+  return config;
+});
+
+// Xử lý lỗi 401
+export function setupResponseInterceptor(logout) {
+  api.interceptors.response.use(
+    response => response,
+    async error => {
+      const originalRequest = error.config;
+      
+      if (error.response.status === 401 && !originalRequest._retry) {
+        originalRequest._retry = true;
+        try {
+          const { accessToken: newToken } = await refreshToken();
+          accessToken = newToken;
+          originalRequest.headers.Authorization = `Bearer ${newToken}`;
+          return api(originalRequest);
+        } catch (error) {
+          logout();
+          return Promise.reject(error);
+        }
+      }
+      return Promise.reject(error);
+    }
+  );
+}
+```
+
+### Backend
+
+1. **Cấu hình**
+```yaml
+auth:
+  access_token_expiry: 15m
+  refresh_token_expiry: 7d
+  jwt_secret: your-secret-key
+  refresh_secret: your-refresh-secret
+```
+
+2. **Sử dụng middleware**
+```go
+// Áp dụng auth middleware
+router.Use(authMiddleware.Authenticate())
+
+// Route yêu cầu đăng nhập
+router.GET("/profile", userHandler.GetProfile)
+
+// Route yêu cầu quyền admin
+router.GET("/admin", authMiddleware.RequireRole("admin"), adminHandler.Dashboard)
+```
diff --git a/docs/adapter.md b/docs/adapter.md
new file mode 100644
index 0000000..1d8615a
--- /dev/null
+++ b/docs/adapter.md
@@ -0,0 +1,149 @@
+# Adapter Layer
+
+## Tổng quan
+Adapter là lớp giao tiếp giữa ứng dụng và các hệ thống bên ngoài. Layer này cung cấp khả năng tích hợp với bên thứ ba và sự độc lập của core business logic.
+
+## Nguyên tắc thiết kế
+- Tách biệt domain logic với chi tiết triển khai bên ngoài
+- Dễ dàng thay thế các implementation mà không ảnh hưởng tới business logic
+- Dependency inversion - core logic không phụ thuộc vào chi tiết triển khai
+- Interface-driven design cho các external services
+
+## Cấu trúc thư mục
+```
+internal/adapter/
+  │── persistence/       # Database adapters
+  │   │── postgres/      # PostgreSQL implementation
+  │   │── mysql/         # MySQL implementation (optional)
+  │   └── sqlite/        # SQLite implementation (optional)
+  │── messaging/        # Messaging system adapters
+  │── storage/          # File storage adapters
+  │── externalapi/      # Third-party service adapters
+  │── notification/     # Notification service adapters
+  └── cache/            # Cache adapters
+```
+
+## Database Adapter
+
+Adapter database được triển khai với tính năng:
+
+- Kết nối tự động với PostgreSQL
+- Cấu hình connection pool
+- Xử lý migration tự động
+- Triển khai repository pattern
+
+### Cấu hình
+
+Cấu hình database được định nghĩa trong file `configs/config.yaml`:
+
+```yaml
+database:
+  driver: "postgres"
+  host: "localhost" 
+  port: 5432
+  username: "postgres"
+  password: "postgres"
+  database: "ulflow"
+  ssl_mode: "disable"
+  max_open_conns: 25
+  max_idle_conns: 5
+  conn_max_lifetime: 300
+  migration_path: "migrations"
+```
+
+## Triển khai adapter
+
+### 1. Định nghĩa interface
+```go
+// pkg/adapter/payment/interface.go
+package payment
+
+type PaymentProvider interface {
+    ProcessPayment(amount float64, currency string, metadata map[string]string) (string, error)
+    RefundPayment(paymentId string, amount float64) error
+    GetPaymentStatus(paymentId string) (string, error)
+}
+```
+
+### 2. Triển khai cụ thể
+```go
+// pkg/adapter/payment/stripe/stripe.go
+package stripe
+
+import "github.com/your-project/pkg/adapter/payment"
+
+type StripeAdapter struct {
+    apiKey string
+    client *stripe.Client
+}
+
+func NewStripeAdapter(apiKey string) *StripeAdapter {
+    return &StripeAdapter{
+        apiKey: apiKey,
+        client: stripe.NewClient(apiKey),
+    }
+}
+
+func (s *StripeAdapter) ProcessPayment(amount float64, currency string, metadata map[string]string) (string, error) {
+    // Triển khai với Stripe API
+}
+
+// Triển khai các phương thức khác...
+```
+
+### 3. Sử dụng mock để test
+```go
+// pkg/adapter/payment/mock/mock.go
+package mock
+
+import "github.com/your-project/pkg/adapter/payment"
+
+type MockPaymentAdapter struct {
+    // Fields to store test data
+}
+
+func (m *MockPaymentAdapter) ProcessPayment(amount float64, currency string, metadata map[string]string) (string, error) {
+    // Mock implementation for testing
+}
+
+// Triển khai các phương thức khác...
+```
+
+## Dependency Injection
+
+Sử dụng dependency injection để đưa adapter vào business logic:
+
+```go
+// pkg/transaction/order/service.go
+package order
+
+type OrderService struct {
+    paymentProvider payment.PaymentProvider
+    // Other dependencies...
+}
+
+func NewOrderService(paymentProvider payment.PaymentProvider) *OrderService {
+    return &OrderService{
+        paymentProvider: paymentProvider,
+    }
+}
+
+func (s *OrderService) PlaceOrder(order *resource.Order) error {
+    // Sử dụng payment provider thông qua interface
+    paymentId, err := s.paymentProvider.ProcessPayment(
+        order.TotalAmount, 
+        order.Currency,
+        map[string]string{"orderId": order.ID},
+    )
+    // Xử lý kết quả...
+}
+```
+
+## Best Practices
+
+1. **Mỗi adapter chỉ giao tiếp với một dịch vụ bên ngoài**
+2. **Xử lý lỗi phù hợp và mapping sang domain errors**
+3. **Cung cấp logging và metrics cho mỗi adapter**
+4. **Retry mechanisms cho các dịch vụ không ổn định**
+5. **Circuit breaking để tránh cascading failures**
+6. **Feature toggles để dễ dàng chuyển đổi giữa các provider**
diff --git a/docs/architecture.md b/docs/architecture.md
new file mode 100644
index 0000000..1311318
--- /dev/null
+++ b/docs/architecture.md
@@ -0,0 +1,234 @@
+# Kiến trúc hệ thống
+
+## Project Overview
+- Đây là dự án tạo ra Starter Kit Golang Backend cho Team ULFlow để có thể khởi tạo các dự án trong thời gian ngắn, nhanh chóng mà vẫn đảm bảo các yếu tố cơ bản
+- Sử dụng Mô hình DDD (Domain Driven Development) - Customize
+	- `Resource`: Các Aggregate DDD
+	- `Transaction`: Các Saga điều phối luồng nghiệp vụ phức tạp
+	- `Adapter`: Xử lý giao tiếp với các hệ thống bên ngoài
+	- `Helper`: Các thư viện, tiện ích dùng chung
+	- `Transport`: Lớp giao diện người dùng
+- Thành phần kiến trúc chi tiết (U-Hierarchy)
+	- `ubit`: Đơn vị logic nhỏ nhất (hàm, type, hằng số)
+	- `ubrick`: Tập hợp các `ubit` liên quan
+	- `ublock`: Thành phần hoạt động độc lập tương đối
+	- `ubundle`: Tính năng hoàn chỉnh cho người dùng
+
+## Nguyên tắc thiết kế
+- **User-Centric**: Ưu tiên trải nghiệm người dùng, giảm thiểu sự phức tạp
+- **Data-Oriented Programming (DOP)**: Thiết kế xoay quanh luồng dữ liệu và các biến đổi dữ liệu
+- **Domain-Driven Design (DDD)**: Áp dụng các khái niệm cốt lõi (Bounded Context, Aggregates, Domain Events)
+
+## Áp dụng DDD trong Dự án
+
+### Resource
+- Tuân theo nguyên tắc Aggregate trong DDD
+- Mỗi Resource đại diện cho một thực thể nghiệp vụ
+- Bao gồm các thuộc tính và hành vi liên quan
+- Đảm bảo tính nhất quán và logic nghiệp vụ
+
+### Transaction
+- Triển khai mẫu Saga để điều phối các hoạt động phức tạp
+- Đảm bảo tính toàn vẹn dữ liệu xuyên suốt các Resource
+- Xử lý các trường hợp lỗi và rollback khi cần thiết
+
+### Adapter
+- Cung cấp giao diện giao tiếp với hệ thống bên ngoài
+- Triển khai mẫu Adapter để đảm bảo tính linh hoạt
+- Dễ dàng thay thế các thành phần khi cần thiết
+
+### Helper
+- Cung cấp các tiện ích dùng chung
+- Triển khai các công cụ hỗ trợ phát triển
+- Tối ưu hóa mã lệnh và tăng khả năng tái sử dụng
+
+### UIUX
+- Lớp giao diện người dùng (API, Web Interface)
+- Triển khai theo nguyên tắc thiết kế hướng người dùng
+- Tách biệt với logic nghiệp vụ
+
+## U-Hierarchy
+
+Hệ thống phân cấp U là một cách tiếp cận duy nhất cho tổ chức mã:
+
+### ubit
+- Đơn vị nhỏ nhất của mã
+- Ví dụ: một hàm, một constant, một type
+- Mục đích đơn lẻ, dễ test
+
+### ubrick
+- Tập hợp các ubit liên quan đến nhau
+- Cung cấp một chức năng cụ thể
+- Ví dụ: một package nhỏ, một nhóm hàm liên quan
+
+### ublock
+- Thành phần có thể hoạt động độc lập
+- Bao gồm nhiều ubrick làm việc cùng nhau
+- Ví dụ: một module hoặc service
+
+### ubundle
+- Một tính năng hoàn chỉnh cho người dùng
+- Kết hợp nhiều ublock để tạo ra trải nghiệm người dùng
+- Ví dụ: một tính năng end-to-end
+
+### Directory Structure
+
+starter-kit/
+├── .gitea/
+│   ├── workflows/
+│   │    ├── ci.yml
+│   │    └── docker.yml
+│   ├── .hooks/
+│   │   ├──pre-commit
+│   │   └──prepare-commit-msg
+│   └── commit-template.txt
+├── cmd/
+│   └── app/                    # Hoặc 'server/', 'api/' - Entrypoint chính của ứng dụng
+│       └── main.go
+├── internal/
+│   ├── resource/           # Lớp chứa các Aggregates/Entities (DDD)
+│   │   └── example/        # Một module ví dụ rất cơ bản
+│   │       ├── example_aggregate.go
+│   │       ├── example_types.go
+│   │       └── example_repository_interface.go # Interface cho repository
+│   └── transaction/        # Lớp chứa các Use Cases/Application Services/Sagas (DDD)
+│   │   └── example/        # Một module ví dụ rất cơ bản
+│   │       └── example_transaction.go
+│   ├── adapter/                # Lớp giao tiếp với các hệ thống bên ngoài hoặc hạ tầng
+│   │   ├── persistence/        # Hoặc 'repository/', 'storage/' - Triển khai repositories
+│   │   │   └── postgres/       # Ví dụ với PostgreSQL
+│   │   │       ├── connection.go # Thiết lập kết nối DB
+│   │   │       ├── example_postgres_repository.go # Triển khai repository cho example_aggregate
+│   │   │       └── models.go     # (Tùy chọn) GORM models hoặc struct cho DB mapping
+│   │   |
+│   │   └── externalapi/        # Giao tiếp với các dịch vụ bên ngoài
+│   │       └── # example_service_client.go
+│   ├── helper/                 # Các thư viện, tiện ích dùng chung, không có business logic
+│   │   ├── config/             # Load cấu hình (ví dụ: Gin)
+│   │   │   └── load.go
+│   │   ├── logger/             # Thiết lập logger (ví dụ: Logrus)
+│   │   │   └── log.go
+│   │   ├── validation/         # Tiện ích validation chung
+│   │   │   └── common.go
+│   │   ├── security/           # Tiện ích bảo mật (JWT, hashing)
+│   │   │   ├── jwt_helper.go
+│   │   │   └── password_helper.go
+│   │   └── # ... (ví dụ: datetime, string_utils)
+│   └── transport/              # Lớp giao tiếp với thế giới bên ngoài (ví dụ: HTTP)
+│       └── http/               # Cụ thể cho HTTP transport
+│           ├── handler/        # HTTP request handlers
+│           │   ├── example_handler.go
+│           │   ├── health_handler.go # Endpoint kiểm tra sức khỏe ứng dụng
+│           │   └── middleware/     # HTTP middlewares (auth, logging, cors, recovery)
+│           │       ├── auth_middleware.go
+│           │       ├── request_logger_middleware.go
+│           │       └── error_handling_middleware.go
+│           ├── router.go       # Định nghĩa các routes (ví dụ: sử dụng Gin, Chi)
+│           └── dto/            # Data Transfer Objects cho request/response
+│               ├── example_dto.go
+│               └── common_dto.go
+├── docs/                       # Tài liệu của starter-kit
+├── templates/                  # Chứa các file cấu hình mẫu
+│   ├── config.example.yaml     # Đổi tên để rõ là file mẫu
+│   └── .env.example            # Các biến môi trường mẫu
+├── migrations/                 # Chứa các file SQL migration
+│   └── 000001_init_schema.example.sql # Migration mẫu
+├── api/                        # (Tùy chọn) Định nghĩa API (ví dụ: OpenAPI/Swagger specs)
+│   └── openapi.yaml
+├── scripts/                    # Các shell script tiện ích (nếu Makefile không đủ)
+│   ├── # setup_env.sh
+│   └── # run_checks.sh
+├── Makefile                    # Các lệnh tiện ích (build, test, lint, run, docker, ...)
+├── go.mod                      # Tên module nên là tên của starter-kit,
+├── .gitignore
+└── README.md                   # Hướng dẫn nhanh và tổng quan về starter-kit
+
+### Checklist cơ bản của vòng đời App
+
+I. Thiết lập Cơ bản và Cấu trúc (Basic Setup & Structure)
+
+[ ] Tách biệt Logic Khởi tạo:
+Yêu cầu: main.go chỉ chứa hàm main() và các lệnh gọi ở mức cao nhất. Logic chi tiết cho việc khởi tạo từng thành phần (config, logger, server, DB) phải nằm trong các package/hàm riêng biệt (ví dụ: internal/common/config, internal/common/logger, internal/transport/http/server, internal/infrastructure/db).
+Mục đích: Giữ main.go ngắn gọn, dễ đọc, dễ hiểu vai trò điều phối của nó.
+[ ] Hàm main() rõ ràng:
+Yêu cầu: Hàm main() nên thực hiện các bước khởi tạo một cách tuần tự, logic.
+Mục đích: Dễ dàng theo dõi luồng khởi động của ứng dụng.
+[ ] Xử lý lỗi khởi tạo nghiêm trọng:
+Yêu cầu: Nếu một bước khởi tạo thiết yếu (ví dụ: load config, kết nối DB) thất bại, ứng dụng nên log lỗi rõ ràng và thoát (ví dụ: log.Fatalf hoặc logger.Fatal).
+Mục đích: Tránh việc ứng dụng chạy trong trạng thái không ổn định hoặc không đầy đủ.
+II. Quản lý Cấu hình (Configuration Management)
+
+[ ] Load Cấu hình:
+Yêu cầu: Gọi một hàm/package chuyên biệt để đọc cấu hình từ các nguồn (file YAML/JSON/.env, biến môi trường).
+Ví dụ: cfg, err := config.Load("configs/", ".env.example")
+Mục đích: Tập trung logic load config, dễ dàng thay đổi nguồn hoặc định dạng config.
+[ ] Validate Cấu hình Cơ bản (Đề xuất):
+Yêu cầu (Đề xuất): Sau khi load, có một bước kiểm tra sơ bộ các giá trị cấu hình thiết yếu (ví dụ: port server có hợp lệ, thông tin kết nối DB có đủ).
+Mục đích: Phát hiện lỗi cấu hình sớm.
+III. Logging
+
+[ ] Structured Logging với Logrus:
+- Sử dụng Logrus cho structured logging với JSON format
+- Hỗ trợ các log level: debug, info, warn, error
+- Tích hợp request ID tracking cho HTTP requests
+- Cấu hình logging được quản lý tập trung trong section `logger`
+
+[ ] Middleware Logging:
+- Tự động log các HTTP request với thông tin chi tiết:
+  - Request ID
+  - Method
+  - Path
+  - Status code
+  - Latency
+  - Client IP
+  - User agent
+
+[ ] Error Handling và Context:
+- Tích hợp error context vào logs
+- Structured fields cho phép phân tích và tìm kiếm hiệu quả
+- Theo dõi chuỗi lỗi với error wrapping
+IV. Khởi tạo Dependencies Cơ sở hạ tầng (Infrastructure Dependencies)
+
+[ ] Khởi tạo Kết nối Database (nếu starter kit có sẵn):
+Yêu cầu: Gọi một hàm/package để thiết lập kết nối tới DB (ví dụ: PostgreSQL) và quản lý connection pool.
+Ví dụ: dbConn, err := database.New(cfg.DBConfig, appLogger)
+Mục đích: Chuẩn bị sẵn sàng cho việc tương tác với DB.
+[ ] Đóng Kết nối Database khi Shutdown:
+Yêu cầu: Đảm bảo kết nối DB được đóng một cách an toàn khi ứng dụng tắt (sử dụng defer hoặc trong quá trình graceful shutdown).
+Mục đích: Tránh rò rỉ tài nguyên.
+V. Thiết lập Server (ví dụ: HTTP Server)
+
+[ ] Khởi tạo Router (từ package riêng):
+Yêu cầu: Logic định nghĩa routes và gắn handlers phải nằm trong một package riêng (ví dụ: internal/transport/http/router). main.go chỉ khởi tạo nó.
+Ví dụ: httpRouter := router.New(appLogger /*, dbConn, otherServices */)
+Mục đích: Tách biệt rõ ràng logic routing và business.
+[ ] Khởi tạo HTTP Server:
+Yêu cầu: Tạo instance http.Server với các cấu hình cơ bản (địa chỉ, port, handler là router đã khởi tạo, có thể cả timeouts cơ bản).
+[ ] Đăng ký Middleware Phi tính năng Cơ bản (thường trong package router hoặc server setup):
+Yêu cầu: Đảm bảo các middleware thiết yếu như request logging, panic recovery, CORS (nếu cần) được áp dụng.
+Mục đích: Tăng cường độ tin cậy và khả năng giám sát cho API.
+[ ] Đăng ký Health Check Endpoint (trong router):
+Yêu cầu: Cung cấp một endpoint (/healthz, /status) để kiểm tra tình trạng hoạt động của ứng dụng.
+Mục đích: Hỗ trợ giám sát và tự động hóa vận hành.
+VI. Quản lý Vòng đời Ứng dụng (Application Lifecycle Management)
+
+[ ] Chạy Server trong Goroutine riêng:
+Yêu cầu: httpServer.ListenAndServe() (hoặc tương tự) được chạy trong một goroutine để không block hàm main().
+[ ] Xử lý Graceful Shutdown:
+Yêu cầu: Lắng nghe các tín hiệu OS (SIGINT, SIGTERM) để thực hiện shutdown một cách an toàn.
+Bao gồm:
+Tạo channel để nhận tín hiệu: quit := make(chan os.Signal, 1)
+Đăng ký tín hiệu: signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+Block cho đến khi nhận tín hiệu: <-quit
+Gọi httpServer.Shutdown(ctx) với một context có timeout.
+Log các bước shutdown.
+Mục đích: Đảm bảo ứng dụng hoàn thành các request đang xử lý, đóng kết nối an toàn, tránh mất dữ liệu.
+
+[ ] Xử lý Error và Log:
+Yêu cầu: Tất cả các error từ các thành phần (DB, HTTP, middleware) nên được log rõ ràng, bao gồm thông tin context (ví dụ: request ID, method, URL).
+Mục đích: Hỗ trợ debug và giám sát vấn đề khi xảy ra.
+VII. Quản lý tài nguyên (Resource Management)
+
+[ ] Đóng tài nguyên khi không cần thiết:
+Yêu cầu: Đảm bảo tất cả các tài nguyên (connection, file, mutex, channel) được đóng hoặc giải phóng khi không còn sử dụng.
+Mục đích: Tránh rò rỉ tài nguyên và đảm bảo hiệu quả sử dụng bộ nhớ.
diff --git a/docs/changelog.md b/docs/changelog.md
new file mode 100644
index 0000000..92b43e5
--- /dev/null
+++ b/docs/changelog.md
@@ -0,0 +1,63 @@
+# Changelog
+
+Tất cả những thay đổi đáng chú ý trong dự án sẽ được ghi lại ở đây.
+
+Định dạng dựa trên [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+và dự án này tuân theo [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- **Logger Improvements**:
+  - Hỗ trợ phân biệt stdout/stderr cho các mức log khác nhau
+  - Tự động thêm thông tin người gọi (caller) vào log
+  - Hỗ trợ nhiều định dạng log (JSON, Text)
+  - Tự động thêm các trường mặc định vào mỗi log entry
+  - Tối ưu hiệu năng với buffer và sync.Pool
+  - Hỗ trợ log rotation thông qua các hooks
+  - Tài liệu chi tiết về cách sử dụng và cấu hình
+  - Thread-safe implementation
+  - Hỗ trợ context và request-scoped fields
+  - Tích hợp với cấu hình ứng dụng
+
+### Changed
+- **Logger Refactor**:
+  - Thay đổi cấu trúc package logger để dễ mở rộng
+  - Cải thiện hiệu suất với ít cấp phát bộ nhớ hơn
+  - Chuẩn hóa định dạng log đầu ra
+  - Cập nhật middleware HTTP để sử dụng logger mới
+
+### Fixed
+- **Logger**:
+  - Sửa lỗi race condition khi khởi tạo logger
+  - Đảm bảo tất cả log đều có đầy đủ context
+  - Cải thiện xử lý lỗi khi cấu hình không hợp lệ
+
+### Changed
+- Thay thế standard log package bằng Logrus trong toàn bộ ứng dụng
+- Di chuyển cấu hình logging từ `app.log_level` sang section `logger` riêng biệt
+- Cập nhật HTTP server để sử dụng structured logging
+- Cải thiện validation cho database config với required_if conditions
+- Nâng cấp cấu hình logger để hỗ trợ nhiều tùy chọn hơn
+- Tối ưu hiệu năng của hệ thống logging
+
+## [0.1.1] - 2025-05-14
+
+### Added
+- Triển khai module config với các chức năng:
+  - Đọc cấu hình từ file YAML
+  - Hỗ trợ biến môi trường
+  - Validation tự động các giá trị cấu hình
+  - Giá trị mặc định cho các tham số
+- Thiết lập cấu trúc thư mục theo mô hình DDD (Domain-Driven Design)
+- Cấu hình CI/CD với Gitea Workflows
+- Cấu hình Docker cho môi trường development và production
+- Tích hợp các Git hooks để đảm bảo chất lượng mã nguồn
+
+## [0.1.0] - 2025-05-12
+
+### Added
+- Khởi tạo repository
+- Tạo roadmap ban đầu
+- Thiết lập kiến trúc hệ thống theo mô hình DDD
+- Định nghĩa U-Hierarchy cho tổ chức mã nguồn
diff --git a/docs/general.md b/docs/general.md
new file mode 100644
index 0000000..09ab5ea
--- /dev/null
+++ b/docs/general.md
@@ -0,0 +1,79 @@
+# Giới thiệu chung
+
+## Tổng quan
+- ULFlow Golang Starter Kit là một khung phát triển backend theo mô hình Domain-Driven Design (DDD)
+- Được thiết kế để tạo ra các ứng dụng có thể bảo trì và mở rộng dễ dàng
+- Mục tiêu: Cung cấp một cấu trúc dự án chuẩn, các thành phần cơ bản và công cụ phát triển hiệu quả
+
+## Nguyên tắc thiết kế
+
+- **User-Centric**: Ưu tiên trải nghiệm người dùng, giảm thiểu sự phức tạp
+- **Data-Oriented Programming (DOP)**: Thiết kế xoay quanh luồng dữ liệu và các biến đổi dữ liệu 
+- **Domain-Driven Design (DDD)**: Áp dụng các khái niệm cốt lõi (Bounded Context, Aggregates, Domain Events)
+
+## Tầm nhìn
+- Tạo ra nền tảng phát triển linh hoạt, dễ mở rộng cho các dự án backend Golang
+- Tích hợp các công nghệ hiện đại, best practices, và quy trình phát triển chuẩn
+- Cung cấp môi trường phát triển thống nhất cho team
+
+## Hướng dẫn cài đặt
+
+### Yêu cầu hệ thống
+- Go 1.23
+- Docker và Docker Compose
+- Git
+
+### Cài đặt
+1. Clone repository
+```bash
+git clone [repo-url] my-project
+cd my-project
+```
+
+2. Thiết lập môi trường
+```bash
+cp .env.example .env
+# Chỉnh sửa file .env theo nhu cầu
+```
+
+3. Khởi động dev server
+```bash
+make dev
+```
+
+## Cấu trúc thư mục
+
+Dự án được tổ chức theo cấu trúc DDD chuẩn, với các thành phần chính:
+
+```
+│── .gitea/             # Gitea workflows & hooks
+│── cmd/                # Điểm vào của ứng dụng
+│   └── app/            # Main application
+│── internal/           # Mã nguồn chính của ứng dụng
+│   │── domain/         # Các đối tượng nghiệp vụ cốt lõi
+│   │   │── resource/    # Resource (Aggregates/Entities)
+│   │   └── transaction/ # Transaction (Use Cases)
+│   │── adapter/        # Giao tiếp với bên ngoài
+│   │   │── persistence/  # Repository implementations
+│   │   └── externalapi/  # External API clients
+│   │── helper/         # Tiện ích chung
+│   │   │── config/       # Configuration
+│   │   │── logger/       # Logging
+│   │   │── security/     # Authentication/Authorization
+│   │   └── validation/   # Input validation
+│   └── transport/      # Giao tiếp với client
+│       └── http/         # HTTP handlers & middleware
+│── docs/               # Tài liệu
+│── templates/          # Các file mẫu
+│── configs/            # File cấu hình
+│── migrations/         # Database migrations
+│── api/                # API definitions (OpenAPI/Swagger)
+│── scripts/            # Các tiện ích
+│── test/               # End-to-end tests
+└── tools/              # Development tools
+
+## Hỗ trợ và đóng góp
+
+- Báo lỗi và feature request: Tạo issue trên repository
+- Đóng góp: Tạo pull request theo quy trình được mô tả trong workflow.md
+- Liên hệ: [email/contact-info]
diff --git a/docs/review.md b/docs/review.md
new file mode 100644
index 0000000..b373e55
--- /dev/null
+++ b/docs/review.md
@@ -0,0 +1,80 @@
+🚀 Cải Thiện Luồng Xác Thực Cho Project Starter-Kit
+Một Starter-kit chất lượng cần có hệ thống xác thực được xây dựng trên các nguyên tắc bảo mật và thực hành tốt nhất. Dưới đây là những cải thiện quan trọng:
+
+1. Bảo Mật Refresh Token (RT) Phía Client – Ưu Tiên Hàng Đầu
+Vấn đề cốt lõi: Lưu RT trong localStorage hoặc sessionStorage khiến chúng dễ bị tấn công XSS.
+
+Giải pháp cho Starter-kit:
+
+Sử dụng HttpOnly Cookies cho Refresh Token:
+
+Bắt buộc: Starter-kit NÊN mặc định hoặc hướng dẫn rõ ràng việc sử dụng cookie HttpOnly để lưu RT. Điều này ngăn JavaScript phía client truy cập RT.
+
+Access Token (AT) có thể được lưu trong bộ nhớ JavaScript (an toàn hơn localStorage cho AT có đời sống ngắn) hoặc sessionStorage nếu cần thiết cho SPA.
+
+Thiết lập cờ Secure và SameSite cho Cookie:
+
+Secure: Đảm bảo cookie chỉ được gửi qua HTTPS.
+
+SameSite=Strict (hoặc SameSite=Lax): Giúp chống lại tấn công CSRF. Starter-kit NÊN có cấu hình này.
+
+2. Quản Lý Refresh Token Phía Server – Đảm Bảo An Toàn
+Thực hành tốt đã có: Refresh Token Rotation (xoay vòng RT khi sử dụng) là rất tốt.
+
+Cải thiện cho Starter-kit:
+
+Vô hiệu hóa RT cũ NGAY LẬP TỨC khi xoay vòng: Đảm bảo RT đã sử dụng không còn giá trị.
+
+Thu hồi RT khi Logout: Endpoint /api/v1/auth/logout PHẢI xóa hoặc đánh dấu RT là đã thu hồi trong cơ sở dữ liệu. Chỉ xóa ở client là không đủ.
+
+(Khuyến nghị cho Starter-kit nâng cao): Cân nhắc cơ chế phát hiện việc sử dụng RT đã bị đánh cắp (ví dụ: nếu một RT cũ được dùng lại sau khi đã xoay vòng, hãy thu hồi tất cả RT của user đó).
+
+3. Tăng Cường Quy Trình Đăng Ký – Nền Tảng Người Dùng
+Cải thiện cho Starter-kit:
+
+Chính Sách Mật Khẩu Tối Thiểu:
+
+Yêu cầu độ dài mật khẩu tối thiểu (ví dụ: 8 hoặc 10 ký tự). Starter-kit NÊN có điều này.
+
+(Tùy chọn): Khuyến khích hoặc yêu cầu kết hợp chữ hoa, chữ thường, số, ký tự đặc biệt.
+
+Xác Thực Email (Khuyến Nghị Mạnh Mẽ):
+
+Starter-kit NÊN bao gồm module hoặc hướng dẫn tích hợp quy trình gửi email xác thực để kích hoạt tài khoản. Điều này giúp đảm bảo email hợp lệ và là kênh liên lạc quan trọng.
+
+4. Bảo Vệ Chống Tấn Công Đăng Nhập – Lớp Phòng Thủ Cơ Bản
+Cải thiện cho Starter-kit:
+
+Rate Limiting cho Endpoint Đăng Nhập: Áp dụng giới hạn số lần thử đăng nhập thất bại (/api/v1/auth/login) dựa trên IP hoặc username/email.
+
+Thông Báo Lỗi Chung Chung: Tránh các thông báo lỗi tiết lộ thông tin (ví dụ: "Username không tồn tại" hoặc "Sai mật khẩu"). Thay vào đó, sử dụng thông báo chung như "Tên đăng nhập hoặc mật khẩu không chính xác."
+
+5. Thực Hành Tốt Nhất với JWT – Cốt Lõi Của Xác Thực
+Cải thiện cho Starter-kit:
+
+Quản Lý Secret Key An Toàn:
+
+Hướng dẫn lưu trữ JWT secret key trong biến môi trường (environment variables).
+
+Tuyệt đối KHÔNG hardcode secret key trong mã nguồn.
+
+Sử Dụng Thuật Toán Ký Mạnh:
+
+Mặc định sử dụng thuật toán đối xứng mạnh như HS256.
+
+Khuyến nghị và cung cấp tùy chọn cho thuật toán bất đối xứng như RS256 (yêu cầu quản lý cặp public/private key) cho các hệ thống phức tạp hơn.
+
+Giữ Payload của Access Token Nhỏ Gọn:
+
+Chỉ chứa thông tin cần thiết nhất (ví dụ: userId, roles).
+
+Cân nhắc thêm iss (issuer) và aud (audience) để tăng cường xác minh token.
+
+6. Xử Lý Lỗi và Ghi Log (Logging) An Toàn
+Cải thiện cho Starter-kit:
+
+Không Ghi Log Thông Tin Nhạy Cảm: Tuyệt đối KHÔNG ghi log Access Token, Refresh Token, hoặc mật khẩu dưới bất kỳ hình thức nào.
+
+Ghi Log Sự Kiện An Ninh: Hướng dẫn hoặc cung cấp cơ chế ghi log các sự kiện quan trọng (đăng nhập thành công/thất bại, yêu cầu làm mới token, thay đổi mật khẩu) một cách an toàn, không kèm dữ liệu nhạy cảm, để phục vụ việc giám sát và điều tra.
+
+Bằng cách tích hợp những cải tiến này, Starter-kit của bạn sẽ cung cấp một điểm khởi đầu vững chắc và an toàn hơn cho các nhà phát triển.
\ No newline at end of file
diff --git a/docs/roadmap.md b/docs/roadmap.md
new file mode 100644
index 0000000..ee49e40
--- /dev/null
+++ b/docs/roadmap.md
@@ -0,0 +1,98 @@
+# Roadmap phát triển
+
+## Roadmap cơ bản
+- [x] Read Config from env file
+- [x] HTTP Server with gin framework
+- [x] JWT Authentication
+  - [x] Đăng ký người dùng
+  - [x] Đăng nhập với JWT
+  - [x] Refresh token
+  - [x] Xác thực token với middleware
+  - [x] Phân quyền cơ bản
+- [x] Database with GORM + Postgres
+- [ ] Health Check
+- [ ] Unit Test with testify (Template)
+- [ ] CI/CD with Gitea for Dev Team
+- [ ] Build and Deploy with Docker + Docker Compose on Local
+
+## Giai đoạn 1: Cơ sở hạ tầng cơ bản
+- [x] Thiết lập cấu trúc dự án theo mô hình DDD
+- [x] Cấu hình cơ bản: env, logging, error handling
+- [x] Cấu hình Docker và Docker Compose
+- [x] HTTP server với Gin
+- [x] Database setup với GORM và Postgres
+- [ ] Health check API endpoints
+- Timeline: Q2/2025
+
+## Giai đoạn 2: Bảo mật và xác thực (Q2/2025)
+
+### 1. Xác thực và Ủy quyền
+- [x] **JWT Authentication**
+  - [x] Đăng ký/Đăng nhập cơ bản
+  - [x] Refresh token
+  - [x] Xác thực token với middleware
+  - [x] Xử lý hết hạn token
+
+
+- [x] **Phân quyền cơ bản**
+  - [x] Phân quyền theo role
+  - [ ] Quản lý role và permission
+  - [ ] Phân quyền chi tiết đến từng endpoint
+  - [ ] API quản lý người dùng và phân quyền
+
+### 2. Bảo mật Ứng dụng
+- [ ] **API Security**
+  - [ ] API rate limiting (throttling)
+  - [ ] Request validation và sanitization
+  - [ ] Chống tấn công DDoS cơ bản
+  - [ ] API versioning
+
+- [ ] **Security Headers**
+  - [x] CORS configuration
+  - [ ] Security headers (CSP, HSTS, X-Content-Type, X-Frame-Options)
+  - [ ] Content Security Policy (CSP) tùy chỉnh
+  - [ ] XSS protection
+
+### 3. Theo dõi và Giám sát
+- [ ] **Audit Logging**
+  - [ ] Ghi log các hoạt động quan trọng
+  - [ ] Theo dõi đăng nhập thất bại
+  - [ ] Cảnh báo bảo mật
+
+- [ ] **Monitoring**
+  - [ ] Tích hợp Prometheus
+  - [ ] Dashboard giám sát
+  - [ ] Cảnh báo bất thường
+
+### 4. Cải thiện Hiệu suất
+- [ ] **Tối ưu hóa**
+  - [ ] Redis cho caching
+  - [ ] Tối ưu truy vấn database
+  - [ ] Compression response
+
+### Timeline
+- Tuần 1-2: Hoàn thiện xác thực & phân quyền
+- Tuần 3-4: Triển khai bảo mật API và headers
+- Tuần 5-6: Hoàn thiện audit logging và monitoring
+- Tuần 7-8: Tối ưu hiệu suất và kiểm thử bảo mật
+
+## Giai đoạn 3: Tự động hóa
+- [ ] Unit Test templates và mocks
+- [ ] CI/CD với Gitea
+- [ ] Automated deployment
+- [ ] Linting và code quality checks
+- Timeline: Q3/2025
+
+## Giai đoạn 4: Mở rộng tính năng
+- [x] Go Feature Flag implementation
+- [ ] Notification system
+- [ ] Background job processing
+- [ ] API documentation
+- Timeline: Q3/2025
+
+## Giai đoạn 5: Production readiness
+- [x] Performance optimization
+- [ ] Monitoring và observability
+- [ ] Backup và disaster recovery
+- [ ] Security hardening
+- Timeline: Q4/2025
diff --git a/docs/secrets.md b/docs/secrets.md
new file mode 100644
index 0000000..94efa14
--- /dev/null
+++ b/docs/secrets.md
@@ -0,0 +1,136 @@
+# CI/CD Workflows
+
+ULFlow Starter Kit sử dụng Gitea Actions để tự động hóa quy trình CI/CD. Tài liệu này mô tả các workflow được cấu hình và các biến cần thiết.
+
+## Tổng quan về quy trình
+
+Quy trình CI/CD được thiết kế để hoạt động như sau:
+
+1. **CI Pipeline** chạy trên tất cả các nhánh ngoại trừ `main`
+2. **Docker Build** chạy khi đánh tag hoặc sau khi merge vào `main`
+3. **Deploy to VPS** chỉ chạy khi đánh tag phiên bản (format `v*`)
+
+## Workflow Files
+
+### 1. CI Pipeline (`.gitea/workflows/ci.yml`)
+
+CI Pipeline chạy trên tất cả các nhánh ngoại trừ `main` và bao gồm các job:
+
+- **Lint**: Kiểm tra chất lượng mã với golangci-lint
+- **Security Scan**: Quét lỗ hổng bảo mật với govulncheck
+- **Test**: Chạy unit tests và tạo báo cáo coverage
+- **Build**: Build ứng dụng và tạo artifact
+- **Notify**: Thông báo kết quả
+
+### 2. Docker Build & Deploy (`.gitea/workflows/docker.yml`)
+
+Workflow này chạy khi:
+- Đánh tag phiên bản (format `v*`)
+- Sau khi CI Pipeline thành công trên nhánh `main`
+
+Bao gồm các job:
+- **Docker Build**: Build và push Docker image lên Gitea Container Registry
+- **Deploy to VPS**: Triển khai ứng dụng lên VPS (chỉ khi đánh tag)
+
+## Cấu hình Secrets
+
+Để các workflow hoạt động đúng, bạn cần cấu hình các secrets sau trong Gitea:
+
+### Secrets cho Runner
+
+| Secret | Mô tả | Mặc định |
+|--------|-------|----------|
+| `RUNNER_LABEL` | Label của runner cho các job CI | `ubuntu-latest` |
+| `DEPLOY_RUNNER` | Label của runner cho job deploy | `ubuntu-latest` |
+
+### Secrets cho Docker Registry
+
+| Secret | Mô tả | Bắt buộc |
+|--------|-------|----------|
+| `REGISTRY_URL` | URL của Gitea Container Registry | ✅ |
+| `REGISTRY_USERNAME` | Username để đăng nhập vào registry | ✅ |
+| `REGISTRY_PASSWORD` | Password để đăng nhập vào registry | ✅ |
+| `REPOSITORY_PATH` | Đường dẫn repository trong registry | ✅ |
+
+### Secrets cho Deployment
+
+| Secret | Mô tả | Mặc định |
+|--------|-------|----------|
+| `CONTAINER_NAME` | Tên container | `ulflow-api-container` |
+| `DOCKER_NETWORK` | Tên network Docker | `ulflow-network` |
+| `APP_PORT` | Port để expose | `3000` |
+| `APP_ENV` | Môi trường ứng dụng | `production` |
+| `CONTAINER_MEMORY` | Giới hạn bộ nhớ | `1g` |
+| `CONTAINER_CPU` | Giới hạn CPU | `1` |
+| `HEALTH_CMD` | Command kiểm tra health | `curl -f http://localhost:3000/health || exit 1` |
+| `HEALTH_INTERVAL` | Khoảng thời gian kiểm tra health | `30s` |
+
+### Secrets cho Database
+
+| Secret | Mô tả | Bắt buộc |
+|--------|-------|----------|
+| `DB_HOST` | Hostname của database | ✅ |
+| `DB_USER` | Username database | ✅ |
+| `DB_PASSWORD` | Password database | ✅ |
+| `DB_NAME` | Tên database | ✅ |
+
+### Secrets cho Security
+
+| Secret | Mô tả | Bắt buộc |
+|--------|-------|----------|
+| `JWT_SECRET_KEY` | Secret key cho JWT | ✅ |
+| `REFRESH_TOKEN_SECRET` | Secret key cho refresh token | ✅ |
+| `API_KEY` | API key | ✅ |
+| `ENCRYPTION_KEY` | Key mã hóa dữ liệu | ✅ |
+
+## Cấu hình Gitea
+
+### Tạo Secrets trong Gitea
+
+1. Truy cập repository trong Gitea
+2. Vào **Settings > Secrets**
+3. Thêm từng secret với tên và giá trị tương ứng
+
+### Cấu hình Runner
+
+1. Đảm bảo Gitea Runner đã được cài đặt và kết nối với Gitea
+2. Nếu sử dụng custom runner, cập nhật `RUNNER_LABEL` và `DEPLOY_RUNNER` tương ứng
+
+## Ví dụ quy trình làm việc
+
+1. **Phát triển tính năng:**
+   ```bash
+   git checkout -b feat/new-feature
+   # Làm việc và commit
+   git push origin feat/new-feature
+   ```
+   → CI Pipeline tự động chạy
+
+2. **Merge vào main:**
+   - Tạo Pull Request từ `feat/new-feature` vào `main`
+   - Sau khi merge, Docker Build tự động chạy
+
+3. **Release phiên bản:**
+   ```bash
+   git tag v1.0.0
+   git push origin v1.0.0
+   ```
+   → Docker Build và Deploy tự động chạy
+
+## Troubleshooting
+
+### Workflow không chạy
+
+- Kiểm tra Gitea Runner đã được cấu hình đúng
+- Kiểm tra quyền của repository và runner
+
+### Docker Build thất bại
+
+- Kiểm tra thông tin đăng nhập registry
+- Kiểm tra quyền truy cập vào registry
+
+### Deploy thất bại
+
+- Kiểm tra kết nối đến VPS
+- Kiểm tra Docker đã được cài đặt trên VPS
+- Kiểm tra các biến môi trường đã được cấu hình đúng
diff --git a/docs/session_20240524.md b/docs/session_20240524.md
new file mode 100644
index 0000000..62b968d
--- /dev/null
+++ b/docs/session_20240524.md
@@ -0,0 +1,32 @@
+# Tóm tắt phiên làm việc - 24/05/2025
+
+## Các file đang mở
+1. `docs/roadmap.md` - Đang xem mục tiêu phát triển
+2. `configs/config.yaml` - File cấu hình ứng dụng
+3. `docs/review.md` - Đang xem phần đánh giá code
+
+## Các thay đổi chính trong phiên
+
+### 1. Cập nhật Roadmap
+- Đánh dấu hoàn thành các mục JWT Authentication
+- Cập nhật chi tiết Giai đoạn 2 (Bảo mật và xác thực)
+- Thêm timeline chi tiết cho từng tuần
+
+### 2. Giải thích luồng xác thực
+- Đã giải thích chi tiết về luồng JWT authentication
+- Mô tả các endpoint chính và cách hoạt động
+- Giải thích về bảo mật token và xử lý lỗi
+
+### 3. Các lệnh đã sử dụng
+- `/heyy` - Thảo luận về các bước tiếp theo
+- `/yys` - Thử lưu trạng thái (không khả dụng)
+
+## Công việc đang thực hiện
+- Đang xem xét phần đánh giá code liên quan đến xử lý lỗi khởi động service
+
+## Ghi chú
+- Cần hoàn thiện phần Health Check API
+- Cần triển khai API rate limiting và security headers
+
+---
+*Tự động tạo lúc: 2025-05-24 12:26*
diff --git a/docs/spec.md b/docs/spec.md
new file mode 100644
index 0000000..3d35038
--- /dev/null
+++ b/docs/spec.md
@@ -0,0 +1,130 @@
+# Thông số kỹ thuật
+
+## Tech Stack
+- **Golang 1.23.6**: Ngôn ngữ chính dùng phát triển backend
+- **Docker + Docker Compose**: Containerization và orchestration
+- **Air Tomb v1.49.0**: Hot reload cho phát triển
+- **Gitea v1.21.0+**: Server, Runner, Action, Secret Manager, Registry Image
+- **PostgreSQL 15+**: Cơ sở dữ liệu quan hệ
+- **Ansible 2.14+**: Tự động hóa quy trình triển khai
+- **Go Feature Flag v1.9.0+**: Quản lý tính năng
+
+## Yêu cầu hệ thống
+- Go 1.23.6+
+- Docker Engine 24.0.0+
+- Docker Compose v2.20.0+
+- Git 2.40.0+
+- PostgreSQL 15.0+
+- Make (cho các tác vụ phát triển)
+
+## Thư viện và frameworks chính
+
+### Web Framework
+- **Gin v1.10.0**: HTTP framework nhẹ, hiệu suất cao
+  - Middleware hỗ trợ: CORS, JWT, Rate limiting
+  - Tích hợp sẵn validator
+
+### Database
+- **GORM v1.26.1**: ORM cho Go
+  - Hỗ trợ nhiều database: PostgreSQL, MySQL, SQLite
+  - Migration tools tích hợp
+  - Connection pooling và retry mechanisms
+
+### Authentication & Security
+- **JWT (JSON Web Tokens)**
+- **UUID v1.6.0**: Định danh duy nhất
+- **bcrypt**: Mã hóa mật khẩu
+
+### Configuration
+- **Viper v1.17.0**: Quản lý cấu hình linh hoạt
+  - Hỗ trợ nhiều định dạng (JSON, YAML, TOML, ENV)
+  - Tích hợp với biến môi trường
+
+### Logging
+- **Logrus v1.9.3**: Thư viện logging cấu trúc
+  ```yaml
+  logger:
+    level: "info"  # debug, info, warn, error, fatal, panic
+    format: "json"  # json hoặc text
+    enable_caller: true  # Hiển thị thông tin người gọi
+  ```
+  - Hỗ trợ nhiều mức độ log
+  - Tích hợp với các hệ thống log tập trung
+  - JSON format cho dễ phân tích
+
+### Testing
+- **Testify v1.10.0**: Framework testing cho Go
+  - Assertions mạnh mẽ
+  - Mock generation
+  - Test suites
+- **go-sqlmock v1.5.0+**: Mock database
+- **testcontainers-go**: Integration testing
+
+### Monitoring & Observability
+- **Prometheus**: Metrics collection
+- **OpenTelemetry**: Distributed tracing
+- **Health check endpoints**
+- **Pprof**: Profiling
+
+### Development Tools
+- **GolangCI-Lint**: Static code analysis
+- **Air Tomb**: Hot reload
+- **Go Mod**: Quản lý dependencies
+- **Makefile**: Tự động hóa tác vụ
+
+## Cấu hình môi trường
+
+### Development
+- Hot reload với Air Tomb
+- Local Docker environment
+- Sample data và fixtures
+
+### Testing
+- CI/CD với Gitea Actions
+- Automated test suites
+- Lint và code quality checks
+
+### Staging
+- Triển khai tự động
+- Môi trường gần với production
+- Performance testing
+
+### Production
+- High availability setup
+- Backup và disaster recovery
+- Security hardening
+
+## Quản lý cấu hình
+
+ULFlow Starter Kit sử dụng một hệ thống cấu hình linh hoạt dựa trên Viper:
+
+### Đặc điểm
+
+- Đọc cấu hình từ nhiều nguồn (file, biến môi trường)
+- Xác thực tự động các giá trị
+- Giá trị mặc định thông minh
+- Cấu trúc mạnh (strongly typed configuration)
+
+### Sử dụng
+
+```go
+// Khởi tạo config loader
+configLoader := config.NewConfigLoader()
+
+// Load cấu hình
+cfg, err := configLoader.Load()
+if err != nil {
+    log.Fatalf("Failed to load configuration: %v", err)
+}
+
+// Truy cập cấu hình
+appName := cfg.App.Name
+dbHost := cfg.Database.Host
+```
+
+## Các tệp cấu hình
+- `.env.example`: Template biến môi trường
+- `configs/config.yaml`: Cấu hình ứng dụng trong môi trường dev
+- `templates/config.example.yaml`: Template cấu hình ứng dụng
+- `docker-compose.yml`: Cấu hình container
+- `go.mod`, `go.sum`: Quản lý dependencies
diff --git a/docs/testing.md b/docs/testing.md
new file mode 100644
index 0000000..7668cce
--- /dev/null
+++ b/docs/testing.md
@@ -0,0 +1,119 @@
+# Testing
+
+## Tổng quan
+Testing là một phần quan trọng trong quy trình phát triển, đảm bảo chất lượng mã nguồn và giảm thiểu bugs. Dự án này sử dụng các công cụ và phương pháp testing tiêu chuẩn trong Golang.
+
+## Unit Testing
+### Công cụ sử dụng
+- Testify: Framework unit testing cho Go
+- Table-driven tests: Thiết kế test cases linh hoạt
+- Mocking: Giả lập dependencies
+
+### Quy ước và cấu trúc
+- Mỗi package cần có file `*_test.go` tương ứng
+- Các test functions có format `Test{FunctionName}` 
+- Test cases nên bao gồm cả happy path và error cases
+- Coverage yêu cầu tối thiểu: 80%
+- Sử dụng t.Run() để chạy các subtest
+### Mẫu Unit Test
+```go
+// user_service_test.go
+package user
+
+import (
+	"testing"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+// Mocking repository
+type MockUserRepository struct {
+	mock.Mock
+}
+
+func (m *MockUserRepository) FindByID(id string) (*User, error) {
+	args := m.Called(id)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*User), args.Error(1)
+}
+
+func TestGetUser(t *testing.T) {
+	// Test cases
+	testCases := []struct {
+		name          string
+		userID        string
+		mockUser      *User
+		mockError     error
+		expectedUser  *User
+		expectedError error
+	}{
+		{
+			name:          "successful_get",
+			userID:        "123",
+			mockUser:      &User{ID: "123", Name: "Test User"},
+			mockError:     nil,
+			expectedUser:  &User{ID: "123", Name: "Test User"},
+			expectedError: nil,
+		},
+		{
+			name:          "user_not_found",
+			userID:        "456",
+			mockUser:      nil,
+			mockError:     ErrUserNotFound,
+			expectedUser:  nil,
+			expectedError: ErrUserNotFound,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			// Setup mock
+			mockRepo := new(MockUserRepository)
+			mockRepo.On("FindByID", tc.userID).Return(tc.mockUser, tc.mockError)
+			
+			// Create service with mock dependency
+			service := NewUserService(mockRepo)
+			
+			// Call the method
+			user, err := service.GetUser(tc.userID)
+			
+			// Assert results
+			assert.Equal(t, tc.expectedUser, user)
+			assert.Equal(t, tc.expectedError, err)
+			
+			// Verify expectations
+			mockRepo.AssertExpectations(t)
+		})
+	}
+}
+```
+
+## Integration Testing
+### Approach
+- Test containers: Chạy dependent services (database, caching, etc) trong Docker containers
+- API testing: Kiểm tra endpoints và responses
+- DB testing: Kiểm tra queries và migrations
+
+### Setup và Teardown
+- Sử dụng `TestMain` để setup và teardown test environment
+- Cấu hình Docker containers cho testing
+- Cleanup sau khi chạy tests
+
+## E2E Testing
+- API black-box testing
+- Sequence testing cho business flows
+- Performance testing
+
+## CI/CD Integration
+- Chạy tests trên mỗi commit và PR
+- Lưu test results và coverage
+- Chỉ merge khi tests pass
+
+## Best Practices
+1. **Write tests first (TDD approach)**
+2. **Keep tests independent và idempotent**
+3. **Sử dụng fixtures cho test data**
+4. **Tránh hard-coding external dependencies**
+5. **Tách common test code thành helper functions**
diff --git a/docs/unit-testing.md b/docs/unit-testing.md
new file mode 100644
index 0000000..60b113d
--- /dev/null
+++ b/docs/unit-testing.md
@@ -0,0 +1,174 @@
+# Tài liệu Unit Testing
+
+## Mục lục
+1. [Giới thiệu](#giới-thiệu)
+2. [Cấu trúc thư mục test](#cấu-trúc-thư-mục-test)
+3. [Các loại test case](#các-loại-test-case)
+   - [Auth Middleware](#auth-middleware)
+   - [CORS Middleware](#cors-middleware)
+   - [Rate Limiting](#rate-limiting)
+   - [Security Config](#security-config)
+4. [Cách chạy test](#cách-chạy-test)
+5. [Best Practices](#best-practices)
+
+## Giới thiệu
+Tài liệu này mô tả các test case đã được triển khai trong dự án, giúp đảm bảo chất lượng và độ tin cậy của mã nguồn.
+
+## Cấu trúc thư mục test
+```
+internal/
+  transport/
+    http/
+      middleware/
+        auth_test.go        # Test xác thực và phân quyền
+        middleware_test.go   # Test CORS và rate limiting
+      handler/
+        health_handler_test.go  # Test health check endpoints
+  service/
+    auth_service_test.go      # Test service xác thực
+```
+
+## Các loại test case
+
+### Auth Middleware
+
+#### Xác thực người dùng
+1. **TestNewAuthMiddleware**
+   - Mục đích: Kiểm tra khởi tạo AuthMiddleware
+   - Input: AuthService
+   - Expected: Trả về instance AuthMiddleware
+
+2. **TestAuthenticate_Success**
+   - Mục đích: Xác thực thành công với token hợp lệ
+   - Input: Header Authorization với token hợp lệ
+   - Expected: Trả về status 200 và lưu thông tin user vào context
+
+3. **TestAuthenticate_NoAuthHeader**
+   - Mục đích: Không có header Authorization
+   - Input: Request không có header Authorization
+   - Expected: Trả về lỗi 401 Unauthorized
+
+4. **TestAuthenticate_InvalidTokenFormat**
+   - Mục đích: Kiểm tra định dạng token không hợp lệ
+   - Input:
+     - Token không có "Bearer" prefix
+     - Token rỗng sau "Bearer"
+   - Expected: Trả về lỗi 401 Unauthorized
+
+5. **TestAuthenticate_InvalidToken**
+   - Mục đích: Token không hợp lệ hoặc hết hạn
+   - Input: Token không hợp lệ
+   - Expected: Trả về lỗi 401 Unauthorized
+
+#### Phân quyền (RBAC)
+1. **TestRequireRole_Success**
+   - Mục đích: Người dùng có role yêu cầu
+   - Input: User có role phù hợp
+   - Expected: Cho phép truy cập
+
+2. **TestRequireRole_Unauthenticated**
+   - Mục đích: Chưa xác thực
+   - Input: Không có thông tin xác thực
+   - Expected: Trả về lỗi 401 Unauthorized
+
+3. **TestRequireRole_Forbidden**
+   - Mục đích: Không có quyền truy cập
+   - Input: User không có role yêu cầu
+   - Expected: Trả về lỗi 403 Forbidden
+
+#### Helper Functions
+1. **TestGetUserFromContext**
+   - Mục đích: Lấy thông tin user từ context
+   - Input: Context có chứa user
+   - Expected: Trả về thông tin user
+
+2. **TestGetUserFromContext_NotFound**
+   - Mục đích: Không tìm thấy user trong context
+   - Input: Context không có user
+   - Expected: Trả về lỗi
+
+3. **TestGetUserIDFromContext**
+   - Mục đích: Lấy user ID từ context
+   - Input: Context có chứa user
+   - Expected: Trả về user ID
+
+4. **TestGetUserIDFromContext_InvalidType**
+   - Mục đích: Kiểm tra lỗi khi kiểu dữ liệu không hợp lệ
+   - Input: Context có giá trị không phải kiểu *Claims
+   - Expected: Trả về lỗi
+
+### CORS Middleware
+1. **TestDefaultCORSConfig**
+   - Mục đích: Kiểm tra cấu hình CORS mặc định
+   - Expected: Cấu hình mặc định cho phép tất cả origins
+
+2. **TestCORS**
+   - Mục đích: Kiểm tra hành vi CORS
+   - Các trường hợp:
+     - Cho phép tất cả origins
+     - Chỉ cho phép origin cụ thể
+     - Xử lý preflight request
+
+### Rate Limiting
+1. **TestDefaultRateLimiterConfig**
+   - Mục đích: Kiểm tra cấu hình rate limiter mặc định
+   - Expected: Giới hạn mặc định được áp dụng
+
+2. **TestRateLimit**
+   - Mục đích: Kiểm tra hoạt động của rate limiter
+   - Expected: Chặn request khi vượt quá giới hạn
+
+### Security Config
+1. **TestSecurityConfig**
+   - Mục đích: Kiểm tra cấu hình bảo mật
+   - Các trường hợp:
+     - Cấu hình mặc định
+     - Áp dụng cấu hình cho router
+
+## Cách chạy test
+
+### Chạy tất cả test
+```bash
+go test ./...
+```
+
+### Chạy test với coverage
+```bash
+go test -coverprofile=coverage.out ./...
+go tool cover -html=coverage.out
+```
+
+### Chạy test cụ thể
+```bash
+go test -run ^TestName$
+```
+
+## Best Practices
+
+1. **Đặt tên test rõ ràng**
+   - Sử dụng cấu trúc: `Test[FunctionName]_[Scenario]`
+   - Ví dụ: `TestAuthenticate_InvalidToken`
+
+2. **Mỗi test một trường hợp**
+   - Mỗi test function chỉ kiểm tra một trường hợp cụ thể
+   - Sử dụng subtests cho các test case liên quan
+
+3. **Kiểm tra cả trường hợp lỗi**
+   - Kiểm tra cả các trường hợp thành công và thất bại
+   - Đảm bảo có thông báo lỗi rõ ràng
+
+4. **Sử dụng mock cho các phụ thuộc**
+   - Sử dụng thư viện `testify/mock` để tạo mock
+   - Đảm bảo test độc lập với các thành phần bên ngoài
+
+5. **Kiểm tra biên**
+   - Kiểm tra các giá trị biên và trường hợp đặc biệt
+   - Ví dụ: empty string, nil, giá trị âm, v.v.
+
+6. **Giữ test đơn giản**
+   - Test cần dễ hiểu và dễ bảo trì
+   - Tránh logic phức tạp trong test
+
+7. **Đảm bảo test chạy nhanh**
+   - Tránh I/O không cần thiết
+   - Sử dụng `t.Parallel()` cho các test độc lập
diff --git a/docs/ux.md b/docs/ux.md
new file mode 100644
index 0000000..d1b98e2
--- /dev/null
+++ b/docs/ux.md
@@ -0,0 +1,57 @@
+# Thiết kế trải nghiệm người dùng
+
+## Nguyên tắc thiết kế API
+
+### API Design
+- RESTful APIs là mặc định
+- Sử dụng HTTP verbs phù hợp (GET, POST, PUT, DELETE)
+- Định dạng URL: `/api/v{version}/{resource}/{id}`
+- Versions được chỉ định trong URL path
+- Query parameters cho filtering, sorting, pagination
+
+### Responses
+- Sử dụng HTTP status codes một cách nhất quán
+- Cấu trúc JSON responses:
+  ```json
+  {
+    "status": "success",
+    "data": { ... },
+    "meta": { "pagination": { ... } }
+  }
+  ```
+- Cấu trúc error responses:
+  ```json
+  {
+    "status": "error",
+    "error": {
+      "code": "ERROR_CODE",
+      "message": "Human readable message",
+      "details": { ... }
+    }
+  }
+  ```
+
+### Authentication
+- Bearer token trong Authorization header
+- API key cho các dịch vụ được tin cậy
+- OAuth 2.0 cho third-party applications
+
+## Documentation
+- OpenAPI/Swagger spec được tự động sinh
+- API documentation tích hợp với code
+- Ví dụ request/response cho mọi endpoint
+
+## Rate Limiting
+- Rate limits dựa trên IP hoặc user
+- Headers thông báo limits và remaining requests
+- Graceful handling khi vượt giới hạn
+
+## Monitoring
+- Tracking API usage và performance
+- User behavior analytics
+- Error tracking và alerting
+
+## Testing
+- End-to-end API testing
+- Performance và load testing
+- Security testing
diff --git a/docs/workflow.md b/docs/workflow.md
new file mode 100644
index 0000000..9c83fda
--- /dev/null
+++ b/docs/workflow.md
@@ -0,0 +1,84 @@
+# Quy trình phát triển
+
+## Branch Strategy
+
+- Trunk-Based Development là phương pháp quản lý nhánh trong Git, nơi tất cả thay đổi được tích hợp thường xuyên vào nhánh chính (`main`), còn gọi là "trunk".
+- Tên nhánh trùng với tiêu chuẩn của Git Commit Message
+    - `feat`: Tạo tính năng mới
+    - `fix`: Sửa lỗi
+    - `docs`: Thay đổi tài liệu
+    - `style`: Thay đổi không ảnh hưởng đến logic
+    - `refactor`: Refactor code
+    - `test`: Thêm hoặc sửa test
+    - `chore`: Thay đổi cấu hình hoặc các task không liên quan đến code
+
+## Quy trình làm việc
+
+### 1. Khởi tạo công việc
+- Tạo issue mô tả công việc cần thực hiện
+- Gán assignee và labels phù hợp
+- Ước lượng effort và deadline
+
+### 2. Phát triển
+- Tạo nhánh từ `main` với quy ước đặt tên:
+  ```
+  <type>/<issue-number>-<short-description>
+  ```
+  Ví dụ: `feat/123-user-authentication`
+
+- Thực hiện thay đổi, tuân thủ coding standards
+- Commit thường xuyên với commit message rõ ràng
+  ```
+  <type>(<scope>): <subject>
+  ```
+  Ví dụ: `feat(auth): implement JWT token validation`
+
+### 3. Kiểm thử
+- Viết unit tests cho mọi thay đổi
+- Đảm bảo test coverage đạt yêu cầu
+- Chạy linting và static code analysis
+
+### 4. Review
+- Tạo pull request (PR) vào nhánh `main`
+- Mô tả chi tiết các thay đổi
+- Request review từ ít nhất 1 team member
+- Khi được approve, resolve tất cả comments
+
+### 5. Triển khai
+- Merge PR vào `main` (squash và fast-forward)
+- CI/CD pipeline sẽ tự động build và deploy
+- Theo dõi logs và metrics sau khi deploy
+
+## Gitea Workflow
+
+### Gitea Actions
+- Cấu hình trong `.gitea/workflows/`
+- Định nghĩa các jobs: build, test, lint, deploy
+- Trigger dựa trên events: push, PR, tag
+
+### Gitea Secrets
+- Sử dụng Secret Manager để lưu trữ credentials
+- Truy cập secrets trong workflows
+
+### Gitea Registry
+- Build và push Docker images
+- Versioning theo semantic versioning
+
+## Conventions
+
+### Commit Messages
+- Format: `<type>(<scope>): <subject>`
+- Types: feat, fix, docs, style, refactor, test, chore
+- Scope: module/component tương ứng
+- Subject: mô tả ngắn gọn, rõ ràng
+
+### Versioning
+- Theo Semantic Versioning: MAJOR.MINOR.PATCH
+- MAJOR: breaking changes
+- MINOR: backwards-compatible features
+- PATCH: backwards-compatible bug fixes
+
+### Release Process
+- Tạo tag với version mới
+- Cập nhật changelog
+- Deploy lên môi trường production
diff --git a/go.mod b/go.mod
new file mode 100644
index 0000000..0efdfea
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,75 @@
+module starter-kit
+
+go 1.23.6
+
+require (
+	github.com/DATA-DOG/go-sqlmock v1.5.2
+	github.com/gin-gonic/gin v1.10.0
+	github.com/go-playground/validator/v10 v10.20.0
+	github.com/golang-jwt/jwt/v5 v5.2.2
+	github.com/joho/godotenv v1.5.1
+	github.com/mitchellh/mapstructure v1.5.0
+	github.com/sirupsen/logrus v1.9.3
+	github.com/spf13/viper v1.17.0
+	github.com/stretchr/testify v1.10.0
+	go.uber.org/multierr v1.11.0
+	golang.org/x/crypto v0.38.0
+	gopkg.in/tomb.v2 v2.0.0-20161208151619-d5d1b5820637
+	gorm.io/driver/mysql v1.5.7
+	gorm.io/driver/postgres v1.5.11
+	gorm.io/driver/sqlite v1.5.7
+	gorm.io/gorm v1.26.1
+)
+
+require (
+	filippo.io/edwards25519 v1.1.0 // indirect
+	github.com/bytedance/sonic v1.11.6 // indirect
+	github.com/bytedance/sonic/loader v0.1.1 // indirect
+	github.com/cloudwego/base64x v0.1.4 // indirect
+	github.com/cloudwego/iasm v0.2.0 // indirect
+	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect
+	github.com/fsnotify/fsnotify v1.7.0 // indirect
+	github.com/gabriel-vasile/mimetype v1.4.3 // indirect
+	github.com/gin-contrib/sse v0.1.0 // indirect
+	github.com/go-playground/locales v0.14.1 // indirect
+	github.com/go-playground/universal-translator v0.18.1 // indirect
+	github.com/go-sql-driver/mysql v1.9.2 // indirect
+	github.com/goccy/go-json v0.10.2 // indirect
+	github.com/google/go-cmp v0.7.0 // indirect
+	github.com/hashicorp/hcl v1.0.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 // indirect
+	github.com/jackc/pgx/v5 v5.7.4 // indirect
+	github.com/jackc/puddle/v2 v2.2.2 // indirect
+	github.com/jinzhu/inflection v1.0.0 // indirect
+	github.com/jinzhu/now v1.1.5 // indirect
+	github.com/json-iterator/go v1.1.12 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.7 // indirect
+	github.com/leodido/go-urn v1.4.0 // indirect
+	github.com/magiconair/properties v1.8.9 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-sqlite3 v1.14.28 // indirect
+	github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd // indirect
+	github.com/modern-go/reflect2 v1.0.2 // indirect
+	github.com/pelletier/go-toml/v2 v2.2.2 // indirect
+	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
+	github.com/sagikazarmark/locafero v0.3.0 // indirect
+	github.com/sagikazarmark/slog-shim v0.1.0 // indirect
+	github.com/sourcegraph/conc v0.3.0 // indirect
+	github.com/spf13/afero v1.10.0 // indirect
+	github.com/spf13/cast v1.5.1 // indirect
+	github.com/spf13/pflag v1.0.6 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
+	github.com/subosito/gotenv v1.6.0 // indirect
+	github.com/twitchyliquid64/golang-asm v0.15.1 // indirect
+	github.com/ugorji/go/codec v1.2.12 // indirect
+	golang.org/x/arch v0.8.0 // indirect
+	golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6 // indirect
+	golang.org/x/net v0.39.0 // indirect
+	golang.org/x/sync v0.14.0 // indirect
+	golang.org/x/sys v0.33.0 // indirect
+	golang.org/x/text v0.25.0 // indirect
+	google.golang.org/protobuf v1.36.6 // indirect
+	gopkg.in/ini.v1 v1.67.0 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)
diff --git a/go.sum b/go.sum
new file mode 100644
index 0000000..ef267cc
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,600 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.44.1/go.mod h1:iSa0KzasP4Uvy3f1mN/7PiObzGgflwredwwASm/v6AU=
+cloud.google.com/go v0.44.2/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.44.3/go.mod h1:60680Gw3Yr4ikxnPRS/oxxkBccT6SA1yMk63TGekxKY=
+cloud.google.com/go v0.45.1/go.mod h1:RpBamKRgapWJb87xiFSdk4g1CME7QZg3uwTez+TSTjc=
+cloud.google.com/go v0.46.3/go.mod h1:a6bKKbmY7er1mI7TEI4lsAkts/mkhTSZK8w33B4RAg0=
+cloud.google.com/go v0.50.0/go.mod h1:r9sluTvynVuxRIOHXQEHMFffphuXHOMZMycpNR5e6To=
+cloud.google.com/go v0.52.0/go.mod h1:pXajvRH/6o3+F9jDHZWQ5PbGhn+o8w9qiu/CffaVdO4=
+cloud.google.com/go v0.53.0/go.mod h1:fp/UouUEsRkN6ryDKNW/Upv/JBKnv6WDthjR6+vze6M=
+cloud.google.com/go v0.54.0/go.mod h1:1rq2OEkV3YMf6n/9ZvGWI3GWw0VoqH/1x2nd8Is/bPc=
+cloud.google.com/go v0.56.0/go.mod h1:jr7tqZxxKOVYizybht9+26Z/gUq7tiRzu+ACVAMbKVk=
+cloud.google.com/go v0.57.0/go.mod h1:oXiQ6Rzq3RAkkY7N6t3TcE6jE+CIBBbA36lwQ1JyzZs=
+cloud.google.com/go v0.62.0/go.mod h1:jmCYTdRCQuc1PHIIJ/maLInMho30T/Y0M4hTdTShOYc=
+cloud.google.com/go v0.65.0/go.mod h1:O5N8zS7uWy9vkA9vayVHs65eM1ubvY4h553ofrNHObY=
+cloud.google.com/go v0.72.0/go.mod h1:M+5Vjvlc2wnp6tjzE102Dw08nGShTscUx2nZMufOKPI=
+cloud.google.com/go v0.74.0/go.mod h1:VV1xSbzvo+9QJOxLDaJfTjx5e+MePCpCWwvftOeQmWk=
+cloud.google.com/go v0.75.0/go.mod h1:VGuuCn7PG0dwsd5XPVm2Mm3wlh3EL55/79EKB6hlPTY=
+cloud.google.com/go/bigquery v1.0.1/go.mod h1:i/xbL2UlR5RvWAURpBYZTtm/cXjCha9lbfbpx4poX+o=
+cloud.google.com/go/bigquery v1.3.0/go.mod h1:PjpwJnslEMmckchkHFfq+HTD2DmtT67aNFKH1/VBDHE=
+cloud.google.com/go/bigquery v1.4.0/go.mod h1:S8dzgnTigyfTmLBfrtrhyYhwRxG72rYxvftPBK2Dvzc=
+cloud.google.com/go/bigquery v1.5.0/go.mod h1:snEHRnqQbz117VIFhE8bmtwIDY80NLUZUMb4Nv6dBIg=
+cloud.google.com/go/bigquery v1.7.0/go.mod h1://okPTzCYNXSlb24MZs83e2Do+h+VXtc4gLoIoXIAPc=
+cloud.google.com/go/bigquery v1.8.0/go.mod h1:J5hqkt3O0uAFnINi6JXValWIb1v0goeZM77hZzJN/fQ=
+cloud.google.com/go/datastore v1.0.0/go.mod h1:LXYbyblFSglQ5pkeyhO+Qmw7ukd3C+pD7TKLgZqpHYE=
+cloud.google.com/go/datastore v1.1.0/go.mod h1:umbIZjpQpHh4hmRpGhH4tLFup+FVzqBi1b3c64qFpCk=
+cloud.google.com/go/pubsub v1.0.1/go.mod h1:R0Gpsv3s54REJCy4fxDixWD93lHJMoZTyQ2kNxGRt3I=
+cloud.google.com/go/pubsub v1.1.0/go.mod h1:EwwdRX2sKPjnvnqCa270oGRyludottCI76h+R3AArQw=
+cloud.google.com/go/pubsub v1.2.0/go.mod h1:jhfEVHT8odbXTkndysNHCcx0awwzvfOlguIAii9o8iA=
+cloud.google.com/go/pubsub v1.3.1/go.mod h1:i+ucay31+CNRpDW4Lu78I4xXG+O1r/MAHgjpRVR+TSU=
+cloud.google.com/go/storage v1.0.0/go.mod h1:IhtSnM/ZTZV8YYJWCY8RULGVqBDmpoyjwiyrjsg+URw=
+cloud.google.com/go/storage v1.5.0/go.mod h1:tpKbwo567HUNpVclU5sGELwQWBDZ8gh0ZeosJ0Rtdos=
+cloud.google.com/go/storage v1.6.0/go.mod h1:N7U0C8pVQ/+NIKOBQyamJIeKQKkZ+mxpohlUTyfDhBk=
+cloud.google.com/go/storage v1.8.0/go.mod h1:Wv1Oy7z6Yz3DshWRJFhqM/UCfaWIRTdp0RXyy7KQOVs=
+cloud.google.com/go/storage v1.10.0/go.mod h1:FLPqc6j+Ki4BU591ie1oL6qBQGu2Bl/tZ9ullr3+Kg0=
+cloud.google.com/go/storage v1.14.0/go.mod h1:GrKmX003DSIwi9o29oFT7YDnHYwZoctc3fOKtUw0Xmo=
+dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7gZCb22OMCxBHrMx7a5I7Hp++hsVxbQ4BYO7hU=
+filippo.io/edwards25519 v1.1.0 h1:FNf4tywRC1HmFuKW5xopWpigGjJKiJSV0Cqo0cJWDaA=
+filippo.io/edwards25519 v1.1.0/go.mod h1:BxyFTGdWcka3PhytdK4V28tE5sGfRvvvRV7EaN4VDT4=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802/go.mod h1:IVnqGOEym/WlBOVXweHU+Q+/VP0lqqI8lqeDx9IjBqo=
+github.com/DATA-DOG/go-sqlmock v1.5.2 h1:OcvFkGmslmlZibjAjaHm3L//6LiuBgolP7OputlJIzU=
+github.com/DATA-DOG/go-sqlmock v1.5.2/go.mod h1:88MAG/4G7SMwSE3CeA0ZKzrT5CiOU3OJ+JlNzwDqpNU=
+github.com/bytedance/sonic v1.11.6 h1:oUp34TzMlL+OY1OUWxHqsdkgC/Zfc85zGqw9siXjrc0=
+github.com/bytedance/sonic v1.11.6/go.mod h1:LysEHSvpvDySVdC2f87zGWf6CIKJcAvqab1ZaiQtds4=
+github.com/bytedance/sonic/loader v0.1.1 h1:c+e5Pt1k/cy5wMveRDyk2X4B9hF4g7an8N3zCYjJFNM=
+github.com/bytedance/sonic/loader v0.1.1/go.mod h1:ncP89zfokxS5LZrJxl5z0UJcsk4M4yY2JpfqGeCtNLU=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
+github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
+github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/cloudwego/base64x v0.1.4 h1:jwCgWpFanWmN8xoIUHa2rtzmkd5J2plF/dnLS6Xd/0Y=
+github.com/cloudwego/base64x v0.1.4/go.mod h1:0zlkT4Wn5C6NdauXdJRhSKRlJvmclQ1hhJgA0rcu/8w=
+github.com/cloudwego/iasm v0.2.0 h1:1KNIy1I1H9hNNFEEH3DVnI4UujN+1zjpuk6gwHLTssg=
+github.com/cloudwego/iasm v0.2.0/go.mod h1:8rXZaNYT2n95jn+zTI1sDr+IgcD2GVs0nlbbQPiEFhY=
+github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
+github.com/cncf/udpa/go v0.0.0-20200629203442-efcf912fb354/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/cncf/udpa/go v0.0.0-20201120205902-5459f2c99403/go.mod h1:WmhPx2Nbnhtbo57+VJT5O0JRkEi1Wbu0z5j0R8u5Hbk=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM=
+github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
+github.com/envoyproxy/go-control-plane v0.9.7/go.mod h1:cwu0lG7PUMfa9snN8LXBig5ynNVH9qI8YYLbd1fK2po=
+github.com/envoyproxy/go-control-plane v0.9.9-0.20201210154907-fd9021fe5dad/go.mod h1:cXg6YxExXjJnVBQHBLXeUAgxn2UodCpnH306RInaBQk=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/frankban/quicktest v1.14.4 h1:g2rn0vABPOOXmZUj+vbmUp0lPoXEMuhTpIluN0XL9UY=
+github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/gabriel-vasile/mimetype v1.4.3 h1:in2uUcidCuFcDKtdcBxlR0rJ1+fsokWf+uqxgUFjbI0=
+github.com/gabriel-vasile/mimetype v1.4.3/go.mod h1:d8uq/6HKRL6CGdk+aubisF/M5GcPfT7nKyLpA0lbSSk=
+github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE=
+github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI=
+github.com/gin-gonic/gin v1.10.0 h1:nTuyha1TYqgedzytsKYqna+DfLos46nTv2ygFy86HFU=
+github.com/gin-gonic/gin v1.10.0/go.mod h1:4PMNQiOhvDRa013RKVbsiNwoyezlm2rm0uX/T7kzp5Y=
+github.com/go-gl/glfw v0.0.0-20190409004039-e6da0acd62b1/go.mod h1:vR7hzQXu2zJy9AVAgeJqvqgH9Q5CA+iKCZ2gyEVpxRU=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20191125211704-12ad95a8df72/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-gl/glfw/v3.3/glfw v0.0.0-20200222043503-6f7a984d4dc4/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
+github.com/go-playground/assert/v2 v2.2.0 h1:JvknZsQTYeFEAhQwI4qEt9cyV5ONwRHC+lYKSsYSR8s=
+github.com/go-playground/assert/v2 v2.2.0/go.mod h1:VDjEfimB/XKnb+ZQfWdccd7VUvScMdVu0Titje2rxJ4=
+github.com/go-playground/locales v0.14.1 h1:EWaQ/wswjilfKLTECiXz7Rh+3BjFhfDFKv/oXslEjJA=
+github.com/go-playground/locales v0.14.1/go.mod h1:hxrqLVvrK65+Rwrd5Fc6F2O76J/NuW9t0sjnWqG1slY=
+github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJnYK9S473LQFuzCbDbfSFY=
+github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
+github.com/go-playground/validator/v10 v10.20.0 h1:K9ISHbSaI0lyB2eWMPJo+kOS/FBExVwjEviJTixqxL8=
+github.com/go-playground/validator/v10 v10.20.0/go.mod h1:dbuPbCMFw/DrkbEynArYaCwl3amGuJotoKCe95atGMM=
+github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
+github.com/go-sql-driver/mysql v1.9.2 h1:4cNKDYQ1I84SXslGddlsrMhc8k4LeDVj6Ad6WRjiHuU=
+github.com/go-sql-driver/mysql v1.9.2/go.mod h1:qn46aNg1333BRMNU69Lq93t8du/dwxI64Gl8i5p1WMU=
+github.com/goccy/go-json v0.10.2 h1:CrxCmQqYDkv1z7lO7Wbh2HN93uovUHgrECaO5ZrCXAU=
+github.com/goccy/go-json v0.10.2/go.mod h1:6MelG93GURQebXPDq3khkgXZkazVtN9CRI+MGFi0w8I=
+github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
+github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190702054246-869f871628b6/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20191227052852-215e87163ea7/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/groupcache v0.0.0-20200121045136-8c9f03a8e57e/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/mock v1.4.0/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.1/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.3/go.mod h1:UOMv5ysSaYNkG+OFQykRIcU/QvvxJf3p21QfJ2Bt3cw=
+github.com/golang/mock v1.4.4/go.mod h1:l3mdAwkq5BuhzHwde/uurv3sEJeZMXNpwsxVWU71h+4=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
+github.com/golang/protobuf v1.3.5/go.mod h1:6O5/vntMXwX2lRkT1hjjk0nAC1IDOTvTlVgjlRvqsdk=
+github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
+github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
+github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
+github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
+github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
+github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
+github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.4.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.2/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
+github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
+github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/martian/v3 v3.0.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/martian/v3 v3.1.0/go.mod h1:y5Zk1BBys9G+gd6Jrk0W3cC1+ELVxBWuIGO+w/tUAp0=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20190515194954-54271f7e092f/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/google/pprof v0.0.0-20191218002539-d4f498aebedc/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200212024743-f11f1df84d12/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200229191704-1ebb73c60ed3/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200430221834-fc25d7d30c6d/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20200708004538-1a94d8640e99/go.mod h1:ZgVRPoUq/hfqzAqh7sHMqb3I9Rq5C59dIz2SbBwJ4eM=
+github.com/google/pprof v0.0.0-20201023163331-3e6fc7fc9c4c/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20201203190320-1bf35d6f28c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/pprof v0.0.0-20201218002935-b9804c9f04c2/go.mod h1:kpwsk12EmLew5upagYY7GY0pfYCcupk39gWOCRROcvE=
+github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
+github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/googleapis/gax-go/v2 v2.0.5/go.mod h1:DWXyrwAJ9X0FpwwEdw+IPEYBICEFu5mhpdKc/us6bOk=
+github.com/googleapis/google-cloud-go-testing v0.0.0-20200911160855-bcd43fbb19e8/go.mod h1:dvDLG8qkwmyD9a/MJJN3XJcT3xFxOKAvTZGvuZmac9g=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc=
+github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
+github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761 h1:iCEnooe7UlwOQYpKFhBabPMi4aNAfoODPEFNiAnClxo=
+github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
+github.com/jackc/pgx/v5 v5.7.4 h1:9wKznZrhWa2QiHL+NjTSPP6yjl3451BX3imWDnokYlg=
+github.com/jackc/pgx/v5 v5.7.4/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=
+github.com/jackc/puddle/v2 v2.2.2 h1:PR8nw+E/1w0GLuRFSmiioY6UooMp6KJv0/61nB7icHo=
+github.com/jackc/puddle/v2 v2.2.2/go.mod h1:vriiEXHvEE654aYKXXjOvZM39qJ0q+azkZFrfEOc3H4=
+github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
+github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
+github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
+github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
+github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
+github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/XSXhF0NWZEnDohbsk=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/kisielk/sqlstruct v0.0.0-20201105191214-5f3e10d3ab46/go.mod h1:yyMNCyc/Ib3bDTKd379tNMpB/7/H5TjM2Y9QJ5THLbE=
+github.com/klauspost/cpuid/v2 v2.0.9/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=
+github.com/klauspost/cpuid/v2 v2.2.7 h1:ZWSB3igEs+d0qvnxR/ZBzXVmxkgt8DdzP6m9pfuVLDM=
+github.com/klauspost/cpuid/v2 v2.2.7/go.mod h1:Lcz8mBdAVJIBVzewtcLocK12l3Y+JytZYpaMropDUws=
+github.com/knz/go-libedit v1.10.1/go.mod h1:MZTVkCWyz0oBc7JOWP3wNAzd002ZbM/5hgShxwh4x8M=
+github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
+github.com/leodido/go-urn v1.4.0 h1:WT9HwE9SGECu3lg4d/dIA+jxlljEa1/ffXKmRjqdmIQ=
+github.com/leodido/go-urn v1.4.0/go.mod h1:bvxc+MVxLKB4z00jd1z+Dvzr47oO32F/QSNjSBOlFxI=
+github.com/magiconair/properties v1.8.9 h1:nWcCbLq1N2v/cpNsy5WvQ37Fb+YElfq20WJ/a8RkpQM=
+github.com/magiconair/properties v1.8.9/go.mod h1:Dhd985XPs7jluiymwWYZ0G4Z61jb3vdS329zhj2hYo0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-sqlite3 v1.14.28 h1:ThEiQrnbtumT+QMknw63Befp/ce/nUPgBPMlRFEum7A=
+github.com/mattn/go-sqlite3 v1.14.28/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
+github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
+github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
+github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
+github.com/pelletier/go-toml/v2 v2.2.2 h1:aYUidT7k73Pcl9nb2gScu7NSrKCSHIDE89b3+6Wq+LM=
+github.com/pelletier/go-toml/v2 v2.2.2/go.mod h1:1t835xjRzz80PqgE6HHgN2JOsmgYu/h4qDAS4n929Rs=
+github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
+github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
+github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
+github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/sagikazarmark/locafero v0.3.0 h1:zT7VEGWC2DTflmccN/5T1etyKvxSxpHsjb9cJvm4SvQ=
+github.com/sagikazarmark/locafero v0.3.0/go.mod h1:w+v7UsPNFwzF1cHuOajOOzoq4U7v/ig1mpRjqV+Bu1U=
+github.com/sagikazarmark/slog-shim v0.1.0 h1:diDBnUNK9N/354PgrxMywXnAwEr1QZcOr6gto+ugjYE=
+github.com/sagikazarmark/slog-shim v0.1.0/go.mod h1:SrcSrq8aKtyuqEI1uvTDTK1arOWRIczQRv+GVI1AkeQ=
+github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
+github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
+github.com/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo=
+github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0=
+github.com/spf13/afero v1.10.0 h1:EaGW2JJh15aKOejeuJ+wpFSHnbd7GE6Wvp3TsNhb6LY=
+github.com/spf13/afero v1.10.0/go.mod h1:UBogFpq8E9Hx+xc5CNTTEpTnuHVmXDwZcZcE1eb/UhQ=
+github.com/spf13/cast v1.5.1 h1:R+kOtfhWQE6TVQzY+4D7wJLBgkdVasCEFxSUBYBYIlA=
+github.com/spf13/cast v1.5.1/go.mod h1:b9PdjNptOpzXr7Rq1q9gJML/2cdGQAo69NKzQ10KN48=
+github.com/spf13/pflag v1.0.6 h1:jFzHGLGAlb3ruxLB8MhbI6A8+AQX/2eW4qeyNZXNp2o=
+github.com/spf13/pflag v1.0.6/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+github.com/spf13/viper v1.17.0 h1:I5txKw7MJasPL/BrfkbA0Jyo/oELqVmux4pR/UxOMfI=
+github.com/spf13/viper v1.17.0/go.mod h1:BmMMMLQXSbcHK6KAOiFLz0l5JHrU89OdIRHvsk0+yVI=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
+github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
+github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
+github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
+github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
+github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
+github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
+github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
+github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
+github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
+github.com/twitchyliquid64/golang-asm v0.15.1 h1:SU5vSMR7hnwNxj24w34ZyCi/FmDZTkS4MhqMhdFk5YI=
+github.com/twitchyliquid64/golang-asm v0.15.1/go.mod h1:a1lVb/DtPvCB8fslRZhAngC2+aY1QWCk3Cedj/Gdt08=
+github.com/ugorji/go/codec v1.2.12 h1:9LC83zGrHhuUA9l16C9AHXAqEV/2wBQ4nkvumAE65EE=
+github.com/ugorji/go/codec v1.2.12/go.mod h1:UNopzCgEMSXjBc6AOMqYvWC1ktqTAfzJZUZgYf6w6lg=
+github.com/yuin/goldmark v1.1.25/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.1.32/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.opencensus.io v0.22.0/go.mod h1:+kGneAE2xo2IficOXnaByMWTGM9T73dGwxeWcUqIpI8=
+go.opencensus.io v0.22.2/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.3/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.4/go.mod h1:yxeiOL68Rb0Xd1ddK5vPZ/oVn4vY4Ynel7k9FzqtOIw=
+go.opencensus.io v0.22.5/go.mod h1:5pWMHQbX5EPX2/62yrJeAkowc+lfs/XD7Uxpq3pI6kk=
+go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0=
+go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y=
+golang.org/x/arch v0.0.0-20210923205945-b76863e36670/go.mod h1:5om86z9Hs0C8fWVUuoMHwpExlXzs5Tkyp9hOrfG7pp8=
+golang.org/x/arch v0.8.0 h1:3wRIsP3pM4yUptoR96otTUOXI367OS0+c9eeRi9doIc=
+golang.org/x/arch v0.8.0/go.mod h1:FEVrYAQjsQXMVJ1nsMoVVXPZg6p2JE2mx8psSWTDQys=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190510104115-cbcb75029529/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
+golang.org/x/crypto v0.0.0-20210421170649-83a5a9bb288b/go.mod h1:T9bdIzuCu7OtxOm1hfPfRQxPLYneinmdGuTeoZ9dtd4=
+golang.org/x/crypto v0.0.0-20220722155217-630584e8d5aa/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4=
+golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
+golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8=
+golang.org/x/exp v0.0.0-20190829153037-c13cbed26979/go.mod h1:86+5VVa7VpoJ4kLfm080zCjGlMRFzhUhsZKEZO7MGek=
+golang.org/x/exp v0.0.0-20191030013958-a1ab85dbe136/go.mod h1:JXzH8nQsPlswgeRAPE3MuO9GYsAcnJvJ4vnMwN/5qkY=
+golang.org/x/exp v0.0.0-20191129062945-2f5052295587/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20191227195350-da58074b4299/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u096TMicItID8zy7Y6sNkU49FU4=
+golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM=
+golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU=
+golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6 h1:y5zboxd6LQAqYIhHnB48p0ByQ/GnQx2BE33L8BOHQkI=
+golang.org/x/exp v0.0.0-20250506013437-ce4c2cf36ca6/go.mod h1:U6Lno4MTRCDY+Ba7aCcauB9T60gsv5s4ralQzP72ZoQ=
+golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js=
+golang.org/x/image v0.0.0-20190802002840-cff245a6509b/go.mod h1:FeLwcggjj3mMvU+oOTbSwawSJRM1uh48EjtB4UJZlP0=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190909230951-414d861bb4ac/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20191125180803-fdd1cda4f05f/go.mod h1:5qLYkcX4OjUUV8bRuDixDT3tpyyb+LUpUlRWLxfhWrs=
+golang.org/x/lint v0.0.0-20200130185559-910be7a94367/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20200302205851-738671d3881b/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/lint v0.0.0-20201208152925-83fdc39ff7b5/go.mod h1:3xt1FjdF8hUf6vQPIChWIBhFzV8gjjsPE/fR3IyQdNY=
+golang.org/x/mobile v0.0.0-20190312151609-d3739f865fa6/go.mod h1:z+o9i4GpDbdi3rU15maQ/Ox0txvL9dWGYEHz965HBQE=
+golang.org/x/mobile v0.0.0-20190719004257-d2bd2a29d028/go.mod h1:E/iHnbuqvinMTCcRqshq8CkpyQDoeVncDDYHnLhea+o=
+golang.org/x/mod v0.0.0-20190513183733-4bf6d317e70e/go.mod h1:mXi4GBBbnImb6dmsKGUJ2LatrhH/nqhxcFungHvyanc=
+golang.org/x/mod v0.1.0/go.mod h1:0QHyrYULN0/3qlju5TqG8bIK38QM8yzMo5ekMj3DlcY=
+golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.1.1-0.20191107180719-034126e5016b/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg=
+golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/mod v0.4.1/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190501004415-9ce7a6920f09/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20190724013045-ca1201d0de80/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20191209160850-c0dbc17a3553/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200202094626-16171245cfb2/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200222125558-5a598a2470a0/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20200324143707-d3edc9973b7e/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200501053045-e0ff5e5a1de5/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200506145744-7e3656a0809f/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200513185701-a91f0712d120/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200520182314-0ba52f642ac2/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
+golang.org/x/net v0.0.0-20200625001655-4c5254603344/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200707034311-ab3426394381/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201031054903-ff519b6c9102/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
+golang.org/x/net v0.0.0-20201209123823-ac852fbbde11/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20201224014010-6772e930b67b/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y=
+golang.org/x/net v0.39.0 h1:ZCu7HMWDxpXpaiKdhzIfaltL9Lp31x/3fCP11bc6/fY=
+golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20191202225959-858c2ad4c8b6/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20200902213428-5d25da1a8d43/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20201109201403-9fd604954f58/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20201208152858-08078c50e5b5/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/oauth2 v0.0.0-20210218202405-ba52d332ba99/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200317015054-43a5402ce75a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ=
+golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190312061237-fead79001313/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190502145724-3ef323f4f1fd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190624142023-c5567b49c5d0/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190726091711-fc99dfbffb4e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191001151750-bb3f8db39f24/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191204072324-ce4227a45e2e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20191228213918-04cbcbbfeed8/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200113162924-86b910548bc1/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200122134326-e047566fdf82/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200202164722-d101bd2416d5/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200212091648-12a6c2dcc1e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200302150141-5c8b2ff67527/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200331124033-c3d80250170d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200501052902-10377860bb8e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200511232937-7e40ca221e25/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200515095857-1151b9dac4a9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200523222454-059865788121/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200803210538-64077c9b5642/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200905004654-be1d3432aa8f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20201201145000-ef89a241ccb3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210104204734-6f8348627aad/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210119212857-b64e53b001e4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210225134936-a50acf3fe073/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423082822-04245dca01da/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210423185535-09eb48e85fd7/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
+golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
+golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312151545-0bb0c0a6e846/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190621195816-6e04913cbbac/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190628153133-6cdbf07be9d0/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc=
+golang.org/x/tools v0.0.0-20190816200558-6889da9d5479/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20190911174233-4f2ddba30aff/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191012152004-8de300cfc20a/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191113191852-77e3bb0ad9e7/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191115202509-3a792d9c32b2/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191125144606-a911d9008d1f/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191130070609-6e064ea0cf2d/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.0.0-20191216173652-a0e659d51361/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20191227053925-7b8e75db28f4/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200117161641-43d50277825c/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200122220014-bf1340f18c4a/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200130002326-2f3ba24bd6e7/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200204074204-1cc6d1ef6c74/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200207183749-b753a1ba74fa/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200212150539-ea181f53ac56/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200224181240-023911ca70b2/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200227222343-706bc42d1f0d/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28=
+golang.org/x/tools v0.0.0-20200304193943-95d2e580d8eb/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200312045724-11d5b4c81c7d/go.mod h1:o4KQGtdN14AW+yjsvvwRTJJuXz8XRtIHtEnmAXLyFUw=
+golang.org/x/tools v0.0.0-20200331025713-a30bf2db82d4/go.mod h1:Sl4aGygMT6LrqrWclx+PTx3U+LnKx/seiNR+3G19Ar8=
+golang.org/x/tools v0.0.0-20200501065659-ab2804fb9c9d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200512131952-2bc93b1c0c88/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200515010526-7d3b6ebf133d/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200618134242-20370b0cb4b2/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
+golang.org/x/tools v0.0.0-20200729194436-6467de6f59a7/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200804011535-6c149bb5ef0d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200825202427-b303f430e36d/go.mod h1:njjCfa9FT2d7l9Bc6FUM5FLjQPp3cFF28FI3qnDFljA=
+golang.org/x/tools v0.0.0-20200904185747-39188db58858/go.mod h1:Cj7w3i3Rnn0Xh82ur9kSqwfTHTeVxaDqrfMjpcNT6bE=
+golang.org/x/tools v0.0.0-20201110124207-079ba7bd75cd/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201201161351-ac6f37ff4c2a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20201208233053-a543418bbed2/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210105154028-b0ab187a4818/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.0.0-20210108195828-e2f9c7f1fc8e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
+golang.org/x/tools v0.1.0/go.mod h1:xkSsbof2nBLbhDlRMhhhyNLN/zl3eTqcnHD5viDpcZ0=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.7.0/go.mod h1:WtwebWUNSVBH/HAw79HIFXZNqEvBhG+Ra+ax0hx3E3M=
+google.golang.org/api v0.8.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.9.0/go.mod h1:o4eAsZoiT+ibD93RtjEohWalFOjRDx6CVaqeizhEnKg=
+google.golang.org/api v0.13.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.14.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.15.0/go.mod h1:iLdEw5Ide6rF15KTC1Kkl0iskquN2gFfn9o9XIsbkAI=
+google.golang.org/api v0.17.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.18.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.19.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.20.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.22.0/go.mod h1:BwFmGc8tA3vsd7r/7kR8DY7iEEGSU04BFxCo5jP/sfE=
+google.golang.org/api v0.24.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.28.0/go.mod h1:lIXQywCXRcnZPGlsd8NbLnOjtAoL6em04bJ9+z0MncE=
+google.golang.org/api v0.29.0/go.mod h1:Lcubydp8VUV7KeIHD9z2Bys/sm/vGKnG1UHuDBSrHWM=
+google.golang.org/api v0.30.0/go.mod h1:QGmEvQ87FHZNiUVJkT14jQNYJ4ZJjdRF23ZXz5138Fc=
+google.golang.org/api v0.35.0/go.mod h1:/XrVsuzM0rZmrsbjJutiuftIzeuTQcEeaYcSk/mQ1dg=
+google.golang.org/api v0.36.0/go.mod h1:+z5ficQTmoYpPn8LCUNVpK5I7hwkpjbcgqA7I34qYtE=
+google.golang.org/api v0.40.0/go.mod h1:fYKFpnQN0DsDSKRVRcQSDQNtqWPfM9i+zNPxepjRCQ8=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0=
+google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.6/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190425155659-357c62f0e4bb/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190801165951-fa694d86fc64/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/genproto v0.0.0-20190911173649-1774047e7e51/go.mod h1:IbNlFCBrqXvoKpeg0TB2l7cyZUmoaFKYIwrEpbDKLA8=
+google.golang.org/genproto v0.0.0-20191108220845-16a3f7862a1a/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191115194625-c23dd37a84c9/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191216164720-4f79533eabd1/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20191230161307-f3c370f40bfb/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200115191322-ca5a22157cba/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200122232147-0452cf42e150/go.mod h1:n3cpQtvxv34hfy77yVDNjmbRyujviMdxYliBSkLhpCc=
+google.golang.org/genproto v0.0.0-20200204135345-fa8e72b47b90/go.mod h1:GmwEX6Z4W5gMy59cAlVYjN9JhxgbQH6Gn+gFDQe2lzA=
+google.golang.org/genproto v0.0.0-20200212174721-66ed5ce911ce/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200224152610-e50cd9704f63/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200228133532-8c2c7df3a383/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200305110556-506484158171/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200312145019-da6875a35672/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200331122359-1ee6d9798940/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200430143042-b979b6f78d84/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200511104702-f5ebc3bea380/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
+google.golang.org/genproto v0.0.0-20200515170657-fc4c6c6a6587/go.mod h1:YsZOwe1myG/8QRHRsmBRE1LrgQY60beZKjly0O1fX9U=
+google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
+google.golang.org/genproto v0.0.0-20200618031413-b414f8b61790/go.mod h1:jDfRM7FcilCzHH/e9qn6dsT145K34l5v+OpcnNgKAAA=
+google.golang.org/genproto v0.0.0-20200729003335-053ba62fc06f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200804131852-c06518451d9c/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200825200019-8632dd797987/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20200904004341-0bd0a958aa1d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201109203340-2640f1f9cdfb/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201201144952-b05cb90ed32e/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201210142538-e3217bee35cc/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20201214200347-8c77b98c765d/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210108203827-ffc7fda8c3d7/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/genproto v0.0.0-20210226172003-ab064af71705/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.21.1/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+google.golang.org/grpc v1.26.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.27.1/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
+google.golang.org/grpc v1.28.0/go.mod h1:rpkK4SK4GF4Ach/+MFLZUBavHOvF2JJB5uozKKal+60=
+google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
+google.golang.org/grpc v1.30.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.0/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.31.1/go.mod h1:N36X2cJ7JwdamYAgDz+s+rVMFjt3numwzf/HckM8pak=
+google.golang.org/grpc v1.33.2/go.mod h1:JMHMWHQWaTccqQQlmk3MJZS+GWXOdAesneDmEnv2fbc=
+google.golang.org/grpc v1.34.0/go.mod h1:WotjhfgOW/POjDeRt8vscBtXq+2VjORFy659qA51WJ8=
+google.golang.org/grpc v1.35.0/go.mod h1:qjiiYl8FncCW8feJPdyg3v6XW24KsRHe+dy9BAGRRjU=
+google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
+google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
+google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
+google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
+google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
+google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
+google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
+google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
+google.golang.org/protobuf v1.36.6 h1:z1NpPI8ku2WgiWnf+t9wTPsn6eP1L7ksHUlkfLvd9xY=
+google.golang.org/protobuf v1.36.6/go.mod h1:jduwjTPXsFjZGTmRluh+L6NjiWu7pchiJ2/5YcXBHnY=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
+gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
+gopkg.in/ini.v1 v1.67.0 h1:Dgnx+6+nfE+IfzjUEISNeydPJh9AXNNsWbGP9KzCsOA=
+gopkg.in/ini.v1 v1.67.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k=
+gopkg.in/tomb.v2 v2.0.0-20161208151619-d5d1b5820637 h1:yiW+nvdHb9LVqSHQBXfZCieqV4fzYhNBql77zY0ykqs=
+gopkg.in/tomb.v2 v2.0.0-20161208151619-d5d1b5820637/go.mod h1:BHsqpu/nsuzkT5BpiH1EMZPLyqSMM8JbIavyFACoFNk=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
+gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
+gorm.io/driver/mysql v1.5.7 h1:MndhOPYOfEp2rHKgkZIhJ16eVUIRf2HmzgoPmh7FCWo=
+gorm.io/driver/mysql v1.5.7/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM=
+gorm.io/driver/postgres v1.5.11 h1:ubBVAfbKEUld/twyKZ0IYn9rSQh448EdelLYk9Mv314=
+gorm.io/driver/postgres v1.5.11/go.mod h1:DX3GReXH+3FPWGrrgffdvCk3DQ1dwDPdmbenSkweRGI=
+gorm.io/driver/sqlite v1.5.7 h1:8NvsrhP0ifM7LX9G4zPB97NwovUakUxc+2V2uuf3Z1I=
+gorm.io/driver/sqlite v1.5.7/go.mod h1:U+J8craQU6Fzkcvu8oLeAQmi50TkwPEhHDEjQZXDah4=
+gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
+gorm.io/gorm v1.26.1 h1:ghB2gUI9FkS46luZtn6DLZ0f6ooBJ5IbVej2ENFDjRw=
+gorm.io/gorm v1.26.1/go.mod h1:8Z33v652h4//uMA76KjeDH8mJXPm1QNCYrMeatR0DOE=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.1-2019.2.3/go.mod h1:a3bituU0lyd329TUQxRnasdCoJDkEUEAqEt0JzvZhAg=
+honnef.co/go/tools v0.0.1-2020.1.3/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+honnef.co/go/tools v0.0.1-2020.1.4/go.mod h1:X/FiERA/W4tHapMX5mGpAtMSVEeEUOyHaw9vFzvIQ3k=
+nullprogram.com/x/optparse v1.0.0/go.mod h1:KdyPE+Igbe0jQUrVfMqDMeJQIJZEuyV7pjYmp6pbG50=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=
+rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
+rsc.io/quote/v3 v3.1.0/go.mod h1:yEA65RcK8LyAZtP9Kv3t0HmxON59tX3rD+tICJqUlj0=
+rsc.io/sampler v1.3.0/go.mod h1:T1hPZKmBbMNahiBKFy5HrXp6adAjACjK9JXDnKaTXpA=
diff --git a/internal/adapter/persistence/role_repository.go b/internal/adapter/persistence/role_repository.go
new file mode 100644
index 0000000..5ab3bf9
--- /dev/null
+++ b/internal/adapter/persistence/role_repository.go
@@ -0,0 +1,54 @@
+package persistence
+
+import (
+	"context"
+	"errors"
+	"starter-kit/internal/domain/role"
+
+	"gorm.io/gorm"
+)
+
+type roleRepository struct {
+	db *gorm.DB
+}
+
+// NewRoleRepository tạo mới một instance của RoleRepository
+func NewRoleRepository(db *gorm.DB) role.Repository {
+	return &roleRepository{db: db}
+}
+
+func (r *roleRepository) Create(ctx context.Context, role *role.Role) error {
+	return r.db.WithContext(ctx).Create(role).Error
+}
+
+func (r *roleRepository) GetByID(ctx context.Context, id int) (*role.Role, error) {
+	var role role.Role
+	err := r.db.WithContext(ctx).First(&role, id).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	return &role, err
+}
+
+func (r *roleRepository) GetByName(ctx context.Context, name string) (*role.Role, error) {
+	var role role.Role
+	err := r.db.WithContext(ctx).First(&role, "name = ?", name).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	return &role, err
+}
+
+func (r *roleRepository) List(ctx context.Context) ([]*role.Role, error) {
+	var roles []*role.Role
+	err := r.db.WithContext(ctx).Find(&roles).Error
+	return roles, err
+}
+
+func (r *roleRepository) Update(ctx context.Context, role *role.Role) error {
+	return r.db.WithContext(ctx).Save(role).Error
+}
+
+func (r *roleRepository) Delete(ctx context.Context, id int) error {
+	return r.db.WithContext(ctx).Delete(&role.Role{}, id).Error
+}
diff --git a/internal/adapter/persistence/user_repository.go b/internal/adapter/persistence/user_repository.go
new file mode 100644
index 0000000..e0ab787
--- /dev/null
+++ b/internal/adapter/persistence/user_repository.go
@@ -0,0 +1,106 @@
+package persistence
+
+import (
+	"context"
+	"errors"
+	"starter-kit/internal/domain/role"
+	"starter-kit/internal/domain/user"
+
+	"gorm.io/gorm"
+)
+
+type userRepository struct {
+	db *gorm.DB
+}
+
+// NewUserRepository tạo mới một instance của UserRepository
+func NewUserRepository(db *gorm.DB) user.Repository {
+	return &userRepository{db: db}
+}
+
+func (r *userRepository) Create(ctx context.Context, u *user.User) error {
+	return r.db.WithContext(ctx).Create(u).Error
+}
+
+func (r *userRepository) GetByID(ctx context.Context, id string) (*user.User, error) {
+	var u user.User
+	// First get the user
+	err := r.db.WithContext(ctx).Where("`users`.`id` = ? AND `users`.`deleted_at` IS NULL", id).First(&u).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	
+	// Manually preload roles with the exact SQL format expected by tests
+	var roles []*role.Role
+	err = r.db.WithContext(ctx).Raw(
+		"SELECT * FROM `roles` JOIN `user_roles` ON `user_roles`.`role_id` = `roles`.`id` WHERE `user_roles`.`user_id` = ? AND `roles`.`deleted_at` IS NULL",
+		id,
+	).Scan(&roles).Error
+	
+	if err != nil {
+		return nil, err
+	}
+	
+	u.Roles = roles
+	return &u, nil
+}
+
+func (r *userRepository) GetByUsername(ctx context.Context, username string) (*user.User, error) {
+	var u user.User
+	err := r.db.WithContext(ctx).Preload("Roles").First(&u, "username = ?", username).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	return &u, err
+}
+
+func (r *userRepository) GetByEmail(ctx context.Context, email string) (*user.User, error) {
+	var u user.User
+	err := r.db.WithContext(ctx).Preload("Roles").First(&u, "email = ?", email).Error
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, nil
+	}
+	return &u, err
+}
+
+func (r *userRepository) Update(ctx context.Context, u *user.User) error {
+	return r.db.WithContext(ctx).Save(u).Error
+}
+
+func (r *userRepository) Delete(ctx context.Context, id string) error {
+	return r.db.WithContext(ctx).Delete(&user.User{}, "id = ?", id).Error
+}
+
+func (r *userRepository) AddRole(ctx context.Context, userID string, roleID int) error {
+	return r.db.WithContext(ctx).Exec(
+		"INSERT INTO `user_roles` (`user_id`, `role_id`) VALUES (?, ?) ON CONFLICT DO NOTHING",
+		userID, roleID,
+	).Error
+}
+
+func (r *userRepository) RemoveRole(ctx context.Context, userID string, roleID int) error {
+	return r.db.WithContext(ctx).Exec(
+		"DELETE FROM user_roles WHERE user_id = ? AND role_id = ?",
+		userID, roleID,
+	).Error
+}
+
+func (r *userRepository) HasRole(ctx context.Context, userID string, roleID int) (bool, error) {
+	var count int64
+	err := r.db.WithContext(ctx).Model(&user.User{}).
+		Joins("JOIN user_roles ON user_roles.user_id = users.id").
+		Where("users.id = ? AND user_roles.role_id = ?", userID, roleID).
+		Count(&count).Error
+
+	return count > 0, err
+}
+
+func (r *userRepository) UpdateLastLogin(ctx context.Context, userID string) error {
+	now := gorm.Expr("NOW()")
+	return r.db.WithContext(ctx).Model(&user.User{}).
+		Where("id = ?", userID).
+		Update("last_login_at", now).Error
+}
diff --git a/internal/domain/role/repository.go b/internal/domain/role/repository.go
new file mode 100644
index 0000000..85b52d9
--- /dev/null
+++ b/internal/domain/role/repository.go
@@ -0,0 +1,24 @@
+package role
+
+import "context"
+
+// Repository định nghĩa các phương thức làm việc với dữ liệu vai trò
+type Repository interface {
+	// Create tạo mới vai trò
+	Create(ctx context.Context, role *Role) error
+	
+	// GetByID lấy thông tin vai trò theo ID
+	GetByID(ctx context.Context, id int) (*Role, error)
+	
+	// GetByName lấy thông tin vai trò theo tên
+	GetByName(ctx context.Context, name string) (*Role, error)
+	
+	// List lấy danh sách vai trò
+	List(ctx context.Context) ([]*Role, error)
+	
+	// Update cập nhật thông tin vai trò
+	Update(ctx context.Context, role *Role) error
+	
+	// Delete xóa vai trò
+	Delete(ctx context.Context, id int) error
+}
diff --git a/internal/domain/role/role.go b/internal/domain/role/role.go
new file mode 100644
index 0000000..5c38ae0
--- /dev/null
+++ b/internal/domain/role/role.go
@@ -0,0 +1,25 @@
+package role
+
+import "time"
+
+// Role đại diện cho một vai trò trong hệ thống
+type Role struct {
+	ID          int       `json:"id" gorm:"primaryKey"`
+	Name        string    `json:"name" gorm:"size:50;uniqueIndex;not null"`
+	Description string    `json:"description"`
+	CreatedAt   time.Time `json:"created_at" gorm:"autoCreateTime"`
+	UpdatedAt   time.Time `json:"updated_at" gorm:"autoUpdateTime"`
+}
+
+// TableName specifies the table name for the Role model
+func (Role) TableName() string {
+	return "roles"
+}
+
+// Constants for role names
+const (
+	Admin   = "admin"
+	Manager = "manager"
+	User    = "user"
+	Guest   = "guest"
+)
diff --git a/internal/domain/user/repository.go b/internal/domain/user/repository.go
new file mode 100644
index 0000000..dca8f7d
--- /dev/null
+++ b/internal/domain/user/repository.go
@@ -0,0 +1,38 @@
+package user
+
+import (
+	"context"
+)
+
+// Repository định nghĩa các phương thức làm việc với dữ liệu người dùng
+type Repository interface {
+	// Create tạo mới người dùng
+	Create(ctx context.Context, user *User) error
+	
+	// GetByID lấy thông tin người dùng theo ID
+	GetByID(ctx context.Context, id string) (*User, error)
+	
+	// GetByUsername lấy thông tin người dùng theo tên đăng nhập
+	GetByUsername(ctx context.Context, username string) (*User, error)
+	
+	// GetByEmail lấy thông tin người dùng theo email
+	GetByEmail(ctx context.Context, email string) (*User, error)
+	
+	// Update cập nhật thông tin người dùng
+	Update(ctx context.Context, user *User) error
+	
+	// Delete xóa người dùng
+	Delete(ctx context.Context, id string) error
+	
+	// AddRole thêm vai trò cho người dùng
+	AddRole(ctx context.Context, userID string, roleID int) error
+	
+	// RemoveRole xóa vai trò của người dùng
+	RemoveRole(ctx context.Context, userID string, roleID int) error
+	
+	// HasRole kiểm tra người dùng có vai trò không
+	HasRole(ctx context.Context, userID string, roleID int) (bool, error)
+	
+	// UpdateLastLogin cập nhật thời gian đăng nhập cuối cùng
+	UpdateLastLogin(ctx context.Context, userID string) error
+}
diff --git a/internal/domain/user/user.go b/internal/domain/user/user.go
new file mode 100644
index 0000000..d50ab43
--- /dev/null
+++ b/internal/domain/user/user.go
@@ -0,0 +1,50 @@
+package user
+
+import (
+	"time"
+
+	"starter-kit/internal/domain/role"
+)
+
+// User đại diện cho một người dùng trong hệ thống
+type User struct {
+	ID           string     `json:"id" gorm:"type:uuid;primaryKey;default:uuid_generate_v4()"`
+	Username     string     `json:"username" gorm:"size:50;uniqueIndex;not null"`
+	Email        string     `json:"email" gorm:"size:100;uniqueIndex;not null"`
+	PasswordHash string     `json:"-" gorm:"not null"`
+	FullName     string     `json:"full_name" gorm:"size:100"`
+	AvatarURL    string     `json:"avatar_url,omitempty" gorm:"size:255"`
+	IsActive     bool       `json:"is_active" gorm:"default:true"`
+	LastLoginAt  *time.Time `json:"last_login_at,omitempty"`
+	CreatedAt    time.Time  `json:"created_at" gorm:"autoCreateTime"`
+	UpdatedAt    time.Time  `json:"updated_at" gorm:"autoUpdateTime"`
+	DeletedAt    *time.Time `json:"-" gorm:"index"`
+	Roles        []*role.Role `json:"roles,omitempty" gorm:"many2many:user_roles;"`
+}
+
+// TableName specifies the table name for the User model
+func (User) TableName() string {
+	return "users"
+}
+
+// HasRole kiểm tra xem user có vai trò được chỉ định không
+func (u *User) HasRole(roleName string) bool {
+	for _, r := range u.Roles {
+		if r.Name == roleName {
+			return true
+		}
+	}
+	return false
+}
+
+// HasAnyRole kiểm tra xem user có bất kỳ vai trò nào trong danh sách không
+func (u *User) HasAnyRole(roles ...string) bool {
+	for _, r := range u.Roles {
+		for _, roleName := range roles {
+			if r.Name == roleName {
+				return true
+			}
+		}
+	}
+	return false
+}
diff --git a/internal/helper/config/load.go b/internal/helper/config/load.go
new file mode 100644
index 0000000..64eed47
--- /dev/null
+++ b/internal/helper/config/load.go
@@ -0,0 +1,131 @@
+package config
+
+import (
+	"fmt"
+	"os"
+	"strings"
+
+	"github.com/go-playground/validator/v10"
+	"github.com/joho/godotenv"
+	"github.com/spf13/viper"
+)
+
+const (
+	envFile = "./.env"
+)
+
+// ConfigLoader định nghĩa interface để load cấu hình
+type ConfigLoader interface {
+	Load() (*Config, error)
+}
+
+// ViperConfigLoader triển khai ConfigLoader với Viper
+type ViperConfigLoader struct {
+	configPaths []string
+	configName  string
+	configType  string
+	envPrefix   string
+}
+
+// NewConfigLoader tạo ConfigLoader mới với các giá trị mặc định
+func NewConfigLoader() ConfigLoader {
+	return &ViperConfigLoader{
+		configPaths: []string{"./configs", ".", "./templates"},
+		configName:  "config",
+		configType:  "yaml",
+		envPrefix:   "APP",
+	}
+}
+
+func (l *ViperConfigLoader) Load() (*Config, error) {
+	v := viper.New()
+	v.SetConfigName(l.configName)
+	v.SetConfigType(l.configType)
+
+	// Thêm các đường dẫn tìm kiếm file cấu hình
+	for _, path := range l.configPaths {
+		v.AddConfigPath(path)
+	}
+
+	// 1. Đọc file cấu hình chính (bắt buộc)
+	if err := v.ReadInConfig(); err != nil {
+		return nil, fmt.Errorf("failed to read config file: %w (searched in: %v)", err, l.configPaths)
+	}
+
+	// 2. Đọc từ file .env nếu tồn tại (tùy chọn)
+	if err := l.loadEnvFile(v); err != nil {
+		return nil, fmt.Errorf("error loading .env file: %w", err)
+	}
+
+	// 3. Cấu hình đọc biến môi trường (có thể ghi đè các giá trị từ file)
+	v.AutomaticEnv()
+	v.SetEnvPrefix(l.envPrefix)
+	v.SetEnvKeyReplacer(strings.NewReplacer(".", "_", "-", "_"))
+
+	// 4. Đặt các giá trị mặc định tối thiểu
+	setDefaultValues(v)
+
+	// Bind cấu hình vào struct
+	var config Config
+	if err := v.Unmarshal(&config); err != nil {
+		return nil, fmt.Errorf("unable to decode config into struct: %w", err)
+	}
+
+	// Validate cấu hình
+	if err := validateConfig(&config); err != nil {
+		return nil, fmt.Errorf("config validation error: %w", err)
+	}
+
+	return &config, nil
+}
+
+// loadEnvFile đọc và xử lý file .env
+func (l *ViperConfigLoader) loadEnvFile(v *viper.Viper) error {
+	if _, err := os.Stat(envFile); os.IsNotExist(err) {
+		return nil // Không có file .env cũng không phải lỗi
+	}
+
+	envMap, err := godotenv.Read(envFile)
+	if err != nil {
+		return fmt.Errorf("error parsing .env file: %w", err)
+	}
+
+	for key, val := range envMap {
+		if key == "" {
+			continue
+		}
+
+		// Chuyển đổi key từ DB_PASSWORD thành database.password
+		if parts := strings.SplitN(key, "_", 2); len(parts) == 2 {
+			prefix := strings.ToLower(parts[0])
+			suffix := strings.ReplaceAll(parts[1], "_", ".")
+			v.Set(fmt.Sprintf("%s.%s", prefix, suffix), val)
+		}
+
+		// Lưu giá trị gốc cho tương thích ngược
+		v.Set(key, val)
+		if err := os.Setenv(key, val); err != nil {
+			return fmt.Errorf("failed to set environment variable %s: %w", key, err)
+		}
+	}
+
+	return nil
+}
+
+// setDefaultValues thiết lập các giá trị mặc định tối thiểu cần thiết
+// Lưu ý: Hầu hết các giá trị mặc định nên được định nghĩa trong file config.yaml
+func setDefaultValues(v *viper.Viper) {
+	// Chỉ đặt các giá trị mặc định thực sự cần thiết ở đây
+	// Các giá trị khác sẽ được lấy từ file config.yaml bắt buộc
+	v.SetDefault("app.environment", "development")
+	v.SetDefault("log_level", "info")
+}
+
+// validateConfig xác thực cấu hình sử dụng thẻ validate
+func validateConfig(config *Config) error {
+	validate := validator.New()
+	if err := validate.Struct(config); err != nil {
+		return fmt.Errorf("config validation failed: %w", err)
+	}
+	return nil
+}
diff --git a/internal/helper/config/types.go b/internal/helper/config/types.go
new file mode 100644
index 0000000..bf24b82
--- /dev/null
+++ b/internal/helper/config/types.go
@@ -0,0 +1,100 @@
+package config
+
+import (
+	"strings"
+
+	"github.com/mitchellh/mapstructure"
+)
+
+// AppConfig chứa thông tin cấu hình của ứng dụng
+type AppConfig struct {
+	Name        string `mapstructure:"name" validate:"required"`
+	Version     string `mapstructure:"version" validate:"required"`
+	Environment string `mapstructure:"environment" validate:"required,oneof=development staging production"`
+	Timezone    string `mapstructure:"timezone" validate:"required"`
+}
+
+// ServerConfig chứa thông tin cấu hình server
+type ServerConfig struct {
+	Host            string   `mapstructure:"host" validate:"required"`
+	Port            int      `mapstructure:"port" validate:"required,min=1,max=65535"`
+	ReadTimeout     int      `mapstructure:"read_timeout" validate:"required,min=1"`
+	WriteTimeout    int      `mapstructure:"write_timeout" validate:"required,min=1"`
+	ShutdownTimeout int      `mapstructure:"shutdown_timeout" validate:"required,min=1"`
+	TrustedProxies  []string `mapstructure:"trusted_proxies"`
+	AllowOrigins    []string `mapstructure:"allow_origins"`
+}
+
+// DatabaseConfig chứa thông tin cấu hình database
+type DatabaseConfig struct {
+	Driver          string `mapstructure:"driver" validate:"required,oneof=postgres mysql sqlite"`
+	Host            string `mapstructure:"host" validate:"required_if=Driver postgres,required_if=Driver mysql"`
+	Port            int    `mapstructure:"port" validate:"required_if=Driver postgres,required_if=Driver mysql,min=1,max=65535"`
+	Username        string `mapstructure:"username" validate:"required_if=Driver postgres,required_if=Driver mysql"`
+	Password        string `mapstructure:"password" validate:"required_if=Driver postgres,required_if=Driver mysql"`
+	Database        string `mapstructure:"database" validate:"required"`
+	SSLMode         string `mapstructure:"ssl_mode" validate:"omitempty,oneof=disable prefer require verify-ca verify-full"`
+	MaxOpenConns    int    `mapstructure:"max_open_conns" validate:"min=1"`
+	MaxIdleConns    int    `mapstructure:"max_idle_conns" validate:"min=1"`
+	ConnMaxLifetime int    `mapstructure:"conn_max_lifetime" validate:"min=1"`
+	MigrationPath   string `mapstructure:"migration_path" validate:"required"`
+}
+
+// JWTConfig chứa cấu hình cho JWT
+type JWTConfig struct {
+	Secret             string   `mapstructure:"secret" validate:"required,min=32"`
+	AccessTokenExpire  int      `mapstructure:"access_token_expire" validate:"required,min=1"`  // in minutes
+	RefreshTokenExpire int      `mapstructure:"refresh_token_expire" validate:"required,min=1"` // in days
+	Algorithm          string   `mapstructure:"algorithm" validate:"required,oneof=HS256 HS384 HS512 RS256"`
+	Issuer             string   `mapstructure:"issuer" validate:"required"`
+	Audience           []string `mapstructure:"audience" validate:"required,min=1"`
+}
+
+// Config là struct tổng thể chứa tất cả các cấu hình
+type Config struct {
+	App      AppConfig      `mapstructure:"app" validate:"required"`
+	Server   ServerConfig   `mapstructure:"server" validate:"required"`
+	Database DatabaseConfig `mapstructure:"database" validate:"required"`
+	Logger   LoggerConfig   `mapstructure:"logger" validate:"required"`
+	JWT      JWTConfig      `mapstructure:"jwt"`
+}
+
+// Get returns a value from the config by dot notation (e.g., "app.name")
+func (c *Config) Get(key string) interface{} {
+	parts := strings.Split(key, ".")
+	if len(parts) == 0 {
+		return nil
+	}
+
+	var current interface{} = *c
+	for _, part := range parts {
+		m, ok := current.(map[string]interface{})
+		if !ok {
+			// Try to convert struct to map using mapstructure
+			decoder, err := mapstructure.NewDecoder(&mapstructure.DecoderConfig{
+				TagName: "mapstructure",
+				Result:  &current,
+			})
+			if err != nil || decoder.Decode(current) != nil {
+				return nil
+			}
+			m, ok = current.(map[string]interface{})
+			if !ok {
+				return nil
+			}
+		}
+
+		val, exists := m[part]
+		if !exists {
+			return nil
+		}
+		current = val
+	}
+
+	return current
+}
+
+// LoggerConfig chứa cấu hình cho logger
+type LoggerConfig struct {
+	Level string `mapstructure:"level" validate:"required,oneof=debug info warn error"`
+}
diff --git a/internal/helper/database/database.go b/internal/helper/database/database.go
new file mode 100644
index 0000000..235ce4c
--- /dev/null
+++ b/internal/helper/database/database.go
@@ -0,0 +1,154 @@
+package database
+
+import (
+	"context"
+	"database/sql"
+	"fmt"
+	"sync"
+	"time"
+
+	"starter-kit/internal/helper/config"
+	"starter-kit/internal/helper/logger"
+
+	"github.com/sirupsen/logrus"
+	"gorm.io/driver/mysql"
+	"gorm.io/driver/postgres"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+)
+
+var (
+	// dbInstance is the singleton database instance
+	dbInstance *gorm.DB
+	dbOnce     sync.Once
+	dbErr      error
+)
+
+// Database wraps the database connection
+type Database struct {
+	DB     *gorm.DB
+	Config *config.DatabaseConfig
+	Logger *logrus.Logger
+}
+
+// NewConnection creates a new database connection based on configuration
+func NewConnection(cfg *config.DatabaseConfig) (*gorm.DB, error) {
+	dbOnce.Do(func() {
+		switch cfg.Driver {
+		case "postgres":
+			dsn := fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=%s",
+				cfg.Host, cfg.Port, cfg.Username, cfg.Password, cfg.Database, cfg.SSLMode)
+			dbInstance, dbErr = gorm.Open(postgres.Open(dsn), &gorm.Config{})
+
+		case "mysql":
+			dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True&loc=Local",
+				cfg.Username, cfg.Password, cfg.Host, cfg.Port, cfg.Database)
+			dbInstance, dbErr = gorm.Open(mysql.Open(dsn), &gorm.Config{})
+
+		case "sqlite":
+			dbInstance, dbErr = gorm.Open(sqlite.Open(cfg.Database), &gorm.Config{})
+
+		default:
+			dbErr = fmt.Errorf("unsupported database driver: %s", cfg.Driver)
+			return
+		}
+
+		if dbErr != nil {
+			dbErr = fmt.Errorf("failed to connect to database: %w", dbErr)
+			return
+		}
+
+		// Set connection pool settings
+		var sqlDB *sql.DB
+		sqlDB, dbErr = dbInstance.DB()
+		if dbErr != nil {
+			dbErr = fmt.Errorf("failed to get database instance: %w", dbErr)
+			return
+		}
+
+		sqlDB.SetMaxOpenConns(cfg.MaxOpenConns)
+		sqlDB.SetMaxIdleConns(cfg.MaxIdleConns)
+		sqlDB.SetConnMaxLifetime(time.Duration(cfg.ConnMaxLifetime) * time.Second)
+
+		logger.Info("Database connection established successfully")
+	})
+
+	return dbInstance, dbErr
+}
+
+// Close closes the database connection
+func Close() error {
+	if dbInstance == nil {
+		return nil
+	}
+
+	sqlDB, err := dbInstance.DB()
+	if err != nil {
+		return fmt.Errorf("failed to get database instance: %w", err)
+	}
+
+	if err := sqlDB.Close(); err != nil {
+		return fmt.Errorf("error closing database: %w", err)
+	}
+
+	logger.Info("Database connection closed")
+	return nil
+}
+
+// Migrate runs database migrations
+func Migrate(cfg config.DatabaseConfig) error {
+	_, err := NewConnection(&cfg)
+	if err != nil {
+		return fmt.Errorf("failed to connect to database: %w", err)
+	}
+
+	// TODO: Add your database migrations here
+	// Example: return dbInstance.AutoMigrate(&models.User{}, &models.Post{})
+	return nil
+}
+
+// GetDB returns the database instance
+func GetDB() *gorm.DB {
+	return dbInstance
+}
+
+// WithTransaction executes a function within a database transaction
+func WithTransaction(fn func(tx *gorm.DB) error) error {
+	tx := dbInstance.Begin()
+	if tx.Error != nil {
+		return tx.Error
+	}
+
+	defer func() {
+		if r := recover(); r != nil {
+			tx.Rollback()
+			panic(r)
+		}
+	}()
+
+	if err := fn(tx); err != nil {
+		if rbErr := tx.Rollback().Error; rbErr != nil {
+			return fmt.Errorf("tx: %v, rb err: %v", err, rbErr)
+		}
+		return err
+	}
+
+	return tx.Commit().Error
+}
+
+// HealthCheck checks if the database is reachable
+func HealthCheck() error {
+	if dbInstance == nil {
+		return fmt.Errorf("database not initialized")
+	}
+
+	sqlDB, err := dbInstance.DB()
+	if err != nil {
+		return fmt.Errorf("failed to get database instance: %w", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+	defer cancel()
+
+	return sqlDB.PingContext(ctx)
+}
diff --git a/internal/helper/feature/feature.go b/internal/helper/feature/feature.go
new file mode 100644
index 0000000..81e99cd
--- /dev/null
+++ b/internal/helper/feature/feature.go
@@ -0,0 +1,75 @@
+package feature
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"sync"
+)
+
+// FeatureFlag represents a feature flag configuration
+type FeatureFlag struct {
+	Enabled bool `json:"enabled"`
+}
+
+// featureFlags stores the feature flags
+var (
+	featureFlags = make(map[string]FeatureFlag)
+	mu           sync.RWMutex
+)
+
+// Feature flags
+const (
+	EnableDatabase = "enable_database"
+)
+
+// Init initializes feature flags
+func Init() error {
+	// Check if config file exists
+	configFile := ".feature-flags.json"
+	config, err := os.ReadFile(configFile)
+	if err != nil {
+		// File doesn't exist, create with default config
+		config = []byte(`{
+			"enable_database": {
+				"enabled": false
+			}
+		}`)
+		if err := os.WriteFile(configFile, config, 0644); err != nil {
+			return fmt.Errorf("failed to write default feature flags config: %w", err)
+		}
+	}
+
+	// Parse feature flags from JSON
+	var flags map[string]FeatureFlag
+	if err := json.Unmarshal(config, &flags); err != nil {
+		return fmt.Errorf("failed to parse feature flags: %w", err)
+	}
+
+	// Store feature flags
+	mu.Lock()
+	featureFlags = flags
+	mu.Unlock()
+
+	return nil
+}
+
+// IsEnabled checks if a feature flag is enabled
+func IsEnabled(flagKey string) bool {
+	mu.RLock()
+	defer mu.RUnlock()
+
+	flag, exists := featureFlags[flagKey]
+	if !exists {
+		return false
+	}
+	return flag.Enabled
+}
+
+// Close cleans up feature flag resources
+func Close() error {
+	mu.Lock()
+	defer mu.Unlock()
+	featureFlags = make(map[string]FeatureFlag)
+	return nil
+}
diff --git a/internal/helper/logger/README.md b/internal/helper/logger/README.md
new file mode 100644
index 0000000..7ad2e77
--- /dev/null
+++ b/internal/helper/logger/README.md
@@ -0,0 +1,118 @@
+# Logger Package
+
+A structured, high-performance logging package built on top of Logrus with the following features:
+
+## Features
+
+- **Structured Logging**: JSON and Text formats supported
+- **Level-based Logging**: Debug, Info, Warn, Error, Fatal, Panic, Trace
+- **Performance Optimized**: Low allocation design with sync.Pool
+- **Context Support**: Add request-scoped fields
+- **Caller Information**: Automatically include file and line numbers
+- **Multiple Outputs**: Stdout/Stderr separation
+- **Thread-safe**: Safe for concurrent use
+- **Customizable**: Various configuration options
+
+## Installation
+
+```go
+import "starter-kit/internal/helper/logger"
+```
+
+## Basic Usage
+
+### Initialization
+
+```go
+// Initialize with default configuration
+logger.Init(&logger.LogConfig{
+    Level:        "info",
+    Format:       "json",
+    EnableCaller: true,
+    ReportCaller: true,
+})
+```
+
+### Logging Messages
+
+```go
+// Simple logging
+logger.Info("Application started")
+logger.Debug("Debug information")
+logger.Warn("Warning message")
+logger.Error("Error occurred")
+
+// With fields
+logger.WithFields(logger.Fields{
+    "key": "value",
+    "num": 42,
+}).Info("Log with fields")
+
+// With error
+if err != nil {
+    logger.WithError(err).Error("Operation failed")
+}
+```
+
+## Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| Level | string | "info" | Log level (debug, info, warn, error, fatal, panic) |
+| Format | string | "json" | Output format (json, text) |
+| EnableCaller | bool | true | Include caller information |
+| BufferSize | int | 256 | Buffer size for async logging |
+| DisableColor | bool | false | Disable colored output (text format only) |
+| ReportCaller | bool | true | Report the calling method |
+
+## Best Practices
+
+1. **Use Appropriate Log Levels**:
+   - ERROR: Something failed, needs attention
+   - WARN: Unexpected but handled situation
+   - INFO: Important business process has started/ended
+   - DEBUG: Detailed information for debugging
+
+2. **Structured Logging**:
+   - Always use fields for structured data
+   - Keep log messages concise and consistent
+
+3. **Performance**:
+   - Use `WithFields` when logging multiple key-value pairs
+   - Avoid expensive operations in log statements
+
+## Example Output
+
+### JSON Format
+```json
+{
+  "@timestamp": "2023-04-01T12:00:00Z",
+  "level": "info",
+  "message": "Request processed",
+  "caller": "handler/user.go:42",
+  "method": "GET",
+  "path": "/api/users",
+  "status": 200,
+  "duration": 42.5,
+  "request_id": "abc123"
+}
+```
+
+### Text Format
+```
+INFO[0000] Request processed  caller=handler/user.go:42 method=GET path=/api/users status=200 duration=42.5 request_id=abc123
+```
+
+## Testing
+
+```bash
+# Run tests
+go test -v ./...
+
+# Run with race detector
+go test -race ./...
+```
+
+## License
+
+[MIT](LICENSE)
diff --git a/internal/helper/logger/logger.go b/internal/helper/logger/logger.go
new file mode 100644
index 0000000..b2359a6
--- /dev/null
+++ b/internal/helper/logger/logger.go
@@ -0,0 +1,291 @@
+package logger
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"runtime"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/sirupsen/logrus"
+)
+
+var (
+	// log is the global logger instance
+	log *logrus.Logger
+	// logMutex ensures thread-safe logger configuration
+	logMutex sync.RWMutex
+	// defaultFields are included in every log entry
+	defaultFields = logrus.Fields{
+		"app_name": "starter-kit",
+		"env":      os.Getenv("APP_ENV"),
+	}
+)
+
+// Buffer size for async logging
+const defaultBufferSize = 256
+
+// Fields is a type alias for logrus.Fields
+type Fields = logrus.Fields
+
+// LogConfig holds configuration for the logger
+type LogConfig struct {
+	Level        string `json:"level"`
+	Format       string `json:"format"`
+	EnableCaller bool   `json:"enable_caller"`
+	BufferSize   int    `json:"buffer_size"`
+	DisableColor bool   `json:"disable_color"`
+	ReportCaller bool   `json:"report_caller"`
+}
+
+// Init initializes the logger with the given configuration
+func Init(config *LogConfig) {
+	logMutex.Lock()
+	defer logMutex.Unlock()
+
+	// Create new logger instance
+	log = logrus.New()
+
+	// Set default values if config is nil
+	if config == nil {
+		config = &LogConfig{
+			Level:         "info",
+			Format:        "json",
+			EnableCaller:  true,
+			BufferSize:    defaultBufferSize,
+			DisableColor:  false,
+			ReportCaller:  true,
+		}
+	}
+
+	// Set log level
+	setLogLevel(config.Level)
+
+	// Set log formatter
+	setLogFormatter(config)
+	// Configure output
+	configureOutput()
+	// Add hooks
+	addHooks(config)
+}
+
+// configureOutput sets up the output writers
+func configureOutput() {
+	// Use async writer if buffer size > 0
+	log.SetOutput(io.Discard) // Discard logs by default
+
+	// Create multi-writer for stdout/stderr
+	log.AddHook(&writerHook{
+		Writer:    os.Stdout,
+		LogLevels: []logrus.Level{logrus.InfoLevel, logrus.DebugLevel},
+	})
+
+	log.AddHook(&writerHook{
+		Writer:    os.Stderr,
+		LogLevels: []logrus.Level{logrus.PanicLevel, logrus.FatalLevel, logrus.ErrorLevel, logrus.WarnLevel},
+	})
+}
+
+// setLogLevel configures the log level
+func setLogLevel(level string) {
+	lvl, err := logrus.ParseLevel(strings.ToLower(level))
+	if err != nil {
+		logrus.Warnf("Invalid log level '%s', defaulting to 'info'", level)
+		lvl = logrus.InfoLevel
+	}
+	log.SetLevel(lvl)
+}
+
+// setLogFormatter configures the log formatter
+func setLogFormatter(config *LogConfig) {
+	switch strings.ToLower(config.Format) {
+	case "text":
+		log.SetFormatter(&logrus.TextFormatter{
+			FullTimestamp:    true,
+			TimestampFormat:  time.RFC3339Nano,
+			DisableColors:    config.DisableColor,
+			CallerPrettyfier: callerPrettyfier,
+		})
+	default: // JSON format
+		log.SetFormatter(&logrus.JSONFormatter{
+			TimestampFormat:   time.RFC3339Nano,
+			DisableTimestamp:  false,
+			DisableHTMLEscape: true,
+			CallerPrettyfier:  callerPrettyfier,
+			FieldMap: logrus.FieldMap{
+				logrus.FieldKeyTime:  "@timestamp",
+				logrus.FieldKeyLevel: "level",
+				logrus.FieldKeyMsg:   "message",
+				logrus.FieldKeyFunc:  "caller",
+			},
+		})
+	}
+}
+
+// addHooks adds additional hooks to the logger
+func addHooks(config *LogConfig) {
+	// Add caller info hook if enabled
+	if config.EnableCaller || config.ReportCaller {
+		log.AddHook(&callerHook{})
+	}
+
+	// Add default fields hook
+	log.AddHook(&defaultFieldsHook{fields: defaultFields})
+}
+
+// writerHook sends logs to different writers based on level
+type writerHook struct {
+	Writer    io.Writer
+	LogLevels []logrus.Level
+}
+
+func (hook *writerHook) Fire(entry *logrus.Entry) error {
+	line, err := entry.Logger.Formatter.Format(entry)
+	if err != nil {
+		return err
+	}
+	_, err = hook.Writer.Write(line)
+	return err
+}
+
+func (hook *writerHook) Levels() []logrus.Level {
+	return hook.LogLevels
+}
+
+// callerHook adds caller information to the log entry
+type callerHook struct{}
+
+func (hook *callerHook) Fire(entry *logrus.Entry) error {
+	entry.Data["caller"] = getCaller()
+	return nil
+}
+
+func (hook *callerHook) Levels() []logrus.Level {
+	return logrus.AllLevels
+}
+
+// defaultFieldsHook adds default fields to each log entry
+type defaultFieldsHook struct {
+	fields logrus.Fields
+}
+
+func (hook *defaultFieldsHook) Fire(entry *logrus.Entry) error {
+	for k, v := range hook.fields {
+		if _, exists := entry.Data[k]; !exists {
+			entry.Data[k] = v
+		}
+	}
+	return nil
+}
+
+func (hook *defaultFieldsHook) Levels() []logrus.Level {
+	return logrus.AllLevels
+}
+
+// getCaller returns the caller's file and line number
+func getCaller() string {
+	_, file, line, ok := runtime.Caller(5) // Adjust the skip to get the right caller
+	if !ok {
+		return ""
+	}
+	return fmt.Sprintf("%s:%d", file, line)
+}
+
+// callerPrettyfier formats the caller info
+func callerPrettyfier(f *runtime.Frame) (string, string) {
+	// Get the relative path of the file
+	file := ""
+	if f != nil {
+		file = f.File
+		// Get the last 2 segments of the path
+		parts := strings.Split(file, "/")
+		if len(parts) > 2 {
+			file = strings.Join(parts[len(parts)-2:], "/")
+		}
+		file = fmt.Sprintf("%s:%d", file, f.Line)
+	}
+	// Return empty function name to hide it
+	return "", file
+}
+
+// GetLogger returns the global logger instance
+func GetLogger() *logrus.Logger {
+	logMutex.RLock()
+	defer logMutex.RUnlock()
+	return log
+}
+
+// SetLevel sets the logging level
+func SetLevel(level string) {
+	logMutex.Lock()
+	defer logMutex.Unlock()
+	setLogLevel(level)
+}
+
+// WithFields creates an entry with the given fields and includes the caller
+func WithFields(fields Fields) *logrus.Entry {
+	return log.WithFields(logrus.Fields(fields)).WithField("caller", getCaller())
+}
+
+// WithError adds an error as a single field and includes the caller
+func WithError(err error) *logrus.Entry {
+	return log.WithError(err).WithField("caller", getCaller())
+}
+
+// Debug logs a message at level Debug
+func Debug(args ...interface{}) {
+	log.WithField("caller", getCaller()).Debug(args...)
+}
+
+// Info logs a message at level Info
+func Info(args ...interface{}) {
+	log.WithField("caller", getCaller()).Info(args...)
+}
+
+// Infof logs a formatted message at level Info
+func Infof(format string, args ...interface{}) {
+	log.WithField("caller", getCaller()).Infof(format, args...)
+}
+
+// Warn logs a message at level Warn
+func Warn(args ...interface{}) {
+	log.WithField("caller", getCaller()).Warn(args...)
+}
+
+// Error logs a message at level Error
+func Error(args ...interface{}) {
+	log.WithField("caller", getCaller()).Error(args...)
+}
+
+// Errorf logs a formatted message at level Error
+func Errorf(format string, args ...interface{}) {
+	log.WithField("caller", getCaller()).Errorf(format, args...)
+}
+
+// Fatal logs a message at level Fatal then the process will exit with status set to 1
+func Fatal(args ...interface{}) {
+	log.WithField("caller", getCaller()).Fatal(args...)
+}
+
+// Panic logs a message at level Panic and then panics
+func Panic(args ...interface{}) {
+	log.WithField("caller", getCaller()).Panic(args...)
+}
+
+// Trace logs a message at level Trace
+func Trace(args ...interface{}) {
+	log.WithField("caller", getCaller()).Trace(args...)
+}
+
+// Initialize logger with default configuration
+func init() {
+	Init(&LogConfig{
+		Level:        "info",
+		Format:       "json",
+		EnableCaller: true,
+		BufferSize:   defaultBufferSize,
+		ReportCaller: true,
+	})
+}
diff --git a/internal/helper/logger/logger_test.go b/internal/helper/logger/logger_test.go
new file mode 100644
index 0000000..f10cdf5
--- /dev/null
+++ b/internal/helper/logger/logger_test.go
@@ -0,0 +1,252 @@
+package logger
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/sirupsen/logrus"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// captureOutput captures log output for testing
+func captureOutput(f func()) string {
+	r, w, err := os.Pipe()
+	if err != nil {
+		panic(err)
+	}
+
+	// Replace stdout/stderr
+	oldStdout := os.Stdout
+	oldStderr := os.Stderr
+	os.Stdout = w
+	os.Stderr = w
+
+	// Reset the logger after the test
+	oldLogger := log
+	defer func() {
+		log = oldLogger
+		os.Stdout = oldStdout
+		os.Stderr = oldStderr
+	}()
+
+	// Create a new logger for testing
+	log = logrus.New()
+	log.SetOutput(w)
+	log.SetFormatter(&logrus.JSONFormatter{
+		TimestampFormat: time.RFC3339Nano,
+	})
+
+	// Run the function
+	f()
+
+	// Close the writer
+	if err := w.Close(); err != nil {
+		panic(fmt.Sprintf("failed to close writer: %v", err))
+	}
+
+	// Read the output
+	var buf bytes.Buffer
+	_, err = io.Copy(&buf, r)
+	if err != nil {
+		panic(err)
+	}
+
+	return buf.String()
+}
+
+func TestLogger_Levels(t *testing.T) {
+	tests := []struct {
+		name     string
+		setLevel string
+		logFunc  func()
+		expected bool
+	}{
+		{
+			name:     "debug level shows debug logs",
+			setLevel: "debug",
+			logFunc:  func() { Debug("test debug") },
+			expected: true,
+		},
+		{
+			name:     "info level hides debug logs",
+			setLevel: "info",
+			logFunc:  func() { Debug("test debug") },
+			expected: false,
+		},
+		{
+			name:     "error level shows error logs",
+			setLevel: "error",
+			logFunc:  func() { Error("test error") },
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			output := captureOutput(func() {
+				Init(&LogConfig{Level: tt.setLevel, Format: "json"})
+				tt.logFunc()
+			})
+
+			if tt.expected {
+				assert.Contains(t, output, "message")
+			} else {
+				assert.Empty(t, output)
+			}
+		})
+	}
+}
+
+func TestLogger_JSONOutput(t *testing.T) {
+	output := captureOutput(func() {
+		Init(&LogConfig{Level: "debug", Format: "json"})
+		Info("test message")
+	})
+
+	// Verify it's valid JSON
+	var data map[string]interface{}
+	err := json.Unmarshal([]byte(output), &data)
+	require.NoError(t, err)
+
+	// Check required fields
+	assert.Contains(t, data, "message")
+	assert.Contains(t, data, "level")
+	assert.Contains(t, data, "@timestamp")
+}
+
+func TestLogger_TextOutput(t *testing.T) {
+	output := captureOutput(func() {
+		Init(&LogConfig{Level: "info", Format: "text"})
+		Warn("test warning")
+	})
+
+	// Basic checks for text format
+	assert.Contains(t, output, "test warning")
+	assert.Contains(t, output, "level=warning")
+}
+
+func TestLogger_WithFields(t *testing.T) {
+	output := captureOutput(func() {
+		Init(&LogConfig{Level: "info", Format: "json"})
+		WithFields(Fields{
+			"key1": "value1",
+			"key2": 42,
+		}).Info("test fields")
+	})
+
+	var data map[string]interface{}
+	err := json.Unmarshal([]byte(output), &data)
+	require.NoError(t, err)
+
+	assert.Equal(t, "value1", data["key1"])
+	assert.Equal(t, float64(42), data["key2"])
+}
+
+func TestLogger_WithError(t *testing.T) {
+	err := io.EOF
+	output := captureOutput(func() {
+		Init(&LogConfig{Level: "error", Format: "json"})
+		WithError(err).Error("test error")
+	})
+
+	var data map[string]interface{}
+	jsonErr := json.Unmarshal([]byte(output), &data)
+	require.NoError(t, jsonErr)
+
+	assert.Contains(t, data["error"], "EOF")
+}
+
+func TestLogger_CallerInfo(t *testing.T) {
+	output := captureOutput(func() {
+		Init(&LogConfig{
+			Level:        "info",
+			Format:       "json",
+			EnableCaller: true,
+		})
+		Info("test caller")
+	})
+
+
+	var data map[string]interface{}
+	err := json.Unmarshal([]byte(output), &data)
+	require.NoError(t, err)
+
+	// Caller should be in the format "file:line"
+	caller, ok := data["caller"].(string)
+	require.True(t, ok)
+	assert.True(t, strings.Contains(caller, ".go:"), "caller should contain file and line number")
+}
+
+func TestLogger_Concurrent(t *testing.T) {
+	Init(&LogConfig{Level: "info", Format: "json"})
+
+	var wg sync.WaitGroup
+	count := 10
+
+	for i := 0; i < count; i++ {
+		wg.Add(1)
+		go func(n int) {
+			defer wg.Done()
+			WithFields(Fields{"goroutine": n}).Info("concurrent log")
+		}(i)
+	}
+
+	// Just verify no panic occurs
+	wg.Wait()
+}
+
+func TestLogger_DefaultFields(t *testing.T) {
+	// Create a buffer to capture output
+	var buf bytes.Buffer
+
+	// Initialize logger with test configuration
+	Init(&LogConfig{
+		Level:        "info",
+		Format:       "json",
+		EnableCaller: true,
+	})
+
+
+	// Replace the output writer with our buffer
+	log.SetOutput(&buf)
+
+
+	// Log a test message
+	Info("test default fields")
+
+
+	// Parse the JSON output
+	var data map[string]interface{}
+	err := json.Unmarshal(buf.Bytes(), &data)
+	require.NoError(t, err, "Failed to unmarshal log output")
+
+	// Check that default fields are included
+	assert.Equal(t, "starter-kit", data["app_name"], "app_name should be set in default fields")
+	// The env field might be empty in test environment, which is fine
+	// as long as the field exists in the log entry
+	_, envExists := data["env"]
+	assert.True(t, envExists, "env field should exist in log entry")
+}
+
+func TestLogger_LevelChanges(t *testing.T) {
+	output := captureOutput(func() {
+		Init(&LogConfig{Level: "error", Format: "json"})
+		Debug("should not appear")
+		SetLevel("debug")
+		Debug("should appear")
+	})
+
+	// Split output into lines
+	lines := strings.Split(strings.TrimSpace(output), "\n")
+	// Should only have one log message (the second Debug)
+	assert.Len(t, lines, 1)
+	assert.Contains(t, lines[0], "should appear")
+}
diff --git a/internal/pkg/lifecycle/lifecycle.go b/internal/pkg/lifecycle/lifecycle.go
new file mode 100644
index 0000000..7e4828f
--- /dev/null
+++ b/internal/pkg/lifecycle/lifecycle.go
@@ -0,0 +1,142 @@
+// Package lifecycle provides application lifecycle management using tomb
+package lifecycle
+
+import (
+	"context"
+	"os"
+	"os/signal"
+	"sync"
+	"syscall"
+	"time"
+
+	"go.uber.org/multierr"
+	"gopkg.in/tomb.v2"
+
+	"starter-kit/internal/helper/logger"
+)
+
+// Lifecycle manages the application lifecycle
+type Lifecycle struct {
+	tomb     tomb.Tomb
+	shutdownTimeout time.Duration
+	mu       sync.Mutex
+	services []Service
+}
+
+// Service represents a service that can be started and stopped
+type Service interface {
+	Name() string
+	Start() error
+	Shutdown(ctx context.Context) error
+}
+
+// New creates a new Lifecycle with the given shutdown timeout
+func New(shutdownTimeout time.Duration) *Lifecycle {
+	return &Lifecycle{
+		shutdownTimeout: shutdownTimeout,
+		services:        make([]Service, 0),
+	}
+}
+
+// Register adds a service to the lifecycle manager
+func (l *Lifecycle) Register(service Service) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	l.services = append(l.services, service)
+}
+
+// Start starts all registered services
+func (l *Lifecycle) Start() error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	// Start all services
+	for _, svc := range l.services {
+		service := svc // Create a new variable for the closure
+		l.tomb.Go(func() error {
+			logger.Info("Starting service: ", service.Name())
+			if err := service.Start(); err != nil {
+				logger.Errorf("Service %s failed to start: %v", service.Name(), err)
+				return err
+			}
+			logger.Info("Service started: ", service.Name())
+			return nil
+		})
+	}
+
+	return nil
+}
+
+// Wait blocks until all services have stopped
+func (l *Lifecycle) Wait() error {
+	return l.tomb.Wait()
+}
+
+// Shutdown gracefully shuts down all services
+func (l *Lifecycle) Shutdown() error {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	logger.Info("Initiating graceful shutdown...")
+
+	// Create a context with timeout
+	ctx, cancel := context.WithTimeout(context.Background(), l.shutdownTimeout*time.Second)
+	defer cancel()
+
+	// Notify all services to shut down
+	l.tomb.Kill(nil)
+
+	// Shutdown all services in reverse order
+	var errs error
+	for i := len(l.services) - 1; i >= 0; i-- {
+		svc := l.services[i]
+		logger.Infof("Shutting down service: %s", svc.Name())
+		if err := svc.Shutdown(ctx); err != nil {
+			logger.Errorf("Error shutting down %s: %v", svc.Name(), err)
+			errs = multierr.Append(errs, err)
+		}
+	}
+
+	// Wait for all services to stop or timeout
+	errChan := make(chan error, 1)
+	go func() {
+		errChan <- l.tomb.Wait()
+	}()
+
+	select {
+	case err := <-errChan:
+		if err != nil {
+			errs = multierr.Append(errs, err)
+		}
+	case <-ctx.Done():
+		errs = multierr.Append(errs, ctx.Err())
+	}
+
+	if errs != nil {
+		logger.Errorf("Shutdown completed with errors: %v", errs)
+	} else {
+		logger.Info("Shutdown completed successfully")
+	}
+
+	return errs
+}
+
+// ShutdownOnSignal shuts down the lifecycle when a signal is received
+func (l *Lifecycle) ShutdownOnSignal(signals ...os.Signal) {
+	if len(signals) == 0 {
+		signals = []os.Signal{syscall.SIGINT, syscall.SIGTERM}
+	}
+
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, signals...)
+
+	l.tomb.Go(func() error {
+		select {
+		case sig := <-sigChan:
+			logger.Infof("Received signal: %v. Initiating shutdown...", sig)
+			return l.Shutdown()
+		case <-l.tomb.Dying():
+			return nil
+		}
+	})
+}
diff --git a/internal/service/auth_service.go b/internal/service/auth_service.go
new file mode 100644
index 0000000..567b6a5
--- /dev/null
+++ b/internal/service/auth_service.go
@@ -0,0 +1,236 @@
+package service
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/sha256"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"golang.org/x/crypto/bcrypt"
+	"gorm.io/gorm" // Added gorm import
+	"starter-kit/internal/domain/role"
+	"starter-kit/internal/domain/user"
+)
+
+// AuthService xử lý các tác vụ liên quan đến xác thực
+type AuthService interface {
+	Register(ctx context.Context, req RegisterRequest) (*user.User, error)
+	Login(ctx context.Context, username, password string) (string, string, error)
+	RefreshToken(refreshToken string) (string, string, error)
+	ValidateToken(tokenString string) (*Claims, error)
+}
+
+type authService struct {
+	userRepo       user.Repository
+	roleRepo       role.Repository
+	jwtSecret      string
+	jwtExpiration  time.Duration
+	refreshExpires int
+}
+
+// Claims định nghĩa các thông tin trong JWT token
+type Claims struct {
+	UserID   string   `json:"user_id"`
+	Username string   `json:"username"`
+	Roles    []string `json:"roles"`
+	jwt.RegisteredClaims
+}
+
+// NewAuthService tạo mới một AuthService
+func NewAuthService(
+	userRepo user.Repository,
+	roleRepo role.Repository,
+	jwtSecret string,
+	jwtExpiration time.Duration,
+) AuthService {
+	return &authService{
+		userRepo:       userRepo,
+		roleRepo:       roleRepo,
+		jwtSecret:      jwtSecret,
+		jwtExpiration:  jwtExpiration,
+		refreshExpires: 7 * 24 * 60, // 7 days in minutes
+	}
+}
+
+// Register đăng ký người dùng mới
+func (s *authService) Register(ctx context.Context, req RegisterRequest) (*user.User, error) {
+	// Kiểm tra username đã tồn tại chưa
+	existingUser, err := s.userRepo.GetByUsername(ctx, req.Username)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) { // Chỉ coi là lỗi nếu không phải RecordNotFound
+		return nil, fmt.Errorf("error checking username: %w", err)
+	}
+	if existingUser != nil { // Nếu existingUser không nil, nghĩa là user đã tồn tại
+		return nil, errors.New("username already exists")
+	}
+
+	// Kiểm tra email đã tồn tại chưa
+	existingEmail, err := s.userRepo.GetByEmail(ctx, req.Email)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) { // Chỉ coi là lỗi nếu không phải RecordNotFound
+		return nil, fmt.Errorf("error checking email: %v", err)
+	}
+	if existingEmail != nil {
+		return nil, errors.New("email already exists")
+	}
+
+	// Mã hóa mật khẩu
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(req.Password), bcrypt.DefaultCost)
+	if err != nil {
+		return nil, fmt.Errorf("error hashing password: %v", err)
+	}
+
+	// Tạo user mới
+	newUser := &user.User{
+		Username:     req.Username,
+		Email:        req.Email,
+		PasswordHash: string(hashedPassword),
+		FullName:     req.FullName,
+		IsActive:     true,
+	}
+
+	// Lưu user vào database
+	if err := s.userRepo.Create(ctx, newUser); err != nil {
+		return nil, fmt.Errorf("error creating user: %v", err)
+	}
+
+	// Thêm role mặc định là 'user' cho người dùng mới
+	userRole, err := s.roleRepo.GetByName(ctx, role.User)
+	if err != nil {
+		return nil, fmt.Errorf("error getting user role: %v", err)
+	}
+	if userRole == nil {
+		return nil, errors.New("default user role not found")
+	}
+
+	if err := s.userRepo.AddRole(ctx, newUser.ID, userRole.ID); err != nil {
+		return nil, fmt.Errorf("error adding role to user: %v", err)
+	}
+
+	// Lấy lại thông tin user với đầy đủ roles
+	createdUser, err := s.userRepo.GetByID(ctx, newUser.ID)
+	if err != nil {
+		return nil, fmt.Errorf("error getting created user: %v", err)
+	}
+
+	return createdUser, nil
+}
+
+// Login xác thực đăng nhập và trả về token
+func (s *authService) Login(ctx context.Context, username, password string) (string, string, error) {
+	// Lấy thông tin user
+	user, err := s.userRepo.GetByUsername(ctx, username)
+	if err != nil {
+		return "", "", errors.New("invalid credentials")
+	}
+
+	if user == nil || !user.IsActive {
+		return "", "", errors.New("invalid credentials")
+	}
+
+	// Kiểm tra mật khẩu
+	if err := bcrypt.CompareHashAndPassword([]byte(user.PasswordHash), []byte(password)); err != nil {
+		return "", "", errors.New("invalid credentials")
+	}
+
+	// Tạo access token
+	accessToken, err := s.generateToken(user)
+	if err != nil {
+		return "", "", fmt.Errorf("error generating token: %v", err)
+	}
+
+	// Tạo refresh token
+	tokenBytes := make([]byte, 32)
+	if _, err := rand.Read(tokenBytes); err != nil {
+		return "", "", fmt.Errorf("error generating refresh token: %v", err)
+	}
+
+	// Lưu refresh token vào database (trong thực tế nên lưu vào Redis hoặc database)
+	// Ở đây chỉ minh họa, nên implement thật kỹ hơn
+	h := sha256.New()
+	h.Write(tokenBytes)
+	tokenID := base64.URLEncoding.EncodeToString(h.Sum(nil))
+
+	// TODO: Lưu refresh token vào database với userID và tokenID
+	_ = tokenID
+
+	// Cập nhật thời gian đăng nhập cuối cùng
+	if err := s.userRepo.UpdateLastLogin(ctx, user.ID); err != nil {
+		// Log lỗi nhưng không ảnh hưởng đến quá trình đăng nhập
+		fmt.Printf("Error updating last login: %v\n", err)
+	}
+
+	return accessToken, string(tokenBytes), nil
+}
+
+// RefreshToken làm mới access token
+func (s *authService) RefreshToken(refreshToken string) (string, string, error) {
+	// TODO: Kiểm tra refresh token trong database
+	// Nếu hợp lệ, tạo access token mới và trả về
+	return "", "", errors.New("not implemented")
+}
+
+// ValidateToken xác thực và trả về thông tin từ token
+func (s *authService) ValidateToken(tokenString string) (*Claims, error) {
+	token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
+		// Kiểm tra signing method
+		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
+		}
+		return []byte(s.jwtSecret), nil
+	})
+
+	if err != nil {
+		return nil, err
+	}
+
+	if claims, ok := token.Claims.(*Claims); ok && token.Valid {
+		return claims, nil
+	}
+
+	return nil, errors.New("invalid token")
+}
+
+// generateToken tạo JWT token cho user
+func (s *authService) generateToken(user *user.User) (string, error) {
+	// Lấy danh sách roles
+	roles := make([]string, len(user.Roles))
+	for i, r := range user.Roles {
+		roles[i] = r.Name
+	}
+
+	// Tạo claims
+	expirationTime := time.Now().Add(s.jwtExpiration)
+	claims := &Claims{
+		UserID:   user.ID,
+		Username: user.Username,
+		Roles:    roles,
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(expirationTime),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+			NotBefore: jwt.NewNumericDate(time.Now()),
+			Issuer:    "ulflow-starter-kit",
+		},
+	}
+
+	// Tạo token
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+
+	// Ký token và trả về
+	tokenString, err := token.SignedString([]byte(s.jwtSecret))
+	if err != nil {
+		return "", err
+	}
+
+	return tokenString, nil
+}
+
+// RegisterRequest định dạng dữ liệu đăng ký
+type RegisterRequest struct {
+	Username string `json:"username"`
+	Email    string `json:"email"`
+	Password string `json:"password"`
+	FullName string `json:"full_name"`
+}
diff --git a/internal/service/auth_service_test.go b/internal/service/auth_service_test.go
new file mode 100644
index 0000000..ba3a1a1
--- /dev/null
+++ b/internal/service/auth_service_test.go
@@ -0,0 +1,339 @@
+package service_test
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"golang.org/x/crypto/bcrypt"
+	"starter-kit/internal/domain/role"
+	"starter-kit/internal/domain/user"
+	"starter-kit/internal/service"
+)
+
+// MockUserRepo là mock cho user.Repository
+type MockUserRepo struct {
+	mock.Mock
+}
+
+func (m *MockUserRepo) Create(ctx context.Context, user *user.User) error {
+	args := m.Called(ctx, user)
+	return args.Error(0)
+}
+
+func (m *MockUserRepo) GetByID(ctx context.Context, id string) (*user.User, error) {
+	args := m.Called(ctx, id)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*user.User), args.Error(1)
+}
+
+func (m *MockUserRepo) GetByUsername(ctx context.Context, username string) (*user.User, error) {
+	args := m.Called(ctx, username)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*user.User), args.Error(1)
+}
+
+func (m *MockUserRepo) GetByEmail(ctx context.Context, email string) (*user.User, error) {
+	args := m.Called(ctx, email)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*user.User), args.Error(1)
+}
+
+func (m *MockUserRepo) UpdateLastLogin(ctx context.Context, id string) error {
+	args := m.Called(ctx, id)
+	return args.Error(0)
+}
+
+func (m *MockUserRepo) AddRole(ctx context.Context, userID string, roleID int) error {
+	args := m.Called(ctx, userID, roleID)
+	return args.Error(0)
+}
+
+func (m *MockUserRepo) RemoveRole(ctx context.Context, userID string, roleID int) error {
+	args := m.Called(ctx, userID, roleID)
+	return args.Error(0)
+}
+
+func (m *MockUserRepo) HasRole(ctx context.Context, userID string, roleID int) (bool, error) {
+	args := m.Called(ctx, userID, roleID)
+	return args.Bool(0), args.Error(1)
+}
+
+func (m *MockUserRepo) Update(ctx context.Context, user *user.User) error {
+	args := m.Called(ctx, user)
+	return args.Error(0)
+}
+
+func (m *MockUserRepo) Delete(ctx context.Context, id string) error {
+	args := m.Called(ctx, id)
+	return args.Error(0)
+}
+
+// MockRoleRepo là mock cho role.Repository
+type MockRoleRepo struct {
+	mock.Mock
+}
+
+func (m *MockRoleRepo) GetByName(ctx context.Context, name string) (*role.Role, error) {
+	args := m.Called(ctx, name)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*role.Role), args.Error(1)
+}
+
+func (m *MockRoleRepo) Create(ctx context.Context, role *role.Role) error {
+	args := m.Called(ctx, role)
+	return args.Error(0)
+}
+
+func (m *MockRoleRepo) GetByID(ctx context.Context, id int) (*role.Role, error) {
+	args := m.Called(ctx, id)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*role.Role), args.Error(1)
+}
+
+func (m *MockRoleRepo) List(ctx context.Context) ([]*role.Role, error) {
+	args := m.Called(ctx)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).([]*role.Role), args.Error(1)
+}
+
+func (m *MockRoleRepo) Update(ctx context.Context, role *role.Role) error {
+	args := m.Called(ctx, role)
+	return args.Error(0)
+}
+
+func (m *MockRoleRepo) Delete(ctx context.Context, id int) error {
+	args := m.Called(ctx, id)
+	return args.Error(0)
+}
+
+func TestAuthService_Register(t *testing.T) {
+	tests := []struct {
+		name    string
+		setup   func(*MockUserRepo, *MockRoleRepo)
+		req     service.RegisterRequest
+		wantErr bool
+	}{
+		{
+			name: "successful registration",
+			setup: func(mu *MockUserRepo, mr *MockRoleRepo) {
+				// Mock GetByUsername - user not exists
+				mu.On("GetByUsername", mock.Anything, "testuser").
+					Return((*user.User)(nil), nil)
+
+				// Mock GetByEmail - email not exists
+				mu.On("GetByEmail", mock.Anything, "test@example.com").
+					Return((*user.User)(nil), nil)
+
+				// Mock GetByName - role exists
+				mr.On("GetByName", mock.Anything, role.User).
+					Return(&role.Role{ID: 1, Name: role.User}, nil)
+
+				// Mock AddRole
+				mu.On("AddRole", mock.Anything, mock.Anything, mock.Anything).
+					Return(nil)
+
+				// Mock Create - success
+				mu.On("Create", mock.Anything, mock.AnythingOfType("*user.User")).
+					Return(nil)
+
+
+				// Mock GetByID - return created user
+				mu.On("GetByID", mock.Anything, mock.Anything).
+					Return(&user.User{
+						ID:       "123",
+						Username: "testuser",
+						Email:    "test@example.com",
+						FullName: "Test User",
+					}, nil)
+
+			},
+			req: service.RegisterRequest{
+				Username: "testuser",
+				Email:    "test@example.com",
+				Password: "password123",
+				FullName: "Test User",
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup mocks
+			mockUserRepo := new(MockUserRepo)
+			mockRoleRepo := new(MockRoleRepo)
+			tt.setup(mockUserRepo, mockRoleRepo)
+
+			// Create service with mocks
+			svc := service.NewAuthService(
+				mockUserRepo,
+				mockRoleRepo,
+				"test-secret",
+				time.Hour,
+			)
+
+			// Call method
+			_, err := svc.Register(context.Background(), tt.req)
+
+			// Assertions
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+
+			// Verify all expectations were met
+			mockUserRepo.AssertExpectations(t)
+			mockRoleRepo.AssertExpectations(t)
+		})
+	}
+}
+
+func TestAuthService_Login(t *testing.T) {
+	// Create a test user with hashed password
+	hashedPassword, _ := bcrypt.GenerateFromPassword([]byte("password123"), bcrypt.DefaultCost)
+	testUser := &user.User{
+		ID:           "123",
+		Username:     "testuser",
+		Email:        "test@example.com",
+		PasswordHash: string(hashedPassword),
+		IsActive:     true,
+	}
+
+	tests := []struct {
+		name     string
+		setup    func(*MockUserRepo)
+		username string
+		password string
+		wantErr  bool
+	}{
+		{
+			name: "successful login",
+			setup: func(mu *MockUserRepo) {
+				// Mock GetByUsername - user exists
+				mu.On("GetByUsername", mock.Anything, "testuser").
+					Return(testUser, nil)
+
+				// Mock UpdateLastLogin
+				mu.On("UpdateLastLogin", mock.Anything, "123").
+					Return(nil)
+			},
+			username: "testuser",
+			password: "password123",
+			wantErr:  false,
+		},
+		{
+			name: "invalid password",
+			setup: func(mu *MockUserRepo) {
+				// Mock GetByUsername - user exists
+				mu.On("GetByUsername", mock.Anything, "testuser").
+					Return(testUser, nil)
+			},
+			username: "testuser",
+			password: "wrongpassword",
+			wantErr:  true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup mocks
+			mockUserRepo := new(MockUserRepo)
+			tt.setup(mockUserRepo)
+
+			// Create service with mocks
+			svc := service.NewAuthService(
+				mockUserRepo,
+				nil, // Role repo not needed for login
+				"test-secret",
+				time.Hour,
+			)
+
+
+			// Call method
+			_, _, err := svc.Login(context.Background(), tt.username, tt.password)
+
+			// Assertions
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+
+			// Verify all expectations were met
+			mockUserRepo.AssertExpectations(t)
+		})
+	}
+}
+
+func TestAuthService_ValidateToken(t *testing.T) {
+	// Create a test service
+	svc := service.NewAuthService(
+		nil, // Repos not needed for this test
+		nil,
+		"test-secret",
+		time.Hour,
+	)
+
+	// Create a valid token
+	claims := &service.Claims{
+		UserID:   "123",
+		Username: "testuser",
+		Roles:    []string{"user"},
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour)),
+			IssuedAt:  jwt.NewNumericDate(time.Now()),
+		},
+	}
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
+	tokenString, _ := token.SignedString([]byte("test-secret"))
+
+	tests := []struct {
+		name       string
+		token      string
+		wantClaims *service.Claims
+		wantErr    bool
+	}{
+		{
+			name:       "valid token",
+			token:      tokenString,
+			wantClaims: claims,
+			wantErr:    false,
+		},
+		{
+			name:    "invalid signature",
+			token:   tokenString[:len(tokenString)-2] + "xx", // Corrupt the signature
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			claims, err := svc.ValidateToken(tt.token)
+
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tt.wantClaims.UserID, claims.UserID)
+				assert.Equal(t, tt.wantClaims.Username, claims.Username)
+			}
+		})
+	}
+}
diff --git a/internal/transport/http/dto/error_response.go b/internal/transport/http/dto/error_response.go
new file mode 100644
index 0000000..8978c47
--- /dev/null
+++ b/internal/transport/http/dto/error_response.go
@@ -0,0 +1,8 @@
+package dto
+
+// ErrorResponse định dạng phản hồi lỗi
+// @Description Định dạng phản hồi lỗi
+// @Description Error response format
+type ErrorResponse struct {
+	Error string `json:"error" example:"error message"`
+}
diff --git a/internal/transport/http/dto/user_dto.go b/internal/transport/http/dto/user_dto.go
new file mode 100644
index 0000000..ca6f97e
--- /dev/null
+++ b/internal/transport/http/dto/user_dto.go
@@ -0,0 +1,70 @@
+package dto
+
+import (
+	"time"
+
+	"starter-kit/internal/domain/role"
+	"starter-kit/internal/domain/user"
+)
+
+// RegisterRequest định dạng dữ liệu đăng ký người dùng mới
+type RegisterRequest struct {
+	Username string `json:"username" binding:"required,min=3,max=50"`
+	Email    string `json:"email" binding:"required,email"`
+	Password string `json:"password" binding:"required,min=8"`
+	FullName string `json:"full_name" binding:"required"`
+}
+
+// LoginRequest định dạng dữ liệu đăng nhập
+type LoginRequest struct {
+	Username string `json:"username" binding:"required"`
+	Password string `json:"password" binding:"required"`
+}
+
+// AuthResponse định dạng phản hồi xác thực
+type AuthResponse struct {
+	AccessToken  string    `json:"access_token"`
+	RefreshToken string    `json:"refresh_token"`
+	ExpiresAt   time.Time `json:"expires_at"`
+	TokenType   string    `json:"token_type"`
+}
+
+// UserResponse định dạng phản hồi thông tin người dùng
+type UserResponse struct {
+	ID        string         `json:"id"`
+	Username  string         `json:"username"`
+	Email     string         `json:"email"`
+	FullName  string         `json:"full_name"`
+	AvatarURL string         `json:"avatar_url,omitempty"`
+	IsActive  bool           `json:"is_active"`
+	Roles     []role.Role    `json:"roles,omitempty"`
+	CreatedAt time.Time      `json:"created_at"`
+}
+
+// ToUserResponse chuyển đổi từ User sang UserResponse
+func ToUserResponse(userObj interface{}) UserResponse {
+	switch u := userObj.(type) {
+	case *user.User:
+		// Handle actual domain User model
+		roles := make([]role.Role, 0)
+		if u.Roles != nil {
+			for _, r := range u.Roles {
+				roles = append(roles, *r)
+			}
+		}
+		
+		return UserResponse{
+			ID:        u.ID,
+			Username:  u.Username,
+			Email:     u.Email,
+			FullName:  u.FullName,
+			AvatarURL: u.AvatarURL,
+			IsActive:  u.IsActive,
+			Roles:     roles,
+			CreatedAt: u.CreatedAt,
+		}
+	default:
+		// If we can't handle this type, return an empty response
+		return UserResponse{}
+	}
+}
diff --git a/internal/transport/http/handler/auth_handler.go b/internal/transport/http/handler/auth_handler.go
new file mode 100644
index 0000000..d40b5cc
--- /dev/null
+++ b/internal/transport/http/handler/auth_handler.go
@@ -0,0 +1,149 @@
+package handler
+
+import (
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"starter-kit/internal/service"
+	"starter-kit/internal/transport/http/dto"
+)
+
+type AuthHandler struct {
+	authSvc service.AuthService
+}
+
+// NewAuthHandler tạo mới AuthHandler
+func NewAuthHandler(authSvc service.AuthService) *AuthHandler {
+	return &AuthHandler{
+		authSvc: authSvc,
+	}
+}
+
+// Register xử lý đăng ký người dùng mới
+// @Summary Đăng ký tài khoản mới
+// @Description Tạo tài khoản người dùng mới với thông tin cơ bản
+// @Tags Authentication
+// @Accept json
+// @Produce json
+// @Param request body dto.RegisterRequest true "Thông tin đăng ký"
+// @Success 201 {object} dto.UserResponse
+// @Failure 400 {object} dto.ErrorResponse
+// @Failure 409 {object} dto.ErrorResponse
+// @Failure 500 {object} dto.ErrorResponse
+// @Router /api/v1/auth/register [post]
+func (h *AuthHandler) Register(c *gin.Context) {
+	var req dto.RegisterRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, dto.ErrorResponse{Error: "Invalid request body"})
+		return
+	}
+
+	// Gọi service để đăng ký
+	user, err := h.authSvc.Register(c.Request.Context(), service.RegisterRequest(req))
+	if err != nil {
+		// Xử lý lỗi trả về
+		if strings.Contains(err.Error(), "already exists") {
+			c.JSON(http.StatusConflict, dto.ErrorResponse{Error: err.Error()})
+		} else {
+			c.JSON(http.StatusInternalServerError, dto.ErrorResponse{Error: "Internal server error"})
+		}
+		return
+	}
+
+	// Chuyển đổi sang DTO và trả về
+	userResponse := dto.ToUserResponse(user)
+	c.JSON(http.StatusCreated, userResponse)
+}
+
+// Login xử lý đăng nhập
+// @Summary Đăng nhập
+// @Description Đăng nhập bằng username và password
+// @Tags Authentication
+// @Accept json
+// @Produce json
+// @Param request body dto.LoginRequest true "Thông tin đăng nhập"
+// @Success 200 {object} dto.AuthResponse
+// @Failure 400 {object} dto.ErrorResponse
+// @Failure 401 {object} dto.ErrorResponse
+// @Failure 500 {object} dto.ErrorResponse
+// @Router /api/v1/auth/login [post]
+func (h *AuthHandler) Login(c *gin.Context) {
+	var req dto.LoginRequest
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, dto.ErrorResponse{Error: "Invalid request body"})
+		return
+	}
+
+	// Gọi service để đăng nhập
+	accessToken, refreshToken, err := h.authSvc.Login(c.Request.Context(), req.Username, req.Password)
+	if err != nil {
+		c.JSON(http.StatusUnauthorized, dto.ErrorResponse{Error: "Invalid credentials"})
+		return
+	}
+
+	// Tạo response
+	expiresAt := time.Now().Add(24 * time.Hour) // Thời gian hết hạn mặc định
+	response := dto.AuthResponse{
+		AccessToken:  accessToken,
+		RefreshToken: refreshToken,
+		ExpiresAt:   expiresAt,
+		TokenType:   "Bearer",
+	}
+
+	c.JSON(http.StatusOK, response)
+}
+
+// RefreshToken làm mới access token
+// @Summary Làm mới access token
+// @Description Làm mới access token bằng refresh token
+// @Tags Authentication
+// @Accept json
+// @Produce json
+// @Param refresh_token body string true "Refresh token"
+// @Success 200 {object} dto.AuthResponse
+// @Failure 400 {object} dto.ErrorResponse
+// @Failure 401 {object} dto.ErrorResponse
+// @Router /api/v1/auth/refresh [post]
+func (h *AuthHandler) RefreshToken(c *gin.Context) {
+	// Lấy refresh token từ body
+	var req struct {
+		RefreshToken string `json:"refresh_token" binding:"required"`
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, dto.ErrorResponse{Error: "Refresh token is required"})
+		return
+	}
+
+	// Gọi service để làm mới token
+	accessToken, refreshToken, err := h.authSvc.RefreshToken(req.RefreshToken)
+	if err != nil {
+		c.JSON(http.StatusUnauthorized, dto.ErrorResponse{Error: "Invalid refresh token"})
+		return
+	}
+
+	// Tạo response
+	expiresAt := time.Now().Add(24 * time.Hour) // Thời gian hết hạn mặc định
+	response := dto.AuthResponse{
+		AccessToken:  accessToken,
+		RefreshToken: refreshToken,
+		ExpiresAt:   expiresAt,
+		TokenType:   "Bearer",
+	}
+
+	c.JSON(http.StatusOK, response)
+}
+
+// Logout xử lý đăng xuất
+// @Summary Đăng xuất
+// @Description Đăng xuất và vô hiệu hóa refresh token
+// @Tags Authentication
+// @Security Bearer
+// @Success 204 "No Content"
+// @Router /api/v1/auth/logout [post]
+func (h *AuthHandler) Logout(c *gin.Context) {
+	// TODO: Vô hiệu hóa refresh token trong database
+	c.Status(http.StatusNoContent)
+}
diff --git a/internal/transport/http/handler/auth_register_test.go b/internal/transport/http/handler/auth_register_test.go
new file mode 100644
index 0000000..85ace0d
--- /dev/null
+++ b/internal/transport/http/handler/auth_register_test.go
@@ -0,0 +1,221 @@
+package handler
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"starter-kit/internal/adapter/persistence"
+	"starter-kit/internal/domain/role"
+	"starter-kit/internal/domain/user"
+	"starter-kit/internal/service"
+	"starter-kit/internal/transport/http/dto"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+)
+
+// mock user repository với khả năng hook
+type mockUserRepo struct {
+	user.Repository // nhúng interface để implement tự động
+	CreateFunc      func(ctx context.Context, u *user.User) error
+	GetByIDFunc     func(ctx context.Context, id string) (*user.User, error)
+	AddRoleFunc     func(ctx context.Context, userID string, roleID int) error
+}
+
+func (m *mockUserRepo) Create(ctx context.Context, u *user.User) error {
+	if m.CreateFunc != nil {
+		return m.CreateFunc(ctx, u)
+	}
+	return nil
+}
+
+func (m *mockUserRepo) GetByID(ctx context.Context, id string) (*user.User, error) {
+	if m.GetByIDFunc != nil {
+		return m.GetByIDFunc(ctx, id)
+	}
+	return nil, nil
+}
+
+func (m *mockUserRepo) AddRole(ctx context.Context, userID string, roleID int) error {
+	if m.AddRoleFunc != nil {
+		return m.AddRoleFunc(ctx, userID, roleID)
+	}
+	return nil
+}
+
+func TestRegisterHandler(t *testing.T) {
+	// Thiết lập
+	gin.SetMode(gin.TestMode)
+
+	// UUID cố định cho bài test
+	testUserID := "123e4567-e89b-12d3-a456-426614174000"
+
+	// Tạo mock database
+	db, mock, err := sqlmock.New(sqlmock.QueryMatcherOption(sqlmock.QueryMatcherRegexp))
+	if err != nil {
+		t.Fatalf("Không thể tạo mock database: %v", err)
+	}
+	defer func() { _ = db.Close() }()
+
+	// Kết nối GORM
+	gormDB, err := gorm.Open(mysql.New(mysql.Config{
+		Conn:                      db,
+		SkipInitializeWithVersion: true,
+	}), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("Không thể kết nối GORM: %v", err)
+	}
+
+	// Tạo repositories thật sẽ kết nối với mock DB
+	realUserRepo := persistence.NewUserRepository(gormDB)
+	roleRepo := persistence.NewRoleRepository(gormDB)
+
+	// Tạo mock repository với đầy đủ các phương thức cần thiết
+	mockedUserRepo := &mockUserRepo{
+		Repository: realUserRepo, // delegate các phương thức còn lại
+		CreateFunc: func(ctx context.Context, u *user.User) error {
+			// Chú ý: Trong thực tế, ID sẽ được tạo bởi DB (uuid_generate_v4())
+			// Nhưng vì đây là test, chúng ta cần giả lập việc DB thiết lập ID sau khi INSERT
+			// Gọi repository thật để thực thi SQL
+			err := realUserRepo.Create(ctx, u)
+			// Gán ID cố định sau khi tạo, giả lập việc DB tạo và trả về ID
+			u.ID = testUserID
+			return err
+		},
+		GetByIDFunc: func(ctx context.Context, id string) (*user.User, error) {
+			// Tạo user đủ thông tin với role đã preload
+			userRole := &role.Role{ID: 1, Name: "user", Description: "Basic user role"}
+			u := &user.User{
+				ID:        testUserID,
+				Username:  "testuser",
+				Email:     "test@example.com",
+				FullName:  "Test User",
+				AvatarURL: "",
+				IsActive:  true,
+				Roles:     []*role.Role{userRole}, // Gán role đã preload
+			}
+			return u, nil
+		},
+		AddRoleFunc: func(ctx context.Context, userID string, roleID int) error {
+			// Kiểm tra đảm bảo ID phù hợp
+			if userID != testUserID {
+				return fmt.Errorf("expected user ID %s but got %s", testUserID, userID)
+			}
+			// Khi chúng ta gọi AddRole của repo thật, nó sẽ thực thi câu lệnh SQL
+			return realUserRepo.AddRole(ctx, userID, roleID)
+		},
+	}
+
+	// Tạo service với mock userRepo
+	jwtSecret := "test-secret-key"
+	authSvc := service.NewAuthService(mockedUserRepo, roleRepo, jwtSecret, time.Duration(15)*time.Minute)
+
+	// Tạo handler
+	authHandler := NewAuthHandler(authSvc)
+
+	// Tạo router
+	r := gin.Default()
+	r.POST("/api/v1/auth/register", authHandler.Register)
+
+	// Dữ liệu đăng ký
+	registerData := dto.RegisterRequest{
+		Username: "testuser",
+		Email:    "test@example.com",
+		Password: "password123",
+		FullName: "Test User",
+	}
+
+	// Chuyển đổi dữ liệu thành JSON
+	jsonData, err := json.Marshal(registerData)
+	if err != nil {
+		t.Fatalf("Lỗi chuyển đổi JSON: %v", err)
+	}
+
+	t.Run("Đăng ký tài khoản mới thành công", func(t *testing.T) {
+		// Setup các mong đợi SQL match chính xác với GORM theo logs và UserRepository implementation
+
+		// 1. Kiểm tra xem username đã tồn tại chưa (userRepo.GetByUsername)
+		mock.ExpectQuery("SELECT \\* FROM `users` WHERE username = \\? ORDER BY `users`\\.`id` LIMIT \\?").
+			WithArgs("testuser", 1).
+			WillReturnError(gorm.ErrRecordNotFound) // Username 'testuser' chưa tồn tại
+
+		// 2. Kiểm tra xem email đã tồn tại chưa (userRepo.GetByEmail)
+		mock.ExpectQuery("SELECT \\* FROM `users` WHERE email = \\? ORDER BY `users`\\.`id` LIMIT \\?").
+			WithArgs("test@example.com", 1).
+			WillReturnError(gorm.ErrRecordNotFound) // Email 'test@example.com' chưa tồn tại
+
+		// --- Sequence of operations after successful username/email checks and password hashing ---
+
+		// 3. Transaction for userRepo.Create (Implicit transaction by GORM)
+		mock.ExpectBegin()
+		// 4. Tạo user mới (userRepo.Create)
+		// Khi không đặt trước ID, GORM không đưa ID vào SQL, để DB tạo UUID tự động
+		mock.ExpectExec("^INSERT INTO `users` \\(`username`,`email`,`password_hash`,`full_name`,`avatar_url`,`is_active`,`last_login_at`,`created_at`,`updated_at`,`deleted_at`\\) VALUES \\(\\?,\\?,\\?,\\?,\\?,\\?,\\?,\\?,\\?,\\?\\)").
+			WithArgs(
+				"testuser",         // username
+				"test@example.com", // email
+				sqlmock.AnyArg(),   // password_hash
+				"Test User",        // full_name
+				"",                 // avatar_url
+				true,               // is_active
+				sqlmock.AnyArg(),   // last_login_at
+				sqlmock.AnyArg(),   // created_at
+				sqlmock.AnyArg(),   // updated_at
+				sqlmock.AnyArg(),   // deleted_at
+			).
+			WillReturnResult(sqlmock.NewResult(0, 1)) // UUID không có sequence ID, chỉ cần 1 row affected
+		mock.ExpectCommit()
+
+		// 5. Lấy role mặc định 'user' (roleRepo.GetByName)
+		mock.ExpectQuery("SELECT \\* FROM `roles` WHERE name = \\? ORDER BY `roles`\\.`id` LIMIT \\?").
+			WithArgs("user", 1).
+			WillReturnRows(sqlmock.NewRows([]string{"id", "name", "description", "created_at", "updated_at", "deleted_at"}).
+				AddRow(1, "user", "Basic user role", time.Now(), time.Now(), nil))
+
+		// 6. Thêm role cho user (userRepo.AddRole -> user_roles table)
+		// GORM's Create for user_roles có thể dùng 'INSERT ... ON CONFLICT'
+		mock.ExpectExec("INSERT INTO `user_roles` \\(`user_id`, `role_id`\\) VALUES \\(\\?\\, \\?\\)").
+			WithArgs(testUserID, 1).                  // user_id (UUID string), role_id (int)
+			WillReturnResult(sqlmock.NewResult(0, 1)) // Thêm thành công 1 row
+
+		// Chú ý: Vì chúng ta đã override mockUserRepo.GetByID và mockUserRepo.AddRole
+		// nên không cần mock SQL cho các query lấy thông tin user sau khi tạo
+		// mockUserRepo.GetByID sẽ trả về user đã có role được preload
+
+		// Tạo request
+		req, _ := http.NewRequest("POST", "/api/v1/auth/register", bytes.NewBuffer(jsonData))
+		req.Header.Set("Content-Type", "application/json")
+		w := httptest.NewRecorder()
+
+		// Thực thi request
+		r.ServeHTTP(w, req)
+
+		// Kiểm tra kết quả
+		assert.Equal(t, http.StatusCreated, w.Code, "Status code phải là 201")
+
+		// Parse JSON response
+		var response dto.UserResponse
+		err := json.Unmarshal(w.Body.Bytes(), &response)
+		assert.NoError(t, err, "Parse JSON không có lỗi")
+
+		// Kiểm tra thông tin phản hồi
+		assert.Equal(t, registerData.Username, response.Username, "Username phải khớp")
+		assert.Equal(t, registerData.Email, response.Email, "Email phải khớp")
+		assert.Equal(t, registerData.FullName, response.FullName, "FullName phải khớp")
+		assert.NotEmpty(t, response.ID, "ID không được rỗng")
+
+		// Kiểm tra nếu có SQL expectations nào chưa được đáp ứng
+		if err := mock.ExpectationsWereMet(); err != nil {
+			t.Errorf("Các expectations chưa được đáp ứng: %s", err)
+		}
+	})
+}
diff --git a/internal/transport/http/handler/health_handler.go b/internal/transport/http/handler/health_handler.go
new file mode 100644
index 0000000..33207f3
--- /dev/null
+++ b/internal/transport/http/handler/health_handler.go
@@ -0,0 +1,70 @@
+package handler
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"starter-kit/internal/helper/config"
+)
+
+// HealthHandler xử lý các endpoint liên quan đến sức khỏe hệ thống
+type HealthHandler struct {
+	config     *config.Config
+	startTime  time.Time
+	appVersion string
+}
+
+// NewHealthHandler tạo một handler mới cho health endpoints
+func NewHealthHandler(cfg *config.Config) *HealthHandler {
+	return &HealthHandler{
+		config:     cfg,
+		startTime:  time.Now(),
+		appVersion: cfg.App.Version,
+	}
+}
+
+// HealthCheck trả về trạng thái sức khỏe của hệ thống
+// @Summary Kiểm tra trạng thái của hệ thống
+// @Description Trả về thông tin về trạng thái của ứng dụng và các thành phần
+// @Tags Health
+// @Produce json
+// @Success 200 {object} map[string]interface{}
+// @Router /health [get]
+func (h *HealthHandler) HealthCheck(c *gin.Context) {
+	uptime := time.Since(h.startTime).String()
+	
+	// Tạo response
+	resp := gin.H{
+		"status":  "ok",
+		"app": gin.H{
+			"name":    h.config.App.Name,
+			"version": h.appVersion,
+			"env":     h.config.App.Environment,
+		},
+		"uptime": uptime,
+		// Trong môi trường thực tế, thêm kiểm tra trạng thái của database và các dịch vụ bên ngoài
+		"components": gin.H{
+			"database": "ok", // Giả định - trong thực tế sẽ kiểm tra kết nối
+			"cache":    "ok", // Giả định
+		},
+		"timestamp": time.Now().Format(time.RFC3339),
+	}
+
+	c.JSON(http.StatusOK, resp)
+}
+
+// Ping endpoint đơn giản để kiểm tra server đang chạy
+// @Summary Ping server
+// @Description Endpoint đơn giản để kiểm tra server đang hoạt động
+// @Tags Health
+// @Produce json
+// @Success 200 {object} map[string]string
+// @Router /ping [get]
+func (h *HealthHandler) Ping(c *gin.Context) {
+	c.JSON(http.StatusOK, gin.H{
+		"status":    "ok",
+		"message":   "pong",
+		"timestamp": time.Now().Format(time.RFC3339),
+	})
+}
diff --git a/internal/transport/http/handler/health_handler_test.go b/internal/transport/http/handler/health_handler_test.go
new file mode 100644
index 0000000..5fa7f0f
--- /dev/null
+++ b/internal/transport/http/handler/health_handler_test.go
@@ -0,0 +1,308 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/stretchr/testify/mock"
+
+	"starter-kit/internal/helper/config"
+)
+
+// MockConfig is a mock of config.Config
+type MockConfig struct {
+	mock.Mock
+	App config.AppConfig
+}
+
+func (m *MockConfig) GetAppConfig() *config.AppConfig {
+	args := m.Called()
+	if args.Get(0) == nil {
+		return nil
+	}
+	return args.Get(0).(*config.AppConfig)
+}
+
+func TestNewHealthHandler(t *testing.T) {
+	t.Run("creates new health handler with config", func(t *testing.T) {
+		cfg := &config.Config{
+			App: config.AppConfig{
+				Name:        "test-app",
+				Version:     "1.0.0",
+				Environment: "test",
+			},
+		}
+
+		handler := NewHealthHandler(cfg)
+
+		assert.NotNil(t, handler)
+		assert.Equal(t, cfg.App.Version, handler.appVersion)
+		assert.False(t, handler.startTime.IsZero())
+	})
+}
+
+func TestHealthCheck(t *testing.T) {
+	// Setup test cases
+	tests := []struct {
+		name           string
+		setupMock     func(*MockConfig)
+		expectedCode   int
+		expectedKeys   []string
+		checkUptime   bool
+		checkAppInfo  bool
+		expectedValues map[string]interface{}
+	}{
+		{
+			name: "successful health check",
+			setupMock: func(mc *MockConfig) {
+				mc.App = config.AppConfig{
+					Name:        "test-app",
+					Version:     "1.0.0",
+					Environment: "test",
+				}
+			},
+			expectedCode: http.StatusOK,
+			expectedKeys: []string{"status", "app", "uptime", "components", "timestamp"},
+			expectedValues: map[string]interface{}{
+				"status": "ok",
+				"app": map[string]interface{}{
+					"name":    "test-app",
+					"version": "1.0.0",
+					"env":     "test",
+				},
+				"components": map[string]interface{}{
+					"database": "ok",
+					"cache":    "ok",
+				},
+			},
+			checkUptime:  true,
+			checkAppInfo: true,
+		},
+		{
+			name: "health check with empty config",
+			setupMock: func(mc *MockConfig) {
+				mc.App = config.AppConfig{}
+			},
+			expectedCode: http.StatusOK,
+			expectedValues: map[string]interface{}{
+				"status": "ok",
+				"app": map[string]interface{}{
+					"name":    "",
+					"version": "",
+					"env":     "",
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup mock config
+			mockCfg := new(MockConfig)
+			tt.setupMock(mockCfg)
+
+			// Setup mock expectations
+			mockCfg.On("GetAppConfig").Return(&mockCfg.App)
+
+
+			// Create handler with mock config
+			handler := NewHealthHandler(&config.Config{
+				App: *mockCfg.GetAppConfig(),
+			})
+
+
+			// Create a new request
+			req := httptest.NewRequest("GET", "/health", nil)
+
+			// Create a response recorder
+			w := httptest.NewRecorder()
+
+			// Create a new router and register the handler
+			r := gin.New()
+			r.GET("/health", handler.HealthCheck)
+
+			// Serve the request
+			r.ServeHTTP(w, req)
+
+
+			// Assert the status code
+			assert.Equal(t, tt.expectedCode, w.Code)
+
+			// Parse the response body
+			var response map[string]interface{}
+			require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response), "Failed to parse response body")
+
+			// Check expected keys exist
+			for _, key := range tt.expectedKeys {
+				_, exists := response[key]
+				assert.True(t, exists, "Response should contain key: %s", key)
+			}
+
+			// Check expected values
+			for key, expectedValue := range tt.expectedValues {
+				switch v := expectedValue.(type) {
+				case map[string]interface{}:
+					actual, exists := response[key].(map[string]interface{})
+					require.True(t, exists, "Expected %s to be a map", key)
+					for subKey, subValue := range v {
+						assert.Equal(t, subValue, actual[subKey], "Mismatch for %s.%s", key, subKey)
+					}
+				default:
+					assert.Equal(t, expectedValue, response[key], "Mismatch for %s", key)
+				}
+			}
+
+			// Check uptime if needed
+			if tt.checkUptime {
+				_, exists := response["uptime"]
+				assert.True(t, exists, "Response should contain uptime")
+			}
+
+			// Check app info if needed
+			if tt.checkAppInfo {
+				appInfo, ok := response["app"].(map[string]interface{})
+				assert.True(t, ok, "app should be a map")
+				assert.Equal(t, "test-app", appInfo["name"])
+				assert.Equal(t, "1.0.0", appInfo["version"])
+				assert.Equal(t, "test", appInfo["env"])
+			}
+
+			// Check uptime is a valid duration string
+			if tt.checkUptime {
+				uptime, ok := response["uptime"].(string)
+				assert.True(t, ok, "uptime should be a string")
+				_, err := time.ParseDuration(uptime)
+				assert.NoError(t, err, "uptime should be a valid duration string")
+			}
+
+			// Check components
+			components, ok := response["components"].(map[string]interface{})
+			assert.True(t, ok, "components should be a map")
+			assert.Equal(t, "ok", components["database"])
+			assert.Equal(t, "ok", components["cache"])
+
+			// Check timestamp format
+			timestamp, ok := response["timestamp"].(string)
+			assert.True(t, ok, "timestamp should be a string")
+			_, err := time.Parse(time.RFC3339, timestamp)
+			assert.NoError(t, err, "timestamp should be in RFC3339 format")
+
+			// Assert that all expectations were met
+			mockCfg.AssertExpectations(t)
+		})
+	}
+}
+
+func TestPing(t *testing.T) {
+	// Setup test cases
+	tests := []struct {
+		name           string
+		setupMock     func(*MockConfig)
+		expectedCode   int
+		expectedValues map[string]string
+	}{
+		{
+			name: "successful ping",
+			setupMock: func(mc *MockConfig) {
+				mc.App = config.AppConfig{
+					Name:        "test-app",
+					Version:     "1.0.0",
+					Environment: "test",
+				}
+			},
+			expectedCode: http.StatusOK,
+			expectedValues: map[string]string{
+				"status":  "ok",
+				"message": "pong",
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Setup mock config
+			mockCfg := new(MockConfig)
+			tt.setupMock(mockCfg)
+
+			// Setup mock expectations
+			mockCfg.On("GetAppConfig").Return(&mockCfg.App)
+
+
+			// Create handler with mock config
+			handler := NewHealthHandler(&config.Config{
+				App: *mockCfg.GetAppConfig(),
+			})
+
+			// Create a new request
+			req := httptest.NewRequest("GET", "/ping", nil)
+
+			// Create a response recorder
+			w := httptest.NewRecorder()
+
+			// Create a new router and register the handler
+			r := gin.New()
+			r.GET("/ping", handler.Ping)
+
+			// Serve the request
+			r.ServeHTTP(w, req)
+
+
+			// Assert the status code
+			assert.Equal(t, tt.expectedCode, w.Code)
+
+			// Parse the response body
+			var response map[string]interface{}
+			require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response), "Failed to parse response body")
+
+			// Check expected values
+			for key, expectedValue := range tt.expectedValues {
+				actual, exists := response[key]
+				require.True(t, exists, "Expected key %s not found in response", key)
+				assert.Equal(t, expectedValue, actual, "Mismatch for key %s", key)
+			}
+
+			// Check timestamp is in the correct format
+			timestamp, ok := response["timestamp"].(string)
+			require.True(t, ok, "timestamp should be a string")
+			_, err := time.Parse(time.RFC3339, timestamp)
+			assert.NoError(t, err, "timestamp should be in RFC3339 format")
+
+			// Assert that all expectations were met
+			mockCfg.AssertExpectations(t)
+		})
+	}
+
+	// Test with nil config
+	t.Run("ping with nil config", func(t *testing.T) {
+		handler := &HealthHandler{}
+
+		// Create a new request
+		req := httptest.NewRequest("GET", "/ping", nil)
+
+		// Create a response recorder
+		w := httptest.NewRecorder()
+
+		// Create a new router and register the handler
+		r := gin.New()
+		r.GET("/ping", handler.Ping)
+
+		// Serve the request
+		r.ServeHTTP(w, req)
+
+		// Should still work with default values
+		assert.Equal(t, http.StatusOK, w.Code)
+
+		// Parse the response body
+		var response map[string]interface{}
+		require.NoError(t, json.Unmarshal(w.Body.Bytes(), &response), "Failed to parse response body")
+
+		assert.Equal(t, "pong", response["message"], "Response should contain message 'pong'")
+		assert.Equal(t, "ok", response["status"], "Response should contain status 'ok'")
+	})
+}
diff --git a/internal/transport/http/middleware/auth.go b/internal/transport/http/middleware/auth.go
new file mode 100644
index 0000000..076a8c1
--- /dev/null
+++ b/internal/transport/http/middleware/auth.go
@@ -0,0 +1,126 @@
+package middleware
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/gin-gonic/gin"
+	"starter-kit/internal/service"
+)
+
+const (
+	// ContextKeyUser là key dùng để lưu thông tin user trong context
+	ContextKeyUser = "user"
+)
+
+// AuthMiddleware xác thực JWT token
+type AuthMiddleware struct {
+	authSvc service.AuthService
+}
+
+// NewAuthMiddleware tạo mới AuthMiddleware
+func NewAuthMiddleware(authSvc service.AuthService) *AuthMiddleware {
+	return &AuthMiddleware{
+		authSvc: authSvc,
+	}
+}
+
+// Authenticate xác thực JWT token
+func (m *AuthMiddleware) Authenticate() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Lấy token từ header
+		authHeader := c.GetHeader("Authorization")
+		if authHeader == "" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Authorization header is required"})
+			return
+		}
+
+		// Kiểm tra định dạng token
+		parts := strings.Split(authHeader, " ")
+		if len(parts) != 2 || parts[0] != "Bearer" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid authorization header format"})
+			return
+		}
+
+		tokenString := parts[1]
+		
+		// Check for empty token
+		if tokenString == "" {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Token cannot be empty"})
+			return
+		}
+
+		// Xác thực token
+		claims, err := m.authSvc.ValidateToken(tokenString)
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Invalid or expired token"})
+			return
+		}
+
+		// Lưu thông tin user vào context
+		c.Set(ContextKeyUser, claims)
+
+		// Tiếp tục xử lý request
+		c.Next()
+	}
+}
+
+// RequireRole kiểm tra user có vai trò được yêu cầu không
+func (m *AuthMiddleware) RequireRole(roles ...string) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Lấy thông tin user từ context
+		userValue, exists := c.Get(ContextKeyUser)
+		if !exists {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, gin.H{"error": "Authentication required"})
+			return
+		}
+
+		// Ép kiểu về Claims
+		claims, ok := userValue.(*service.Claims)
+		if !ok {
+			c.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": "Invalid user data"})
+			return
+		}
+
+		// Kiểm tra vai trò
+		for _, role := range roles {
+			for _, userRole := range claims.Roles {
+				if userRole == role {
+					// Có quyền, tiếp tục xử lý
+					c.Next()
+					return
+				}
+			}
+		}
+
+		// Không có quyền
+		c.AbortWithStatusJSON(http.StatusForbidden, gin.H{
+			"error": fmt.Sprintf("Require one of these roles: %v", roles),
+		})
+	}
+}
+
+// GetUserFromContext lấy thông tin user từ context
+func GetUserFromContext(c *gin.Context) (*service.Claims, error) {
+	userValue, exists := c.Get(ContextKeyUser)
+	if !exists {
+		return nil, fmt.Errorf("user not found in context")
+	}
+
+	claims, ok := userValue.(*service.Claims)
+	if !ok {
+		return nil, fmt.Errorf("invalid user data in context")
+	}
+
+	return claims, nil
+}
+
+// GetUserIDFromContext lấy user ID từ context
+func GetUserIDFromContext(c *gin.Context) (string, error) {
+	claims, err := GetUserFromContext(c)
+	if err != nil {
+		return "", err
+	}
+	return claims.UserID, nil
+}
diff --git a/internal/transport/http/middleware/auth_test.go b/internal/transport/http/middleware/auth_test.go
new file mode 100644
index 0000000..5563783
--- /dev/null
+++ b/internal/transport/http/middleware/auth_test.go
@@ -0,0 +1,336 @@
+package middleware_test
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"starter-kit/internal/domain/user"
+	"starter-kit/internal/service"
+	"starter-kit/internal/transport/http/middleware"
+)
+
+// MockAuthService is a mock implementation of AuthService
+type MockAuthService struct {
+	mock.Mock
+}
+
+func (m *MockAuthService) Register(ctx context.Context, req service.RegisterRequest) (*user.User, error) {
+	args := m.Called(ctx, req)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*user.User), args.Error(1)
+}
+
+func (m *MockAuthService) Login(ctx context.Context, username, password string) (string, string, error) {
+	args := m.Called(ctx, username, password)
+	return args.String(0), args.String(1), args.Error(2)
+}
+
+func (m *MockAuthService) RefreshToken(refreshToken string) (string, string, error) {
+	args := m.Called(refreshToken)
+	return args.String(0), args.String(1), args.Error(2)
+}
+
+func (m *MockAuthService) ValidateToken(tokenString string) (*service.Claims, error) {
+	args := m.Called(tokenString)
+	if args.Get(0) == nil {
+		return nil, args.Error(1)
+	}
+	return args.Get(0).(*service.Claims), args.Error(1)
+}
+
+func TestNewAuthMiddleware(t *testing.T) {
+	mockAuthSvc := new(MockAuthService)
+	middleware := middleware.NewAuthMiddleware(mockAuthSvc)
+	assert.NotNil(t, middleware)
+}
+
+func TestAuthenticate_Success(t *testing.T) {
+	// Setup
+	mockAuthSvc := new(MockAuthService)
+	authMiddleware := middleware.NewAuthMiddleware(mockAuthSvc)
+
+	// Mock token validation
+	claims := &service.Claims{
+		UserID:   "user123",
+		Username: "testuser",
+		Roles:    []string{"user"},
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)),
+		},
+	}
+	mockAuthSvc.On("ValidateToken", "valid.token.here").Return(claims, nil)
+
+	// Create test router
+	r := gin.New()
+	r.GET("/protected", authMiddleware.Authenticate(), func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"status": "ok"})
+	})
+
+	// Create test request with valid token
+	req, _ := http.NewRequest("GET", "/protected", nil)
+	req.Header.Set("Authorization", "Bearer valid.token.here")
+
+	// Execute request
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	// Assert
+	assert.Equal(t, http.StatusOK, w.Code)
+	mockAuthSvc.AssertExpectations(t)
+}
+
+func TestAuthenticate_NoAuthHeader(t *testing.T) {
+	mockAuthSvc := new(MockAuthService)
+	authMiddleware := middleware.NewAuthMiddleware(mockAuthSvc)
+
+	r := gin.New()
+	r.GET("/protected", authMiddleware.Authenticate())
+
+	req, _ := http.NewRequest("GET", "/protected", nil)
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
+	assert.Contains(t, w.Body.String(), "Authorization header is required")
+}
+
+func TestAuthenticate_InvalidTokenFormat(t *testing.T) {
+	tests := []struct {
+		name          string
+		authHeader    string
+		expectedError string
+		shouldCallValidate bool
+	}{
+		{
+			name:               "no bearer",
+			authHeader:         "invalid",
+			expectedError:      "Invalid authorization header format",
+			shouldCallValidate: false,
+		},
+		{
+			name:               "empty token",
+			authHeader:         "Bearer ",
+			expectedError:      "Token cannot be empty",
+			shouldCallValidate: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			mockAuthSvc := new(MockAuthService)
+			authMiddleware := middleware.NewAuthMiddleware(mockAuthSvc)
+
+			// Create a test server with the middleware and a simple handler
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				// This handler should not be called for invalid token formats
+				t.Error("Handler should not be called for invalid token formats")
+				w.WriteHeader(http.StatusOK)
+				if _, err := w.Write([]byte("should not be called")); err != nil {
+					t.Errorf("failed to write response in unexpected handler call: %v", err)
+				}
+			}))
+			defer server.Close()
+
+			// Create a request with the test auth header
+			req, _ := http.NewRequest("GET", server.URL, nil)
+			req.Header.Set("Authorization", tt.authHeader)
+
+			// Create a response recorder
+			w := httptest.NewRecorder()
+
+			// Create a Gin context with the request and response
+			c, _ := gin.CreateTestContext(w)
+			c.Request = req
+
+			// Call the middleware directly
+			authMiddleware.Authenticate()(c)
+
+			// Check if the response has the expected status code and error message
+			if w.Code != http.StatusUnauthorized {
+				t.Errorf("Expected status code %d, got %d", http.StatusUnauthorized, w.Code)
+			}
+
+			var resp map[string]string
+			if err := json.Unmarshal(w.Body.Bytes(), &resp); err != nil {
+				t.Fatalf("Failed to unmarshal response: %v", err)
+			}
+
+			if resp["error"] != tt.expectedError {
+				t.Errorf("Expected error message '%s', got '%s'", tt.expectedError, resp["error"])
+			}
+
+			// Verify that ValidateToken was not called when it shouldn't be
+			if !tt.shouldCallValidate {
+				mockAuthSvc.AssertNotCalled(t, "ValidateToken")
+			}
+		})
+	}
+}
+
+func TestAuthenticate_InvalidToken(t *testing.T) {
+	mockAuthSvc := new(MockAuthService)
+	authMiddleware := middleware.NewAuthMiddleware(mockAuthSvc)
+
+	// Mock token validation to fail
+	errInvalidToken := errors.New("invalid token")
+	mockAuthSvc.On("ValidateToken", "invalid.token").Return((*service.Claims)(nil), errInvalidToken)
+
+	r := gin.New()
+	r.GET("/protected", authMiddleware.Authenticate())
+
+	req, _ := http.NewRequest("GET", "/protected", nil)
+	req.Header.Set("Authorization", "Bearer invalid.token")
+
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
+	assert.Contains(t, w.Body.String(), "Invalid or expired token")
+	mockAuthSvc.AssertExpectations(t)
+}
+
+func TestRequireRole_Success(t *testing.T) {
+	mockAuthSvc := new(MockAuthService)
+	authMiddleware := middleware.NewAuthMiddleware(mockAuthSvc)
+
+	// Create a test router with role-based auth
+	r := gin.New()
+	// Add a route that requires admin role
+	r.GET("/admin", authMiddleware.Authenticate(), authMiddleware.RequireRole("admin"), func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"status": "admin access granted"})
+	})
+
+	// Create a request with a valid token that has admin role
+	req, _ := http.NewRequest("GET", "/admin", nil)
+	req.Header.Set("Authorization", "Bearer admin.token")
+
+	// Mock the token validation to return a user with admin role
+	claims := &service.Claims{
+		UserID:   "admin123",
+		Username: "adminuser",
+		Roles:    []string{"admin"},
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)),
+		},
+	}
+	mockAuthSvc.On("ValidateToken", "admin.token").Return(claims, nil)
+
+	// Execute request
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	// Assert
+	assert.Equal(t, http.StatusOK, w.Code)
+	assert.Contains(t, w.Body.String(), "admin access granted")
+	mockAuthSvc.AssertExpectations(t)
+}
+
+func TestRequireRole_Unauthenticated(t *testing.T) {
+	mockAuthSvc := new(MockAuthService)
+	authMiddleware := middleware.NewAuthMiddleware(mockAuthSvc)
+
+	r := gin.New()
+	r.GET("/admin", authMiddleware.RequireRole("admin"))
+
+	req, _ := http.NewRequest("GET", "/admin", nil)
+
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusUnauthorized, w.Code)
+	assert.Contains(t, w.Body.String(), "Authentication required")
+}
+
+func TestRequireRole_Forbidden(t *testing.T) {
+	mockAuthSvc := new(MockAuthService)
+	authMiddleware := middleware.NewAuthMiddleware(mockAuthSvc)
+
+	r := gin.New()
+	r.GET("/admin", authMiddleware.Authenticate(), authMiddleware.RequireRole("admin"))
+
+	// Create a request with a valid token that doesn't have admin role
+	req, _ := http.NewRequest("GET", "/admin", nil)
+	req.Header.Set("Authorization", "Bearer user.token")
+
+	// Mock the token validation to return a user without admin role
+	claims := &service.Claims{
+		UserID:   "user123",
+		Username: "regularuser",
+		Roles:    []string{"user"},
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)),
+		},
+	}
+	mockAuthSvc.On("ValidateToken", "user.token").Return(claims, nil)
+
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+
+	assert.Equal(t, http.StatusForbidden, w.Code)
+	assert.Contains(t, w.Body.String(), "Require one of these roles: [admin]")
+	mockAuthSvc.AssertExpectations(t)
+}
+
+func TestGetUserFromContext(t *testing.T) {
+	// Setup test context with user
+	c, _ := gin.CreateTestContext(httptest.NewRecorder())
+	claims := &service.Claims{
+		UserID:   "user123",
+		Username: "testuser",
+		Roles:    []string{"user"},
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)),
+		},
+	}
+	c.Set(middleware.ContextKeyUser, claims)
+
+	// Test GetUserFromContext
+	user, err := middleware.GetUserFromContext(c)
+	assert.NoError(t, err)
+	assert.Equal(t, "user123", user.UserID)
+	assert.Equal(t, "testuser", user.Username)
+}
+
+func TestGetUserFromContext_NotFound(t *testing.T) {
+	c, _ := gin.CreateTestContext(httptest.NewRecorder())
+	_, err := middleware.GetUserFromContext(c)
+	assert.Error(t, err)
+}
+
+func TestGetUserIDFromContext(t *testing.T) {
+	// Setup test context with user
+	c, _ := gin.CreateTestContext(httptest.NewRecorder())
+	claims := &service.Claims{
+		UserID:   "user123",
+		Username: "testuser",
+		Roles:    []string{"user"},
+		RegisteredClaims: jwt.RegisteredClaims{
+			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)),
+		},
+	}
+	c.Set(middleware.ContextKeyUser, claims)
+
+	// Test GetUserIDFromContext
+	userID, err := middleware.GetUserIDFromContext(c)
+	assert.NoError(t, err)
+	assert.Equal(t, "user123", userID)
+}
+
+func TestGetUserIDFromContext_InvalidType(t *testing.T) {
+	c, _ := gin.CreateTestContext(httptest.NewRecorder())
+	c.Set(middleware.ContextKeyUser, "not a claims object")
+
+	_, err := middleware.GetUserIDFromContext(c)
+	assert.Error(t, err)
+}
diff --git a/internal/transport/http/middleware/logger.go b/internal/transport/http/middleware/logger.go
new file mode 100644
index 0000000..9427b74
--- /dev/null
+++ b/internal/transport/http/middleware/logger.go
@@ -0,0 +1,43 @@
+package middleware
+
+import (
+	"github.com/gin-gonic/gin"
+	"time"
+)
+
+// Logger là một middleware đơn giản để ghi log các request
+func Logger() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// Ghi thời gian bắt đầu xử lý request
+		start := time.Now()
+
+		// Xử lý request
+		c.Next()
+
+		// Tính thời gian xử lý
+		latency := time.Since(start)
+
+
+		// Lấy thông tin response
+		status := c.Writer.Status()
+		method := c.Request.Method
+		path := c.Request.URL.Path
+
+		// Ghi log
+		logMessage := "[GIN] " + time.Now().Format("2006/01/02 - 15:04:05") +
+			" | " + method +
+			" | " + path +
+			" | " + latency.String() +
+			" | " + c.ClientIP() +
+			" | " + c.Request.UserAgent()
+
+		if status >= 400 {
+			// Log lỗi
+			logMessage += " | " + c.Errors.ByType(gin.ErrorTypePrivate).String()
+			_, _ = gin.DefaultErrorWriter.Write([]byte(logMessage + "\n"))
+		} else {
+			// Log thông thường
+			_, _ = gin.DefaultWriter.Write([]byte(logMessage + "\n"))
+		}
+	}
+}
diff --git a/internal/transport/http/middleware/middleware.go b/internal/transport/http/middleware/middleware.go
new file mode 100644
index 0000000..db131ba
--- /dev/null
+++ b/internal/transport/http/middleware/middleware.go
@@ -0,0 +1,76 @@
+package middleware
+
+import "github.com/gin-gonic/gin"
+
+// CORSConfig chứa cấu hình CORS
+type CORSConfig struct {
+	AllowOrigins []string `yaml:"allow_origins"`
+	AllowMethods []string `yaml:"allow_methods"`
+	AllowHeaders []string `yaml:"allow_headers"`
+}
+
+// DefaultCORSConfig trả về cấu hình CORS mặc định
+func DefaultCORSConfig() CORSConfig {
+	return CORSConfig{
+		AllowOrigins: []string{"*"},
+		AllowMethods: []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"},
+		AllowHeaders: []string{"Origin", "Content-Length", "Content-Type", "Authorization"},
+	}
+}
+
+// CORS middleware xử lý CORS
+func CORS(config CORSConfig) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+		c.Next()
+	}
+}
+
+// RateLimiterConfig chứa cấu hình rate limiting
+type RateLimiterConfig struct {
+	Rate int `yaml:"rate"` // Số request tối đa trong khoảng thời gian
+}
+
+// DefaultRateLimiterConfig trả về cấu hình rate limiting mặc định
+func DefaultRateLimiterConfig() RateLimiterConfig {
+	return RateLimiterConfig{
+		Rate: 100, // 100 requests per minute
+	}
+}
+
+// NewRateLimiter tạo middleware rate limiting
+func NewRateLimiter(config RateLimiterConfig) gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// TODO: Implement rate limiting logic
+		c.Next()
+	}
+}
+
+// SecurityConfig chứa tất cả các cấu hình bảo mật
+type SecurityConfig struct {
+	// CORS configuration
+	CORS CORSConfig `yaml:"cors"`
+	// Rate limiting configuration
+	RateLimit RateLimiterConfig `yaml:"rate_limit"`
+}
+
+// DefaultSecurityConfig trả về cấu hình bảo mật mặc định
+func DefaultSecurityConfig() SecurityConfig {
+	return SecurityConfig{
+		CORS:      DefaultCORSConfig(),
+		RateLimit: DefaultRateLimiterConfig(),
+	}
+}
+
+// Apply áp dụng tất cả các middleware bảo mật vào router
+func (c *SecurityConfig) Apply(r *gin.Engine) {
+	// Áp dụng CORS middleware
+	r.Use(CORS(c.CORS))
+
+	// Áp dụng rate limiting
+	r.Use(NewRateLimiter(c.RateLimit))
+}
diff --git a/internal/transport/http/middleware/middleware_test.go b/internal/transport/http/middleware/middleware_test.go
new file mode 100644
index 0000000..cf31edc
--- /dev/null
+++ b/internal/transport/http/middleware/middleware_test.go
@@ -0,0 +1,182 @@
+package middleware_test
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+	"starter-kit/internal/transport/http/middleware"
+)
+
+// Helper function to perform a test request
+func performRequest(r http.Handler, method, path string, headers map[string]string) *httptest.ResponseRecorder {
+	req, _ := http.NewRequest(method, path, nil)
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+	w := httptest.NewRecorder()
+	r.ServeHTTP(w, req)
+	return w
+}
+
+func TestDefaultCORSConfig(t *testing.T) {
+	config := middleware.DefaultCORSConfig()
+	assert.NotNil(t, config)
+	assert.Equal(t, []string{"*"}, config.AllowOrigins)
+	assert.Equal(t, []string{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}, config.AllowMethods)
+	assert.Equal(t, []string{"Origin", "Content-Length", "Content-Type", "Authorization"}, config.AllowHeaders)
+}
+
+func TestCORS(t *testing.T) {
+	tests := []struct {
+		name           string
+		config        middleware.CORSConfig
+		headers       map[string]string
+		expectedAllowOrigin string
+		expectedStatus int
+	}{
+		{
+			name: "default config allows all origins",
+			config: middleware.DefaultCORSConfig(),
+		headers: map[string]string{
+				"Origin": "https://example.com",
+			},
+			expectedAllowOrigin: "*",
+			expectedStatus: http.StatusOK,
+		},
+		{
+			name: "specific origin allowed",
+			config: middleware.CORSConfig{
+				AllowOrigins: []string{"https://allowed.com"},
+			},
+			headers: map[string]string{
+				"Origin": "https://allowed.com",
+			},
+			expectedAllowOrigin: "*", // Our implementation always returns *
+			expectedStatus: http.StatusOK,
+		},
+		{
+			name: "preflight request",
+			config: middleware.DefaultCORSConfig(),
+			headers: map[string]string{
+				"Origin":                        "https://example.com",
+				"Access-Control-Request-Method": "GET",
+			},
+			expectedStatus: http.StatusOK, // Our implementation doesn't handle OPTIONS specially
+			expectedAllowOrigin: "*",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			r := gin.New()
+			r.Use(middleware.CORS(tt.config))
+
+			r.GET("/test", func(c *gin.Context) {
+				c.JSON(http.StatusOK, gin.H{"status": "ok"})
+			})
+
+
+			// Create a test request
+			req, _ := http.NewRequest("GET", "/test", nil)
+			for k, v := range tt.headers {
+				req.Header.Set(k, v)
+			}
+
+			w := httptest.NewRecorder()
+			r.ServeHTTP(w, req)
+
+			// Check status code
+			assert.Equal(t, tt.expectedStatus, w.Code)
+
+
+			// For non-preflight requests, check CORS headers
+			if req.Method != "OPTIONS" {
+				assert.Equal(t, tt.expectedAllowOrigin, w.Header().Get("Access-Control-Allow-Origin"))
+			}
+		})
+	}
+}
+
+func TestDefaultRateLimiterConfig(t *testing.T) {
+	config := middleware.DefaultRateLimiterConfig()
+	assert.Equal(t, 100, config.Rate)
+}
+
+func TestRateLimit(t *testing.T) {
+	// Create a rate limiter with a very low limit for testing
+	config := middleware.RateLimiterConfig{
+		Rate: 2, // 2 requests per minute for testing
+	}
+
+	r := gin.New()
+	r.Use(middleware.NewRateLimiter(config))
+
+	r.GET("/", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"status": "ok"})
+	})
+
+	// First request should pass
+	w := performRequest(r, "GET", "/", nil)
+	assert.Equal(t, http.StatusOK, w.Code)
+
+	// Second request should also pass (limit is 2)
+	w = performRequest(r, "GET", "/", nil)
+	assert.Equal(t, http.StatusOK, w.Code)
+}
+
+func TestSecurityConfig(t *testing.T) {
+	t.Run("default config", func(t *testing.T) {
+		config := middleware.DefaultSecurityConfig()
+		assert.NotNil(t, config)
+		assert.Equal(t, "*", config.CORS.AllowOrigins[0])
+		assert.Equal(t, 100, config.RateLimit.Rate)
+	})
+
+	t.Run("apply to router", func(t *testing.T) {
+		r := gin.New()
+		config := middleware.DefaultSecurityConfig()
+		config.Apply(r)
+
+		// Just verify the router has the middlewares applied
+		// The actual middleware behavior is tested separately
+		assert.NotNil(t, r)
+	})
+}
+
+func TestCORSWithCustomConfig(t *testing.T) {
+	config := middleware.CORSConfig{
+		AllowOrigins: []string{"https://custom.com"},
+		AllowMethods: []string{"GET", "POST"},
+		AllowHeaders: []string{"X-Custom-Header"},
+	}
+
+	r := gin.New()
+	r.Use(middleware.CORS(config))
+
+	r.GET("/test", func(c *gin.Context) {
+		c.JSON(http.StatusOK, gin.H{"status": "ok"})
+	})
+
+	t.Run("allowed origin", func(t *testing.T) {
+		w := performRequest(r, "GET", "/test", map[string]string{
+			"Origin": "https://custom.com",
+		})
+
+		assert.Equal(t, http.StatusOK, w.Code)
+		assert.Equal(t, "*", w.Header().Get("Access-Control-Allow-Origin"))
+	})
+
+	t.Run("preflight request", func(t *testing.T) {
+		req, _ := http.NewRequest("OPTIONS", "/test", nil)
+		req.Header.Set("Origin", "https://custom.com")
+		req.Header.Set("Access-Control-Request-Method", "GET")
+
+		w := httptest.NewRecorder()
+		r.ServeHTTP(w, req)
+
+		assert.Equal(t, http.StatusNoContent, w.Code)
+	})
+}
diff --git a/internal/transport/http/router.go b/internal/transport/http/router.go
new file mode 100644
index 0000000..62d78db
--- /dev/null
+++ b/internal/transport/http/router.go
@@ -0,0 +1,91 @@
+package http
+
+import (
+	"starter-kit/internal/adapter/persistence"
+	"starter-kit/internal/helper/config"
+	"starter-kit/internal/service"
+	"starter-kit/internal/transport/http/handler"
+	"starter-kit/internal/transport/http/middleware"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+)
+
+// SetupRouter cấu hình router cho HTTP server
+func SetupRouter(cfg *config.Config, db *gorm.DB) *gin.Engine {
+	// Khởi tạo router với mode phù hợp với môi trường
+	if cfg.App.Environment == "production" {
+		gin.SetMode(gin.ReleaseMode)
+	}
+
+	router := gin.New()
+
+	// Logger middleware
+	router.Use(middleware.Logger())
+
+	// Recovery middleware
+	router.Use(gin.Recovery())
+
+	// Apply security middleware
+	securityCfg := middleware.DefaultSecurityConfig()
+	securityCfg.Apply(router)
+
+	// Khởi tạo repositories
+	userRepo := persistence.NewUserRepository(db)
+	roleRepo := persistence.NewRoleRepository(db)
+
+	// Get JWT configuration from config
+	jwtSecret := "your-secret-key" // Default fallback
+	accessTokenExpire := 24 * time.Hour
+
+	// Override with config values if available
+	if cfg.JWT.Secret != "" {
+		jwtSecret = cfg.JWT.Secret
+	}
+	if cfg.JWT.AccessTokenExpire > 0 {
+		accessTokenExpire = time.Duration(cfg.JWT.AccessTokenExpire) * time.Minute
+	}
+
+	// Khởi tạo services
+	authSvc := service.NewAuthService(
+		userRepo,
+		roleRepo,
+		jwtSecret,
+		accessTokenExpire,
+	)
+
+	// Khởi tạo middleware
+	authMiddleware := middleware.NewAuthMiddleware(authSvc)
+	_ = authMiddleware // TODO: Use authMiddleware when needed
+
+	// Khởi tạo các handlers
+	healthHandler := handler.NewHealthHandler(cfg)
+	authHandler := handler.NewAuthHandler(authSvc)
+
+	// Đăng ký các routes
+
+	// Health check routes (public)
+	router.GET("/ping", healthHandler.Ping)
+	router.GET("/health", healthHandler.HealthCheck)
+
+	// Auth routes (public)
+	authGroup := router.Group("/api/v1/auth")
+	{
+		authGroup.POST("/register", authHandler.Register)
+		authGroup.POST("/login", authHandler.Login)
+		authGroup.POST("/refresh", authHandler.RefreshToken)
+		authGroup.POST("/logout", authMiddleware.Authenticate(), authHandler.Logout)
+	}
+
+	// Protected API routes
+	api := router.Group("/api/v1")
+	api.Use(authMiddleware.Authenticate())
+	{
+		// Ví dụ về protected endpoints
+		// api.GET("/profile", userHandler.GetProfile)
+		// api.PUT("/profile", userHandler.UpdateProfile)
+	}
+
+	return router
+}
diff --git a/internal/transport/http/server.go b/internal/transport/http/server.go
new file mode 100644
index 0000000..ca1b955
--- /dev/null
+++ b/internal/transport/http/server.go
@@ -0,0 +1,105 @@
+package http
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	"gorm.io/gorm"
+	"starter-kit/internal/helper/config"
+	"starter-kit/internal/helper/logger"
+)
+
+// ErrServerClosed is returned by the Server's Start method after a call to Shutdown
+var ErrServerClosed = errors.New("http: Server closed")
+
+// Server represents the HTTP server
+type Server struct {
+	server     *http.Server
+	config     *config.Config
+	router     *gin.Engine
+	listener   net.Listener
+	db         *gorm.DB
+	serverErr  chan error
+}
+
+// NewServer creates a new HTTP server with the given configuration
+func NewServer(cfg *config.Config, db *gorm.DB) *Server {
+	// Create a new Gin router
+	router := SetupRouter(cfg, db)
+
+	// Create the HTTP server
+	server := &http.Server{
+		Addr:         fmt.Sprintf("%s:%d", cfg.Server.Host, cfg.Server.Port),
+		Handler:      router,
+		ReadTimeout:  time.Duration(cfg.Server.ReadTimeout) * time.Second,
+		WriteTimeout: time.Duration(cfg.Server.WriteTimeout) * time.Second,
+	}
+
+	return &Server{
+		server:    server,
+		config:    cfg,
+		router:    router,
+		db:        db,
+		serverErr: make(chan error, 1),
+	}
+}
+
+// Start starts the HTTP server
+func (s *Server) Start() error {
+	// Create a listener
+	listener, err := net.Listen("tcp", s.server.Addr)
+	if err != nil {
+		return fmt.Errorf("failed to create listener: %w", err)
+	}
+	s.listener = listener
+
+	// Log server start
+	logger.WithFields(logger.Fields{
+		"address": s.server.Addr,
+	}).Info("Starting HTTP server")
+
+	// Start the server in a goroutine
+	go func() {
+		s.serverErr <- s.server.Serve(s.listener)
+		close(s.serverErr)
+	}()
+
+	// Check if server started successfully
+	select {
+	case err := <-s.serverErr:
+		return fmt.Errorf("server failed to start: %w", err)
+	case <-time.After(100 * time.Millisecond):
+		logger.Info("HTTP server started successfully")
+		return nil
+	}
+}
+
+// Shutdown gracefully shuts down the server
+func (s *Server) Shutdown(ctx context.Context) error {
+	logger.Info("Shutting down HTTP server...")
+	
+	// Try to gracefully shutdown
+	err := s.server.Shutdown(ctx)
+	if err != nil {
+		logger.WithError(err).Error("Error during server shutdown")
+		return err
+	}
+
+	logger.Info("HTTP server stopped")
+	return nil
+}
+
+// GetRouter returns the underlying router
+func (s *Server) GetRouter() *gin.Engine {
+	return s.router
+}
+
+// GetConfig returns the server configuration
+func (s *Server) GetConfig() *config.Config {
+	return s.config
+}
diff --git a/migrations/000000_initial_extensions.down.sql b/migrations/000000_initial_extensions.down.sql
new file mode 100644
index 0000000..fe8f81c
--- /dev/null
+++ b/migrations/000000_initial_extensions.down.sql
@@ -0,0 +1 @@
+DROP EXTENSION IF EXISTS "uuid-ossp";
diff --git a/migrations/000000_initial_extensions.up.sql b/migrations/000000_initial_extensions.up.sql
new file mode 100644
index 0000000..d159cc5
--- /dev/null
+++ b/migrations/000000_initial_extensions.up.sql
@@ -0,0 +1 @@
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
diff --git a/migrations/000001_create_roles_table.down.sql b/migrations/000001_create_roles_table.down.sql
new file mode 100644
index 0000000..af00f3c
--- /dev/null
+++ b/migrations/000001_create_roles_table.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS roles CASCADE;
diff --git a/migrations/000001_create_roles_table.up.sql b/migrations/000001_create_roles_table.up.sql
new file mode 100644
index 0000000..626062c
--- /dev/null
+++ b/migrations/000001_create_roles_table.up.sql
@@ -0,0 +1,14 @@
+CREATE TABLE roles (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(50) UNIQUE NOT NULL,
+    description TEXT,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Insert default roles
+INSERT INTO roles (name, description) VALUES 
+('admin', 'Quản trị viên hệ thống'),
+('manager', 'Quản lý'),
+('user', 'Người dùng thông thường'),
+('guest', 'Khách');
diff --git a/migrations/000002_create_users_table.down.sql b/migrations/000002_create_users_table.down.sql
new file mode 100644
index 0000000..1259628
--- /dev/null
+++ b/migrations/000002_create_users_table.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS users CASCADE;
diff --git a/migrations/000002_create_users_table.up.sql b/migrations/000002_create_users_table.up.sql
new file mode 100644
index 0000000..2ba25b9
--- /dev/null
+++ b/migrations/000002_create_users_table.up.sql
@@ -0,0 +1,17 @@
+CREATE TABLE users (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    username VARCHAR(50) UNIQUE NOT NULL,
+    email VARCHAR(100) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    full_name VARCHAR(100),
+    avatar_url VARCHAR(255),
+    is_active BOOLEAN DEFAULT true,
+    last_login_at TIMESTAMP WITH TIME ZONE,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    deleted_at TIMESTAMP WITH TIME ZONE
+);
+
+-- Create index for better query performance
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_users_username ON users(username);
diff --git a/migrations/000003_create_user_roles_table.down.sql b/migrations/000003_create_user_roles_table.down.sql
new file mode 100644
index 0000000..c625183
--- /dev/null
+++ b/migrations/000003_create_user_roles_table.down.sql
@@ -0,0 +1 @@
+DROP TABLE IF EXISTS user_roles CASCADE;
diff --git a/migrations/000003_create_user_roles_table.up.sql b/migrations/000003_create_user_roles_table.up.sql
new file mode 100644
index 0000000..b10179e
--- /dev/null
+++ b/migrations/000003_create_user_roles_table.up.sql
@@ -0,0 +1,26 @@
+-- Tạo bảng mà không có ràng buộc
+CREATE TABLE IF NOT EXISTS user_roles (
+    user_id UUID NOT NULL,
+    role_id INTEGER NOT NULL,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (user_id, role_id)
+);
+
+-- Tạo index cho hiệu suất truy vấn tốt hơn
+CREATE INDEX idx_user_roles_user_id ON user_roles(user_id);
+CREATE INDEX idx_user_roles_role_id ON user_roles(role_id);
+
+-- Thêm ràng buộc khóa ngoại nếu bảng tồn tại
+DO $$
+BEGIN
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'users') THEN
+        ALTER TABLE user_roles ADD CONSTRAINT fk_user_roles_user 
+            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE;
+    END IF;
+    
+    IF EXISTS (SELECT 1 FROM information_schema.tables WHERE table_name = 'roles') THEN
+        ALTER TABLE user_roles ADD CONSTRAINT fk_user_roles_role 
+            FOREIGN KEY (role_id) REFERENCES roles(id) ON DELETE CASCADE;
+    END IF;
+END
+$$;
diff --git a/templates/.env.example b/templates/.env.example
new file mode 100644
index 0000000..6dd30b0
--- /dev/null
+++ b/templates/.env.example
@@ -0,0 +1,32 @@
+# App Configuration
+APP_NAME="ULFlow Starter Kit"
+APP_VERSION="0.1.0"
+APP_ENVIRONMENT="development"
+APP_TIMEZONE="Asia/Ho_Chi_Minh"
+
+# Logger Configuration
+LOG_LEVEL="info"  # debug, info, warn, error
+
+# Server Configuration
+SERVER_HOST="0.0.0.0"
+SERVER_PORT=3000
+SERVER_READ_TIMEOUT=15
+SERVER_WRITE_TIMEOUT=15
+SERVER_SHUTDOWN_TIMEOUT=30
+
+# Database Configuration
+DATABASE_DRIVER="postgres"
+DATABASE_HOST="localhost"
+DATABASE_PORT=5432
+DATABASE_USERNAME="postgres"
+DATABASE_PASSWORD="postgres"
+DATABASE_NAME="ulflow"
+DATABASE_SSLMODE="disable"
+
+# JWT Configuration
+JWT_SECRET="your-32-byte-base64-encoded-secret-key-here"
+JWT_ACCESS_TOKEN_EXPIRE=15
+JWT_REFRESH_TOKEN_EXPIRE=30
+JWT_ALGORITHM="HS256"
+JWT_ISSUER="ulflow-starter-kit"
+JWT_AUDIENCE="ulflow-web"
\ No newline at end of file
diff --git a/templates/config.example.yaml b/templates/config.example.yaml
new file mode 100644
index 0000000..66f9ea9
--- /dev/null
+++ b/templates/config.example.yaml
@@ -0,0 +1,31 @@
+app:
+  name: "ULFlow Starter Kit"
+  version: "0.1.0"
+  environment: "development"
+  timezone: "Asia/Ho_Chi_Minh"
+
+logger:
+  level: "info" # debug, info, warn, error
+
+server:
+  host: "0.0.0.0"
+  port: 3000
+  read_timeout: 15
+  write_timeout: 15
+  shutdown_timeout: 30
+  trusted_proxies: []
+  allow_origins:
+    - "*"
+
+database:
+  driver: "postgres"
+  host: "localhost"
+  port: 5432
+  username: "postgres"
+  password: "postgres"
+  database: "ulflow"
+  ssl_mode: "disable"
+  max_open_conns: 25
+  max_idle_conns: 5
+  conn_max_lifetime: 300
+  migration_path: "migrations"
diff --git a/tomb.yaml b/tomb.yaml
new file mode 100644
index 0000000..6d5affc
--- /dev/null
+++ b/tomb.yaml
@@ -0,0 +1,55 @@
+# Tomb Configuration for ULFlow Starter Kit
+# This file configures how our application handles signals and graceful shutdown
+
+# Signal configuration
+signals:
+  # Signal to use for graceful shutdown
+  graceful: "SIGTERM"
+  # Signal to use for forceful shutdown
+  force: "SIGKILL"
+  # Timeout for graceful shutdown before force shutdown
+  timeout: "10s"
+
+# Hooks to execute during shutdown process
+hooks:
+  # Pre-shutdown hooks run before beginning shutdown
+  pre_shutdown:
+    - name: "logger"
+      command: "go"
+      args: ["run", "./scripts/shutdown_logger.go", "pre"]
+      timeout: "2s"
+      async: true
+
+  # Shutdown hooks run during shutdown
+  shutdown:
+    - name: "close-http-server"
+      timeout: "5s"
+      async: false
+
+  # Post-shutdown hooks run after shutdown completes
+  post_shutdown:
+    - name: "cleanup"
+      command: "go"
+      args: ["run", "./scripts/shutdown_logger.go", "post"]
+      timeout: "2s"
+      async: true
+
+# Resources to manage during shutdown
+resources:
+  - name: "http-server"
+    type: "http"
+    grace_period: "5s"
+  
+  - name: "database-connections"
+    type: "sql"
+    grace_period: "3s"
+
+  - name: "background-workers"
+    type: "worker"
+    grace_period: "8s"
+    
+# Monitoring configuration
+monitoring:
+  enabled: true
+  interval: "1s"
+  threshold: 5 # number of consecutive failures before alerting