task-012 (#2)

Co-authored-by: Joe Carstairs <jcarstairs@scottlogic.com>
Reviewed-on: https://git.joeac.net/joeac/schist/pulls/2
Co-authored-by: Joe Carstairs <me@joeac.net>
Co-committed-by: Joe Carstairs <me@joeac.net>

17 files changed, 602 insertions, 748 deletions

diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs
index a6c850e..d5f7e6f 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/schist_state.rs
@@ -1,7 +1,9 @@
 use anyhow::Result;
 use diesel::SqliteConnection;
 use schist_models::{
-    account::Account, account_transfer::AccountTransfer, budget_drip::BudgetDrip, bucket::Bucket, bucket_transfer::BucketTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation
+    account::Account, account_transfer::AccountTransfer, bucket::Bucket,
+    bucket_transfer::BucketTransfer, date_utc::DateUtc, drip::Drip, pipe::Pipe,
+    transaction::Transaction,
 };
 
 pub struct SchistState {
@@ -9,20 +11,32 @@ pub struct SchistState {
     pub accounts: Vec<Account>,
     pub account_transfers: Vec<AccountTransfer>,
     pub buckets: Vec<Bucket>,
-    pub budget_drips: Vec<BudgetDrip>,
+    pub budget_drips: Vec<Drip>,
     pub transactions: Vec<Transaction>,
-    pub transaction_categorisations: Vec<TransactionCategorisation>,
+    pub pipes: Vec<Pipe>,
     pub bucket_transfers: Vec<BucketTransfer>,
 }
 
-pub fn export_schist_state(schist_state: &SchistState, schist_connection: &mut SqliteConnection) -> Result<()> {
+pub fn export_schist_state(
+    schist_state: &SchistState,
+    schist_connection: &mut SqliteConnection,
+) -> Result<()> {
     schist_queries::clear::clear(schist_connection)?;
     schist_queries::accounts::insert_accounts(&schist_state.accounts, schist_connection)?;
-    schist_queries::account_transfers::insert_account_transfers(&schist_state.account_transfers, schist_connection)?;
+    schist_queries::account_transfers::insert_account_transfers(
+        &schist_state.account_transfers,
+        schist_connection,
+    )?;
     schist_queries::buckets::insert_buckets(&schist_state.buckets, schist_connection)?;
-    schist_queries::budget_drips::insert_budget_drips(&schist_state.budget_drips, schist_connection)?;
-    schist_queries::transactions::insert_transactions(&schist_state.transactions, schist_connection)?;
-    schist_queries::transaction_categorisations::insert_transaction_categorisations(&schist_state.transaction_categorisations, schist_connection)?;
-    schist_queries::bucket_transfers::insert_bucket_transfers(&schist_state.bucket_transfers, schist_connection)?;
+    schist_queries::drips::insert_drips(&schist_state.budget_drips, schist_connection)?;
+    schist_queries::transactions::insert_transactions(
+        &schist_state.transactions,
+        schist_connection,
+    )?;
+    schist_queries::pipes::insert_pipes(&schist_state.pipes, schist_connection)?;
+    schist_queries::bucket_transfers::insert_bucket_transfers(
+        &schist_state.bucket_transfers,
+        schist_connection,
+    )?;
     Ok(())
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/mod.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/mod.rs
index 8787699..5fadc2c 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/mod.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/mod.rs
@@ -9,17 +9,19 @@ mod transform_date;
 mod transform_id;
 mod transform_state;
 mod transform_transactions;
+mod transform_zero_budgets;
 
 use is_account_transfer::is_account_transfer;
 use is_account_transfer::is_not_account_transfer;
 use is_category_transfer::is_category_transfer;
 use is_category_transfer::is_not_category_transfer;
-use transform_accounts::transform_accounts;
 use transform_account_transfers::transform_account_transfers;
+use transform_accounts::transform_accounts;
 use transform_categories::transform_categories;
 use transform_category_transfers::transform_category_transfers;
 use transform_date::transform_date;
 use transform_id::transform_id;
 use transform_transactions::transform_transactions;
+use transform_zero_budgets::transform_zero_budgets;
 
 pub use transform_state::transform_state;
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_account_transfers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_account_transfers.rs
index a0c426d..3a9d4b2 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_account_transfers.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_account_transfers.rs
@@ -3,7 +3,10 @@ use anyhow::{Context, Result};
 use itertools::Itertools;
 use schist_models::account_transfer::AccountTransfer;
 
-use super::{is_account_transfer, is_not_account_transfer, transform_date::transform_date, transform_id::transform_id};
+use super::{
+    is_account_transfer, is_not_account_transfer, transform_date::transform_date,
+    transform_id::transform_id,
+};
 
 pub fn transform_account_transfers(
     actualbudget_transactions: &[ActualbudgetTransaction],
@@ -15,7 +18,10 @@ pub fn transform_account_transfers(
 pub fn transform_account_transfers_without_context(
     actualbudget_transactions: &[ActualbudgetTransaction],
 ) -> Result<(Vec<ActualbudgetTransaction>, Vec<AccountTransfer>)> {
-    let mut account_transfer_transaction_pairs: Vec<(ActualbudgetTransaction, ActualbudgetTransaction)> = Vec::new();
+    let mut account_transfer_transaction_pairs: Vec<(
+        ActualbudgetTransaction,
+        ActualbudgetTransaction,
+    )> = Vec::new();
     let mut transactions_not_transformed: Vec<ActualbudgetTransaction> = Vec::new();
     let account_transfer_transactions = actualbudget_transactions
         .iter()
@@ -28,9 +34,11 @@ pub fn transform_account_transfers_without_context(
             continue;
         }
 
-        let is_already_transformed = |t: &ActualbudgetTransaction|
+        let is_already_transformed = |t: &ActualbudgetTransaction| {
             account_transfer_transaction_pairs
-                .iter().any(|(t1, t2)| *t1 == *t || *t2 == *t);
+                .iter()
+                .any(|(t1, t2)| *t1 == *t || *t2 == *t)
+        };
 
         if is_already_transformed(actualbudget_transaction) {
             continue;
@@ -38,10 +46,12 @@ pub fn transform_account_transfers_without_context(
 
         let companion = account_transfer_transactions
             .clone()
-            .filter(|t| !is_already_transformed(t)
-                && t.date == actualbudget_transaction.date
-                && t.amount == -actualbudget_transaction.amount
-            ).last();
+            .filter(|t| {
+                !is_already_transformed(t)
+                    && t.date == actualbudget_transaction.date
+                    && t.amount == -actualbudget_transaction.amount
+            })
+            .last();
 
         if companion.is_none() {
             transactions_not_transformed.push(actualbudget_transaction.clone());
@@ -68,23 +78,31 @@ pub fn transform_account_transfers_without_context(
 }
 
 fn transform_account_transfer(
-    (actualbudget_transaction_from, actualbudget_transaction_to):
-        &(ActualbudgetTransaction, ActualbudgetTransaction),
+    (actualbudget_transaction_from, actualbudget_transaction_to): &(
+        ActualbudgetTransaction,
+        ActualbudgetTransaction,
+    ),
 ) -> Result<AccountTransfer> {
-    let context = || format!(
-        "failed to transform account transfer from transactions ({:?}, {:?})",
-        actualbudget_transaction_from,
-        actualbudget_transaction_to,
-    );
+    let context = || {
+        format!(
+            "failed to transform account transfer from transactions ({:?}, {:?})",
+            actualbudget_transaction_from, actualbudget_transaction_to,
+        )
+    };
 
     Ok(AccountTransfer {
         id: transform_id(&actualbudget_transaction_from.id),
-        date: transform_date(&actualbudget_transaction_from.date)
-            .with_context(context)?,
-        description: actualbudget_transaction_from.notes.clone().unwrap_or_else(||
-            actualbudget_transaction_to.notes.clone().unwrap_or_else(String::new)
-        ),
-        quantity: actualbudget_transaction_to.amount,
+        date: transform_date(&actualbudget_transaction_from.date).with_context(context)?,
+        description: actualbudget_transaction_from
+            .notes
+            .clone()
+            .unwrap_or_else(|| {
+                actualbudget_transaction_to
+                    .notes
+                    .clone()
+                    .unwrap_or_else(String::new)
+            }),
+        amount: actualbudget_transaction_to.amount,
         from_account_id: transform_id(actualbudget_transaction_from.account_id.as_str()),
         to_account_id: transform_id(actualbudget_transaction_to.account_id.as_str()),
     })
@@ -129,9 +147,12 @@ mod test {
         assert_eq!(0, remaining_transactions.len());
         assert_eq!(1, account_transfers.len());
         let account_transfer = account_transfers.get(0).unwrap();
-        assert_eq!("2024-08-01".parse::<DateUtc>().unwrap(), account_transfer.date);
+        assert_eq!(
+            "2024-08-01".parse::<DateUtc>().unwrap(),
+            account_transfer.date
+        );
         assert_eq!("My notes", account_transfer.description);
-        assert_eq!(100, account_transfer.quantity);
+        assert_eq!(100, account_transfer.amount);
         assert_eq!(transform_id("0"), account_transfer.from_account_id);
         assert_eq!(transform_id("1"), account_transfer.to_account_id);
     }
@@ -165,9 +186,12 @@ mod test {
         assert_eq!(0, remaining_transactions.len());
         assert_eq!(1, account_transfers.len());
         let account_transfer = account_transfers.get(0).unwrap();
-        assert_eq!("2024-08-01".parse::<DateUtc>().unwrap(), account_transfer.date);
+        assert_eq!(
+            "2024-08-01".parse::<DateUtc>().unwrap(),
+            account_transfer.date
+        );
         assert_eq!("My notes", account_transfer.description);
-        assert_eq!(100, account_transfer.quantity);
+        assert_eq!(100, account_transfer.amount);
         assert_eq!(transform_id("0"), account_transfer.from_account_id);
         assert_eq!(transform_id("1"), account_transfer.to_account_id);
     }
@@ -219,20 +243,26 @@ mod test {
 
         let account_transfer_0 = account_transfers
             .iter()
-            .filter(|at| at.quantity == 100)
+            .filter(|at| at.amount == 100)
             .last()
             .unwrap();
-        assert_eq!("2024-08-01".parse::<DateUtc>().unwrap(), account_transfer_0.date);
+        assert_eq!(
+            "2024-08-01".parse::<DateUtc>().unwrap(),
+            account_transfer_0.date
+        );
         assert_eq!(transform_id("0"), account_transfer_0.from_account_id);
         assert_eq!(transform_id("1"), account_transfer_0.to_account_id);
         assert_eq!("My notes 1", account_transfer_0.description);
 
         let account_transfer_1 = account_transfers
             .iter()
-            .filter(|at| at.quantity == 200)
+            .filter(|at| at.amount == 200)
             .last()
             .unwrap();
-        assert_eq!("2024-08-01".parse::<DateUtc>().unwrap(), account_transfer_1.date);
+        assert_eq!(
+            "2024-08-01".parse::<DateUtc>().unwrap(),
+            account_transfer_1.date
+        );
         assert_eq!(transform_id("0"), account_transfer_1.from_account_id);
         assert_eq!(transform_id("1"), account_transfer_1.to_account_id);
         assert_eq!("My notes 2", account_transfer_1.description);
@@ -288,7 +318,7 @@ mod test {
             .filter(|at| at.date == "2024-08-01".parse().unwrap())
             .last()
             .unwrap();
-        assert_eq!(100, account_transfer_0.quantity);
+        assert_eq!(100, account_transfer_0.amount);
         assert_eq!(transform_id("0"), account_transfer_0.from_account_id);
         assert_eq!(transform_id("1"), account_transfer_0.to_account_id);
         assert_eq!("My notes 1", account_transfer_0.description);
@@ -298,7 +328,7 @@ mod test {
             .filter(|at| at.date == "2024-08-02".parse().unwrap())
             .last()
             .unwrap();
-        assert_eq!(100, account_transfer_1.quantity);
+        assert_eq!(100, account_transfer_1.amount);
         assert_eq!(transform_id("0"), account_transfer_1.from_account_id);
         assert_eq!(transform_id("1"), account_transfer_1.to_account_id);
         assert_eq!("My notes 2", account_transfer_1.description);
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs
index 01289a0..6fd7610 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs
@@ -3,40 +3,46 @@ use std::hash::{DefaultHasher, Hash, Hasher};
 use actualbudget_models::ActualbudgetZeroBudget;
 use anyhow::{Context, Result};
 use itertools::Itertools;
-use schist_models::{budget_drip::BudgetDrip, date_utc::DateUtc};
+use schist_models::{date_utc::DateUtc, drip::Drip};
 use schist_traits::dateable::Dateable;
 
 use super::{transform_date::transform_date, transform_id::transform_id};
 
-pub fn transform_budget_drips(actualbudget_zero_budgets: &[ActualbudgetZeroBudget]) -> Result<Vec<BudgetDrip>> {
+pub fn transform_budget_drips(
+    actualbudget_zero_budgets: &[ActualbudgetZeroBudget],
+) -> Result<Vec<Drip>> {
     let non_zero_actualbudget_zero_budgets: Vec<ActualbudgetZeroBudget> = actualbudget_zero_budgets
         .iter()
         .filter(|zb| zb.amount != 0)
         .cloned()
         .collect();
 
-    let budget_drips = group_actualbudget_zero_budgets_by_category_id(
-            &non_zero_actualbudget_zero_budgets,
-        ).iter()
-        .map(sort_actualbudget_zero_budgets_by_month)
-        .flat_map(|sorted_actualbudget_zero_budgets| sorted_actualbudget_zero_budgets
+    let budget_drips =
+        group_actualbudget_zero_budgets_by_category_id(&non_zero_actualbudget_zero_budgets)
             .iter()
-            .map(map_actualbudget_zero_budget_to_budget_drips)
-            .collect::<Result<Vec<Vec<BudgetDrip>>>>()
-        ).flatten()
-        .flatten()
-        .filter(|bd| bd.quantity != 0)
-        .collect();
+            .map(sort_actualbudget_zero_budgets_by_month)
+            .flat_map(|sorted_actualbudget_zero_budgets| {
+                sorted_actualbudget_zero_budgets
+                    .iter()
+                    .map(map_actualbudget_zero_budget_to_budget_drips)
+                    .collect::<Result<Vec<Vec<Drip>>>>()
+            })
+            .flatten()
+            .flatten()
+            .filter(|bd| bd.amount != 0)
+            .collect();
 
     Ok(budget_drips)
 }
 
 fn map_actualbudget_zero_budget_to_budget_drips(
     actualbudget_zero_budget: &ActualbudgetZeroBudget,
-) -> Result<Vec<BudgetDrip>> {
+) -> Result<Vec<Drip>> {
     let context = || "failed to map actualbudget zero budgets to budget drips";
 
-    let first_day_of_month: DateUtc = Into::<DateUtc>::into(transform_date(&actualbudget_zero_budget.month).with_context(context)?);
+    let first_day_of_month: DateUtc = Into::<DateUtc>::into(
+        transform_date(&actualbudget_zero_budget.month).with_context(context)?,
+    );
     let month = first_day_of_month.month();
     let days_in_month: Vec<DateUtc> = (0..31)
         .map(|i| first_day_of_month.add_days(i))
@@ -52,21 +58,29 @@ fn map_actualbudget_zero_budget_to_budget_drips(
     // 31 elements, so we should be grand
     let num_days_in_month: i32 = days_in_month.len().try_into().unwrap();
 
-    let quantity = actualbudget_zero_budget.amount / num_days_in_month;
-    let remainder_quantity = actualbudget_zero_budget.amount - (quantity * num_days_in_month);
+    let amount = actualbudget_zero_budget.amount / num_days_in_month;
+    let remainder_amount = actualbudget_zero_budget.amount - (amount * num_days_in_month);
 
-    let budget_drips: Vec<BudgetDrip> = days_in_month.iter().map(|&date|
-        BudgetDrip {
+    let budget_drips: Vec<Drip> = days_in_month
+        .iter()
+        .map(|&date| Drip {
             id: transform_budget_drip_id(&actualbudget_zero_budget, &date),
             bucket_id: transform_id(&actualbudget_zero_budget.category_id),
             date,
-            quantity: if date == first_day_of_month {
-                quantity + remainder_quantity
+            amount: if date == first_day_of_month {
+                amount + remainder_amount
             } else {
-                quantity
-            }
-        }
-    ).collect();
+                amount
+            },
+            inserted_at_unix_seconds: std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .expect("The current time should be after the Unix epoch")
+                .as_secs()
+                .try_into()
+                .expect("The current time's timestamp in seconds should fit into a 32-bit signed integer"),
+            pipe_id: 0,
+        })
+        .collect();
 
     Ok(budget_drips)
 }
@@ -88,12 +102,14 @@ fn group_actualbudget_zero_budgets_by_category_id(
         .unique();
 
     category_ids
-        .map(|category_id| actualbudget_zero_budgets
-            .iter()
-            .filter(|zb| zb.category_id == category_id)
-            .map(ActualbudgetZeroBudget::clone)
-            .collect()
-        ).collect()
+        .map(|category_id| {
+            actualbudget_zero_budgets
+                .iter()
+                .filter(|zb| zb.category_id == category_id)
+                .map(ActualbudgetZeroBudget::clone)
+                .collect()
+        })
+        .collect()
 }
 
 fn transform_budget_drip_id(
@@ -112,7 +128,7 @@ fn transform_budget_drip_id(
 mod test {
     use actualbudget_fakes::actualbudget_zero_budget::make_fake_actualbudget_zero_budget_builder;
     use actualbudget_models::ActualbudgetDate;
-    use schist_models::budget_drip::BudgetDrip;
+    use schist_models::drip::Drip;
     use schist_traits::dateable::Dateable;
 
     use crate::transform_state::transform_id::transform_id;
@@ -122,7 +138,7 @@ mod test {
     mod map_actualbudget_zero_budget_to_budget_drips {
         use actualbudget_fakes::actualbudget_zero_budget::make_fake_actualbudget_zero_budget_builder;
         use actualbudget_models::ActualbudgetDate;
-        use schist_models::budget_drip::BudgetDrip;
+        use schist_models::drip::Drip;
         use schist_traits::dateable::Dateable;
 
         use crate::transform_state::transform_budget_drips::map_actualbudget_zero_budget_to_budget_drips;
@@ -141,10 +157,13 @@ mod test {
             assert!(result.is_ok());
             let mut budget_drips = result.unwrap();
             assert_eq!(31, budget_drips.len());
-            assert!(budget_drips.iter().all(|bd| bd.quantity == 100));
+            assert!(budget_drips.iter().all(|bd| bd.amount == 100));
             budget_drips.sort_by_key(|bd| bd.date);
             for i in 1..31 {
-                assert_eq!(Ok(i), budget_drips.get(i - 1).unwrap().date.day().try_into());
+                assert_eq!(
+                    Ok(i),
+                    budget_drips.get(i - 1).unwrap().date.day().try_into()
+                );
             }
         }
 
@@ -163,16 +182,12 @@ mod test {
             let budget_drips = result.unwrap();
             assert_eq!(31, budget_drips.len());
 
-            let budget_drips_quantity_not_floored: Vec<&BudgetDrip> = budget_drips
-                .iter()
-                .filter(|bd| bd.quantity != 100)
-                .collect();
-            assert_eq!(1, budget_drips_quantity_not_floored.len());
+            let budget_drips_amount_not_floored: Vec<&Drip> =
+                budget_drips.iter().filter(|bd| bd.amount != 100).collect();
+            assert_eq!(1, budget_drips_amount_not_floored.len());
 
-            let budget_drips_floored: Vec<&BudgetDrip> = budget_drips
-                .iter()
-                .filter(|bd| bd.quantity == 100)
-                .collect();
+            let budget_drips_floored: Vec<&Drip> =
+                budget_drips.iter().filter(|bd| bd.amount == 100).collect();
             assert_eq!(30, budget_drips_floored.len());
         }
     }
@@ -187,37 +202,36 @@ mod test {
 
     #[test]
     fn when_one_zero_budget_with_integer_budget_per_day_then_evenly_divided_budget_drips() {
-        let actualbudget_zero_budgets = [
-            make_fake_actualbudget_zero_budget_builder("0")
-                .amount(31 * 100)
-                .category_id(String::from("0"))
-                .month(ActualbudgetDate::from_i32(202401))
-                .build()
-                .unwrap()
-        ];
+        let actualbudget_zero_budgets = [make_fake_actualbudget_zero_budget_builder("0")
+            .amount(31 * 100)
+            .category_id(String::from("0"))
+            .month(ActualbudgetDate::from_i32(202401))
+            .build()
+            .unwrap()];
 
         let result = transform_budget_drips(&actualbudget_zero_budgets);
 
         assert!(result.is_ok());
         let mut budget_drips = result.unwrap();
         assert_eq!(31, budget_drips.len());
-        assert!(budget_drips.iter().all(|bd| bd.quantity == 100));
+        assert!(budget_drips.iter().all(|bd| bd.amount == 100));
         budget_drips.sort_by_key(|bd| bd.date);
         for i in 1..31 {
-            assert_eq!(Ok(i), budget_drips.get(i - 1).unwrap().date.day().try_into());
+            assert_eq!(
+                Ok(i),
+                budget_drips.get(i - 1).unwrap().date.day().try_into()
+            );
         }
     }
 
     #[test]
     fn when_one_zero_budgets_with_non_integer_budget_per_day_then_remainder_on_one_day() {
-        let actualbudget_zero_budgets = [
-            make_fake_actualbudget_zero_budget_builder("0")
-                .amount(31 * 100 + 30)
-                .category_id(String::from("0"))
-                .month(ActualbudgetDate::from_i32(202401))
-                .build()
-                .unwrap()
-        ];
+        let actualbudget_zero_budgets = [make_fake_actualbudget_zero_budget_builder("0")
+            .amount(31 * 100 + 30)
+            .category_id(String::from("0"))
+            .month(ActualbudgetDate::from_i32(202401))
+            .build()
+            .unwrap()];
 
         let result = transform_budget_drips(&actualbudget_zero_budgets);
 
@@ -225,21 +239,18 @@ mod test {
         let budget_drips = result.unwrap();
         assert_eq!(31, budget_drips.len());
 
-        let budget_drips_quantity_not_floored: Vec<&BudgetDrip> = budget_drips
-            .iter()
-            .filter(|bd| bd.quantity != 100)
-            .collect();
-        assert_eq!(1, budget_drips_quantity_not_floored.len());
+        let budget_drips_amount_not_floored: Vec<&Drip> =
+            budget_drips.iter().filter(|bd| bd.amount != 100).collect();
+        assert_eq!(1, budget_drips_amount_not_floored.len());
 
-        let budget_drips_floored: Vec<&BudgetDrip> = budget_drips
-            .iter()
-            .filter(|bd| bd.quantity == 100)
-            .collect();
+        let budget_drips_floored: Vec<&Drip> =
+            budget_drips.iter().filter(|bd| bd.amount == 100).collect();
         assert_eq!(30, budget_drips_floored.len());
     }
 
     #[test]
-    fn when_multiple_zero_budgets_with_integer_budget_per_day_across_multiple_categories_then_evenly_divided_budget_drips() {
+    fn when_multiple_zero_budgets_with_integer_budget_per_day_across_multiple_categories_then_evenly_divided_budget_drips(
+    ) {
         let actualbudget_zero_budgets = [
             make_fake_actualbudget_zero_budget_builder("0")
                 .amount(31 * 100)
@@ -275,32 +286,40 @@ mod test {
         let budget_drips = result.unwrap();
         assert_eq!(31 + 31 + 29 + 29, budget_drips.len());
 
-        let budget_drips_jan_category_0: Vec<&BudgetDrip> = budget_drips
+        let budget_drips_jan_category_0: Vec<&Drip> = budget_drips
             .iter()
             .filter(|bd| bd.bucket_id == category_0_id && bd.date.month() == 1)
             .collect();
         assert_eq!(31, budget_drips_jan_category_0.len());
-        assert!(budget_drips_jan_category_0.iter().all(|bd| bd.quantity == 100));
+        assert!(budget_drips_jan_category_0
+            .iter()
+            .all(|bd| bd.amount == 100));
 
-        let budget_drips_jan_category_1: Vec<&BudgetDrip> = budget_drips
+        let budget_drips_jan_category_1: Vec<&Drip> = budget_drips
             .iter()
             .filter(|bd| bd.bucket_id == category_1_id && bd.date.month() == 1)
             .collect();
         assert_eq!(31, budget_drips_jan_category_1.len());
-        assert!(budget_drips_jan_category_1.iter().all(|bd| bd.quantity == 200));
+        assert!(budget_drips_jan_category_1
+            .iter()
+            .all(|bd| bd.amount == 200));
 
-        let budget_drips_feb_category_0: Vec<&BudgetDrip> = budget_drips
+        let budget_drips_feb_category_0: Vec<&Drip> = budget_drips
             .iter()
             .filter(|bd| bd.bucket_id == category_0_id && bd.date.month() == 2)
             .collect();
         assert_eq!(29, budget_drips_feb_category_0.len());
-        assert!(budget_drips_feb_category_0.iter().all(|bd| bd.quantity == 110));
+        assert!(budget_drips_feb_category_0
+            .iter()
+            .all(|bd| bd.amount == 110));
 
-        let budget_drips_feb_category_1: Vec<&BudgetDrip> = budget_drips
+        let budget_drips_feb_category_1: Vec<&Drip> = budget_drips
             .iter()
             .filter(|bd| bd.bucket_id == category_1_id && bd.date.month() == 2)
             .collect();
         assert_eq!(29, budget_drips_feb_category_1.len());
-        assert!(budget_drips_feb_category_1.iter().all(|bd| bd.quantity == 210));
+        assert!(budget_drips_feb_category_1
+            .iter()
+            .all(|bd| bd.amount == 210));
     }
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs
index 2a21860..ccc8639 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_categories.rs
@@ -1,48 +1,24 @@
 use actualbudget_models::{ActualbudgetCategory, ActualbudgetZeroBudget};
-use itertools::Itertools;
-use schist_models::{budget_period_unit::BudgetPeriodUnit, bucket::Bucket, date_utc::DateUtc};
+use schist_models::bucket::Bucket;
 
 use super::transform_id;
 
-pub fn transform_categories(
-    actualbudget_categories: &[ActualbudgetCategory],
-    actualbudget_zero_budgets: &[ActualbudgetZeroBudget],
-    before_first_activity: &DateUtc,
-) -> Vec<Bucket> {
-    let last_non_zero_month = actualbudget_zero_budgets
+pub fn transform_categories(actualbudget_categories: &[ActualbudgetCategory]) -> Vec<Bucket> {
+    actualbudget_categories
         .iter()
-        .map(|zb| zb.month.clone())
-        .unique()
-        .filter(|month| actualbudget_zero_budgets
-            .iter()
-            .any(|zb| zb.month == *month && zb.amount != 0)
-        ).max();
-
-    let actualbudget_zero_budgets = if let Some(last_non_zero_month) = last_non_zero_month {
-        &actualbudget_zero_budgets
-            .iter()
-            .filter(|zb| zb.month == last_non_zero_month)
-            .cloned()
-            .collect::<Vec<_>>()
-    } else {
-        actualbudget_zero_budgets
-    };
-
-    actualbudget_categories.iter().map(|actualbudget_category| Bucket {
-        id: transform_id(&actualbudget_category.id.clone()),
-        name: actualbudget_category.name.clone(),
-        balance: 0,
-        balance_date: before_first_activity.clone(),
-        budget_period: 1,
-        budget_period_unit: BudgetPeriodUnit::Month,
-        budget_quantity: get_budget_quantity(actualbudget_category, actualbudget_zero_budgets),
-        group: String::from("un-named group"),
-    }).collect()
+        .map(|actualbudget_category| Bucket {
+            id: transform_id(&actualbudget_category.id.clone()),
+            balance: None,
+            balance_cache_key: None,
+            group: String::from("un-named group"),
+            name: actualbudget_category.name.clone(),
+        })
+        .collect()
 }
 
 fn get_budget_quantity(
     actualbudget_category: &ActualbudgetCategory,
-    actualbudget_zero_budgets: &[ActualbudgetZeroBudget]
+    actualbudget_zero_budgets: &[ActualbudgetZeroBudget],
 ) -> i32 {
     let latest_zero_budget_for_category = actualbudget_zero_budgets
         .iter()
@@ -57,10 +33,7 @@ fn get_budget_quantity(
 
 #[cfg(test)]
 mod test {
-    use actualbudget_fakes::{actualbudget_category::make_fake_actualbudget_category_builder, actualbudget_zero_budget::make_fake_actualbudget_zero_budget_builder};
-    use actualbudget_models::ActualbudgetDate;
-    use schist_models::{budget_period_unit::BudgetPeriodUnit, date_utc::DateUtc};
-    use schist_traits::nowlike::Nowlike;
+    use actualbudget_fakes::actualbudget_category::make_fake_actualbudget_category_builder;
 
     use crate::transform_state::transform_id::transform_id;
 
@@ -68,138 +41,103 @@ mod test {
 
     #[test]
     fn when_one_category_one_zero_budget_then_transforms_category() {
-        let actualbudget_categories = [
-            make_fake_actualbudget_category_builder("0").name(String::from("Food")).build().unwrap(),
-        ];
-        let actualbudget_zero_budgets = [
-            make_fake_actualbudget_zero_budget_builder("0").amount(100).build().unwrap(),
-        ];
-        let before_first_transaction = DateUtc::now();
+        let actualbudget_categories = [make_fake_actualbudget_category_builder("0")
+            .name(String::from("Food"))
+            .build()
+            .unwrap()];
 
-        let buckets = transform_categories(
-            &actualbudget_categories,
-            &actualbudget_zero_budgets,
-            &before_first_transaction,
-        );
+        let buckets = transform_categories(&actualbudget_categories);
 
         assert_eq!(1, buckets.len());
         let bucket = buckets.get(0).unwrap();
+        assert_eq!(None, bucket.balance);
+        assert_eq!(None, bucket.balance_cache_key);
         assert_eq!("Food", bucket.name);
-        assert_eq!(0, bucket.balance);
-        assert_eq!(before_first_transaction, bucket.balance_date);
-        assert_eq!(1, bucket.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, bucket.budget_period_unit);
-        assert_eq!(100, bucket.budget_quantity);
     }
 
     #[test]
     fn when_one_category_no_zero_budget_then_transforms_category() {
-        let actualbudget_categories = [
-            make_fake_actualbudget_category_builder("0").name(String::from("Food")).build().unwrap(),
-        ];
-        let actualbudget_zero_budgets = [];
-        let before_first_transaction = DateUtc::now();
+        let actualbudget_categories = [make_fake_actualbudget_category_builder("0")
+            .name(String::from("Food"))
+            .build()
+            .unwrap()];
 
-        let buckets = transform_categories(
-            &actualbudget_categories,
-            &actualbudget_zero_budgets,
-            &before_first_transaction,
-        );
+        let buckets = transform_categories(&actualbudget_categories);
 
         assert_eq!(1, buckets.len());
         let bucket = buckets.get(0).unwrap();
         assert_eq!("Food", bucket.name);
-        assert_eq!(0, bucket.balance);
-        assert_eq!(before_first_transaction, bucket.balance_date);
-        assert_eq!(1, bucket.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, bucket.budget_period_unit);
-        assert_eq!(0, bucket.budget_quantity);
+        assert_eq!(None, bucket.balance);
+        assert_eq!(None, bucket.balance_cache_key);
+        assert_eq!("un-named group", bucket.group);
     }
 
     #[test]
     fn when_one_category_multiple_zero_budgets_then_transforms_category() {
-        let actualbudget_categories = [
-            make_fake_actualbudget_category_builder("0").name(String::from("Food")).build().unwrap(),
-        ];
-        let jan = ActualbudgetDate::from_i32(202401);
-        let feb = ActualbudgetDate::from_i32(202402);
-        let mar = ActualbudgetDate::from_i32(202403);
-        let actualbudget_zero_budgets = [
-            make_fake_actualbudget_zero_budget_builder("0").amount(100).month(jan).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("1").amount(200).month(feb).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("2").amount(300).month(mar).build().unwrap(),
-        ];
-        let before_first_transaction = DateUtc::now();
+        let actualbudget_categories = [make_fake_actualbudget_category_builder("0")
+            .name(String::from("Food"))
+            .build()
+            .unwrap()];
 
-        let buckets = transform_categories(
-            &actualbudget_categories,
-            &actualbudget_zero_budgets,
-            &before_first_transaction,
-        );
+        let buckets = transform_categories(&actualbudget_categories);
 
         assert_eq!(1, buckets.len());
         let bucket = buckets.get(0).unwrap();
         assert_eq!("Food", bucket.name);
-        assert_eq!(0, bucket.balance);
-        assert_eq!(before_first_transaction, bucket.balance_date);
-        assert_eq!(1, bucket.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, bucket.budget_period_unit);
-        assert_eq!(300, bucket.budget_quantity);
+        assert_eq!(None, bucket.balance);
+        assert_eq!(None, bucket.balance_cache_key);
+        assert_eq!("un-named group", bucket.group);
     }
 
     #[test]
     fn when_multiple_categories_multiple_zero_budgets_then_transforms_category() {
         let actualbudget_categories = [
-            make_fake_actualbudget_category_builder("0").name(String::from("Food")).build().unwrap(),
-            make_fake_actualbudget_category_builder("1").name(String::from("Clothes")).build().unwrap(),
-            make_fake_actualbudget_category_builder("2").name(String::from("Rent")).build().unwrap(),
+            make_fake_actualbudget_category_builder("0")
+                .name(String::from("Food"))
+                .build()
+                .unwrap(),
+            make_fake_actualbudget_category_builder("1")
+                .name(String::from("Clothes"))
+                .build()
+                .unwrap(),
+            make_fake_actualbudget_category_builder("2")
+                .name(String::from("Rent"))
+                .build()
+                .unwrap(),
         ];
-        let jan = ActualbudgetDate::from_i32(202401);
-        let feb = ActualbudgetDate::from_i32(202402);
-        let mar = ActualbudgetDate::from_i32(202403);
-        let actualbudget_zero_budgets = [
-            make_fake_actualbudget_zero_budget_builder("0").amount(100).month(jan.clone()).category_id(String::from("0")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("1").amount(200).month(feb.clone()).category_id(String::from("0")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("2").amount(300).month(mar.clone()).category_id(String::from("0")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("3").amount(110).month(jan.clone()).category_id(String::from("1")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("4").amount(210).month(feb.clone()).category_id(String::from("1")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("5").amount(310).month(mar.clone()).category_id(String::from("1")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("6").amount(120).month(jan.clone()).category_id(String::from("2")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("7").amount(220).month(feb.clone()).category_id(String::from("2")).build().unwrap(),
-            make_fake_actualbudget_zero_budget_builder("8").amount(320).month(mar.clone()).category_id(String::from("2")).build().unwrap(),
-        ];
-        let before_first_transaction = DateUtc::now();
 
-        let buckets = transform_categories(
-            &actualbudget_categories,
-            &actualbudget_zero_budgets,
-            &before_first_transaction,
-        );
+        let buckets = transform_categories(&actualbudget_categories);
 
         assert_eq!(3, buckets.len());
 
-        let bucket_0 = buckets.iter().filter(|c| c.id == transform_id("0")).last().unwrap();
+        let bucket_0 = buckets
+            .iter()
+            .filter(|c| c.id == transform_id("0"))
+            .last()
+            .unwrap();
         assert_eq!("Food", bucket_0.name);
-        assert_eq!(0, bucket_0.balance);
-        assert_eq!(before_first_transaction, bucket_0.balance_date);
-        assert_eq!(1, bucket_0.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, bucket_0.budget_period_unit);
-        assert_eq!(300, bucket_0.budget_quantity);
+        assert_eq!(None, bucket_0.balance);
+        assert_eq!(None, bucket_0.balance_cache_key);
+        assert_eq!("un-named group", bucket_0.group);
 
-        let bucket_1 = buckets.iter().filter(|c| c.id == transform_id("1")).last().unwrap();
+        let bucket_1 = buckets
+            .iter()
+            .filter(|c| c.id == transform_id("1"))
+            .last()
+            .unwrap();
         assert_eq!("Clothes", bucket_1.name);
-        assert_eq!(0, bucket_1.balance);
-        assert_eq!(before_first_transaction, bucket_1.balance_date);
-        assert_eq!(1, bucket_1.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, bucket_1.budget_period_unit);
-        assert_eq!(310, bucket_1.budget_quantity);
+        assert_eq!(None, bucket_1.balance);
+        assert_eq!(None, bucket_1.balance_cache_key);
+        assert_eq!("un-named group", bucket_1.group);
 
-        let bucket_2 = buckets.iter().filter(|c| c.id == transform_id("2")).last().unwrap();
+        let bucket_2 = buckets
+            .iter()
+            .filter(|c| c.id == transform_id("2"))
+            .last()
+            .unwrap();
         assert_eq!("Rent", bucket_2.name);
-        assert_eq!(0, bucket_2.balance);
-        assert_eq!(before_first_transaction, bucket_2.balance_date);
-        assert_eq!(1, bucket_2.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, bucket_2.budget_period_unit);
-        assert_eq!(320, bucket_2.budget_quantity);
+        assert_eq!(None, bucket_2.balance);
+        assert_eq!(None, bucket_2.balance_cache_key);
+        assert_eq!("un-named group", bucket_2.group);
     }
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs
index 11ed2e3..bfbf7ac 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_category_transfers.rs
@@ -1,7 +1,4 @@
-use actualbudget_models::{
-    ActualbudgetAccount,
-    ActualbudgetTransaction,
-};
+use actualbudget_models::{ActualbudgetAccount, ActualbudgetTransaction};
 use anyhow::{bail, Context, Result};
 use itertools::Itertools;
 use schist_models::bucket_transfer::BucketTransfer;
@@ -12,20 +9,20 @@ pub fn transform_category_transfers(
     actualbudget_transactions: &[ActualbudgetTransaction],
     actualbudget_category_transfers_account: &Option<ActualbudgetAccount>,
 ) -> Result<Vec<BucketTransfer>> {
-    let actualbudget_category_transfers = actualbudget_transactions
-        .iter()
-        .filter(|transaction|
-            is_category_transfer(transaction, actualbudget_category_transfers_account)
-        );
-    let actualbudget_parent_category_transfers: Vec<ActualbudgetTransaction> = actualbudget_category_transfers
-        .clone()
-        .filter(|t| t.is_parent)
-        .map(ActualbudgetTransaction::clone)
-        .collect();
-    let actualbudget_child_category_transfers: Vec<ActualbudgetTransaction> = actualbudget_category_transfers
-        .filter(|t| t.is_child)
-        .map(ActualbudgetTransaction::clone)
-        .collect();
+    let actualbudget_category_transfers = actualbudget_transactions.iter().filter(|transaction| {
+        is_category_transfer(transaction, actualbudget_category_transfers_account)
+    });
+    let actualbudget_parent_category_transfers: Vec<ActualbudgetTransaction> =
+        actualbudget_category_transfers
+            .clone()
+            .filter(|t| t.is_parent)
+            .map(ActualbudgetTransaction::clone)
+            .collect();
+    let actualbudget_child_category_transfers: Vec<ActualbudgetTransaction> =
+        actualbudget_category_transfers
+            .filter(|t| t.is_child)
+            .map(ActualbudgetTransaction::clone)
+            .collect();
 
     Ok(actualbudget_parent_category_transfers
         .iter()
@@ -33,8 +30,7 @@ pub fn transform_category_transfers(
         .filter_ok(Option::is_some)
         .map_ok(Option::unwrap)
         .collect::<Result<Vec<BucketTransfer>>>()
-        .with_context(|| "failed to transform category transfers")?
-    )
+        .with_context(|| "failed to transform category transfers")?)
 }
 
 fn transform_category_transfer(
@@ -44,7 +40,8 @@ fn transform_category_transfer(
     transform_category_transfer_without_context(
         actualbudget_parent_category_transfer,
         actualbudget_child_category_transfers,
-    ).with_context(|| "failed to transform category transfer")
+    )
+    .with_context(|| "failed to transform category transfer")
 }
 
 fn transform_category_transfer_without_context(
@@ -53,11 +50,12 @@ fn transform_category_transfer_without_context(
 ) -> Result<Option<BucketTransfer>> {
     let actualbudget_child_category_transfers = actualbudget_child_category_transfers
         .iter()
-        .filter(|t|
+        .filter(|t| {
             t.parent_id
                 .clone()
                 .is_some_and(|parent_id| parent_id == actualbudget_parent_category_transfer.id)
-        ).map(ActualbudgetTransaction::clone);
+        })
+        .map(ActualbudgetTransaction::clone);
 
     let from_transfers: Vec<ActualbudgetTransaction> = actualbudget_child_category_transfers
         .clone()
@@ -73,7 +71,10 @@ fn transform_category_transfer_without_context(
     let from_transfer = from_transfers.get(0).unwrap();
 
     if from_transfer.category_id.is_none() {
-        bail!("actualbudget child from transfer {} had no category ID", from_transfer.id);
+        bail!(
+            "actualbudget child from transfer {} had no category ID",
+            from_transfer.id
+        );
     }
     let from_category_id: i32 = transform_id(&from_transfer.category_id.clone().unwrap());
 
@@ -91,12 +92,14 @@ fn transform_category_transfer_without_context(
     let to_transfer = to_transfers.get(0).unwrap();
 
     if to_transfer.category_id.is_none() {
-        bail!("actualbudget child to transfer {} had no category ID", to_transfer.id);
+        bail!(
+            "actualbudget child to transfer {} had no category ID",
+            to_transfer.id
+        );
     }
     let to_category_id: i32 = transform_id(&to_transfer.category_id.clone().unwrap());
 
-    if from_transfer.amount != -to_transfer.amount
-    {
+    if from_transfer.amount != -to_transfer.amount {
         bail!("actualbudget category transfer amounts did not sum to zero");
     }
 
@@ -106,7 +109,7 @@ fn transform_category_transfer_without_context(
             .notes
             .clone()
             .unwrap_or_else(String::new),
-        quantity: to_transfer.amount.try_into().unwrap(),
+        amount: to_transfer.amount.try_into().unwrap(),
         from_bucket_id: from_category_id,
         to_bucket_id: to_category_id,
     }))
@@ -114,7 +117,10 @@ fn transform_category_transfer_without_context(
 
 #[cfg(test)]
 mod test {
-    use actualbudget_fakes::{actualbudget_account::make_fake_actualbudget_account, actualbudget_transaction::make_fake_actualbudget_transaction_builder};
+    use actualbudget_fakes::{
+        actualbudget_account::make_fake_actualbudget_account,
+        actualbudget_transaction::make_fake_actualbudget_transaction_builder,
+    };
     use actualbudget_models::{ActualbudgetTransaction, ActualbudgetTransactionBuilder};
     use schist_models::bucket_transfer::BucketTransfer;
 
@@ -140,7 +146,7 @@ mod test {
         let bucket_transfers = result.unwrap();
         assert_eq!(1, bucket_transfers.len());
         let bucket_transfer = bucket_transfers.get(0).unwrap();
-        assert_eq!(100, bucket_transfer.quantity);
+        assert_eq!(100, bucket_transfer.amount);
         assert_eq!("I was a parent transaction", bucket_transfer.description);
         assert_eq!(transform_id("0"), bucket_transfer.from_bucket_id);
         assert_eq!(transform_id("1"), bucket_transfer.to_bucket_id);
@@ -151,13 +157,31 @@ mod test {
         let actualbudget_category_transfers_account = make_fake_actualbudget_account("0");
         let actualbudget_transactions = [
             make_fake_parent_transaction("0"),
-            make_fake_from_child_transaction_builder("1", 100, "0").category_id(Some(String::from("0"))).build().unwrap(),
-            make_fake_to_child_transaction_builder("2", 100, "0").category_id(Some(String::from("1"))).build().unwrap(),
+            make_fake_from_child_transaction_builder("1", 100, "0")
+                .category_id(Some(String::from("0")))
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("2", 100, "0")
+                .category_id(Some(String::from("1")))
+                .build()
+                .unwrap(),
             make_fake_parent_transaction("3"),
-            make_fake_from_child_transaction_builder("4", 200, "3").category_id(Some(String::from("1"))).build().unwrap(),
-            make_fake_to_child_transaction_builder("5", 200, "3").category_id(Some(String::from("0"))).build().unwrap(),
-            make_fake_actualbudget_transaction_builder("6").amount(300).build().unwrap(),
-            make_fake_actualbudget_transaction_builder("7").amount(-400).build().unwrap(),
+            make_fake_from_child_transaction_builder("4", 200, "3")
+                .category_id(Some(String::from("1")))
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("5", 200, "3")
+                .category_id(Some(String::from("0")))
+                .build()
+                .unwrap(),
+            make_fake_actualbudget_transaction_builder("6")
+                .amount(300)
+                .build()
+                .unwrap(),
+            make_fake_actualbudget_transaction_builder("7")
+                .amount(-400)
+                .build()
+                .unwrap(),
         ];
 
         let result = transform_category_transfers(
@@ -171,7 +195,7 @@ mod test {
 
         let bucket_transfer_0: Vec<&BucketTransfer> = bucket_transfers
             .iter()
-            .filter(|ct| ct.quantity == 100)
+            .filter(|ct| ct.amount == 100)
             .collect();
         assert_eq!(1, bucket_transfer_0.len());
         let bucket_transfer_0 = bucket_transfer_0.get(0).unwrap();
@@ -180,7 +204,7 @@ mod test {
 
         let bucket_transfer_1: Vec<&BucketTransfer> = bucket_transfers
             .iter()
-            .filter(|ct| ct.quantity == 200)
+            .filter(|ct| ct.amount == 200)
             .collect();
         assert_eq!(1, bucket_transfer_1.len());
         let bucket_transfer_1 = bucket_transfer_1.get(0).unwrap();
@@ -193,9 +217,15 @@ mod test {
         let actualbudget_category_transfers_account = make_fake_actualbudget_account("0");
         let actualbudget_transactions = [
             make_fake_parent_transaction("0"),
-            make_fake_from_child_transaction_builder("1", 50, "0").build().unwrap(),
-            make_fake_from_child_transaction_builder("2", 50, "0").build().unwrap(),
-            make_fake_to_child_transaction_builder("3", 100, "0").build().unwrap(),
+            make_fake_from_child_transaction_builder("1", 50, "0")
+                .build()
+                .unwrap(),
+            make_fake_from_child_transaction_builder("2", 50, "0")
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("3", 100, "0")
+                .build()
+                .unwrap(),
         ];
 
         let result = transform_category_transfers(
@@ -211,9 +241,15 @@ mod test {
         let actualbudget_category_transfers_account = make_fake_actualbudget_account("0");
         let actualbudget_transactions = [
             make_fake_parent_transaction("0"),
-            make_fake_from_child_transaction_builder("1", 100, "0").build().unwrap(),
-            make_fake_to_child_transaction_builder("2", 50, "0").build().unwrap(),
-            make_fake_to_child_transaction_builder("3", 50, "0").build().unwrap(),
+            make_fake_from_child_transaction_builder("1", 100, "0")
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("2", 50, "0")
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("3", 50, "0")
+                .build()
+                .unwrap(),
         ];
 
         let result = transform_category_transfers(
@@ -261,8 +297,12 @@ mod test {
         let actualbudget_category_transfers_account = make_fake_actualbudget_account("0");
         let actualbudget_transactions = [
             make_fake_parent_transaction("0"),
-            make_fake_from_child_transaction_builder("1", 50, "0").build().unwrap(),
-            make_fake_to_child_transaction_builder("2", 100, "0").build().unwrap(),
+            make_fake_from_child_transaction_builder("1", 50, "0")
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("2", 100, "0")
+                .build()
+                .unwrap(),
         ];
 
         let result = transform_category_transfers(
@@ -278,13 +318,23 @@ mod test {
         let actualbudget_category_transfers_account = make_fake_actualbudget_account("0");
         let actualbudget_transactions_0 = [
             make_fake_parent_transaction("0"),
-            make_fake_from_child_transaction_builder("1", 100, "0").category_id(None).build().unwrap(),
-            make_fake_to_child_transaction_builder("2", 100, "0").build().unwrap(),
+            make_fake_from_child_transaction_builder("1", 100, "0")
+                .category_id(None)
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("2", 100, "0")
+                .build()
+                .unwrap(),
         ];
         let actualbudget_transactions_1 = [
             make_fake_parent_transaction("0"),
-            make_fake_from_child_transaction_builder("1", 100, "0").build().unwrap(),
-            make_fake_to_child_transaction_builder("2", 100, "0").category_id(None).build().unwrap(),
+            make_fake_from_child_transaction_builder("1", 100, "0")
+                .build()
+                .unwrap(),
+            make_fake_to_child_transaction_builder("2", 100, "0")
+                .category_id(None)
+                .build()
+                .unwrap(),
         ];
 
         let result_0 = transform_category_transfers(
@@ -314,25 +364,37 @@ mod test {
     }
 
     fn make_fake_from_child_transaction(id: &str, parent_id: &str) -> ActualbudgetTransaction {
-        make_fake_from_child_transaction_builder(id, 100, parent_id).build().unwrap()
+        make_fake_from_child_transaction_builder(id, 100, parent_id)
+            .build()
+            .unwrap()
     }
-        fn make_fake_from_child_transaction_builder(id: &str, amount: i32, parent_id: &str) -> ActualbudgetTransactionBuilder {
-            let mut builder = make_fake_actualbudget_transaction_builder(id);
-            builder
-                .account_id(String::from("0"))
-                .category_id(Some(String::from("0")))
-                .amount(-amount)
-                .is_child(true)
-                .notes(Some(String::from("I was a from child transaction")))
-                .parent_id(Some(String::from(parent_id)));
-            builder
+    fn make_fake_from_child_transaction_builder(
+        id: &str,
+        amount: i32,
+        parent_id: &str,
+    ) -> ActualbudgetTransactionBuilder {
+        let mut builder = make_fake_actualbudget_transaction_builder(id);
+        builder
+            .account_id(String::from("0"))
+            .category_id(Some(String::from("0")))
+            .amount(-amount)
+            .is_child(true)
+            .notes(Some(String::from("I was a from child transaction")))
+            .parent_id(Some(String::from(parent_id)));
+        builder
     }
 
     fn make_fake_to_child_transaction(id: &str, parent_id: &str) -> ActualbudgetTransaction {
-        make_fake_to_child_transaction_builder(id, 100, parent_id).build().unwrap()
+        make_fake_to_child_transaction_builder(id, 100, parent_id)
+            .build()
+            .unwrap()
     }
 
-    fn make_fake_to_child_transaction_builder(id: &str, amount: i32, parent_id: &str) -> ActualbudgetTransactionBuilder {
+    fn make_fake_to_child_transaction_builder(
+        id: &str,
+        amount: i32,
+        parent_id: &str,
+    ) -> ActualbudgetTransactionBuilder {
         let mut builder = make_fake_actualbudget_transaction_builder(id);
         builder
             .account_id(String::from("0"))
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs
index 575e624..7d7f90b 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_state.rs
@@ -1,9 +1,16 @@
 use anyhow::{bail, Context, Result};
-use schist_models::{account::Account, bucket::Bucket, bucket_transfer::BucketTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation};
+use schist_models::{
+    account::Account, bucket::Bucket, bucket_transfer::BucketTransfer, date_utc::DateUtc,
+    pipe::Pipe, transaction::Transaction,
+};
 
 use crate::{actualbudget_state::ActualbudgetState, schist_state::SchistState};
 
-use super::{transform_account_transfers, transform_accounts, transform_budget_drips::transform_budget_drips, transform_categories, transform_category_transfers, transform_date, transform_transactions};
+use super::{
+    transform_account_transfers, transform_accounts,
+    transform_budget_drips::transform_budget_drips, transform_categories,
+    transform_category_transfers, transform_date, transform_transactions, transform_zero_budgets,
+};
 
 pub fn transform_state(actualbudget_state: ActualbudgetState) -> Result<SchistState> {
     transform_state_without_context(actualbudget_state)
@@ -11,30 +18,23 @@ pub fn transform_state(actualbudget_state: ActualbudgetState) -> Result<SchistSt
 }
 
 fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Result<SchistState> {
-    let (remaining_transactions, account_transfers) = transform_account_transfers(
-        &actualbudget_state.actualbudget_transactions,
-    )?;
-    let first_activity_date =
-        transform_date(&actualbudget_state.actualbudget_first_activity_date)?;
+    let (remaining_transactions, account_transfers) =
+        transform_account_transfers(&actualbudget_state.actualbudget_transactions)?;
+    let first_activity_date = transform_date(&actualbudget_state.actualbudget_first_activity_date)?;
     let before_first_activity_date = find_date_before(&first_activity_date)?;
-    let accounts: Vec<Account> =
-        transform_accounts(
-            &actualbudget_state.actualbudget_accounts,
-            &actualbudget_state.actualbudget_category_transfers_account,
-            &first_activity_date,
-        );
-    let budget_drips = transform_budget_drips(&actualbudget_state.actualbudget_zero_budgets)?;
-    let buckets: Vec<Bucket> = transform_categories(
-        &actualbudget_state.actualbudget_categories,
-        &actualbudget_state.actualbudget_zero_budgets,
-        &before_first_activity_date,
+    let accounts: Vec<Account> = transform_accounts(
+        &actualbudget_state.actualbudget_accounts,
+        &actualbudget_state.actualbudget_category_transfers_account,
+        &first_activity_date,
     );
-    let (transactions, transaction_categorisations): (Vec<Transaction>, Vec<TransactionCategorisation>) =
-        transform_transactions(
-            &remaining_transactions,
-            &actualbudget_state.actualbudget_category_transfers_account,
-            &actualbudget_state.actualbudget_payees,
-        )?;
+    let budget_drips = transform_budget_drips(&actualbudget_state.actualbudget_zero_budgets)?;
+    let buckets: Vec<Bucket> = transform_categories(&actualbudget_state.actualbudget_categories);
+    let pipes: Vec<Pipe> = transform_zero_budgets(&actualbudget_state.actualbudget_zero_budgets);
+    let transactions: Vec<Transaction> = transform_transactions(
+        &remaining_transactions,
+        &actualbudget_state.actualbudget_category_transfers_account,
+        &actualbudget_state.actualbudget_payees,
+    )?;
     let bucket_transfers: Vec<BucketTransfer> = transform_category_transfers(
         &remaining_transactions,
         &actualbudget_state.actualbudget_category_transfers_account,
@@ -46,8 +46,8 @@ fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Res
         account_transfers,
         buckets,
         budget_drips,
+        pipes: pipes,
         transactions,
-        transaction_categorisations,
         bucket_transfers,
     })
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs
index f24e8b6..a1b7c4d 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_transactions.rs
@@ -1,6 +1,6 @@
-use anyhow::{Context, Result};
 use actualbudget_models::{ActualbudgetAccount, ActualbudgetPayee, ActualbudgetTransaction};
-use schist_models::{transaction::Transaction, transaction_categorisation::TransactionCategorisation};
+use anyhow::{Context, Result};
+use schist_models::transaction::Transaction;
 
 use super::{is_not_category_transfer, transform_date, transform_id};
 
@@ -8,22 +8,21 @@ pub fn transform_transactions(
     actualbudget_transactions: &[ActualbudgetTransaction],
     actualbudget_category_transfers_account: &Option<ActualbudgetAccount>,
     actualbudget_payees: &[ActualbudgetPayee],
-) -> Result<(Vec<Transaction>, Vec<TransactionCategorisation>)> {
+) -> Result<Vec<Transaction>> {
     transform_transactions_without_context(
         actualbudget_transactions,
         actualbudget_category_transfers_account,
         actualbudget_payees,
     )
-        .with_context(|| "failed to transform actualbudget transactions to schist transactions")
+    .with_context(|| "failed to transform actualbudget transactions to schist transactions")
 }
 
 fn transform_transactions_without_context(
     actualbudget_transactions: &[ActualbudgetTransaction],
     actualbudget_category_transfers_account: &Option<ActualbudgetAccount>,
     actualbudget_payees: &[ActualbudgetPayee],
-) -> Result<(Vec<Transaction>, Vec<TransactionCategorisation>)> {
+) -> Result<Vec<Transaction>> {
     let mut transactions = Vec::<Transaction>::new();
-    let mut transaction_categorisations = Vec::<TransactionCategorisation>::new();
 
     let actualbudget_transactions = actualbudget_transactions
         .iter()
@@ -32,10 +31,6 @@ fn transform_transactions_without_context(
         .clone()
         .filter(|t| t.is_parent)
         .collect();
-    let child_actualbudget_transactions: Vec<&ActualbudgetTransaction> = actualbudget_transactions
-        .clone()
-        .filter(|t| t.is_child)
-        .collect();
     let atomic_actualbudget_transactions: Vec<&ActualbudgetTransaction> = actualbudget_transactions
         .filter(|t| !t.is_parent && !t.is_child)
         .collect();
@@ -46,84 +41,59 @@ fn transform_transactions_without_context(
         let payee_name = atomic_actualbudget_transaction
             .payee
             .clone()
-            .map(|p| actualbudget_payees
-                .iter()
-                .find(|pp| pp.id == p)
-                .map(|pp| pp.name.clone())
-            ).unwrap_or(None)
+            .map(|p| {
+                actualbudget_payees
+                    .iter()
+                    .find(|pp| pp.id == p)
+                    .map(|pp| pp.name.clone())
+            })
+            .unwrap_or(None)
             .unwrap_or_else(String::new);
 
         transactions.push(Transaction {
             id: transaction_id,
-            description: atomic_actualbudget_transaction.notes.clone().unwrap_or_else(String::new),
-            payee: payee_name,
-            quantity: atomic_actualbudget_transaction.amount.try_into().unwrap(),
+            description: atomic_actualbudget_transaction
+                .notes
+                .clone()
+                .unwrap_or_else(String::new),
+            counterparty: payee_name,
+            amount: atomic_actualbudget_transaction.amount.try_into().unwrap(),
             date: transform_date(&atomic_actualbudget_transaction.date)?,
             account_id: transform_id(&atomic_actualbudget_transaction.account_id),
-        });
-
-        let actualbudget_category_id = atomic_actualbudget_transaction
-            .category_id
-            .clone()
-            .with_context(|| format!(
-                "atomic actualbudget transaction {} did not have a category ID",
-                atomic_actualbudget_transaction.id,
-            ))?;
-
-        transaction_categorisations.push(TransactionCategorisation {
-            id: transaction_id,
-            description: String::new(),
-            quantity: atomic_actualbudget_transaction.amount.try_into().unwrap(),
-            transaction_id,
-            bucket_id: transform_id(&actualbudget_category_id),
+            bucket_id: None,
         });
     }
 
     for parent_actualbudget_transaction in parent_actualbudget_transactions {
-        let child_actualbudget_transactions = child_actualbudget_transactions
-                .iter()
-                .filter(|t| t
-                    .parent_id
-                    .clone()
-                    .is_some_and(|parent_id| parent_id == parent_actualbudget_transaction.id.clone())
-                );
-
         let transaction_id = transform_id(&parent_actualbudget_transaction.id);
 
         transactions.push(Transaction {
             id: transaction_id,
-            description: parent_actualbudget_transaction.notes.clone().unwrap_or_else(String::new),
-            payee: parent_actualbudget_transaction.payee.clone().unwrap_or_else(String::new),
-            quantity: parent_actualbudget_transaction.amount.try_into().unwrap(),
+            bucket_id: None,
+            description: parent_actualbudget_transaction
+                .notes
+                .clone()
+                .unwrap_or_else(String::new),
+            counterparty: parent_actualbudget_transaction
+                .payee
+                .clone()
+                .unwrap_or_else(String::new),
+            amount: parent_actualbudget_transaction.amount.try_into().unwrap(),
             date: transform_date(&parent_actualbudget_transaction.date)?,
             account_id: transform_id(&parent_actualbudget_transaction.account_id),
         });
-
-        for child_actualbudget_transaction in child_actualbudget_transactions {
-            let actualbudget_category_id = child_actualbudget_transaction
-                .category_id
-                .clone()
-                .with_context(|| format!(
-                    "actualbudget child transaction {} had no category ID",
-                    child_actualbudget_transaction.id,
-                ))?;
-
-            transaction_categorisations.push(TransactionCategorisation {
-                id: transform_id(&child_actualbudget_transaction.id),
-                description: child_actualbudget_transaction.notes.clone().unwrap_or_else(String::new),
-                quantity: child_actualbudget_transaction.amount.try_into().unwrap(),
-                transaction_id,
-                bucket_id: transform_id(&actualbudget_category_id),
-            });
-        }
     }
 
-    Ok((transactions, transaction_categorisations))
+    Ok(transactions)
 }
 
 #[cfg(test)]
 mod test {
-    use actualbudget_fakes::{actualbudget_account::make_fake_actualbudget_account, actualbudget_payee::{make_fake_actualbudget_payee, make_fake_actualbudget_payee_builder}, actualbudget_transaction::make_fake_actualbudget_transaction_builder};
+    use actualbudget_fakes::{
+        actualbudget_account::make_fake_actualbudget_account,
+        actualbudget_payee::{make_fake_actualbudget_payee, make_fake_actualbudget_payee_builder},
+        actualbudget_transaction::make_fake_actualbudget_transaction_builder,
+    };
     use actualbudget_models::ActualbudgetDate;
     use schist_models::date_utc::DateUtc;
 
@@ -133,65 +103,50 @@ mod test {
 
     #[test]
     fn when_one_category_transfer_transaction_then_returns_empty() {
-        let actualbudget_transactions = [
-            make_fake_actualbudget_transaction_builder("0")
-                .category_id(Some(String::from("0")))
-                .build()
-                .unwrap(),
-        ];
+        let actualbudget_transactions = [make_fake_actualbudget_transaction_builder("0")
+            .category_id(Some(String::from("0")))
+            .build()
+            .unwrap()];
         let actualbudget_category_transfers_account = make_fake_actualbudget_account("0");
         let actualbudget_payees = [make_fake_actualbudget_payee("0")];
 
-        let (transactions, transaction_categorisations) = transform_transactions(
+        let transactions = transform_transactions(
             &actualbudget_transactions,
             &Some(actualbudget_category_transfers_account),
             &actualbudget_payees,
-        ).unwrap();
+        )
+        .unwrap();
 
         assert_eq!(0, transactions.len());
-        assert_eq!(0, transaction_categorisations.len());
     }
 
     #[test]
     fn when_one_atomic_transaction_then_returns_transformed_transaction() {
-        let actualbudget_transactions = [
-            make_fake_actualbudget_transaction_builder("0")
-                .account_id(String::from("0"))
-                .amount(100)
-                .category_id(Some(String::from("0")))
-                .payee(Some(String::from("0")))
-                .notes(Some(String::from("Savings")))
-                .date(ActualbudgetDate::from_i32(19700101))
-                .build()
-                .unwrap(),
-        ];
-        let actualbudget_payees = [
-            make_fake_actualbudget_payee_builder("0")
-                .name(String::from("Gringotts"))
-                .build()
-                .unwrap(),
-        ];
-
-        let (transactions, transaction_categorisations) = transform_transactions(
-            &actualbudget_transactions,
-            &None,
-            &actualbudget_payees,
-        ).unwrap();
+        let actualbudget_transactions = [make_fake_actualbudget_transaction_builder("0")
+            .account_id(String::from("0"))
+            .amount(100)
+            .category_id(Some(String::from("0")))
+            .payee(Some(String::from("0")))
+            .notes(Some(String::from("Savings")))
+            .date(ActualbudgetDate::from_i32(19700101))
+            .build()
+            .unwrap()];
+        let actualbudget_payees = [make_fake_actualbudget_payee_builder("0")
+            .name(String::from("Gringotts"))
+            .build()
+            .unwrap()];
+
+        let transactions =
+            transform_transactions(&actualbudget_transactions, &None, &actualbudget_payees)
+                .unwrap();
 
         assert_eq!(1, transactions.len());
         let transaction = transactions.get(0).unwrap();
         assert_eq!("Savings", transaction.description);
-        assert_eq!("Gringotts", transaction.payee);
-        assert_eq!(100, transaction.quantity);
+        assert_eq!("Gringotts", transaction.counterparty);
+        assert_eq!(100, transaction.amount);
         assert_eq!(DateUtc::from_ymd(1970, 1, 1).unwrap(), transaction.date);
         assert_eq!(transform_id("0"), transaction.account_id);
-
-        assert_eq!(1, transaction_categorisations.len());
-        let transaction_categorisation = transaction_categorisations.get(0).unwrap();
-        assert_eq!("", transaction_categorisation.description);
-        assert_eq!(100, transaction_categorisation.quantity);
-        assert_eq!(transaction.id, transaction_categorisation.transaction_id);
-        assert_eq!(transform_id("0"), transaction_categorisation.bucket_id);
     }
 
     #[test]
@@ -220,34 +175,11 @@ mod test {
                 .unwrap(),
         ];
 
-        let (transactions, transaction_categorisations) = transform_transactions(
-            &actualbudget_transactions,
-            &None,
-            &[],
-        ).unwrap();
+        let transactions = transform_transactions(&actualbudget_transactions, &None, &[]).unwrap();
 
         assert_eq!(1, transactions.len());
-        assert_eq!(2, transaction_categorisations.len());
 
         let transaction = transactions.get(0).unwrap();
-        assert_eq!(100, transaction.quantity);
-
-        let transaction_categorisation_0 = transaction_categorisations
-            .iter()
-            .filter(|tc| tc.quantity == 200)
-            .last()
-            .unwrap();
-        assert_eq!(transaction.id, transaction_categorisation_0.transaction_id);
-        assert_eq!(transform_id("0"), transaction_categorisation_0.bucket_id);
-        assert_eq!("notes A", transaction_categorisation_0.description);
-
-        let transaction_categorisation_1 = transaction_categorisations
-            .iter()
-            .filter(|tc| tc.quantity == 300)
-            .last()
-            .unwrap();
-        assert_eq!(transaction.id, transaction_categorisation_1.transaction_id);
-        assert_eq!(transform_id("0"), transaction_categorisation_1.bucket_id);
-        assert_eq!("notes B", transaction_categorisation_1.description);
+        assert_eq!(100, transaction.amount);
     }
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_zero_budgets.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_zero_budgets.rs
new file mode 100644
index 0000000..07ecd56
--- /dev/null
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_zero_budgets.rs
@@ -0,0 +1,6 @@
+use actualbudget_models::ActualbudgetZeroBudget;
+use schist_models::pipe::Pipe;
+
+pub fn transform_zero_budgets(_actualbudget_zero_budgets: &[ActualbudgetZeroBudget]) -> Vec<Pipe> {
+    todo!()
+}
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/account_transfer_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/account_transfer_matchers.rs
index ea3180e..f3e3037 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/account_transfer_matchers.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/account_transfer_matchers.rs
@@ -3,11 +3,10 @@ use schist_models::{account::Account, account_transfer::AccountTransfer};
 
 use super::ACCOUNT_NAMES_DICT;
 
-pub fn get_account_transfer_matchers(
-) -> Vec<Box<dyn Fn(&AccountTransfer, &[Account]) -> bool>> {
-    vec![
-        Box::new(|at, a| matches_cash_withdrawal_10_sept_2024(at, a)),
-    ]
+pub fn get_account_transfer_matchers() -> Vec<Box<dyn Fn(&AccountTransfer, &[Account]) -> bool>> {
+    vec![Box::new(|at, a| {
+        matches_cash_withdrawal_10_sept_2024(at, a)
+    })]
 }
 
 fn matches_cash_withdrawal_10_sept_2024(
@@ -33,13 +32,15 @@ fn matches_cash_withdrawal_10_sept_2024(
             id: _id,
             date,
             description,
-            quantity: 80_00,
+            amount: 80_00,
             from_account_id,
             to_account_id,
-        } => *date == "2024-09-10".parse().unwrap()
-            && *description == ""
-            && *from_account_id == bank_account.id
-            && *to_account_id == cash_account.id,
+        } => {
+            *date == "2024-09-10".parse().unwrap()
+                && *description == ""
+                && *from_account_id == bank_account.id
+                && *to_account_id == cash_account.id
+        }
         _ => false,
     }
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs
index 76189d3..5f5ef4f 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs
@@ -1,34 +1,16 @@
-use schist_models::{budget_period_unit::BudgetPeriodUnit, bucket::Bucket};
+use schist_models::bucket::Bucket;
 
-use super::bucket_names::{BUCKET_NAMES, BUCKET_NAME_BILLS, BUCKET_NAME_BILLS_FLEXIBLE, BUCKET_NAME_FOOD, BUCKET_NAME_GENERAL, BUCKET_NAME_INCOME, BUCKET_NAME_SAVINGS, BUCKET_NAME_STARTING_BALANCES};
+use super::bucket_names::BUCKET_NAMES;
 
-pub fn get_bucket_matchers(
-) -> Vec<Box<dyn Fn(&Bucket) -> bool>> {
+pub fn get_bucket_matchers() -> Vec<Box<dyn Fn(&Bucket) -> bool>> {
     BUCKET_NAMES
         .iter()
         .map(|bucket_name| -> Box<dyn Fn(&Bucket) -> bool> {
             Box::new(|c| matches_bucket(c, bucket_name))
-        }).collect()
+        })
+        .collect()
 }
 
-fn matches_bucket(bucket: &Bucket, bucket_name: &str,) -> bool {
-    bucket.name == bucket_name
-    && bucket.balance == 0
-    && bucket.balance_date < "2024-08-01".parse().unwrap()
-    && bucket.budget_period == 1
-    && bucket.budget_period_unit == BudgetPeriodUnit::Month
-    && bucket.budget_quantity == get_expected_budget_quantity(bucket_name)
-}
-
-fn get_expected_budget_quantity(bucket_name: &str) -> i32 {
-    match bucket_name {
-        BUCKET_NAME_FOOD => 200_00,
-        BUCKET_NAME_GENERAL => 100_00,
-        BUCKET_NAME_BILLS => 125_00,
-        BUCKET_NAME_BILLS_FLEXIBLE => 25_00,
-        BUCKET_NAME_SAVINGS => 400_00,
-        BUCKET_NAME_STARTING_BALANCES => 0,
-        BUCKET_NAME_INCOME => 0,
-        _ => panic!("unexpected bucket name {}", bucket_name),
-    }
+fn matches_bucket(bucket: &Bucket, bucket_name: &str) -> bool {
+    bucket.name == bucket_name && bucket.balance == None && bucket.balance_cache_key == None
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs
index 3b46d76..038e4f7 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs
@@ -2,11 +2,10 @@ use schist_models::{bucket::Bucket, bucket_transfer::BucketTransfer};
 
 use super::bucket_names::{BUCKET_NAME_GENERAL, BUCKET_NAME_SAVINGS};
 
-pub fn get_bucket_transfer_matchers(
-) -> Vec<Box<dyn Fn(&BucketTransfer, &[Bucket]) -> bool>> {
-    vec![
-        Box::new(|ct, c| matches_120_savings_to_general_23_oct_2024(ct, c)),
-    ]
+pub fn get_bucket_transfer_matchers() -> Vec<Box<dyn Fn(&BucketTransfer, &[Bucket]) -> bool>> {
+    vec![Box::new(|ct, c| {
+        matches_120_savings_to_general_23_oct_2024(ct, c)
+    })]
 }
 
 fn matches_120_savings_to_general_23_oct_2024(
@@ -27,12 +26,14 @@ fn matches_120_savings_to_general_23_oct_2024(
         BucketTransfer {
             id: _id,
             description,
-            quantity: 120_00,
+            amount: 120_00,
             from_bucket_id,
             to_bucket_id,
-        } => *from_bucket_id == savings_bucket.id
-            && *to_bucket_id == general_bucket.id
-            && description.as_str() == "",
+        } => {
+            *from_bucket_id == savings_bucket.id
+                && *to_bucket_id == general_bucket.id
+                && description.as_str() == ""
+        }
         _ => false,
     }
 }
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs
index 97f81a2..bd42d76 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/budget_drip_matchers.rs
@@ -1,9 +1,12 @@
 use std::sync::LazyLock;
 
-use schist_models::{budget_drip::BudgetDrip, bucket::Bucket, date_utc::DateUtc};
+use schist_models::{bucket::Bucket, date_utc::DateUtc, drip::Drip};
 use schist_traits::dateable::Dateable;
 
-use crate::common::bucket_names::{BUCKET_NAME_BILLS, BUCKET_NAME_BILLS_FLEXIBLE, BUCKET_NAME_FOOD, BUCKET_NAME_GENERAL, BUCKET_NAME_SAVINGS};
+use crate::common::bucket_names::{
+    BUCKET_NAME_BILLS, BUCKET_NAME_BILLS_FLEXIBLE, BUCKET_NAME_FOOD, BUCKET_NAME_GENERAL,
+    BUCKET_NAME_SAVINGS,
+};
 
 pub fn get_num_expected_budget_drips() -> usize {
     let num_expected_dates = DATES.len();
@@ -11,12 +14,11 @@ pub fn get_num_expected_budget_drips() -> usize {
     num_expected_dates * num_expected_buckets
 }
 
-pub fn assert_budget_drip_matches(
-    budget_drip: &BudgetDrip,
-    buckets: &[Bucket],
-) {
+pub fn assert_budget_drip_matches(budget_drip: &Drip, buckets: &[Bucket]) {
     assert!(
-        DATES.iter().any(|date| *LazyLock::force(date) == budget_drip.date),
+        DATES
+            .iter()
+            .any(|date| *LazyLock::force(date) == budget_drip.date),
         "budget drip had unexpected date: {:?}",
         budget_drip,
     );
@@ -25,11 +27,13 @@ pub fn assert_budget_drip_matches(
         .iter()
         .find(|c| c.id == budget_drip.bucket_id)
         .map(|c| c.name.clone())
-        .expect(format!(
-            "budget drip {:?} had unexpected bucket ID. buckets were: {:?}",
-            budget_drip,
-            buckets,
-        ).as_str());
+        .expect(
+            format!(
+                "budget drip {:?} had unexpected bucket ID. buckets were: {:?}",
+                budget_drip, buckets,
+            )
+            .as_str(),
+        );
 
     let expected_quantity = match (
         bucket_name.as_str(),
@@ -58,7 +62,9 @@ pub fn assert_budget_drip_matches(
         (BUCKET_NAME_BILLS_FLEXIBLE, 8 | 10, _) => 80,
         (BUCKET_NAME_BILLS_FLEXIBLE, 9 | 11, 1) => 93,
         (BUCKET_NAME_BILLS_FLEXIBLE, 9 | 11, _) => 83,
-        (BUCKET_NAME_BILLS_FLEXIBLE, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
+        (BUCKET_NAME_BILLS_FLEXIBLE, _, _) => {
+            panic!("budget drip {:?} had unexpected date", budget_drip)
+        }
 
         (BUCKET_NAME_SAVINGS, 8 | 10, 1) => 13_00,
         (BUCKET_NAME_SAVINGS, 8 | 10, _) => 12_90,
@@ -68,14 +74,12 @@ pub fn assert_budget_drip_matches(
 
         (_, _, _) => panic!(
             "budget drip {:?} had unexpected bucket name {}",
-            budget_drip,
-            bucket_name,
+            budget_drip, bucket_name,
         ),
     };
 
     assert_eq!(
-        expected_quantity,
-        budget_drip.quantity,
+        expected_quantity, budget_drip.amount,
         "budget drip {:?} had unexpected quantity",
         budget_drip,
     );
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs
index 62255b0..f067d0d 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/mod.rs
@@ -1,23 +1,22 @@
 mod account_matchers;
 mod account_names;
 mod account_transfer_matchers;
-mod budget_drip_matchers;
 mod bucket_matchers;
 mod bucket_names;
 mod bucket_transfer_matchers;
+mod budget_drip_matchers;
 mod db_url;
 mod test_context;
 mod transaction_matchers;
-mod transaction_categorisation_matchers;
 
 pub use account_matchers::get_account_matchers;
 pub use account_names::ACCOUNT_NAMES_DICT;
 pub use account_transfer_matchers::get_account_transfer_matchers;
-pub use budget_drip_matchers::assert_budget_drip_matches;
-pub use budget_drip_matchers::get_num_expected_budget_drips;
-pub use bucket_names::BUCKET_NAMES_DICT;
 pub use bucket_matchers::get_bucket_matchers;
+pub use bucket_names::BUCKET_NAMES_DICT;
 pub use bucket_transfer_matchers::get_bucket_transfer_matchers;
+pub use budget_drip_matchers::assert_budget_drip_matches;
+pub use budget_drip_matchers::get_num_expected_budget_drips;
 pub use db_url::TEST_IN_DB_URL;
 pub use db_url::TEST_OUT_DB_URL;
 pub use test_context::TestContext;
@@ -26,4 +25,3 @@ pub use transaction_matchers::matches_bank_account_initial_transaction;
 pub use transaction_matchers::matches_cash_account_initial_transaction;
 pub use transaction_matchers::matches_food_transaction;
 pub use transaction_matchers::matches_income_transaction;
-pub use transaction_categorisation_matchers::get_transaction_categorisation_matchers;
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_categorisation_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_categorisation_matchers.rs
deleted file mode 100644
index 8082055..0000000
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_categorisation_matchers.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-use schist_models::{account::Account, bucket::Bucket, transaction::Transaction, transaction_categorisation::TransactionCategorisation};
-
-use super::{bucket_names::{BUCKET_NAME_FOOD, BUCKET_NAME_INCOME, BUCKET_NAME_STARTING_BALANCES}, matches_bank_account_initial_transaction, matches_cash_account_initial_transaction, matches_food_transaction, matches_income_transaction};
-
-pub fn get_transaction_categorisation_matchers(
-) -> Vec<Box<dyn Fn(&TransactionCategorisation, &[Transaction], &[Bucket], &[Account]) -> bool>> {
-    vec![
-        Box::new(|tc, t, c, a| matches_bank_account_initial_transaction_categorisation(tc, t, c, a)),
-        Box::new(|tc, t, c, a| matches_cash_account_initial_transaction_categorisation(tc, t, c, a)),
-        Box::new(|tc, t, c, a| matches_income_transaction_categorisation(tc, t, c, a, "08")),
-        Box::new(|tc, t, c, a| matches_income_transaction_categorisation(tc, t, c, a, "09")),
-        Box::new(|tc, t, c, a| matches_income_transaction_categorisation(tc, t, c, a, "10")),
-        Box::new(|tc, t, c, a| matches_income_transaction_categorisation(tc, t, c, a, "11")),
-        Box::new(|tc, t, c, a| matches_food_transaction_categorisation(tc, t, c, a, "08")),
-        Box::new(|tc, t, c, a| matches_food_transaction_categorisation(tc, t, c, a, "09")),
-        Box::new(|tc, t, c, a| matches_food_transaction_categorisation(tc, t, c, a, "10")),
-        Box::new(|tc, t, c, a| matches_food_transaction_categorisation(tc, t, c, a, "11")),
-    ]
-}
-
-fn matches_bank_account_initial_transaction_categorisation(
-    transaction_categorisation: &TransactionCategorisation,
-    transactions: &[Transaction],
-    buckets: &[Bucket],
-    accounts: &[Account],
-) -> bool {
-    let bank_account_initial_transaction = transactions
-        .iter()
-        .find(|t| matches_bank_account_initial_transaction(t, accounts))
-        .expect("failed to find bank account initial transaction");
-
-    let starting_balance_bucket = buckets
-        .iter()
-        .find(|c| c.name == BUCKET_NAME_STARTING_BALANCES)
-        .expect("failed to find starting balance bucket");
-
-    match transaction_categorisation {
-        TransactionCategorisation {
-            id: _id,
-            description,
-            quantity: 1200_00,
-            transaction_id,
-            bucket_id,
-        } => description == ""
-            && *transaction_id == bank_account_initial_transaction.id
-            && *bucket_id == starting_balance_bucket.id,
-        _ => false,
-    }
-}
-
-fn matches_cash_account_initial_transaction_categorisation(
-    transaction_categorisation: &TransactionCategorisation,
-    transactions: &[Transaction],
-    buckets: &[Bucket],
-    accounts: &[Account],
-) -> bool {
-    let cash_account_initial_transaction = transactions
-        .iter()
-        .find(|t| matches_cash_account_initial_transaction(t, accounts))
-        .expect("failed to find cash account initial transaction");
-
-    let starting_balance_bucket = buckets
-        .iter()
-        .find(|c| c.name == BUCKET_NAME_STARTING_BALANCES)
-        .expect("failed to find starting balance bucket");
-
-    match transaction_categorisation {
-        TransactionCategorisation {
-            id: _id,
-            description,
-            quantity: 45_10,
-            transaction_id,
-            bucket_id,
-        } => description == ""
-            && *transaction_id == cash_account_initial_transaction.id
-            && *bucket_id == starting_balance_bucket.id,
-        _ => false,
-    }
-}
-
-fn matches_income_transaction_categorisation(
-    transaction_categorisation: &TransactionCategorisation,
-    transactions: &[Transaction],
-    buckets: &[Bucket],
-    accounts: &[Account],
-    month: &str,
-) -> bool {
-    let income_transaction = transactions
-        .iter()
-        .find(|t| matches_income_transaction(t, accounts, month))
-        .expect(format!("failed to find income transaction for month {}", month).as_str());
-
-    let income_bucket = buckets
-        .iter()
-        .find(|c| c.name == BUCKET_NAME_INCOME)
-        .expect("failed to find income bucket");
-
-    match transaction_categorisation {
-        TransactionCategorisation {
-            id: _id,
-            description,
-            quantity: 846_46,
-            transaction_id,
-            bucket_id,
-        } => description == ""
-            && *transaction_id == income_transaction.id
-            && *bucket_id == income_bucket.id,
-        _ => false,
-    }
-}
-
-fn matches_food_transaction_categorisation(
-    transaction_categorisation: &TransactionCategorisation,
-    transactions: &[Transaction],
-    buckets: &[Bucket],
-    accounts: &[Account],
-    month: &str,
-) -> bool {
-    let food_transaction = transactions
-        .iter()
-        .find(|t| matches_food_transaction(t, accounts, month))
-        .expect(format!("failed to find food transaction for month {}", month).as_str());
-
-    let food_bucket = buckets
-        .iter()
-        .find(|c| c.name == BUCKET_NAME_FOOD)
-        .expect("failed to find food bucket");
-
-    match transaction_categorisation {
-        TransactionCategorisation {
-            id: _id,
-            description,
-            quantity: -200_00,
-            transaction_id,
-            bucket_id,
-        } => description == ""
-            && *transaction_id == food_transaction.id
-            && *bucket_id == food_bucket.id,
-        _ => false,
-    }
-}
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_matchers.rs
index c3763c1..ea22054 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_matchers.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/transaction_matchers.rs
@@ -2,8 +2,7 @@ use schist_models::{account::Account, transaction::Transaction};
 
 use super::ACCOUNT_NAMES_DICT;
 
-pub fn get_transaction_matchers(
-) -> Vec<Box<dyn Fn(&Transaction, &[Account]) -> bool>> {
+pub fn get_transaction_matchers() -> Vec<Box<dyn Fn(&Transaction, &[Account]) -> bool>> {
     vec![
         Box::new(|t, a| matches_bank_account_initial_transaction(t, a)),
         Box::new(|t, a| matches_cash_account_initial_transaction(t, a)),
@@ -18,10 +17,7 @@ pub fn get_transaction_matchers(
     ]
 }
 
-pub fn matches_bank_account_initial_transaction(
-    t: &Transaction,
-    accounts: &[Account],
-) -> bool {
+pub fn matches_bank_account_initial_transaction(t: &Transaction, accounts: &[Account]) -> bool {
     let bank_account_id = accounts
         .iter()
         .find(|a| a.name == ACCOUNT_NAMES_DICT.bank_account)
@@ -32,23 +28,24 @@ pub fn matches_bank_account_initial_transaction(
     match t {
         Transaction {
             account_id,
+            bucket_id,
             date,
             id: _id,
             description,
-            payee,
-            quantity: 1200_00,
-        } => *account_id == bank_account_id
-            && *date == "2024-08-01".parse().unwrap()
-            && description == ""
-            && payee == "Starting Balance",
+            counterparty: payee,
+            amount: 1200_00,
+        } => {
+            *account_id == bank_account_id
+                && *bucket_id == get_bucket_id()
+                && *date == "2024-08-01".parse().unwrap()
+                && description == ""
+                && payee == "Starting Balance"
+        }
         _ => false,
     }
 }
 
-pub fn matches_cash_account_initial_transaction(
-    t: &Transaction,
-    accounts: &[Account],
-) -> bool {
+pub fn matches_cash_account_initial_transaction(t: &Transaction, accounts: &[Account]) -> bool {
     let bank_account_id = accounts
         .iter()
         .find(|a| a.name == ACCOUNT_NAMES_DICT.cash_account)
@@ -59,24 +56,24 @@ pub fn matches_cash_account_initial_transaction(
     match t {
         Transaction {
             account_id,
+            bucket_id,
             date,
             id: _id,
             description,
-            payee,
-            quantity: 45_10,
-        } => *account_id == bank_account_id
-            && *date == "2024-08-01".parse().unwrap()
-            && description == ""
-            && payee == "Starting Balance",
+            counterparty: payee,
+            amount: 45_10,
+        } => {
+            *account_id == bank_account_id
+                && *bucket_id == get_bucket_id()
+                && *date == "2024-08-01".parse().unwrap()
+                && description == ""
+                && payee == "Starting Balance"
+        }
         _ => false,
     }
 }
 
-pub fn matches_income_transaction(
-    t: &Transaction,
-    accounts: &[Account],
-    month: &str,
-) -> bool {
+pub fn matches_income_transaction(t: &Transaction, accounts: &[Account], month: &str) -> bool {
     let bank_account_id = accounts
         .iter()
         .find(|a| a.name == ACCOUNT_NAMES_DICT.bank_account)
@@ -87,25 +84,24 @@ pub fn matches_income_transaction(
     match t {
         Transaction {
             account_id,
+            bucket_id,
             date,
             description,
             id: _id,
-            payee,
-            quantity: 846_46,
-        } =>
+            counterparty: payee,
+            amount: 846_46,
+        } => {
             *account_id == bank_account_id
+                && *bucket_id == get_bucket_id()
                 && *date == format!("2024-{}-21", month).parse().unwrap()
                 && description == "Salary"
-                && payee == "Employer Ltd",
+                && payee == "Employer Ltd"
+        }
         _ => false,
     }
 }
 
-pub fn matches_food_transaction(
-    t: &Transaction,
-    accounts: &[Account],
-    month: &str,
-) -> bool {
+pub fn matches_food_transaction(t: &Transaction, accounts: &[Account], month: &str) -> bool {
     let bank_account_id = accounts
         .iter()
         .find(|a| a.name == ACCOUNT_NAMES_DICT.bank_account)
@@ -116,15 +112,23 @@ pub fn matches_food_transaction(
     match t {
         Transaction {
             account_id,
+            bucket_id,
             date,
             description,
             id: _id,
-            payee,
-            quantity: -200_00,
-        } => *account_id == bank_account_id
-            && *date == format!("2024-{}-08", month).parse().unwrap()
-            && description == ""
-            && payee == "Tesco",
+            counterparty: payee,
+            amount: -200_00,
+        } => {
+            *account_id == bank_account_id
+                && *bucket_id == get_bucket_id()
+                && *date == format!("2024-{}-08", month).parse().unwrap()
+                && description == ""
+                && payee == "Tesco"
+        }
         _ => false,
     }
 }
+
+fn get_bucket_id() -> Option<i32> {
+    todo!()
+}
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs
index 4c13d55..62e1159 100644
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/run.rs
@@ -1,9 +1,18 @@
 pub mod common;
 
 use actualbudget_to_schist_transformer::run::run;
-use common::{assert_budget_drip_matches, get_account_matchers, get_account_transfer_matchers, get_bucket_matchers, get_bucket_transfer_matchers, get_num_expected_budget_drips, get_transaction_categorisation_matchers, get_transaction_matchers, TestContext, TEST_IN_DB_URL, TEST_OUT_DB_URL};
+use common::{
+    assert_budget_drip_matches, get_account_matchers, get_account_transfer_matchers,
+    get_bucket_matchers, get_bucket_transfer_matchers, get_num_expected_budget_drips,
+    get_transaction_matchers, TestContext, TEST_IN_DB_URL, TEST_OUT_DB_URL,
+};
 use diesel::{Connection, SqliteConnection};
-use schist_queries::{account_transfers::get_all_account_transfers, accounts::get_all_accounts, budget_drips::get_all_budget_drips, buckets::get_all_buckets, bucket_transfers::get_all_bucket_transfers, transaction_categorisations::get_all_transaction_categorisations, transactions::get_all_transactions};
+use schist_models::pipe::Pipe;
+use schist_queries::{
+    account_transfers::get_all_account_transfers, accounts::get_all_accounts,
+    bucket_transfers::get_all_bucket_transfers, buckets::get_all_buckets, drips::get_all_drips,
+    pipes::get_all_pipes, transactions::get_all_transactions,
+};
 
 #[test]
 fn given_test_database_when_run_then_exports_expected_schist_state() {
@@ -12,11 +21,11 @@ fn given_test_database_when_run_then_exports_expected_schist_state() {
     let connection = &mut SqliteConnection::establish(TEST_OUT_DB_URL).unwrap();
     let accounts = get_all_accounts(connection).unwrap();
     let account_transfers = get_all_account_transfers(connection).unwrap();
-    let budget_drips = get_all_budget_drips(connection).unwrap();
+    let drips = get_all_drips(connection).unwrap();
     let buckets = get_all_buckets(connection).unwrap();
     let bucket_transfers = get_all_bucket_transfers(connection).unwrap();
+    let pipes = get_all_pipes(connection).unwrap();
     let transactions = get_all_transactions(connection).unwrap();
-    let transaction_categorisations = get_all_transaction_categorisations(connection).unwrap();
 
     let account_matchers = get_account_matchers();
     assert_eq!(account_matchers.len(), accounts.len());
@@ -32,14 +41,16 @@ fn given_test_database_when_run_then_exports_expected_schist_state() {
     assert_eq!(account_transfer_matchers.len(), account_transfers.len());
     for account_transfer in account_transfers {
         assert!(
-            account_transfer_matchers.iter().any(|m| m(&account_transfer, &accounts)),
+            account_transfer_matchers
+                .iter()
+                .any(|m| m(&account_transfer, &accounts)),
             "no match found for account_transfer {:?}",
             account_transfer,
         );
     }
 
-    assert_eq!(get_num_expected_budget_drips(), budget_drips.len());
-    for budget_drip in budget_drips {
+    assert_eq!(get_num_expected_budget_drips(), drips.len());
+    for budget_drip in drips {
         assert_budget_drip_matches(&budget_drip, &buckets);
     }
 
@@ -57,7 +68,9 @@ fn given_test_database_when_run_then_exports_expected_schist_state() {
     assert_eq!(bucket_transfer_matchers.len(), bucket_transfers.len());
     for bucket_transfer in bucket_transfers {
         assert!(
-            bucket_transfer_matchers.iter().any(|m| m(&bucket_transfer, &buckets)),
+            bucket_transfer_matchers
+                .iter()
+                .any(|m| m(&bucket_transfer, &buckets)),
             "no match found for bucket_transfer {:?}",
             bucket_transfer,
         );
@@ -67,24 +80,13 @@ fn given_test_database_when_run_then_exports_expected_schist_state() {
     assert_eq!(transaction_matchers.len(), transactions.len());
     for transaction in transactions.clone() {
         assert!(
-            transaction_matchers.iter().any(|m| m(&transaction, &accounts)),
+            transaction_matchers
+                .iter()
+                .any(|m| m(&transaction, &accounts)),
             "no match found for transaction {:?}",
             transaction,
         );
     }
 
-    let transaction_categorisation_matchers = get_transaction_categorisation_matchers();
-    assert_eq!(transaction_categorisation_matchers.len(), transaction_categorisations.len());
-    for transaction_categorisation in transaction_categorisations {
-        assert!(
-            transaction_categorisation_matchers.iter().any(|m| m(
-                &transaction_categorisation,
-                &transactions,
-                &buckets,
-                &accounts,
-            )),
-            "no match found for transaction_categorisation {:?}",
-            transaction_categorisation,
-        );
-    }
+    assert_eq!(Vec::<Pipe>::new(), pipes);
 }