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

56
kb_lib/src/db/queries/analysis_signal.rs
View File

@@ -1,27 +1,27 @@
// file: kb_lib/src/db/queries/analysis_signal.rs
//! Queries for `kb_analysis_signals`.
//! Queries for `k_sol_analysis_signals`.
/// Inserts one analysis signal row and returns its numeric id.
pub async fn insert_analysis_signal(
database: &crate::KbDatabase,
dto: &crate::KbAnalysisSignalDto,
) -> Result<i64, crate::KbError> {
pub async fn query_analysis_signals_insert(
database: &crate::Database,
dto: &crate::AnalysisSignalDto,
) -> Result<i64, crate::Error> {
let payload_json_result = serde_json::to_string(&dto.payload);
let payload_json = match payload_json_result {
Ok(payload_json) => payload_json,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot serialize analysis signal payload: {}",
error
)));
},
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_analysis_signals (
INSERT INTO k_sol_analysis_signals (
signal_kind,
severity,
object_key,
@@ -45,8 +45,8 @@ VALUES (?, ?, ?, ?, ?, ?, ?)
let query_result = match query_result {
Ok(query_result) => query_result,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot insert kb_analysis_signals on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot insert k_sol_analysis_signals on sqlite: {}",
error
)));
},
@@ -57,16 +57,16 @@ VALUES (?, ?, ?, ?, ?, ?, ?)
}
/// Lists recent analysis signals ordered from newest to oldest.
pub async fn list_recent_analysis_signals(
database: &crate::KbDatabase,
pub async fn query_analysis_signals_list(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbAnalysisSignalDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::AnalysisSignalDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbAnalysisSignalEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::AnalysisSignalEntity>(
r#"
SELECT
id,
@@ -77,7 +77,7 @@ SELECT
score,
payload_json,
created_at
FROM kb_analysis_signals
FROM k_sol_analysis_signals
ORDER BY id DESC
LIMIT ?
"#,
@@ -88,7 +88,7 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot list analysis signals on sqlite: {}",
error
)));
@@ -96,7 +96,7 @@ LIMIT ?
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbAnalysisSignalDto::try_from(entity);
let dto_result = crate::AnalysisSignalDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -114,10 +114,10 @@ mod tests {
async fn analysis_signal_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("analysis_signal.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,
@@ -126,29 +126,29 @@ 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 dto = crate::KbAnalysisSignalDto::new(
let dto = crate::AnalysisSignalDto::new(
"candidate_token".to_string(),
crate::KbAnalysisSignalSeverity::Medium,
"So11111111111111111111111111111111111111112".to_string(),
crate::AnalysisSignalSeverity::Medium,
crate::WSOL_MINT_ID.to_string(),
None,
Some(0.72),
serde_json::json!({
"reason": "fresh_token_with_activity"
}),
);
let inserted_id = crate::insert_analysis_signal(&database, &dto)
let inserted_id = crate::query_analysis_signals_insert(&database, &dto)
.await
.expect("insert must succeed");
assert!(inserted_id > 0);
let listed = crate::list_recent_analysis_signals(&database, 10)
let listed = crate::query_analysis_signals_list(&database, 10)
.await
.expect("list must succeed");
assert_eq!(listed.len(), 1);
assert_eq!(listed[0].signal_kind, "candidate_token");
assert_eq!(listed[0].severity, crate::KbAnalysisSignalSeverity::Medium);
assert_eq!(listed[0].severity, crate::AnalysisSignalSeverity::Medium);
assert_eq!(listed[0].score, Some(0.72));
}
}

103
kb_lib/src/db/queries/chain_instruction.rs
View File

@@ -1,12 +1,12 @@
// file: kb_lib/src/db/queries/chain_instruction.rs
//! Queries for `kb_chain_instructions`.
//! Queries for `k_sol_chain_instructions`.
/// Inserts one normalized chain instruction row.
pub async fn insert_chain_instruction(
database: &crate::KbDatabase,
dto: &crate::KbChainInstructionDto,
) -> Result<i64, crate::KbError> {
pub async fn query_chain_instructions_insert(
database: &crate::Database,
dto: &crate::ChainInstructionDto,
) -> Result<i64, crate::Error> {
let instruction_index_result = i64::from(dto.instruction_index);
let inner_instruction_index = match dto.inner_instruction_index {
Some(inner_instruction_index) => Some(i64::from(inner_instruction_index)),
@@ -17,10 +17,10 @@ pub async fn insert_chain_instruction(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_chain_instructions (
INSERT INTO k_sol_chain_instructions (
transaction_id,
parent_instruction_id,
instruction_index,
@@ -54,8 +54,8 @@ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
let insert_result = match query_result {
Ok(insert_result) => insert_result,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot insert kb_chain_instructions on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot insert k_sol_chain_instructions on sqlite: {}",
error
)));
},
@@ -66,13 +66,13 @@ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
}
/// Reads one chain instruction by its internal id.
pub async fn get_chain_instruction_by_id(
database: &crate::KbDatabase,
pub async fn query_chain_instructions_get_by_id(
database: &crate::Database,
instruction_id: i64,
) -> Result<std::option::Option<crate::KbChainInstructionDto>, crate::KbError> {
) -> Result<std::option::Option<crate::ChainInstructionDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbChainInstructionEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ChainInstructionEntity>(
r#"
SELECT
id,
@@ -88,7 +88,7 @@ SELECT
parsed_type,
parsed_json,
created_at
FROM kb_chain_instructions
FROM k_sol_chain_instructions
WHERE id = ?
LIMIT 1
"#,
@@ -99,15 +99,15 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_chain_instructions id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_chain_instructions id '{}' on sqlite: {}",
instruction_id, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbChainInstructionDto::try_from(entity);
let dto_result = crate::ChainInstructionDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -120,13 +120,13 @@ LIMIT 1
}
/// Lists instructions for one transaction ordered from outer to inner.
pub async fn list_chain_instructions_by_transaction_id(
database: &crate::KbDatabase,
pub async fn query_chain_instructions_list_by_transaction_id(
database: &crate::Database,
transaction_id: i64,
) -> Result<std::vec::Vec<crate::KbChainInstructionDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::ChainInstructionDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbChainInstructionEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ChainInstructionEntity>(
r#"
SELECT
id,
@@ -142,7 +142,7 @@ SELECT
parsed_type,
parsed_json,
created_at
FROM kb_chain_instructions
FROM k_sol_chain_instructions
WHERE transaction_id = ?
ORDER BY instruction_index ASC, inner_instruction_index ASC, id ASC
"#,
@@ -153,15 +153,15 @@ ORDER BY instruction_index ASC, inner_instruction_index ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_chain_instructions for transaction_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_chain_instructions for transaction_id '{}' on sqlite: {}",
transaction_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbChainInstructionDto::try_from(entity);
let dto_result = crate::ChainInstructionDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -174,15 +174,15 @@ ORDER BY instruction_index ASC, inner_instruction_index ASC, id ASC
}
/// Deletes all instructions for one transaction id.
pub async fn delete_chain_instructions_by_transaction_id(
database: &crate::KbDatabase,
pub async fn query_chain_instructions_delete_by_transaction_id(
database: &crate::Database,
transaction_id: i64,
) -> Result<(), crate::KbError> {
) -> Result<(), crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
DELETE FROM kb_chain_instructions
DELETE FROM k_sol_chain_instructions
WHERE transaction_id = ?
"#,
)
@@ -190,8 +190,8 @@ WHERE transaction_id = ?
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot delete kb_chain_instructions for transaction_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot delete k_sol_chain_instructions for transaction_id '{}' on sqlite: {}",
transaction_id, error
)));
}
@@ -202,13 +202,13 @@ WHERE transaction_id = ?
#[cfg(test)]
mod tests {
async fn make_database() -> crate::KbDatabase {
async fn make_database() -> crate::Database {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("chain_instruction.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,
@@ -217,13 +217,13 @@ mod tests {
use_wal: true,
},
};
return crate::KbDatabase::connect_and_initialize(&config)
return crate::Database::connect_and_initialize(&config)
.await
.expect("database init must succeed");
}
async fn make_transaction(database: &crate::KbDatabase) -> i64 {
let dto = crate::KbChainTransactionDto::new(
async fn make_transaction(database: &crate::Database) -> i64 {
let dto = crate::ChainTransactionDto::new(
"sig-chain-instruction-1".to_string(),
None,
None,
@@ -233,7 +233,7 @@ mod tests {
None,
r#"{"transaction":{"message":{"instructions":[]}}}"#.to_string(),
);
return crate::upsert_chain_transaction(database, &dto)
return crate::query_chain_transactions_upsert(database, &dto)
.await
.expect("chain transaction upsert must succeed");
}
@@ -242,7 +242,7 @@ mod tests {
async fn chain_instruction_insert_list_delete_works() {
let database = make_database().await;
let transaction_id = make_transaction(&database).await;
let outer_dto = crate::KbChainInstructionDto::new(
let outer_dto = crate::ChainInstructionDto::new(
transaction_id,
None,
0,
@@ -255,11 +255,11 @@ mod tests {
Some("transfer".to_string()),
Some(r#"{"type":"transfer","info":{"amount":"10"}}"#.to_string()),
);
let outer_instruction_id = crate::insert_chain_instruction(&database, &outer_dto)
let outer_instruction_id = crate::query_chain_instructions_insert(&database, &outer_dto)
.await
.expect("outer instruction insert must succeed");
assert!(outer_instruction_id > 0);
let inner_dto = crate::KbChainInstructionDto::new(
let inner_dto = crate::ChainInstructionDto::new(
transaction_id,
Some(outer_instruction_id),
0,
@@ -272,13 +272,14 @@ mod tests {
Some("mintTo".to_string()),
Some(r#"{"type":"mintTo","info":{"amount":"5"}}"#.to_string()),
);
let inner_instruction_id = crate::insert_chain_instruction(&database, &inner_dto)
let inner_instruction_id = crate::query_chain_instructions_insert(&database, &inner_dto)
.await
.expect("inner instruction insert must succeed");
assert!(inner_instruction_id > outer_instruction_id);
let listed = crate::list_chain_instructions_by_transaction_id(&database, transaction_id)
.await
.expect("chain instruction list must succeed");
let listed =
crate::query_chain_instructions_list_by_transaction_id(&database, transaction_id)
.await
.expect("chain instruction list must succeed");
assert_eq!(listed.len(), 2);
assert_eq!(listed[0].parent_instruction_id, None);
assert_eq!(listed[0].instruction_index, 0);
@@ -288,11 +289,11 @@ mod tests {
assert_eq!(listed[1].instruction_index, 0);
assert_eq!(listed[1].inner_instruction_index, Some(0));
assert_eq!(listed[1].parsed_type, Some("mintTo".to_string()));
crate::delete_chain_instructions_by_transaction_id(&database, transaction_id)
crate::query_chain_instructions_delete_by_transaction_id(&database, transaction_id)
.await
.expect("chain instruction delete must succeed");
let listed_after_delete =
crate::list_chain_instructions_by_transaction_id(&database, transaction_id)
crate::query_chain_instructions_list_by_transaction_id(&database, transaction_id)
.await
.expect("chain instruction list after delete must succeed");
assert_eq!(listed_after_delete.len(), 0);

78
kb_lib/src/db/queries/chain_slot.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/chain_slot.rs
//! Queries for `kb_chain_slots`.
//! Queries for `k_sol_chain_slots`.
/// Inserts or updates one normalized chain slot row.
pub async fn upsert_chain_slot(
database: &crate::KbDatabase,
dto: &crate::KbChainSlotDto,
) -> Result<u64, crate::KbError> {
pub async fn query_chain_slots_upsert(
database: &crate::Database,
dto: &crate::ChainSlotDto,
) -> Result<u64, crate::Error> {
let slot_result = i64::try_from(dto.slot);
let slot = match slot_result {
Ok(slot) => slot,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert chain slot '{}' to i64: {}",
dto.slot, error
)));
@@ -23,7 +23,7 @@ pub async fn upsert_chain_slot(
match parent_slot_result {
Ok(parent_slot) => Some(parent_slot),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert chain parent_slot '{}' to i64: {}",
parent_slot, error
)));
@@ -33,10 +33,10 @@ pub async fn upsert_chain_slot(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_chain_slots (
INSERT INTO k_sol_chain_slots (
slot,
parent_slot,
block_time_unix,
@@ -58,8 +58,8 @@ ON CONFLICT(slot) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_chain_slots on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_chain_slots on sqlite: {}",
error
)));
}
@@ -69,23 +69,23 @@ ON CONFLICT(slot) DO UPDATE SET
}
/// Reads one chain slot row by slot number.
pub async fn get_chain_slot(
database: &crate::KbDatabase,
pub async fn query_chain_slots_get(
database: &crate::Database,
slot: u64,
) -> Result<std::option::Option<crate::KbChainSlotDto>, crate::KbError> {
) -> Result<std::option::Option<crate::ChainSlotDto>, crate::Error> {
let slot_result = i64::try_from(slot);
let slot_i64 = match slot_result {
Ok(slot_i64) => slot_i64,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert requested chain slot '{}' to i64: {}",
slot, error
)));
},
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbChainSlotEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ChainSlotEntity>(
r#"
SELECT
slot,
@@ -93,7 +93,7 @@ SELECT
block_time_unix,
created_at,
updated_at
FROM kb_chain_slots
FROM k_sol_chain_slots
WHERE slot = ?
LIMIT 1
"#,
@@ -104,15 +104,15 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_chain_slots for slot '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_chain_slots for slot '{}' on sqlite: {}",
slot, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbChainSlotDto::try_from(entity);
let dto_result = crate::ChainSlotDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -125,16 +125,16 @@ LIMIT 1
}
/// Lists recent chain slots ordered from newest to oldest.
pub async fn list_recent_chain_slots(
database: &crate::KbDatabase,
pub async fn query_chain_slots_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbChainSlotDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::ChainSlotDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbChainSlotEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ChainSlotEntity>(
r#"
SELECT
slot,
@@ -142,7 +142,7 @@ SELECT
block_time_unix,
created_at,
updated_at
FROM kb_chain_slots
FROM k_sol_chain_slots
ORDER BY slot DESC
LIMIT ?
"#,
@@ -153,15 +153,15 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_chain_slots on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_chain_slots on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbChainSlotDto::try_from(entity);
let dto_result = crate::ChainSlotDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -175,13 +175,13 @@ LIMIT ?
#[cfg(test)]
mod tests {
async fn make_database() -> crate::KbDatabase {
async fn make_database() -> crate::Database {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("chain_slot.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,
@@ -190,7 +190,7 @@ mod tests {
use_wal: true,
},
};
return crate::KbDatabase::connect_and_initialize(&config)
return crate::Database::connect_and_initialize(&config)
.await
.expect("database init must succeed");
}
@@ -198,19 +198,19 @@ mod tests {
#[tokio::test]
async fn chain_slot_roundtrip_works() {
let database = make_database().await;
let dto = crate::KbChainSlotDto::new(424242, Some(424241), Some(1_777_777_777));
let slot = crate::upsert_chain_slot(&database, &dto)
let dto = crate::ChainSlotDto::new(424242, Some(424241), Some(1_777_777_777));
let slot = crate::query_chain_slots_upsert(&database, &dto)
.await
.expect("chain slot upsert must succeed");
assert_eq!(slot, 424242);
let fetched = crate::get_chain_slot(&database, 424242)
let fetched = crate::query_chain_slots_get(&database, 424242)
.await
.expect("chain slot fetch must succeed")
.expect("chain slot must exist");
assert_eq!(fetched.slot, 424242);
assert_eq!(fetched.parent_slot, Some(424241));
assert_eq!(fetched.block_time_unix, Some(1_777_777_777));
let listed = crate::list_recent_chain_slots(&database, 10)
let listed = crate::query_chain_slots_list_recent(&database, 10)
.await
.expect("chain slot list must succeed");
assert_eq!(listed.len(), 1);

98
kb_lib/src/db/queries/chain_transaction.rs
View File

@@ -1,19 +1,19 @@
// file: kb_lib/src/db/queries/chain_transaction.rs
//! Queries for `kb_chain_transactions`.
//! Queries for `k_sol_chain_transactions`.
/// Inserts or updates one normalized chain transaction row.
pub async fn upsert_chain_transaction(
database: &crate::KbDatabase,
dto: &crate::KbChainTransactionDto,
) -> Result<i64, crate::KbError> {
pub async fn query_chain_transactions_upsert(
database: &crate::Database,
dto: &crate::ChainTransactionDto,
) -> Result<i64, crate::Error> {
let slot_i64 = match dto.slot {
Some(slot) => {
let slot_result = i64::try_from(slot);
match slot_result {
Ok(slot) => Some(slot),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert chain transaction slot '{}' to i64: {}",
slot, error
)));
@@ -23,10 +23,10 @@ pub async fn upsert_chain_transaction(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_chain_transactions (
INSERT INTO k_sol_chain_transactions (
signature,
slot,
block_time_unix,
@@ -63,15 +63,15 @@ ON CONFLICT(signature) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_chain_transactions on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_chain_transactions on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_chain_transactions
FROM k_sol_chain_transactions
WHERE signature = ?
LIMIT 1
"#,
@@ -82,8 +82,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_chain_transactions id for signature '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_chain_transactions id for signature '{}' on sqlite: {}",
dto.signature, error
)));
},
@@ -93,13 +93,13 @@ LIMIT 1
}
/// Reads one chain transaction row by signature.
pub async fn get_chain_transaction_by_signature(
database: &crate::KbDatabase,
pub async fn query_chain_transactions_get_by_signature(
database: &crate::Database,
signature: &str,
) -> Result<std::option::Option<crate::KbChainTransactionDto>, crate::KbError> {
) -> Result<std::option::Option<crate::ChainTransactionDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbChainTransactionEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ChainTransactionEntity>(
r#"
SELECT
id,
@@ -113,7 +113,7 @@ SELECT
transaction_json,
created_at,
updated_at
FROM kb_chain_transactions
FROM k_sol_chain_transactions
WHERE signature = ?
LIMIT 1
"#,
@@ -124,15 +124,15 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_chain_transactions for signature '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_chain_transactions for signature '{}' on sqlite: {}",
signature, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbChainTransactionDto::try_from(entity);
let dto_result = crate::ChainTransactionDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -145,16 +145,16 @@ LIMIT 1
}
/// Lists recent chain transactions ordered from newest to oldest.
pub async fn list_recent_chain_transactions(
database: &crate::KbDatabase,
pub async fn query_chain_transactions_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbChainTransactionDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::ChainTransactionDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbChainTransactionEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ChainTransactionEntity>(
r#"
SELECT
id,
@@ -168,7 +168,7 @@ SELECT
transaction_json,
created_at,
updated_at
FROM kb_chain_transactions
FROM k_sol_chain_transactions
ORDER BY id DESC
LIMIT ?
"#,
@@ -179,15 +179,15 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_chain_transactions on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_chain_transactions on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbChainTransactionDto::try_from(entity);
let dto_result = crate::ChainTransactionDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -200,12 +200,12 @@ LIMIT ?
}
/// Lists persisted chain transaction signatures for local pipeline replay.
pub async fn list_chain_transaction_signatures_for_replay(
database: &crate::KbDatabase,
pub async fn query_chain_transactions_list_signatures_for_replay(
database: &crate::Database,
limit: std::option::Option<i64>,
) -> Result<std::vec::Vec<std::string::String>, crate::KbError> {
) -> Result<std::vec::Vec<std::string::String>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let effective_limit = match limit {
Some(limit) => {
if limit <= 0 {
@@ -219,7 +219,7 @@ pub async fn list_chain_transaction_signatures_for_replay(
let query_result = sqlx::query_scalar::<sqlx::Sqlite, std::string::String>(
r#"
SELECT signature
FROM kb_chain_transactions
FROM k_sol_chain_transactions
ORDER BY id ASC
LIMIT ?
"#,
@@ -230,8 +230,8 @@ LIMIT ?
match query_result {
Ok(signatures) => return Ok(signatures),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_chain_transactions signatures for local replay on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_chain_transactions signatures for local replay on sqlite: {}",
error
)));
},
@@ -242,13 +242,13 @@ LIMIT ?
#[cfg(test)]
mod tests {
async fn make_database() -> crate::KbDatabase {
async fn make_database() -> crate::Database {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("chain_transaction.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,
@@ -257,7 +257,7 @@ mod tests {
use_wal: true,
},
};
return crate::KbDatabase::connect_and_initialize(&config)
return crate::Database::connect_and_initialize(&config)
.await
.expect("database init must succeed");
}
@@ -265,11 +265,11 @@ mod tests {
#[tokio::test]
async fn chain_transaction_roundtrip_works() {
let database = make_database().await;
let slot_dto = crate::KbChainSlotDto::new(515151, Some(515150), Some(1_700_000_001));
crate::upsert_chain_slot(&database, &slot_dto)
let slot_dto = crate::ChainSlotDto::new(515151, Some(515150), Some(1_700_000_001));
crate::query_chain_slots_upsert(&database, &slot_dto)
.await
.expect("chain slot upsert must succeed");
let dto = crate::KbChainTransactionDto::new(
let dto = crate::ChainTransactionDto::new(
"sig-chain-transaction-1".to_string(),
Some(515151),
Some(1_700_000_001),
@@ -279,12 +279,12 @@ mod tests {
Some(r#"{"fee":5000}"#.to_string()),
r#"{"slot":515151,"transaction":{"message":{"instructions":[]}}}"#.to_string(),
);
let transaction_id = crate::upsert_chain_transaction(&database, &dto)
let transaction_id = crate::query_chain_transactions_upsert(&database, &dto)
.await
.expect("chain transaction upsert must succeed");
assert!(transaction_id > 0);
let fetched =
crate::get_chain_transaction_by_signature(&database, "sig-chain-transaction-1")
crate::query_chain_transactions_get_by_signature(&database, "sig-chain-transaction-1")
.await
.expect("chain transaction fetch must succeed")
.expect("chain transaction must exist");
@@ -295,7 +295,7 @@ mod tests {
assert_eq!(fetched.source_endpoint_name, Some("helius_primary_http".to_string()));
assert_eq!(fetched.version_text, Some("0".to_string()));
assert_eq!(fetched.meta_json, Some(r#"{"fee":5000}"#.to_string()));
let listed = crate::list_recent_chain_transactions(&database, 10)
let listed = crate::query_chain_transactions_list_recent(&database, 10)
.await
.expect("chain transaction list must succeed");
assert_eq!(listed.len(), 1);

74
kb_lib/src/db/queries/db_metadata.rs
View File

@@ -1,18 +1,18 @@
// file: kb_lib/src/db/queries/db_metadata.rs
//! Queries for `kb_db_metadata`.
//! Queries for `k_sol_db_metadata`.
/// Inserts or updates one metadata row.
pub async fn upsert_db_metadata(
database: &crate::KbDatabase,
dto: &crate::KbDbMetadataDto,
) -> Result<(), crate::KbError> {
let entity = crate::KbDbMetadataEntity::from(dto.clone());
pub async fn query_db_metadatas_upsert(
database: &crate::Database,
dto: &crate::DbMetadataDto,
) -> Result<(), crate::Error> {
let entity = crate::DbMetadataEntity::from(dto.clone());
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_db_metadata (
INSERT INTO k_sol_db_metadata (
key,
value,
updated_at
@@ -31,8 +31,8 @@ ON CONFLICT(key) DO UPDATE SET
match query_result {
Ok(_) => return Ok(()),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_db_metadata on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_db_metadata on sqlite: {}",
error
)));
},
@@ -42,19 +42,19 @@ ON CONFLICT(key) DO UPDATE SET
}
/// Reads one metadata row by key.
pub async fn get_db_metadata(
database: &crate::KbDatabase,
pub async fn query_db_metadatas_get(
database: &crate::Database,
key: &str,
) -> Result<std::option::Option<crate::KbDbMetadataDto>, crate::KbError> {
) -> Result<std::option::Option<crate::DbMetadataDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDbMetadataEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::DbMetadataEntity>(
r#"
SELECT
key,
value,
updated_at
FROM kb_db_metadata
FROM k_sol_db_metadata
WHERE key = ?
LIMIT 1
"#,
@@ -65,15 +65,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_db_metadata '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_db_metadata '{}' on sqlite: {}",
key, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbDbMetadataDto::try_from(entity);
let dto_result = crate::DbMetadataDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -86,18 +86,18 @@ LIMIT 1
}
/// Lists all metadata rows.
pub async fn list_db_metadata(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbDbMetadataDto>, crate::KbError> {
pub async fn query_db_metadatas_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::DbMetadataDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDbMetadataEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::DbMetadataEntity>(
r#"
SELECT
key,
value,
updated_at
FROM kb_db_metadata
FROM k_sol_db_metadata
ORDER BY key ASC
"#,
)
@@ -106,15 +106,15 @@ ORDER BY key ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_db_metadata on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_db_metadata on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbDbMetadataDto::try_from(entity);
let dto_result = crate::DbMetadataDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -132,10 +132,10 @@ mod tests {
async fn db_metadata_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("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,
@@ -144,19 +144,21 @@ 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 dto = crate::KbDbMetadataDto::new("schema_version".to_string(), "0.5.0".to_string());
crate::upsert_db_metadata(&database, &dto).await.expect("upsert must succeed");
let fetched = crate::get_db_metadata(&database, "schema_version")
let dto = crate::DbMetadataDto::new("schema_version".to_string(), "0.5.0".to_string());
crate::query_db_metadatas_upsert(&database, &dto)
.await
.expect("upsert must succeed");
let fetched = crate::query_db_metadatas_get(&database, "schema_version")
.await
.expect("fetch must succeed");
assert!(fetched.is_some());
let fetched = fetched.expect("metadata must exist");
assert_eq!(fetched.key, "schema_version");
assert_eq!(fetched.value, "0.5.0");
let listed = crate::list_db_metadata(&database).await.expect("list must succeed");
let listed = crate::query_db_metadatas_list(&database).await.expect("list must succeed");
assert!(!listed.is_empty());
}
}

52
kb_lib/src/db/queries/db_runtime_event.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/db_runtime_event.rs
//! Queries for `kb_db_runtime_events`.
//! Queries for `k_sol_db_runtime_events`.
/// Inserts one runtime event row and returns its numeric id.
pub async fn insert_db_runtime_event(
database: &crate::KbDatabase,
dto: &crate::KbDbRuntimeEventDto,
) -> Result<i64, crate::KbError> {
pub async fn query_db_runtime_events_insert(
database: &crate::Database,
dto: &crate::DbRuntimeEventDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_db_runtime_events (
INSERT INTO k_sol_db_runtime_events (
event_kind,
level,
source,
@@ -31,8 +31,8 @@ VALUES (?, ?, ?, ?, ?)
let query_result = match query_result {
Ok(query_result) => query_result,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot insert kb_db_runtime_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot insert k_sol_db_runtime_events on sqlite: {}",
error
)));
},
@@ -43,16 +43,16 @@ VALUES (?, ?, ?, ?, ?)
}
/// Lists recent runtime events ordered from newest to oldest.
pub async fn list_recent_db_runtime_events(
database: &crate::KbDatabase,
pub async fn query_db_runtime_events_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbDbRuntimeEventDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::DbRuntimeEventDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDbRuntimeEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::DbRuntimeEventEntity>(
r#"
SELECT
id,
@@ -61,7 +61,7 @@ SELECT
source,
message,
created_at
FROM kb_db_runtime_events
FROM k_sol_db_runtime_events
ORDER BY id DESC
LIMIT ?
"#,
@@ -72,7 +72,7 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot list runtime events on sqlite: {}",
error
)));
@@ -80,7 +80,7 @@ LIMIT ?
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbDbRuntimeEventDto::try_from(entity);
let dto_result = crate::DbRuntimeEventDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -98,10 +98,10 @@ mod tests {
async fn runtime_event_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("runtime_event.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,
@@ -110,24 +110,24 @@ 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 dto = crate::KbDbRuntimeEventDto::new(
let dto = crate::DbRuntimeEventDto::new(
"http_request".to_string(),
crate::KbDbRuntimeEventLevel::Info,
crate::DbRuntimeEventLevel::Info,
"demo_http".to_string(),
"getHealth executed".to_string(),
);
let inserted_id = crate::insert_db_runtime_event(&database, &dto)
let inserted_id = crate::query_db_runtime_events_insert(&database, &dto)
.await
.expect("insert must succeed");
assert!(inserted_id > 0);
let listed = crate::list_recent_db_runtime_events(&database, 10)
let listed = crate::query_db_runtime_events_list_recent(&database, 10)
.await
.expect("list must succeed");
assert_eq!(listed.len(), 1);
assert_eq!(listed[0].event_kind, "http_request");
assert_eq!(listed[0].level, crate::KbDbRuntimeEventLevel::Info);
assert_eq!(listed[0].level, crate::DbRuntimeEventLevel::Info);
}
}

76
kb_lib/src/db/queries/dex.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/dex.rs
//! Queries for `kb_dexes`.
//! Queries for `k_sol_dexes`.
/// Inserts or updates one normalized DEX row by code.
pub async fn upsert_dex(
database: &crate::KbDatabase,
dto: &crate::KbDexDto,
) -> Result<i64, crate::KbError> {
pub async fn query_dexs_upsert(
database: &crate::Database,
dto: &crate::DexDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_dexes (
INSERT INTO k_sol_dexes (
code,
name,
program_id,
@@ -39,15 +39,15 @@ ON CONFLICT(code) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_dexes on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_dexes on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_dexes
FROM k_sol_dexes
WHERE code = ?
LIMIT 1
"#,
@@ -58,8 +58,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_dexes id for code '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_dexes id for code '{}' on sqlite: {}",
dto.code, error
)));
},
@@ -69,13 +69,13 @@ LIMIT 1
}
/// Reads one normalized DEX row by code.
pub async fn get_dex_by_code(
database: &crate::KbDatabase,
pub async fn query_dexs_get_by_code(
database: &crate::Database,
code: &str,
) -> Result<std::option::Option<crate::KbDexDto>, crate::KbError> {
) -> Result<std::option::Option<crate::DexDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDexEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::DexEntity>(
r#"
SELECT
id,
@@ -86,7 +86,7 @@ SELECT
is_enabled,
created_at,
updated_at
FROM kb_dexes
FROM k_sol_dexes
WHERE code = ?
LIMIT 1
"#,
@@ -97,15 +97,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_dexes '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_dexes '{}' on sqlite: {}",
code, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbDexDto::try_from(entity);
let dto_result = crate::DexDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -118,12 +118,12 @@ LIMIT 1
}
/// Lists normalized DEX rows.
pub async fn list_dexes(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbDexDto>, crate::KbError> {
pub async fn query_dexs_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::DexDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDexEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::DexEntity>(
r#"
SELECT
id,
@@ -134,7 +134,7 @@ SELECT
is_enabled,
created_at,
updated_at
FROM kb_dexes
FROM k_sol_dexes
ORDER BY code ASC
"#,
)
@@ -143,15 +143,15 @@ ORDER BY code ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_dexes on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_dexes on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbDexDto::try_from(entity);
let dto_result = crate::DexDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -169,10 +169,10 @@ mod tests {
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 {
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,
@@ -181,22 +181,22 @@ 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");
assert!(dex_id > 0);
let dex = crate::get_dex_by_code(&database, "raydium")
let dex = crate::query_dexs_get_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");
let dexes = crate::query_dexs_list(&database).await.expect("list dexes must succeed");
assert_eq!(dexes.len(), 1);
}
}

102
kb_lib/src/db/queries/dex_decoded_event.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/dex_decoded_event.rs
//! Queries for `kb_dex_decoded_events`.
//! Queries for `k_sol_dex_decoded_events`.
/// Inserts or updates one decoded DEX event row.
pub async fn upsert_dex_decoded_event(
database: &crate::KbDatabase,
dto: &crate::KbDexDecodedEventDto,
) -> Result<i64, crate::KbError> {
pub async fn query_dex_decoded_events_upsert(
database: &crate::Database,
dto: &crate::DexDecodedEventDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_dex_decoded_events (
INSERT INTO k_sol_dex_decoded_events (
transaction_id,
instruction_id,
protocol_name,
@@ -52,15 +52,15 @@ ON CONFLICT(transaction_id, instruction_id, event_kind) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_dex_decoded_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_dex_decoded_events on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_dex_decoded_events
FROM k_sol_dex_decoded_events
WHERE transaction_id = ?
AND (
(instruction_id IS NULL AND ? IS NULL)
@@ -79,8 +79,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_dex_decoded_events id on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_dex_decoded_events id on sqlite: {}",
error
)));
},
@@ -90,15 +90,15 @@ LIMIT 1
}
/// Reads one decoded DEX event by its natural key.
pub async fn get_dex_decoded_event_by_key(
database: &crate::KbDatabase,
pub async fn query_dex_decoded_events_get_by_key(
database: &crate::Database,
transaction_id: i64,
instruction_id: std::option::Option<i64>,
event_kind: &str,
) -> Result<std::option::Option<crate::KbDexDecodedEventDto>, crate::KbError> {
) -> Result<std::option::Option<crate::DexDecodedEventDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDexDecodedEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::DexDecodedEventEntity>(
r#"
SELECT
id,
@@ -114,7 +114,7 @@ SELECT
market_account,
payload_json,
created_at
FROM kb_dex_decoded_events
FROM k_sol_dex_decoded_events
WHERE transaction_id = ?
AND (
(instruction_id IS NULL AND ? IS NULL)
@@ -133,15 +133,15 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_dex_decoded_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_dex_decoded_events on sqlite: {}",
error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbDexDecodedEventDto::try_from(entity);
let dto_result = crate::DexDecodedEventDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -154,13 +154,13 @@ LIMIT 1
}
/// Lists decoded DEX events for one transaction.
pub async fn list_dex_decoded_events_by_transaction_id(
database: &crate::KbDatabase,
pub async fn query_dex_decoded_events_list_by_transaction_id(
database: &crate::Database,
transaction_id: i64,
) -> Result<std::vec::Vec<crate::KbDexDecodedEventDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::DexDecodedEventDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbDexDecodedEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::DexDecodedEventEntity>(
r#"
SELECT
id,
@@ -176,7 +176,7 @@ SELECT
market_account,
payload_json,
created_at
FROM kb_dex_decoded_events
FROM k_sol_dex_decoded_events
WHERE transaction_id = ?
ORDER BY id ASC
"#,
@@ -187,15 +187,15 @@ ORDER BY id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_dex_decoded_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_dex_decoded_events on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbDexDecodedEventDto::try_from(entity);
let dto_result = crate::DexDecodedEventDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -208,16 +208,16 @@ ORDER BY id ASC
}
/// Returns the latest Pump.fun create payload associated with a token mint.
pub async fn get_latest_pump_fun_create_payload_by_mint(
database: &crate::KbDatabase,
pub async fn query_dex_decoded_events_get_latest_pump_fun_create_payload_by_mint(
database: &crate::Database,
mint: &str,
) -> Result<std::option::Option<std::string::String>, crate::KbError> {
) -> Result<std::option::Option<std::string::String>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let payload_result = sqlx::query_scalar::<sqlx::Sqlite, std::string::String>(
r#"
SELECT payload_json
FROM kb_dex_decoded_events
FROM k_sol_dex_decoded_events
WHERE protocol_name = 'pump_fun'
AND event_kind IN ('pump_fun.create', 'pump_fun.create_v2_token')
AND (
@@ -237,7 +237,7 @@ LIMIT 1
match payload_result {
Ok(payload_option) => return Ok(payload_option),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot read latest pump.fun create payload for mint '{}' on sqlite: {}",
mint, error
)));
@@ -249,17 +249,17 @@ LIMIT 1
#[cfg(test)]
mod tests {
async fn make_database() -> crate::KbDatabase {
async fn make_database() -> crate::Database {
let tempdir_result = tempfile::tempdir();
let tempdir = match tempdir_result {
Ok(tempdir) => tempdir,
Err(error) => panic!("tempdir must succeed: {}", error),
};
let database_path = tempdir.path().join("dex_decoded_event.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,
@@ -268,7 +268,7 @@ mod tests {
use_wal: true,
},
};
let database_result = crate::KbDatabase::connect_and_initialize(&config).await;
let database_result = crate::Database::connect_and_initialize(&config).await;
match database_result {
Ok(database) => return database,
Err(error) => panic!("database init must succeed: {}", error),
@@ -278,7 +278,7 @@ mod tests {
#[tokio::test]
async fn dex_decoded_event_roundtrip_works() {
let database = make_database().await;
let transaction_dto = crate::KbChainTransactionDto::new(
let transaction_dto = crate::ChainTransactionDto::new(
"sig-dex-event-test-1".to_string(),
None,
None,
@@ -289,17 +289,17 @@ mod tests {
r#"{"transaction":{"message":{"instructions":[]}}}"#.to_string(),
);
let transaction_id_result =
crate::upsert_chain_transaction(&database, &transaction_dto).await;
crate::query_chain_transactions_upsert(&database, &transaction_dto).await;
let transaction_id = match transaction_id_result {
Ok(transaction_id) => transaction_id,
Err(error) => panic!("transaction upsert must succeed: {}", error),
};
let instruction_dto = crate::KbChainInstructionDto::new(
let instruction_dto = crate::ChainInstructionDto::new(
transaction_id,
None,
0,
None,
Some(crate::KB_RAYDIUM_AMM_V4_PROGRAM_ID.to_string()),
Some(crate::RAYDIUM_AMM_V4_PROGRAM_ID.to_string()),
Some("raydium-amm-v4".to_string()),
Some(1),
r#"["Account0","Pool111","Lp111","TokenA111","TokenB111"]"#.to_string(),
@@ -308,16 +308,16 @@ mod tests {
None,
);
let instruction_id_result =
crate::insert_chain_instruction(&database, &instruction_dto).await;
crate::query_chain_instructions_insert(&database, &instruction_dto).await;
let instruction_id = match instruction_id_result {
Ok(instruction_id) => instruction_id,
Err(error) => panic!("instruction insert must succeed: {}", error),
};
let dto = crate::KbDexDecodedEventDto::new(
let dto = crate::DexDecodedEventDto::new(
transaction_id,
Some(instruction_id),
"raydium_amm_v4".to_string(),
crate::KB_RAYDIUM_AMM_V4_PROGRAM_ID.to_string(),
crate::RAYDIUM_AMM_V4_PROGRAM_ID.to_string(),
"raydium_amm_v4.initialize2_pool".to_string(),
Some("Pool111".to_string()),
Some("Lp111".to_string()),
@@ -326,13 +326,13 @@ mod tests {
Some("Market111".to_string()),
r#"{"k":"v"}"#.to_string(),
);
let event_id_result = crate::upsert_dex_decoded_event(&database, &dto).await;
let event_id_result = crate::query_dex_decoded_events_upsert(&database, &dto).await;
let event_id = match event_id_result {
Ok(event_id) => event_id,
Err(error) => panic!("event upsert must succeed: {}", error),
};
assert!(event_id > 0);
let fetched_result = crate::get_dex_decoded_event_by_key(
let fetched_result = crate::query_dex_decoded_events_get_by_key(
&database,
transaction_id,
Some(instruction_id),
@@ -353,7 +353,7 @@ mod tests {
assert_eq!(fetched.protocol_name, "raydium_amm_v4");
assert_eq!(fetched.pool_account, Some("Pool111".to_string()));
let listed_result =
crate::list_dex_decoded_events_by_transaction_id(&database, transaction_id).await;
crate::query_dex_decoded_events_list_by_transaction_id(&database, transaction_id).await;
let listed = match listed_result {
Ok(listed) => listed,
Err(error) => panic!("event list must succeed: {}", error),

70
kb_lib/src/db/queries/known_http_endpoint.rs
View File

@@ -1,23 +1,23 @@
// file: kb_lib/src/db/queries/known_http_endpoint.rs
//! Queries for `kb_known_http_endpoints`.
//! Queries for `k_sol_known_http_endpoints`.
/// Inserts or updates one known HTTP endpoint row.
pub async fn upsert_known_http_endpoint(
database: &crate::KbDatabase,
dto: &crate::KbKnownHttpEndpointDto,
) -> Result<(), crate::KbError> {
let entity_result = crate::KbKnownHttpEndpointEntity::try_from(dto.clone());
pub async fn query_known_http_endpoints_upsert(
database: &crate::Database,
dto: &crate::KnownHttpEndpointDto,
) -> Result<(), crate::Error> {
let entity_result = crate::KnownHttpEndpointEntity::try_from(dto.clone());
let entity = match entity_result {
Ok(entity) => entity,
Err(error) => return Err(error),
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_known_http_endpoints (
INSERT INTO k_sol_known_http_endpoints (
name,
provider,
url,
@@ -48,8 +48,8 @@ ON CONFLICT(name) DO UPDATE SET
match query_result {
Ok(_) => return Ok(()),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_known_http_endpoints on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_known_http_endpoints on sqlite: {}",
error
)));
},
@@ -59,13 +59,13 @@ ON CONFLICT(name) DO UPDATE SET
}
/// Reads one known HTTP endpoint by name.
pub async fn get_known_http_endpoint(
database: &crate::KbDatabase,
pub async fn query_known_http_endpoints_get(
database: &crate::Database,
name: &str,
) -> Result<std::option::Option<crate::KbKnownHttpEndpointDto>, crate::KbError> {
) -> Result<std::option::Option<crate::KnownHttpEndpointDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbKnownHttpEndpointEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KnownHttpEndpointEntity>(
r#"
SELECT
name,
@@ -75,7 +75,7 @@ SELECT
roles_json,
last_seen_at,
updated_at
FROM kb_known_http_endpoints
FROM k_sol_known_http_endpoints
WHERE name = ?
LIMIT 1
"#,
@@ -86,7 +86,7 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot read known http endpoint '{}' on sqlite: {}",
name, error
)));
@@ -94,7 +94,7 @@ LIMIT 1
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbKnownHttpEndpointDto::try_from(entity);
let dto_result = crate::KnownHttpEndpointDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -107,12 +107,12 @@ LIMIT 1
}
/// Lists all known HTTP endpoints.
pub async fn list_known_http_endpoints(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbKnownHttpEndpointDto>, crate::KbError> {
pub async fn query_known_http_endpoints_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::KnownHttpEndpointDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbKnownHttpEndpointEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KnownHttpEndpointEntity>(
r#"
SELECT
name,
@@ -122,7 +122,7 @@ SELECT
roles_json,
last_seen_at,
updated_at
FROM kb_known_http_endpoints
FROM k_sol_known_http_endpoints
ORDER BY name ASC
"#,
)
@@ -131,7 +131,7 @@ ORDER BY name ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot list known http endpoints on sqlite: {}",
error
)));
@@ -139,7 +139,7 @@ ORDER BY name ASC
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbKnownHttpEndpointDto::try_from(entity);
let dto_result = crate::KnownHttpEndpointDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -157,10 +157,10 @@ mod tests {
async fn known_http_endpoint_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("known_http_endpoint.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,
@@ -169,27 +169,29 @@ 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 dto = crate::KbKnownHttpEndpointDto::new(
let dto = crate::KnownHttpEndpointDto::new(
"helius_primary_http".to_string(),
"helius".to_string(),
"https://mainnet.helius-rpc.com".to_string(),
true,
vec!["http_queries".to_string(), "http_transactions".to_string()],
);
crate::upsert_known_http_endpoint(&database, &dto)
crate::query_known_http_endpoints_upsert(&database, &dto)
.await
.expect("upsert must succeed");
let fetched = crate::get_known_http_endpoint(&database, "helius_primary_http")
let fetched = crate::query_known_http_endpoints_get(&database, "helius_primary_http")
.await
.expect("fetch must succeed");
assert!(fetched.is_some());
let fetched = fetched.expect("endpoint must exist");
assert_eq!(fetched.provider, "helius");
assert_eq!(fetched.roles.len(), 2);
let listed = crate::list_known_http_endpoints(&database).await.expect("list must succeed");
let listed = crate::query_known_http_endpoints_list(&database)
.await
.expect("list must succeed");
assert_eq!(listed.len(), 1);
}
}

70
kb_lib/src/db/queries/known_ws_endpoint.rs
View File

@@ -1,22 +1,22 @@
// file: kb_lib/src/db/queries/known_ws_endpoint.rs
//! Queries for `kb_known_ws_endpoints`.
//! Queries for `k_sol_known_ws_endpoints`.
/// Inserts or updates one known WS endpoint row.
pub async fn upsert_known_ws_endpoint(
database: &crate::KbDatabase,
dto: &crate::KbKnownWsEndpointDto,
) -> Result<(), crate::KbError> {
let entity_result = crate::KbKnownWsEndpointEntity::try_from(dto.clone());
pub async fn query_known_ws_endpoints_upsert(
database: &crate::Database,
dto: &crate::KnownWsEndpointDto,
) -> Result<(), crate::Error> {
let entity_result = crate::KnownWsEndpointEntity::try_from(dto.clone());
let entity = match entity_result {
Ok(entity) => entity,
Err(error) => return Err(error),
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_known_ws_endpoints (
INSERT INTO k_sol_known_ws_endpoints (
name,
provider,
url,
@@ -47,8 +47,8 @@ ON CONFLICT(name) DO UPDATE SET
match query_result {
Ok(_) => return Ok(()),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_known_ws_endpoints on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_known_ws_endpoints on sqlite: {}",
error
)));
},
@@ -58,13 +58,13 @@ ON CONFLICT(name) DO UPDATE SET
}
/// Reads one known WS endpoint by name.
pub async fn get_known_ws_endpoint(
database: &crate::KbDatabase,
pub async fn query_known_ws_endpoints_get(
database: &crate::Database,
name: &str,
) -> Result<std::option::Option<crate::KbKnownWsEndpointDto>, crate::KbError> {
) -> Result<std::option::Option<crate::KnownWsEndpointDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbKnownWsEndpointEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KnownWsEndpointEntity>(
r#"
SELECT
name,
@@ -74,7 +74,7 @@ SELECT
roles_json,
last_seen_at,
updated_at
FROM kb_known_ws_endpoints
FROM k_sol_known_ws_endpoints
WHERE name = ?
LIMIT 1
"#,
@@ -85,7 +85,7 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot read known ws endpoint '{}' on sqlite: {}",
name, error
)));
@@ -93,7 +93,7 @@ LIMIT 1
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbKnownWsEndpointDto::try_from(entity);
let dto_result = crate::KnownWsEndpointDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -106,12 +106,12 @@ LIMIT 1
}
/// Lists all known WS endpoints.
pub async fn list_known_ws_endpoints(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbKnownWsEndpointDto>, crate::KbError> {
pub async fn query_known_ws_endpoints_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::KnownWsEndpointDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbKnownWsEndpointEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KnownWsEndpointEntity>(
r#"
SELECT
name,
@@ -121,7 +121,7 @@ SELECT
roles_json,
last_seen_at,
updated_at
FROM kb_known_ws_endpoints
FROM k_sol_known_ws_endpoints
ORDER BY name ASC
"#,
)
@@ -130,7 +130,7 @@ ORDER BY name ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot list known ws endpoints on sqlite: {}",
error
)));
@@ -138,7 +138,7 @@ ORDER BY name ASC
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbKnownWsEndpointDto::try_from(entity);
let dto_result = crate::KnownWsEndpointDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -156,10 +156,10 @@ mod tests {
async fn known_ws_endpoint_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("known_ws_endpoint.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,
@@ -168,27 +168,29 @@ 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 dto = crate::KbKnownWsEndpointDto::new(
let dto = crate::KnownWsEndpointDto::new(
"mainnet_public_ws_slots".to_string(),
"solana".to_string(),
"wss://api.mainnet.solana.com".to_string(),
true,
vec!["ws_slots".to_string(), "ws_subscriptions".to_string()],
);
crate::upsert_known_ws_endpoint(&database, &dto)
crate::query_known_ws_endpoints_upsert(&database, &dto)
.await
.expect("upsert must succeed");
let fetched = crate::get_known_ws_endpoint(&database, "mainnet_public_ws_slots")
let fetched = crate::query_known_ws_endpoints_get(&database, "mainnet_public_ws_slots")
.await
.expect("fetch must succeed");
assert!(fetched.is_some());
let fetched = fetched.expect("endpoint must exist");
assert_eq!(fetched.provider, "solana");
assert_eq!(fetched.roles.len(), 2);
let listed = crate::list_known_ws_endpoints(&database).await.expect("list must succeed");
let listed = crate::query_known_ws_endpoints_list(&database)
.await
.expect("list must succeed");
assert_eq!(listed.len(), 1);
}
}

60
kb_lib/src/db/queries/launch_attribution.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/launch_attribution.rs
//! Queries for `kb_launch_attributions`.
//! Queries for `k_sol_launch_attributions`.
/// Inserts or updates one launch attribution row and returns its stable internal id.
pub async fn upsert_launch_attribution(
database: &crate::KbDatabase,
dto: &crate::KbLaunchAttributionDto,
) -> Result<i64, crate::KbError> {
pub async fn query_launch_attributions_upsert(
database: &crate::Database,
dto: &crate::LaunchAttributionDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_launch_attributions (
INSERT INTO k_sol_launch_attributions (
launch_surface_id,
transaction_id,
decoded_event_id,
@@ -51,15 +51,15 @@ ON CONFLICT(decoded_event_id) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_launch_attributions on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_launch_attributions on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_launch_attributions
FROM k_sol_launch_attributions
WHERE decoded_event_id = ?
LIMIT 1
"#,
@@ -70,8 +70,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_launch_attributions id for decoded_event_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_launch_attributions id for decoded_event_id '{}' on sqlite: {}",
dto.decoded_event_id, error
)));
},
@@ -81,13 +81,13 @@ LIMIT 1
}
/// Returns one launch attribution identified by its decoded-event id, if it exists.
pub async fn get_launch_attribution_by_decoded_event_id(
database: &crate::KbDatabase,
pub async fn query_launch_attributions_get_by_decoded_event_id(
database: &crate::Database,
decoded_event_id: i64,
) -> Result<std::option::Option<crate::KbLaunchAttributionDto>, crate::KbError> {
) -> Result<std::option::Option<crate::LaunchAttributionDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbLaunchAttributionEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::LaunchAttributionEntity>(
r#"
SELECT
id,
@@ -102,7 +102,7 @@ SELECT
matched_value,
attributed_at,
updated_at
FROM kb_launch_attributions
FROM k_sol_launch_attributions
WHERE decoded_event_id = ?
LIMIT 1
"#,
@@ -113,14 +113,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_launch_attributions by decoded_event_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_launch_attributions by decoded_event_id '{}' on sqlite: {}",
decoded_event_id, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbLaunchAttributionDto::try_from(entity).map(Some),
Some(entity) => return crate::LaunchAttributionDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -128,13 +128,13 @@ LIMIT 1
}
/// Lists all launch attributions attached to one pool id.
pub async fn list_launch_attributions_by_pool_id(
database: &crate::KbDatabase,
pub async fn query_launch_attributions_list_by_pool_id(
database: &crate::Database,
pool_id: i64,
) -> Result<std::vec::Vec<crate::KbLaunchAttributionDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::LaunchAttributionDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbLaunchAttributionEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::LaunchAttributionEntity>(
r#"
SELECT
id,
@@ -149,7 +149,7 @@ SELECT
matched_value,
attributed_at,
updated_at
FROM kb_launch_attributions
FROM k_sol_launch_attributions
WHERE pool_id = ?
ORDER BY attributed_at ASC, id ASC
"#,
@@ -160,15 +160,15 @@ ORDER BY attributed_at ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_launch_attributions by pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_launch_attributions by pool_id '{}' on sqlite: {}",
pool_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbLaunchAttributionDto::try_from(entity);
let dto_result = crate::LaunchAttributionDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

60
kb_lib/src/db/queries/launch_surface.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/launch_surface.rs
//! Queries for `kb_launch_surfaces`.
//! Queries for `k_sol_launch_surfaces`.
/// Inserts or updates one launch surface row and returns its stable internal id.
pub async fn upsert_launch_surface(
database: &crate::KbDatabase,
dto: &crate::KbLaunchSurfaceDto,
) -> Result<i64, crate::KbError> {
pub async fn query_launch_surfaces_upsert(
database: &crate::Database,
dto: &crate::LaunchSurfaceDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_launch_surfaces (
INSERT INTO k_sol_launch_surfaces (
code,
name,
protocol_family,
@@ -36,15 +36,15 @@ ON CONFLICT(code) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_launch_surfaces on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_launch_surfaces on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_launch_surfaces
FROM k_sol_launch_surfaces
WHERE code = ?
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_launch_surfaces id for code '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_launch_surfaces id for code '{}' on sqlite: {}",
dto.code, error
)));
},
@@ -66,13 +66,13 @@ LIMIT 1
}
/// Returns one launch surface identified by its stable short code, if it exists.
pub async fn get_launch_surface_by_code(
database: &crate::KbDatabase,
pub async fn query_launch_surfaces_get_by_code(
database: &crate::Database,
code: &str,
) -> Result<std::option::Option<crate::KbLaunchSurfaceDto>, crate::KbError> {
) -> Result<std::option::Option<crate::LaunchSurfaceDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbLaunchSurfaceEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::LaunchSurfaceEntity>(
r#"
SELECT
id,
@@ -82,7 +82,7 @@ SELECT
is_enabled,
created_at,
updated_at
FROM kb_launch_surfaces
FROM k_sol_launch_surfaces
WHERE code = ?
LIMIT 1
"#,
@@ -93,14 +93,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_launch_surfaces '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_launch_surfaces '{}' on sqlite: {}",
code, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbLaunchSurfaceDto::try_from(entity).map(Some),
Some(entity) => return crate::LaunchSurfaceDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -108,12 +108,12 @@ LIMIT 1
}
/// Lists all persisted launch surfaces ordered by code.
pub async fn list_launch_surfaces(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbLaunchSurfaceDto>, crate::KbError> {
pub async fn query_launch_surfaces_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::LaunchSurfaceDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbLaunchSurfaceEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::LaunchSurfaceEntity>(
r#"
SELECT
id,
@@ -123,7 +123,7 @@ SELECT
is_enabled,
created_at,
updated_at
FROM kb_launch_surfaces
FROM k_sol_launch_surfaces
ORDER BY code ASC
"#,
)
@@ -132,15 +132,15 @@ ORDER BY code ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_launch_surfaces on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_launch_surfaces on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbLaunchSurfaceDto::try_from(entity);
let dto_result = crate::LaunchSurfaceDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

60
kb_lib/src/db/queries/launch_surface_key.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/launch_surface_key.rs
//! Queries for `kb_launch_surface_keys`.
//! Queries for `k_sol_launch_surface_keys`.
/// Inserts or updates one launch-surface matching key and returns its stable internal id.
pub async fn upsert_launch_surface_key(
database: &crate::KbDatabase,
dto: &crate::KbLaunchSurfaceKeyDto,
) -> Result<i64, crate::KbError> {
pub async fn query_launch_surface_keys_upsert(
database: &crate::Database,
dto: &crate::LaunchSurfaceKeyDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_launch_surface_keys (
INSERT INTO k_sol_launch_surface_keys (
launch_surface_id,
match_kind,
match_value,
@@ -32,15 +32,15 @@ ON CONFLICT(match_kind, match_value) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_launch_surface_keys on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_launch_surface_keys on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_launch_surface_keys
FROM k_sol_launch_surface_keys
WHERE match_kind = ? AND match_value = ?
LIMIT 1
"#,
@@ -52,8 +52,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_launch_surface_keys id for '{}:{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_launch_surface_keys id for '{}:{}' on sqlite: {}",
dto.match_kind, dto.match_value, error
)));
},
@@ -63,14 +63,14 @@ LIMIT 1
}
/// Returns one launch-surface matching key identified by its kind and value, if it exists.
pub async fn get_launch_surface_key_by_match(
database: &crate::KbDatabase,
pub async fn query_launch_surface_keys_get_by_match(
database: &crate::Database,
match_kind: &str,
match_value: &str,
) -> Result<std::option::Option<crate::KbLaunchSurfaceKeyDto>, crate::KbError> {
) -> Result<std::option::Option<crate::LaunchSurfaceKeyDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbLaunchSurfaceKeyEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::LaunchSurfaceKeyEntity>(
r#"
SELECT
id,
@@ -79,7 +79,7 @@ SELECT
match_value,
created_at,
updated_at
FROM kb_launch_surface_keys
FROM k_sol_launch_surface_keys
WHERE match_kind = ? AND match_value = ?
LIMIT 1
"#,
@@ -91,14 +91,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_launch_surface_keys '{}:{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_launch_surface_keys '{}:{}' on sqlite: {}",
match_kind, match_value, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbLaunchSurfaceKeyDto::try_from(entity).map(Some),
Some(entity) => return crate::LaunchSurfaceKeyDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -106,13 +106,13 @@ LIMIT 1
}
/// Lists all launch-surface matching keys attached to one launch surface id.
pub async fn list_launch_surface_keys_by_surface_id(
database: &crate::KbDatabase,
pub async fn query_launch_surface_keys_list_by_surface_id(
database: &crate::Database,
launch_surface_id: i64,
) -> Result<std::vec::Vec<crate::KbLaunchSurfaceKeyDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::LaunchSurfaceKeyDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbLaunchSurfaceKeyEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::LaunchSurfaceKeyEntity>(
r#"
SELECT
id,
@@ -121,7 +121,7 @@ SELECT
match_value,
created_at,
updated_at
FROM kb_launch_surface_keys
FROM k_sol_launch_surface_keys
WHERE launch_surface_id = ?
ORDER BY match_kind ASC, match_value ASC
"#,
@@ -132,15 +132,15 @@ ORDER BY match_kind ASC, match_value ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_launch_surface_keys by surface_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_launch_surface_keys by surface_id '{}' on sqlite: {}",
launch_surface_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbLaunchSurfaceKeyDto::try_from(entity);
let dto_result = crate::LaunchSurfaceKeyDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

44
kb_lib/src/db/queries/liquidity_event.rs
View File

@@ -1,19 +1,19 @@
// file: kb_lib/src/db/queries/liquidity_event.rs
//! Queries for `kb_liquidity_events`.
//! Queries for `k_sol_liquidity_events`.
/// Inserts or updates one normalized liquidity event row.
pub async fn upsert_liquidity_event(
database: &crate::KbDatabase,
dto: &crate::KbLiquidityEventDto,
) -> Result<i64, crate::KbError> {
pub async fn query_liquidity_events_upsert(
database: &crate::Database,
dto: &crate::LiquidityEventDto,
) -> Result<i64, crate::Error> {
let slot_i64 = match dto.slot {
Some(slot) => {
let slot_result = i64::try_from(slot);
match slot_result {
Ok(slot) => Some(slot),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert liquidity event slot '{}' to i64: {}",
slot, error
)));
@@ -23,10 +23,10 @@ pub async fn upsert_liquidity_event(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_liquidity_events (
INSERT INTO k_sol_liquidity_events (
dex_id,
pool_id,
pair_id,
@@ -78,15 +78,15 @@ ON CONFLICT(signature, instruction_index) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_liquidity_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_liquidity_events on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_liquidity_events
FROM k_sol_liquidity_events
WHERE signature = ? AND instruction_index = ?
LIMIT 1
"#,
@@ -98,8 +98,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_liquidity_events id for signature '{}' and instruction_index '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_liquidity_events id for signature '{}' and instruction_index '{}' on sqlite: {}",
dto.signature, dto.instruction_index, error
)));
},
@@ -109,16 +109,16 @@ LIMIT 1
}
/// Lists recent liquidity events ordered from newest to oldest.
pub async fn list_recent_liquidity_events(
database: &crate::KbDatabase,
pub async fn query_liquidity_events_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbLiquidityEventDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::LiquidityEventDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbLiquidityEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::LiquidityEventEntity>(
r#"
SELECT
id,
@@ -137,7 +137,7 @@ SELECT
quote_amount,
lp_amount,
executed_at
FROM kb_liquidity_events
FROM k_sol_liquidity_events
ORDER BY id DESC
LIMIT ?
"#,
@@ -148,15 +148,15 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_liquidity_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_liquidity_events on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbLiquidityEventDto::try_from(entity);
let dto_result = crate::LiquidityEventDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

761
kb_lib/src/db/queries/local_pipeline_diagnostics.rs
View File

File diff suppressed because it is too large Load Diff

87
kb_lib/src/db/queries/observed_token.rs
View File

@@ -1,18 +1,18 @@
// file: kb_lib/src/db/queries/observed_token.rs
//! Queries for `kb_observed_tokens`.
//! Queries for `k_sol_observed_tokens`.
/// Inserts or updates one observed token by mint.
pub async fn upsert_observed_token(
database: &crate::KbDatabase,
dto: &crate::KbObservedTokenDto,
) -> Result<i64, crate::KbError> {
pub async fn query_observed_tokens_upsert(
database: &crate::Database,
dto: &crate::ObservedTokenDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let decimals_i64 = dto.decimals.map(i64::from);
let insert_result = sqlx::query(
r#"
INSERT INTO kb_observed_tokens (
INSERT INTO k_sol_observed_tokens (
mint,
symbol,
name,
@@ -46,15 +46,15 @@ ON CONFLICT(mint) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = insert_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_observed_tokens on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_observed_tokens on sqlite: {}",
error
)));
}
let select_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_observed_tokens
FROM k_sol_observed_tokens
WHERE mint = ?
LIMIT 1
"#,
@@ -65,8 +65,8 @@ LIMIT 1
match select_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_observed_tokens id for mint '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_observed_tokens id for mint '{}' on sqlite: {}",
dto.mint, error
)));
},
@@ -76,13 +76,13 @@ LIMIT 1
}
/// Reads one observed token by mint.
pub async fn get_observed_token_by_mint(
database: &crate::KbDatabase,
pub async fn query_observed_tokens_get_by_mint(
database: &crate::Database,
mint: &str,
) -> Result<std::option::Option<crate::KbObservedTokenDto>, crate::KbError> {
) -> Result<std::option::Option<crate::ObservedTokenDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbObservedTokenEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ObservedTokenEntity>(
r#"
SELECT
id,
@@ -95,7 +95,7 @@ SELECT
first_seen_at,
last_seen_at,
updated_at
FROM kb_observed_tokens
FROM k_sol_observed_tokens
WHERE mint = ?
LIMIT 1
"#,
@@ -106,7 +106,7 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot read observed token '{}' on sqlite: {}",
mint, error
)));
@@ -114,7 +114,7 @@ LIMIT 1
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbObservedTokenDto::try_from(entity);
let dto_result = crate::ObservedTokenDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -127,16 +127,16 @@ LIMIT 1
}
/// Lists observed tokens ordered by newest first.
pub async fn list_observed_tokens(
database: &crate::KbDatabase,
pub async fn query_observed_tokens_list(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbObservedTokenDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::ObservedTokenDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbObservedTokenEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::ObservedTokenEntity>(
r#"
SELECT
id,
@@ -149,7 +149,7 @@ SELECT
first_seen_at,
last_seen_at,
updated_at
FROM kb_observed_tokens
FROM k_sol_observed_tokens
ORDER BY id DESC
LIMIT ?
"#,
@@ -160,7 +160,7 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot list observed tokens on sqlite: {}",
error
)));
@@ -168,7 +168,7 @@ LIMIT ?
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbObservedTokenDto::try_from(entity);
let dto_result = crate::ObservedTokenDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -186,10 +186,10 @@ mod tests {
async fn observed_token_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("observed_token.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,
@@ -198,33 +198,32 @@ 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 dto = crate::KbObservedTokenDto::new(
"So11111111111111111111111111111111111111112".to_string(),
let dto = crate::ObservedTokenDto::new(
crate::WSOL_MINT_ID.to_string(),
Some("WSOL".to_string()),
Some("Wrapped SOL".to_string()),
Some(9),
crate::SPL_TOKEN_PROGRAM_ID.to_string(),
crate::KbObservedTokenStatus::Active,
crate::ObservedTokenStatus::Active,
);
let inserted_id = crate::upsert_observed_token(&database, &dto)
let inserted_id = crate::query_observed_tokens_upsert(&database, &dto)
.await
.expect("upsert must succeed");
assert!(inserted_id > 0);
let fetched = crate::get_observed_token_by_mint(
&database,
"So11111111111111111111111111111111111111112",
)
.await
.expect("fetch must succeed");
let fetched = crate::query_observed_tokens_get_by_mint(&database, crate::WSOL_MINT_ID)
.await
.expect("fetch must succeed");
assert!(fetched.is_some());
let fetched = fetched.expect("token must exist");
assert_eq!(fetched.symbol.as_deref(), Some("WSOL"));
assert_eq!(fetched.decimals, Some(9));
assert_eq!(fetched.status, crate::KbObservedTokenStatus::Active);
let listed = crate::list_observed_tokens(&database, 10).await.expect("list must succeed");
assert_eq!(fetched.status, crate::ObservedTokenStatus::Active);
let listed = crate::query_observed_tokens_list(&database, 10)
.await
.expect("list must succeed");
assert_eq!(listed.len(), 1);
}
}

60
kb_lib/src/db/queries/onchain_observation.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/onchain_observation.rs
//! Queries for `kb_onchain_observations`.
//! Queries for `k_sol_onchain_observations`.
/// Inserts one on-chain observation row and returns its numeric id.
pub async fn insert_onchain_observation(
database: &crate::KbDatabase,
dto: &crate::KbOnchainObservationDto,
) -> Result<i64, crate::KbError> {
pub async fn query_onchain_observations_insert(
database: &crate::Database,
dto: &crate::OnchainObservationDto,
) -> Result<i64, crate::Error> {
let payload_json_result = serde_json::to_string(&dto.payload);
let payload_json = match payload_json_result {
Ok(payload_json) => payload_json,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot serialize on-chain observation payload: {}",
error
)));
@@ -23,7 +23,7 @@ pub async fn insert_onchain_observation(
match slot_result {
Ok(slot) => Some(slot),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert on-chain observation slot '{}' to i64: {}",
slot, error
)));
@@ -33,10 +33,10 @@ pub async fn insert_onchain_observation(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_onchain_observations (
INSERT INTO k_sol_onchain_observations (
observation_kind,
source_kind,
endpoint_name,
@@ -60,8 +60,8 @@ VALUES (?, ?, ?, ?, ?, ?, ?)
let query_result = match query_result {
Ok(query_result) => query_result,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot insert kb_onchain_observations on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot insert k_sol_onchain_observations on sqlite: {}",
error
)));
},
@@ -72,16 +72,16 @@ VALUES (?, ?, ?, ?, ?, ?, ?)
}
/// Lists recent on-chain observations ordered from newest to oldest.
pub async fn list_recent_onchain_observations(
database: &crate::KbDatabase,
pub async fn query_onchain_observations_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbOnchainObservationDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::OnchainObservationDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbOnchainObservationEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::OnchainObservationEntity>(
r#"
SELECT
id,
@@ -92,7 +92,7 @@ SELECT
slot,
payload_json,
observed_at
FROM kb_onchain_observations
FROM k_sol_onchain_observations
ORDER BY id DESC
LIMIT ?
"#,
@@ -103,7 +103,7 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot list on-chain observations on sqlite: {}",
error
)));
@@ -111,7 +111,7 @@ LIMIT ?
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbOnchainObservationDto::try_from(entity);
let dto_result = crate::OnchainObservationDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -129,10 +129,10 @@ mod tests {
async fn onchain_observation_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("onchain_observation.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,
@@ -141,30 +141,30 @@ 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 dto = crate::KbOnchainObservationDto::new(
let dto = crate::OnchainObservationDto::new(
"token_discovered".to_string(),
crate::KbObservationSourceKind::WsRpc,
crate::ObservationSourceKind::WsRpc,
Some("mainnet_public_ws_slots".to_string()),
"So11111111111111111111111111111111111111112".to_string(),
crate::WSOL_MINT_ID.to_string(),
Some(123456u64),
serde_json::json!({
"mint": "So11111111111111111111111111111111111111112",
"mint": crate::WSOL_MINT_ID,
"source": "ws"
}),
);
let inserted_id = crate::insert_onchain_observation(&database, &dto)
let inserted_id = crate::query_onchain_observations_insert(&database, &dto)
.await
.expect("insert must succeed");
assert!(inserted_id > 0);
let listed = crate::list_recent_onchain_observations(&database, 10)
let listed = crate::query_onchain_observations_list_recent(&database, 10)
.await
.expect("list must succeed");
assert_eq!(listed.len(), 1);
assert_eq!(listed[0].observation_kind, "token_discovered");
assert_eq!(listed[0].source_kind, crate::KbObservationSourceKind::WsRpc);
assert_eq!(listed[0].source_kind, crate::ObservationSourceKind::WsRpc);
assert_eq!(listed[0].slot, Some(123456u64));
}
}

114
kb_lib/src/db/queries/pair.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/pair.rs
//! Queries for `kb_pairs`.
//! Queries for `k_sol_pairs`.
/// Inserts or updates one normalized pair row by pool id.
pub async fn upsert_pair(
database: &crate::KbDatabase,
dto: &crate::KbPairDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pairs_upsert(
database: &crate::Database,
dto: &crate::PairDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pairs (
INSERT INTO k_sol_pairs (
dex_id,
pool_id,
base_token_id,
@@ -28,7 +28,7 @@ ON CONFLICT(pool_id) DO UPDATE SET
symbol = CASE
WHEN excluded.symbol IS NOT NULL AND trim(excluded.symbol) <> ''
THEN excluded.symbol
ELSE kb_pairs.symbol
ELSE k_sol_pairs.symbol
END,
updated_at = excluded.updated_at
"#,
@@ -43,15 +43,15 @@ ON CONFLICT(pool_id) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pairs on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pairs on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pairs
FROM k_sol_pairs
WHERE pool_id = ?
LIMIT 1
"#,
@@ -62,8 +62,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pairs id for pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pairs id for pool_id '{}' on sqlite: {}",
dto.pool_id, error
)));
},
@@ -73,13 +73,13 @@ LIMIT 1
}
/// Reads one normalized pair row by pool id.
pub async fn get_pair_by_pool_id(
database: &crate::KbDatabase,
pub async fn query_pairs_get_by_pool_id(
database: &crate::Database,
pool_id: i64,
) -> Result<std::option::Option<crate::KbPairDto>, crate::KbError> {
) -> Result<std::option::Option<crate::PairDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairEntity>(
r#"
SELECT
id,
@@ -90,7 +90,7 @@ SELECT
symbol,
first_seen_at,
updated_at
FROM kb_pairs
FROM k_sol_pairs
WHERE pool_id = ?
LIMIT 1
"#,
@@ -101,15 +101,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_pairs by pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_pairs by pool_id '{}' on sqlite: {}",
pool_id, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbPairDto::try_from(entity);
let dto_result = crate::PairDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -122,16 +122,16 @@ LIMIT 1
}
/// Updates the display symbol of one normalized pair row.
pub async fn update_pair_symbol(
database: &crate::KbDatabase,
pub async fn query_pairs_update_symbol(
database: &crate::Database,
pair_id: i64,
symbol: std::option::Option<&str>,
) -> Result<bool, crate::KbError> {
) -> Result<bool, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
UPDATE kb_pairs
UPDATE k_sol_pairs
SET
symbol = ?,
updated_at = ?
@@ -146,8 +146,8 @@ WHERE id = ?
match query_result {
Ok(done) => return Ok(done.rows_affected() > 0),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot update kb_pairs symbol for id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot update k_sol_pairs symbol for id '{}' on sqlite: {}",
pair_id, error
)));
},
@@ -157,12 +157,12 @@ WHERE id = ?
}
/// Lists normalized pairs ordered by id ascending.
pub async fn list_pairs(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbPairDto>, crate::KbError> {
pub async fn query_pairs_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::PairDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairEntity>(
r#"
SELECT
id,
@@ -173,7 +173,7 @@ SELECT
symbol,
first_seen_at,
updated_at
FROM kb_pairs
FROM k_sol_pairs
ORDER BY id ASC
"#,
)
@@ -182,15 +182,15 @@ ORDER BY id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pairs on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pairs on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPairDto::try_from(entity);
let dto_result = crate::PairDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -208,10 +208,10 @@ mod tests {
async fn pair_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("pair_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,
@@ -220,18 +220,18 @@ 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 base_token_id = crate::upsert_token(
let base_token_id = crate::query_tokens_upsert(
&database,
&crate::KbTokenDto::new(
&crate::TokenDto::new(
"Base111111111111111111111111111111111111111".to_string(),
Some("BASE".to_string()),
Some("Base Token".to_string()),
@@ -242,10 +242,10 @@ mod tests {
)
.await
.expect("base token upsert must succeed");
let quote_token_id = crate::upsert_token(
let quote_token_id = crate::query_tokens_upsert(
&database,
&crate::KbTokenDto::new(
"So11111111111111111111111111111111111111112".to_string(),
&crate::TokenDto::new(
crate::WSOL_MINT_ID.to_string(),
Some("WSOL".to_string()),
Some("Wrapped SOL".to_string()),
Some(9),
@@ -255,20 +255,20 @@ mod tests {
)
.await
.expect("quote token 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");
let pair_id = crate::upsert_pair(
let pair_id = crate::query_pairs_upsert(
&database,
&crate::KbPairDto::new(
&crate::PairDto::new(
dex_id,
pool_id,
base_token_id,
@@ -279,12 +279,12 @@ mod tests {
.await
.expect("pair upsert must succeed");
assert!(pair_id > 0);
let pair = crate::get_pair_by_pool_id(&database, pool_id)
let pair = crate::query_pairs_get_by_pool_id(&database, pool_id)
.await
.expect("get pair must succeed");
assert!(pair.is_some());
assert_eq!(pair.expect("pair must exist").symbol.as_deref(), Some("BASE/WSOL"));
let pairs = crate::list_pairs(&database).await.expect("list pairs must succeed");
let pairs = crate::query_pairs_list(&database).await.expect("list pairs must succeed");
assert_eq!(pairs.len(), 1);
}
}

62
kb_lib/src/db/queries/pair_analytic_signal.rs
View File

@@ -1,27 +1,27 @@
// file: kb_lib/src/db/queries/pair_analytic_signal.rs
//! Queries for `kb_pair_analytic_signals`.
//! Queries for `k_sol_pair_analytic_signals`.
/// Inserts or updates one pair-analytic-signal row and returns its stable internal id.
pub async fn upsert_pair_analytic_signal(
database: &crate::KbDatabase,
dto: &crate::KbPairAnalyticSignalDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pair_analytic_signals_upsert(
database: &crate::Database,
dto: &crate::PairAnalyticSignalDto,
) -> Result<i64, crate::Error> {
let signal_value_json_result = serde_json::to_string(&dto.signal_value);
let signal_value_json = match signal_value_json_result {
Ok(signal_value_json) => signal_value_json,
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot serialize pair analytic signal payload: {}",
error
)));
},
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pair_analytic_signals (
INSERT INTO k_sol_pair_analytic_signals (
pair_id,
signal_kind,
severity,
@@ -57,15 +57,15 @@ ON CONFLICT(pair_id, signal_kind, timeframe_seconds, bucket_start_unix) DO UPDAT
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pair_analytic_signals on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pair_analytic_signals on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pair_analytic_signals
FROM k_sol_pair_analytic_signals
WHERE pair_id = ? AND signal_kind = ? AND timeframe_seconds = ? AND bucket_start_unix = ?
LIMIT 1
"#,
@@ -79,8 +79,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pair_analytic_signals id on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pair_analytic_signals id on sqlite: {}",
error
)));
},
@@ -90,16 +90,16 @@ LIMIT 1
}
/// Returns one pair-analytic-signal row identified by its key, if it exists.
pub async fn get_pair_analytic_signal_by_key(
database: &crate::KbDatabase,
pub async fn query_pair_analytic_signals_get_by_key(
database: &crate::Database,
pair_id: i64,
signal_kind: &str,
timeframe_seconds: i64,
bucket_start_unix: i64,
) -> Result<std::option::Option<crate::KbPairAnalyticSignalDto>, crate::KbError> {
) -> Result<std::option::Option<crate::PairAnalyticSignalDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairAnalyticSignalEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairAnalyticSignalEntity>(
r#"
SELECT
id,
@@ -114,7 +114,7 @@ SELECT
last_transaction_id,
created_at,
updated_at
FROM kb_pair_analytic_signals
FROM k_sol_pair_analytic_signals
WHERE pair_id = ? AND signal_kind = ? AND timeframe_seconds = ? AND bucket_start_unix = ?
LIMIT 1
"#,
@@ -128,14 +128,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_pair_analytic_signals by key on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_pair_analytic_signals by key on sqlite: {}",
error
)));
},
};
match entity_option {
Some(entity) => return crate::KbPairAnalyticSignalDto::try_from(entity).map(Some),
Some(entity) => return crate::PairAnalyticSignalDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -143,13 +143,13 @@ LIMIT 1
}
/// Lists all pair-analytic signals for one pair ordered by key.
pub async fn list_pair_analytic_signals_by_pair_id(
database: &crate::KbDatabase,
pub async fn query_pair_analytic_signals_list_by_pair_id(
database: &crate::Database,
pair_id: i64,
) -> Result<std::vec::Vec<crate::KbPairAnalyticSignalDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::PairAnalyticSignalDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairAnalyticSignalEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairAnalyticSignalEntity>(
r#"
SELECT
id,
@@ -164,7 +164,7 @@ SELECT
last_transaction_id,
created_at,
updated_at
FROM kb_pair_analytic_signals
FROM k_sol_pair_analytic_signals
WHERE pair_id = ?
ORDER BY timeframe_seconds ASC, bucket_start_unix ASC, signal_kind ASC, id ASC
"#,
@@ -175,15 +175,15 @@ ORDER BY timeframe_seconds ASC, bucket_start_unix ASC, signal_kind ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pair_analytic_signals by pair_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pair_analytic_signals by pair_id '{}' on sqlite: {}",
pair_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPairAnalyticSignalDto::try_from(entity);
let dto_result = crate::PairAnalyticSignalDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

60
kb_lib/src/db/queries/pair_candle.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/pair_candle.rs
//! Queries for `kb_pair_candles`.
//! Queries for `k_sol_pair_candles`.
/// Inserts or updates one pair-candle row and returns its stable internal id.
pub async fn upsert_pair_candle(
database: &crate::KbDatabase,
dto: &crate::KbPairCandleDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pair_candles_upsert(
database: &crate::Database,
dto: &crate::PairCandleDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pair_candles (
INSERT INTO k_sol_pair_candles (
pair_id,
timeframe_seconds,
bucket_start_unix,
@@ -67,8 +67,8 @@ ON CONFLICT(pair_id, timeframe_seconds, bucket_start_unix) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pair_candles on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pair_candles on sqlite: {}",
error
)));
}
@@ -76,7 +76,7 @@ ON CONFLICT(pair_id, timeframe_seconds, bucket_start_unix) DO UPDATE SET
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pair_candles
FROM k_sol_pair_candles
WHERE pair_id = ? AND timeframe_seconds = ? AND bucket_start_unix = ?
LIMIT 1
"#,
@@ -89,8 +89,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pair_candles id for pair_id '{}' timeframe '{}' bucket '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pair_candles id for pair_id '{}' timeframe '{}' bucket '{}' on sqlite: {}",
dto.pair_id, dto.timeframe_seconds, dto.bucket_start_unix, error
)));
},
@@ -100,15 +100,15 @@ LIMIT 1
}
/// Returns one pair-candle row identified by `(pair_id, timeframe_seconds, bucket_start_unix)`.
pub async fn get_pair_candle_by_key(
database: &crate::KbDatabase,
pub async fn query_pair_candles_get_by_key(
database: &crate::Database,
pair_id: i64,
timeframe_seconds: i64,
bucket_start_unix: i64,
) -> Result<std::option::Option<crate::KbPairCandleDto>, crate::KbError> {
) -> Result<std::option::Option<crate::PairCandleDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairCandleEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairCandleEntity>(
r#"
SELECT
id,
@@ -129,7 +129,7 @@ SELECT
last_trade_signature,
created_at,
updated_at
FROM kb_pair_candles
FROM k_sol_pair_candles
WHERE pair_id = ? AND timeframe_seconds = ? AND bucket_start_unix = ?
LIMIT 1
"#,
@@ -142,14 +142,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_pair_candles by key on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_pair_candles by key on sqlite: {}",
error
)));
},
};
match entity_option {
Some(entity) => return crate::KbPairCandleDto::try_from(entity).map(Some),
Some(entity) => return crate::PairCandleDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -157,14 +157,14 @@ LIMIT 1
}
/// Lists candles for one pair and one timeframe ordered by bucket start.
pub async fn list_pair_candles_by_pair_and_timeframe(
database: &crate::KbDatabase,
pub async fn query_pair_candles_list_by_pair_and_timeframe(
database: &crate::Database,
pair_id: i64,
timeframe_seconds: i64,
) -> Result<std::vec::Vec<crate::KbPairCandleDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::PairCandleDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairCandleEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairCandleEntity>(
r#"
SELECT
id,
@@ -185,7 +185,7 @@ SELECT
last_trade_signature,
created_at,
updated_at
FROM kb_pair_candles
FROM k_sol_pair_candles
WHERE pair_id = ? AND timeframe_seconds = ?
ORDER BY bucket_start_unix ASC, id ASC
"#,
@@ -197,15 +197,15 @@ ORDER BY bucket_start_unix ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pair_candles by pair_id '{}' timeframe '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pair_candles by pair_id '{}' timeframe '{}' on sqlite: {}",
pair_id, timeframe_seconds, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPairCandleDto::try_from(entity);
let dto_result = crate::PairCandleDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

60
kb_lib/src/db/queries/pair_metric.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/pair_metric.rs
//! Queries for `kb_pair_metrics`.
//! Queries for `k_sol_pair_metrics`.
/// Inserts or updates one pair-metric row and returns its stable internal id.
pub async fn upsert_pair_metric(
database: &crate::KbDatabase,
dto: &crate::KbPairMetricDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pair_metrics_upsert(
database: &crate::Database,
dto: &crate::PairMetricDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pair_metrics (
INSERT INTO k_sol_pair_metrics (
pair_id,
first_slot,
last_slot,
@@ -57,15 +57,15 @@ ON CONFLICT(pair_id) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pair_metrics on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pair_metrics on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pair_metrics
FROM k_sol_pair_metrics
WHERE pair_id = ?
LIMIT 1
"#,
@@ -76,8 +76,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pair_metrics id for pair_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pair_metrics id for pair_id '{}' on sqlite: {}",
dto.pair_id, error
)));
},
@@ -87,13 +87,13 @@ LIMIT 1
}
/// Returns one pair-metric row identified by its pair id, if it exists.
pub async fn get_pair_metric_by_pair_id(
database: &crate::KbDatabase,
pub async fn query_pair_metrics_get_by_pair_id(
database: &crate::Database,
pair_id: i64,
) -> Result<std::option::Option<crate::KbPairMetricDto>, crate::KbError> {
) -> Result<std::option::Option<crate::PairMetricDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairMetricEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairMetricEntity>(
r#"
SELECT
id,
@@ -110,7 +110,7 @@ SELECT
last_price_quote_per_base,
created_at,
updated_at
FROM kb_pair_metrics
FROM k_sol_pair_metrics
WHERE pair_id = ?
LIMIT 1
"#,
@@ -121,14 +121,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_pair_metrics by pair_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_pair_metrics by pair_id '{}' on sqlite: {}",
pair_id, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbPairMetricDto::try_from(entity).map(Some),
Some(entity) => return crate::PairMetricDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -136,12 +136,12 @@ LIMIT 1
}
/// Lists all pair-metric rows ordered by pair id.
pub async fn list_pair_metrics(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbPairMetricDto>, crate::KbError> {
pub async fn query_pair_metrics_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::PairMetricDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPairMetricEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PairMetricEntity>(
r#"
SELECT
id,
@@ -158,7 +158,7 @@ SELECT
last_price_quote_per_base,
created_at,
updated_at
FROM kb_pair_metrics
FROM k_sol_pair_metrics
ORDER BY pair_id ASC
"#,
)
@@ -167,15 +167,15 @@ ORDER BY pair_id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pair_metrics on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pair_metrics on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPairMetricDto::try_from(entity);
let dto_result = crate::PairMetricDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

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);
}
}

106
kb_lib/src/db/queries/pool_listing.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/pool_listing.rs
//! Queries for `kb_pool_listings`.
//! Queries for `k_sol_pool_listings`.
/// Inserts or updates one normalized pool listing row by pool id.
pub async fn upsert_pool_listing(
database: &crate::KbDatabase,
dto: &crate::KbPoolListingDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pool_listings_upsert(
database: &crate::Database,
dto: &crate::PoolListingDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pool_listings (
INSERT INTO k_sol_pool_listings (
dex_id,
pool_id,
pair_id,
@@ -49,15 +49,15 @@ ON CONFLICT(pool_id) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pool_listings on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pool_listings on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pool_listings
FROM k_sol_pool_listings
WHERE pool_id = ?
LIMIT 1
"#,
@@ -68,8 +68,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pool_listings id for pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pool_listings id for pool_id '{}' on sqlite: {}",
dto.pool_id, error
)));
},
@@ -79,13 +79,13 @@ LIMIT 1
}
/// Reads one normalized pool listing row by pool id.
pub async fn get_pool_listing_by_pool_id(
database: &crate::KbDatabase,
pub async fn query_pool_listings_get_by_pool_id(
database: &crate::Database,
pool_id: i64,
) -> Result<std::option::Option<crate::KbPoolListingDto>, crate::KbError> {
) -> Result<std::option::Option<crate::PoolListingDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPoolListingEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PoolListingEntity>(
r#"
SELECT
id,
@@ -99,7 +99,7 @@ SELECT
initial_quote_reserve,
initial_price_quote,
updated_at
FROM kb_pool_listings
FROM k_sol_pool_listings
WHERE pool_id = ?
LIMIT 1
"#,
@@ -110,15 +110,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_pool_listings by pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_pool_listings by pool_id '{}' on sqlite: {}",
pool_id, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbPoolListingDto::try_from(entity);
let dto_result = crate::PoolListingDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -131,12 +131,12 @@ LIMIT 1
}
/// Lists normalized pool listings ordered by detected date then id.
pub async fn list_pool_listings(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbPoolListingDto>, crate::KbError> {
pub async fn query_pool_listings_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::PoolListingDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPoolListingEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PoolListingEntity>(
r#"
SELECT
id,
@@ -150,7 +150,7 @@ SELECT
initial_quote_reserve,
initial_price_quote,
updated_at
FROM kb_pool_listings
FROM k_sol_pool_listings
ORDER BY detected_at ASC, id ASC
"#,
)
@@ -159,15 +159,15 @@ ORDER BY detected_at ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pool_listings on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pool_listings on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPoolListingDto::try_from(entity);
let dto_result = crate::PoolListingDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -185,10 +185,10 @@ mod tests {
async fn pool_listing_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("pool_listing_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,
@@ -197,18 +197,18 @@ 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 base_token_id = crate::upsert_token(
let base_token_id = crate::query_tokens_upsert(
&database,
&crate::KbTokenDto::new(
&crate::TokenDto::new(
"Base111111111111111111111111111111111111111".to_string(),
Some("BASE".to_string()),
Some("Base Token".to_string()),
@@ -219,10 +219,10 @@ mod tests {
)
.await
.expect("base token upsert must succeed");
let quote_token_id = crate::upsert_token(
let quote_token_id = crate::query_tokens_upsert(
&database,
&crate::KbTokenDto::new(
"So11111111111111111111111111111111111111112".to_string(),
&crate::TokenDto::new(
crate::WSOL_MINT_ID.to_string(),
Some("WSOL".to_string()),
Some("Wrapped SOL".to_string()),
Some(9),
@@ -232,20 +232,20 @@ mod tests {
)
.await
.expect("quote token 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");
let pair_id = crate::upsert_pair(
let pair_id = crate::query_pairs_upsert(
&database,
&crate::KbPairDto::new(
&crate::PairDto::new(
dex_id,
pool_id,
base_token_id,
@@ -255,13 +255,13 @@ mod tests {
)
.await
.expect("pair upsert must succeed");
let pool_listing_id = crate::upsert_pool_listing(
let pool_listing_id = crate::query_pool_listings_upsert(
&database,
&crate::KbPoolListingDto::new(
&crate::PoolListingDto::new(
dex_id,
pool_id,
Some(pair_id),
crate::KbObservationSourceKind::WsRpc,
crate::ObservationSourceKind::WsRpc,
Some("mainnet_public_ws_slots".to_string()),
Some(1000.0),
Some(10.0),
@@ -271,15 +271,15 @@ mod tests {
.await
.expect("pool listing upsert must succeed");
assert!(pool_listing_id > 0);
let pool_listing = crate::get_pool_listing_by_pool_id(&database, pool_id)
let pool_listing = crate::query_pool_listings_get_by_pool_id(&database, pool_id)
.await
.expect("get pool listing must succeed");
assert!(pool_listing.is_some());
assert_eq!(
pool_listing.expect("pool listing must exist").source_kind,
crate::KbObservationSourceKind::WsRpc
crate::ObservationSourceKind::WsRpc
);
let pool_listings = crate::list_pool_listings(&database)
let pool_listings = crate::query_pool_listings_list(&database)
.await
.expect("list pool listings must succeed");
assert_eq!(pool_listings.len(), 1);

66
kb_lib/src/db/queries/pool_origin.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/pool_origin.rs
//! Queries for `kb_pool_origins`.
//! Queries for `k_sol_pool_origins`.
/// Inserts or updates one pool-origin row and returns its stable internal id.
pub async fn upsert_pool_origin(
database: &crate::KbDatabase,
dto: &crate::KbPoolOriginDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pool_origins_upsert(
database: &crate::Database,
dto: &crate::PoolOriginDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pool_origins (
INSERT INTO k_sol_pool_origins (
dex_id,
pool_id,
pair_id,
@@ -29,9 +29,9 @@ INSERT INTO kb_pool_origins (
)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
ON CONFLICT(pool_id) DO UPDATE SET
pair_id = COALESCE(kb_pool_origins.pair_id, excluded.pair_id),
pool_listing_id = COALESCE(kb_pool_origins.pool_listing_id, excluded.pool_listing_id),
launch_attribution_id = COALESCE(kb_pool_origins.launch_attribution_id, excluded.launch_attribution_id),
pair_id = COALESCE(k_sol_pool_origins.pair_id, excluded.pair_id),
pool_listing_id = COALESCE(k_sol_pool_origins.pool_listing_id, excluded.pool_listing_id),
launch_attribution_id = COALESCE(k_sol_pool_origins.launch_attribution_id, excluded.launch_attribution_id),
updated_at = excluded.updated_at
"#,
)
@@ -52,15 +52,15 @@ ON CONFLICT(pool_id) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pool_origins on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pool_origins on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pool_origins
FROM k_sol_pool_origins
WHERE pool_id = ?
LIMIT 1
"#,
@@ -71,8 +71,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pool_origins id for pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pool_origins id for pool_id '{}' on sqlite: {}",
dto.pool_id, error
)));
},
@@ -82,13 +82,13 @@ LIMIT 1
}
/// Returns one pool-origin row identified by its pool id, if it exists.
pub async fn get_pool_origin_by_pool_id(
database: &crate::KbDatabase,
pub async fn query_pool_origins_get_by_pool_id(
database: &crate::Database,
pool_id: i64,
) -> Result<std::option::Option<crate::KbPoolOriginDto>, crate::KbError> {
) -> Result<std::option::Option<crate::PoolOriginDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPoolOriginEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PoolOriginEntity>(
r#"
SELECT
id,
@@ -106,7 +106,7 @@ SELECT
launch_attribution_id,
created_at,
updated_at
FROM kb_pool_origins
FROM k_sol_pool_origins
WHERE pool_id = ?
LIMIT 1
"#,
@@ -117,14 +117,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_pool_origins by pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_pool_origins by pool_id '{}' on sqlite: {}",
pool_id, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbPoolOriginDto::try_from(entity).map(Some),
Some(entity) => return crate::PoolOriginDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -132,12 +132,12 @@ LIMIT 1
}
/// Lists all pool-origin rows ordered by creation time then id.
pub async fn list_pool_origins(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbPoolOriginDto>, crate::KbError> {
pub async fn query_pool_origins_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::PoolOriginDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPoolOriginEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PoolOriginEntity>(
r#"
SELECT
id,
@@ -155,7 +155,7 @@ SELECT
launch_attribution_id,
created_at,
updated_at
FROM kb_pool_origins
FROM k_sol_pool_origins
ORDER BY created_at ASC, id ASC
"#,
)
@@ -164,15 +164,15 @@ ORDER BY created_at ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pool_origins on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pool_origins on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPoolOriginDto::try_from(entity);
let dto_result = crate::PoolOriginDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

76
kb_lib/src/db/queries/pool_token.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/pool_token.rs
//! Queries for `kb_pool_tokens`.
//! Queries for `k_sol_pool_tokens`.
/// Inserts or updates one normalized pool token composition row.
pub async fn upsert_pool_token(
database: &crate::KbDatabase,
dto: &crate::KbPoolTokenDto,
) -> Result<i64, crate::KbError> {
pub async fn query_pool_tokens_upsert(
database: &crate::Database,
dto: &crate::PoolTokenDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_pool_tokens (
INSERT INTO k_sol_pool_tokens (
pool_id,
token_id,
role,
@@ -37,15 +37,15 @@ ON CONFLICT(pool_id, token_id, role) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_pool_tokens on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_pool_tokens on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_pool_tokens
FROM k_sol_pool_tokens
WHERE pool_id = ? AND token_id = ? AND role = ?
LIMIT 1
"#,
@@ -58,8 +58,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_pool_tokens id on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_pool_tokens id on sqlite: {}",
error
)));
},
@@ -69,13 +69,13 @@ LIMIT 1
}
/// Lists normalized pool token rows by pool id.
pub async fn list_pool_tokens_by_pool_id(
database: &crate::KbDatabase,
pub async fn query_pool_tokens_list_by_pool_id(
database: &crate::Database,
pool_id: i64,
) -> Result<std::vec::Vec<crate::KbPoolTokenDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::PoolTokenDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbPoolTokenEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::PoolTokenEntity>(
r#"
SELECT
id,
@@ -86,7 +86,7 @@ SELECT
token_order,
created_at,
updated_at
FROM kb_pool_tokens
FROM k_sol_pool_tokens
WHERE pool_id = ?
ORDER BY token_order ASC, id ASC
"#,
@@ -97,15 +97,15 @@ ORDER BY token_order ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_pool_tokens for pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_pool_tokens for pool_id '{}' on sqlite: {}",
pool_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbPoolTokenDto::try_from(entity);
let dto_result = crate::PoolTokenDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -123,10 +123,10 @@ mod tests {
async fn pool_token_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("pool_token_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,
@@ -135,18 +135,18 @@ 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 token_id = crate::upsert_token(
let token_id = crate::query_tokens_upsert(
&database,
&crate::KbTokenDto::new(
&crate::TokenDto::new(
"Base111111111111111111111111111111111111111".to_string(),
Some("BASE".to_string()),
Some("Base Token".to_string()),
@@ -157,23 +157,23 @@ mod tests {
)
.await
.expect("token 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");
let pool_token_id = crate::upsert_pool_token(
let pool_token_id = crate::query_pool_tokens_upsert(
&database,
&crate::KbPoolTokenDto::new(
&crate::PoolTokenDto::new(
pool_id,
token_id,
crate::KbPoolTokenRole::Base,
crate::PoolTokenRole::Base,
Some("Vault111111111111111111111111111111111111".to_string()),
Some(0),
),
@@ -181,10 +181,10 @@ mod tests {
.await
.expect("pool token upsert must succeed");
assert!(pool_token_id > 0);
let pool_tokens = crate::list_pool_tokens_by_pool_id(&database, pool_id)
let pool_tokens = crate::query_pool_tokens_list_by_pool_id(&database, pool_id)
.await
.expect("list pool tokens must succeed");
assert_eq!(pool_tokens.len(), 1);
assert_eq!(pool_tokens[0].role, crate::KbPoolTokenRole::Base);
assert_eq!(pool_tokens[0].role, crate::PoolTokenRole::Base);
}
}

44
kb_lib/src/db/queries/swap.rs
View File

@@ -1,19 +1,19 @@
// file: kb_lib/src/db/queries/swap.rs
//! Queries for `kb_swaps`.
//! Queries for `k_sol_swaps`.
/// Inserts or updates one normalized swap row.
pub async fn upsert_swap(
database: &crate::KbDatabase,
dto: &crate::KbSwapDto,
) -> Result<i64, crate::KbError> {
pub async fn query_swaps_upsert(
database: &crate::Database,
dto: &crate::SwapDto,
) -> Result<i64, crate::Error> {
let slot_i64 = match dto.slot {
Some(slot) => {
let slot_result = i64::try_from(slot);
match slot_result {
Ok(slot) => Some(slot),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert swap slot '{}' to i64: {}",
slot, error
)));
@@ -23,10 +23,10 @@ pub async fn upsert_swap(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_swaps (
INSERT INTO k_sol_swaps (
dex_id,
pool_id,
pair_id,
@@ -75,15 +75,15 @@ ON CONFLICT(signature, instruction_index) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_swaps on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_swaps on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_swaps
FROM k_sol_swaps
WHERE signature = ? AND instruction_index = ?
LIMIT 1
"#,
@@ -95,8 +95,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_swaps id for signature '{}' and instruction_index '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_swaps id for signature '{}' and instruction_index '{}' on sqlite: {}",
dto.signature, dto.instruction_index, error
)));
},
@@ -106,16 +106,16 @@ LIMIT 1
}
/// Lists recent swaps ordered from newest to oldest.
pub async fn list_recent_swaps(
database: &crate::KbDatabase,
pub async fn query_swaps_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbSwapDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::SwapDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbSwapEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::SwapEntity>(
r#"
SELECT
id,
@@ -133,7 +133,7 @@ SELECT
price_quote,
trade_side,
executed_at
FROM kb_swaps
FROM k_sol_swaps
ORDER BY id DESC
LIMIT ?
"#,
@@ -144,15 +144,15 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_swaps on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_swaps on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbSwapDto::try_from(entity);
let dto_result = crate::SwapDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

121
kb_lib/src/db/queries/token.rs
View File

@@ -1,18 +1,18 @@
// file: kb_lib/src/db/queries/token.rs
//! Queries for `kb_tokens`.
//! Queries for `k_sol_tokens`.
/// Inserts or updates one normalized token row by mint.
pub async fn upsert_token(
database: &crate::KbDatabase,
dto: &crate::KbTokenDto,
) -> Result<i64, crate::KbError> {
pub async fn query_tokens_upsert(
database: &crate::Database,
dto: &crate::TokenDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let decimals = dto.decimals.map(i64::from);
let query_result = sqlx::query(
r#"
INSERT INTO kb_tokens (
INSERT INTO k_sol_tokens (
mint,
symbol,
name,
@@ -43,15 +43,15 @@ ON CONFLICT(mint) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_tokens on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_tokens on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_tokens
FROM k_sol_tokens
WHERE mint = ?
LIMIT 1
"#,
@@ -62,8 +62,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_tokens id for mint '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_tokens id for mint '{}' on sqlite: {}",
dto.mint, error
)));
},
@@ -73,13 +73,13 @@ LIMIT 1
}
/// Reads one normalized token row by mint.
pub async fn get_token_by_mint(
database: &crate::KbDatabase,
pub async fn query_tokens_get_by_mint(
database: &crate::Database,
mint: &str,
) -> Result<std::option::Option<crate::KbTokenDto>, crate::KbError> {
) -> Result<std::option::Option<crate::TokenDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTokenEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TokenEntity>(
r#"
SELECT
id,
@@ -91,7 +91,7 @@ SELECT
is_quote_token,
first_seen_at,
updated_at
FROM kb_tokens
FROM k_sol_tokens
WHERE mint = ?
LIMIT 1
"#,
@@ -102,15 +102,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_tokens '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_tokens '{}' on sqlite: {}",
mint, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbTokenDto::try_from(entity);
let dto_result = crate::TokenDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -123,13 +123,13 @@ LIMIT 1
}
/// Reads one normalized token row by internal id.
pub async fn get_token_by_id(
database: &crate::KbDatabase,
pub async fn query_tokens_get_by_id(
database: &crate::Database,
token_id: i64,
) -> Result<std::option::Option<crate::KbTokenDto>, crate::KbError> {
) -> Result<std::option::Option<crate::TokenDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTokenEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TokenEntity>(
r#"
SELECT
id,
@@ -141,7 +141,7 @@ SELECT
is_quote_token,
first_seen_at,
updated_at
FROM kb_tokens
FROM k_sol_tokens
WHERE id = ?
LIMIT 1
"#,
@@ -152,15 +152,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_tokens id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_tokens id '{}' on sqlite: {}",
token_id, error
)));
},
};
match entity_option {
Some(entity) => {
let dto_result = crate::KbTokenDto::try_from(entity);
let dto_result = crate::TokenDto::try_from(entity);
match dto_result {
Ok(dto) => return Ok(Some(dto)),
Err(error) => return Err(error),
@@ -173,12 +173,12 @@ LIMIT 1
}
/// Lists all normalized token rows ordered by mint.
pub async fn list_tokens(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbTokenDto>, crate::KbError> {
pub async fn query_tokens_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::TokenDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTokenEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TokenEntity>(
r#"
SELECT
id,
@@ -190,7 +190,7 @@ SELECT
is_quote_token,
first_seen_at,
updated_at
FROM kb_tokens
FROM k_sol_tokens
ORDER BY mint ASC, id ASC
"#,
)
@@ -199,15 +199,15 @@ ORDER BY mint ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_tokens on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_tokens on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbTokenDto::try_from(entity);
let dto_result = crate::TokenDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -220,15 +220,15 @@ ORDER BY mint ASC, id ASC
}
/// Lists token rows whose display or mint metadata is incomplete.
pub async fn list_tokens_missing_metadata(
database: &crate::KbDatabase,
pub async fn query_tokens_list_missing_metadata(
database: &crate::Database,
limit: std::option::Option<i64>,
) -> Result<std::vec::Vec<crate::KbTokenDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::TokenDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let entities_result = match limit {
Some(limit) => {
sqlx::query_as::<sqlx::Sqlite, crate::KbTokenEntity>(
sqlx::query_as::<sqlx::Sqlite, crate::TokenEntity>(
r#"
SELECT
id,
@@ -240,7 +240,7 @@ SELECT
is_quote_token,
first_seen_at,
updated_at
FROM kb_tokens
FROM k_sol_tokens
WHERE symbol IS NULL
OR trim(symbol) = ''
OR name IS NULL
@@ -257,7 +257,7 @@ LIMIT ?
.await
},
None => {
sqlx::query_as::<sqlx::Sqlite, crate::KbTokenEntity>(
sqlx::query_as::<sqlx::Sqlite, crate::TokenEntity>(
r#"
SELECT
id,
@@ -269,7 +269,7 @@ SELECT
is_quote_token,
first_seen_at,
updated_at
FROM kb_tokens
FROM k_sol_tokens
WHERE symbol IS NULL
OR trim(symbol) = ''
OR name IS NULL
@@ -287,15 +287,15 @@ ORDER BY updated_at ASC, id ASC
let entities = match entities_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_tokens missing metadata on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_tokens missing metadata on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbTokenDto::try_from(entity);
let dto_result = crate::TokenDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -309,17 +309,17 @@ ORDER BY updated_at ASC, id ASC
#[cfg(test)]
mod tests {
async fn make_database() -> std::sync::Arc<crate::KbDatabase> {
async fn make_database() -> std::sync::Arc<crate::Database> {
let tempdir_result = tempfile::tempdir();
let tempdir = match tempdir_result {
Ok(tempdir) => tempdir,
Err(error) => panic!("tempdir must succeed: {}", error),
};
let database_path = tempdir.path().join("token_query.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,
@@ -328,7 +328,7 @@ mod tests {
use_wal: true,
},
};
let database_result = crate::KbDatabase::connect_and_initialize(&config).await;
let database_result = crate::Database::connect_and_initialize(&config).await;
let database = match database_result {
Ok(database) => database,
Err(error) => panic!("database init must succeed: {}", error),
@@ -339,7 +339,7 @@ mod tests {
#[tokio::test]
async fn list_tokens_missing_metadata_only_returns_incomplete_rows() {
let database = make_database().await;
let incomplete = crate::KbTokenDto::new(
let incomplete = crate::TokenDto::new(
"IncompleteMint111".to_string(),
None,
None,
@@ -347,7 +347,7 @@ mod tests {
crate::SPL_TOKEN_PROGRAM_ID.to_string(),
false,
);
let complete = crate::KbTokenDto::new(
let complete = crate::TokenDto::new(
"CompleteMint111".to_string(),
Some("CMP".to_string()),
Some("Complete".to_string()),
@@ -355,15 +355,16 @@ mod tests {
crate::SPL_TOKEN_PROGRAM_ID.to_string(),
false,
);
let incomplete_result = crate::upsert_token(database.as_ref(), &incomplete).await;
let incomplete_result = crate::query_tokens_upsert(database.as_ref(), &incomplete).await;
if let Err(error) = incomplete_result {
panic!("incomplete token upsert must succeed: {}", error);
}
let complete_result = crate::upsert_token(database.as_ref(), &complete).await;
let complete_result = crate::query_tokens_upsert(database.as_ref(), &complete).await;
if let Err(error) = complete_result {
panic!("complete token upsert must succeed: {}", error);
}
let missing_result = crate::list_tokens_missing_metadata(database.as_ref(), None).await;
let missing_result =
crate::query_tokens_list_missing_metadata(database.as_ref(), None).await;
let missing = match missing_result {
Ok(missing) => missing,
Err(error) => panic!("missing metadata list must succeed: {}", error),

108
kb_lib/src/db/queries/token_burn_event.rs
View File

@@ -1,19 +1,19 @@
// file: kb_lib/src/db/queries/token_burn_event.rs
//! Queries for `kb_token_burn_events`.
//! Queries for `k_sol_token_burn_events`.
/// Inserts or updates one normalized token burn event row.
pub async fn upsert_token_burn_event(
database: &crate::KbDatabase,
dto: &crate::KbTokenBurnEventDto,
) -> Result<i64, crate::KbError> {
pub async fn query_token_burn_events_upsert(
database: &crate::Database,
dto: &crate::TokenBurnEventDto,
) -> Result<i64, crate::Error> {
let slot_i64 = match dto.slot {
Some(slot) => {
let slot_result = i64::try_from(slot);
match slot_result {
Ok(slot) => Some(slot),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert token burn event slot '{}' to i64: {}",
slot, error
)));
@@ -23,10 +23,10 @@ pub async fn upsert_token_burn_event(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_token_burn_events (
INSERT INTO k_sol_token_burn_events (
token_id,
signature,
instruction_index,
@@ -60,15 +60,15 @@ ON CONFLICT(signature, instruction_index) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_token_burn_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_token_burn_events on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_token_burn_events
FROM k_sol_token_burn_events
WHERE signature = ? AND instruction_index = ?
LIMIT 1
"#,
@@ -80,8 +80,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_token_burn_events id for signature '{}' and instruction_index '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_token_burn_events id for signature '{}' and instruction_index '{}' on sqlite: {}",
dto.signature, dto.instruction_index, error
)));
},
@@ -91,16 +91,16 @@ LIMIT 1
}
/// Lists recent token burn events ordered from newest to oldest.
pub async fn list_recent_token_burn_events(
database: &crate::KbDatabase,
pub async fn query_token_burn_events_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbTokenBurnEventDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::TokenBurnEventDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTokenBurnEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TokenBurnEventEntity>(
r#"
SELECT
id,
@@ -113,7 +113,7 @@ SELECT
amount,
supply_after,
executed_at
FROM kb_token_burn_events
FROM k_sol_token_burn_events
ORDER BY id DESC
LIMIT ?
"#,
@@ -124,15 +124,15 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_token_burn_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_token_burn_events on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbTokenBurnEventDto::try_from(entity);
let dto_result = crate::TokenBurnEventDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -150,10 +150,10 @@ mod tests {
async fn normalized_activity_roundtrip_works() {
let tempdir = tempfile::tempdir().expect("tempdir must succeed");
let database_path = tempdir.path().join("normalized_activity.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,
@@ -162,18 +162,18 @@ 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 base_token_id = crate::upsert_token(
let base_token_id = crate::query_tokens_upsert(
&database,
&crate::KbTokenDto::new(
&crate::TokenDto::new(
"Base111111111111111111111111111111111111111".to_string(),
Some("BASE".to_string()),
Some("Base Token".to_string()),
@@ -184,10 +184,10 @@ mod tests {
)
.await
.expect("base token upsert must succeed");
let quote_token_id = crate::upsert_token(
let quote_token_id = crate::query_tokens_upsert(
&database,
&crate::KbTokenDto::new(
"So11111111111111111111111111111111111111112".to_string(),
&crate::TokenDto::new(
crate::WSOL_MINT_ID.to_string(),
Some("WSOL".to_string()),
Some("Wrapped SOL".to_string()),
Some(9),
@@ -197,20 +197,20 @@ mod tests {
)
.await
.expect("quote token 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");
let pair_id = crate::upsert_pair(
let pair_id = crate::query_pairs_upsert(
&database,
&crate::KbPairDto::new(
&crate::PairDto::new(
dex_id,
pool_id,
base_token_id,
@@ -220,9 +220,9 @@ mod tests {
)
.await
.expect("pair upsert must succeed");
let swap_id = crate::upsert_swap(
let swap_id = crate::query_swaps_upsert(
&database,
&crate::KbSwapDto::new(
&crate::SwapDto::new(
dex_id,
pool_id,
Some(pair_id),
@@ -235,21 +235,21 @@ mod tests {
"1000.50".to_string(),
"2.75".to_string(),
Some("0.002748625687156422".to_string()),
crate::KbSwapTradeSide::BuyBase,
crate::SwapTradeSide::BuyBase,
),
)
.await
.expect("swap upsert must succeed");
let liquidity_id = crate::upsert_liquidity_event(
let liquidity_id = crate::query_liquidity_events_upsert(
&database,
&crate::KbLiquidityEventDto::new(
&crate::LiquidityEventDto::new(
dex_id,
pool_id,
Some(pair_id),
"liq-signature-1".to_string(),
1,
Some(1001),
crate::KbLiquidityEventKind::Add,
crate::LiquidityEventKind::Add,
Some("LpUser1111111111111111111111111111111111".to_string()),
base_token_id,
quote_token_id,
@@ -261,9 +261,9 @@ mod tests {
)
.await
.expect("liquidity event upsert must succeed");
let mint_id = crate::upsert_token_mint_event(
let mint_id = crate::query_token_mint_events_upsert(
&database,
&crate::KbTokenMintEventDto::new(
&crate::TokenMintEventDto::new(
base_token_id,
"mint-signature-1".to_string(),
2,
@@ -276,9 +276,9 @@ mod tests {
)
.await
.expect("token mint event upsert must succeed");
let burn_id = crate::upsert_token_burn_event(
let burn_id = crate::query_token_burn_events_upsert(
&database,
&crate::KbTokenBurnEventDto::new(
&crate::TokenBurnEventDto::new(
base_token_id,
"burn-signature-1".to_string(),
3,
@@ -295,14 +295,16 @@ mod tests {
assert!(liquidity_id > 0);
assert!(mint_id > 0);
assert!(burn_id > 0);
let swaps = crate::list_recent_swaps(&database, 10).await.expect("swaps list must succeed");
let liquidity_events = crate::list_recent_liquidity_events(&database, 10)
let swaps = crate::query_swaps_list_recent(&database, 10)
.await
.expect("swaps list must succeed");
let liquidity_events = crate::query_liquidity_events_list_recent(&database, 10)
.await
.expect("liquidity list must succeed");
let mint_events = crate::list_recent_token_mint_events(&database, 10)
let mint_events = crate::query_token_mint_events_list_recent(&database, 10)
.await
.expect("mint events list must succeed");
let burn_events = crate::list_recent_token_burn_events(&database, 10)
let burn_events = crate::query_token_burn_events_list_recent(&database, 10)
.await
.expect("burn events list must succeed");
assert_eq!(swaps.len(), 1);

44
kb_lib/src/db/queries/token_mint_event.rs
View File

@@ -1,19 +1,19 @@
// file: kb_lib/src/db/queries/token_mint_event.rs
//! Queries for `kb_token_mint_events`.
//! Queries for `k_sol_token_mint_events`.
/// Inserts or updates one normalized token mint event row.
pub async fn upsert_token_mint_event(
database: &crate::KbDatabase,
dto: &crate::KbTokenMintEventDto,
) -> Result<i64, crate::KbError> {
pub async fn query_token_mint_events_upsert(
database: &crate::Database,
dto: &crate::TokenMintEventDto,
) -> Result<i64, crate::Error> {
let slot_i64 = match dto.slot {
Some(slot) => {
let slot_result = i64::try_from(slot);
match slot_result {
Ok(slot) => Some(slot),
Err(error) => {
return Err(crate::KbError::Db(format!(
return Err(crate::Error::Db(format!(
"cannot convert token mint event slot '{}' to i64: {}",
slot, error
)));
@@ -23,10 +23,10 @@ pub async fn upsert_token_mint_event(
None => None,
};
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_token_mint_events (
INSERT INTO k_sol_token_mint_events (
token_id,
signature,
instruction_index,
@@ -60,15 +60,15 @@ ON CONFLICT(signature, instruction_index) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_token_mint_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_token_mint_events on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_token_mint_events
FROM k_sol_token_mint_events
WHERE signature = ? AND instruction_index = ?
LIMIT 1
"#,
@@ -80,8 +80,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_token_mint_events id for signature '{}' and instruction_index '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_token_mint_events id for signature '{}' and instruction_index '{}' on sqlite: {}",
dto.signature, dto.instruction_index, error
)));
},
@@ -91,16 +91,16 @@ LIMIT 1
}
/// Lists recent token mint events ordered from newest to oldest.
pub async fn list_recent_token_mint_events(
database: &crate::KbDatabase,
pub async fn query_token_mint_events_list_recent(
database: &crate::Database,
limit: u32,
) -> Result<std::vec::Vec<crate::KbTokenMintEventDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::TokenMintEventDto>, crate::Error> {
if limit == 0 {
return Ok(std::vec::Vec::new());
}
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTokenMintEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TokenMintEventEntity>(
r#"
SELECT
id,
@@ -113,7 +113,7 @@ SELECT
amount,
supply_after,
executed_at
FROM kb_token_mint_events
FROM k_sol_token_mint_events
ORDER BY id DESC
LIMIT ?
"#,
@@ -124,15 +124,15 @@ LIMIT ?
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_token_mint_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_token_mint_events on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbTokenMintEventDto::try_from(entity);
let dto_result = crate::TokenMintEventDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

98
kb_lib/src/db/queries/trade_event.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/trade_event.rs
//! Queries for `kb_trade_events`.
//! Queries for `k_sol_trade_events`.
/// Inserts or updates one trade-event row and returns its stable internal id.
pub async fn upsert_trade_event(
database: &crate::KbDatabase,
dto: &crate::KbTradeEventDto,
) -> Result<i64, crate::KbError> {
pub async fn query_trade_events_upsert(
database: &crate::Database,
dto: &crate::TradeEventDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_trade_events (
INSERT INTO k_sol_trade_events (
dex_id,
pool_id,
pair_id,
@@ -38,15 +38,15 @@ ON CONFLICT(decoded_event_id) DO UPDATE SET
pair_id = excluded.pair_id,
transaction_id = excluded.transaction_id,
signature = excluded.signature,
slot = COALESCE(excluded.slot, kb_trade_events.slot),
slot = COALESCE(excluded.slot, k_sol_trade_events.slot),
trade_side = excluded.trade_side,
base_token_id = excluded.base_token_id,
quote_token_id = excluded.quote_token_id,
base_amount_raw = COALESCE(excluded.base_amount_raw, kb_trade_events.base_amount_raw),
quote_amount_raw = COALESCE(excluded.quote_amount_raw, kb_trade_events.quote_amount_raw),
price_quote_per_base = COALESCE(excluded.price_quote_per_base, kb_trade_events.price_quote_per_base),
base_amount_raw = COALESCE(excluded.base_amount_raw, k_sol_trade_events.base_amount_raw),
quote_amount_raw = COALESCE(excluded.quote_amount_raw, k_sol_trade_events.quote_amount_raw),
price_quote_per_base = COALESCE(excluded.price_quote_per_base, k_sol_trade_events.price_quote_per_base),
source_kind = excluded.source_kind,
source_endpoint_name = COALESCE(excluded.source_endpoint_name, kb_trade_events.source_endpoint_name),
source_endpoint_name = COALESCE(excluded.source_endpoint_name, k_sol_trade_events.source_endpoint_name),
payload_json = excluded.payload_json,
updated_at = excluded.updated_at
"#,
@@ -58,7 +58,7 @@ ON CONFLICT(decoded_event_id) DO UPDATE SET
.bind(dto.decoded_event_id)
.bind(dto.signature.clone())
.bind(dto.slot)
.bind(kb_trade_side_to_string(dto.trade_side))
.bind(trade_side_to_string(dto.trade_side))
.bind(dto.base_token_id)
.bind(dto.quote_token_id)
.bind(dto.base_amount_raw.clone())
@@ -72,8 +72,8 @@ ON CONFLICT(decoded_event_id) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_trade_events on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_trade_events on sqlite: {}",
error
)));
}
@@ -81,7 +81,7 @@ ON CONFLICT(decoded_event_id) DO UPDATE SET
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_trade_events
FROM k_sol_trade_events
WHERE decoded_event_id = ?
LIMIT 1
"#,
@@ -92,8 +92,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_trade_events id for decoded_event_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_trade_events id for decoded_event_id '{}' on sqlite: {}",
dto.decoded_event_id, error
)));
},
@@ -103,13 +103,13 @@ LIMIT 1
}
/// Returns one trade-event row identified by its decoded-event id, if it exists.
pub async fn get_trade_event_by_decoded_event_id(
database: &crate::KbDatabase,
pub async fn query_trade_events_get_by_decoded_event_id(
database: &crate::Database,
decoded_event_id: i64,
) -> Result<std::option::Option<crate::KbTradeEventDto>, crate::KbError> {
) -> Result<std::option::Option<crate::TradeEventDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTradeEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TradeEventEntity>(
r#"
SELECT
id,
@@ -131,7 +131,7 @@ SELECT
payload_json,
created_at,
updated_at
FROM kb_trade_events
FROM k_sol_trade_events
WHERE decoded_event_id = ?
LIMIT 1
"#,
@@ -142,14 +142,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_trade_events by decoded_event_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_trade_events by decoded_event_id '{}' on sqlite: {}",
decoded_event_id, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbTradeEventDto::try_from(entity).map(Some),
Some(entity) => return crate::TradeEventDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -157,13 +157,13 @@ LIMIT 1
}
/// Lists trade-event rows for one pair id ordered by creation time then id.
pub async fn list_trade_events_by_pair_id(
database: &crate::KbDatabase,
pub async fn query_trade_events_list_by_pair_id(
database: &crate::Database,
pair_id: i64,
) -> Result<std::vec::Vec<crate::KbTradeEventDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::TradeEventDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTradeEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TradeEventEntity>(
r#"
SELECT
id,
@@ -185,7 +185,7 @@ SELECT
payload_json,
created_at,
updated_at
FROM kb_trade_events
FROM k_sol_trade_events
WHERE pair_id = ?
ORDER BY created_at ASC, id ASC
"#,
@@ -196,15 +196,15 @@ ORDER BY created_at ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_trade_events by pair_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_trade_events by pair_id '{}' on sqlite: {}",
pair_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbTradeEventDto::try_from(entity);
let dto_result = crate::TradeEventDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -217,13 +217,13 @@ ORDER BY created_at ASC, id ASC
}
/// Lists trade-event rows for one transaction id ordered by id.
pub async fn list_trade_events_by_transaction_id(
database: &crate::KbDatabase,
pub async fn query_trade_events_list_by_transaction_id(
database: &crate::Database,
transaction_id: i64,
) -> Result<std::vec::Vec<crate::KbTradeEventDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::TradeEventDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbTradeEventEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::TradeEventEntity>(
r#"
SELECT
id,
@@ -245,7 +245,7 @@ SELECT
payload_json,
created_at,
updated_at
FROM kb_trade_events
FROM k_sol_trade_events
WHERE transaction_id = ?
ORDER BY id ASC
"#,
@@ -256,15 +256,15 @@ ORDER BY id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_trade_events by transaction_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_trade_events by transaction_id '{}' on sqlite: {}",
transaction_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbTradeEventDto::try_from(entity);
let dto_result = crate::TradeEventDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -276,10 +276,10 @@ ORDER BY id ASC
}
}
fn kb_trade_side_to_string(value: crate::KbSwapTradeSide) -> &'static str {
fn trade_side_to_string(value: crate::SwapTradeSide) -> &'static str {
match value {
crate::KbSwapTradeSide::BuyBase => return "BuyBase",
crate::KbSwapTradeSide::SellBase => return "SellBase",
crate::KbSwapTradeSide::Unknown => return "Unknown",
crate::SwapTradeSide::BuyBase => return "BuyBase",
crate::SwapTradeSide::SellBase => return "SellBase",
crate::SwapTradeSide::Unknown => return "Unknown",
}
}

62
kb_lib/src/db/queries/wallet.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/wallet.rs
//! Queries for `kb_wallets`.
//! Queries for `k_sol_wallets`.
/// Inserts or updates one wallet row and returns its stable internal id.
pub async fn upsert_wallet(
database: &crate::KbDatabase,
dto: &crate::KbWalletDto,
) -> Result<i64, crate::KbError> {
pub async fn query_wallets_upsert(
database: &crate::Database,
dto: &crate::WalletDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_wallets (
INSERT INTO k_sol_wallets (
address,
label,
first_seen_at,
@@ -19,7 +19,7 @@ INSERT INTO kb_wallets (
)
VALUES (?, ?, ?, ?)
ON CONFLICT(address) DO UPDATE SET
label = COALESCE(excluded.label, kb_wallets.label),
label = COALESCE(excluded.label, k_sol_wallets.label),
last_seen_at = excluded.last_seen_at
"#,
)
@@ -30,15 +30,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_wallets on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_wallets on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_wallets
FROM k_sol_wallets
WHERE address = ?
LIMIT 1
"#,
@@ -49,8 +49,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_wallets id for address '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_wallets id for address '{}' on sqlite: {}",
dto.address, error
)));
},
@@ -60,13 +60,13 @@ LIMIT 1
}
/// Returns one wallet identified by its address, if it exists.
pub async fn get_wallet_by_address(
database: &crate::KbDatabase,
pub async fn query_wallets_get_by_address(
database: &crate::Database,
address: &str,
) -> Result<std::option::Option<crate::KbWalletDto>, crate::KbError> {
) -> Result<std::option::Option<crate::WalletDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbWalletEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::WalletEntity>(
r#"
SELECT
id,
@@ -74,7 +74,7 @@ SELECT
label,
first_seen_at,
last_seen_at
FROM kb_wallets
FROM k_sol_wallets
WHERE address = ?
LIMIT 1
"#,
@@ -85,14 +85,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_wallets '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_wallets '{}' on sqlite: {}",
address, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbWalletDto::try_from(entity).map(Some),
Some(entity) => return crate::WalletDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -100,12 +100,12 @@ LIMIT 1
}
/// Lists all persisted wallets ordered by address.
pub async fn list_wallets(
database: &crate::KbDatabase,
) -> Result<std::vec::Vec<crate::KbWalletDto>, crate::KbError> {
pub async fn query_wallets_list(
database: &crate::Database,
) -> Result<std::vec::Vec<crate::WalletDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbWalletEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::WalletEntity>(
r#"
SELECT
id,
@@ -113,7 +113,7 @@ SELECT
label,
first_seen_at,
last_seen_at
FROM kb_wallets
FROM k_sol_wallets
ORDER BY address ASC
"#,
)
@@ -122,15 +122,15 @@ ORDER BY address ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_wallets on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_wallets on sqlite: {}",
error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbWalletDto::try_from(entity);
let dto_result = crate::WalletDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

62
kb_lib/src/db/queries/wallet_holding.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/wallet_holding.rs
//! Queries for `kb_wallet_holdings`.
//! Queries for `k_sol_wallet_holdings`.
/// Inserts or updates one wallet-holding row and returns its stable internal id.
pub async fn upsert_wallet_holding(
database: &crate::KbDatabase,
dto: &crate::KbWalletHoldingDto,
) -> Result<i64, crate::KbError> {
pub async fn query_wallet_holdings_upsert(
database: &crate::Database,
dto: &crate::WalletHoldingDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_wallet_holdings (
INSERT INTO k_sol_wallet_holdings (
wallet_id,
token_id,
first_transaction_id,
@@ -34,7 +34,7 @@ ON CONFLICT(wallet_id, token_id) DO UPDATE SET
last_pool_id = excluded.last_pool_id,
last_pair_id = excluded.last_pair_id,
last_role = excluded.last_role,
balance_raw = COALESCE(excluded.balance_raw, kb_wallet_holdings.balance_raw),
balance_raw = COALESCE(excluded.balance_raw, k_sol_wallet_holdings.balance_raw),
last_slot_observed = excluded.last_slot_observed,
source_kind = excluded.source_kind,
source_endpoint_name = excluded.source_endpoint_name,
@@ -58,15 +58,15 @@ ON CONFLICT(wallet_id, token_id) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_wallet_holdings on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_wallet_holdings on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_wallet_holdings
FROM k_sol_wallet_holdings
WHERE wallet_id = ? AND token_id = ?
LIMIT 1
"#,
@@ -78,8 +78,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_wallet_holdings id for wallet_id '{}' token_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_wallet_holdings id for wallet_id '{}' token_id '{}' on sqlite: {}",
dto.wallet_id, dto.token_id, error
)));
},
@@ -89,14 +89,14 @@ LIMIT 1
}
/// Returns one wallet-holding row identified by `(wallet_id, token_id)`, if it exists.
pub async fn get_wallet_holding_by_wallet_and_token(
database: &crate::KbDatabase,
pub async fn query_wallet_holdings_get_by_wallet_and_token(
database: &crate::Database,
wallet_id: i64,
token_id: i64,
) -> Result<std::option::Option<crate::KbWalletHoldingDto>, crate::KbError> {
) -> Result<std::option::Option<crate::WalletHoldingDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbWalletHoldingEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::WalletHoldingEntity>(
r#"
SELECT
id,
@@ -114,7 +114,7 @@ SELECT
source_endpoint_name,
created_at,
updated_at
FROM kb_wallet_holdings
FROM k_sol_wallet_holdings
WHERE wallet_id = ? AND token_id = ?
LIMIT 1
"#,
@@ -126,14 +126,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_wallet_holdings by wallet_id '{}' token_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_wallet_holdings by wallet_id '{}' token_id '{}' on sqlite: {}",
wallet_id, token_id, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbWalletHoldingDto::try_from(entity).map(Some),
Some(entity) => return crate::WalletHoldingDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -141,13 +141,13 @@ LIMIT 1
}
/// Lists wallet-holding rows for one wallet id.
pub async fn list_wallet_holdings_by_wallet_id(
database: &crate::KbDatabase,
pub async fn query_wallet_holdings_list_by_wallet_id(
database: &crate::Database,
wallet_id: i64,
) -> Result<std::vec::Vec<crate::KbWalletHoldingDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::WalletHoldingDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbWalletHoldingEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::WalletHoldingEntity>(
r#"
SELECT
id,
@@ -165,7 +165,7 @@ SELECT
source_endpoint_name,
created_at,
updated_at
FROM kb_wallet_holdings
FROM k_sol_wallet_holdings
WHERE wallet_id = ?
ORDER BY token_id ASC, id ASC
"#,
@@ -176,15 +176,15 @@ ORDER BY token_id ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_wallet_holdings by wallet_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_wallet_holdings by wallet_id '{}' on sqlite: {}",
wallet_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbWalletHoldingDto::try_from(entity);
let dto_result = crate::WalletHoldingDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),

78
kb_lib/src/db/queries/wallet_participation.rs
View File

@@ -1,17 +1,17 @@
// file: kb_lib/src/db/queries/wallet_participation.rs
//! Queries for `kb_wallet_participations`.
//! Queries for `k_sol_wallet_participations`.
/// Inserts or updates one wallet-participation row and returns its stable internal id.
pub async fn upsert_wallet_participation(
database: &crate::KbDatabase,
dto: &crate::KbWalletParticipationDto,
) -> Result<i64, crate::KbError> {
pub async fn query_wallet_participations_upsert(
database: &crate::Database,
dto: &crate::WalletParticipationDto,
) -> Result<i64, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query(
r#"
INSERT INTO kb_wallet_participations (
INSERT INTO k_sol_wallet_participations (
wallet_id,
transaction_id,
decoded_event_id,
@@ -43,15 +43,15 @@ ON CONFLICT(unique_key) DO UPDATE SET
.execute(pool)
.await;
if let Err(error) = query_result {
return Err(crate::KbError::Db(format!(
"cannot upsert kb_wallet_participations on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot upsert k_sol_wallet_participations on sqlite: {}",
error
)));
}
let id_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
r#"
SELECT id
FROM kb_wallet_participations
FROM k_sol_wallet_participations
WHERE unique_key = ?
LIMIT 1
"#,
@@ -62,8 +62,8 @@ LIMIT 1
match id_result {
Ok(id) => return Ok(id),
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot fetch kb_wallet_participations id for unique_key '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot fetch k_sol_wallet_participations id for unique_key '{}' on sqlite: {}",
dto.unique_key, error
)));
},
@@ -73,13 +73,13 @@ LIMIT 1
}
/// Returns one wallet-participation identified by its unique key, if it exists.
pub async fn get_wallet_participation_by_unique_key(
database: &crate::KbDatabase,
pub async fn query_wallet_participations_get_by_unique_key(
database: &crate::Database,
unique_key: &str,
) -> Result<std::option::Option<crate::KbWalletParticipationDto>, crate::KbError> {
) -> Result<std::option::Option<crate::WalletParticipationDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbWalletParticipationEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::WalletParticipationEntity>(
r#"
SELECT
id,
@@ -94,7 +94,7 @@ SELECT
source_endpoint_name,
created_at,
updated_at
FROM kb_wallet_participations
FROM k_sol_wallet_participations
WHERE unique_key = ?
LIMIT 1
"#,
@@ -105,14 +105,14 @@ LIMIT 1
let entity_option = match query_result {
Ok(entity_option) => entity_option,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot read kb_wallet_participations by unique_key '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot read k_sol_wallet_participations by unique_key '{}' on sqlite: {}",
unique_key, error
)));
},
};
match entity_option {
Some(entity) => return crate::KbWalletParticipationDto::try_from(entity).map(Some),
Some(entity) => return crate::WalletParticipationDto::try_from(entity).map(Some),
None => return Ok(None),
}
},
@@ -120,13 +120,13 @@ LIMIT 1
}
/// Lists wallet-participation rows for one wallet id.
pub async fn list_wallet_participations_by_wallet_id(
database: &crate::KbDatabase,
pub async fn query_wallet_participations_list_by_wallet_id(
database: &crate::Database,
wallet_id: i64,
) -> Result<std::vec::Vec<crate::KbWalletParticipationDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::WalletParticipationDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbWalletParticipationEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::WalletParticipationEntity>(
r#"
SELECT
id,
@@ -141,7 +141,7 @@ SELECT
source_endpoint_name,
created_at,
updated_at
FROM kb_wallet_participations
FROM k_sol_wallet_participations
WHERE wallet_id = ?
ORDER BY created_at ASC, id ASC
"#,
@@ -152,15 +152,15 @@ ORDER BY created_at ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_wallet_participations by wallet_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_wallet_participations by wallet_id '{}' on sqlite: {}",
wallet_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbWalletParticipationDto::try_from(entity);
let dto_result = crate::WalletParticipationDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),
@@ -173,13 +173,13 @@ ORDER BY created_at ASC, id ASC
}
/// Lists wallet-participation rows for one pool id.
pub async fn list_wallet_participations_by_pool_id(
database: &crate::KbDatabase,
pub async fn query_wallet_participations_list_by_pool_id(
database: &crate::Database,
pool_id: i64,
) -> Result<std::vec::Vec<crate::KbWalletParticipationDto>, crate::KbError> {
) -> Result<std::vec::Vec<crate::WalletParticipationDto>, crate::Error> {
match database.connection() {
crate::KbDatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbWalletParticipationEntity>(
crate::DatabaseConnection::Sqlite(pool) => {
let query_result = sqlx::query_as::<sqlx::Sqlite, crate::WalletParticipationEntity>(
r#"
SELECT
id,
@@ -194,7 +194,7 @@ SELECT
source_endpoint_name,
created_at,
updated_at
FROM kb_wallet_participations
FROM k_sol_wallet_participations
WHERE pool_id = ?
ORDER BY created_at ASC, id ASC
"#,
@@ -205,15 +205,15 @@ ORDER BY created_at ASC, id ASC
let entities = match query_result {
Ok(entities) => entities,
Err(error) => {
return Err(crate::KbError::Db(format!(
"cannot list kb_wallet_participations by pool_id '{}' on sqlite: {}",
return Err(crate::Error::Db(format!(
"cannot list k_sol_wallet_participations by pool_id '{}' on sqlite: {}",
pool_id, error
)));
},
};
let mut dtos = std::vec::Vec::new();
for entity in entities {
let dto_result = crate::KbWalletParticipationDto::try_from(entity);
let dto_result = crate::WalletParticipationDto::try_from(entity);
let dto = match dto_result {
Ok(dto) => dto,
Err(error) => return Err(error),