0.5.2

kb_lib/src/db/queries/observed_token.rs

@@ -0,0 +1,230 @@
+// file: kb_lib/src/db/queries/observed_token.rs
+
+//! Queries for `kb_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> {
+    match database.connection() {
+        crate::KbDatabaseConnection::Sqlite(pool) => {
+            let decimals_i64 = dto.decimals.map(i64::from);
+            let insert_result = sqlx::query(
+                r#"
+INSERT INTO kb_observed_tokens (
+    mint,
+    symbol,
+    name,
+    decimals,
+    token_program,
+    status,
+    first_seen_at,
+    last_seen_at,
+    updated_at
+)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+ON CONFLICT(mint) DO UPDATE SET
+    symbol = excluded.symbol,
+    name = excluded.name,
+    decimals = excluded.decimals,
+    token_program = excluded.token_program,
+    status = excluded.status,
+    last_seen_at = excluded.last_seen_at,
+    updated_at = excluded.updated_at
+                "#,
+            )
+            .bind(dto.mint.clone())
+            .bind(dto.symbol.clone())
+            .bind(dto.name.clone())
+            .bind(decimals_i64)
+            .bind(dto.token_program.clone())
+            .bind(dto.status.to_i16())
+            .bind(dto.first_seen_at.to_rfc3339())
+            .bind(dto.last_seen_at.to_rfc3339())
+            .bind(dto.updated_at.to_rfc3339())
+            .execute(pool)
+            .await;
+            if let Err(error) = insert_result {
+                return Err(crate::KbError::Db(format!(
+                    "cannot upsert kb_observed_tokens on sqlite: {}",
+                    error
+                )));
+            }
+            let select_result = sqlx::query_scalar::<sqlx::Sqlite, i64>(
+                r#"
+SELECT id
+FROM kb_observed_tokens
+WHERE mint = ?
+LIMIT 1
+                "#,
+            )
+            .bind(dto.mint.clone())
+            .fetch_one(pool)
+            .await;
+            match select_result {
+                Ok(id) => Ok(id),
+                Err(error) => Err(crate::KbError::Db(format!(
+                    "cannot fetch kb_observed_tokens id for mint '{}' on sqlite: {}",
+                    dto.mint, error
+                ))),
+            }
+        }
+    }
+}
+
+/// Reads one observed token by mint.
+pub async fn get_observed_token_by_mint(
+    database: &crate::KbDatabase,
+    mint: &str,
+) -> Result<std::option::Option<crate::KbObservedTokenDto>, crate::KbError> {
+    match database.connection() {
+        crate::KbDatabaseConnection::Sqlite(pool) => {
+            let query_result = sqlx::query_as::<sqlx::Sqlite, crate::KbObservedTokenEntity>(
+                r#"
+SELECT
+    id,
+    mint,
+    symbol,
+    name,
+    decimals,
+    token_program,
+    status,
+    first_seen_at,
+    last_seen_at,
+    updated_at
+FROM kb_observed_tokens
+WHERE mint = ?
+LIMIT 1
+                    "#,
+            )
+            .bind(mint)
+            .fetch_optional(pool)
+            .await;
+            let entity_option = match query_result {
+                Ok(entity_option) => entity_option,
+                Err(error) => {
+                    return Err(crate::KbError::Db(format!(
+                        "cannot read observed token '{}' on sqlite: {}",
+                        mint, error
+                    )));
+                }
+            };
+            match entity_option {
+                Some(entity) => {
+                    let dto_result = crate::KbObservedTokenDto::try_from(entity);
+                    match dto_result {
+                        Ok(dto) => Ok(Some(dto)),
+                        Err(error) => Err(error),
+                    }
+                }
+                None => Ok(None),
+            }
+        }
+    }
+}
+
+/// Lists observed tokens ordered by newest first.
+pub async fn list_observed_tokens(
+    database: &crate::KbDatabase,
+    limit: u32,
+) -> Result<std::vec::Vec<crate::KbObservedTokenDto>, crate::KbError> {
+    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>(
+                r#"
+SELECT
+    id,
+    mint,
+    symbol,
+    name,
+    decimals,
+    token_program,
+    status,
+    first_seen_at,
+    last_seen_at,
+    updated_at
+FROM kb_observed_tokens
+ORDER BY id DESC
+LIMIT ?
+                    "#,
+            )
+            .bind(i64::from(limit))
+            .fetch_all(pool)
+            .await;
+            let entities = match query_result {
+                Ok(entities) => entities,
+                Err(error) => {
+                    return Err(crate::KbError::Db(format!(
+                        "cannot list observed tokens on sqlite: {}",
+                        error
+                    )));
+                }
+            };
+            let mut dtos = std::vec::Vec::new();
+            for entity in entities {
+                let dto_result = crate::KbObservedTokenDto::try_from(entity);
+                let dto = match dto_result {
+                    Ok(dto) => dto,
+                    Err(error) => return Err(error),
+                };
+                dtos.push(dto);
+            }
+            Ok(dtos)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[tokio::test]
+    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 {
+            enabled: true,
+            backend: crate::KbDatabaseBackend::Sqlite,
+            sqlite: crate::KbSqliteDatabaseConfig {
+                path: database_path.to_string_lossy().to_string(),
+                create_if_missing: true,
+                busy_timeout_ms: 5000,
+                max_connections: 1,
+                auto_initialize_schema: true,
+                use_wal: true,
+            },
+        };
+        let database = crate::KbDatabase::connect_and_initialize(&config)
+            .await
+            .expect("database init must succeed");
+        let dto = crate::KbObservedTokenDto::new(
+            "So11111111111111111111111111111111111111112".to_string(),
+            Some("WSOL".to_string()),
+            Some("Wrapped SOL".to_string()),
+            Some(9),
+            crate::SPL_TOKEN_PROGRAM_ID.to_string(),
+            crate::KbObservedTokenStatus::Active,
+        );
+        let inserted_id = crate::upsert_observed_token(&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");
+        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!(listed.len(), 1);
+    }
+}