rename category -> bucket

16 files changed, 302 insertions, 301 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 370a0e8..a6c850e 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,28 +1,28 @@
 use anyhow::Result;
 use diesel::SqliteConnection;
 use schist_models::{
-    account::Account, account_transfer::AccountTransfer, budget_drip::BudgetDrip, category::Category, category_transfer::CategoryTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation
+    account::Account, account_transfer::AccountTransfer, budget_drip::BudgetDrip, bucket::Bucket, bucket_transfer::BucketTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation
 };
 
 pub struct SchistState {
     pub first_transaction_date: DateUtc,
     pub accounts: Vec<Account>,
     pub account_transfers: Vec<AccountTransfer>,
-    pub categories: Vec<Category>,
+    pub buckets: Vec<Bucket>,
     pub budget_drips: Vec<BudgetDrip>,
     pub transactions: Vec<Transaction>,
     pub transaction_categorisations: Vec<TransactionCategorisation>,
-    pub category_transfers: Vec<CategoryTransfer>,
+    pub bucket_transfers: Vec<BucketTransfer>,
 }
 
 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::categories::insert_categories(&schist_state.categories, 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::category_transfers::insert_category_transfers(&schist_state.category_transfers, 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/transform_budget_drips.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/src/transform_state/transform_budget_drips.rs
index 1163e56..01289a0 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
@@ -58,7 +58,7 @@ fn map_actualbudget_zero_budget_to_budget_drips(
     let budget_drips: Vec<BudgetDrip> = days_in_month.iter().map(|&date|
         BudgetDrip {
             id: transform_budget_drip_id(&actualbudget_zero_budget, &date),
-            category_id: transform_id(&actualbudget_zero_budget.category_id),
+            bucket_id: transform_id(&actualbudget_zero_budget.category_id),
             date,
             quantity: if date == first_day_of_month {
                 quantity + remainder_quantity
@@ -277,28 +277,28 @@ mod test {
 
         let budget_drips_jan_category_0: Vec<&BudgetDrip> = budget_drips
             .iter()
-            .filter(|bd| bd.category_id == category_0_id && bd.date.month() == 1)
+            .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));
 
         let budget_drips_jan_category_1: Vec<&BudgetDrip> = budget_drips
             .iter()
-            .filter(|bd| bd.category_id == category_1_id && bd.date.month() == 1)
+            .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));
 
         let budget_drips_feb_category_0: Vec<&BudgetDrip> = budget_drips
             .iter()
-            .filter(|bd| bd.category_id == category_0_id && bd.date.month() == 2)
+            .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));
 
         let budget_drips_feb_category_1: Vec<&BudgetDrip> = budget_drips
             .iter()
-            .filter(|bd| bd.category_id == category_1_id && bd.date.month() == 2)
+            .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));
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 17ce194..2a21860 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,6 +1,6 @@
 use actualbudget_models::{ActualbudgetCategory, ActualbudgetZeroBudget};
 use itertools::Itertools;
-use schist_models::{budget_period_unit::BudgetPeriodUnit, category::Category, date_utc::DateUtc};
+use schist_models::{budget_period_unit::BudgetPeriodUnit, bucket::Bucket, date_utc::DateUtc};
 
 use super::transform_id;
 
