Will squash and merge

Author: JeremieRodon

CHANGELOG.md

@@ -29,6 +29,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Breaking**: The crate no longer generates `main()`, log initialization, or AWS SDK client singletons. Users write their own `main()` and initialize these concerns directly. This is a deliberate design change: generating `main()` and instantiating SDK clients are application-level concerns that don't belong in a type-generation / operation-dispatch crate. The monolithic approach led to unsustainable option proliferation (every new logging framework or instrumentation pattern required another macro option and feature flag) and made it impossible to compose with external middleware such as Tower layers. See [PR #12](https://github.com/RustyServerless/lambda-appsync/pull/12) for the full rationale
 - **Breaking**: Default features are now empty. `env_logger` is no longer enabled by default. Add `features = ["env_logger"]` to restore the previous behavior
 - **Breaking**: The `hook`, `log_init`, `event_logging`, `only_appsync_types`, `exclude_appsync_types`, `only_appsync_operations`, `exclude_appsync_operations`, `only_lambda_handler`, `exclude_lambda_handler`, and AWS SDK client definition options are no longer available in the default API. They remain available through `appsync_lambda_main!` behind the `compat` feature
+- **Breaking**: `#[appsync_operation]` now **preserves the original function** by default (it used to inline the body and remove the function). A new `inline_and_remove` parameter is available when you want the old behavior — the function body is inlined into the generated `impl Operation` method and the original function is removed. The `keep_original_function_name` parameter is moved behind the `compat` feature. Enabling `compat` also restores the old default behavior (inline and remove)
 - Repository migrated to the [RustyServerless](https://github.com/RustyServerless) organization
 
 ### Deprecated

README.md

@@ -324,19 +324,39 @@ async fn create_player(
 }
 ```
 
-### Preserving Original Function Names
+### Original Function Preservation
 
-Keep the original function name available while using it as an operation handler:
+By default, `#[appsync_operation]` preserves the original function alongside the generated `impl Operation` method. You can call it directly elsewhere in your code:
 
 ```rust
-#[appsync_operation(query(players), keep_original_function_name)]
+#[appsync_operation(query(players))]
 async fn fetch_players() -> Result<Vec<Player>, AppsyncError> {
     todo!()
 }
 
-// Can still call fetch_players() directly elsewhere
+// fetch_players() is still available as a regular function
+```
+
+If you want the function to be removed (its body is inlined into the generated method), use `inline_and_remove`. This can be handy when generating handlers with `macro_rules!`, where you don't want the function name to collide with itself:
+
+```rust
+macro_rules! game_status_mut {
+    ($mut_name:ident, $status:path) => {
+        #[appsync_operation(mutation($mut_name), inline_and_remove)]
+        pub async fn _discarded() -> Result<GameStatus, AppsyncError> {
+            dynamodb_set_game_status($status).await?;
+            Ok($status)
+        }
+    };
+}
+
+game_status_mut!(startGame, GameStatus::Started);
+game_status_mut!(stopGame, GameStatus::Stopped);
+game_status_mut!(resetGame, GameStatus::Reset);
 ```
 
+> **Note:** When the `compat` feature is enabled, the old default behavior is restored (inline and remove), and the `keep_original_function_name` parameter is available to opt back into preservation.
+
 ### AWS SDK Error Support
 
 AWS SDK errors are automatically converted to `AppsyncError`, allowing use of the `?` operator:

lambda-appsync-proc/Cargo.toml

@@ -21,15 +21,15 @@ proc-macro2 = { workspace = true }
 graphql-parser = { workspace = true }
 
 [dev-dependencies]
-lambda-appsync = { path = "../lambda-appsync", default-features = false, features = ["log", "env_logger", "tracing", "compat"] }
+lambda-appsync = { path = "../lambda-appsync", default-features = false, features = ["compat", "log", "env_logger", "tracing"] }
 tracing = { workspace = true }
 aws-sdk-s3 = { workspace = true }
 aws-sdk-dynamodb = { workspace = true }
 serde = { workspace = true }
 trybuild = { workspace = true }
 
 [features]
-default = ["log", "env_logger", "tracing", "compat"]
+default = ["compat", "log", "env_logger", "tracing"]
 compat = []
 log = []
 env_logger = []

lambda-appsync-proc/doc/appsync_operation.md

@@ -78,34 +78,58 @@ Note that the `args` field of the [AppsyncEvent](struct.AppsyncEvent.html) will
 [Null](https://docs.rs/serde_json/latest/serde_json/enum.Value.html#variant.Null) at this stage because its initial content is taken to extract
 the argument values for the operation.
 
-## Preserve original function name
+## Original function preservation
+
+By default the [macro@appsync_operation] macro preserves your original function in addition to
+generating the `impl Operation` method. This means you can call the function directly elsewhere
+in your code:
 
-By default the [macro@appsync_operation] macro will discard your function's name but
-you can also keep it available by adding the `keep_original_function_name` flag:
 ```rust,no_run
 # lambda_appsync::make_appsync!("schema.graphql");
-# mod sub {
-use lambda_appsync::{appsync_operation, AppsyncError};
-
-// Your types are declared at the crate level by the make_appsync! macro
-use crate::Player;
-
 # async fn dynamodb_get_players() -> Result<Vec<Player>, AppsyncError> {
 #    todo!()
 # }
-// Keep the original function name available separately
-#[appsync_operation(query(players), keep_original_function_name)]
+# // Needed because compat is enabled
+# async fn fetch_players() {}
+# use lambda_appsync::{appsync_operation, AppsyncError};
+
+#[appsync_operation(query(players))]
 async fn fetch_players() -> Result<Vec<Player>, AppsyncError> {
     Ok(dynamodb_get_players().await?)
 }
 async fn other_stuff() {
-    // Can still call fetch_players() directly
+    // fetch_players() is still available as a regular function
     fetch_players().await;
+} 
+# fn main() {}
+```
+
+If you want the original function to be removed (its body is inlined into the generated
+`impl Operation` method), use the `inline_and_remove` flag:
+
+```rust,compile_fail
+# lambda_appsync::make_appsync!("schema.graphql");
+# use lambda_appsync::{appsync_operation, AppsyncError};
+
+#[appsync_operation(query(players), inline_and_remove)]
+async fn get_players() -> Result<Vec<Player>, AppsyncError> {
+    Ok(vec![])
 }
-# }
+
+async fn other_stuff() {
+    // get_players() is NOT available anymore.
+    get_players().await;
+} 
+
 # fn main() {}
 ```
 
+### `keep_original_function_name` (compat only)
+
+When the `compat` feature is enabled, the old default behavior is restored: the original function
+is inlined and removed by default. In that mode, the `keep_original_function_name` flag is available to
+explicitly preserve the function.
+
 ## Using enhanced subscription filters
 
 ```rust,no_run

lambda-appsync-proc/src/internal/appsync_operation/mod.rs

@@ -7,17 +7,22 @@ use super::common::{Name, OperationKind};
 
 /// Optional flags accepted by the `appsync_operation` macro attribute.
 enum ArgsOption {
-    /// Preserve the original function name in addition to generating the operation method.
+    /// Preserve the original function name in addition to generating the operation method
+    #[cfg(feature = "compat")]
     KeepOriginalFunctionName,
     /// Pass the full `AppsyncEvent` as an extra argument to the handler.
     WithAppsyncEvent,
+    /// Remove the function and inline its body inside the implemented method on Operation
+    InlineAndRemove,
 }
 impl Parse for ArgsOption {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let ident = input.parse::<Ident>()?;
         match ident.to_string().as_str() {
+            #[cfg(feature = "compat")]
             "keep_original_function_name" => Ok(Self::KeepOriginalFunctionName),
             "with_appsync_event" => Ok(Self::WithAppsyncEvent),
+            "inline_and_remove" => Ok(Self::InlineAndRemove),
             _ => Err(syn::Error::new(
                 ident.span(),
                 format!("Unknown option `{ident}`",),
@@ -33,6 +38,7 @@ struct Args {
     keep_original_function_name: bool,
     with_appsync_event: bool,
 }
+
 impl Parse for Args {
     fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
         let op_kind = input.parse::<Ident>()?;
@@ -58,7 +64,7 @@ impl Parse for Args {
         let mut args = Self {
             op_kind,
             op_name,
-            keep_original_function_name: false,
+            keep_original_function_name: !cfg!(feature = "compat"),
             with_appsync_event: false,
         };
 
@@ -70,8 +76,10 @@ impl Parse for Args {
             // We got an option
             let option = input.parse::<ArgsOption>()?;
             match option {
+                #[cfg(feature = "compat")]
                 ArgsOption::KeepOriginalFunctionName => args.keep_original_function_name = true,
                 ArgsOption::WithAppsyncEvent => args.with_appsync_event = true,
+                ArgsOption::InlineAndRemove => args.keep_original_function_name = false,
             }
         }
         Ok(args)

lambda-appsync-proc/src/internal/make_appsync/graphql/mod.rs

@@ -70,6 +70,7 @@ pub(super) struct GraphQLSchema {
     subscriptions: Operations,
     structures: Vec<Structure>,
     enums: Vec<Enum>,
+    #[cfg(feature = "log")]
     make_operation_parameters: MakeOperationParameters,
 }
 impl GraphQLSchema {
@@ -270,6 +271,7 @@ impl GraphQLSchema {
                 subscriptions: subscriptions.unwrap_or_default(),
                 structures,
                 enums,
+                #[cfg(feature = "log")]
                 make_operation_parameters,
             })
         } else {

lambda-appsync-proc/src/internal/make_appsync/make_operation.rs

@@ -44,6 +44,7 @@ impl Default for MakeOperationParameters {
     fn default() -> Self {
         Self {
             type_module: None,
+            #[cfg(feature = "log")]
             error_logging: true,
         }
     }

lambda-appsync-proc/tests/fail/operation_inline.rs

@@ -0,0 +1,81 @@
+use lambda_appsync::{
+    appsync_operation, make_appsync,
+    subscription_filters::{FieldPath, FilterGroup},
+    AppsyncError, ID,
+};
+
+make_appsync!("../../../../schema.graphql");
+fn main() {}
+
+// Query operations
+#[appsync_operation(query(players), inline_and_remove)]
+async fn get_players() -> Result<Vec<Player>, AppsyncError> {
+    Ok(vec![])
+}
+
+#[appsync_operation(query(gameStatus), inline_and_remove)]
+async fn get_game_status() -> Result<GameStatus, AppsyncError> {
+    Ok(GameStatus::Started)
+}
+
+#[appsync_operation(query(player), inline_and_remove)]
+async fn get_player(id: ID) -> Result<Option<Player>, AppsyncError> {
+    Ok(Some(Player {
+        id,
+        name: "Test".into(),
+        team: Team::Rust,
+    }))
+}
+
+// Mutation operations
+#[appsync_operation(mutation(createPlayer), inline_and_remove)]
+async fn create_player(name: String) -> Result<Player, AppsyncError> {
+    Ok(Player {
+        id: ID::new(),
+        name,
+        team: Team::Rust,
+    })
+}
+
+#[appsync_operation(mutation(deletePlayer), inline_and_remove)]
+async fn delete_player(id: ID) -> Result<Player, AppsyncError> {
+    Ok(Player {
+        id,
+        name: "Deleted".into(),
+        team: Team::MultiWordsTeam,
+    })
+}
+
+#[appsync_operation(mutation(setGameStatus), inline_and_remove)]
+async fn set_game_status() -> Result<GameStatus, AppsyncError> {
+    Ok(GameStatus::Started)
+}
+
+// Subscription operations
+#[appsync_operation(subscription(onCreatePlayer), inline_and_remove)]
+async fn on_create_player(name: String) -> Result<Option<FilterGroup>, AppsyncError> {
+    Ok(Some(FieldPath::new("name")?.contains(name).into()))
+}
+
+#[appsync_operation(subscription(onDeletePlayer), inline_and_remove)]
+async fn on_delete_player(id: ID) -> Result<Option<FilterGroup>, AppsyncError> {
+    Ok(Some(FieldPath::new("id")?.eq(id).into()))
+}
+
+#[appsync_operation(subscription(onGameStatusChange), inline_and_remove)]
+async fn on_game_status_change() -> Result<Option<FilterGroup>, AppsyncError> {
+    Ok(None)
+}
+
+// Test that we cannot call the original functions
+async fn test_original_fn() {
+    let _ = create_player("test".to_string()).await;
+    let _ = get_players().await;
+    let _ = get_game_status().await;
+    let _ = get_player(ID::new()).await;
+    let _ = delete_player(ID::new()).await;
+    let _ = set_game_status().await;
+    let _ = on_create_player("test".to_string()).await;
+    let _ = on_delete_player(ID::new()).await;
+    let _ = on_game_status_change().await;
+}

lambda-appsync-proc/tests/fail/operation_inline.stderr

@@ -0,0 +1,53 @@
+error[E0425]: cannot find function `create_player` in this scope
+  --> tests/fail/operation_inline.rs:72:13
+   |
+72 |     let _ = create_player("test".to_string()).await;
+   |             ^^^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `get_players` in this scope
+  --> tests/fail/operation_inline.rs:73:13
+   |
+73 |     let _ = get_players().await;
+   |             ^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `get_game_status` in this scope
+  --> tests/fail/operation_inline.rs:74:13
+   |
+74 |     let _ = get_game_status().await;
+   |             ^^^^^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `get_player` in this scope
+  --> tests/fail/operation_inline.rs:75:13
+   |
+75 |     let _ = get_player(ID::new()).await;
+   |             ^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `delete_player` in this scope
+  --> tests/fail/operation_inline.rs:76:13
+   |
+76 |     let _ = delete_player(ID::new()).await;
+   |             ^^^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `set_game_status` in this scope
+  --> tests/fail/operation_inline.rs:77:13
+   |
+77 |     let _ = set_game_status().await;
+   |             ^^^^^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `on_create_player` in this scope
+  --> tests/fail/operation_inline.rs:78:13
+   |
+78 |     let _ = on_create_player("test".to_string()).await;
+   |             ^^^^^^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `on_delete_player` in this scope
+  --> tests/fail/operation_inline.rs:79:13
+   |
+79 |     let _ = on_delete_player(ID::new()).await;
+   |             ^^^^^^^^^^^^^^^^ not found in this scope
+
+error[E0425]: cannot find function `on_game_status_change` in this scope
+  --> tests/fail/operation_inline.rs:80:13
+   |
+80 |     let _ = on_game_status_change().await;
+   |             ^^^^^^^^^^^^^^^^^^^^^ not found in this scope