██████╗ ██████╗ ██████╗ ███████╗    ██╗    ██╗███████╗██████╗ 
 ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ██║    ██║██╔════╝██╔══██╗
 ██║     ██║   ██║██████╔╝█████╗      ██║ █╗ ██║█████╗  ██████╔╝
 ██║     ██║   ██║██╔══██╗██╔══╝      ██║███╗██║██╔══╝  ██╔══██╗
 ╚██████╗╚██████╔╝██║  ██║███████╗    ╚███╔███╔╝███████╗██████╔╝
  ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝     ╚══╝╚══╝ ╚══════╝╚═════╝ 
  

Core Web

A production-ready, multi-protocol web platform built with Rust

🚀 Welcome to Core Web

Core Web is a comprehensive, production-ready web platform built with Rust that provides everything you need to build scalable, secure, and high-performance web applications. With support for multiple protocols, advanced security features, and enterprise-grade observability, Core Web is designed to handle the most demanding workloads.

 ██████╗ ██████╗ ██████╗ ███████╗    ██╗    ██╗███████╗██████╗ 
██╔════╝██╔═══██╗██╔══██╗██╔════╝    ██║    ██║██╔════╝██╔══██╗
██║     ██║   ██║██████╔╝█████╗      ██║ █╗ ██║█████╗  ██████╔╝
██║     ██║   ██║██╔══██╗██╔══╝      ██║███╗██║██╔══╝  ██╔══██╗
╚██████╗╚██████╔╝██║  ██║███████╗    ╚███╔███╔╝███████╗██████╔╝
 ╚═════╝ ╚═════╝ ╚═╝  ╚═╝╚══════╝     ╚══╝╚══╝ ╚══════╝╚═════╝ 

✨ Key Features

🌐 Multi-Protocol Support

• REST API with full CRUD operations, pagination, and ETags
• GraphQL with schema and resolvers
• gRPC with Protocol Buffer service contracts
• WebSocket/SSE for real-time communication

🗄️ Multi-Database Integration

• MySQL - Primary transactional database
• Redis - Caching, session storage, and pub/sub messaging
• MongoDB - Document storage for flexible schemas
• ClickHouse - Analytics and time-series data warehouse

🔒 Advanced Security

• Authentication: JWT, OIDC, and API key support
• Authorization: RBAC and ABAC with Casbin/Cedar
• Security Headers: HSTS, CSP, CORS/CSRF protection
• Compliance: Data protection regulation compliance

📈 Observability & Monitoring

• Distributed Tracing with OpenTelemetry
• Metrics Collection and dashboarding
• Structured Logging with multiple output formats
• Health Checks with Kubernetes-ready endpoints

⚡ Performance & Resilience

• Caching Layers: In-memory (Moka) and Redis distributed caching
• Resilience Patterns: Retry, Circuit Breaker, Bulkhead, Timeout
• Rate Limiting: Token bucket algorithm
• Idempotency: Redis-backed POST idempotency

🛠️ Developer Experience

• Auto-generated SDKs for REST and gRPC clients
• Comprehensive API Documentation
• WASM Plugin System for extensibility
• CLI Tooling for management and operations

📦 Architecture Overview

┌─────────────────────────────────────────────────────────────┐
│                    Load Balancer/Proxy                      │
└─────────────────────┬───────────────────────────────────────┘
                      │
┌─────────────────────┴───────────────────────────────────────┐
│                    Core Web Server (8080)                   │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐ │
│  │   REST API  │  │  GraphQL    │  │       gRPC          │ │
│  └─────────────┘  └─────────────┘  └─────────────────────┘ │
│  ┌─────────────────────────────────────────────────────────┐ │
│  │                 Authentication & AuthZ                  │ │
│  └─────────────────────────────────────────────────────────┘ │
└─────────────────────┬───────────────────────────────────────┘
                      │
        ┌─────────────┼─────────────┐            ┌────────────┐
        │             │             │            │            │
