lunchmoney 0.10.0 → 1.1.0

data/lib/lunchmoney/tags/tag_calls.rb

@@ -1,20 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative "tag/tag_base"
-require_relative "tag/tag"
-
-module LunchMoney
-  # https://lunchmoney.dev/#tags
-  class TagCalls < ApiCall
-    sig { returns(T.any(T::Array[LunchMoney::Tag], LunchMoney::Errors)) }
-    def tags
-      response = get("tags")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body.map { |tag| LunchMoney::Tag.new(**tag) }
-    end
-  end
-end

data/lib/lunchmoney/transactions/transaction/child_transaction.rb

@@ -1,31 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # Slimmed down version of https://lunchmoney.dev/#transaction-object used in the
-  # `children` field of a transaction object with an additional `formatted_date`` field
-  class ChildTransaction < TransactionBase
-    sig { returns(String) }
-    attr_accessor :formatted_date
-
-    sig do
-      params(
-        id: Integer,
-        date: String,
-        amount: String,
-        currency: String,
-        to_base: Number,
-        payee: String,
-        formatted_date: String,
-        notes: T.nilable(String),
-        asset_id: T.nilable(Integer),
-        plaid_account_id: T.nilable(Integer),
-      ).void
-    end
-    def initialize(id:, date:, amount:, currency:, to_base:, payee:, formatted_date:, notes: nil, asset_id: nil,
-      plaid_account_id: nil)
-      super(id:, date:, amount:, currency:, to_base:, payee:, notes:, asset_id:, plaid_account_id:)
-      @formatted_date = formatted_date
-    end
-  end
-end

data/lib/lunchmoney/transactions/transaction/split.rb

@@ -1,24 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # Object used to split a transaction when updating https://lunchmoney.dev/#update-transaction
-  class Split < TransactionModificationBase
-    sig { returns(T.any(Number, String)) }
-    attr_accessor :amount
-
-    sig do
-      params(
-        amount: T.any(Number, String),
-        payee: T.nilable(String),
-        date: T.nilable(String),
-        category_id: T.nilable(Integer),
-        notes: T.nilable(String),
-      ).void
-    end
-    def initialize(amount:, payee: nil, date: nil, category_id: nil, notes: nil)
-      super(payee:, date:, category_id:, notes:)
-      @amount = amount
-    end
-  end
-end

data/lib/lunchmoney/transactions/transaction/transaction.rb

