Add goreleaser config

.gitignore

@@ -1 +1,2 @@
 /target
+/dist

.goreleaser.yaml

@@ -0,0 +1,15 @@
+version: 2
+before:
+  hooks:
+    - cargo install --locked cargo-zigbuild
+builds:
+  - builder: rust
+    # targets:
+    #   - x86_64-unknown-linux-gnu
+    #   - aarch64-unknown-linux-gnu
+archives:
+  - formats: ["binary"]
+
+gitea_urls:
+  api: https://git.shee.sh/api/v1
+  download: https://git.shee.sh

Cargo.lock

@@ -2,6 +2,15 @@
 # It is not intended for manual editing.
 version = 4
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "anstream"
 version = "1.0.0"
@@ -52,12 +61,24 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
 [[package]]
 name = "atomic-waker"
 version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
 [[package]]
 name = "aws-lc-rs"
 version = "1.16.3"
@@ -128,6 +149,19 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
 
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
 [[package]]
 name = "clap"
 version = "4.6.1"
@@ -527,6 +561,30 @@ dependencies = [
  "windows-registry",
 ]
 
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
 [[package]]
 name = "icu_collections"
 version = "2.2.0"
@@ -795,6 +853,15 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -1385,9 +1452,21 @@ dependencies = [
  "mio",
  "pin-project-lite",
  "socket2",
+ "tokio-macros",
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tokio-rustls"
 version = "0.26.4"
@@ -1644,6 +1723,41 @@ dependencies = [
  "windows-sys 0.61.2",
 ]
 
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "windows-link"
 version = "0.2.1"
@@ -1851,12 +1965,16 @@ checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4"
 name = "ynabmunger"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
+ "chrono",
  "clap",
  "csv",
  "directories",
  "reqwest",
  "serde",
  "serde_json",
+ "thiserror",
+ "tokio",
 ]
 
 [[package]]

Cargo.toml