┌───────▼──┐   ┌──────▼──┐  ┌───────▼──┐  ┌──────▼──┐   ┌─────▼──────┐
│  MySQL   │   │  Redis  │  │ MongoDB  │  │ClickHouse│   │ WASM Host  │
│ (Primary)│   │(Caching)│  │(Documents)│  │(Analytics)│   │ (Plugins)  │
└──────────┘   └─────────┘  └──────────┘  └──────────┘   └────────────┘
        │             │             │            │            │
        └─────────────┼─────────────┘            │            │
                      │                          │            │
              ┌───────▼───────┐          ┌───────▼──────┐     │
              │ Job Workers   │          │   Events     │     │
              │ (Background)  │          │ (Streaming)  │     │
              └───────────────┘          └──────────────┘     │
                      │                          │            │
              ┌───────▼───────┐          ┌───────▼──────┐     │
              │ Outbox Pattern│          │ Redis Streams│     │
              │   Publisher   │          │  Consumer    │     │
              └───────────────┘          └──────────────┘     │
                                                             │
                                                     ┌───────▼───────┐
                                                     │ Admin Dashboard│
                                                     │   (Yew/WASM)  │
                                                     └───────────────┘

🚀 Quick Start

Prerequisites

• Rust (latest stable version)
• Docker and Docker Compose
• Git

1. Clone the Repository

git clone https://github.com/your-org/core-web.git
cd core-web

2. Start Supporting Services

./scripts/dev-up.sh

3. Run the Main Web Server

cd apps/core-web
cargo run

The server will start on port 8080. Visit http://localhost:8080/healthz to verify it's running.

🧪 Testing

Run the full test suite:

cargo test

📚 Documentation

• How to Run the Project
• Architecture Overview
• API Reference
• Feature Flags
• Crate Stack
• Framework Comparison - How Core Web compares to Axum, Rocket, and other frameworks
• Framework Roadmap - Path to becoming a modular framework
• Framework Implementation Guide - Markup signs and focus areas for framework development
• Framework Implementation Status - Current status and missing features

🛠️ CLI Tool

Core Web includes a powerful CLI tool for managing the application:

# Navigate to the CLI crate
cd crates/core-cli

# Run CLI commands
cargo run -- --help        # Show help
cargo run -- start         # Start the server
cargo run -- status        # Check server status
cargo run -- health        # Run health checks
cargo run -- logs          # View logs

🛡️ Security

Core Web takes security seriously. We implement several measures to ensure the safety and integrity of our codebase:

• Automated Security Scanning: CodeQL analysis runs on every push and pull request
• Dependency Monitoring: Dependabot keeps dependencies up-to-date and alerts on vulnerabilities
• Security Audits: Regular cargo-audit scans for known vulnerabilities in dependencies
• Secure Coding Practices: Following Rust community guidelines for secure development
• Branch Protection: Main branch is protected with required status checks and code reviews
• GitHub Rulesets: Enhanced policy enforcement for commits and file modifications

For security-related issues, please see our Security Policy.

📈 Performance

Core Web is optimized for high performance:

• Built with async Rust for maximum efficiency
• Zero-copy serialization with Serde
• Connection pooling for database access
• Efficient caching strategies
• HTTP/2 and HTTP/3 support

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details on how to get started.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a pull request

Please also read our Code of Conduct before contributing.

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Built with Rust
• Powered by Axum web framework
• Database access with SQLx
• Observability with OpenTelemetry
• Containerization with Docker

📞 Support

For support, please open an issue on GitHub.

Project Maintainers:

• Seng Keat
• Jonathan Seng

🚀 Scaling Up

Core Web is designed with scalability in mind. The architecture supports horizontal scaling through:

• Microservices Pattern: Independent services that can be scaled separately
• Load Balancing: Distribute traffic across multiple instances
• Database Sharding: Horizontal partitioning of data across multiple databases
• Caching Layers: Redis clustering for distributed caching
• Containerization: Docker support for easy deployment and scaling
• Kubernetes Ready: Deployment manifests included for orchestration

To scale the application:

1. Vertical Scaling: Increase resources (CPU, RAM) for existing instances
2. Horizontal Scaling: Add more instances behind a load balancer
3. Database Scaling: Implement read replicas and sharding strategies
4. Caching: Expand Redis cluster for better performance
5. Background Jobs: Scale job workers independently based on workload

For production deployments, consider using the provided Kubernetes manifests in the k8s/ directory to orchestrate scaling automatically based on metrics and resource usage.

---

Made with ❤️ and 🦀 Rust