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

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