feat: 完成 rust cutover phase 8 收口

rust/crates/storage-convex-bridge/src/lib.rs

@@ -22,10 +22,16 @@ mod tests {
     use super::*;
     use core_protocol::{
         command::{
-            CreatePage, CreateWorkspace, PatchPageBlock, ReplaceMediaAssetStorage,
-            SavePageContent, UpdatePageOptions, UpdatePageStats, UpdatePageTitle,
+            CopyTreeDocumentPages, CreateDocumentPage, CreatePage, CreateWorkspace,
+            DeleteDocumentPage, DuplicateDocumentPage, MoveDocumentPage, PatchPageBlock,
+            PutMindmap, ReplaceMediaAssetStorage, RestoreDocumentPage, SavePageContent,
+            UpdatePageOptions, UpdatePageStats, UpdatePageTitle,
+        },
+        query::{
+            GetBlock, GetBridgeCommand, GetBridgeRequest, GetBridgeTrace, GetMindmap, GetPage,
+            GetPageContent, GetPageMeta, ListBridgeWorkspaceOverview, ListSidebarDataset,
+            SearchDocuments, SearchRecent,
         },
-        query::{GetPage, GetPageContent, GetPageMeta, ListSidebarDataset},
         ActorPayload, CommandEnvelope, QueryEnvelope, SourcePayload, TargetRef,
     };
 
@@ -80,7 +86,8 @@ mod tests {
             validate_only: false,
         };
 
-        let request = build_write_request(&demo_context(), &command).expect("write request should build");
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
         assert_eq!(request.function_name, "pages:create");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
         assert_eq!(request.deployment_id.as_deref(), Some("dep_1"));
@@ -99,7 +106,8 @@ mod tests {
             },
         };
 
-        let request = build_query_request(&demo_context(), &query).expect("query request should build");
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
         assert_eq!(request.function_name, "pages:get");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
         assert_eq!(request.request_id, "req_1");
@@ -134,12 +142,19 @@ mod tests {
             validate_only: false,
         };
 
-        let pipeline = build_write_pipeline(&demo_context(), &command).expect("pipeline should build");
+        let pipeline =
+            build_write_pipeline(&demo_context(), &command).expect("pipeline should build");
         assert_eq!(pipeline.command_log.command_name, "create_workspace");
-        assert!(pipeline.command_log.payload_summary.contains("request_id=req_1"));
+        assert!(pipeline
+            .command_log
+            .payload_summary
+            .contains("request_id=req_1"));
         assert_eq!(pipeline.command_log.trace_id, "trace_1");
         assert_eq!(pipeline.command_log.request_id, "req_1");
-        assert!(pipeline.domain_event.payload_json.contains("\"trace_id\":\"trace_1\""));
+        assert!(pipeline
+            .domain_event
+            .payload_json
+            .contains("\"trace_id\":\"trace_1\""));
         assert_eq!(pipeline.result.event_ids, vec!["evt_cmd_2".to_string()]);
     }
 
@@ -173,10 +188,13 @@ mod tests {
             validate_only: false,
         };
 
-        let request = build_write_request(&demo_context(), &command).expect("write request should build");
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
         assert_eq!(request.function_name, "documents:updateTitle");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
-        assert!(request.payload_json.contains("\"name\":\"documents.title.update\""));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"documents.title.update\""));
     }
 
     #[test]
@@ -212,12 +230,190 @@ mod tests {
             validate_only: false,
         };
 
-        let request = build_write_request(&demo_context(), &command).expect("write request should build");
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
         assert_eq!(request.function_name, "documents:updateContent");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
         assert!(request.payload_json.contains("\"name\":\"documents.save\""));
     }
 
