init with react+axum+spacetimedb

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

@@ -0,0 +1,306 @@
+use super::*;
+use crate::mapper::*;
+use crate::module_bindings::delete_big_fish_work_procedure::delete_big_fish_work;
+
+impl SpacetimeClient {
+    pub async fn create_big_fish_session(
+        &self,
+        input: BigFishSessionCreateRecordInput,
+    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
+        let procedure_input = BigFishSessionCreateInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            seed_text: input.seed_text,
+            welcome_message_id: input.welcome_message_id,
+            welcome_message_text: input.welcome_message_text,
+            created_at_micros: input.created_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().create_big_fish_session_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn get_big_fish_session(
+        &self,
+        session_id: String,
+        owner_user_id: String,
+    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
+        let procedure_input = BigFishSessionGetInput {
+            session_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .get_big_fish_session_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_session_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn list_big_fish_works(
+        &self,
+        owner_user_id: String,
+    ) -> Result<Vec<BigFishWorkSummaryRecord>, SpacetimeClientError> {
+        let procedure_input = BigFishWorksListInput { owner_user_id };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .list_big_fish_works_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_works_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn delete_big_fish_work(
+        &self,
+        session_id: String,
+        owner_user_id: String,
+    ) -> Result<Vec<BigFishWorkSummaryRecord>, SpacetimeClientError> {
+        let procedure_input = BigFishWorkDeleteInput {
+            session_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .delete_big_fish_work_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_works_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn submit_big_fish_message(
+        &self,
+        input: BigFishMessageSubmitRecordInput,
+    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
+        let procedure_input = BigFishMessageSubmitInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            user_message_id: input.user_message_id,
+            user_message_text: input.user_message_text,
+            assistant_message_id: input.assistant_message_id,
+            submitted_at_micros: input.submitted_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().submit_big_fish_message_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn finalize_big_fish_agent_message(
+        &self,
+        input: BigFishMessageFinalizeRecordInput,
+    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
+        let procedure_input = BigFishMessageFinalizeInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            assistant_message_id: input.assistant_message_id,
+            assistant_reply_text: input.assistant_reply_text,
+            stage: parse_big_fish_creation_stage(&input.stage)?,
+            progress_percent: input.progress_percent,
+            anchor_pack_json: input.anchor_pack_json,
+            error_message: input.error_message,
+            updated_at_micros: input.updated_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .finalize_big_fish_agent_message_turn_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_session_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn compile_big_fish_draft(
+        &self,
+        session_id: String,
+        owner_user_id: String,
+        compiled_at_micros: i64,
+    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
+        let procedure_input = BigFishDraftCompileInput {
+            session_id,
+            owner_user_id,
+            compiled_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().compile_big_fish_draft_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn generate_big_fish_asset(
+        &self,
+        input: BigFishAssetGenerateRecordInput,
+    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
+        let procedure_input = BigFishAssetGenerateInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            asset_kind: input.asset_kind.as_str().try_into()?,
+            level: input.level,
+            motion_key: input.motion_key,
+            asset_url: input.asset_url,
+            generated_at_micros: input.generated_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().generate_big_fish_asset_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn publish_big_fish_game(
+        &self,
+        session_id: String,
+        owner_user_id: String,
+        published_at_micros: i64,
+    ) -> Result<BigFishSessionRecord, SpacetimeClientError> {
+        let procedure_input = BigFishPublishInput {
+            session_id,
+            owner_user_id,
+            published_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().publish_big_fish_game_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn start_big_fish_run(
+        &self,
+        input: BigFishRunStartRecordInput,
+    ) -> Result<BigFishRuntimeRecord, SpacetimeClientError> {
+        let procedure_input = BigFishRunStartInput {
+            run_id: input.run_id,
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            started_at_micros: input.started_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .start_big_fish_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn submit_big_fish_input(
+        &self,
+        input: BigFishRunInputSubmitRecordInput,
+    ) -> Result<BigFishRuntimeRecord, SpacetimeClientError> {
+        let procedure_input = BigFishRunInputSubmitInput {
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            input_x: input.input_x,
+            input_y: input.input_y,
+            submitted_at_micros: input.submitted_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().submit_big_fish_input_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_run_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn get_big_fish_run(
+        &self,
+        run_id: String,
+        owner_user_id: String,
+    ) -> Result<BigFishRuntimeRecord, SpacetimeClientError> {
+        let procedure_input = BigFishRunGetInput {
+            run_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .get_big_fish_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_big_fish_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+}