@@ -8,7 +8,7 @@ pub fn transform_categories(
     actualbudget_categories: &[ActualbudgetCategory],
     actualbudget_zero_budgets: &[ActualbudgetZeroBudget],
     before_first_activity: &DateUtc,
-) -> Vec<Category> {
+) -> Vec<Bucket> {
     let last_non_zero_month = actualbudget_zero_budgets
         .iter()
         .map(|zb| zb.month.clone())
@@ -28,7 +28,7 @@ pub fn transform_categories(
         actualbudget_zero_budgets
     };
 
-    actualbudget_categories.iter().map(|actualbudget_category| Category {
+    actualbudget_categories.iter().map(|actualbudget_category| Bucket {
         id: transform_id(&actualbudget_category.id.clone()),
         name: actualbudget_category.name.clone(),
         balance: 0,
@@ -36,6 +36,7 @@ pub fn transform_categories(
         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()
 }
 
@@ -75,20 +76,20 @@ mod test {
         ];
         let before_first_transaction = DateUtc::now();
 
-        let categories = transform_categories(
+        let buckets = transform_categories(
             &actualbudget_categories,
             &actualbudget_zero_budgets,
             &before_first_transaction,
         );
 
-        assert_eq!(1, categories.len());
-        let category = categories.get(0).unwrap();
-        assert_eq!("Food", category.name);
-        assert_eq!(0, category.balance);
-        assert_eq!(before_first_transaction, category.balance_date);
-        assert_eq!(1, category.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, category.budget_period_unit);
-        assert_eq!(100, category.budget_quantity);
+        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!(100, bucket.budget_quantity);
     }
 
     #[test]
@@ -99,20 +100,20 @@ mod test {
         let actualbudget_zero_budgets = [];
         let before_first_transaction = DateUtc::now();
 
-        let categories = transform_categories(
+        let buckets = transform_categories(
             &actualbudget_categories,
             &actualbudget_zero_budgets,
             &before_first_transaction,
         );
 
-        assert_eq!(1, categories.len());
-        let category = categories.get(0).unwrap();
-        assert_eq!("Food", category.name);
-        assert_eq!(0, category.balance);
-        assert_eq!(before_first_transaction, category.balance_date);
-        assert_eq!(1, category.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, category.budget_period_unit);
-        assert_eq!(0, category.budget_quantity);
+        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);
     }
 
     #[test]
@@ -130,20 +131,20 @@ mod test {
         ];
         let before_first_transaction = DateUtc::now();
 
-        let categories = transform_categories(
+        let buckets = transform_categories(
             &actualbudget_categories,
             &actualbudget_zero_budgets,
             &before_first_transaction,
         );
 
-        assert_eq!(1, categories.len());
-        let category = categories.get(0).unwrap();
-        assert_eq!("Food", category.name);
-        assert_eq!(0, category.balance);
-        assert_eq!(before_first_transaction, category.balance_date);
-        assert_eq!(1, category.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, category.budget_period_unit);
-        assert_eq!(300, category.budget_quantity);
+        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);
     }
 
     #[test]
@@ -169,36 +170,36 @@ mod test {
         ];
         let before_first_transaction = DateUtc::now();
 
-        let categories = transform_categories(
+        let buckets = transform_categories(
             &actualbudget_categories,
             &actualbudget_zero_budgets,
             &before_first_transaction,
         );
 
-        assert_eq!(3, categories.len());
-
-        let category_0 = categories.iter().filter(|c| c.id == transform_id("0")).last().unwrap();
-        assert_eq!("Food", category_0.name);
-        assert_eq!(0, category_0.balance);
-        assert_eq!(before_first_transaction, category_0.balance_date);
-        assert_eq!(1, category_0.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, category_0.budget_period_unit);
-        assert_eq!(300, category_0.budget_quantity);
-
-        let category_1 = categories.iter().filter(|c| c.id == transform_id("1")).last().unwrap();
-        assert_eq!("Clothes", category_1.name);
-        assert_eq!(0, category_1.balance);
-        assert_eq!(before_first_transaction, category_1.balance_date);
-        assert_eq!(1, category_1.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, category_1.budget_period_unit);
-        assert_eq!(310, category_1.budget_quantity);
-
-        let category_2 = categories.iter().filter(|c| c.id == transform_id("2")).last().unwrap();
-        assert_eq!("Rent", category_2.name);
-        assert_eq!(0, category_2.balance);
-        assert_eq!(before_first_transaction, category_2.balance_date);
-        assert_eq!(1, category_2.budget_period);
-        assert_eq!(BudgetPeriodUnit::Month, category_2.budget_period_unit);
-        assert_eq!(320, category_2.budget_quantity);
+        assert_eq!(3, buckets.len());
+
+        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);
+
+        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);
+
+        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);
     }
 }
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 318e88c..11ed2e3 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
@@ -4,14 +4,14 @@ use actualbudget_models::{
 };
 use anyhow::{bail, Context, Result};
 use itertools::Itertools;
