# Clone the repository
git clone https://github.com/materi/materi.git
cd materi/api

# Install Go dependencies
go mod download

# Copy environment configuration
cp .env.example .env.development

# Using Docker Compose (recommended)
docker-compose up -d postgres redis

# Or using Make from repository root
cd ..
make start-deps

# Create database
make db-create ENV=development

# Apply migrations
make migrate-up ENV=development

# With hot reload
make dev

# Or without hot reload
make run

api/
├── cmd/
│   ├── api/
│   │   └── main.go          # Application entry point
│   └── migrate/
│       └── main.go          # Migration tool
├── internal/
│   ├── config/              # Configuration loading
│   ├── controller/          # HTTP handlers
│   ├── middleware/          # HTTP middleware
│   ├── model/               # Domain models
│   ├── repository/          # Data access layer
│   ├── service/             # Business logic
│   ├── infra/               # Infrastructure (DB, Redis)
│   └── wire/                # Dependency injection
├── migrations/              # SQL migration files
├── pkg/                     # Shared utilities
├── test/                    # Test utilities and fixtures
├── .env.example             # Environment template
├── Makefile                 # Build commands
├── go.mod                   # Go dependencies
└── Dockerfile               # Container definition

# Core Configuration
ENVIRONMENT=development
API_PORT=8080
LOG_LEVEL=debug

# Database
DATABASE_URL=postgresql://postgres:postgres@localhost:5432/materi_dev
DATABASE_POOL_SIZE=20
DATABASE_TIMEOUT=30s

# Redis
REDIS_URL=redis://localhost:6379/0
REDIS_POOL_SIZE=50

# Authentication
JWT_PUBLIC_KEY_PATH=./certs/jwt.pub
SHIELD_URL=http://localhost:8000
SHIELD_INTERNAL_SECRET=dev-secret

# AI Services (optional for development)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...

# Feature Flags
ENABLE_AI_FEATURES=true
ENABLE_COLLABORATION=true

# Using Kubernetes secrets
kubectl create secret generic api-secrets \
  --from-literal=DATABASE_URL='postgresql://...' \
  --from-literal=REDIS_URL='redis://...'

# Using AWS Secrets Manager
aws secretsmanager get-secret-value --secret-id materi/api/prod

# Using Make
make db-create ENV=development

# Manually
createdb -h localhost -U postgres materi_dev

# Apply all pending migrations
make migrate-up ENV=development

# Rollback last migration
make migrate-down ENV=development

# Check migration status
make migrate-status ENV=development

# Create migration files
make migrate-create NAME=add_users_table

# This creates:
# migrations/YYYYMMDDHHMMSS_add_users_table.up.sql
# migrations/YYYYMMDDHHMMSS_add_users_table.down.sql

# Apply seed data
make db-seed ENV=development

# Or run specific seed file
psql -d materi_dev -f seeds/development.sql

# Development with hot reload (recommended)
make dev

# Development without hot reload
make run

# Build and run optimized binary
make build && ./bin/api

# Generate dependency injection code (Wire)
make generate

# Generate SQL query types (sqlc)
make sqlc-generate

# Generate Protocol Buffer types
make proto-generate

# Run all tests
make test

# Run with coverage
make test-coverage

# Run specific package tests
go test -v ./internal/service/...

# Run single test
go test -v -run TestDocumentService_Create ./internal/service/

# Run linter
make lint

# Format code
make format

# Run security scanner
make security

{
  "go.useLanguageServer": true,
  "go.lintTool": "golangci-lint",
  "go.lintFlags": ["--fast"],
  "go.formatTool": "goimports",
  "editor.formatOnSave": true,
  "[go]": {
    "editor.codeActionsOnSave": {
      "source.organizeImports": true
    }
  },
  "go.testFlags": ["-v"],
  "go.coverOnSave": true,
  "go.coverageDecorator": {
    "type": "highlight"
  }
}

# Build development image
docker build -t materi-api:dev .

# Build with build args
docker build \
  --build-arg VERSION=1.2.3 \
  --build-arg GIT_COMMIT=$(git rev-parse HEAD) \
  -t materi-api:1.2.3 .

# Run with environment file
docker run -p 8080:8080 --env-file .env.development materi-api:dev

# Run with Docker Compose
docker-compose up api

# docker-compose.yml
services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "8080:8080"
    environment:
      - DATABASE_URL=postgresql://postgres:postgres@postgres:5432/materi
      - REDIS_URL=redis://redis:6379
    depends_on:
      - postgres
      - redis

  postgres:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: materi
    ports:
      - "5432:5432"
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7
    ports:
      - "6379:6379"

volumes:
  postgres_data:

# Create migration
make migrate-create NAME=add_documents_index

# Edit the generated files
vim migrations/YYYYMMDDHHMMSS_add_documents_index.up.sql
vim migrations/YYYYMMDDHHMMSS_add_documents_index.down.sql

# Test migration
make migrate-up ENV=development
make migrate-down ENV=development
make migrate-up ENV=development

# Check PostgreSQL is running
pg_isready -h localhost -p 5432

# Test connection
psql -h localhost -U postgres -d materi_dev -c "SELECT 1"

# Check connection pool
make db-pool-status

# Check Redis is running
redis-cli ping

# Check connection info
redis-cli INFO clients

# Clean build cache
go clean -cache

# Update dependencies
go mod tidy
go mod download

# Regenerate code
make clean
make generate

# Run with verbose output
go test -v ./...

# Check test database
make db-test-reset

# Run single test with debug
go test -v -run TestName ./internal/service/ 2>&1 | tee test.log