Slim default dependency tree for rustapi-rs

Remove tracing-subscriber from rustapi-core production dependencies and stop auto-initializing it in RustApi::new(); apps and cargo-rustapi templates already set up tracing in main.

Gate rust-i18n behind the validate i18n feature with English fallbacks, exposing core-i18n on rustapi-rs. Default builds drop from ~259 to ~158 transitive crates.

Also align rustapi-openapi on workspace rustapi-macros version.

Author: Tuntii

crates/rustapi-core/Cargo.toml

@@ -37,7 +37,6 @@ tower-service = { workspace = true }
 
 # Utilities
 tracing = { workspace = true }
-tracing-subscriber = { workspace = true }
 linkme = { workspace = true }
 uuid = { workspace = true }
 
@@ -76,6 +75,7 @@ async-trait = { workspace = true, optional = true }
 dashmap = { version = "6.0", optional = true }
 
 [dev-dependencies]
+tracing-subscriber = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 proptest = "1.4"
 rustapi-testing = { workspace = true }

crates/rustapi-core/src/app/builder.rs

@@ -7,20 +7,13 @@ use crate::middleware::{LayerStack, MiddlewareLayer, DEFAULT_BODY_LIMIT};
 use crate::router::Router;
 use std::future::Future;
 use std::sync::Arc;