+    #[test]
+    fn page_lifecycle_commands_map_to_document_mutations() {
+        let base_actor = ActorPayload {
+            actor_type: "human".into(),
+            actor_id: "user_1".into(),
+            session_id: Some("session_1".into()),
+        };
+        let base_source = SourcePayload {
+            channel: "next-route".into(),
+            client: "wolai-frontend".into(),
+        };
+
+        let create_request = build_write_request(
+            &demo_context(),
+            &CommandEnvelope {
+                name: "documents.create".into(),
+                command_id: "cmd_create_1".into(),
+                idempotency_key: Some("idem_create".into()),
+                actor: base_actor.clone(),
+                source: base_source.clone(),
+                target: Some(TargetRef {
+                    workspace_id: None,
+                    page_id: Some("page_1".into()),
+                    block_id: None,
+                }),
+                payload: CreateDocumentPage {
+                    page_id: "page_1".into(),
+                    parent_page_id: Some("parent_1".into()),
+                    title: "无标题".into(),
+                    workspace_seed_id: "ws_seed_1".into(),
+                },
+                reason: Some("创建页面".into()),
+                refs: vec![],
+                dry_run: false,
+                validate_only: false,
+            },
+        )
+        .expect("create request should build");
+        assert_eq!(
+            create_request.function_name,
+            "documents:createWithParentReference"
+        );
+
+        let move_request = build_write_request(
+            &demo_context(),
+            &CommandEnvelope {
+                name: "documents.move".into(),
+                command_id: "cmd_move_1".into(),
+                idempotency_key: Some("idem_move".into()),
+                actor: base_actor.clone(),
+                source: base_source.clone(),
+                target: Some(TargetRef {
+                    workspace_id: None,
+                    page_id: Some("page_1".into()),
+                    block_id: None,
+                }),
+                payload: MoveDocumentPage {
+                    page_id: "page_1".into(),
+                    parent_page_id: Some("parent_2".into()),
+                    sort_order: 3,
+                },
+                reason: Some("移动页面".into()),
+                refs: vec![],
+                dry_run: false,
+                validate_only: false,
+            },
+        )
+        .expect("move request should build");
+        assert_eq!(move_request.function_name, "documents:move");
+
+        let delete_request = build_write_request(
+            &demo_context(),
+            &CommandEnvelope {
+                name: "documents.delete".into(),
+                command_id: "cmd_delete_1".into(),
+                idempotency_key: Some("idem_delete".into()),
+                actor: base_actor.clone(),
+                source: base_source.clone(),
+                target: Some(TargetRef {
+                    workspace_id: None,
+                    page_id: Some("page_1".into()),
+                    block_id: None,
+                }),
+                payload: DeleteDocumentPage {
+                    page_id: "page_1".into(),
+                },
+                reason: Some("删除页面".into()),
+                refs: vec![],
+                dry_run: false,
+                validate_only: false,
+            },
+        )
+        .expect("delete request should build");
+        assert_eq!(delete_request.function_name, "documents:softDelete");
+
+        let restore_request = build_write_request(
+            &demo_context(),
+            &CommandEnvelope {
+                name: "documents.restore".into(),
+                command_id: "cmd_restore_1".into(),
+                idempotency_key: Some("idem_restore".into()),
+                actor: base_actor.clone(),
+                source: base_source.clone(),
+                target: Some(TargetRef {
+                    workspace_id: None,
+                    page_id: Some("page_1".into()),
+                    block_id: None,
+                }),
+                payload: RestoreDocumentPage {
+                    page_id: "page_1".into(),
+                },
+                reason: Some("恢复页面".into()),
+                refs: vec![],
+                dry_run: false,
+                validate_only: false,
+            },
+        )
+        .expect("restore request should build");
+        assert_eq!(restore_request.function_name, "documents:restore");
+
+        let duplicate_request = build_write_request(
+            &demo_context(),
+            &CommandEnvelope {
+                name: "documents.duplicate".into(),
+                command_id: "cmd_duplicate_1".into(),
+                idempotency_key: Some("idem_duplicate".into()),
+                actor: base_actor.clone(),
+                source: base_source.clone(),
+                target: Some(TargetRef {
+                    workspace_id: None,
+                    page_id: Some("page_copy_1".into()),
+                    block_id: None,
+                }),
+                payload: DuplicateDocumentPage {
+                    source_page_id: "page_1".into(),
+                    new_page_id: "page_copy_1".into(),
+                    title: Some("无标题 副本".into()),
+                },
+                reason: Some("复制页面".into()),
+                refs: vec![],
+                dry_run: false,
+                validate_only: false,
+            },
+        )
+        .expect("duplicate request should build");
+        assert_eq!(
+            duplicate_request.function_name,
+            "documents:duplicateWithMindmaps"
+        );
+
+        let copy_tree_request = build_write_request(
+            &demo_context(),
+            &CommandEnvelope {
+                name: "documents.copy_tree".into(),
+                command_id: "cmd_copy_tree_1".into(),
+                idempotency_key: Some("idem_copy_tree".into()),
+                actor: base_actor,
+                source: base_source,
+                target: Some(TargetRef {
+                    workspace_id: None,
+                    page_id: Some("target_parent_1".into()),
+                    block_id: None,
+                }),
+                payload: CopyTreeDocumentPages {
+                    items_json: "[{\"documentId\":\"page_1\",\"recursive\":true}]".into(),
+                    target_parent_page_id: Some("target_parent_1".into()),
+                },
+                reason: Some("复制页面树".into()),
+                refs: vec![],
+                dry_run: false,
+                validate_only: false,
+            },
+        )
+        .expect("copy tree request should build");
+        assert_eq!(copy_tree_request.function_name, "documents:copyTree");
+    }
+
     #[test]
     fn block_patch_command_maps_to_documents_update_content() {
         let command = CommandEnvelope {
@@ -252,12 +448,29 @@ mod tests {
             validate_only: false,
         };
 
-        let request = build_write_request(&demo_context(), &command).expect("write request should build");
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
         assert_eq!(request.function_name, "documents:updateContent");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
         assert!(request.payload_json.contains("\"name\":\"blocks.patch\""));
     }
 
+    #[test]
+    fn blocks_get_query_maps_to_blocks_get_by_id() {
+        let query = QueryEnvelope {
+            name: "blocks.get".into(),
+            payload: GetBlock {
+                block_id: "block_1".into(),
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "blocks:getById");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request.payload_json.contains("\"name\":\"blocks.get\""));
+    }
+
     #[test]
     fn document_stats_command_maps_to_documents_update_stats() {
         let command = CommandEnvelope {
@@ -292,10 +505,13 @@ mod tests {
             validate_only: false,
         };
 
-        let request = build_write_request(&demo_context(), &command).expect("write request should build");
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
         assert_eq!(request.function_name, "documents:updateStats");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
-        assert!(request.payload_json.contains("\"name\":\"documents.stats.update\""));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"documents.stats.update\""));
     }
 
     #[test]
