DeepSeek JavaScript Architecture for task management app

Design a production-ready software architecture for a task management app using JavaScript with Nuxt.js + Supabase.

**Leverage DeepSeek strengths:** This task requires deep technical reasoning about code architecture, design patterns, and implementation details where your coding capabilities excel.

**Developer context:** I am a junior developer building this system.

## Architecture Requirements

### System Overview
- Define the high-level architecture pattern (monolith, microservices, serverless, etc.)
- Justify the architecture choice for a task management app at this scale
- Create a component diagram showing all major modules and their interactions
- Define the data flow from user input through processing to output

### Core Module Design
For each of the 5-7 core modules, provide:
1. **Module name and responsibility** (single responsibility principle)
2. **Public API/Interface** in JavaScript syntax
3. **Key data structures** and type definitions
4. **Dependencies** on other modules (with dependency direction)
5. **Design pattern** used and why (Repository, Strategy, Observer, etc.)

### Database Architecture
- Schema design with tables/collections and relationships
- Indexing strategy for common query patterns
- Data access layer pattern (Repository, ORM configuration, query builders)
- Migration strategy and versioning approach

### API Design
- RESTful or GraphQL endpoint definitions
- Request/response schemas with validation rules
- Authentication and authorization middleware pipeline
- Rate limiting and throttling strategy
- API versioning approach

### Error Handling Architecture
- Global error handling strategy
- Custom error types hierarchy in JavaScript
- Error logging and monitoring integration
- User-facing error response formatting
- Retry and circuit breaker patterns for external services

### Testing Architecture
- Unit testing strategy with example test structure in JavaScript
- Integration testing approach for Nuxt.js + Supabase
- Test data management and factory patterns
- Coverage targets and critical paths to test

### Performance Considerations
- Caching strategy (what to cache, invalidation rules, cache layers)
- Query optimization guidelines
- Async processing for heavy operations
- Connection pooling and resource management

### Security Architecture
- Input validation and sanitization pipeline
- Authentication flow (JWT, OAuth, session-based)
- Authorization model (RBAC, ABAC, or policy-based)
- Secret management approach
- OWASP top 10 mitigation checklist for task management app

### Deployment Architecture
- Environment configuration management
- CI/CD pipeline stages
- Docker or container configuration overview
- Monitoring and observability stack
- Scaling strategy (horizontal, vertical, auto-scaling rules)

Provide actual JavaScript code snippets for the key architectural components. Focus on clean, maintainable patterns that a team can build on.