New struct-based service definition API (#117)

* feat: struct-based service definition API

Put #[restate_sdk::service] (or #[object]/#[workflow]) on an impl block,
annotate handlers with #[handler], and do dependency injection via &self
struct fields. Bind the struct value directly (no .serve()) via the new
IntoServiceDefinition trait. Shared/exclusive is inferred from the context
type. Generic structs (bounds + where-clauses) are supported.

The trait-based API keeps working but is deprecated with a compile-time
warning. Examples and test-services migrated to the new API.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* chore: use prelude-reexported macros (drop restate_sdk:: prefix)

The service/object/workflow/handler macros are now re-exported from the
prelude, so first-party examples, tests and test-services use the bare
attribute form.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* refactor: rename service attr arg `vis` to `client_visibility`

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

* Polish

* Polish

* Make sure options get overriden

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: slinkydeveloper

README.md

@@ -31,15 +31,12 @@ Then you're ready to develop your Restate service using Rust:
 ```rust
 use restate_sdk::prelude::*;
 
-#[restate_sdk::service]
-trait Greeter {
-    async fn greet(name: String) -> HandlerResult<String>;
-}
-
-struct GreeterImpl;
+struct Greeter;
 
-impl Greeter for GreeterImpl {
-    async fn greet(&self, _: Context<'_>, name: String) -> HandlerResult<String> {
+#[service]
+impl Greeter {
+    #[handler]
+    async fn greet(&self, _ctx: Context<'_>, name: String) -> HandlerResult<String> {
         Ok(format!("Greetings {name}"))
     }
 }
@@ -50,7 +47,7 @@ async fn main() {
     // tracing_subscriber::fmt::init();
     HttpServer::new(
         Endpoint::builder()
-            .with_service(GreeterImpl.serve())
+            .bind(Greeter)
             .build(),
     )
     .listen_and_serve("0.0.0.0:9080".parse().unwrap())
@@ -79,15 +76,12 @@ Here's how to create a simple Lambda service:
 ```rust
 use restate_sdk::prelude::*;
 
-#[restate_sdk::service]
-trait Greeter {
-    async fn greet(name: String) -> HandlerResult<String>;
-}
-
-struct GreeterImpl;
+struct Greeter;
 
-impl Greeter for GreeterImpl {
-    async fn greet(&self, _: Context<'_>, name: String) -> HandlerResult<String> {
+#[service]
+impl Greeter {
+    #[handler]
+    async fn greet(&self, _ctx: Context<'_>, name: String) -> HandlerResult<String> {
         Ok(format!("Greetings {name}"))
     }
 }
@@ -100,7 +94,7 @@ async fn main() {
     // Build and run the Lambda endpoint
     LambdaEndpoint::run(
         Endpoint::builder()
-            .bind(GreeterImpl.serve())
+            .bind(Greeter)
             .build(),
     )
     .await
@@ -144,7 +138,7 @@ async fn test_container() {
         .with_max_level(tracing::Level::INFO) // Set the maximum log level
         .init();
 
-    let endpoint = Endpoint::builder().bind(MyServiceImpl.serve()).build();
+    let endpoint = Endpoint::builder().bind(MyService).build();
 
     // simple test container intialization with default configuration
     //let test_container = TestContainer::default().start(endpoint).await.unwrap();

examples/counter.rs

@@ -1,34 +1,30 @@
 use restate_sdk::prelude::*;
 
-#[restate_sdk::object]
-trait Counter {
-    #[shared]
-    async fn get() -> Result<u64, TerminalError>;
-    async fn add(val: u64) -> Result<u64, TerminalError>;
-    async fn increment() -> Result<u64, TerminalError>;
-    async fn reset() -> Result<(), TerminalError>;
-}
-
-struct CounterImpl;
+struct Counter;
 
 const COUNT: &str = "count";
 
-impl Counter for CounterImpl {
+#[object]
+impl Counter {
+    #[handler(name = "get")]
     async fn get(&self, ctx: SharedObjectContext<'_>) -> Result<u64, TerminalError> {
         Ok(ctx.get::<u64>(COUNT).await?.unwrap_or(0))
     }
 
+    #[handler]
     async fn add(&self, ctx: ObjectContext<'_>, val: u64) -> Result<u64, TerminalError> {
         let current = ctx.get::<u64>(COUNT).await?.unwrap_or(0);
         let new = current + val;
         ctx.set(COUNT, new);
         Ok(new)
     }
 
+    #[handler]
     async fn increment(&self, ctx: ObjectContext<'_>) -> Result<u64, TerminalError> {
         self.add(ctx, 1).await
     }
 
+    #[handler]
     async fn reset(&self, ctx: ObjectContext<'_>) -> Result<(), TerminalError> {
         ctx.clear(COUNT);
         Ok(())
@@ -38,7 +34,7 @@ impl Counter for CounterImpl {
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
-    HttpServer::new(Endpoint::builder().bind(CounterImpl.serve()).build())
+    HttpServer::new(Endpoint::builder().bind(Counter).build())
         .listen_and_serve("0.0.0.0:9080".parse().unwrap())
         .await;
 }

examples/cron.rs

@@ -13,21 +13,14 @@ use std::time::Duration;
 /// ```shell
 /// $ curl -v http://localhost:8080/PeriodicTask/my-periodic-task/start
 /// ```
-#[restate_sdk::object]
-trait PeriodicTask {
-    /// Schedules the periodic task to start
-    async fn start() -> Result<(), TerminalError>;
-    /// Stops the periodic task
-    async fn stop() -> Result<(), TerminalError>;
-    /// Business logic of the periodic task
-    async fn run() -> Result<(), TerminalError>;
-}
-
-struct PeriodicTaskImpl;
+struct PeriodicTask;
 
 const ACTIVE: &str = "active";
 
-impl PeriodicTask for PeriodicTaskImpl {
+#[object]
+impl PeriodicTask {
+    /// Schedules the periodic task to start
+    #[handler]
     async fn start(&self, context: ObjectContext<'_>) -> Result<(), TerminalError> {
         if context
             .get::<bool>(ACTIVE)
@@ -39,21 +32,25 @@ impl PeriodicTask for PeriodicTaskImpl {
         }
 
         // Schedule the periodic task
-        PeriodicTaskImpl::schedule_next(&context);
+        PeriodicTask::schedule_next(&context);
 
         // Mark the periodic task as active
         context.set(ACTIVE, true);
 
         Ok(())
     }
 
+    /// Stops the periodic task
+    #[handler]
     async fn stop(&self, context: ObjectContext<'_>) -> Result<(), TerminalError> {
         // Remove the active flag
         context.clear(ACTIVE);
 
         Ok(())
     }
 
+    /// Business logic of the periodic task
+    #[handler]
     async fn run(&self, context: ObjectContext<'_>) -> Result<(), TerminalError> {
         if context.get::<bool>(ACTIVE).await?.is_none() {
             // Task is inactive, do nothing
@@ -64,13 +61,13 @@ impl PeriodicTask for PeriodicTaskImpl {
         println!("Triggered the periodic task!");
 
         // Schedule the periodic task
-        PeriodicTaskImpl::schedule_next(&context);
+        PeriodicTask::schedule_next(&context);
 
         Ok(())
     }
 }
 
-impl PeriodicTaskImpl {
+impl PeriodicTask {
     fn schedule_next(context: &ObjectContext<'_>) {
         // To schedule, create a client to the callee handler (in this case, we're calling ourselves)
         context
@@ -84,7 +81,7 @@ impl PeriodicTaskImpl {
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
-    HttpServer::new(Endpoint::builder().bind(PeriodicTaskImpl.serve()).build())
+    HttpServer::new(Endpoint::builder().bind(PeriodicTask).build())
         .listen_and_serve("0.0.0.0:9080".parse().unwrap())
         .await;
 }

examples/failures.rs

@@ -1,19 +1,15 @@
 use rand::Rng;
 use restate_sdk::prelude::*;
 
-#[restate_sdk::service]
-trait FailureExample {
-    #[name = "doRun"]
-    async fn do_run() -> Result<(), TerminalError>;
-}
-
-struct FailureExampleImpl;
+struct FailureExample;
 
 #[derive(Debug, thiserror::Error)]
 #[error("I'm very bad, retry me")]
 struct MyError;
 
-impl FailureExample for FailureExampleImpl {
+#[service]
+impl FailureExample {
+    #[handler(name = "doRun")]
     async fn do_run(&self, context: Context<'_>) -> Result<(), TerminalError> {
         context
             .run::<_, _, ()>(|| async move {
@@ -32,7 +28,7 @@ impl FailureExample for FailureExampleImpl {
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
-    HttpServer::new(Endpoint::builder().bind(FailureExampleImpl.serve()).build())
+    HttpServer::new(Endpoint::builder().bind(FailureExample).build())
         .listen_and_serve("0.0.0.0:9080".parse().unwrap())
         .await;
 }

examples/fan_out.rs

@@ -12,14 +12,11 @@ use std::time::Duration;
 /// ```shell
 /// $ curl -v http://localhost:8080/FanOut/fan_out
 /// ```
-#[restate_sdk::service]
-trait FanOut {
-    async fn fan_out() -> Result<String, TerminalError>;
-}
-
-struct FanOutImpl;
+struct FanOut;
 
-impl FanOut for FanOutImpl {
+#[service]
+impl FanOut {
+    #[handler]
     async fn fan_out(&self, ctx: Context<'_>) -> Result<String, TerminalError> {
         let labels = ["fast", "medium", "slow"];
 
@@ -43,7 +40,7 @@ impl FanOut for FanOutImpl {
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
-    HttpServer::new(Endpoint::builder().bind(FanOutImpl.serve()).build())
+    HttpServer::new(Endpoint::builder().bind(FanOut).build())
         .listen_and_serve("0.0.0.0:9080".parse().unwrap())
         .await;
 }

examples/greeter.rs

@@ -1,23 +1,20 @@
 use restate_sdk::prelude::*;
 use std::convert::Infallible;
 
-#[restate_sdk::service]
-trait Greeter {
-    async fn greet(name: String) -> Result<String, Infallible>;
-}
-
-struct GreeterImpl;
+struct Greeter;
 
-impl Greeter for GreeterImpl {
-    async fn greet(&self, _: Context<'_>, name: String) -> Result<String, Infallible> {
+#[service]
+impl Greeter {
+    #[handler]
+    async fn greet(&self, _ctx: Context<'_>, name: String) -> Result<String, Infallible> {
         Ok(format!("Greetings {name}"))
     }
 }
 
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
-    HttpServer::new(Endpoint::builder().bind(GreeterImpl.serve()).build())
+    HttpServer::new(Endpoint::builder().bind(Greeter).build())
         .listen_and_serve("0.0.0.0:9080".parse().unwrap())
         .await;
 }

examples/run.rs

@@ -1,14 +1,11 @@
 use restate_sdk::prelude::*;
 use std::collections::HashMap;
 
-#[restate_sdk::service]
-trait RunExample {
-    async fn do_run() -> Result<Json<HashMap<String, String>>, HandlerError>;
-}
-
-struct RunExampleImpl(reqwest::Client);
+struct RunExample(reqwest::Client);
 
-impl RunExample for RunExampleImpl {
+#[service]
+impl RunExample {
+    #[handler]
     async fn do_run(
         &self,
         context: Context<'_>,
@@ -39,7 +36,7 @@ async fn main() {
     tracing_subscriber::fmt::init();
     HttpServer::new(
         Endpoint::builder()
-            .bind(RunExampleImpl(reqwest::Client::new()).serve())
+            .bind(RunExample(reqwest::Client::new()))
             .build(),
     )
     .listen_and_serve("0.0.0.0:9080".parse().unwrap())

examples/schema.rs

@@ -10,22 +10,17 @@ use serde::{Deserialize, Serialize};
 use std::time::Duration;
 
 #[derive(Serialize, Deserialize, JsonSchema)]
-struct Product {
+pub struct Product {
     id: String,
     name: String,
     price_cents: u32,
 }
 
-#[restate_sdk::service]
-trait CatalogService {
-    async fn get_product_by_id(product_id: String) -> Result<Json<Product>, HandlerError>;
-    async fn save_product(product: Json<Product>) -> Result<String, HandlerError>;
-    async fn is_in_stock(product_id: String) -> Result<bool, HandlerError>;
-}
-
-struct CatalogServiceImpl;
+struct CatalogService;
 
-impl CatalogService for CatalogServiceImpl {
+#[service]
+impl CatalogService {
+    #[handler]
     async fn get_product_by_id(
         &self,
         ctx: Context<'_>,
@@ -39,6 +34,7 @@ impl CatalogService for CatalogServiceImpl {
         }))
     }
 
+    #[handler]
     async fn save_product(
         &self,
         _ctx: Context<'_>,
@@ -47,6 +43,7 @@ impl CatalogService for CatalogServiceImpl {
         Ok(product.0.id)
     }
 
+    #[handler]
     async fn is_in_stock(
         &self,
         _ctx: Context<'_>,
@@ -59,7 +56,7 @@ impl CatalogService for CatalogServiceImpl {
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
-    HttpServer::new(Endpoint::builder().bind(CatalogServiceImpl.serve()).build())
+    HttpServer::new(Endpoint::builder().bind(CatalogService).build())
         .listen_and_serve("0.0.0.0:9080".parse().unwrap())
         .await;
 }

examples/services/my_service.rs

@@ -1,13 +1,10 @@
 use restate_sdk::prelude::*;
 
-#[restate_sdk::service]
-pub trait MyService {
-    async fn my_handler(greeting: String) -> Result<String, HandlerError>;
-}
-
-pub struct MyServiceImpl;
+pub struct MyService;
 
-impl MyService for MyServiceImpl {
+#[service]
+impl MyService {
+    #[handler]
     async fn my_handler(&self, _ctx: Context<'_>, greeting: String) -> Result<String, HandlerError> {
         Ok(format!("{greeting}!"))
     }
@@ -16,7 +13,7 @@ impl MyService for MyServiceImpl {
 #[tokio::main]
 async fn main() {
     tracing_subscriber::fmt::init();
-    HttpServer::new(Endpoint::builder().bind(MyServiceImpl.serve()).build())
+    HttpServer::new(Endpoint::builder().bind(MyService).build())
         .listen_and_serve("0.0.0.0:9080".parse().unwrap())
         .await;
 }