@@ -340,10 +556,13 @@ mod tests {
             validate_only: false,
         };
 
-        let request = build_write_request(&demo_context(), &command).expect("write request should build");
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
         assert_eq!(request.function_name, "documents:updateOptions");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
-        assert!(request.payload_json.contains("\"name\":\"documents.options.update\""));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"documents.options.update\""));
     }
 
     #[test]
@@ -376,10 +595,16 @@ mod tests {
             validate_only: false,
         };
 
-        let request = build_write_request(&demo_context(), &command).expect("write request should build");
-        assert_eq!(request.function_name, "mediaAssets:replaceStorageFromUpload");
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
+        assert_eq!(
+            request.function_name,
+            "mediaAssets:replaceStorageFromUpload"
+        );
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
-        assert!(request.payload_json.contains("\"name\":\"media.assets.replace_storage\""));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"media.assets.replace_storage\""));
     }
 
     #[test]
@@ -392,10 +617,13 @@ mod tests {
             },
         };
 
-        let request = build_query_request(&demo_context(), &query).expect("query request should build");
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
         assert_eq!(request.function_name, "documents:getMeta");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
-        assert!(request.payload_json.contains("\"name\":\"documents.meta.get\""));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"documents.meta.get\""));
     }
 
     #[test]
@@ -408,10 +636,31 @@ mod tests {
             },
         };
 
-        let request = build_query_request(&demo_context(), &query).expect("query request should build");
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
         assert_eq!(request.function_name, "documents:getContent");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
-        assert!(request.payload_json.contains("\"name\":\"documents.content.get\""));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"documents.content.get\""));
+    }
+
+    #[test]
+    fn mindmap_get_query_maps_to_mindmaps_get() {
+        let query = QueryEnvelope {
+            name: "mindmaps.get".into(),
+            payload: GetMindmap {
+                document_id: "page_1".into(),
+                mindmap_id: "mind_1".into(),
+                workspace_id: Some("ws_1".into()),
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "mindmaps:get");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request.payload_json.contains("\"name\":\"mindmaps.get\""));
     }
 
     #[test]