@@ -1,156 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#transaction-object
-  class Transaction < TransactionBase
-    sig { returns(T.nilable(Integer)) }
-    attr_accessor :category_id,
-      :category_group_id,
-      :recurring_id,
-      :parent_id,
-      :group_id,
-      :external_id
-
-    sig { returns(String) }
-    attr_accessor :created_at,
-      :updated_at,
-      :status,
-      :source,
-      :display_name,
-      :account_display_name
-
-    sig { returns(T.nilable(String)) }
-    attr_accessor :category_name,
-      :category_group_name,
-      :original_name,
-      :recurring_payee,
-      :recurring_description,
-      :recurring_cadence,
-      :recurring_type,
-      :recurring_amount,
-      :recurring_currency,
-      :asset_institution_name,
-      :asset_name,
-      :asset_display_name,
-      :asset_status,
-      :plaid_account_name,
-      :plaid_account_mask,
-      :institution_name,
-      :plaid_account_display_name,
-      :plaid_metadata,
-      :display_notes
-
-    sig { returns(T::Boolean) }
-    attr_accessor :is_income, :exclude_from_budget, :exclude_from_totals, :is_pending, :has_children, :is_group
-
-    sig { returns(T::Array[LunchMoney::TagBase]) }
-    attr_accessor :tags
-
-    sig { returns(T.nilable(T::Array[LunchMoney::ChildTransaction])) }
-    attr_accessor :children
-
-    sig do
-      params(
-        id: Integer,
-        date: String,
-        amount: String,
-        currency: String,
-        to_base: Number,
-        payee: String,
-        is_income: T::Boolean,
-        exclude_from_budget: T::Boolean,
-        exclude_from_totals: T::Boolean,
-        created_at: String,
-        updated_at: String,
-        status: String,
-        is_pending: T::Boolean,
-        has_children: T::Boolean,
-        is_group: T::Boolean,
-        source: String,
-        display_name: String,
-        account_display_name: String,
-        tags: T::Array[LunchMoney::TagBase],
-        category_id: T.nilable(Integer),
-        category_name: T.nilable(String),
-        category_group_id: T.nilable(Integer),
-        category_group_name: T.nilable(String),
-        notes: T.nilable(String),
-        original_name: T.nilable(String),
-        recurring_id: T.nilable(Integer),
-        recurring_payee: T.nilable(String),
-        recurring_description: T.nilable(String),
-        recurring_cadence: T.nilable(String),
-        recurring_type: T.nilable(String),
-        recurring_amount: T.nilable(String),
-        recurring_currency: T.nilable(String),
-        parent_id: T.nilable(Integer),
-        group_id: T.nilable(Integer),
-        asset_id: T.nilable(Integer),
-        asset_institution_name: T.nilable(String),
-        asset_name: T.nilable(String),
-        asset_display_name: T.nilable(String),
-        asset_status: T.nilable(String),
-        plaid_account_id: T.nilable(Integer),
-        plaid_account_name: T.nilable(String),
-        plaid_account_mask: T.nilable(String),
-        institution_name: T.nilable(String),
-        plaid_account_display_name: T.nilable(String),
-        plaid_metadata: T.nilable(String),
-        display_notes: T.nilable(String),
-        external_id: T.nilable(Integer),
-        children: T.nilable(T::Array[LunchMoney::ChildTransaction]),
-      ).void
-    end
-    def initialize(id:, date:, amount:, currency:, to_base:, payee:, is_income:, exclude_from_budget:,
-      exclude_from_totals:, created_at:, updated_at:, status:, is_pending:, has_children:, is_group:, source:,
-      display_name:, account_display_name:, tags:, category_id: nil, category_name: nil, category_group_id: nil,
-      category_group_name: nil, notes: nil, original_name: nil, recurring_id: nil, recurring_payee: nil,
-      recurring_description: nil, recurring_cadence: nil, recurring_type: nil, recurring_amount: nil,
-      recurring_currency: nil, parent_id: nil, group_id: nil, asset_id: nil, asset_institution_name: nil,
-      asset_name: nil, asset_display_name: nil, asset_status: nil, plaid_account_id: nil, plaid_account_name: nil,
-      plaid_account_mask: nil, institution_name: nil, plaid_account_display_name: nil, plaid_metadata: nil,
-      display_notes: nil, external_id: nil, children: nil)
-      super(id:, date:, amount:, currency:, to_base:, payee:, notes:, asset_id:, plaid_account_id:)
-      @is_income = is_income
-      @exclude_from_budget = exclude_from_budget
-      @exclude_from_totals = exclude_from_totals
-      @created_at = created_at
-      @updated_at = updated_at
-      @status = status
-      @is_pending = is_pending
-      @has_children = has_children
-      @is_group = is_group
-      @source = source
-      @display_name = display_name
-      @account_display_name = account_display_name
-      @tags = tags
-      @category_id = category_id
-      @category_name = category_name
-      @category_group_id = category_group_id
-      @category_group_name = category_group_name
-      @original_name = original_name
-      @recurring_id = recurring_id
-      @recurring_payee = recurring_payee
-      @recurring_description = recurring_description
-      @recurring_cadence = recurring_cadence
-      @recurring_type = recurring_type
-      @recurring_amount = recurring_amount
-      @recurring_currency = recurring_currency
-      @parent_id = parent_id
-      @group_id = group_id
-      @asset_institution_name = asset_institution_name
-      @asset_name = asset_name
-      @asset_display_name = asset_display_name
-      @asset_status = asset_status
-      @plaid_account_name = plaid_account_name
-      @plaid_account_mask = plaid_account_mask
-      @institution_name = institution_name
-      @plaid_account_display_name = plaid_account_display_name
-      @plaid_metadata = plaid_metadata
-      @display_notes = display_notes
-      @children = children
-      @external_id = external_id
-    end
-  end
-end