@@ -4,9 +4,13 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+anyhow = "1.0.102"
+chrono = "0.4.44"
 clap = { version = "4.6.1", features = ["derive", "env"] }
 csv = "1.4.0"
 directories = "6.0.0"
 reqwest = { version = "0.13.3", features = ["blocking"] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.149"
+thiserror = "2.0.18"
+tokio = { version = "1.52.1", features = ["macros", "rt-multi-thread"] }

mise.toml

@@ -1,2 +1,3 @@
 [tools]
 rust = "latest"
+zig = "latest"

src/csv.rs

@@ -1,9 +1,11 @@
+use crate::Error;
 use crate::Transaction;
 use csv::ReaderBuilder;
-use std::error::Error;
+use std::fs::File;
-use std::io::{Read, Write};
+use std::io::{Read, Write, stdin};
+use std::path::PathBuf;
 
-pub fn output_csv<W: Write>(output: W, transactions: &[Transaction]) -> Result<(), Box<dyn Error>> {
+pub fn output_csv<W: Write>(output: W, transactions: &[Transaction]) -> Result<(), Error> {
     let mut writer = csv::Writer::from_writer(output);
 
     writer
@@ -22,10 +24,10 @@ enum BankFormat {
 }
 
 impl BankFormat {
-    fn from_str(format: &str) -> Result<BankFormat, String> {
+    fn from_str(format: &str) -> Result<BankFormat, Error> {
         match format {
             "bulder" => Ok(BankFormat::Bulder),
-            _ => Err(format!("Bank '{}' not found", format)),
+            _ => Err(Error::BankFormat(format.to_string())),
         }
     }
 
@@ -38,19 +40,35 @@ impl BankFormat {
         }
     }
 
-    fn transform(&self, record: &csv::StringRecord) -> Result<Transaction, String> {
+    fn transform(&self, record: &csv::StringRecord) -> Result<Transaction, Error> {
         match self {
             BankFormat::Bulder => Transaction::from_fields(&record[0], &record[9], &record[1]),
         }
     }
 }
 
-pub fn read_transactions<R: Read>(input: R, format: &str) -> Result<Vec<Transaction>, String> {
+pub fn read_transactions<R: Read>(input: R, format: &str) -> Result<Vec<Transaction>, Error> {
     let format = BankFormat::from_str(format).unwrap();
     format
         .reader(input)
         .records()
-        .map(|r| r.map_err(|e| format!("parse error: {}", e)))
+        .map(|r| format.transform(&r?))
-        .map(|r| r.and_then(|r| format.transform(&r)))
+        .collect()
-        .collect::<Result<Vec<_>, _>>()
+}
+
+pub fn read_transactions_from(inputs: &[PathBuf], format: &str) -> Result<Vec<Transaction>, Error> {
+    Ok(if inputs.is_empty() {
+        vec![Box::new(stdin()) as Box<dyn Read>]
+    } else {
+        inputs
+            .iter()
+            .map(|p| -> Result<Box<dyn Read>, Error> { Ok(Box::new(File::open(p)?)) })
+            .collect::<Result<Vec<_>, _>>()?
+    }
+    .iter_mut()
+    .map(|s| read_transactions(s, format))
+    .collect::<Result<Vec<_>, _>>()?
+    .into_iter()
+    .flatten()
+    .collect())
 }

src/lib.rs

@@ -2,3 +2,29 @@ mod transaction;
 pub use transaction::Transaction;
 pub mod csv;
 pub mod ynab;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("HTTP Error: {0}")]
+    Http(#[from] reqwest::Error),
+    #[error("parse error: {0}")]
+    Parse(#[from] serde_json::Error),
+    #[error("csv error: {0}")]
+    Csv(#[from] ::csv::Error),
+    #[error("io error: {0}")]
+    Io(#[from] std::io::Error),
+    #[error("couldn't parse amount: {0}")]
+    AmountParse(#[from] std::num::ParseIntError),
+
+    #[error("plan not found: {0}")]
+    PlanNotFound(String),
+    #[error("account not found: {0}")]
+    AccountNotFound(String),
+    #[error("empty amount")]
+    AmountEmpty,
+    #[error("bank format not found: {0}")]
+    BankFormat(String),
+    /// Errors I've been too lazy to give a type yet
+    #[error("{0}")]
+    Text(String),
+}

src/main.rs

@@ -1,14 +1,8 @@
 use clap::{Parser, Subcommand};
-use std::{
+use std::{io::stdout, path::PathBuf};
-    error::Error,
-    fs::File,
-    io::{Read, stdin, stdout},
-    path::PathBuf,
-};
 
-use ynabmunger::Transaction;
+use ynabmunger::csv::{output_csv, read_transactions_from};
-use ynabmunger::csv::{output_csv, read_transactions};
+use ynabmunger::ynab::Client;
-use ynabmunger::ynab::{Lookup, Ynab};
 
 #[derive(Subcommand)]
 enum Command {
@@ -32,6 +26,31 @@ enum Command {
         #[arg(short = 'P', long, group = "planref")]
         plan_id: Option<String>,
     },
+    // List transactions in the last 30 days
+    //
+    // You have to give a plan to list transactions from. You can optionally
+    // also give an account to show only transactions from that account.
+    Transactions {
+        /// Your YNAB token, available from developer settings in YNAB
+        #[arg(short, long, env = "YNAB_API_TOKEN", hide_env_values = true)]
+        token: String,
+
+        /// The name of the YNAB plan to list transactions from
+        #[arg(short, long, group = "planref")]
+        plan: Option<String>,
+
+        /// Alternatively, give the YNAB plan ID directly
+        #[arg(short = 'P', long, group = "planref")]
+        plan_id: Option<String>,
+
+        /// The name of the YNAB account to import to
+        #[arg(short, long, group = "accountref")]
+        account: Option<String>,
+
+        /// Alternatively, give the YNAB account ID directly
+        #[arg(short = 'A', long, group = "accountref")]
+        account_id: Option<String>,
+    },
     /// Convert from a bank export to a CSV you can import manually to YNAB
     Convert {
         #[arg(short, long, help = "Bank export format", default_value_t = String::from("bulder"))]
@@ -78,32 +97,13 @@ struct Cli {
     command: Command,
 }
 
-fn read_transactions_from(
+#[tokio::main]
-    inputs: &[PathBuf],
+async fn main() -> anyhow::Result<()> {
-    format: &str,
-) -> Result<Vec<Transaction>, Box<dyn Error>> {
-    Ok(if inputs.is_empty() {
-        vec![Box::new(stdin()) as Box<dyn Read>]
-    } else {
-        inputs
-            .into_iter()
-            .map(|p| -> Result<Box<dyn Read>, _> { Ok(Box::new(File::open(p)?)) })
-            .collect::<Result<Vec<_>, std::io::Error>>()?
-    }
-    .iter_mut()
-    .map(|s| read_transactions(s, format))
-    .collect::<Result<Vec<_>, _>>()?
-    .into_iter()
-    .flatten()
-    .collect())
-}
-
-fn main() -> Result<(), Box<dyn Error>> {
     let cli = Cli::parse();
 
     match cli.command {
         Command::Plans { token } => {
-            let plans = Ynab::new(&token).list_plans()?;
+            let plans = Client::new(&token).list_plans().await?;
             println!("Available plans:");
             for plan in plans {
                 println!(" - {}", plan);
@@ -115,14 +115,52 @@ fn main() -> Result<(), Box<dyn Error>> {
             plan,
             plan_id,
         } => {
-            let plan = Lookup::try_from((plan, plan_id))?;
+            let client = Client::new(&token);
-            let accounts = Ynab::new(&token).list_accounts(plan)?;
+            let plan = match (plan, plan_id) {
+                (_, Some(id)) => Ok(client.plan_from_id(&id)),
+                (Some(name), _) => Ok(client.plan_from_name(&name).await?),
+                _ => Err(ynabmunger::Error::Text("no plan given".to_string())),
+            }?;
+
+            let accounts = plan.list_accounts().await?;
             println!("Available accounts in plan:");
             for account in accounts {
                 println!(" - {}", account);
             }
             Ok(())
         }
+        Command::Transactions {
+            token,
+            plan,
+            plan_id,
+            account,
+            account_id,
+        } => {
+            let client = Client::new(&token);
+            let plan = match (plan, plan_id) {
+                (_, Some(id)) => Ok(client.plan_from_id(&id)),
+                (Some(name), _) => Ok(client.plan_from_name(&name).await?),
+                _ => Err(ynabmunger::Error::Text("no plan given".to_string())),
+            }?;
+
+            // Account is optional here
+            let (account, accountstr) = match (account, account_id) {
+                (_, Some(id)) => (Some(plan.account_from_id(&id)), " for account"),
+                (Some(name), _) => (Some(plan.account_from_name(&name).await?), " for account"),
+                _ => (None, ""),
+            };
+
+            let transactions = match account {
+                Some(account) => account.list_transactions().await?,
+                None => plan.list_transactions(None).await?,
+            };
+            println!("Transactions{} in the last 30 days:", accountstr);
+            for t in transactions {
+                println!("{},{},{}", t.date, t.payee, t.amount);
+            }
+
+            Ok(())
+        }
         Command::Import {
             token,
             plan,
@@ -132,16 +170,27 @@ fn main() -> Result<(), Box<dyn Error>> {
             format,
             inputs,
         } => {
-            let plan = Lookup::try_from((plan, plan_id))?;
+            let client = Client::new(&token);
-            let account = Lookup::try_from((account, account_id))?;
+            let plan = match (plan, plan_id) {
+                (_, Some(id)) => Ok(client.plan_from_id(&id)),
+                (Some(name), _) => Ok(client.plan_from_name(&name).await?),
+                _ => Err(ynabmunger::Error::Text("no plan given".to_string())),
+            }?;
+            let account = match (account, account_id) {
+                (_, Some(id)) => Ok(plan.account_from_id(&id)),
+                (Some(name), _) => Ok(plan.account_from_name(&name).await?),
+                _ => Err(ynabmunger::Error::Text("no account given".to_string())),
+            }?;
 
             let transactions = read_transactions_from(&inputs, &format)?;
 
-            Ynab::new(&token).upload(&transactions, plan, account)
+            account.upload(&transactions).await?;
+            Ok(())
         }
         Command::Convert { format, inputs } => {
             let transactions = read_transactions_from(&inputs, &format)?;
-            output_csv(stdout(), &transactions)
+            output_csv(stdout(), &transactions)?;
+            Ok(())
         }
     }
 }

src/transaction.rs

@@ -1,20 +1,18 @@
+use crate::Error;
+
 pub struct Transaction {
     pub date: String,
     pub payee: String,
     pub amount: i64,
 }
 
-fn parse_amount_str(amount: &str) -> Result<i64, String> {
+fn parse_amount_str(amount: &str) -> Result<i64, Error> {
     if amount.is_empty() {
-        return Err("empty amount".to_string());
+        return Err(Error::AmountEmpty);
     }
     let (whole, frac) = amount.split_once('.').unwrap_or((amount, "00"));
-    let whole = whole
+    let whole = whole.parse::<i64>()?;
-        .parse::<i64>()
+    let frac = frac.parse::<i64>()?;
-        .map_err(|e| format!("parse error on whole {}: {}", whole, e))?;
-    let frac = frac
-        .parse::<i64>()
-        .map_err(|e| format!("parse error on fraction {}: {}", frac, e))?;
 
     let mut amount: i64 = 0;
     amount += whole * 100 * 10;
@@ -24,7 +22,7 @@ fn parse_amount_str(amount: &str) -> Result<i64, String> {
 
 impl Transaction {
     /// Construct a Transaction from [date, payee, amount] strings
-    pub fn from_fields(date: &str, payee: &str, amount: &str) -> Result<Transaction, String> {
+    pub fn from_fields(date: &str, payee: &str, amount: &str) -> Result<Transaction, Error> {
         Ok(Transaction {
             date: date.to_owned(),
             payee: payee.to_owned(),

src/ynab.rs

@@ -1,218 +0,0 @@
-use crate::Transaction;
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-#[derive(Debug, Serialize)]
-struct YnabTransaction {
-    import_id: String,
-    date: String,
-    amount: i64,
-    payee_name: String,
-    account_id: String,
-}
-
-#[derive(Serialize, Deserialize, Debug)]
-struct YnabResponse<T> {
-    data: T,
-}
-
-#[derive(Deserialize, Debug)]
-struct YnabPlanList {
-    plans: Vec<YnabPlan>,
-}
-
-#[derive(Deserialize, Debug)]
-struct YnabPlan {
-    id: String,
-    name: String,
-}
-
-#[derive(Deserialize, Debug)]
-struct YnabAccountList {
-    accounts: Vec<YnabAccount>,
-}
-
-#[derive(Deserialize, Debug)]
-struct YnabAccount {
-    id: String,
-    name: String,
-}
-
-#[derive(Serialize, Debug)]
-struct YnabTransactionList {
-    transactions: Vec<YnabTransaction>,
-}
-
-#[derive(Debug)]
-pub enum Lookup {
-    Name(String),
-    Id(String),
-}
-
-impl TryFrom<(Option<String>, Option<String>)> for Lookup {
-    type Error = String;
-
-    fn try_from((name, id): (Option<String>, Option<String>)) -> Result<Self, Self::Error> {
-        match (name, id) {
-            (Some(name), _) => Ok(Lookup::Name(name)),
-            (_, Some(id)) => Ok(Lookup::Id(id)),
-            _ => Err("must provide name or id".to_owned()),
-        }
-    }
-}
-
-pub struct Ynab {
-    token: String,
-    webclient: reqwest::blocking::Client,
-}
-
-impl Ynab {
-    pub fn new(token: &str) -> Ynab {
-        Ynab {
-            token: token.to_owned(),
-            webclient: reqwest::blocking::Client::new(),
-        }
-    }
-
-    fn resolve_plan(&self, plan: Lookup) -> Result<String, String> {
-        match plan {
-            Lookup::Id(id) => Ok(id),
-            Lookup::Name(name) => {
-                let url = "plans";
-                let res: YnabResponse<YnabPlanList> = serde_json::from_str(
-                    &self.get(url).map_err(|e| format!("request error: {}", e))?,
-                )
-                .map_err(|e| format!("parse error: {}", e))?;
-                let plans = res.data.plans;
-                plans
-                    .into_iter()
-                    .find(|p| p.name == name)
-                    .map(|p| p.id)
-                    .ok_or_else(|| "no matching plan found".to_string())
-            }
-        }
-    }
-
-    fn resolve_account(&self, plan_id: &str, account: Lookup) -> Result<String, String> {
-        match account {
-            Lookup::Id(id) => Ok(id),
-            Lookup::Name(name) => {
-                let url = format!("plans/{}/accounts", plan_id);
-                let res: YnabResponse<YnabAccountList> = serde_json::from_str(
-                    &self
-                        .get(&url)
-                        .map_err(|e| format!("request error: {}", e))?,
-                )
-                .map_err(|e| format!("parse error: {}", e))?;
-                let accounts = res.data.accounts;
-                accounts
-                    .into_iter()
-                    .find(|a| a.name == name)
-                    .map(|a| a.id)
-                    .ok_or_else(|| "no matching account found".to_string())
-            }
-        }
-    }
-
-    fn get(&self, request: &str) -> Result<String, reqwest::Error> {
-        const URL: &str = "https://api.ynab.com/v1/";
-        let request = format!("{}{}", URL, request);
-        let res = self
-            .webclient
-            .get(request)
-            .bearer_auth(&self.token)
-            .send()?;
-        let text = res.text()?;
-        Ok(text)
-    }
-
-    fn post(&self, request: &str, body: &str) -> Result<(), String> {
-        const URL: &str = "https://api.ynab.com/v1/";
-        let request = format!("{}{}", URL, request);
-        let res = self
-            .webclient
-            .post(request)
-            .body(body.to_owned())
-            .bearer_auth(&self.token)
-            .header("Content-Type", "application/json")
-            .send()
-            .map_err(|e| format!("post error: {}", e))?;
-        if res.status().is_success() {
-            Ok(())
-        } else {
-            Err(format!(
-                "api error: {}: {}",
-                res.status(),
-                res.text()
-                    .map_err(|e| format!("error retrieving api error: {}", e))?
-            ))
-        }
-    }
-
-    pub fn list_plans(&self) -> Result<Vec<String>, String> {
-        let url = String::from("plans");
-        let res: YnabResponse<YnabPlanList> = serde_json::from_str(
-            &self
-                .get(&url)
-                .map_err(|e| format!("request error: {}", e))?,
-        )
-        .map_err(|e| format!("parse error: {}", e))?;
-        Ok(res.data.plans.into_iter().map(|p| p.name).collect())
-    }
-
-    pub fn list_accounts(&self, plan: Lookup) -> Result<Vec<String>, String> {
-        let plan_id = self.resolve_plan(plan)?;
-        let url = format!("plans/{}/accounts", plan_id);
-        let res: YnabResponse<YnabAccountList> = serde_json::from_str(
-            &self
-                .get(&url)
-                .map_err(|e| format!("request error: {}", e))?,
-        )
-        .map_err(|e| format!("parse error: {}", e))?;
-        Ok(res.data.accounts.into_iter().map(|p| p.name).collect())
-    }
-
-    fn ynab_transactions(
-        &self,
-        transactions: &[Transaction],
-        account_id: &str,
-    ) -> Vec<YnabTransaction> {
-        let mut result = Vec::new();
-        let mut idmap: HashMap<(String, i64), u32> = HashMap::new();
-        for t in transactions {
-            let key = (t.date.clone(), t.amount);
-            let id = {
-                let n = idmap.entry(key).or_insert(0);
-                *n += 1;
-                *n
-            };
-            let y = YnabTransaction {
-                import_id: format!("YNAB:{}:{}:{}", t.amount, t.date, id),
-                date: t.date.clone(),
-                amount: t.amount,
-                payee_name: t.payee.clone(),
-                account_id: account_id.to_string(),
-            };
-            result.push(y);
-        }
-        result
-    }
-
-    pub fn upload(
-        &self,
-        transactions: &[Transaction],
-        plan: Lookup,
-        account: Lookup,
-    ) -> Result<(), Box<dyn std::error::Error>> {
-        let plan_id = self.resolve_plan(plan)?;
-        let account_id = self.resolve_account(&plan_id, account)?;
-        let request = format!("plans/{}/transactions", plan_id);
-        let body = serde_json::to_string(&YnabTransactionList {
-            transactions: self.ynab_transactions(transactions, &account_id),
-        })
-        .map_err(|e| format!("transaction format error: {}", e))?;
-        println!("{}", body);
-        self.post(&request, &body)?;
-        Ok(())
-    }
-}

src/ynab/apitypes.rs

@@ -0,0 +1,43 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct Response<T> {
+    pub(crate) data: T,
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct TransactionList {
+    pub(crate) transactions: Vec<Transaction>,
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct Transaction {
+    pub(crate) import_id: Option<String>,
+    pub(crate) date: String,
+    pub(crate) amount: i64,
+    pub(crate) payee_name: Option<String>,
+    pub(crate) account_id: String,
+    pub(crate) cleared: String,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct PlanList {
+    pub(crate) plans: Vec<Plan>,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct Plan {
+    pub(crate) id: String,
+    pub(crate) name: String,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct AccountList {
+    pub(crate) accounts: Vec<Account>,
+}
+
+#[derive(Deserialize)]
+pub(crate) struct Account {
+    pub(crate) id: String,
+    pub(crate) name: String,
+}

src/ynab/client.rs

@@ -0,0 +1,181 @@
+use super::apitypes;
+use super::transform;
+use crate::Error;
+use crate::Transaction;
+
+#[derive(Clone)]
+pub struct Client {
+    token: String,
+    webclient: reqwest::Client,
+}
+
+impl Client {
+    pub fn new(token: &str) -> Client {
+        Client {
+            token: token.to_owned(),
+            webclient: reqwest::Client::new(),
+        }
+    }
+
+    pub(crate) async fn get(&self, request: &str) -> Result<String, Error> {
+        const URL: &str = "https://api.ynab.com/v1/";
+        let request = format!("{}{}", URL, request);
+        let res = self
+            .webclient
+            .get(request)
+            .bearer_auth(&self.token)
+            .send()
+            .await?;
+        let text = res.text().await?;
+        Ok(text)
+    }
+
+    async fn post(&self, request: &str, body: &str) -> Result<(), Error> {
+        const URL: &str = "https://api.ynab.com/v1/";
+        let request = format!("{}{}", URL, request);
+        let res = self
+            .webclient
+            .post(request)
+            .body(body.to_owned())
+            .bearer_auth(&self.token)
+            .header("Content-Type", "application/json")
+            .send()
+            .await?;
+        if res.status().is_success() {
+            // Maybe do something with the status here
+            // println!(
+            //     "successful api response {}: {}",
+            //     res.status(),
+            //     res.text()
+            //         .await
+            //         .map_err(|e| format!("error retrieving api error: {}", e))?
+            // );
+            Ok(())
+        } else {
+            Err(Error::Text(format!(
+                "api error: {}: {}",
+                res.status(),
+                res.text().await?
+            )))
+        }
+    }
+
+    pub async fn list_plans(&self) -> Result<Vec<String>, Error> {
+        let url = String::from("plans");
+        let res: apitypes::Response<apitypes::PlanList> =
+            serde_json::from_str(&self.get(&url).await?)?;
+        Ok(res.data.plans.into_iter().map(|p| p.name).collect())
+    }
+
+    pub fn plan_from_id(self, id: &str) -> Plan {
+        Plan::from_id(self, id)
+    }
+
+    pub async fn plan_from_name(self, name: &str) -> Result<Plan, Error> {
+        Plan::from_name(self, name).await
+    }
+}
+
+#[derive(Clone)]
+pub struct Plan {
+    client: Client,
+    id: String,
+}
+
+impl Plan {
+    fn from_id(client: Client, id: &str) -> Plan {
+        Plan {
+            client,
+            id: id.to_owned(),
+        }
+    }
+
+    async fn from_name(client: Client, name: &str) -> Result<Plan, Error> {
+        let raw = client.get("plans").await?;
+        let res: apitypes::Response<apitypes::PlanList> = serde_json::from_str(&raw)?;
+        let id = res
+            .data
+            .plans
+            .into_iter()
+            .find(|p| p.name == name)
+            .map(|p| p.id)
+            .ok_or_else(|| Error::PlanNotFound(name.to_string()))?;
+        Ok(Plan { client, id })
+    }
+
+    pub fn account_from_id(&self, id: &str) -> Account {
+        Account::from_id(self, id)
+    }
+
+    pub async fn account_from_name(&self, name: &str) -> Result<Account, Error> {
+        Account::from_name(self, name).await
+    }
+
+    pub async fn list_accounts(&self) -> Result<Vec<String>, Error> {
+        let url = format!("plans/{}/accounts", self.id);
+        let raw = self.client.get(&url).await?;
+        let res: apitypes::Response<apitypes::AccountList> = serde_json::from_str(&raw)?;
+        Ok(res.data.accounts.into_iter().map(|p| p.name).collect())
+    }
+
+    pub async fn list_transactions(
+        &self,
+        account_id: Option<&str>,
+    ) -> Result<Vec<Transaction>, Error> {
+        let since_date = chrono::Local::now().date_naive() - chrono::Duration::days(30);
+        let since_date = since_date.format("%Y-%m-%d");
+        let url = format!("plans/{}/transactions?since_date={}", self.id, since_date);
+        let raw = self.client.get(&url).await?;
+        let res: apitypes::Response<apitypes::TransactionList> = serde_json::from_str(&raw)?;
+        Ok(transform::from_ynab_transactions(
+            &res.data.transactions,
+            account_id,
+        ))
+    }
+}
+
+pub struct Account {
+    plan: Plan,
+    id: String,
+}
+
+impl Account {
+    fn from_id(plan: &Plan, id: &str) -> Account {
+        Account {
+            plan: plan.clone(),
+            id: id.to_owned(),
+        }
+    }
+
+    async fn from_name(plan: &Plan, name: &str) -> Result<Account, Error> {
+        let raw = plan
+            .client
+            .get(&format!("plans/{}/accounts", &plan.id))
+            .await?;
+        let res: apitypes::Response<apitypes::AccountList> = serde_json::from_str(&raw)?;
+        let id = res
+            .data
+            .accounts
+            .into_iter()
+            .find(|p| p.name == name)
+            .map(|p| p.id)
+            .ok_or_else(|| Error::AccountNotFound(name.to_string()))?;
+        Ok(Account {
+            plan: plan.clone(),
+            id,
+        })
+    }
+
+    pub async fn list_transactions(&self) -> Result<Vec<Transaction>, Error> {
+        self.plan.list_transactions(Some(&self.id)).await
+    }
+
+    pub async fn upload(&self, transactions: &[Transaction]) -> Result<(), Error> {
+        let request = format!("plans/{}/transactions", self.plan.id);
+        let body = serde_json::to_string(&apitypes::TransactionList {
+            transactions: transform::to_ynab_transactions(transactions, &self.id),
+        })?;
+        self.plan.client.post(&request, &body).await?;
+        Ok(())
+    }
+}

src/ynab/mod.rs

@@ -0,0 +1,6 @@
+mod apitypes;
+
+mod client;
+pub use client::Client;
+
+mod transform;

src/ynab/transform.rs

@@ -0,0 +1,50 @@
+use super::apitypes;
+use crate::Transaction;
+use std::collections::HashMap;
+
+pub(crate) fn to_ynab_transactions(
+    transactions: &[Transaction],
+    account_id: &str,
+) -> Vec<apitypes::Transaction> {
+    let mut result = Vec::new();
+    let mut idmap: HashMap<(String, i64), u32> = HashMap::new();
+    for t in transactions {
+        let key = (t.date.clone(), t.amount);
+        let id = {
+            let n = idmap.entry(key).or_insert(0);
+            *n += 1;
+            *n
+        };
+        let y = apitypes::Transaction {
+            import_id: Some(format!("YNAB:{}:{}:{}", t.amount, t.date, id)),
+            date: t.date.clone(),
+            amount: t.amount,
+            payee_name: Some(t.payee.clone()),
+            account_id: account_id.to_string(),
+            cleared: "cleared".to_string(),
+        };
+        result.push(y);
+    }
+    result
+}
+
+pub(crate) fn from_ynab_transactions(
+    transactions: &[apitypes::Transaction],
+    account_id: Option<&str>,
+) -> Vec<Transaction> {
+    transactions
+        .iter()
+        .filter(|t| match account_id {
+            Some(id) => t.account_id == id,
+            None => true,
+        })
+        .map(|t| Transaction {
+            date: t.date.to_owned(),
+            payee: match &t.payee_name {
+                Some(name) => name.to_owned(),
+                None => String::new(),
+            },
+            amount: t.amount,
+        })
+        .collect()
+}