@@ -423,9 +672,191 @@ mod tests {
             },
         };
 
-        let request = build_query_request(&demo_context(), &query).expect("query request should build");
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
         assert_eq!(request.function_name, "sidebar:datasetList");
         assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
-        assert!(request.payload_json.contains("\"name\":\"sidebar.dataset.list\""));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"sidebar.dataset.list\""));
+    }
+
+    #[test]
+    fn search_documents_query_maps_to_search_documents() {
+        let query = QueryEnvelope {
+            name: "search.documents".into(),
+            payload: SearchDocuments {
+                query: "rust".into(),
+                workspace_id: "ws_1".into(),
+                page_id: Some("page_1".into()),
+                pagination: core_protocol::query::Pagination {
+                    limit: 20,
+                    cursor: None,
+                },
+                title_only: false,
+                exact: false,
+                include_ocr: true,
+                time_range: "any".into(),
+                time_field: "updated".into(),
+                custom_range_from: None,
+                custom_range_to: None,
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "search:documents");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"search.documents\""));
+    }
+
+    #[test]
+    fn search_recent_query_maps_to_search_recent() {
+        let query = QueryEnvelope {
+            name: "search.recent".into(),
+            payload: SearchRecent {
+                workspace_id: "ws_1".into(),
+                pagination: core_protocol::query::Pagination {
+                    limit: 10,
+                    cursor: None,
+                },
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "search:recent");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"search.recent\""));
+    }
+
+    #[test]
+    fn bridge_request_query_maps_to_bridge_logs_request() {
+        let query = QueryEnvelope {
+            name: "bridge.request.get".into(),
+            payload: GetBridgeRequest {
+                workspace_id: "ws_1".into(),
+                request_id: "req_1".into(),
+                command_id: Some("cmd_1".into()),
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "bridgeLogs:listByRequest");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"bridge.request.get\""));
+    }
+
+    #[test]
+    fn bridge_trace_query_maps_to_bridge_logs_trace() {
+        let query = QueryEnvelope {
+            name: "bridge.trace.get".into(),
+            payload: GetBridgeTrace {
+                workspace_id: "ws_1".into(),
+                trace_id: "trace_1".into(),
+                command_id: None,
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "bridgeLogs:listByTrace");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"bridge.trace.get\""));
+    }
+
+    #[test]
+    fn bridge_command_query_maps_to_bridge_logs_command() {
+        let query = QueryEnvelope {
+            name: "bridge.command.get".into(),
+            payload: GetBridgeCommand {
+                workspace_id: "ws_1".into(),
+                command_id: "cmd_1".into(),
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "bridgeLogs:listByCommand");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"bridge.command.get\""));
+    }
+
+    #[test]
+    fn bridge_workspace_overview_query_maps_to_bridge_logs_workspace_overview() {
+        let query = QueryEnvelope {
+            name: "bridge.workspace.overview".into(),
+            payload: ListBridgeWorkspaceOverview {
+                workspace_id: "ws_1".into(),
+                pagination: core_protocol::query::Pagination {
+                    limit: 20,
+                    cursor: Some("cursor_1".into()),
+                },
+                command_status: Some("failed".into()),
+                event_status: Some("failed".into()),
+                target_page_id: Some("page_1".into()),
+                target_block_id: None,
+                aggregate_type: Some("page".into()),
+                aggregate_id: Some("page_1".into()),
+            },
+        };
+
+        let request =
+            build_query_request(&demo_context(), &query).expect("query request should build");
+        assert_eq!(request.function_name, "bridgeLogs:listWorkspaceOverview");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request
+            .payload_json
+            .contains("\"name\":\"bridge.workspace.overview\""));
+    }
+
+    #[test]
+    fn mindmap_put_command_maps_to_mindmaps_put() {
+        let command = CommandEnvelope {
+            name: "mindmaps.put".into(),
+            command_id: "cmd_mindmap_put_1".into(),
+            idempotency_key: Some("idem_mindmap_put".into()),
+            actor: ActorPayload {
+                actor_type: "human".into(),
+                actor_id: "user_1".into(),
+                session_id: Some("session_1".into()),
+            },
+            source: SourcePayload {
+                channel: "cli".into(),
+                client: "mnote-cli".into(),
+            },
+            target: Some(TargetRef {
+                workspace_id: Some("ws_1".into()),
+                page_id: Some("page_1".into()),
+                block_id: Some("mind_1".into()),
+            }),
+            payload: PutMindmap {
+                document_id: "page_1".into(),
+                mindmap_id: "mind_1".into(),
+                data_json: r#"{"data":{"text":"中心主题"},"children":[]}"#.into(),
+                create_only: false,
+            },
+            reason: Some("保存导图".into()),
+            refs: vec!["task-032".into()],
+            dry_run: false,
+            validate_only: false,
+        };
+
+        let request =
+            build_write_request(&demo_context(), &command).expect("write request should build");
+        assert_eq!(request.function_name, "mindmaps:put");
+        assert_eq!(request.workspace_id.as_deref(), Some("ws_1"));
+        assert!(request.payload_json.contains("\"name\":\"mindmaps.put\""));
     }
 }

