Create tags index for transactions

utxo/src/ledger.rs

@@ -1,6 +1,6 @@
 use crate::{
     amount::AmountCents, config::Config, status::StatusManager, storage::Storage,
-    transaction::Type, AccountId, Amount, Error, PaymentFrom, PaymentId, RevId, Status,
+    transaction::Type, AccountId, Amount, Error, PaymentFrom, PaymentId, RevId, Status, Tag,
     Transaction, TxId,
 };
 use std::{cmp::Ordering, collections::HashMap, sync::Arc};
@@ -317,7 +317,7 @@ where
     pub async fn set_tags(
         &self,
         transaction_id: &TxId,
-        tags: Vec<String>,
+        tags: Vec<Tag>,
         reason: String,
     ) -> Result<Transaction, Error> {
         Ok(self

utxo/src/storage/cache/batch.rs

@@ -2,7 +2,7 @@ use super::Storage;
 use crate::{
     payment::PaymentTo,
     storage::{Batch, Error, ReceivedPaymentStatus},
-    AccountId, BaseTx, PaymentId, RevId, Revision, TxId,
+    AccountId, BaseTx, PaymentId, RevId, Revision, Tag, TxId,
 };
 use std::{collections::HashMap, marker::PhantomData, sync::Arc};
 
@@ -170,11 +170,7 @@ where
             .await
     }
 
-    async fn tag_transaction(
-        &mut self,
-        transaction_id: &TxId,
-        tags: &[String],
-    ) -> Result<(), Error> {
+    async fn tag_transaction(&mut self, transaction_id: &TxId, tags: &[Tag]) -> Result<(), Error> {
         self.to_invalidate
             .insert(Ids::Transaction(transaction_id.clone()), ());
         self.inner.tag_transaction(transaction_id, tags).await

utxo/src/storage/cache/mod.rs

@@ -2,7 +2,7 @@
 use crate::{
     amount::AmountCents,
     storage::{self, Error, FilterId},
-    AccountId, Amount, Asset, BaseTx, PaymentFrom, PaymentId, RevId, Revision, TxId, Type,
+    AccountId, Amount, Asset, BaseTx, PaymentFrom, PaymentId, RevId, Revision, Tag, TxId, Type,
 };
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::RwLock;
@@ -173,7 +173,7 @@ where
         &self,
         account: &AccountId,
         types: &[Type],
-        tags: &[String],
+        tags: &[Tag],
     ) -> Result<Vec<(BaseTx, Revision)>, Error> {
         self.inner
             .get_transactions_with_latest_revision(account, types, tags)

utxo/src/storage/mod.rs

@@ -1,7 +1,7 @@
 //! Storage layer trait
 use crate::{
     amount::AmountCents, payment::PaymentTo, transaction::Type, AccountId, Amount, Asset, BaseTx,
-    PaymentFrom, PaymentId, RevId, Revision, Transaction, TxId,
+    PaymentFrom, PaymentId, RevId, Revision, Tag, Transaction, TxId,
 };
 //use chrono::{DateTime, Utc};
 use serde::Serialize;
@@ -232,11 +232,7 @@ pub trait Batch<'a> {
 
     /// Sets the tags for a given transaction. Any tag not included in this
     /// vector should be removed
-    async fn tag_transaction(
-        &mut self,
-        transaction_id: &TxId,
-        tags: &[String],
-    ) -> Result<(), Error>;
+    async fn tag_transaction(&mut self, transaction_id: &TxId, tags: &[Tag]) -> Result<(), Error>;
 
     /// Creates a relationship between an account and a transaction.
     ///
@@ -355,7 +351,7 @@ pub trait Storage {
         &self,
         account: &AccountId,
         types: &[Type],
-        tags: &[String],
+        tags: &[Tag],
     ) -> Result<Vec<(BaseTx, Revision)>, Error>;
 
     /// Returns a revision with a transaction object by id
@@ -375,7 +371,7 @@ pub trait Storage {
         &self,
         account: &AccountId,
         types: &[Type],
-        tags: &[String],
+        tags: &[Tag],
     ) -> Result<Vec<Transaction>, Error> {
         let mut transactions = Vec::new();
         for (base_tx, revision) in self

utxo/src/storage/sqlite/batch.rs

@@ -1,7 +1,7 @@
 use crate::{
     payment::PaymentTo,
     storage::{self, to_bytes, Error, ReceivedPaymentStatus},
-    AccountId, BaseTx, PaymentId, RevId, Revision, TxId, Type,
+    AccountId, BaseTx, PaymentId, RevId, Revision, Tag, TxId, Type,
 };
 use sqlx::{Row, Sqlite, Transaction as SqlxTransaction};
 use std::{marker::PhantomData, num::TryFromIntError};
@@ -307,11 +307,22 @@ impl<'a> storage::Batch<'a> for Batch<'a> {
         Ok(())
     }
 
-    async fn tag_transaction(
-        &mut self,
-        _transaction_id: &TxId,
-        _tags: &[String],
-    ) -> Result<(), Error> {
-        todo!()
+    async fn tag_transaction(&mut self, transaction_id: &TxId, tags: &[Tag]) -> Result<(), Error> {
+        sqlx::query(r#"DELETE FROM "transactions_by_tags" WHERE "transaction_id" = ? "#)
+            .bind(transaction_id.to_string())
+            .execute(&mut *self.inner)
+            .await
+            .map_err(|e| Error::Storage(e.to_string()))?;
+
+        for tag in tags {
+            sqlx::query(r#"INSERT INTO "transaction_by_tags" VALUES(?, ?)"#)
+                .bind(transaction_id.to_string())
+                .bind(tag.as_str())
+                .execute(&mut *self.inner)
+                .await
+                .map_err(|e| Error::Storage(e.to_string()))?;
+        }
+
+        Ok(())
     }
 }

utxo/src/storage/sqlite/mod.rs

@@ -3,7 +3,7 @@ use crate::{
     amount::AmountCents,
     storage::{Error, FilterId, Storage},
     transaction::{Revision, Type},
-    AccountId, Amount, Asset, BaseTx, PaymentFrom, PaymentId, RevId, TxId,
+    AccountId, Amount, Asset, BaseTx, PaymentFrom, PaymentId, RevId, Tag, TxId,
 };
 use borsh::from_slice;
 use futures::TryStreamExt;
@@ -59,6 +59,12 @@ impl SQLite {
             "blob" BINARY NOT NULL,
             "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP
         );
+        CREATE TABLE IF NOT EXISTS "transactions_by_tags" (
+            "transaction_id" VARCHAR(67),
+            "tag" VARCHAR(250) NOT NULL,
+            "created_at" DATETIME DEFAULT CURRENT_TIMESTAMP,
+            PRIMARY KEY ("transaction_id", "tag")
+        );
         CREATE TABLE IF NOT EXISTS "payments" (
             "payment_id" VARCHAR(80) NOT NULL PRIMARY KEY,
             "to" VARCHAR(64) NOT NULL,
@@ -305,18 +311,26 @@ impl Storage for SQLite {
 
         Ok(sqlx::query(
             r#"
-            SELECT "revision_id" FROM "revisions" WHERE "transaction_id" = ? ORDER BY "created_at" ASC
+            SELECT
+                "revision_id"
+            FROM
+                "revisions"
+            WHERE
+                "transaction_id" = ?
+            ORDER BY "created_at" ASC
             "#,
         )
         .bind(transaction_id.to_string())
         .fetch_all(&mut *conn)
         .await
         .map_err(|e| Error::Storage(e.to_string()))?
-        .into_iter().map(|x| {
-              x.try_get::<String, usize>(0)
+        .into_iter()
+        .map(|x| {
+            x.try_get::<String, usize>(0)
                 .map(|x| RevId::from_str(&x))
                 .map_err(|e| Error::Storage(e.to_string()))
-        }).collect::<Result<Result<Vec<_>, _>, _>>()??)
+        })
+        .collect::<Result<Result<Vec<_>, _>, _>>()??)
     }
 
     async fn get_transaction_and_revision(
@@ -381,7 +395,7 @@ impl Storage for SQLite {
         &self,
         account: &AccountId,
         types: &[Type],
-        _tags: &[String],
+        _tags: &[Tag],
     ) -> Result<Vec<(BaseTx, Revision)>, Error> {
         let mut conn = self
             .db

utxo/src/transaction/mod.rs

@@ -3,7 +3,7 @@ use crate::{
     payment::PaymentTo,
     status::InternalStatus,
     storage::{Batch, ReceivedPaymentStatus, Storage},
-    AccountId, Amount, PaymentFrom, RevId, Status, TxId,
+    AccountId, Amount, MaxLengthString, PaymentFrom, RevId, Status, TxId,
 };
 use chrono::{DateTime, TimeZone, Utc};
 use serde::{Deserialize, Serialize};
@@ -16,6 +16,9 @@ mod typ;
 
 pub use self::{base_tx::BaseTx, error::Error, revision::Revision, typ::Type};
 
+/// Tag definition
+pub type Tag = MaxLengthString<64>;
+
 pub(crate) fn to_ts_microseconds<W: std::io::Write>(
     dt: &DateTime<Utc>,
     writer: &mut W,
@@ -172,7 +175,7 @@ impl Transaction {
     pub async fn set_tags<S>(
         self,
         config: &Config<S>,
-        new_tags: Vec<String>,
+        new_tags: Vec<Tag>,
         reason: String,
     ) -> Result<Self, Error>
     where
@@ -307,22 +310,24 @@ impl Transaction {
 
         let (created_updated, spent_updated) =
             match config.status.internal_type(&self.revision.status) {
-                InternalStatus::Reverted => batch
-                    .update_transaction_payments(
-                        &self.id,
-                        ReceivedPaymentStatus::Failed,
-                        ReceivedPaymentStatus::Spendable,
-                    )
-                    .await
-                    .expect("foo0"),
-                InternalStatus::Spendable => batch
-                    .update_transaction_payments(
-                        &self.id,
-                        ReceivedPaymentStatus::Spendable,
-                        ReceivedPaymentStatus::Spent,
-                    )
-                    .await
-                    .expect("foo1"),
+                InternalStatus::Reverted => {
+                    batch
+                        .update_transaction_payments(
+                            &self.id,
+                            ReceivedPaymentStatus::Failed,
+                            ReceivedPaymentStatus::Spendable,
+                        )
+                        .await?
+                }
+                InternalStatus::Spendable => {
+                    batch
+                        .update_transaction_payments(
+                            &self.id,
+                            ReceivedPaymentStatus::Spendable,
+                            ReceivedPaymentStatus::Spent,
+                        )
+                        .await?
+                }
                 _ => (self.creates.len(), self.spends.len()),
             };
 
@@ -337,14 +342,15 @@ impl Transaction {
                     ReceivedPaymentStatus::Spendable,
                     ReceivedPaymentStatus::Spent,
                 )
-                .await
-                .expect("foo2");
+                .await?;
         }
 
         batch
             .store_revision(&self.revision_id, &self.revision)
             .await?;
 
+        batch.tag_transaction(&self.id, &self.revision.tags).await?;
+
         batch
             .update_transaction_revision(
                 &self.id,

utxo/src/transaction/revision.rs

@@ -1,4 +1,4 @@
-use crate::{transaction::Error, RevId, Status, TxId};
+use crate::{transaction::Error, RevId, Status, Tag, TxId};
 use chrono::{serde::ts_milliseconds, DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use sha2::{Digest, Sha256};
@@ -18,7 +18,7 @@ pub struct Revision {
     pub changelog: String,
 
     /// Vector of tags associated with a transaction
-    pub tags: Vec<String>,
+    pub tags: Vec<Tag>,
 
     /// Transaction status
     pub status: Status,
@@ -38,7 +38,7 @@ impl Revision {
         transaction_id: TxId,
         previous: Option<RevId>,
         changelog: String,
-        tags: Vec<String>,
+        tags: Vec<Tag>,
         status: Status,
     ) -> Self {
         Self {