Todo Microservices Application

📋 Table of Contents

🏗 Architecture Overview

┌─────────────────────────────────────────────┐
│                   Nginx                      │
│              (Reverse Proxy)                 │
│                 Port: 80                     │
└────────────────────┬─────────────────────────┘
                     │
         ┌───────────┼───────────┐
         │           │           │
    ┌────▼────┐ ┌────▼────┐ ┌───▼────┐
    │Frontend │ │  User   │ │  Todo  │
    │ (React) │ │ Service │ │Service │
    │   :80   │ │  :3001  │ │ :3002  │
    └─────────┘ └────┬────┘ └───┬────┘
                     │           │
                ┌────▼────┐ ┌────▼────┐
                │  MySQL  │ │  MySQL  │
                │ userdb  │ │ tododb  │
                └─────────┘ └─────────┘

Services:

🛠 Tech Stack

Backend

Frontend

DevOps

📦 Prerequisites

For Local Development:

For Docker Deployment:

Verify Installation:

# Local development
node --version    # Should output v16.x.x or higher
npm --version     # Should output v7.x.x or higher
mysql --version   # Should output 8.x.x

# Docker deployment
docker --version
docker-compose --version

📁 Project Structure

todo-microservices/
├── user-service/
│   ├── src/
│   │   ├── config/         # Database and environment config
│   │   ├── controllers/    # Request handlers
│   │   ├── middlewares/    # Custom middleware
│   │   ├── models/         # Database models
│   │   ├── routes/         # API routes
│   │   ├── services/       # Business logic
│   │   ├── utils/          # Utility functions
│   │   ├── validators/     # Input validation schemas
│   │   ├── types/          # TypeScript types
│   │   ├── app.ts          # Express app setup
│   │   └── index.ts        # Entry point
│   ├── tests/
│   │   ├── unit/           # Unit tests
│   │   ├── integration/    # Integration tests
│   │   └── setup.ts        # Test configuration
│   ├── Dockerfile          # Docker configuration
│   ├── Dockerfile.dev      # Development Docker config
│   ├── package.json
│   ├── tsconfig.json
│   ├── jest.config.js
│   ├── .env
│   ├── .dockerignore
│   └── nodemon.json
│
├── todo-service/
│   ├── src/
│   │   └── [Similar structure as user-service]
│   ├── tests/
│   │   └── [Similar structure as user-service]
│   ├── Dockerfile
│   ├── Dockerfile.dev
│   └── [Similar config files]
│
├── frontend/
│   ├── public/
│   ├── src/
│   │   ├── components/     # Reusable components
│   │   ├── pages/          # Page components
│   │   ├── services/       # API services
│   │   ├── utils/          # Utility functions
│   │   ├── App.js          # Main App component
│   │   └── index.js        # Entry point
│   ├── Dockerfile
│   ├── nginx.conf          # Nginx configuration
│   ├── package.json
│   └── .env
│
├── docker-compose.yml       # Production Docker orchestration
├── docker-compose.dev.yml   # Development Docker orchestration
├── Makefile                # Convenience commands
├── init-db/
│   └── init.sql            # Database initialization
└── README.md               # This file

🚀 Installation & Setup

Option 1: Quick Start with Docker (Recommended)

# Clone the repository
git clone <repository-url>
cd todo-microservices

# Create environment file
cp .env.docker .env

# Build and run all services
docker-compose up -d

# Application will be available at:
# - Frontend: http://localhost
# - User Service: http://localhost:3001
# - Todo Service: http://localhost:3002

Option 2: Local Development Setup

git clone <repository-url>
cd todo-microservices

-- Login to MySQL
mysql -u root -p

-- Create databases
CREATE DATABASE IF NOT EXISTS userdb;
CREATE DATABASE IF NOT EXISTS tododb;

-- Create users
CREATE USER IF NOT EXISTS 'userservice'@'localhost' IDENTIFIED BY 'userpass123';
CREATE USER IF NOT EXISTS 'todoservice'@'localhost' IDENTIFIED BY 'todopass123';

-- Grant privileges
GRANT ALL PRIVILEGES ON userdb.* TO 'userservice'@'localhost';
GRANT ALL PRIVILEGES ON tododb.* TO 'todoservice'@'localhost';
FLUSH PRIVILEGES;

EXIT;

# User Service
cd user-service
npm install
cp .env.example .env  # Edit with your config
npm run dev

# Todo Service (new terminal)
cd todo-service
npm install
cp .env.example .env  # Edit with your config
npm run dev

# Frontend (new terminal)
cd frontend
npm install
cp .env.example .env  # Edit with your config
npm start

🐳 Docker Deployment

Production Deployment

# Build and start all services
docker-compose up -d

# View logs
docker-compose logs -f

# Stop all services
docker-compose down

# Rebuild after code changes
docker-compose up -d --build

Development with Hot Reload

