Support renamed rustapi-rs dependency

Allow macros to work when the rustapi-rs crate is renamed in Cargo.toml (e.g. api = { package = "rustapi-rs" }).

Adds get_rustapi_path() which uses crate_name to resolve the facade crate and updates generated code to reference the discovered path for linkme slices, route helpers, OpenAPI types and TypedPath prelude. Includes a new test (renamed_dependency_support.rs) verifying alias usage, documentation and README examples showing how to rename the crate, and adds dev-dependencies for testing in crates/rustapi-macros/Cargo.toml.

Author: Tuntii

Cargo.lock

@@ -94,6 +94,20 @@ async fn main() {
 }
 ```
 
+Prefer a shorter macro prefix? You can rename the crate in `Cargo.toml` and use the same macros:
+
+```toml
+[dependencies]
+api = { package = "rustapi-rs", version = "0.1.335" }
+```
+
+```rust
+use api::prelude::*;
+
+#[api::get("/users")]
+async fn list_users() -> &'static str { "ok" }
+```
+
 **That's it.** You get:
 *   ✅ **Swagger UI** at `/docs`
 *   ✅ **Input Validation**

README.md

@@ -21,3 +21,7 @@ proc-macro-crate = "3.1"
 
 # Note: async-trait is used in generated code, not in the macro itself
 # Users need to have async-trait available when using the Validate derive
+
+[dev-dependencies]
+api = { package = "rustapi-rs", path = "../rustapi-rs", default-features = false }
+serde = { workspace = true, features = ["derive"] }

crates/rustapi-macros/Cargo.toml

@@ -20,6 +20,9 @@ Registers a function as a route handler.
 - `#[rustapi_rs::head("/health")]`
 - `#[rustapi_rs::options("/cors")]`
 
+Dependency rename is supported. If you rename `rustapi-rs` to `api` in `Cargo.toml`,
+you can use the same macros as `#[api::get(...)]`, `#[api::post(...)]`, etc.
+
 ### OpenAPI Metadata
 Enrich your auto-generated documentation.
 

crates/rustapi-macros/README.md