data/lib/lunchmoney/transactions/transaction/transaction_base.rb

@@ -1,52 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # Slimmed down version of https://lunchmoney.dev/#transaction-object used as a base for other transaction objects
-  class TransactionBase < LunchMoney::DataObject
-    sig { returns(Integer) }
-    attr_accessor :id
-
-    sig { returns(Number) }
-    attr_accessor :to_base
-
-    sig { returns(T.nilable(Integer)) }
-    attr_accessor :asset_id, :plaid_account_id
-
-    sig { returns(String) }
-    attr_accessor :date,
-      :amount,
-      :currency,
-      :payee
-
-    sig { returns(T.nilable(String)) }
-    attr_accessor :notes
-
-    sig do
-      params(
-        id: Integer,
-        date: String,
-        amount: String,
-        currency: String,
-        to_base: Number,
-        payee: String,
-        notes: T.nilable(String),
-        asset_id: T.nilable(Integer),
-        plaid_account_id: T.nilable(Integer),
-      ).void
-    end
-    def initialize(id:, date:, amount:, currency:, to_base:, payee:, notes: nil, asset_id: nil,
-      plaid_account_id: nil)
-      super()
-      @id = id
-      @date = date
-      @amount = amount
-      @currency = currency
-      @to_base = to_base
-      @payee = payee
-      @notes = notes
-      @asset_id = asset_id
-      @plaid_account_id = plaid_account_id
-    end
-  end
-end

data/lib/lunchmoney/transactions/transaction/transaction_modification_base.rb

@@ -1,30 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # Base object used for transaction objects that are used to update
-  # transactions https://lunchmoney.dev/#update-transaction
-  class TransactionModificationBase < LunchMoney::DataObject
-    sig { returns(T.nilable(String)) }
-    attr_accessor :payee, :date, :notes
-
-    sig { returns(T.nilable(Integer)) }
-    attr_accessor :category_id
-
-    sig do
-      params(
-        payee: T.nilable(String),
-        date: T.nilable(String),
-        category_id: T.nilable(Integer),
-        notes: T.nilable(String),
-      ).void
-    end
-    def initialize(payee: nil, date: nil, category_id: nil, notes: nil)
-      super()
-      @payee = payee
-      @date = date
-      @category_id = category_id
-      @notes = notes
-    end
-  end
-end

data/lib/lunchmoney/transactions/transaction/update_transaction.rb

@@ -1,43 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # object used when updating a transaction https://lunchmoney.dev/#update-transaction
-  class UpdateTransaction < TransactionModificationBase
-    sig { returns(T.nilable(String)) }
-    attr_accessor :amount, :currency, :status, :external_id
-
-    sig { returns(T.nilable(Integer)) }
-    attr_accessor :asset_id, :recurring_id
-
-    sig { returns(T.nilable(T::Array[T.any(String, Integer)])) }
-    attr_accessor :tags
-
-    sig do
-      params(
-        tags: T.nilable(T::Array[T.any(String, Integer)]),
-        category_id: T.nilable(Integer),
-        payee: T.nilable(String),
-        amount: T.nilable(String),
-        currency: T.nilable(String),
-        asset_id: T.nilable(Integer),
-        recurring_id: T.nilable(Integer),
-        notes: T.nilable(String),
-        status: T.nilable(String),
-        external_id: T.nilable(String),
-        date: T.nilable(String),
-      ).void
-    end
-    def initialize(tags: nil, category_id: nil, payee: nil, amount: nil, currency: nil, asset_id: nil,
-      recurring_id: nil, notes: nil, status: nil, external_id: nil, date: nil)
-      super(payee:, date:, category_id:, notes:)
-      @amount = amount
-      @tags = tags
-      @currency = currency
-      @asset_id = asset_id
-      @recurring_id = recurring_id
-      @status = status
-      @external_id = external_id
-    end
-  end
-end

