0.5.6

kb_lib/src/db/queries/dex.rs

@@ -66,6 +66,55 @@ LIMIT 1
     }
 }
 
+/// Reads one normalized DEX row by code.
+pub async fn get_dex_by_code(
+    database: &crate::KbDatabase,
+    code: &str,
+) -> Result<std::option::Option<crate::KbDexDto>, crate::KbError> {
+    match database.connection() {
+        crate::KbDatabaseConnection::Sqlite(pool) => {
+            let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDexEntity>(
+                r#"
+SELECT
+    id,
+    code,
+    name,
+    program_id,
+    router_program_id,
+    is_enabled,
+    created_at,
+    updated_at
+FROM kb_dexes
+WHERE code = ?
+LIMIT 1
+                "#,
+            )
+            .bind(code)
+            .fetch_optional(pool)
+            .await;
+            let entity_option = match query_result {
+                Ok(entity_option) => entity_option,
+                Err(error) => {
+                    return Err(crate::KbError::Db(format!(
+                        "cannot read kb_dexes '{}' on sqlite: {}",
+                        code, error
+                    )));
+                }
+            };
+            match entity_option {
+                Some(entity) => {
+                    let dto_result = crate::KbDexDto::try_from(entity);
+                    match dto_result {
+                        Ok(dto) => Ok(Some(dto)),
+                        Err(error) => Err(error),
+                    }
+                }
+                None => Ok(None),
+            }
+        }
+    }
+}
+
 /// Lists normalized DEX rows.
 pub async fn list_dexes(
     database: &crate::KbDatabase,
@@ -111,3 +160,49 @@ ORDER BY code ASC
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[tokio::test]
+    async fn dex_roundtrip_works() {
+        let tempdir = tempfile::tempdir().expect("tempdir must succeed");
+        let database_path = tempdir.path().join("dex_roundtrip.sqlite3");
+        let config = crate::KbDatabaseConfig {
+            enabled: true,
+            backend: crate::KbDatabaseBackend::Sqlite,
+            sqlite: crate::KbSqliteDatabaseConfig {
+                path: database_path.to_string_lossy().to_string(),
+                create_if_missing: true,
+                busy_timeout_ms: 5000,
+                max_connections: 1,
+                auto_initialize_schema: true,
+                use_wal: true,
+            },
+        };
+        let database = crate::KbDatabase::connect_and_initialize(&config)
+            .await
+            .expect("database init must succeed");
+        let dex_id = crate::upsert_dex(
+            &database,
+            &crate::KbDexDto::new(
+                "raydium".to_string(),
+                "Raydium".to_string(),
+                None,
+                None,
+                true,
+            ),
+        )
+        .await
+        .expect("dex upsert must succeed");
+        assert!(dex_id > 0);
+        let dex = crate::get_dex_by_code(&database, "raydium")
+            .await
+            .expect("get dex must succeed");
+        assert!(dex.is_some());
+        assert_eq!(dex.expect("dex must exist").name, "Raydium");
+        let dexes = crate::list_dexes(&database)
+            .await
+            .expect("list dexes must succeed");
+        assert_eq!(dexes.len(), 1);
+    }
+}