feat: Introduce IntoTaskHandlerResult trait

It allows to have no return type in the TaskHandler trait implementation

README.md

@@ -111,11 +111,10 @@ pub struct CounterTask;
 impl TaskHandler for CounterTask {
     const IDENTIFIER: &'static str = "counter_task";
 
-    async fn run(self, _ctx: WorkerContext) -> Result<(), ()> {
+    async fn run(self, ctx: WorkerContext) {
         let app_state = ctx.extensions().get::<AppState>().unwrap();
         let run_count = app_state.run_count.fetch_add(1, SeqCst);
         println!("Run count: {run_count}");
-        Ok(())
     }
 }
 
@@ -138,10 +137,6 @@ async fn main() -> Result<(), ()> {
 }
 ```
 
-### Success!
-
-You should see the worker output `Hello Bobby Tables !`. Gosh, that was fast!
-
 ## Features
 
 - Standalone and embedded modes

crates/task_handler/src/handler.rs

@@ -4,24 +4,41 @@ use serde::Serialize;
 use std::fmt::Debug;
 use std::future::Future;
 
+pub trait IntoTaskHandlerResult {
+    fn into_task_handler_result(self) -> Result<(), impl Debug>;
+}
+
+impl IntoTaskHandlerResult for () {
+    fn into_task_handler_result(self) -> Result<(), impl Debug> {
+        Ok::<_, ()>(())
+    }
+}
+
+impl<D: Debug> IntoTaskHandlerResult for Result<(), D> {
+    fn into_task_handler_result(self) -> Result<(), impl Debug> {
+        self
+    }
+}
+
 pub trait TaskHandler: Serialize + for<'de> Deserialize<'de> + Send + Sync + 'static {
     const IDENTIFIER: &'static str;
 
     fn run(
         self,
         ctx: WorkerContext,
-    ) -> impl Future<Output = Result<(), impl Debug>> + Send + 'static;
+    ) -> impl Future<Output = impl IntoTaskHandlerResult> + Send + 'static;
+}
 
-    fn run_from_ctx(
-        worker_context: WorkerContext,
-    ) -> impl Future<Output = Result<(), String>> + Send + 'static {
-        let job = serde_json::from_value::<Self>(worker_context.payload().clone());
-        async move {
-            let Ok(job) = job else {
-                let e = job.err().unwrap();
-                return Err(format!("{e:?}"));
-            };
-            job.run(worker_context).await.map_err(|e| format!("{e:?}"))
-        }
-    }
+pub async fn run_task_from_worker_ctx<T: TaskHandler>(
+    worker_context: WorkerContext,
+) -> Result<(), String> {
+    let job = serde_json::from_value::<T>(worker_context.payload().clone());
+    let Ok(job) = job else {
+        let e = job.err().unwrap();
+        return Err(format!("{e:?}"));
+    };
+    job.run(worker_context)
+        .await
+        .into_task_handler_result()
+        .map_err(|e| format!("{e:?}"))
 }

crates/task_handler/src/lib.rs

@@ -1,3 +1,5 @@
 mod handler;
 
+pub use handler::run_task_from_worker_ctx;
+pub use handler::IntoTaskHandlerResult;
 pub use handler::TaskHandler;

examples/app_state.rs

@@ -34,11 +34,10 @@ struct ShowRunCount;
 impl TaskHandler for ShowRunCount {
     const IDENTIFIER: &'static str = "show_run_count";
 
-    async fn run(self, ctx: WorkerContext) -> Result<(), String> {
+    async fn run(self, ctx: WorkerContext) {
         let app_state = ctx.extensions().get::<AppState>().unwrap();
         let run_count = app_state.run_count.fetch_add(1, SeqCst);
         println!("Run count: {run_count}");
-        Ok(())
     }
 }
 

src/builder.rs

@@ -9,7 +9,7 @@ use graphile_worker_ctx::WorkerContext;
 use graphile_worker_extensions::Extensions;
 use graphile_worker_migrations::migrate;
 use graphile_worker_shutdown_signal::shutdown_signal;
-use graphile_worker_task_handler::TaskHandler;
+use graphile_worker_task_handler::{run_task_from_worker_ctx, TaskHandler};
 use rand::RngCore;
 use sqlx::postgres::PgPoolOptions;
 use sqlx::PgPool;
@@ -149,7 +149,7 @@ impl WorkerOptions {
 
         let worker_fn = move |ctx: WorkerContext| {
             let ctx = ctx.clone();
-            T::run_from_ctx(ctx).boxed()
+            run_task_from_worker_ctx::<T>(ctx).boxed()
         };
 
         self.jobs