Sasedev/khadhroony-bobobot
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

0.7.27 +Refactor

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-05-10 00:33:01 +02:00
parent cb2e8e7096
commit 1f0137b9de
261 changed files with 12308 additions and 8928 deletions
Download Patch File Download Diff File Expand all files Collapse all files

94
kb_lib/src/db/queries/pool.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/pool.rs
//! Queries for `kb_pools`.
//! Queries for `k_sol_pools`.
/// Inserts or updates one normalized pool row by address.
pub async fn upsert_pool(
database: &crate::KbDatabase,
dto: &crate::KbPoolDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pools_upsert(
database: &crate::Database,
dto: &crate::PoolDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pools (
INSERT INTO k_sol_pools (
dex_id,
address,
pool_kind,
@@ -36,15 +36,15 @@ ON CONFLICT(address) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pools on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pools on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pools
FROM k_sol_pools
WHERE address = ?
LIMIT 1
"#,
@@ -55,8 +55,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pools id for address '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pools id for address '{}' on sqlite: {}",
dto.address, error
)));
},
@@ -66,13 +66,13 @@ LIMIT 1
}
/// Reads one normalized pool row by address.
pub async fn get_pool_by_address(
database: &crate::KbDatabase,
pub async fn query_pools_get_by_address(
database: &crate::Database,
address: &str,
) -> Result<std::option::Option<crate::KbPoolDto>, crate::KbError> {
) -> Result<std::option::Option<crate::PoolDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPoolEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PoolEntity>(
r#"
SELECT
id,
@@ -82,7 +82,7 @@ SELECT
status,
first_seen_at,
updated_at
FROM kb_pools
FROM k_sol_pools
WHERE address = ?
LIMIT 1
"#,
@@ -93,15 +93,15 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_pools '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_pools '{}' on sqlite: {}",
address, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbPoolDto::try_from(entity);
let dto_result = crate::PoolDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -114,12 +114,12 @@ LIMIT 1
}
/// Lists normalized pools ordered by id ascending.
pub async fn list_pools(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbPoolDto>, crate::KbError> {
pub async fn query_pools_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::PoolDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPoolEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PoolEntity>(
r#"
SELECT
id,
@@ -129,7 +129,7 @@ SELECT
status,
first_seen_at,
updated_at
FROM kb_pools
FROM k_sol_pools
ORDER BY id ASC
"#,
)
@@ -138,15 +138,15 @@ ORDER BY id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pools on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pools on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPoolDto::try_from(entity);
let dto_result = crate::PoolDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -164,10 +164,10 @@ mod tests {
async fn pool_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("pool_roundtrip.sqlite3");
let config = crate::KbDatabaseConfig {
let config = crate::DatabaseConfig {
enabled: true,
backend: crate::KbDatabaseBackend::Sqlite,
sqlite: crate::KbSqliteDatabaseConfig {
backend: crate::DatabaseBackend::Sqlite,
sqlite: crate::SqliteDatabaseConfig {
path: database_path.to_string_lossy().to_string(),
create_if_missing: true,
busy_timeout_ms: 5000,
@@ -176,34 +176,36 @@ mod tests {
use_wal: true,
},
};
let database = crate::KbDatabase::connect_and_initialize(&config)
let database = crate::Database::connect_and_initialize(&config)
.await
.expect("database init must succeed");
let dex_id = crate::upsert_dex(
let dex_id = crate::query_dexs_upsert(
&database,
&crate::KbDexDto::new("raydium".to_string(), "Raydium".to_string(), None, None, true),
&crate::DexDto::new("raydium".to_string(), "Raydium".to_string(), None, None, true),
)
.await
.expect("dex upsert must succeed");
let pool_id = crate::upsert_pool(
let pool_id = crate::query_pools_upsert(
&database,
&crate::KbPoolDto::new(
&crate::PoolDto::new(
dex_id,
"Pool111111111111111111111111111111111111111".to_string(),
crate::KbPoolKind::Amm,
crate::KbPoolStatus::Active,
crate::PoolKind::Amm,
crate::PoolStatus::Active,
),
)
.await
.expect("pool upsert must succeed");
assert!(pool_id > 0);
let pool =
crate::get_pool_by_address(&database, "Pool111111111111111111111111111111111111111")
.await
.expect("get pool must succeed");
let pool = crate::query_pools_get_by_address(
&database,
"Pool111111111111111111111111111111111111111",
)
.await
.expect("get pool must succeed");
assert!(pool.is_some());
assert_eq!(pool.expect("pool must exist").pool_kind, crate::KbPoolKind::Amm);
let pools = crate::list_pools(&database).await.expect("list pools must succeed");
assert_eq!(pool.expect("pool must exist").pool_kind, crate::PoolKind::Amm);
let pools = crate::query_pools_list(&database).await.expect("list pools must succeed");
assert_eq!(pools.len(), 1);
}
}