-use schist_models::category_transfer::CategoryTransfer;
+use schist_models::bucket_transfer::BucketTransfer;
 
 use super::{is_category_transfer, transform_id};
 
 pub fn transform_category_transfers(
     actualbudget_transactions: &[ActualbudgetTransaction],
     actualbudget_category_transfers_account: &Option<ActualbudgetAccount>,
-) -> Result<Vec<CategoryTransfer>> {
+) -> Result<Vec<BucketTransfer>> {
     let actualbudget_category_transfers = actualbudget_transactions
         .iter()
         .filter(|transaction|
@@ -32,7 +32,7 @@ pub fn transform_category_transfers(
         .map(|pct| transform_category_transfer(pct, &actualbudget_child_category_transfers))
         .filter_ok(Option::is_some)
         .map_ok(Option::unwrap)
-        .collect::<Result<Vec<CategoryTransfer>>>()
+        .collect::<Result<Vec<BucketTransfer>>>()
         .with_context(|| "failed to transform category transfers")?
     )
 }
@@ -40,7 +40,7 @@ pub fn transform_category_transfers(
 fn transform_category_transfer(
     actualbudget_parent_category_transfer: &ActualbudgetTransaction,
     actualbudget_child_category_transfers: &[ActualbudgetTransaction],
-) -> Result<Option<CategoryTransfer>> {
+) -> Result<Option<BucketTransfer>> {
     transform_category_transfer_without_context(
         actualbudget_parent_category_transfer,
         actualbudget_child_category_transfers,
@@ -50,7 +50,7 @@ fn transform_category_transfer(
 fn transform_category_transfer_without_context(
     actualbudget_parent_category_transfer: &ActualbudgetTransaction,
     actualbudget_child_category_transfers: &[ActualbudgetTransaction],
-) -> Result<Option<CategoryTransfer>> {
+) -> Result<Option<BucketTransfer>> {
     let actualbudget_child_category_transfers = actualbudget_child_category_transfers
         .iter()
         .filter(|t|
@@ -100,15 +100,15 @@ fn transform_category_transfer_without_context(
         bail!("actualbudget category transfer amounts did not sum to zero");
     }
 
-    Ok(Some(CategoryTransfer {
+    Ok(Some(BucketTransfer {
         id: transform_id(&actualbudget_parent_category_transfer.id),
         description: actualbudget_parent_category_transfer
             .notes
             .clone()
             .unwrap_or_else(String::new),
         quantity: to_transfer.amount.try_into().unwrap(),
-        from_category_id,
-        to_category_id,
+        from_bucket_id: from_category_id,
+        to_bucket_id: to_category_id,
     }))
 }
 
@@ -116,7 +116,7 @@ fn transform_category_transfer_without_context(
 mod test {
     use actualbudget_fakes::{actualbudget_account::make_fake_actualbudget_account, actualbudget_transaction::make_fake_actualbudget_transaction_builder};
     use actualbudget_models::{ActualbudgetTransaction, ActualbudgetTransactionBuilder};
-    use schist_models::category_transfer::CategoryTransfer;
+    use schist_models::bucket_transfer::BucketTransfer;
 
     use crate::transform_state::transform_id::transform_id;
 
@@ -137,13 +137,13 @@ mod test {
         );
 
         assert!(result.is_ok());
-        let category_transfers = result.unwrap();
-        assert_eq!(1, category_transfers.len());
-        let category_transfer = category_transfers.get(0).unwrap();
-        assert_eq!(100, category_transfer.quantity);
-        assert_eq!("I was a parent transaction", category_transfer.description);
-        assert_eq!(transform_id("0"), category_transfer.from_category_id);
-        assert_eq!(transform_id("1"), category_transfer.to_category_id);
+        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!("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);
     }
 
     #[test]
@@ -166,26 +166,26 @@ mod test {
         );
 
         assert!(result.is_ok());
-        let category_transfers = result.unwrap();
-        assert_eq!(2, category_transfers.len());
+        let bucket_transfers = result.unwrap();
+        assert_eq!(2, bucket_transfers.len());
 
-        let category_transfer_0: Vec<&CategoryTransfer> = category_transfers
+        let bucket_transfer_0: Vec<&BucketTransfer> = bucket_transfers
             .iter()
             .filter(|ct| ct.quantity == 100)
             .collect();
-        assert_eq!(1, category_transfer_0.len());
-        let category_transfer_0 = category_transfer_0.get(0).unwrap();
-        assert_eq!(transform_id("0"), category_transfer_0.from_category_id);
-        assert_eq!(transform_id("1"), category_transfer_0.to_category_id);
+        assert_eq!(1, bucket_transfer_0.len());
+        let bucket_transfer_0 = bucket_transfer_0.get(0).unwrap();
+        assert_eq!(transform_id("0"), bucket_transfer_0.from_bucket_id);
+        assert_eq!(transform_id("1"), bucket_transfer_0.to_bucket_id);
 
-        let category_transfer_1: Vec<&CategoryTransfer> = category_transfers
+        let bucket_transfer_1: Vec<&BucketTransfer> = bucket_transfers
             .iter()
             .filter(|ct| ct.quantity == 200)
             .collect();
-        assert_eq!(1, category_transfer_1.len());
-        let category_transfer_1 = category_transfer_1.get(0).unwrap();
-        assert_eq!(transform_id("1"), category_transfer_1.from_category_id);
-        assert_eq!(transform_id("0"), category_transfer_1.to_category_id);
+        assert_eq!(1, bucket_transfer_1.len());
+        let bucket_transfer_1 = bucket_transfer_1.get(0).unwrap();
+        assert_eq!(transform_id("1"), bucket_transfer_1.from_bucket_id);
+        assert_eq!(transform_id("0"), bucket_transfer_1.to_bucket_id);
     }
 
     #[test]
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 7c64e35..575e624 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,5 +1,5 @@
 use anyhow::{bail, Context, Result};
-use schist_models::{account::Account, category::Category, category_transfer::CategoryTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation};
+use schist_models::{account::Account, bucket::Bucket, bucket_transfer::BucketTransfer, date_utc::DateUtc, transaction::Transaction, transaction_categorisation::TransactionCategorisation};
 
 use crate::{actualbudget_state::ActualbudgetState, schist_state::SchistState};
 
@@ -24,7 +24,7 @@ fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Res
             &first_activity_date,
         );
     let budget_drips = transform_budget_drips(&actualbudget_state.actualbudget_zero_budgets)?;
-    let categories: Vec<Category> = transform_categories(
+    let buckets: Vec<Bucket> = transform_categories(
         &actualbudget_state.actualbudget_categories,
         &actualbudget_state.actualbudget_zero_budgets,
         &before_first_activity_date,
@@ -35,7 +35,7 @@ fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Res
             &actualbudget_state.actualbudget_category_transfers_account,
             &actualbudget_state.actualbudget_payees,
         )?;
-    let category_transfers: Vec<CategoryTransfer> = transform_category_transfers(
+    let bucket_transfers: Vec<BucketTransfer> = transform_category_transfers(
         &remaining_transactions,
         &actualbudget_state.actualbudget_category_transfers_account,
     )?;
@@ -44,11 +44,11 @@ fn transform_state_without_context(actualbudget_state: ActualbudgetState) -> Res
         first_transaction_date: first_activity_date,
         accounts,
         account_transfers,
-        categories,
+        buckets,
         budget_drips,
         transactions,
         transaction_categorisations,
-        category_transfers,
+        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 f7fb098..f24e8b6 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
@@ -75,7 +75,7 @@ fn transform_transactions_without_context(
             description: String::new(),
             quantity: atomic_actualbudget_transaction.amount.try_into().unwrap(),
             transaction_id,
-            category_id: transform_id(&actualbudget_category_id),
+            bucket_id: transform_id(&actualbudget_category_id),
         });
     }
 
@@ -113,7 +113,7 @@ fn transform_transactions_without_context(
                 description: child_actualbudget_transaction.notes.clone().unwrap_or_else(String::new),
                 quantity: child_actualbudget_transaction.amount.try_into().unwrap(),
                 transaction_id,
-                category_id: transform_id(&actualbudget_category_id),
+                bucket_id: transform_id(&actualbudget_category_id),
             });
         }
     }
@@ -191,7 +191,7 @@ mod test {
         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.category_id);
+        assert_eq!(transform_id("0"), transaction_categorisation.bucket_id);
     }
 
     #[test]
@@ -238,7 +238,7 @@ mod test {
             .last()
             .unwrap();
         assert_eq!(transaction.id, transaction_categorisation_0.transaction_id);
-        assert_eq!(transform_id("0"), transaction_categorisation_0.category_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
@@ -247,7 +247,7 @@ mod test {
             .last()
             .unwrap();
         assert_eq!(transaction.id, transaction_categorisation_1.transaction_id);
-        assert_eq!(transform_id("0"), transaction_categorisation_1.category_id);
+        assert_eq!(transform_id("0"), transaction_categorisation_1.bucket_id);
         assert_eq!("notes B", transaction_categorisation_1.description);
     }
 }
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
new file mode 100644
index 0000000..76189d3
--- /dev/null
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_matchers.rs
@@ -0,0 +1,34 @@
+use schist_models::{budget_period_unit::BudgetPeriodUnit, 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};
+
+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()
+}
+
+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),
+    }
+}
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_names.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_names.rs
new file mode 100644
index 0000000..5f232a8
--- /dev/null
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_names.rs
@@ -0,0 +1,37 @@
+pub const BUCKET_NAME_FOOD: &str = "Food";
+pub const BUCKET_NAME_GENERAL: &str = "General";
+pub const BUCKET_NAME_BILLS: &str = "Bills";
+pub const BUCKET_NAME_BILLS_FLEXIBLE: &str = "Bills (Flexible)";
+pub const BUCKET_NAME_SAVINGS: &str = "Savings";
+pub const BUCKET_NAME_STARTING_BALANCES: &str = "Starting Balances";
+pub const BUCKET_NAME_INCOME: &str = "Income";
+
+pub const BUCKET_NAMES: &[&'static str] = &[
+    BUCKET_NAME_FOOD,
+    BUCKET_NAME_GENERAL,
+    BUCKET_NAME_BILLS,
+    BUCKET_NAME_BILLS_FLEXIBLE,
+    BUCKET_NAME_SAVINGS,
+    BUCKET_NAME_STARTING_BALANCES,
+    BUCKET_NAME_INCOME,
+];
+
+pub struct BucketNamesDict {
+    pub food: &'static str,
+    pub general: &'static str,
+    pub bills: &'static str,
+    pub bills_flexible: &'static str,
+    pub savings: &'static str,
+    pub starting_balances: &'static str,
+    pub income: &'static str,
+}
+
+pub const BUCKET_NAMES_DICT: BucketNamesDict = BucketNamesDict {
+    food: BUCKET_NAME_FOOD,
+    general: BUCKET_NAME_GENERAL,
+    bills: BUCKET_NAME_BILLS,
+    bills_flexible: BUCKET_NAME_BILLS_FLEXIBLE,
+    savings: BUCKET_NAME_SAVINGS,
+    starting_balances: BUCKET_NAME_STARTING_BALANCES,
+    income: BUCKET_NAME_INCOME,
+};
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
new file mode 100644
index 0000000..3b46d76
--- /dev/null
+++ b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/bucket_transfer_matchers.rs
@@ -0,0 +1,38 @@
+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)),
+    ]
+}
+
+fn matches_120_savings_to_general_23_oct_2024(
+    bucket_transfer: &BucketTransfer,
+    buckets: &[Bucket],
+) -> bool {
+    let savings_bucket = buckets
+        .iter()
+        .find(|c| c.name == BUCKET_NAME_SAVINGS)
+        .expect("failed to find savings bucket");
+
+    let general_bucket = buckets
+        .iter()
+        .find(|c| c.name == BUCKET_NAME_GENERAL)
+        .expect("failed to find general bucket");
+
+    match bucket_transfer {
+        BucketTransfer {
+            id: _id,
+            description,
+            quantity: 120_00,
+            from_bucket_id,
+            to_bucket_id,
+        } => *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 04be584..97f81a2 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,19 +1,19 @@
 use std::sync::LazyLock;
 
-use schist_models::{budget_drip::BudgetDrip, category::Category, date_utc::DateUtc};
+use schist_models::{budget_drip::BudgetDrip, bucket::Bucket, date_utc::DateUtc};
 use schist_traits::dateable::Dateable;
 
-use crate::common::category_names::{CATEGORY_NAME_BILLS, CATEGORY_NAME_BILLS_FLEXIBLE, CATEGORY_NAME_FOOD, CATEGORY_NAME_GENERAL, CATEGORY_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();
-    let num_expected_categories = 5;
-    num_expected_dates * num_expected_categories
+    let num_expected_buckets = 5;
+    num_expected_dates * num_expected_buckets
 }
 
 pub fn assert_budget_drip_matches(
     budget_drip: &BudgetDrip,
-    categories: &[Category],
+    buckets: &[Bucket],
 ) {
     assert!(
         DATES.iter().any(|date| *LazyLock::force(date) == budget_drip.date),
@@ -21,55 +21,55 @@ pub fn assert_budget_drip_matches(
         budget_drip,
     );
 
-    let category_name = categories
+    let bucket_name = buckets
         .iter()
-        .find(|c| c.id == budget_drip.category_id)
+        .find(|c| c.id == budget_drip.bucket_id)
         .map(|c| c.name.clone())
         .expect(format!(
-            "budget drip {:?} had unexpected category ID. categories were: {:?}",
+            "budget drip {:?} had unexpected bucket ID. buckets were: {:?}",
             budget_drip,
-            categories,
+            buckets,
         ).as_str());
 
     let expected_quantity = match (
-        category_name.as_str(),
+        bucket_name.as_str(),
         budget_drip.date.month(),
         budget_drip.date.day(),
     ) {
-        (CATEGORY_NAME_FOOD, 8 | 10, 1) => 6_50,
-        (CATEGORY_NAME_FOOD, 8 | 10, _) => 6_45,
-        (CATEGORY_NAME_FOOD, 9 | 11, 1) => 6_86,
-        (CATEGORY_NAME_FOOD, 9 | 11, _) => 6_66,
-        (CATEGORY_NAME_FOOD, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
+        (BUCKET_NAME_FOOD, 8 | 10, 1) => 6_50,
+        (BUCKET_NAME_FOOD, 8 | 10, _) => 6_45,
+        (BUCKET_NAME_FOOD, 9 | 11, 1) => 6_86,
+        (BUCKET_NAME_FOOD, 9 | 11, _) => 6_66,
+        (BUCKET_NAME_FOOD, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
 
-        (CATEGORY_NAME_GENERAL, 8 | 10, 1) => 3_40,
-        (CATEGORY_NAME_GENERAL, 8 | 10, _) => 3_22,
-        (CATEGORY_NAME_GENERAL, 9 | 11, 1) => 3_43,
-        (CATEGORY_NAME_GENERAL, 9 | 11, _) => 3_33,
-        (CATEGORY_NAME_GENERAL, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
+        (BUCKET_NAME_GENERAL, 8 | 10, 1) => 3_40,
+        (BUCKET_NAME_GENERAL, 8 | 10, _) => 3_22,
+        (BUCKET_NAME_GENERAL, 9 | 11, 1) => 3_43,
+        (BUCKET_NAME_GENERAL, 9 | 11, _) => 3_33,
+        (BUCKET_NAME_GENERAL, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
 
-        (CATEGORY_NAME_BILLS, 8 | 10, 1) => 4_10,
-        (CATEGORY_NAME_BILLS, 8 | 10, _) => 4_03,
-        (CATEGORY_NAME_BILLS, 9 | 11, 1) => 4_36,
-        (CATEGORY_NAME_BILLS, 9 | 11, _) => 4_16,
-        (CATEGORY_NAME_BILLS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
+        (BUCKET_NAME_BILLS, 8 | 10, 1) => 4_10,
+        (BUCKET_NAME_BILLS, 8 | 10, _) => 4_03,
+        (BUCKET_NAME_BILLS, 9 | 11, 1) => 4_36,
+        (BUCKET_NAME_BILLS, 9 | 11, _) => 4_16,
+        (BUCKET_NAME_BILLS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
 
-        (CATEGORY_NAME_BILLS_FLEXIBLE, 8 | 10, 1) => 1_00,
-        (CATEGORY_NAME_BILLS_FLEXIBLE, 8 | 10, _) => 80,
-        (CATEGORY_NAME_BILLS_FLEXIBLE, 9 | 11, 1) => 93,
-        (CATEGORY_NAME_BILLS_FLEXIBLE, 9 | 11, _) => 83,
-        (CATEGORY_NAME_BILLS_FLEXIBLE, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
+        (BUCKET_NAME_BILLS_FLEXIBLE, 8 | 10, 1) => 1_00,
+        (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),
 
-        (CATEGORY_NAME_SAVINGS, 8 | 10, 1) => 13_00,
-        (CATEGORY_NAME_SAVINGS, 8 | 10, _) => 12_90,
-        (CATEGORY_NAME_SAVINGS, 9 | 11, 1) => 13_43,
-        (CATEGORY_NAME_SAVINGS, 9 | 11, _) => 13_33,
-        (CATEGORY_NAME_SAVINGS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
+        (BUCKET_NAME_SAVINGS, 8 | 10, 1) => 13_00,
+        (BUCKET_NAME_SAVINGS, 8 | 10, _) => 12_90,
+        (BUCKET_NAME_SAVINGS, 9 | 11, 1) => 13_43,
+        (BUCKET_NAME_SAVINGS, 9 | 11, _) => 13_33,
+        (BUCKET_NAME_SAVINGS, _, _) => panic!("budget drip {:?} had unexpected date", budget_drip),
 
         (_, _, _) => panic!(
-            "budget drip {:?} had unexpected category name {}",
+            "budget drip {:?} had unexpected bucket name {}",
             budget_drip,
-            category_name,
+            bucket_name,
         ),
     };
 
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_matchers.rs
deleted file mode 100644
index 6660add..0000000
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_matchers.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use schist_models::{budget_period_unit::BudgetPeriodUnit, category::Category};
-
-use super::category_names::{CATEGORY_NAMES, CATEGORY_NAME_BILLS, CATEGORY_NAME_BILLS_FLEXIBLE, CATEGORY_NAME_FOOD, CATEGORY_NAME_GENERAL, CATEGORY_NAME_INCOME, CATEGORY_NAME_SAVINGS, CATEGORY_NAME_STARTING_BALANCES};
-
-pub fn get_category_matchers(
-) -> Vec<Box<dyn Fn(&Category) -> bool>> {
-    CATEGORY_NAMES
-        .iter()
-        .map(|category_name| -> Box<dyn Fn(&Category) -> bool> {
-            Box::new(|c| matches_category(c, category_name))
-        }).collect()
-}
-
-fn matches_category(category: &Category, category_name: &str,) -> bool {
-    category.name == category_name
-    && category.balance == 0
-    && category.balance_date < "2024-08-01".parse().unwrap()
-    && category.budget_period == 1
-    && category.budget_period_unit == BudgetPeriodUnit::Month
-    && category.budget_quantity == get_expected_budget_quantity(category_name)
-}
-
-fn get_expected_budget_quantity(category_name: &str) -> i32 {
-    match category_name {
-        CATEGORY_NAME_FOOD => 200_00,
-        CATEGORY_NAME_GENERAL => 100_00,
-        CATEGORY_NAME_BILLS => 125_00,
-        CATEGORY_NAME_BILLS_FLEXIBLE => 25_00,
-        CATEGORY_NAME_SAVINGS => 400_00,
-        CATEGORY_NAME_STARTING_BALANCES => 0,
-        CATEGORY_NAME_INCOME => 0,
-        _ => panic!("unexpected category name {}", category_name),
-    }
-}
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_names.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_names.rs
deleted file mode 100644
index 601f294..0000000
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_names.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-pub const CATEGORY_NAME_FOOD: &str = "Food";
-pub const CATEGORY_NAME_GENERAL: &str = "General";
-pub const CATEGORY_NAME_BILLS: &str = "Bills";
-pub const CATEGORY_NAME_BILLS_FLEXIBLE: &str = "Bills (Flexible)";
-pub const CATEGORY_NAME_SAVINGS: &str = "Savings";
-pub const CATEGORY_NAME_STARTING_BALANCES: &str = "Starting Balances";
-pub const CATEGORY_NAME_INCOME: &str = "Income";
-
-pub const CATEGORY_NAMES: &[&'static str] = &[
-    CATEGORY_NAME_FOOD,
-    CATEGORY_NAME_GENERAL,
-    CATEGORY_NAME_BILLS,
-    CATEGORY_NAME_BILLS_FLEXIBLE,
-    CATEGORY_NAME_SAVINGS,
-    CATEGORY_NAME_STARTING_BALANCES,
-    CATEGORY_NAME_INCOME,
-];
-
-pub struct CategoryNamesDict {
-    pub food: &'static str,
-    pub general: &'static str,
-    pub bills: &'static str,
-    pub bills_flexible: &'static str,
-    pub savings: &'static str,
-    pub starting_balances: &'static str,
-    pub income: &'static str,
-}
-
-pub const CATEGORY_NAMES_DICT: CategoryNamesDict = CategoryNamesDict {
-    food: CATEGORY_NAME_FOOD,
-    general: CATEGORY_NAME_GENERAL,
-    bills: CATEGORY_NAME_BILLS,
-    bills_flexible: CATEGORY_NAME_BILLS_FLEXIBLE,
-    savings: CATEGORY_NAME_SAVINGS,
-    starting_balances: CATEGORY_NAME_STARTING_BALANCES,
-    income: CATEGORY_NAME_INCOME,
-};
diff --git a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_transfer_matchers.rs b/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_transfer_matchers.rs
deleted file mode 100644
index 6d11c8a..0000000
--- a/transformers/actualbudget_transformer/actualbudget_to_schist_transformer/tests/common/category_transfer_matchers.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use schist_models::{category::Category, category_transfer::CategoryTransfer};
-
-use super::category_names::{CATEGORY_NAME_GENERAL, CATEGORY_NAME_SAVINGS};
-
-pub fn get_category_transfer_matchers(
-) -> Vec<Box<dyn Fn(&CategoryTransfer, &[Category]) -> 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(
-    category_transfer: &CategoryTransfer,
-    categories: &[Category],
-) -> bool {
-    let savings_category = categories
-        .iter()
-        .find(|c| c.name == CATEGORY_NAME_SAVINGS)
-        .expect("failed to find savings category");
-
-    let general_category = categories
-        .iter()
-        .find(|c| c.name == CATEGORY_NAME_GENERAL)
-        .expect("failed to find general category");
-
-    match category_transfer {
-        CategoryTransfer {
-            id: _id,
-            description,
-            quantity: 120_00,
-            from_category_id,
-            to_category_id,
-        } => *from_category_id == savings_category.id
-            && *to_category_id == general_category.id
-            && description.as_str() == "",
-        _ => false,
-    }
-}
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 c67f62e..62255b0 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
@@ -2,9 +2,9 @@ mod account_matchers;
 mod account_names;
 mod account_transfer_matchers;
 mod budget_drip_matchers;
-mod category_matchers;
-mod category_names;
-mod category_transfer_matchers;
+mod bucket_matchers;
+mod bucket_names;
+mod bucket_transfer_matchers;
 mod db_url;
 mod test_context;
 mod transaction_matchers;
@@ -15,9 +15,9 @@ 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 category_names::CATEGORY_NAMES_DICT;
-pub use category_matchers::get_category_matchers;
-pub use category_transfer_matchers::get_category_transfer_matchers;
+pub use bucket_names::BUCKET_NAMES_DICT;
+pub use bucket_matchers::get_bucket_matchers;
+pub use bucket_transfer_matchers::get_bucket_transfer_matchers;
 pub use db_url::TEST_IN_DB_URL;
 pub use db_url::TEST_OUT_DB_URL;
 pub use test_context::TestContext;
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
index 04ce6a7..8082055 100644
--- 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
@@ -1,9 +1,9 @@
-use schist_models::{account::Account, category::Category, transaction::Transaction, transaction_categorisation::TransactionCategorisation};
+use schist_models::{account::Account, bucket::Bucket, transaction::Transaction, transaction_categorisation::TransactionCategorisation};
 
-use super::{category_names::{CATEGORY_NAME_FOOD, CATEGORY_NAME_INCOME, CATEGORY_NAME_STARTING_BALANCES}, matches_bank_account_initial_transaction, matches_cash_account_initial_transaction, matches_food_transaction, matches_income_transaction};
+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], &[Category], &[Account]) -> bool>> {
+) -> 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)),
@@ -21,7 +21,7 @@ pub fn get_transaction_categorisation_matchers(
 fn matches_bank_account_initial_transaction_categorisation(
     transaction_categorisation: &TransactionCategorisation,
     transactions: &[Transaction],
-    categories: &[Category],
+    buckets: &[Bucket],
     accounts: &[Account],
 ) -> bool {
     let bank_account_initial_transaction = transactions
@@ -29,10 +29,10 @@ fn matches_bank_account_initial_transaction_categorisation(
         .find(|t| matches_bank_account_initial_transaction(t, accounts))
         .expect("failed to find bank account initial transaction");
 
-    let starting_balance_category = categories
+    let starting_balance_bucket = buckets
         .iter()
-        .find(|c| c.name == CATEGORY_NAME_STARTING_BALANCES)
-        .expect("failed to find starting balance category");
+        .find(|c| c.name == BUCKET_NAME_STARTING_BALANCES)
+        .expect("failed to find starting balance bucket");
 
     match transaction_categorisation {
         TransactionCategorisation {
@@ -40,10 +40,10 @@ fn matches_bank_account_initial_transaction_categorisation(
             description,
             quantity: 1200_00,
             transaction_id,
-            category_id,
+            bucket_id,
         } => description == ""
             && *transaction_id == bank_account_initial_transaction.id
-            && *category_id == starting_balance_category.id,
+            && *bucket_id == starting_balance_bucket.id,
         _ => false,
     }
 }
@@ -51,7 +51,7 @@ fn matches_bank_account_initial_transaction_categorisation(
 fn matches_cash_account_initial_transaction_categorisation(
     transaction_categorisation: &TransactionCategorisation,
     transactions: &[Transaction],
-    categories: &[Category],
+    buckets: &[Bucket],
     accounts: &[Account],
 ) -> bool {
     let cash_account_initial_transaction = transactions
@@ -59,10 +59,10 @@ fn matches_cash_account_initial_transaction_categorisation(
         .find(|t| matches_cash_account_initial_transaction(t, accounts))
         .expect("failed to find cash account initial transaction");
 
-    let starting_balance_category = categories
+    let starting_balance_bucket = buckets
         .iter()
-        .find(|c| c.name == CATEGORY_NAME_STARTING_BALANCES)
-        .expect("failed to find starting balance category");
+        .find(|c| c.name == BUCKET_NAME_STARTING_BALANCES)
+        .expect("failed to find starting balance bucket");
 
     match transaction_categorisation {
         TransactionCategorisation {
@@ -70,10 +70,10 @@ fn matches_cash_account_initial_transaction_categorisation(
             description,
             quantity: 45_10,
             transaction_id,
-            category_id,
+            bucket_id,
         } => description == ""
             && *transaction_id == cash_account_initial_transaction.id
-            && *category_id == starting_balance_category.id,
+            && *bucket_id == starting_balance_bucket.id,
         _ => false,
     }
 }
@@ -81,7 +81,7 @@ fn matches_cash_account_initial_transaction_categorisation(
 fn matches_income_transaction_categorisation(
     transaction_categorisation: &TransactionCategorisation,
     transactions: &[Transaction],
-    categories: &[Category],
+    buckets: &[Bucket],
     accounts: &[Account],
     month: &str,
 ) -> bool {
@@ -90,10 +90,10 @@ fn matches_income_transaction_categorisation(
         .find(|t| matches_income_transaction(t, accounts, month))
         .expect(format!("failed to find income transaction for month {}", month).as_str());
 
-    let income_category = categories
+    let income_bucket = buckets
         .iter()
-        .find(|c| c.name == CATEGORY_NAME_INCOME)
-        .expect("failed to find income category");
+        .find(|c| c.name == BUCKET_NAME_INCOME)
+        .expect("failed to find income bucket");
 
     match transaction_categorisation {
         TransactionCategorisation {
@@ -101,10 +101,10 @@ fn matches_income_transaction_categorisation(
             description,
             quantity: 846_46,
             transaction_id,
-            category_id,
+            bucket_id,
         } => description == ""
             && *transaction_id == income_transaction.id
-            && *category_id == income_category.id,
+            && *bucket_id == income_bucket.id,
         _ => false,
     }
 }
@@ -112,7 +112,7 @@ fn matches_income_transaction_categorisation(
 fn matches_food_transaction_categorisation(
     transaction_categorisation: &TransactionCategorisation,
     transactions: &[Transaction],
-    categories: &[Category],
+    buckets: &[Bucket],
     accounts: &[Account],
     month: &str,
 ) -> bool {
@@ -121,10 +121,10 @@ fn matches_food_transaction_categorisation(
         .find(|t| matches_food_transaction(t, accounts, month))
         .expect(format!("failed to find food transaction for month {}", month).as_str());
 
-    let food_category = categories
+    let food_bucket = buckets
         .iter()
-        .find(|c| c.name == CATEGORY_NAME_FOOD)
-        .expect("failed to find food category");
+        .find(|c| c.name == BUCKET_NAME_FOOD)
+        .expect("failed to find food bucket");
 
     match transaction_categorisation {
         TransactionCategorisation {
@@ -132,10 +132,10 @@ fn matches_food_transaction_categorisation(
             description,
             quantity: -200_00,
             transaction_id,
-            category_id,
+            bucket_id,
         } => description == ""
             && *transaction_id == food_transaction.id
-            && *category_id == food_category.id,
+            && *bucket_id == food_bucket.id,
         _ => false,
     }
 }
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 e882dc5..4c13d55 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,9 @@
 pub mod common;
 
 use actualbudget_to_schist_transformer::run::run;
-use common::{assert_budget_drip_matches, get_account_matchers, get_account_transfer_matchers, get_category_matchers, get_category_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_categorisation_matchers, 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, categories::get_all_categories, category_transfers::get_all_category_transfers, transaction_categorisations::get_all_transaction_categorisations, transactions::get_all_transactions};
+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};
 
 #[test]
 fn given_test_database_when_run_then_exports_expected_schist_state() {
@@ -13,8 +13,8 @@ fn given_test_database_when_run_then_exports_expected_schist_state() {
     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 categories = get_all_categories(connection).unwrap();
-    let category_transfers = get_all_category_transfers(connection).unwrap();
+    let buckets = get_all_buckets(connection).unwrap();
+    let bucket_transfers = get_all_bucket_transfers(connection).unwrap();
     let transactions = get_all_transactions(connection).unwrap();
     let transaction_categorisations = get_all_transaction_categorisations(connection).unwrap();
 
@@ -40,26 +40,26 @@ fn given_test_database_when_run_then_exports_expected_schist_state() {
 
     assert_eq!(get_num_expected_budget_drips(), budget_drips.len());
     for budget_drip in budget_drips {
-        assert_budget_drip_matches(&budget_drip, &categories);
+        assert_budget_drip_matches(&budget_drip, &buckets);
     }
 
-    let category_matchers = get_category_matchers();
-    assert_eq!(category_matchers.len(), categories.len());
-    for category in categories.clone() {
+    let bucket_matchers = get_bucket_matchers();
+    assert_eq!(bucket_matchers.len(), buckets.len());
+    for bucket in buckets.clone() {
         assert!(
-            category_matchers.iter().any(|m| m(&category)),
-            "no match found for category {:?}",
-            category,
+            bucket_matchers.iter().any(|m| m(&bucket)),
+            "no match found for bucket {:?}",
+            bucket,
         );
     }
 
-    let category_transfer_matchers = get_category_transfer_matchers();
-    assert_eq!(category_transfer_matchers.len(), category_transfers.len());
-    for category_transfer in category_transfers {
+    let bucket_transfer_matchers = get_bucket_transfer_matchers();
+    assert_eq!(bucket_transfer_matchers.len(), bucket_transfers.len());
+    for bucket_transfer in bucket_transfers {
         assert!(
-            category_transfer_matchers.iter().any(|m| m(&category_transfer, &categories)),
-            "no match found for category_transfer {:?}",
-            category_transfer,
+            bucket_transfer_matchers.iter().any(|m| m(&bucket_transfer, &buckets)),
+            "no match found for bucket_transfer {:?}",
+            bucket_transfer,
         );
     }
 
@@ -80,7 +80,7 @@ fn given_test_database_when_run_then_exports_expected_schist_state() {
             transaction_categorisation_matchers.iter().any(|m| m(
                 &transaction_categorisation,
                 &transactions,
-                &categories,
+                &buckets,
                 &accounts,
             )),
             "no match found for transaction_categorisation {:?}",