-use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
 
 impl RustApi {
-    /// Create a new RustAPI application
+    /// Create a new RustAPI application.
+    ///
+    /// Initialize `tracing-subscriber` in `main` when using the `tracing` feature;
+    /// `cargo-rustapi` templates already do this.
     pub fn new() -> Self {
-        // Initialize tracing if not already done
-        let _ = tracing_subscriber::registry()
-            .with(
-                EnvFilter::try_from_default_env()
-                    .unwrap_or_else(|_| EnvFilter::new("info,rustapi=debug")),
-            )
-            .with(tracing_subscriber::fmt::layer())
-            .try_init();
-
         Self {
             router: Router::new(),
             openapi_spec: rustapi_openapi::OpenApiSpec::new("RustAPI Application", "1.0.0")

crates/rustapi-openapi/Cargo.toml

@@ -20,7 +20,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 
 # Macros
-rustapi-macros = { path = "../rustapi-macros", version = "0.1.300" }
+rustapi-macros = { workspace = true }
 
 [features]
 default = ["swagger-ui"]

crates/rustapi-rs/Cargo.toml

@@ -60,6 +60,7 @@ core-cookies = ["dep:rustapi-extras", "rustapi-extras/cookies", "rustapi-core/co
 core-http3 = ["rustapi-core/http3"]
 core-http3-dev = ["rustapi-core/http3-dev"]
 core-dashboard = ["rustapi-core/dashboard"]
+core-i18n = ["rustapi-validate/i18n"]
 
 # Canonical protocol features
 protocol-toon = ["dep:rustapi-toon"]
@@ -159,7 +160,8 @@ oauth2-client = ["extras-oauth2-client"]
 session = ["extras-session"]
 session-redis = ["extras-session-redis"]
 jobs = ["extras-jobs"]
+i18n = ["core-i18n"]
 extras = ["extras-jwt", "extras-cors", "extras-rate-limit"]
 
 # Canonical aggregate
-full = ["core", "protocol-all", "extras-all", "core-legacy-validator", "core-dashboard"]
+full = ["core", "protocol-all", "extras-all", "core-legacy-validator", "core-dashboard", "core-i18n"]

crates/rustapi-validate/Cargo.toml

@@ -25,15 +25,23 @@ async-trait = { workspace = true }
 # Regex for pattern validation
 regex = "1.10"
 
-# Internationalization
-rust-i18n = "3.0"
+# Internationalization (optional — English fallbacks ship without this)
+rust-i18n = { version = "3.0", optional = true }
 
 # Re-export derive macro
 rustapi-macros = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
 proptest = "1.4"
-rust-i18n = "3.0"
 rustapi-core = { workspace = true, default-features = false }
 
+[features]
+default = []
+i18n = ["dep:rust-i18n"]
+
+[[test]]
+name = "i18n"
+path = "tests/i18n.rs"
+required-features = ["i18n"]
+

crates/rustapi-validate/src/lib.rs

@@ -71,7 +71,7 @@
 //! }
 //! ```
 
-// Load I18n locales
+#[cfg(feature = "i18n")]
 rust_i18n::i18n!("locales");
 
 pub mod custom;

crates/rustapi-validate/src/v2/i18n.rs

@@ -1,3 +1,4 @@
+#[cfg(feature = "i18n")]
 use rust_i18n::t;
 
 /// Helper to translate a message.
@@ -9,31 +10,57 @@ use rust_i18n::t;
 /// * `key` - The message key (e.g. "validation.email.invalid")
 /// * `locale` - The locale to use (e.g. "en", "tr"). If None, uses default.
 pub fn translate(key: &str, locale: Option<&str>) -> String {
-    let result = if let Some(locale) = locale {
-        t!(key, locale = locale).to_string()
-    } else {
-        t!(key).to_string()
-    };
+    #[cfg(feature = "i18n")]
+    {
+        let result = if let Some(locale) = locale {
+            t!(key, locale = locale).to_string()
+        } else {
+            t!(key).to_string()
+        };
 
-    // Fallback to English if translation is missing (returns key)
-    if result == key {
-        t!(key, locale = "en").to_string()
-    } else {
-        result
+        if result == key {
+            t!(key, locale = "en").to_string()
+        } else {
+            result
+        }
+    }
+
+    #[cfg(not(feature = "i18n"))]
+    {
+        let _ = locale;
+        fallback_message(key)
     }
 }
 
 /// Helper to translate with arguments.
 pub fn translate_with_args(key: &str, locale: Option<&str>, _args: &[(&str, &str)]) -> String {
-    if let Some(locale) = locale {
-        // rust-i18n t! macro doesn't support dynamic args easily in this wrapped form
-        // We might need to use the lower level API or just interpolate ourselves
-        // For now let's use the basic t! with variable interpolation if possible
-        // But t! requires string literals for keys mostly or known args.
-        // Let's stick to basic translation for now and use our existing interpolation
-        // in RuleError for variable replacement.
-        t!(key, locale = locale).to_string()
-    } else {
-        t!(key).to_string()
+    translate(key, locale)
+}
+
+#[cfg(not(feature = "i18n"))]
+fn fallback_message(key: &str) -> String {
+    match key {
+        "validation.email.invalid" => "Invalid email format",
+        "validation.length.min" => "Length must be at least %{min} characters",
+        "validation.length.max" => "Length must be at most %{max} characters",
+        "validation.length.exact" => "Length must be exactly %{len} characters",
+        "validation.range.min" => "Value must be at least %{min}",
+        "validation.range.max" => "Value must be at most %{max}",
+        "validation.range.between" => "Value must be between %{min} and %{max}",
+        "validation.required.missing" => "This field is required",
+        "validation.url.invalid" => "Invalid URL format",
+        "validation.regex.mismatch" => "Value does not match pattern: %{pattern}",
+        "validation.unique.taken" => "This value is already taken",
+        "validation.exists.not_found" => "Value does not exist",
+        "validation.api.invalid" => "External validation failed",
+        "validation.credit_card.invalid_format" => "Invalid credit card format",
+        "validation.credit_card.invalid" => "Invalid credit card number",
+        "validation.ip.v4_required" => "IPv4 address required",
+        "validation.ip.v6_required" => "IPv6 address required",
+        "validation.ip.invalid" => "Invalid IP address",
+        "validation.phone.invalid" => "Invalid phone number",
+        "validation.contains.missing" => "Required value is missing",
+        other => other,
     }
+    .to_string()
 }