Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.
Dart blogconfluence-alternativecontent-managementcontent-servicesdocumentationflutternote-takingnotion-alternativeproject-managementtask-managementteam-collaborationwiki
chore: add tests
Nathan13065ac726e8
diff --git a/frontend/rust-lib/Cargo.lock b/frontend/rust-lib/Cargo.lockindex 29547be823..cd06dc4870 100644--- a/frontend/rust-lib/Cargo.lock+++ b/frontend/rust-lib/Cargo.lock@@ -2313,7 +2313,6 @@ dependencies = [name = "event-integration-test"version = "0.1.0"dependencies = [- "anyhow","assert-json-diff","bytes","chrono",@@ -2322,15 +2321,11 @@ dependencies = ["collab-document","collab-entity","collab-folder",- "collab-plugins",- "dotenv","flowy-ai","flowy-ai-pub","flowy-core",- "flowy-database-pub","flowy-database2","flowy-document",- "flowy-document-pub","flowy-folder","flowy-folder-pub","flowy-notification",@@ -2342,7 +2337,6 @@ dependencies = ["flowy-user","flowy-user-pub","futures",- "futures-util","lib-dispatch","lib-infra","nanoid",@@ -2352,10 +2346,7 @@ dependencies = ["serde","serde_json","strum",- "tempdir",- "thread-id","tokio",- "tokio-postgres","tracing","uuid","walkdir",@@ -2415,12 +2406,6 @@ dependencies = ["rand 0.8.5",]-[[package]]-name = "fallible-iterator"-version = "0.2.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"-[[package]]name = "fancy-regex"version = "0.10.0"@@ -2491,12 +2476,6 @@ dependencies = ["windows-sys 0.52.0",]-[[package]]-name = "finl_unicode"-version = "1.2.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "8fcfdc7a0362c9f4444381a9e697c79d435fe65b52a37466fc2c1184cee9edc6"-[[package]]name = "fixedbitset"version = "0.4.2"@@ -2959,6 +2938,7 @@ dependencies = ["arc-swap","assert-json-diff","bytes",+ "chrono","client-api","collab","collab-database",@@ -3199,12 +3179,6 @@ dependencies = ["libc",]-[[package]]-name = "fuchsia-cprng"-version = "0.1.1"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"-[[package]]name = "funty"version = "2.0.0"@@ -4621,15 +4595,6 @@ dependencies = ["uuid",]-[[package]]-name = "md-5"-version = "0.10.5"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "6365506850d44bff6e2fbcb5176cf63650e48bd45ef2fe2665ae1570e0f4b9ca"-dependencies = [- "digest",-]-[[package]]name = "md5"version = "0.7.0"@@ -5347,35 +5312,6 @@ dependencies = ["universal-hash",]-[[package]]-name = "postgres-protocol"-version = "0.6.6"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "49b6c5ef183cd3ab4ba005f1ca64c21e8bd97ce4699cfea9e8d9a2c4958ca520"-dependencies = [- "base64 0.21.5",- "byteorder",- "bytes",- "fallible-iterator",- "hmac",- "md-5",- "memchr",- "rand 0.8.5",- "sha2",- "stringprep",-]--[[package]]-name = "postgres-types"-version = "0.2.6"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "8d2234cdee9408b523530a9b6d2d6b373d1db34f6a8e51dc03ded1828d7fb67c"-dependencies = [- "bytes",- "fallible-iterator",- "postgres-protocol",-]-[[package]]name = "powerfmt"version = "0.2.0"@@ -5796,19 +5732,6 @@ version = "0.7.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"-[[package]]-name = "rand"-version = "0.4.6"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"-dependencies = [- "fuchsia-cprng",- "libc",- "rand_core 0.3.1",- "rdrand",- "winapi",-]-[[package]]name = "rand"version = "0.7.3"@@ -5854,21 +5777,6 @@ dependencies = ["rand_core 0.6.4",]-[[package]]-name = "rand_core"-version = "0.3.1"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"-dependencies = [- "rand_core 0.4.2",-]--[[package]]-name = "rand_core"-version = "0.4.2"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"-[[package]]name = "rand_core"version = "0.5.1"@@ -5944,15 +5852,6 @@ dependencies = ["crossbeam-utils",]-[[package]]-name = "rdrand"-version = "0.4.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"-dependencies = [- "rand_core 0.3.1",-]-[[package]]name = "redox_syscall"version = "0.1.57"@@ -6053,15 +5952,6 @@ version = "0.8.4"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"-[[package]]-name = "remove_dir_all"-version = "0.5.3"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"-dependencies = [- "winapi",-]-[[package]]name = "rend"version = "0.4.0"@@ -6948,17 +6838,6 @@ dependencies = ["quote",]-[[package]]-name = "stringprep"-version = "0.1.4"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "bb41d74e231a107a1b4ee36bd1214b11285b77768d2e3824aedafa988fd36ee6"-dependencies = [- "finl_unicode",- "unicode-bidi",- "unicode-normalization",-]-[[package]]name = "strsim"version = "0.10.0"@@ -7296,16 +7175,6 @@ version = "1.0.1"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"-[[package]]-name = "tempdir"-version = "0.3.7"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"-dependencies = [- "rand 0.4.6",- "remove_dir_all",-]-[[package]]name = "tempfile"version = "3.12.0"@@ -7538,32 +7407,6 @@ dependencies = ["tokio",]-[[package]]-name = "tokio-postgres"-version = "0.7.10"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "d340244b32d920260ae7448cb72b6e238bddc3d4f7603394e7dd46ed8e48f5b8"-dependencies = [- "async-trait",- "byteorder",- "bytes",- "fallible-iterator",- "futures-channel",- "futures-util",- "log",- "parking_lot 0.12.1",- "percent-encoding",- "phf 0.11.2",- "pin-project-lite",- "postgres-protocol",- "postgres-types",- "rand 0.8.5",- "socket2 0.5.5",- "tokio",- "tokio-util",- "whoami",-]-[[package]]name = "tokio-retry"version = "0.3.0"@@ -8448,16 +8291,6 @@ dependencies = ["rustix",]-[[package]]-name = "whoami"-version = "1.4.1"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "22fc3756b8a9133049b26c7f61ab35416c130e8c09b660f5b3958b446f52cc50"-dependencies = [- "wasm-bindgen",- "web-sys",-]-[[package]]name = "winapi"version = "0.3.9"diff --git a/frontend/rust-lib/event-integration-test/Cargo.toml b/frontend/rust-lib/event-integration-test/Cargo.tomlindex 21d94ae28a..6b2d5af7ba 100644--- a/frontend/rust-lib/event-integration-test/Cargo.toml+++ b/frontend/rust-lib/event-integration-test/Cargo.toml@@ -12,16 +12,13 @@ flowy-user-pub = { workspace = true }flowy-folder = { path = "../flowy-folder", features = ["test_helper"] }flowy-folder-pub = { workspace = true }flowy-database2 = { path = "../flowy-database2" }-flowy-database-pub = { workspace = true }flowy-document = { path = "../flowy-document" }-flowy-document-pub = { workspace = true }flowy-ai = { workspace = true }lib-dispatch = { workspace = true }lib-infra = { workspace = true }flowy-server = { path = "../flowy-server" }flowy-server-pub = { workspace = true }flowy-notification = { workspace = true }-anyhow.workspace = trueflowy-storage = { workspace = true }flowy-storage-pub = { workspace = true }flowy-search = { workspace = true }@@ -31,8 +28,6 @@ serde.workspace = trueserde_json.workspace = trueprotobuf.workspace = truetokio = { workspace = true, features = ["full"] }-futures-util = "0.3.26"-thread-id = "3.3.0"bytes.workspace = truenanoid = "0.4.0"tracing.workspace = true@@ -41,17 +36,13 @@ collab = { workspace = true }collab-document = { workspace = true }collab-folder = { workspace = true }collab-database = { workspace = true }-collab-plugins = { workspace = true }collab-entity = { workspace = true }rand = { version = "0.8.5", features = [] }strum = "0.25.0"[dev-dependencies]-dotenv = "0.15.0"-tempdir = "0.3.7"uuid.workspace = trueassert-json-diff = "2.0.2"-tokio-postgres = { version = "0.7.8" }chrono = "0.4.31"zip.workspace = truewalkdir = "2.5.0"diff --git a/frontend/rust-lib/event-integration-test/tests/main.rs b/frontend/rust-lib/event-integration-test/tests/main.rsindex 05f19e9b75..cf4c1591ac 100644--- a/frontend/rust-lib/event-integration-test/tests/main.rs+++ b/frontend/rust-lib/event-integration-test/tests/main.rs@@ -4,6 +4,8 @@ mod folder;// TODO(Mathias): Enable tests for search// mod search;++mod sql_test;mod user;pub mod util;diff --git a/frontend/rust-lib/event-integration-test/tests/sql_test/chat_message_test.rs b/frontend/rust-lib/event-integration-test/tests/sql_test/chat_message_test.rsnew file mode 100644index 0000000000..549548ccf1--- /dev/null+++ b/frontend/rust-lib/event-integration-test/tests/sql_test/chat_message_test.rs@@ -0,0 +1,596 @@+use event_integration_test::user_event::use_localhost_af_cloud;+use event_integration_test::EventIntegrationTest;+use flowy_ai_pub::cloud::MessageCursor;+use flowy_ai_pub::persistence::{+ insert_chat_messages, select_chat_messages, select_message, select_message_content,+ select_message_where_match_reply_message_id, total_message_count, ChatMessageTable,+};+use uuid::Uuid;++#[tokio::test]+async fn chat_message_table_insert_select_test() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();+ let message_id_1 = 1000;+ let message_id_2 = 2000;++ // Create test messages+ let messages = vec![+ ChatMessageTable {+ message_id: message_id_1,+ chat_id: chat_id.clone(),+ content: "Hello, this is a test message".to_string(),+ created_at: 1625097600, // 2021-07-01+ author_type: 1, // User+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: None,+ },+ ChatMessageTable {+ message_id: message_id_2,+ chat_id: chat_id.clone(),+ content: "This is a reply to the test message".to_string(),+ created_at: 1625097700, // 2021-07-01, 100 seconds later+ author_type: 0, // AI+ author_id: "ai".to_string(),+ reply_message_id: Some(message_id_1),+ metadata: Some(r#"{"source": "test"}"#.to_string()),+ },+ ];++ // Test insert_chat_messages+ let result = insert_chat_messages(db_conn, &messages);+ assert!(+ result.is_ok(),+ "Failed to insert chat messages: {:?}",+ result+ );++ // Test select_chat_messages+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let messages_result =+ select_chat_messages(db_conn, &chat_id, 10, MessageCursor::Offset(0)).unwrap();++ assert_eq!(messages_result.messages.len(), 2);+ assert_eq!(messages_result.total_count, 2);+ assert!(!messages_result.has_more);++ // Verify the content of the returned messages+ let first_message = messages_result+ .messages+ .iter()+ .find(|m| m.message_id == message_id_1)+ .unwrap();+ assert_eq!(first_message.content, "Hello, this is a test message");+ assert_eq!(first_message.author_type, 1);++ let second_message = messages_result+ .messages+ .iter()+ .find(|m| m.message_id == message_id_2)+ .unwrap();+ assert_eq!(+ second_message.content,+ "This is a reply to the test message"+ );+ assert_eq!(second_message.reply_message_id, Some(message_id_1));+}++#[tokio::test]+async fn chat_message_table_cursor_test() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();++ // Create multiple test messages with sequential IDs+ let mut messages = Vec::new();+ for i in 1..6 {+ messages.push(ChatMessageTable {+ message_id: i * 1000,+ chat_id: chat_id.clone(),+ content: format!("Message {}", i),+ created_at: 1625097600 + (i * 100), // Increasing timestamps+ author_type: 1, // User+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: None,+ });+ }++ // Insert messages+ insert_chat_messages(db_conn, &messages).unwrap();++ // Test MessageCursor::Offset+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result_offset = select_chat_messages(+ db_conn,+ &chat_id,+ 2, // Limit to 2 messages+ MessageCursor::Offset(0),+ )+ .unwrap();++ assert_eq!(result_offset.messages.len(), 2);+ assert!(result_offset.has_more);++ // Test MessageCursor::AfterMessageId+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result_after = select_chat_messages(+ db_conn,+ &chat_id,+ 3, // Limit to 3 messages+ MessageCursor::AfterMessageId(2000),+ )+ .unwrap();++ assert_eq!(result_after.messages.len(), 3); // Should get message IDs 3000, 4000, 5000+ assert!(result_after.messages.iter().all(|m| m.message_id > 2000));++ // Test MessageCursor::BeforeMessageId+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result_before = select_chat_messages(+ db_conn,+ &chat_id,+ 2, // Limit to 2 messages+ MessageCursor::BeforeMessageId(4000),+ )+ .unwrap();++ assert_eq!(result_before.messages.len(), 2); // Should get message IDs 1000, 2000, 3000+ assert!(result_before.messages.iter().all(|m| m.message_id < 4000));+}++#[tokio::test]+async fn chat_message_total_count_test() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();++ // Create test messages+ let messages = vec![+ ChatMessageTable {+ message_id: 1001,+ chat_id: chat_id.clone(),+ content: "Message 1".to_string(),+ created_at: 1625097600,+ author_type: 1,+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: None,+ },+ ChatMessageTable {+ message_id: 1002,+ chat_id: chat_id.clone(),+ content: "Message 2".to_string(),+ created_at: 1625097700,+ author_type: 0,+ author_id: "ai".to_string(),+ reply_message_id: None,+ metadata: None,+ },+ ];++ // Insert messages+ insert_chat_messages(db_conn, &messages).unwrap();++ // Test total_message_count+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let count = total_message_count(db_conn, &chat_id).unwrap();+ assert_eq!(count, 2);++ // Add one more message+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let additional_message = ChatMessageTable {+ message_id: 1003,+ chat_id: chat_id.clone(),+ content: "Message 3".to_string(),+ created_at: 1625097800,+ author_type: 1,+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: None,+ };++ insert_chat_messages(db_conn, &[additional_message]).unwrap();++ // Verify count increased+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let updated_count = total_message_count(db_conn, &chat_id).unwrap();+ assert_eq!(updated_count, 3);++ // Test count for non-existent chat+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let empty_count = total_message_count(db_conn, "non_existent_chat").unwrap();+ assert_eq!(empty_count, 0);+}++#[tokio::test]+async fn chat_message_select_message_test() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();+ let message_id = 2001;++ // Create test message+ let message = ChatMessageTable {+ message_id,+ chat_id: chat_id.clone(),+ content: "This is a test message for select_message".to_string(),+ created_at: 1625097600,+ author_type: 1,+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: Some(r#"{"test_key": "test_value"}"#.to_string()),+ };++ // Insert message+ insert_chat_messages(db_conn, &[message]).unwrap();++ // Test select_message+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result = select_message(db_conn, message_id).unwrap();+ assert!(result.is_some());++ let retrieved_message = result.unwrap();+ assert_eq!(retrieved_message.message_id, message_id);+ assert_eq!(retrieved_message.chat_id, chat_id);+ assert_eq!(+ retrieved_message.content,+ "This is a test message for select_message"+ );+ assert_eq!(retrieved_message.author_id, "user_1");+ assert_eq!(+ retrieved_message.metadata,+ Some(r#"{"test_key": "test_value"}"#.to_string())+ );++ // Test select_message with non-existent ID+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let non_existent = select_message(db_conn, 9999).unwrap();+ assert!(non_existent.is_none());+}++#[tokio::test]+async fn chat_message_select_content_test() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();+ let message_id = 3001;+ let message_content = "This is the content to retrieve";++ // Create test message+ let message = ChatMessageTable {+ message_id,+ chat_id: chat_id.clone(),+ content: message_content.to_string(),+ created_at: 1625097600,+ author_type: 1,+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: None,+ };++ // Insert message+ insert_chat_messages(db_conn, &[message]).unwrap();++ // Test select_message_content+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let content = select_message_content(db_conn, message_id).unwrap();+ assert!(content.is_some());+ assert_eq!(content.unwrap(), message_content);++ // Test with non-existent message+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let no_content = select_message_content(db_conn, 9999).unwrap();+ assert!(no_content.is_none());+}++#[tokio::test]+async fn chat_message_reply_test() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();+ let question_id = 4001;+ let answer_id = 4002;++ // Create question and answer messages+ let question = ChatMessageTable {+ message_id: question_id,+ chat_id: chat_id.clone(),+ content: "What is the question?".to_string(),+ created_at: 1625097600,+ author_type: 1, // User+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: None,+ };++ let answer = ChatMessageTable {+ message_id: answer_id,+ chat_id: chat_id.clone(),+ content: "This is the answer".to_string(),+ created_at: 1625097700,+ author_type: 0, // AI+ author_id: "ai".to_string(),+ reply_message_id: Some(question_id), // Link to question+ metadata: None,+ };++ // Insert messages+ insert_chat_messages(db_conn, &[question, answer]).unwrap();++ // Test select_message_where_match_reply_message_id+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result = select_message_where_match_reply_message_id(db_conn, &chat_id, question_id).unwrap();++ assert!(result.is_some());+ let reply = result.unwrap();+ assert_eq!(reply.message_id, answer_id);+ assert_eq!(reply.content, "This is the answer");+ assert_eq!(reply.reply_message_id, Some(question_id));++ // Test with non-existent reply relation+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let no_reply = select_message_where_match_reply_message_id(+ db_conn, &chat_id, 9999, // Non-existent question ID+ )+ .unwrap();++ assert!(no_reply.is_none());++ // Test with wrong chat_id+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let wrong_chat =+ select_message_where_match_reply_message_id(db_conn, "wrong_chat_id", question_id).unwrap();++ assert!(wrong_chat.is_none());+}++#[tokio::test]+async fn chat_message_upsert_test() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();+ let message_id = 5001;++ // Create initial message+ let message = ChatMessageTable {+ message_id,+ chat_id: chat_id.clone(),+ content: "Original content".to_string(),+ created_at: 1625097600,+ author_type: 1,+ author_id: "user_1".to_string(),+ reply_message_id: None,+ metadata: None,+ };++ // Insert message+ insert_chat_messages(db_conn, &[message]).unwrap();++ // Check original content+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let original = select_message(db_conn, message_id).unwrap().unwrap();+ assert_eq!(original.content, "Original content");++ // Create updated message with same ID but different content+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let updated_message = ChatMessageTable {+ message_id, // Same ID+ chat_id: chat_id.clone(),+ content: "Updated content".to_string(), // New content+ created_at: 1625097700, // Updated timestamp+ author_type: 1,+ author_id: "user_1".to_string(),+ reply_message_id: Some(1000), // Added reply ID+ metadata: Some(r#"{"updated": true}"#.to_string()),+ };++ // Upsert message+ insert_chat_messages(db_conn, &[updated_message]).unwrap();++ // Verify update+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result = select_message(db_conn, message_id).unwrap().unwrap();+ assert_eq!(result.content, "Updated content");+ assert_eq!(result.created_at, 1625097700);+ assert_eq!(result.reply_message_id, Some(1000));+ assert_eq!(result.metadata, Some(r#"{"updated": true}"#.to_string()));++ // Count should still be 1 (update, not insert)+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let count = total_message_count(db_conn, &chat_id).unwrap();+ assert_eq!(count, 1);+}++#[tokio::test]+async fn chat_message_select_with_large_dataset() {+ use_localhost_af_cloud().await;+ let test = EventIntegrationTest::new().await;+ test.sign_up_as_anon().await;++ let uid = test.user_manager.get_anon_user().await.unwrap().id;+ let db_conn = test.user_manager.db_connection(uid).unwrap();++ let chat_id = Uuid::new_v4().to_string();++ // Create 100 test messages with sequential IDs+ let mut messages = Vec::new();+ for i in 1..=100 {+ messages.push(ChatMessageTable {+ message_id: i * 100,+ chat_id: chat_id.clone(),+ content: format!("Message {}", i),+ created_at: 1625097600 + (i * 10), // Increasing timestamps+ author_type: if i % 2 == 0 { 0 } else { 1 }, // Alternate between AI and User+ author_id: if i % 2 == 0 {+ "ai".to_string()+ } else {+ "user_1".to_string()+ },+ reply_message_id: if i > 1 && i % 2 == 0 {+ Some((i - 1) * 100)+ } else {+ None+ }, // Even messages reply to previous message+ metadata: if i % 5 == 0 {+ Some(format!(r#"{{"index": {}}}"#, i))+ } else {+ None+ },+ });+ }++ // Insert all 100 messages+ insert_chat_messages(db_conn, &messages).unwrap();++ // Verify total count+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let count = total_message_count(db_conn, &chat_id).unwrap();+ assert_eq!(count, 100, "Should have 100 messages in the database");++ // Test 1: MessageCursor::Offset with small page size+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let page_size = 10;+ let result_offset =+ select_chat_messages(db_conn, &chat_id, page_size, MessageCursor::Offset(0)).unwrap();++ assert_eq!(+ result_offset.messages.len(),+ page_size as usize,+ "Should return exactly {page_size} messages"+ );+ assert!(+ result_offset.has_more,+ "Should have more messages available"+ );+ assert_eq!(result_offset.total_count, 100, "Total count should be 100");++ // Test 2: Pagination with offset+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result_page2 = select_chat_messages(+ db_conn,+ &chat_id,+ page_size,+ MessageCursor::Offset(page_size),+ )+ .unwrap();++ assert_eq!(result_page2.messages.len(), page_size as usize);+ assert!(+ result_page2.messages[0].message_id != result_offset.messages[0].message_id,+ "Second page should have different messages than first page"+ );++ // Test 3: MessageCursor::AfterMessageId (forward pagination)+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let middle_message_id = 5000; // Message ID from the middle+ let result_after = select_chat_messages(+ db_conn,+ &chat_id,+ page_size,+ MessageCursor::AfterMessageId(middle_message_id),+ )+ .unwrap();++ assert_eq!(result_after.messages.len(), page_size as usize);+ assert!(+ result_after+ .messages+ .iter()+ .all(|m| m.message_id > middle_message_id),+ "All messages should have ID greater than the cursor"+ );++ // Test 4: MessageCursor::BeforeMessageId (backward pagination)+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result_before = select_chat_messages(+ db_conn,+ &chat_id,+ page_size,+ MessageCursor::BeforeMessageId(middle_message_id),+ )+ .unwrap();++ assert_eq!(result_before.messages.len(), page_size as usize);+ assert!(+ result_before+ .messages+ .iter()+ .all(|m| m.message_id < middle_message_id),+ "All messages should have ID less than the cursor"+ );++ // Test 5: Large page size (retrieve all)+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result_all = select_chat_messages(+ db_conn,+ &chat_id,+ 200, // More than we have+ MessageCursor::Offset(0),+ )+ .unwrap();++ assert_eq!(+ result_all.messages.len(),+ 100,+ "Should return all 100 messages"+ );+ assert!(!result_all.has_more, "Should not have more messages");++ // Test 6: Empty result when using out of range cursor+ let db_conn = test.user_manager.db_connection(uid).unwrap();+ let result_out_of_range = select_chat_messages(+ db_conn,+ &chat_id,+ page_size,+ MessageCursor::AfterMessageId(10000), // After the last message+ )+ .unwrap();++ assert_eq!(+ result_out_of_range.messages.len(),+ 0,+ "Should return no messages"+ );+ assert!(+ !result_out_of_range.has_more,+ "Should not have more messages"+ );+}diff --git a/frontend/rust-lib/event-integration-test/tests/sql_test/mod.rs b/frontend/rust-lib/event-integration-test/tests/sql_test/mod.rsnew file mode 100644index 0000000000..773bdab81f--- /dev/null+++ b/frontend/rust-lib/event-integration-test/tests/sql_test/mod.rs@@ -0,0 +1 @@+mod chat_message_test;diff --git a/frontend/rust-lib/flowy-ai-pub/src/persistence/chat_message_sql.rs b/frontend/rust-lib/flowy-ai-pub/src/persistence/chat_message_sql.rsindex ac3192064b..f5f985575a 100644--- a/frontend/rust-lib/flowy-ai-pub/src/persistence/chat_message_sql.rs+++ b/frontend/rust-lib/flowy-ai-pub/src/persistence/chat_message_sql.rs@@ -35,6 +35,7 @@ pub fn insert_chat_messages(.do_update().set((chat_message_table::content.eq(excluded(chat_message_table::content)),+ chat_message_table::metadata.eq(excluded(chat_message_table::metadata)),chat_message_table::created_at.eq(excluded(chat_message_table::created_at)),chat_message_table::author_type.eq(excluded(chat_message_table::author_type)),chat_message_table::author_id.eq(excluded(chat_message_table::author_id)),@@ -48,12 +49,18 @@ pub fn insert_chat_messages(Ok(())}+pub struct ChatMessagesResult {+ pub messages: Vec<ChatMessageTable>,+ pub total_count: i64,+ pub has_more: bool,+}+pub fn select_chat_messages(mut conn: DBConnection,chat_id_val: &str,- limit_val: i64,+ limit_val: u64,offset: MessageCursor,-) -> QueryResult<Vec<ChatMessageTable>> {+) -> QueryResult<ChatMessagesResult> {let mut query = dsl::chat_message_table.filter(chat_message_table::chat_id.eq(chat_id_val)).into_boxed();@@ -71,15 +78,46 @@ pub fn select_chat_messages(MessageCursor::NextBack => {},}+ // Get total count before applying limit+ let total_count = dsl::chat_message_table+ .filter(chat_message_table::chat_id.eq(chat_id_val))+ .count()+ .first::<i64>(&mut *conn)?;+query = query.order((chat_message_table::created_at.desc(),chat_message_table::message_id.desc(),))- .limit(limit_val);+ .limit(limit_val as i64);let messages: Vec<ChatMessageTable> = query.load::<ChatMessageTable>(&mut *conn)?;- Ok(messages)++ // Check if there are more messages+ let has_more = if let Some(last_message) = messages.last() {+ let remaining_count = dsl::chat_message_table+ .filter(chat_message_table::chat_id.eq(chat_id_val))+ .filter(chat_message_table::message_id.lt(last_message.message_id))+ .count()+ .first::<i64>(&mut *conn)?;++ remaining_count > 0+ } else {+ false+ };++ Ok(ChatMessagesResult {+ messages,+ total_count,+ has_more,+ })+}++pub fn total_message_count(mut conn: DBConnection, chat_id_val: &str) -> QueryResult<i64> {+ dsl::chat_message_table+ .filter(chat_message_table::chat_id.eq(chat_id_val))+ .count()+ .first::<i64>(&mut *conn)}pub fn select_message(@@ -107,10 +145,12 @@ pub fn select_message_content(pub fn select_message_where_match_reply_message_id(mut conn: DBConnection,+ chat_id: &str,answer_message_id_val: i64,) -> QueryResult<Option<ChatMessageTable>> {dsl::chat_message_table.filter(chat_message_table::reply_message_id.eq(answer_message_id_val))+ .filter(chat_message_table::chat_id.eq(chat_id)).first::<ChatMessageTable>(&mut *conn).optional()}diff --git a/frontend/rust-lib/flowy-ai/src/ai_manager.rs b/frontend/rust-lib/flowy-ai/src/ai_manager.rsindex 1bb05e19b6..a49771a544 100644--- a/frontend/rust-lib/flowy-ai/src/ai_manager.rs+++ b/frontend/rust-lib/flowy-ai/src/ai_manager.rs@@ -270,7 +270,7 @@ impl AIManager {) -> FlowyResult<()> {let chat = self.get_or_create_chat_instance(chat_id).await?;let question_message_id = chat- .get_question_id_from_answer_id(answer_message_id)+ .get_question_id_from_answer_id(chat_id, answer_message_id).await?;let model = model.map_or_else(@@ -567,7 +567,7 @@ impl AIManager {pub async fn load_prev_chat_messages(&self,chat_id: &Uuid,- limit: i64,+ limit: u64,before_message_id: Option<i64>,) -> Result<ChatMessageListPB, FlowyError> {let chat = self.get_or_create_chat_instance(chat_id).await?;@@ -580,7 +580,7 @@ impl AIManager {pub async fn load_latest_chat_messages(&self,chat_id: &Uuid,- limit: i64,+ limit: u64,after_message_id: Option<i64>,) -> Result<ChatMessageListPB, FlowyError> {let chat = self.get_or_create_chat_instance(chat_id).await?;diff --git a/frontend/rust-lib/flowy-ai/src/chat.rs b/frontend/rust-lib/flowy-ai/src/chat.rsindex 0610799f03..976acee3e4 100644--- a/frontend/rust-lib/flowy-ai/src/chat.rs+++ b/frontend/rust-lib/flowy-ai/src/chat.rs@@ -63,18 +63,6 @@ impl Chat {pub fn close(&self) {}- #[allow(dead_code)]- pub async fn pull_latest_message(&self, limit: i64) {- let latest_message_id = self- .latest_message_id- .load(std::sync::atomic::Ordering::Relaxed);- if latest_message_id > 0 {- let _ = self- .load_remote_chat_messages(limit, None, Some(latest_message_id))- .await;- }- }-pub async fn stop_stream_message(&self) {self.stop_stream@@ -340,7 +328,7 @@ impl Chat {/// - `before_message_id` is the first message ID in the current chat messages.pub async fn load_prev_chat_messages(&self,- limit: i64,+ limit: u64,before_message_id: Option<i64>,) -> Result<ChatMessageListPB, FlowyError> {trace!(@@ -388,7 +376,7 @@ impl Chat {pub async fn load_latest_chat_messages(&self,- limit: i64,+ limit: u64,after_message_id: Option<i64>,) -> Result<ChatMessageListPB, FlowyError> {trace!(@@ -420,7 +408,7 @@ impl Chat {async fn load_remote_chat_messages(&self,- limit: i64,+ limit: u64,before_message_id: Option<i64>,after_message_id: Option<i64>,) -> FlowyResult<()> {@@ -445,7 +433,7 @@ impl Chat {_ => MessageCursor::NextBack,};match cloud_service- .get_chat_messages(&workspace_id, &chat_id, cursor.clone(), limit as u64)+ .get_chat_messages(&workspace_id, &chat_id, cursor.clone(), limit).await{Ok(resp) => {@@ -498,12 +486,14 @@ impl Chat {pub async fn get_question_id_from_answer_id(&self,+ chat_id: &Uuid,answer_message_id: i64,) -> Result<i64, FlowyError> {let conn = self.user_service.sqlite_connection(self.uid)?;- let local_result = select_message_where_match_reply_message_id(conn, answer_message_id)?- .map(|message| message.message_id);+ let local_result =+ select_message_where_match_reply_message_id(conn, &chat_id.to_string(), answer_message_id)?+ .map(|message| message.message_id);if let Some(message_id) = local_result {return Ok(message_id);@@ -560,12 +550,12 @@ impl Chat {async fn load_local_chat_messages(&self,- limit: i64,+ limit: u64,offset: MessageCursor,) -> Result<Vec<ChatMessagePB>, FlowyError> {let conn = self.user_service.sqlite_connection(self.uid)?;- let records = select_chat_messages(conn, &self.chat_id.to_string(), limit, offset)?;- let messages = records+ let rows = select_chat_messages(conn, &self.chat_id.to_string(), limit, offset)?.messages;+ let messages = rows.into_iter().map(|record| ChatMessagePB {message_id: record.message_id,diff --git a/frontend/rust-lib/flowy-ai/src/event_handler.rs b/frontend/rust-lib/flowy-ai/src/event_handler.rsindex b8334ffe8d..6788685102 100644--- a/frontend/rust-lib/flowy-ai/src/event_handler.rs+++ b/frontend/rust-lib/flowy-ai/src/event_handler.rs@@ -152,7 +152,7 @@ pub(crate) async fn load_prev_message_handler(let chat_id = Uuid::from_str(&data.chat_id)?;let messages = ai_manager- .load_prev_chat_messages(&chat_id, data.limit, data.before_message_id)+ .load_prev_chat_messages(&chat_id, data.limit as u64, data.before_message_id).await?;data_result_ok(messages)}@@ -168,7 +168,7 @@ pub(crate) async fn load_next_message_handler(let chat_id = Uuid::from_str(&data.chat_id)?;let messages = ai_manager- .load_latest_chat_messages(&chat_id, data.limit, data.after_message_id)+ .load_latest_chat_messages(&chat_id, data.limit as u64, data.after_message_id).await?;data_result_ok(messages)}diff --git a/frontend/rust-lib/flowy-ai/src/local_ai/controller.rs b/frontend/rust-lib/flowy-ai/src/local_ai/controller.rsindex 431d8ff681..3c4ccb1f9d 100644--- a/frontend/rust-lib/flowy-ai/src/local_ai/controller.rs+++ b/frontend/rust-lib/flowy-ai/src/local_ai/controller.rs@@ -79,7 +79,6 @@ impl LocalAIController {// Create the core plugin and resource controllerlet local_ai = Arc::new(OllamaAIPlugin::new(plugin_manager));let res_impl = LLMResourceServiceImpl {- user_service: user_service.clone(),store_preferences: store_preferences.clone(),};let local_ai_resource = Arc::new(LocalAIResourceController::new(@@ -594,7 +593,6 @@ async fn initialize_ai_plugin(}pub struct LLMResourceServiceImpl {- user_service: Arc<dyn AIUserService>,store_preferences: Weak<KVStorePreferences>,}diff --git a/frontend/rust-lib/flowy-ai/src/middleware/chat_service_mw.rs b/frontend/rust-lib/flowy-ai/src/middleware/chat_service_mw.rsindex a9a4022573..e3c3d671ec 100644--- a/frontend/rust-lib/flowy-ai/src/middleware/chat_service_mw.rs+++ b/frontend/rust-lib/flowy-ai/src/middleware/chat_service_mw.rs@@ -5,14 +5,14 @@ use crate::notification::{chat_notification_builder, ChatNotification, APPFLOWY_AI_NOTIFICATION_KEY,};use af_plugin::error::PluginError;-use flowy_ai_pub::persistence::{select_message, select_message_content, ChatMessageTable};+use flowy_ai_pub::persistence::select_message_content;use std::collections::HashMap;use flowy_ai_pub::cloud::{AIModel, AppErrorCode, AppResponseError, ChatCloudService, ChatMessage, ChatMessageMetadata,ChatMessageType, ChatSettings, CompleteTextParams, CompletionStream, MessageCursor, ModelList,RelatedQuestion, RepeatedChatMessage, RepeatedRelatedQuestion, ResponseFormat, StreamAnswer,- StreamComplete, SubscriptionPlan, UpdateChatParams,+ StreamComplete, UpdateChatParams,};use flowy_error::{FlowyError, FlowyResult};use futures::{stream, Sink, StreamExt, TryStreamExt};diff --git a/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rs b/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rsindex c916157ff0..e4bffbfb69 100644--- a/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rs+++ b/frontend/rust-lib/flowy-core/src/deps_resolve/cloud_service_impl.rs@@ -16,7 +16,7 @@ use flowy_ai_pub::cloud::search_dto::{use flowy_ai_pub::cloud::{AIModel, ChatCloudService, ChatMessage, ChatMessageMetadata, ChatMessageType, ChatSettings,CompleteTextParams, MessageCursor, ModelList, RepeatedChatMessage, ResponseFormat, StreamAnswer,- StreamComplete, SubscriptionPlan, UpdateChatParams,+ StreamComplete, UpdateChatParams,};use flowy_database_pub::cloud::{DatabaseAIService, DatabaseCloudService, DatabaseSnapshot, EncodeCollabByOid, SummaryRowContent,diff --git a/frontend/rust-lib/flowy-server/Cargo.toml b/frontend/rust-lib/flowy-server/Cargo.tomlindex 5225eb817d..c8710470b0 100644--- a/frontend/rust-lib/flowy-server/Cargo.toml+++ b/frontend/rust-lib/flowy-server/Cargo.toml@@ -45,6 +45,7 @@ rand = "0.8.5"semver = "1.0.23"flowy-sqlite = { workspace = true }flowy-ai = { workspace = true }+chrono.workspace = true[dependencies.client-api]workspace = truediff --git a/frontend/rust-lib/flowy-server/src/af_cloud/impls/chat.rs b/frontend/rust-lib/flowy-server/src/af_cloud/impls/chat.rsindex 4b0611e497..3f8803c7fc 100644--- a/frontend/rust-lib/flowy-server/src/af_cloud/impls/chat.rs+++ b/frontend/rust-lib/flowy-server/src/af_cloud/impls/chat.rs@@ -9,7 +9,7 @@ use client_api::entity::chat_dto::{};use flowy_ai_pub::cloud::{AIModel, ChatCloudService, ChatMessage, ChatMessageMetadata, ChatMessageType, ChatSettings,- ModelList, StreamAnswer, StreamComplete, SubscriptionPlan, UpdateChatParams,+ ModelList, StreamAnswer, StreamComplete, UpdateChatParams,};use flowy_error::FlowyError;use futures_util::{StreamExt, TryStreamExt};diff --git a/frontend/rust-lib/flowy-server/src/local_server/impls/chat.rs b/frontend/rust-lib/flowy-server/src/local_server/impls/chat.rsindex 23562d2b07..09ef644bfc 100644--- a/frontend/rust-lib/flowy-server/src/local_server/impls/chat.rs+++ b/frontend/rust-lib/flowy-server/src/local_server/impls/chat.rs@@ -1,25 +1,29 @@use crate::af_cloud::define::ServerUser;+use chrono::{TimeZone, Utc};use client_api::entity::ai_dto::RepeatedRelatedQuestion;+use client_api::entity::CompletionStream;use flowy_ai::local_ai::controller::LocalAIController;use flowy_ai::local_ai::stream_util::QuestionStream;+use flowy_ai_pub::cloud::chat_dto::{ChatAuthor, ChatAuthorType};use flowy_ai_pub::cloud::{- AIModel, ChatCloudService, ChatMessage, ChatMessageMetadata, ChatMessageType, ChatSettings,- CompleteTextParams, MessageCursor, ModelList, RepeatedChatMessage, ResponseFormat, StreamAnswer,- StreamComplete, SubscriptionPlan, UpdateChatParams,+ AIModel, AppErrorCode, AppResponseError, ChatCloudService, ChatMessage, ChatMessageMetadata,+ ChatMessageType, ChatSettings, CompleteTextParams, MessageCursor, ModelList, RelatedQuestion,+ RepeatedChatMessage, ResponseFormat, StreamAnswer, StreamComplete, UpdateChatParams,};use flowy_ai_pub::persistence::{- deserialize_chat_metadata, deserialize_rag_ids, read_chat, select_message_content,- serialize_chat_metadata, serialize_rag_ids, update_chat, upsert_chat, ChatTable,- ChatTableChangeset,+ deserialize_chat_metadata, deserialize_rag_ids, read_chat, select_chat_messages,+ select_message_content, select_message_where_match_reply_message_id, serialize_chat_metadata,+ serialize_rag_ids, update_chat, upsert_chat, ChatMessageTable, ChatTable, ChatTableChangeset,};use flowy_error::{FlowyError, FlowyResult};-use futures_util::{stream, FutureExt, StreamExt};+use futures_util::{stream, StreamExt, TryStreamExt};use lib_infra::async_trait::async_trait;use lib_infra::util::timestamp;use serde_json::{json, Value};use std::collections::HashMap;use std::path::Path;use std::sync::Arc;+use tracing::trace;use uuid::Uuid;pub struct LocalServerChatServiceImpl {@@ -148,51 +152,119 @@ impl ChatCloudService for LocalServerChatServiceImpl {offset: MessageCursor,limit: u64,) -> Result<RepeatedChatMessage, FlowyError> {+ let chat_id = chat_id.to_string();let uid = self.user.user_id()?;let db = self.user.get_sqlite_db(uid)?;+ let result = select_chat_messages(db, &chat_id, limit, offset)?;- Err(FlowyError::not_support().with_context("Chat is not supported in local server."))+ let messages = result+ .messages+ .into_iter()+ .map(chat_message_from_row)+ .collect();++ Ok(RepeatedChatMessage {+ messages,+ has_more: result.has_more,+ total: result.total_count,+ })}async fn get_question_from_answer_id(&self,_workspace_id: &Uuid,- _chat_id: &Uuid,- _answer_message_id: i64,+ chat_id: &Uuid,+ answer_message_id: i64,) -> Result<ChatMessage, FlowyError> {- Err(FlowyError::not_support().with_context("Chat is not supported in local server."))+ let chat_id = chat_id.to_string();+ let uid = self.user.user_id()?;+ let db = self.user.get_sqlite_db(uid)?;+ let row = select_message_where_match_reply_message_id(db, &chat_id, answer_message_id)?+ .map(chat_message_from_row)+ .ok_or_else(FlowyError::record_not_found)?;+ Ok(row)}async fn get_related_message(&self,_workspace_id: &Uuid,- _chat_id: &Uuid,+ chat_id: &Uuid,message_id: i64,- ai_model: Option<AIModel>,+ _ai_model: Option<AIModel>,) -> Result<RepeatedRelatedQuestion, FlowyError> {- Ok(RepeatedRelatedQuestion {- message_id,- items: vec![],- })+ if self.local_ai.is_running() {+ let questions = self+ .local_ai+ .get_related_question(&chat_id.to_string())+ .await+ .map_err(|err| FlowyError::local_ai().with_context(err))?;+ trace!("LocalAI related questions: {:?}", questions);++ let items = questions+ .into_iter()+ .map(|content| RelatedQuestion {+ content,+ metadata: None,+ })+ .collect::<Vec<_>>();++ Ok(RepeatedRelatedQuestion { message_id, items })+ } else {+ Ok(RepeatedRelatedQuestion {+ message_id,+ items: vec![],+ })+ }}async fn stream_complete(&self,_workspace_id: &Uuid,- _params: CompleteTextParams,+ params: CompleteTextParams,_ai_model: Option<AIModel>,) -> Result<StreamComplete, FlowyError> {- Err(FlowyError::not_support().with_context("complete text is not supported in local server."))+ if self.local_ai.is_running() {+ match self+ .local_ai+ .complete_text_v2(+ ¶ms.text,+ params.completion_type.unwrap() as u8,+ Some(json!(params.format)),+ Some(json!(params.metadata)),+ )+ .await+ {+ Ok(stream) => Ok(+ CompletionStream::new(+ stream.map_err(|err| AppResponseError::new(AppErrorCode::Internal, err.to_string())),+ )+ .map_err(FlowyError::from)+ .boxed(),+ ),+ Err(_) => Ok(stream::once(async { Err(FlowyError::local_ai_unavailable()) }).boxed()),+ }+ } else {+ Err(FlowyError::local_ai_not_ready())+ }}async fn embed_file(&self,_workspace_id: &Uuid,- _file_path: &Path,- _chat_id: &Uuid,- _metadata: Option<HashMap<String, Value>>,+ file_path: &Path,+ chat_id: &Uuid,+ metadata: Option<HashMap<String, Value>>,) -> Result<(), FlowyError> {- Err(FlowyError::not_support().with_context("indexing file is not supported in local server."))+ if self.local_ai.is_running() {+ self+ .local_ai+ .embed_file(&chat_id.to_string(), file_path.to_path_buf(), metadata)+ .await+ .map_err(|err| FlowyError::local_ai().with_context(err))?;+ Ok(())+ } else {+ Err(FlowyError::local_ai_not_ready())+ }}async fn get_chat_settings(@@ -242,3 +314,36 @@ impl ChatCloudService for LocalServerChatServiceImpl {Err(FlowyError::not_support().with_context("Chat is not supported in local server."))}}++fn chat_message_from_row(row: ChatMessageTable) -> ChatMessage {+ let created_at = Utc+ .timestamp_opt(row.created_at, 0)+ .single()+ .unwrap_or_else(Utc::now);++ let author_id = row.author_id.parse::<i64>().unwrap_or_default();+ let author_type = match row.author_type {+ 1 => ChatAuthorType::Human,+ 2 => ChatAuthorType::System,+ 3 => ChatAuthorType::AI,+ _ => ChatAuthorType::Unknown,+ };++ let metadata = row+ .metadata+ .map(|s| deserialize_chat_metadata::<Value>(&s))+ .unwrap_or_else(|| json!({}));++ ChatMessage {+ author: ChatAuthor {+ author_id,+ author_type,+ meta: None,+ },+ message_id: row.message_id,+ content: row.content,+ created_at,+ metadata,+ reply_message_id: row.reply_message_id,+ }+}diff --git a/frontend/rust-lib/flowy-server/tests/af_cloud_test/util.rs b/frontend/rust-lib/flowy-server/tests/af_cloud_test/util.rsindex b747c0b2ae..3004ce2163 100644--- a/frontend/rust-lib/flowy-server/tests/af_cloud_test/util.rs+++ b/frontend/rust-lib/flowy-server/tests/af_cloud_test/util.rs@@ -48,7 +48,7 @@ impl ServerUser for FakeServerUserImpl {todo!()}- fn get_sqlite_db(&self, uid: i64) -> Result<DBConnection, FlowyError> {+ fn get_sqlite_db(&self, _uid: i64) -> Result<DBConnection, FlowyError> {todo!()}diff --git a/frontend/rust-lib/flowy-sqlite/migrations/2025-04-17-042326_chat_metadata/down.sql b/frontend/rust-lib/flowy-sqlite/migrations/2025-04-17-042326_chat_metadata/down.sqlindex 6edd4a5113..8b07e6189d 100644--- a/frontend/rust-lib/flowy-sqlite/migrations/2025-04-17-042326_chat_metadata/down.sql+++ b/frontend/rust-lib/flowy-sqlite/migrations/2025-04-17-042326_chat_metadata/down.sql@@ -6,4 +6,4 @@ ALTER TABLE chat_tableALTER TABLE chat_tableADD COLUMN local_files TEXT;-ALTER TABLE chat_table DROP COLUMN rag_ids;+ALTER TABLE chat_table DROP COLUMN rag_ids;\ No newline at end of file