rust/crates/storage-convex-bridge/src/mapping.rs

@@ -29,15 +29,24 @@ pub fn map_command_name_to_convex(command_name: &str) -> &'static str {
     match command_name {
         "create_workspace" => "workspaces:create",
         "create_page" => "pages:create",
+        "documents.create" => "documents:createWithParentReference",
+        "documents.move" => "documents:move",
+        "documents.delete" => "documents:softDelete",
+        "documents.restore" => "documents:restore",
+        "documents.duplicate" => "documents:duplicateWithMindmaps",
+        "documents.copy_tree" => "documents:copyTree",
         "blocks.patch" => "documents:updateContent",
         "documents.save" => "documents:updateContent",
         "documents.title.update" => "documents:updateTitle",
         "documents.stats.update" => "documents:updateStats",
         "documents.options.update" => "documents:updateOptions",
+        "mindmaps.put" => "mindmaps:put",
         "insert_block" => "blocks:insert",
         "update_block" => "blocks:update",
         "move_block" => "blocks:move",
         "delete_block" => "blocks:delete",
+        "blocks.move" => "blocks:move",
+        "blocks.embed" => "blocks:insert",
         "media.assets.replace_storage" => "mediaAssets:replaceStorageFromUpload",
         _ => "commands:unknown",
     }
@@ -45,9 +54,17 @@ pub fn map_command_name_to_convex(command_name: &str) -> &'static str {
 
 pub fn map_query_name_to_convex(query_name: &str) -> &'static str {
     match query_name {
+        "bridge.request.get" => "bridgeLogs:listByRequest",
+        "bridge.trace.get" => "bridgeLogs:listByTrace",
+        "bridge.command.get" => "bridgeLogs:listByCommand",
+        "bridge.workspace.overview" => "bridgeLogs:listWorkspaceOverview",
         "documents.meta.get" => "documents:getMeta",
         "documents.content.get" => "documents:getContent",
+        "mindmaps.get" => "mindmaps:get",
+        "blocks.get" => "blocks:getById",
         "sidebar.dataset.list" => "sidebar:datasetList",
+        "search.documents" => "search:documents",
+        "search.recent" => "search:recent",
         "get_page" => "pages:get",
         "list_page_blocks" => "blocks:list_by_page",
         "search_pages" => "search:pages",

rust/crates/storage-convex-bridge/src/types.rs

@@ -21,6 +21,13 @@ impl BridgeError {
             message: message.into(),
         }
     }
+
+    pub fn transport(message: impl Into<String>) -> Self {
+        Self {
+            kind: BridgeErrorKind::Transport,
+            message: message.into(),
+        }
+    }
 }
 
 pub type BridgeResult<T> = Result<T, BridgeError>;

rust/crates/storage-convex-bridge/src/validation.rs

@@ -21,15 +21,6 @@ pub fn validate_command_envelope<T>(
     if context.actor_id.trim().is_empty() {
         return Err(BridgeError::validation("actor_id 不能为空"));
     }
-    if context
-        .workspace_id
-        .as_deref()
-        .unwrap_or("")
-        .trim()
-        .is_empty()
-    {
-        return Err(BridgeError::validation("workspace_id 不能为空"));
-    }
     Ok(())
 }