# Use development compose file
docker-compose -f docker-compose.dev.yml up

# Services will auto-reload on code changes

Docker Commands Reference

# Build images
docker-compose build

# Start services in background
docker-compose up -d

# View running containers
docker-compose ps

# View logs for specific service
docker-compose logs -f user-service

# Execute command in container
docker-compose exec user-service sh

# Stop and remove everything
docker-compose down -v

# Rebuild specific service
docker-compose up -d --build user-service

Using Makefile

make help        # Show available commands
make build       # Build all images
make up          # Start all services
make down        # Stop all services
make logs        # View logs
make test        # Run all tests
make clean       # Clean up everything

🧪 Testing

Test Coverage Summary

Running Tests

# User Service
cd user-service
npm test

# Todo Service
cd todo-service
npm test

# Unit tests only
npm run test:unit

# Integration tests only
npm run test:integration

# Tests with coverage report
npm run test:coverage

# Tests in watch mode
npm run test:watch

# Run tests in Docker containers
docker-compose exec user-service npm test
docker-compose exec todo-service npm test

# Or use Makefile
make test

Test Database Setup

-- Create test databases
CREATE DATABASE IF NOT EXISTS test_userdb;
CREATE DATABASE IF NOT EXISTS test_tododb;

-- Grant permissions
GRANT ALL PRIVILEGES ON test_userdb.* TO 'root'@'localhost';
GRANT ALL PRIVILEGES ON test_tododb.* TO 'root'@'localhost';
FLUSH PRIVILEGES;

Test Examples

it('Should register a new user with valid credentials', async () => {
  const response = await request(app)
    .post('/api/auth/register')
    .send({
      email: 'test@example.com',
      password: 'Test123'
    })
    .expect(201);

  expect(response.body.success).toBe(true);
  expect(response.body.data).toHaveProperty('token');
});

it('Should create a todo for authenticated user', async () => {
  const response = await request(app)
    .post('/api/todos')
    .set('Authorization', `Bearer ${validToken}`)
    .send({ content: 'Test todo' })
    .expect(201);

  expect(response.body.data.content).toBe('Test todo');
});

📚 API Documentation

Base URLs

Authentication Flow

sequenceDiagram
    Client->>User Service: POST /api/auth/login
    User Service-->>Client: JWT Token
    Client->>Todo Service: GET /api/todos (with JWT)
    Todo Service->>Todo Service: Validate JWT
    Todo Service-->>Client: Todo List

Endpoints Summary

Postman Collection

Example Requests

curl -X POST http://localhost:3001/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email": "user@example.com", "password": "Test123"}'

curl -X POST http://localhost:3002/api/todos \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_JWT_TOKEN" \
  -d '{"content": "Complete project"}'

🔧 Environment Variables

User Service (.env)

NODE_ENV=development
PORT=3001
DB_HOST=localhost
DB_PORT=3306
DB_USER=userservice
DB_PASSWORD=userpass123
DB_NAME=userdb
JWT_SECRET=your-super-secret-jwt-key
JWT_EXPIRES_IN=24h
ALLOWED_ORIGINS=http://localhost:3000

Todo Service (.env)

NODE_ENV=development
PORT=3002
DB_HOST=localhost
DB_PORT=3306
DB_USER=todoservice
DB_PASSWORD=todopass123
DB_NAME=tododb
JWT_SECRET=your-super-secret-jwt-key  # Must match User Service
ALLOWED_ORIGINS=http://localhost:3000

Frontend (.env)

REACT_APP_USER_SERVICE_URL=http://localhost:3001
REACT_APP_TODO_SERVICE_URL=http://localhost:3002

Docker Environment (.env.docker)

# MySQL
MYSQL_ROOT_PASSWORD=rootpass123

# Services
NODE_ENV=production
JWT_SECRET=your-super-secret-jwt-key
JWT_EXPIRES_IN=24h

# Ports
USER_SERVICE_PORT=3001
TODO_SERVICE_PORT=3002
FRONTEND_PORT=80

🐛 Troubleshooting

Common Issues and Solutions

# Check logs
docker-compose logs service-name

# Rebuild from scratch
docker-compose down -v
docker-compose up --build

# Wait for MySQL to be ready
docker-compose exec mysql-db mysqladmin ping -h localhost

# Check database exists
docker-compose exec mysql-db mysql -u root -prootpass123 -e "SHOW DATABASES;"

# Ensure test database has correct schema
npm run test:setup

# Or manually sync schema
npm run typeorm schema:sync

// Update ALLOWED_ORIGINS in .env
ALLOWED_ORIGINS=http://localhost:3000,http://localhost:8080

// Restart services after change

# Find and kill process
lsof -i :3001  # Mac/Linux
kill -9 <PID>

# Or change port in .env
PORT=3003

Development Guidelines

👥 Authors

🙏 Acknowledgments

📊 Project Status