Preserve partial creation replies on stream failure

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

@@ -0,0 +1,432 @@
+use super::*;
+use crate::mapper::*;
+
+impl SpacetimeClient {
+    pub async fn create_square_hole_agent_session(
+        &self,
+        input: SquareHoleAgentSessionCreateRecordInput,
+    ) -> Result<SquareHoleAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleAgentSessionCreateInput {
+            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,
+            config_json: input.config_json,
+            created_at_micros: input.created_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().create_square_hole_agent_session_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn get_square_hole_agent_session(
+        &self,
+        session_id: String,
+        owner_user_id: String,
+    ) -> Result<SquareHoleAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleAgentSessionGetInput {
+            session_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().get_square_hole_agent_session_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn submit_square_hole_agent_message(
+        &self,
+        input: SquareHoleAgentMessageSubmitRecordInput,
+    ) -> Result<SquareHoleAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleAgentMessageSubmitInput {
+            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,
+            submitted_at_micros: input.submitted_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection.procedures().submit_square_hole_agent_message_then(
+                procedure_input,
+                move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                },
+            );
+        })
+        .await
+    }
+
+    pub async fn finalize_square_hole_agent_message(
+        &self,
+        input: SquareHoleAgentMessageFinalizeRecordInput,
+    ) -> Result<SquareHoleAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleAgentMessageFinalizeInput {
+            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,
+            config_json: input.config_json,
+            progress_percent: input.progress_percent,
+            stage: input.stage,
+            updated_at_micros: input.updated_at_micros,
+            error_message: input.error_message,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .finalize_square_hole_agent_message_turn_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn compile_square_hole_draft(
+        &self,
+        input: SquareHoleCompileDraftRecordInput,
+    ) -> Result<SquareHoleAgentSessionRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleDraftCompileInput {
+            session_id: input.session_id,
+            owner_user_id: input.owner_user_id,
+            profile_id: input.profile_id,
+            author_display_name: input.author_display_name,
+            game_name: input.game_name,
+            summary_text: input.summary_text,
+            tags_json: input.tags_json,
+            cover_image_src: input.cover_image_src,
+            compiled_at_micros: input.compiled_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .compile_square_hole_draft_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_agent_session_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn update_square_hole_work(
+        &self,
+        input: SquareHoleWorkUpdateRecordInput,
+    ) -> Result<SquareHoleWorkProfileRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleWorkUpdateInput {
+            profile_id: input.profile_id,
+            owner_user_id: input.owner_user_id,
+            game_name: input.game_name,
+            theme_text: input.theme_text,
+            twist_rule: input.twist_rule,
+            summary_text: input.summary_text,
+            tags_json: input.tags_json,
+            cover_image_src: input.cover_image_src,
+            shape_count: input.shape_count,
+            difficulty: input.difficulty,
+            updated_at_micros: input.updated_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .update_square_hole_work_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_work_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn publish_square_hole_work(
+        &self,
+        profile_id: String,
+        owner_user_id: String,
+        published_at_micros: i64,
+    ) -> Result<SquareHoleWorkProfileRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleWorkPublishInput {
+            profile_id,
+            owner_user_id,
+            published_at_micros,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .publish_square_hole_work_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_work_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn list_square_hole_works(
+        &self,
+        owner_user_id: String,
+    ) -> Result<Vec<SquareHoleWorkProfileRecord>, SpacetimeClientError> {
+        self.list_square_hole_works_with_input(SquareHoleWorksListInput {
+            owner_user_id,
+            published_only: false,
+        })
+        .await
+    }
+
+    pub async fn list_square_hole_gallery(
+        &self,
+    ) -> Result<Vec<SquareHoleWorkProfileRecord>, SpacetimeClientError> {
+        self.list_square_hole_works_with_input(SquareHoleWorksListInput {
+            // 中文注释：公开广场只依赖 published_only，owner_user_id 用固定值通过输入校验。
+            owner_user_id: "square-hole-public-gallery".to_string(),
+            published_only: true,
+        })
+        .await
+    }
+
+    async fn list_square_hole_works_with_input(
+        &self,
+        procedure_input: SquareHoleWorksListInput,
+    ) -> Result<Vec<SquareHoleWorkProfileRecord>, SpacetimeClientError> {
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .list_square_hole_works_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_works_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn get_square_hole_work_detail(
+        &self,
+        profile_id: String,
+        owner_user_id: String,
+    ) -> Result<SquareHoleWorkProfileRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleWorkGetInput {
+            profile_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .get_square_hole_work_detail_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_work_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn delete_square_hole_work(
+        &self,
+        profile_id: String,
+        owner_user_id: String,
+    ) -> Result<Vec<SquareHoleWorkProfileRecord>, SpacetimeClientError> {
+        let procedure_input = SquareHoleWorkDeleteInput {
+            profile_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .delete_square_hole_work_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_works_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn start_square_hole_run(
+        &self,
+        input: SquareHoleRunStartRecordInput,
+    ) -> Result<SquareHoleRunRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleRunStartInput {
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            profile_id: input.profile_id,
+            started_at_ms: input.started_at_ms,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .start_square_hole_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn get_square_hole_run(
+        &self,
+        run_id: String,
+        owner_user_id: String,
+    ) -> Result<SquareHoleRunRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleRunGetInput {
+            run_id,
+            owner_user_id,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .get_square_hole_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn drop_square_hole_shape(
+        &self,
+        input: SquareHoleRunDropRecordInput,
+    ) -> Result<SquareHoleDropConfirmationRecord, SpacetimeClientError> {
+        let client_event_id = input.client_event_id.clone();
+        let procedure_input = SquareHoleRunDropInput {
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            hole_id: input.hole_id,
+            client_snapshot_version: input.client_snapshot_version,
+            client_event_id: input.client_event_id,
+            dropped_at_ms: input.dropped_at_ms,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .drop_square_hole_shape_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_drop_shape_procedure_result)
+                        .map(|mut confirmation| {
+                            if confirmation.accepted {
+                                confirmation.run.last_confirmed_action_id =
+                                    Some(client_event_id);
+                            }
+                            confirmation
+                        });
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn stop_square_hole_run(
+        &self,
+        input: SquareHoleRunStopRecordInput,
+    ) -> Result<SquareHoleRunRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleRunStopInput {
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            stopped_at_ms: input.stopped_at_ms,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .stop_square_hole_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn restart_square_hole_run(
+        &self,
+        input: SquareHoleRunRestartRecordInput,
+    ) -> Result<SquareHoleRunRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleRunRestartInput {
+            source_run_id: input.source_run_id,
+            next_run_id: input.next_run_id,
+            owner_user_id: input.owner_user_id,
+            restarted_at_ms: input.restarted_at_ms,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .restart_square_hole_run_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+
+    pub async fn finish_square_hole_time_up(
+        &self,
+        input: SquareHoleRunTimeUpRecordInput,
+    ) -> Result<SquareHoleRunRecord, SpacetimeClientError> {
+        let procedure_input = SquareHoleRunTimeUpInput {
+            run_id: input.run_id,
+            owner_user_id: input.owner_user_id,
+            finished_at_ms: input.finished_at_ms,
+        };
+
+        self.call_after_connect(move |connection, sender| {
+            connection
+                .procedures()
+                .finish_square_hole_time_up_then(procedure_input, move |_, result| {
+                    let mapped = result
+                        .map_err(|error| SpacetimeClientError::Procedure(error.to_string()))
+                        .and_then(map_square_hole_run_procedure_result);
+                    send_once(&sender, mapped);
+                });
+        })
+        .await
+    }
+}