Crate allframe_core 

AllFrame Core

The Composable Rust API Framework - Protocol-agnostic routing, CQRS/ES, resilience patterns, and beautiful API documentation.

AllFrame is the first Rust web framework designed, built, and evolved exclusively through Test-Driven Development (TDD) with 500+ tests.

Features at a Glance

Feature	Description
🔀 Protocol-Agnostic	Write once, expose via REST, GraphQL, and gRPC
📖 Auto Documentation	Scalar UI, GraphiQL, gRPC Explorer built-in
🔄 CQRS/Event Sourcing	85% boilerplate reduction with CommandBus, Projections, Sagas
🛡️ Resilience Patterns	Retry, Circuit Breaker, Rate Limiting
🔒 Security Utilities	Safe logging, credential obfuscation
💉 Compile-time DI	Dependency injection resolved at compile time
📊 OpenTelemetry	Automatic tracing and metrics
📱 Offline-First	SQLite event store, sync engine, zero network deps

Quick Start

Add to your Cargo.toml:

[dependencies]
allframe = "0.1"
tokio = { version = "1", features = ["full"] }

Basic Router Example

use allframe_core::router::{Router, RestAdapter, ProtocolAdapter};

#[tokio::main]
async fn main() {
    // Create a router
    let mut router = Router::new();

    // Register handlers - works with any protocol!
    router.register("get_users", || async {
        r#"[{"id": 1, "name": "Alice"}]"#.to_string()
    });

    router.register("create_user", || async {
        r#"{"id": 2, "name": "Bob"}"#.to_string()
    });

    // Expose via REST
    let mut rest = RestAdapter::new();
    rest.route("GET", "/users", "get_users");
    rest.route("POST", "/users", "create_user");

    println!("Router configured with {} handlers", 2);
}

Protocol-Agnostic Handler

use allframe_core::router::{Router, RestAdapter, GraphQLAdapter, GrpcAdapter};

// Same handler, multiple protocols!
let mut router = Router::new();
router.register("get_user", || async {
    r#"{"id": 42, "name": "John"}"#.to_string()
});

// REST: GET /users/42
let mut rest = RestAdapter::new();
rest.route("GET", "/users/:id", "get_user");

// GraphQL: query { user(id: 42) { name } }
let mut graphql = GraphQLAdapter::new();
graphql.query("user", "get_user");

// gRPC: UserService.GetUser
let mut grpc = GrpcAdapter::new();
grpc.unary("UserService", "GetUser", "get_user");

Feature Flags

AllFrame uses feature flags to minimize binary size. Only enable what you need:

Feature	Description	Default
router	Protocol-agnostic routing	✅
router-graphql	GraphQL adapter with async-graphql	❌
router-grpc	gRPC adapter with tonic	❌
di	Compile-time dependency injection	✅
cqrs	CQRS + Event Sourcing infrastructure	✅
otel	OpenTelemetry tracing	✅
health	Health check endpoints	✅
resilience	Retry, Circuit Breaker, Rate Limiting	❌
security	Safe logging, credential obfuscation	❌
cqrs-sqlite	SQLite event store (WAL mode)	❌
offline	Full offline bundle (cqrs + sqlite + di + security)	❌

Feature Examples

# Minimal REST API
allframe = { version = "0.1", default-features = false, features = ["router"] }

# Full-stack with resilience
allframe = { version = "0.1", features = ["resilience", "security"] }

# Multi-protocol gateway
allframe = { version = "0.1", features = ["router-graphql", "router-grpc"] }

# Offline desktop app (zero network deps)
allframe = { version = "0.1", features = ["offline"] }

Module Overview

• router - Protocol-agnostic request routing (REST, GraphQL, gRPC)
• shutdown - Graceful shutdown utilities
• cache - Caching infrastructure
• cqrs - CQRS + Event Sourcing (requires cqrs feature)
• resilience - Retry, Circuit Breaker, Rate Limiting (requires resilience feature)
• security - Safe logging and credential obfuscation (requires security feature)
• di - Compile-time dependency injection (requires di feature)
• otel - OpenTelemetry instrumentation (requires otel feature)
• health - Health check infrastructure (requires health feature)

Examples

See the examples directory for complete working examples:

• scalar_docs.rs - REST API with Scalar documentation
• graphql_docs.rs - GraphQL API with GraphiQL playground
• resilience.rs - Retry, Circuit Breaker, Rate Limiting
• graceful_shutdown.rs - Production shutdown handling

Learn More

• GitHub Repository
• Feature Flags Guide
• CQRS Documentation

Re-exports

pub use async_graphql;router-graphql

pub use async_graphql_parser;router-graphql

pub use async_trait;

pub use backoff;resilience

pub use chrono;utils

pub use dashmap;cache-memory

pub use futures;router-grpc

pub use governor;rate-limit

pub use hyper;health

pub use moka;cache-memory

pub use opentelemetry;otel-otlp

pub use opentelemetry_otlp;otel-otlp

pub use opentelemetry_sdk;otel-otlp

pub use parking_lot;utils

pub use prometheus;metrics

pub use prost;router-grpc

pub use prost_types;router-grpc

pub use rand;utils

pub use redis;cache-redis

pub use reqwest;http-client

pub use serde;

pub use serde_json;

pub use tokio;

pub use tokio_stream;router-grpc

pub use tonic;router-grpc

pub use tonic_reflection;router-grpc

pub use tracing;otel

pub use tracing_opentelemetry;otel-otlp

pub use tracing_subscriber;otel-otlp

pub use url;utils

Modules

application

Application layer orchestration and use case implementations. This module provides the orchestration layer that coordinates between domain logic and infrastructure, including resilience orchestration, transaction management, and business workflow coordination. Application layer orchestration and use case implementations.

archdi

Clean Architecture enforcement with compile-time dependency injection.

authauth

Authentication primitives with layered feature flags.

cache

Cache abstraction with in-memory and Redis backends.

cqrscqrs

CQRS + Event Sourcing infrastructure with 85% boilerplate reduction.

didi

Compile-time dependency injection infrastructure.

domain

Domain layer contracts and business logic primitives. This module provides the building blocks for Clean Architecture domain layers, including resilience contracts, business rules, and domain models. Domain layer contracts and business logic primitives.

grpcrouter-grpc

gRPC server infrastructure with TLS support.

healthhealth

Health check infrastructure for Kubernetes-ready services.

otelotel

OpenTelemetry automatic instrumentation for distributed tracing.

prelude

Prelude module for convenient imports

resilienceresilience

Resilience patterns: Retry, Circuit Breaker, and Rate Limiting.

router

Protocol-agnostic request routing for REST, GraphQL, and gRPC.

securitysecurity

Security utilities for safe logging and credential obfuscation.

shutdown

Graceful shutdown utilities for production services.

Attribute Macros

circuit_breakerresilience

Re-export circuit_breaker attribute macro Attribute macro for circuit breaker pattern

rate_limitedresilience

Re-export rate_limited attribute macro Attribute macro for rate limiting

retryresilience

Re-export retry attribute macro Attribute macro for automatic retry with exponential backoff

Derive Macros

GrpcErrorrouter-grpc

Re-export GrpcError derive macro for automatic tonic::Status conversion Derive macro for automatic gRPC status conversion

HealthCheckdi

Re-export HealthCheck derive macro for automatic health check implementation Derive macro for automatic HealthCheck implementation

Obfuscatesecurity

Re-export Obfuscate derive macro for safe logging Derive macro for automatic Obfuscate implementation