@@ -26,6 +26,27 @@ use syn::{
 mod api_error;
 mod derive_schema;
 
+/// Determine the path to the RustAPI facade crate (`rustapi-rs`).
+///
+/// This supports dependency renaming, for example:
+/// `api = { package = "rustapi-rs", version = "..." }`.
+fn get_rustapi_path() -> proc_macro2::TokenStream {
+    let rustapi_rs_found = crate_name("rustapi-rs").or_else(|_| crate_name("rustapi_rs"));
+
+    if let Ok(found) = rustapi_rs_found {
+        match found {
+            FoundCrate::Itself => quote! { crate },
+            FoundCrate::Name(name) => {
+                let normalized = name.replace('-', "_");
+                let ident = syn::Ident::new(&normalized, proc_macro2::Span::call_site());
+                quote! { ::#ident }
+            }
+        }
+    } else {
+        quote! { ::rustapi_rs }
+    }
+}
+
 /// Derive macro for OpenAPI Schema trait
 ///
 /// # Example
@@ -58,6 +79,7 @@ pub fn derive_schema(input: TokenStream) -> TokenStream {
 #[proc_macro_attribute]
 pub fn schema(_attr: TokenStream, item: TokenStream) -> TokenStream {
     let input = parse_macro_input!(item as syn::Item);
+    let rustapi_path = get_rustapi_path();
 
     let (ident, generics) = match &input {
         syn::Item::Struct(s) => (&s.ident, &s.generics),
@@ -90,10 +112,10 @@ pub fn schema(_attr: TokenStream, item: TokenStream) -> TokenStream {
         #input
 
         #[allow(non_upper_case_globals)]
-        #[::rustapi_rs::__private::linkme::distributed_slice(::rustapi_rs::__private::AUTO_SCHEMAS)]
-        #[linkme(crate = ::rustapi_rs::__private::linkme)]
-        static #registrar_ident: fn(&mut ::rustapi_rs::__private::rustapi_openapi::OpenApiSpec) =
-            |spec: &mut ::rustapi_rs::__private::rustapi_openapi::OpenApiSpec| {
+        #[#rustapi_path::__private::linkme::distributed_slice(#rustapi_path::__private::AUTO_SCHEMAS)]
+        #[linkme(crate = #rustapi_path::__private::linkme)]
+        static #registrar_ident: fn(&mut #rustapi_path::__private::rustapi_openapi::OpenApiSpec) =
+            |spec: &mut #rustapi_path::__private::rustapi_openapi::OpenApiSpec| {
                 spec.register_in_place::<#ident>();
             };
     };
@@ -439,6 +461,7 @@ pub fn main(_attr: TokenStream, item: TokenStream) -> TokenStream {
 fn generate_route_handler(method: &str, attr: TokenStream, item: TokenStream) -> TokenStream {
     let path = parse_macro_input!(attr as LitStr);
     let input = parse_macro_input!(item as ItemFn);
+    let rustapi_path = get_rustapi_path();
 
     let fn_name = &input.sig.ident;
     let fn_vis = &input.vis;
@@ -470,12 +493,12 @@ fn generate_route_handler(method: &str, attr: TokenStream, item: TokenStream) ->
 
     // Pick the right route helper function based on method
     let route_helper = match method {
-        "GET" => quote!(::rustapi_rs::get_route),
-        "POST" => quote!(::rustapi_rs::post_route),
-        "PUT" => quote!(::rustapi_rs::put_route),
-        "PATCH" => quote!(::rustapi_rs::patch_route),
-        "DELETE" => quote!(::rustapi_rs::delete_route),
-        _ => quote!(::rustapi_rs::get_route),
+        "GET" => quote!(#rustapi_path::get_route),
+        "POST" => quote!(#rustapi_path::post_route),
+        "PUT" => quote!(#rustapi_path::put_route),
+        "PATCH" => quote!(#rustapi_path::patch_route),
+        "DELETE" => quote!(#rustapi_path::delete_route),
+        _ => quote!(#rustapi_path::get_route),
     };
 
     // Auto-detect path parameters from function arguments
@@ -567,30 +590,30 @@ fn generate_route_handler(method: &str, attr: TokenStream, item: TokenStream) ->
 
         // Route info function - creates a Route for this handler
         #[doc(hidden)]
-        #fn_vis fn #route_fn_name() -> ::rustapi_rs::Route {
+        #fn_vis fn #route_fn_name() -> #rustapi_path::Route {
             #route_helper(#path_value, #fn_name)
                 #chained_calls
         }
 
         // Auto-register route with linkme
         #[doc(hidden)]
         #[allow(non_upper_case_globals)]
-        #[::rustapi_rs::__private::linkme::distributed_slice(::rustapi_rs::__private::AUTO_ROUTES)]
-        #[linkme(crate = ::rustapi_rs::__private::linkme)]
-        static #auto_route_name: fn() -> ::rustapi_rs::Route = #route_fn_name;
+        #[#rustapi_path::__private::linkme::distributed_slice(#rustapi_path::__private::AUTO_ROUTES)]
+        #[linkme(crate = #rustapi_path::__private::linkme)]
+        static #auto_route_name: fn() -> #rustapi_path::Route = #route_fn_name;
 
         // Auto-register referenced schemas with linkme (best-effort)
         #[doc(hidden)]
         #[allow(non_snake_case)]
-        fn #schema_reg_fn_name(spec: &mut ::rustapi_rs::__private::rustapi_openapi::OpenApiSpec) {
+        fn #schema_reg_fn_name(spec: &mut #rustapi_path::__private::rustapi_openapi::OpenApiSpec) {
             #( spec.register_in_place::<#schema_types>(); )*
         }
 
         #[doc(hidden)]
         #[allow(non_upper_case_globals)]
-        #[::rustapi_rs::__private::linkme::distributed_slice(::rustapi_rs::__private::AUTO_SCHEMAS)]
-        #[linkme(crate = ::rustapi_rs::__private::linkme)]
-        static #auto_schema_name: fn(&mut ::rustapi_rs::__private::rustapi_openapi::OpenApiSpec) = #schema_reg_fn_name;
+        #[#rustapi_path::__private::linkme::distributed_slice(#rustapi_path::__private::AUTO_SCHEMAS)]
+        #[linkme(crate = #rustapi_path::__private::linkme)]
+        static #auto_schema_name: fn(&mut #rustapi_path::__private::rustapi_openapi::OpenApiSpec) = #schema_reg_fn_name;
     };
 
     debug_output(&format!("{} {}", method, path_value), &expanded);
@@ -1638,6 +1661,7 @@ pub fn derive_typed_path(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     let name = &input.ident;
     let generics = &input.generics;
+    let rustapi_path = get_rustapi_path();
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
 
     // Find the #[typed_path("...")] attribute
@@ -1702,7 +1726,7 @@ pub fn derive_typed_path(input: TokenStream) -> TokenStream {
     }
 
     let expanded = quote! {
-        impl #impl_generics ::rustapi_rs::prelude::TypedPath for #name #ty_generics #where_clause {
+        impl #impl_generics #rustapi_path::prelude::TypedPath for #name #ty_generics #where_clause {
             const PATH: &'static str = #path;
 
             fn to_uri(&self) -> String {

crates/rustapi-macros/src/lib.rs

@@ -0,0 +1,60 @@
+use api as rustapi_alias;
+use rustapi_alias::prelude::*;
+
+#[rustapi_alias::get("/macro-alias-get")]
+async fn alias_get() -> &'static str {
+    "ok"
+}
+
+#[rustapi_alias::post("/macro-alias-post")]
+async fn alias_post() -> &'static str {
+    "ok"
+}
+
+#[rustapi_alias::schema]
+#[derive(Schema)]
+#[allow(dead_code)]
+struct AliasSchema {
+    id: i64,
+}
+
+#[derive(TypedPath, Serialize, Deserialize)]
+#[typed_path("/macro-alias/{id}")]
+struct AliasPath {
+    id: i64,
+}
+
+#[test]
+fn renamed_dependency_supports_route_macros() {
+    let routes = rustapi_alias::collect_auto_routes();
+    assert!(
+        routes
+            .iter()
+            .any(|r| r.path() == "/macro-alias-get" && r.method() == "GET"),
+        "GET route should be discovered via #[api::get]"
+    );
+    assert!(
+        routes
+            .iter()
+            .any(|r| r.path() == "/macro-alias-post" && r.method() == "POST"),
+        "POST route should be discovered via #[api::post]"
+    );
+}
+
+#[test]
+fn renamed_dependency_supports_schema_and_typed_path_macros() {
+    let uri = AliasPath { id: 7 }.to_uri();
+    assert_eq!(uri, "/macro-alias/7");
+
+    let app = rustapi_alias::RustApi::auto();
+    let spec = app.openapi_spec();
+    let schemas = &spec
+        .components
+        .as_ref()
+        .expect("components should exist")
+        .schemas;
+    assert!(
+        schemas.contains_key("AliasSchema"),
+        "schema should be registered via #[api::schema]"
+    );
+}

crates/rustapi-macros/tests/renamed_dependency_support.rs

@@ -25,6 +25,13 @@ Add RustAPI to your `Cargo.toml`:
 rustapi-rs = "0.1.335"
 ```
 
+You can also rename the crate if you prefer shorter macro paths:
+
+```toml
+[dependencies]
+api = { package = "rustapi-rs", version = "0.1.335" }
+```
+
 Or with specific features:
 
 ```toml
@@ -144,6 +151,9 @@ The `#[rustapi_rs::get]` macro:
 - Generates OpenAPI documentation
 - Works with `RustApi::auto()` for zero-config routing
 
+Route macros also work through dependency aliases, e.g. `#[api::get("/")]`
+when `rustapi-rs` is renamed to `api` in `Cargo.toml`.
+
 ### 4. Auto Configuration
 
 ```rust