changed interface to use instance methods rather than static ones (#58)

* changed interface to use instance mthods rather than static ones

* changed interface to use instance mthods rather than static ones

Author: virajmehta

benches/common/tasks.rs

@@ -7,17 +7,23 @@ use std::borrow::Cow;
 // ============================================================================
 
 #[allow(dead_code)]
+#[derive(Default)]
 pub struct NoOpTask;
 
 #[async_trait]
 impl Task<()> for NoOpTask {
-    fn name() -> Cow<'static, str> {
+    fn name(&self) -> Cow<'static, str> {
         Cow::Borrowed("bench-noop")
     }
     type Params = ();
     type Output = ();
 
-    async fn run(_params: Self::Params, _ctx: TaskContext, _state: ()) -> TaskResult<Self::Output> {
+    async fn run(
+        &self,
+        _params: Self::Params,
+        _ctx: TaskContext,
+        _state: (),
+    ) -> TaskResult<Self::Output> {
         Ok(())
     }
 }
@@ -27,6 +33,7 @@ impl Task<()> for NoOpTask {
 // ============================================================================
 
 #[allow(dead_code)]
+#[derive(Default)]
 pub struct QuickTask;
 
 #[allow(dead_code)]
@@ -37,13 +44,18 @@ pub struct QuickParams {
 
 #[async_trait]
 impl Task<()> for QuickTask {
-    fn name() -> Cow<'static, str> {
+    fn name(&self) -> Cow<'static, str> {
         Cow::Borrowed("bench-quick")
     }
     type Params = QuickParams;
     type Output = u32;
 
-    async fn run(params: Self::Params, _ctx: TaskContext, _state: ()) -> TaskResult<Self::Output> {
+    async fn run(
+        &self,
+        params: Self::Params,
+        _ctx: TaskContext,
+        _state: (),
+    ) -> TaskResult<Self::Output> {
         Ok(params.task_num)
     }
 }
@@ -53,6 +65,7 @@ impl Task<()> for QuickTask {
 // ============================================================================
 
 #[allow(dead_code)]
+#[derive(Default)]
 pub struct MultiStepBenchTask;
 
 #[allow(dead_code)]
@@ -63,13 +76,14 @@ pub struct MultiStepParams {
 
 #[async_trait]
 impl Task<()> for MultiStepBenchTask {
-    fn name() -> Cow<'static, str> {
+    fn name(&self) -> Cow<'static, str> {
         Cow::Borrowed("bench-multi-step")
     }
     type Params = MultiStepParams;
     type Output = u32;
 
     async fn run(
+        &self,
         params: Self::Params,
         mut ctx: TaskContext,
         _state: (),
@@ -88,6 +102,7 @@ impl Task<()> for MultiStepBenchTask {
 // ============================================================================
 
 #[allow(dead_code)]
+#[derive(Default)]
 pub struct LargePayloadBenchTask;
 
 #[allow(dead_code)]
@@ -98,13 +113,14 @@ pub struct LargePayloadParams {
 
 #[async_trait]
 impl Task<()> for LargePayloadBenchTask {
-    fn name() -> Cow<'static, str> {
+    fn name(&self) -> Cow<'static, str> {
         Cow::Borrowed("bench-large-payload")
     }
     type Params = LargePayloadParams;
     type Output = usize;
 
     async fn run(
+        &self,
         params: Self::Params,
         mut ctx: TaskContext,
         _state: (),

src/client.rs

@@ -2,14 +2,13 @@ use serde::Serialize;
 use serde_json::Value as JsonValue;
 use sqlx::{Executor, PgPool, Postgres};
 use std::collections::HashMap;
-use std::marker::PhantomData;
 use std::sync::Arc;
 use std::time::Duration;
 use tokio::sync::RwLock;
 use uuid::Uuid;
 
 use crate::error::{DurableError, DurableResult};
-use crate::task::{Task, TaskRegistry};
+use crate::task::{Task, TaskRegistry, TaskWrapper};
 use crate::types::{
     CancellationPolicy, RetryStrategy, SpawnDefaults, SpawnOptions, SpawnResult, SpawnResultRow,
     WorkerOptions,
@@ -305,31 +304,45 @@ where
     /// Register a task type. Required before spawning or processing.
     ///
     /// Returns an error if a task with the same name is already registered.
-    pub async fn register<T: Task<State>>(&self) -> DurableResult<&Self> {
+    pub async fn register<T: Task<State> + Default>(&self) -> DurableResult<&Self> {
+        self.register_instance(T::default()).await
+    }
+
+    /// Register a task instance. Required before spawning or processing.
+    ///
+    /// Use this when you need to register a task with runtime-determined metadata
+    /// (e.g., a TypeScript tool loaded from a config file).
+    ///
+    /// Returns an error if a task with the same name is already registered.
+    pub async fn register_instance<T: Task<State>>(&self, task: T) -> DurableResult<&Self> {
         let mut registry = self.registry.write().await;
-        let name = T::name();
-        if registry.contains_key(&name) {
+        let name = task.name();
+        if registry.contains_key(name.as_ref()) {
             return Err(DurableError::TaskAlreadyRegistered {
                 task_name: name.to_string(),
             });
         }
-        registry.insert(name, &PhantomData::<T>);
+        registry.insert(name, Arc::new(TaskWrapper::new(task)));
         Ok(self)
     }
 
     /// Spawn a task (type-safe version)
-    pub async fn spawn<T: Task<State>>(&self, params: T::Params) -> DurableResult<SpawnResult> {
+    pub async fn spawn<T: Task<State> + Default>(
+        &self,
+        params: T::Params,
+    ) -> DurableResult<SpawnResult> {
         self.spawn_with_options::<T>(params, SpawnOptions::default())
             .await
     }
 
     /// Spawn a task with options (type-safe version)
-    pub async fn spawn_with_options<T: Task<State>>(
+    pub async fn spawn_with_options<T: Task<State> + Default>(
         &self,
         params: T::Params,
         options: SpawnOptions,
     ) -> DurableResult<SpawnResult> {
-        self.spawn_by_name(&T::name(), serde_json::to_value(&params)?, options)
+        let task = T::default();
+        self.spawn_by_name(&task.name(), serde_json::to_value(&params)?, options)
             .await
     }
 
@@ -370,7 +383,7 @@ where
         params: T::Params,
     ) -> DurableResult<SpawnResult>
     where
-        T: Task<State>,
+        T: Task<State> + Default,
         E: Executor<'e, Database = Postgres>,
     {
         self.spawn_with_options_with::<T, E>(executor, params, SpawnOptions::default())
@@ -385,13 +398,13 @@ where
         options: SpawnOptions,
     ) -> DurableResult<SpawnResult>
     where
-        T: Task<State>,
+        T: Task<State> + Default,
         E: Executor<'e, Database = Postgres>,
     {
-        // Type-safe spawn uses T::name() which is already registered
+        let task = T::default();
         self.spawn_by_name_internal(
             executor,
-            &T::name(),
+            &task.name(),
             serde_json::to_value(&params)?,
             options,
         )

src/context.rs

@@ -575,7 +575,7 @@ where
         tracing::instrument(
             name = "durable.task.spawn",
             skip(self, params, options),
-            fields(task_id = %self.task_id, subtask_name = %T::name())
+            fields(task_id = %self.task_id)
         )
     )]
     pub async fn spawn<T>(
@@ -585,10 +585,11 @@ where
         options: crate::SpawnOptions,
     ) -> TaskResult<TaskHandle<T::Output>>
     where
-        T: Task<State>,
+        T: Task<State> + Default,
     {
+        let task = T::default();
         let params_json = serde_json::to_value(&params)?;
-        self.spawn_by_name(name, &T::name(), params_json, options)
+        self.spawn_by_name(name, &task.name(), params_json, options)
             .await
     }
 

src/lib.rs

@@ -19,15 +19,16 @@
 //! #[derive(Serialize, Deserialize)]
 //! struct MyOutput { result: i32 }
 //!
+//! #[derive(Default)]
 //! struct MyTask;
 //!
 //! #[async_trait]
 //! impl Task<()> for MyTask {
-//!     fn name() -> Cow<'static, str> { Cow::Borrowed("my-task") }
+//!     fn name(&self) -> Cow<'static, str> { Cow::Borrowed("my-task") }
 //!     type Params = MyParams;
 //!     type Output = MyOutput;
 //!
-//!     async fn run(params: Self::Params, mut ctx: TaskContext, _state: ()) -> TaskResult<Self::Output> {
+//!     async fn run(&self, params: Self::Params, mut ctx: TaskContext, _state: ()) -> TaskResult<Self::Output> {
 //!         let doubled = ctx.step("double", || async {
 //!             Ok(params.value * 2)
 //!         }).await?;
@@ -61,15 +62,16 @@
 //!     http_client: reqwest::Client,
 //! }
 //!
+//! #[derive(Default)]
 //! struct FetchTask;
 //!
 //! #[async_trait]
 //! impl Task<AppState> for FetchTask {
-//!     fn name() -> Cow<'static, str> { Cow::Borrowed("fetch") }
+//!     fn name(&self) -> Cow<'static, str> { Cow::Borrowed("fetch") }
 //!     type Params = String;
 //!     type Output = String;
 //!
-//!     async fn run(url: Self::Params, mut ctx: TaskContext, state: AppState) -> TaskResult<Self::Output> {
+//!     async fn run(&self, url: Self::Params, mut ctx: TaskContext, state: AppState) -> TaskResult<Self::Output> {
 //!         ctx.step("fetch", || async {
 //!             state.http_client.get(&url).send().await?.text().await
 //!                 .map_err(|e| anyhow::anyhow!(e))
@@ -105,7 +107,7 @@ mod worker;
 pub use client::{Durable, DurableBuilder};
 pub use context::TaskContext;
 pub use error::{ControlFlow, DurableError, DurableResult, TaskError, TaskResult};
-pub use task::Task;
+pub use task::{ErasedTask, Task, TaskWrapper};
 pub use types::{
     CancellationPolicy, ClaimedTask, RetryStrategy, SpawnDefaults, SpawnOptions, SpawnResult,
     TaskHandle, WorkerOptions,

src/task.rs

@@ -2,7 +2,7 @@ use async_trait::async_trait;
 use serde::{Serialize, de::DeserializeOwned};
 use serde_json::Value as JsonValue;
 use std::borrow::Cow;
-use std::marker::PhantomData;
+use std::sync::Arc;
 
 use crate::context::TaskContext;
 use crate::error::{TaskError, TaskResult};
@@ -25,11 +25,11 @@ use crate::error::{TaskError, TaskResult};
 ///
 /// #[async_trait]
 /// impl Task<()> for SendEmailTask {
-///     fn name() -> Cow<'static, str> { Cow::Borrowed("send-email") }
+///     fn name(&self) -> Cow<'static, str> { Cow::Borrowed("send-email") }
 ///     type Params = SendEmailParams;
 ///     type Output = SendEmailResult;
 ///
-///     async fn run(params: Self::Params, mut ctx: TaskContext, _state: ()) -> TaskResult<Self::Output> {
+///     async fn run(&self, params: Self::Params, mut ctx: TaskContext, _state: ()) -> TaskResult<Self::Output> {
 ///         let result = ctx.step("send", || async {
 ///             email_service::send(&params.to, &params.subject, &params.body).await
 ///         }).await?;
@@ -48,11 +48,11 @@ use crate::error::{TaskError, TaskResult};
 ///
 /// #[async_trait]
 /// impl Task<AppState> for FetchUrlTask {
-///     fn name() -> Cow<'static, str> { Cow::Borrowed("fetch-url") }
+///     fn name(&self) -> Cow<'static, str> { Cow::Borrowed("fetch-url") }
 ///     type Params = String;
 ///     type Output = String;
 ///
-///     async fn run(url: Self::Params, mut ctx: TaskContext, state: AppState) -> TaskResult<Self::Output> {
+///     async fn run(&self, url: Self::Params, mut ctx: TaskContext, state: AppState) -> TaskResult<Self::Output> {
 ///         let body = ctx.step("fetch", || async {
 ///             state.http_client.get(&url).send().await
 ///                 .map_err(|e| anyhow::anyhow!("HTTP error: {}", e))?
@@ -70,7 +70,7 @@ where
 {
     /// Task name as stored in the database.
     /// Should be unique across your application.
-    fn name() -> Cow<'static, str>;
+    fn name(&self) -> Cow<'static, str>;
 
     /// Parameter type (must be JSON-serializable)
     type Params: Serialize + DeserializeOwned + Send;
@@ -94,6 +94,7 @@ where
     /// The `state` parameter provides access to application-level resources
     /// like HTTP clients, database pools, etc.
     async fn run(
+        &self,
         params: Self::Params,
         ctx: TaskContext<State>,
         state: State,
@@ -119,14 +120,27 @@ where
     ) -> Result<JsonValue, TaskError>;
 }
 
+/// Wrapper that implements [`ErasedTask`] for any [`Task`] type.
+///
+/// This allows storing heterogeneous tasks in a registry while preserving
+/// their ability to execute.
+pub struct TaskWrapper<T>(pub Arc<T>);
+
+impl<T> TaskWrapper<T> {
+    /// Create a new TaskWrapper from a task instance.
+    pub fn new(task: T) -> Self {
+        Self(Arc::new(task))
+    }
+}
+
 #[async_trait]
-impl<T, State> ErasedTask<State> for PhantomData<T>
+impl<T, State> ErasedTask<State> for TaskWrapper<T>
 where
     T: Task<State>,
     State: Clone + Send + Sync + 'static,
 {
     fn name(&self) -> Cow<'static, str> {
-        T::name()
+        self.0.name()
     }
 
     fn validate_params(&self, params: JsonValue) -> Result<(), TaskError> {
@@ -142,11 +156,11 @@ where
         state: State,
     ) -> Result<JsonValue, TaskError> {
         let typed_params: T::Params = serde_json::from_value(params)?;
-        let result = T::run(typed_params, ctx, state).await?;
+        let result = self.0.run(typed_params, ctx, state).await?;
         Ok(serde_json::to_value(&result)?)
     }
 }
 
 /// Type alias for the task registry
 pub type TaskRegistry<State> =
-    std::collections::HashMap<Cow<'static, str>, &'static dyn ErasedTask<State>>;
+    std::collections::HashMap<Cow<'static, str>, Arc<dyn ErasedTask<State>>>;

src/worker.rs

@@ -364,7 +364,7 @@ impl Worker {
         // Look up handler
         let registry = registry.read().await;
         let handler = match registry.get(task.task_name.as_str()) {
-            Some(h) => *h,
+            Some(h) => h.clone(),
             None => {
                 tracing::error!("Unknown task: {}", task.task_name);
                 Self::fail_run(