init with react+axum+spacetimedb

server-rs/crates/spacetime-client/src/ai.rs

@@ -0,0 +1,196 @@
+use super::*;
+use crate::mapper::*;
+
+impl SpacetimeClient {
+    pub async fn create_ai_task(
+        &self,
+        input: DomainAiTaskCreateInput,
+    ) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+        let procedure_input = input.into();
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().create_ai_task_and_return_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_ai_task_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn start_ai_task(
+        &self,
+        input: DomainAiTaskStartInput,
+    ) -> Result<(), SpacetimeClientError> {
+        let reducer_input = input.into();
+
+        self.call_reducer_after_connect(move |connection, sender| {
+            let callback_sender = sender.clone();
+            if let Err(error) =
+                connection
+                    .reducers
+                    .start_ai_task_then(reducer_input, move |_, result| {
+                        let mapped = result
+                            .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                            .and_then(|inner| inner.map_err(SpacetimeClientError::Runtime));
+                        send_reducer_once(&callback_sender, mapped);
+                    })
+            {
+                send_reducer_once(
+                    &sender,
+                    Err(SpacetimeClientError::Procedure(error.to_string())),
+                );
+            }
+        })
+        .await
+    }
+
+    pub async fn start_ai_task_stage(
+        &self,
+        input: DomainAiTaskStageStartInput,
+    ) -> Result<(), SpacetimeClientError> {
+        let reducer_input = input.into();
+
+        self.call_reducer_after_connect(move |connection, sender| {
+            let callback_sender = sender.clone();
+            if let Err(error) =
+                connection
+                    .reducers
+                    .start_ai_task_stage_then(reducer_input, move |_, result| {
+                        let mapped = result
+                            .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                            .and_then(|inner| inner.map_err(SpacetimeClientError::Runtime));
+                        send_reducer_once(&callback_sender, mapped);
+                    })
+            {
+                send_reducer_once(
+                    &sender,
+                    Err(SpacetimeClientError::Procedure(error.to_string())),
+                );
+            }
+        })
+        .await
+    }
+
+    pub async fn append_ai_text_chunk(
+        &self,
+        input: DomainAiTextChunkAppendInput,
+    ) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+        let procedure_input = input.into();
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .append_ai_text_chunk_and_return_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_ai_task_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn complete_ai_stage(
+        &self,
+        input: DomainAiStageCompletionInput,
+    ) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+        let procedure_input = input.into();
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().complete_ai_stage_and_return_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_ai_task_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn attach_ai_result_reference(
+        &self,
+        input: DomainAiResultReferenceInput,
+    ) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+        let procedure_input = input.into();
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .attach_ai_result_reference_and_return_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_ai_task_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn complete_ai_task(
+        &self,
+        input: DomainAiTaskFinishInput,
+    ) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+        let procedure_input = input.into();
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().complete_ai_task_and_return_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_ai_task_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn fail_ai_task(
+        &self,
+        input: DomainAiTaskFailureInput,
+    ) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+        let procedure_input = input.into();
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().fail_ai_task_and_return_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_ai_task_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn cancel_ai_task(
+        &self,
+        input: DomainAiTaskCancelInput,
+    ) -> Result<AiTaskMutationRecord, SpacetimeClientError> {
+        let procedure_input = input.into();
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().cancel_ai_task_and_return_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_ai_task_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+}