Summerrs Admin

中文 | English

Full-stack Rust admin system · Database sharding, multi-tenant isolation, MCP service, declarative macros — all in one binary

Core Capabilities · Architecture · Project Structure · Frontend & Docs

What It Is

summerrs-admin is a production-grade admin system written entirely in Rust, built on top of the Summer framework (a Spring-style application skeleton for Rust). It bundles capabilities that usually require a whole backend team to assemble — authentication, multi-tenancy, real-time messaging, object storage, declarative auditing — into a single binary via a plugin composition model. Use what you need, ignore what you don't.

It is not a demo, nor a showcase of any single component — it is a complete, self-contained, deployable backend foundation.

How It Differs From Similar Projects

summerrs-admin leverages Rust's zero-cost abstractions, type safety, and compile-time guarantees to integrate capabilities that typically require multiple independent services into a single high-performance binary:

Core Rust Advantages:

• Single Binary Deployment — No JVM/interpreter required, instant startup
• Memory Safety — Eliminates data races and memory leaks at compile time
• High Performance — Zero-cost abstractions, performance close to C/C++
• Type Safety — Catches most errors at compile time, reducing runtime failures

Architecture

The system is built around plugin composition. crates/app/src/main.rs is the assembly point — plugins fed into App::new() in order:

                    HTTP 8080
                       │
                       ▼
        ┌──────────────────────────────────┐
        │  Tower middleware (CORS /        │
        │  compression / panic guard /     │
        │  client IP extraction)           │
        └──────────────┬───────────────────┘
                       │
                       ▼
                  /api/* (JWT)
                  summer-system
                       │
                       ▼
        ┌──────────────────────────────────┐
        │  Declarative macro layer         │
        │  #[login] #[has_perm]            │
        │  #[has_role] #[rate_limit]       │
        │  #[operation_log]                │
        └──────────────┬───────────────────┘
                       │
                       ▼
        ┌──────────────────────────────────┐
        │  Sharding / SQL rewrite layer    │
        │  Tenant context injection        │
        └──────┬─────────────┬─────────────┘
               ▼             ▼
          PostgreSQL 17    Redis 7
          (primary)        (sessions / cache / rate limit)
                                │
                                ▼
                    Socket.IO / background jobs / S3

Core Capabilities

Authentication & Authorization

• Multi-algorithm JWT — HS256 / RS256 / ES256 / EdDSA, key rotation supported
• Bitmap RBAC — Permission bitmap compression to reduce transmission size
• Declarative macros — #[login] #[has_perm("user:create")] #[has_role("admin")] #[public]
• Session governance — concurrent login limits, per-device caps, token refresh, force logout

Multi-Tenancy & Database

• Four isolation tiers

  Mode	Suited for	Mechanism
  shared_row	Most SaaS	SQL rewrite injects tenant_id filter
  separate_table	Mid isolation	Physical sharding (user_001 / user_002)
  separate_schema	Strong isolation	PostgreSQL schema-level separation
  separate_database	Full isolation	Each tenant gets its own physical database

• SQL rewrite engine — tenant context injected transparently, business code untouched

• CDC pipeline — change data capture across tenants

MCP Server Integration

• Schema discovery — AI assistants can introspect the database schema
• Code generation — generate CRUD modules through dialogue
• Menu / dictionary auto-deploy — prompt-driven persistence
• Underlying — built on rmcp (the official Rust MCP SDK), supporting both stdio and streamable-http transports

Real-time & Background Processing

• Socket.IO — bidirectional real-time, session state in Redis (horizontally scalable)
• Background task queue — typed jobs, 4 workers by default, capacity 4096
• Batch logging — operation logs flushed asynchronously, off the hot path
• Cron jobs — driven by tokio-cron-scheduler

Storage & Utilities

• S3-compatible storage — AWS S3 / MinIO / RustFS, multipart upload up to 5 GB
• IP geolocation — IP2Region xdb embedded, login logs auto-attributed
• i18n — compile-time, currently zh / en
• Rate limiting — 5 algorithms: fixed window, sliding window, token bucket, leaky bucket, Lua script
• OpenAPI docs — at /docs, with Swagger UI

Project Structure

summerrs-admin/
├── crates/
│   ├── app/                          # binary entry, assembles all plugins
│   ├── summer-admin-macros/          # declarative macros (#[login] / #[has_perm] etc.)
│   ├── summer-auth/                  # JWT auth + path policy
│   ├── summer-common/                # shared types & utilities
│   ├── summer-domain/                # domain models (entities / VOs)
│   ├── summer-sharding/              # sharding / multi-tenancy middleware
│   ├── summer-mcp/                   # MCP server
│   ├── summer-plugins/               # S3 / IP2Region / background jobs etc.
│   └── summer-system/                # system business (RBAC / users / menus / Socket.IO)
│       └── model/
├── config/                           # multi-env configs (dev / prod / test)
├── sql/                              # database source of truth
│   ├── sys/                          # system domain (users / menus / perms / logs)
│   ├── tenant/                       # tenant control plane
│   └── biz/                          # B/C-side business
├── doc/                              # deployment / migration / technical guides
├── docs/                             # research, surveys, reference materials
├── locales/                          # i18n resources
├── build-tools/                      # fmt / clippy / pre-commit scripts
├── docker-compose.yml                # one-shot stack: postgres + redis + rustfs + app
└── Dockerfile                        # multi-stage build

Frontend & Docs

Frontend Project

Frontend implementation based on Ant Design Pro:

• Repository: art-design-pro

Documentation Site

Project documentation and guides: https://ouywm.github.io/summer-admin-site/