data/lib/lunchmoney/transactions/transaction_calls.rb

@@ -1,218 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative "transaction/transaction_base"
-require_relative "transaction/child_transaction"
-require_relative "transaction/transaction"
-require_relative "transaction/transaction_modification_base"
-require_relative "transaction/split"
-require_relative "transaction/update_transaction"
-
-module LunchMoney
-  # https://lunchmoney.dev/#transactions
-  class TransactionCalls < ApiCall
-    sig do
-      params(
-        tag_id: T.nilable(Integer),
-        recurring_id: T.nilable(Integer),
-        plaid_account_id: T.nilable(Integer),
-        category_id: T.nilable(Integer),
-        asset_id: T.nilable(Integer),
-        is_group: T.nilable(T::Boolean),
-        status: T.nilable(String),
-        start_date: T.nilable(String),
-        end_date: T.nilable(String),
-        debit_as_negative: T.nilable(T::Boolean),
-        pending: T.nilable(T::Boolean),
-        offset: T.nilable(Integer),
-        limit: T.nilable(Integer),
-      ).returns(T.any(T::Array[LunchMoney::Transaction], LunchMoney::Errors))
-    end
-    def transactions(
-      tag_id: nil,
-      recurring_id: nil,
-      plaid_account_id: nil,
-      category_id: nil,
-      asset_id: nil,
-      is_group: nil,
-      status: nil,
-      start_date: nil,
-      end_date: nil,
-      debit_as_negative: nil,
-      pending: nil,
-      offset: nil,
-      limit: nil
-    )
-
-      params = clean_params({
-        tag_id:,
-        recurring_id:,
-        plaid_account_id:,
-        category_id:,
-        asset_id:,
-        is_group:,
-        status:,
-        start_date:,
-        end_date:,
-        debit_as_negative:,
-        pending:,
-        offset:,
-        limit:,
-      })
-      response = get("transactions", query_params: params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body[:transactions].map do |transaction|
-        transaction[:tags].map! { |tag| LunchMoney::TagBase.new(**tag) }
-
-        transaction[:children]&.map! { |child_transaction| LunchMoney::ChildTransaction.new(**child_transaction) }
-
-        LunchMoney::Transaction.new(**transaction)
-      end
-    end
-
-    sig do
-      params(
-        transaction_id: Integer,
-        debit_as_negative: T.nilable(T::Boolean),
-      ).returns(T.any(LunchMoney::Transaction, LunchMoney::Errors))
-    end
-    def transaction(transaction_id, debit_as_negative: nil)
-      params = clean_params({ debit_as_negative: })
-      response = get("transactions/#{transaction_id}", query_params: params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      LunchMoney::Transaction.new(**response.body)
-    end
-
-    sig do
-      params(
-        transactions: T::Array[LunchMoney::UpdateTransaction],
-        apply_rules: T.nilable(T::Boolean),
-        skip_duplicates: T.nilable(T::Boolean),
-        check_for_recurring: T.nilable(T::Boolean),
-        debit_as_negative: T.nilable(T::Boolean),
-        skip_balance_update: T.nilable(T::Boolean),
-      ).returns(T.any(T::Hash[Symbol, T::Array[Integer]], LunchMoney::Errors))
-    end
-    def insert_transactions(transactions, apply_rules: nil, skip_duplicates: nil,
-      check_for_recurring: nil, debit_as_negative: nil, skip_balance_update: nil)
-      params = clean_params({
-        transactions: transactions.map(&:serialize),
-        apply_rules:,
-        skip_duplicates:,
-        check_for_recurring:,
-        debit_as_negative:,
-        skip_balance_update:,
-      })
-      response = post("transactions", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig do
-      params(
-        transaction_id: Integer,
-        transaction: T.nilable(LunchMoney::UpdateTransaction),
-        split: T.nilable(T::Array[LunchMoney::Split]),
-        debit_as_negative: T.nilable(T::Boolean),
-        skip_balance_update: T.nilable(T::Boolean),
-      ).returns(T.any({ updated: T::Boolean, split: T.nilable(T::Array[Integer]) }, LunchMoney::Errors))
-    end
-    def update_transaction(transaction_id, transaction: nil, split: nil,
-      debit_as_negative: nil, skip_balance_update: nil)
-      raise(
-        LunchMoney::MissingArgument,
-        "Either a transaction or split must be provided",
-      ) if transaction.nil? && split.nil?
-
-      params = clean_params({
-        transaction: transaction&.serialize,
-        split: split&.map!(&:serialize),
-        debit_as_negative:,
-        skip_balance_update:,
-      })
-      response = put("transactions/#{transaction_id}", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig do
-      params(
-        parent_ids: T::Array[Integer],
-        remove_parents: T.nilable(T::Boolean),
-      ).returns(T.any(T::Array[Integer], LunchMoney::Errors))
-    end
-    def unsplit_transaction(parent_ids, remove_parents: false)
-      params = { parent_ids:, remove_parents: }
-      response = post("transactions/unsplit", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig { params(transaction_id: Integer).returns(T.any(LunchMoney::Transaction, LunchMoney::Errors)) }
-    def transaction_group(transaction_id)
-      response = get("transactions/group", query_params: { transaction_id: })
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      LunchMoney::Transaction.new(**response.body)
-    end
-
-    sig do
-      params(
-        date: String,
-        payee: String,
-        transactions: T::Array[T.any(Integer, String)],
-        category_id: T.nilable(Integer),
-        notes: T.nilable(String),
-        tags: T.nilable(T::Array[T.any(Integer, String)]),
-      ).returns(T.any(Integer, LunchMoney::Errors))
-    end
-    def create_transaction_group(date:, payee:, transactions:, category_id: nil, notes: nil, tags: nil)
-      params = clean_params({
-        date:,
-        payee:,
-        transactions:,
-        category_id:,
-        notes:,
-        tags:,
-      })
-      response = post("transactions/group", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig do
-      params(transaction_id: T.any(
-        String,
-        Integer,
-      )).returns(T.any(T::Hash[Symbol, T::Array[Integer]], LunchMoney::Errors))
-    end
-    def delete_transaction_group(transaction_id)
-      response = delete("transactions/group/#{transaction_id}")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-  end
-end

data/lib/lunchmoney/user/user.rb

@@ -1,36 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#user-object
-  class User < LunchMoney::DataObject
-    sig { returns(Integer) }
-    attr_accessor :user_id, :account_id
-
-    sig { returns(String) }
-    attr_accessor :user_name, :user_email, :budget_name
-
-    sig { returns(T.nilable(String)) }
-    attr_accessor :api_key_label
-
-    sig do
-      params(
-        user_id: Integer,
-        user_name: String,
-        user_email: String,
-        account_id: Integer,
-        budget_name: String,
-        api_key_label: T.nilable(String),
-      ).void
-    end
-    def initialize(user_id:, user_name:, user_email:, account_id:, budget_name:, api_key_label: nil)
-      super()
-      @user_id = user_id
-      @user_name = user_name
-      @user_email = user_email
-      @account_id = account_id
-      @budget_name = budget_name
-      @api_key_label = api_key_label
-    end
-  end
-end

data/lib/lunchmoney/user/user_calls.rb

@@ -1,19 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative "user"
-
-module LunchMoney
-  # https://lunchmoney.dev/#user
-  class UserCalls < ApiCall
-    sig { returns(T.any(LunchMoney::User, LunchMoney::Errors)) }
-    def me
-      response = get("me")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      LunchMoney::User.new(**response.body)
-    end
-  end
-end