lunchmoney 1.0.0 → 1.1.1

data/lib/lunchmoney/categories/category_calls.rb

@@ -1,195 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative "category/child_category"
-require_relative "category/category"
-
-module LunchMoney
-  # https://lunchmoney.dev/#categories
-  class CategoryCalls < ApiCall
-    # Valid query parameter formets for categories
-    VALID_FORMATS = T.let(
-      [
-        "flattened",
-        "nested",
-      ],
-      T::Array[String],
-    )
-
-    sig do
-      params(
-        format: T.nilable(T.any(String, Symbol)),
-      ).returns(T.any(T::Array[LunchMoney::Category], LunchMoney::Errors))
-    end
-    def categories(format: nil)
-      response = get("categories", query_params: categories_params(format:))
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body[:categories].map do |category|
-        category[:children]&.map! { |child_category| LunchMoney::Category.new(**child_category) }
-
-        LunchMoney::Category.new(**category)
-      end
-    end
-
-    sig { params(category_id: Integer).returns(T.any(LunchMoney::Category, LunchMoney::Errors)) }
-    def category(category_id)
-      response = get("categories/#{category_id}")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body[:children]&.map! { |child_category| LunchMoney::ChildCategory.new(**child_category) }
-
-      LunchMoney::Category.new(**response.body)
-    end
-
-    sig do
-      params(
-        name: String,
-        description: T.nilable(String),
-        is_income: T::Boolean,
-        exclude_from_budget: T::Boolean,
-        exclude_from_totals: T::Boolean,
-        archived: T::Boolean,
-        group_id: T.nilable(Integer),
-      ).returns(T.any(T::Hash[Symbol, Integer], LunchMoney::Errors))
-    end
-    def create_category(name:, description: nil, is_income: false, exclude_from_budget: false,
-      exclude_from_totals: false, archived: false, group_id: nil)
-      params = clean_params({
-        name:,
-        description:,
-        is_income:,
-        exclude_from_budget:,
-        exclude_from_totals:,
-        archived:,
-        group_id:,
-      })
-      response = post("categories", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig do
-      params(
-        name: String,
-        description: T.nilable(String),
-        is_income: T::Boolean,
-        exclude_from_budget: T::Boolean,
-        exclude_from_totals: T::Boolean,
-        category_ids: T::Array[Integer],
-        new_categories: T::Array[String],
-      ).returns(T.any(T::Hash[Symbol, Integer], LunchMoney::Errors))
-    end
-    def create_category_group(name:, description: nil, is_income: false, exclude_from_budget: false,
-      exclude_from_totals: false, category_ids: [], new_categories: [])
-
-      params = {
-        name:,
-        description:,
-        is_income:,
-        exclude_from_budget:,
-        exclude_from_totals:,
-        category_ids:,
-        new_categories:,
-      }
-
-      response = post("categories/group", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig do
-      params(
-        category_id: Integer,
-        name: T.nilable(String),
-        description: T.nilable(String),
-        is_income: T.nilable(T::Boolean),
-        exclude_from_budget: T.nilable(T::Boolean),
-        exclude_from_totals: T.nilable(T::Boolean),
-        archived: T.nilable(T::Boolean),
-        group_id: T.nilable(Integer),
-      ).returns(T.any(T::Boolean, LunchMoney::Errors))
-    end
-    def update_category(category_id, name: nil, description: nil, is_income: nil, exclude_from_budget: nil,
-      exclude_from_totals: nil, archived: nil, group_id: nil)
-
-      params = clean_params({
-        name:,
-        description:,
-        is_income:,
-        exclude_from_budget:,
-        exclude_from_totals:,
-        archived:,
-        group_id:,
-      })
-      response = put("categories/#{category_id}", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig do
-      params(
-        group_id: Integer,
-        category_ids: T::Array[Integer],
-        new_categories: T::Array[String],
-      ).returns(T.any(LunchMoney::Category, LunchMoney::Errors))
-    end
-    def add_to_category_group(group_id, category_ids: [], new_categories: [])
-      params = {
-        category_ids:,
-        new_categories:,
-      }
-
-      response = post("categories/group/#{group_id}/add", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      LunchMoney::Category.new(**response.body)
-    end
-
-    sig { params(category_id: Integer).returns(T.any(T::Boolean, LunchMoney::Errors)) }
-    def delete_category(category_id)
-      response = delete("categories/#{category_id}")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    sig { params(category_id: Integer).returns(T.any(T::Boolean, LunchMoney::Errors)) }
-    def force_delete_category(category_id)
-      response = delete("categories/#{category_id}/force")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-
-    private
-
-    sig { params(format: T.nilable(T.any(String, Symbol))).returns(T.nilable(T::Hash[Symbol, String])) }
-    def categories_params(format:)
-      return unless format
-
-      raise(InvalidQueryParameter, "format must be either flattened or nested") if VALID_FORMATS.exclude?(format.to_s)
-
-      { format: format.to_s }
-    end
-  end
-end

data/lib/lunchmoney/crypto/crypto/crypto.rb

@@ -1,43 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#crypto-object
-  class Crypto < CryptoBase
-    include LunchMoney::Validators
-
-    sig { returns(String) }
-    attr_reader :balance_as_of
-
-    sig { returns(String) }
-    attr_accessor :currency, :status
-
-    sig do
-      params(
-        created_at: String,
-        source: String,
-        name: String,
-        balance: String,
-        balance_as_of: String,
-        currency: String,
-        status: String,
-        institution_name: T.nilable(String),
-        id: T.nilable(Integer),
-        zabo_account_id: T.nilable(Integer),
-        display_name: T.nilable(String),
-      ).void
-    end
-    def initialize(created_at:, source:, name:, balance:, balance_as_of:, currency:,
-      status:, institution_name: nil, id: nil, zabo_account_id: nil, display_name: nil)
-      super(created_at:, source:, name:, balance:, institution_name:, id:, zabo_account_id:, display_name:)
-      @balance_as_of = T.let(validate_iso8601!(balance_as_of), String)
-      @currency = currency
-      @status = status
-    end
-
-    sig { params(time: String).void }
-    def balance_as_of=(time)
-      @balance_as_of = validate_iso8601!(time)
-    end
-  end
-end

data/lib/lunchmoney/crypto/crypto/crypto_base.rb

@@ -1,65 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#crypto-object
-  class CryptoBase < LunchMoney::DataObject
-    include LunchMoney::Validators
-
-    sig { returns(T.nilable(Integer)) }
-    attr_accessor :id, :zabo_account_id
-
-    sig { returns(String) }
-    attr_reader :source, :created_at
-
-    sig { returns(String) }
-    attr_accessor :name, :balance
-
-    sig { returns(T.nilable(String)) }
-    attr_accessor :display_name, :institution_name
-
-    # Valid crypto source types
-    VALID_SOURCES = T.let(
-      [
-        "synced",
-        "manual",
-      ],
-      T::Array[String],
-    )
-
-    sig do
-      params(
-        created_at: String,
-        source: String,
-        name: String,
-        balance: String,
-        institution_name: T.nilable(String),
-        id: T.nilable(Integer),
-        zabo_account_id: T.nilable(Integer),
-        display_name: T.nilable(String),
-      ).void
-    end
-    def initialize(created_at:, source:, name:, balance:, institution_name: nil, id: nil, zabo_account_id: nil,
-      display_name: nil)
-      super()
-      @created_at = T.let(validate_iso8601!(created_at), String)
-      @source = T.let(validate_one_of!(source, VALID_SOURCES), String)
-      @name = name
-      @balance = balance
-      @institution_name = institution_name
-      @id = id
-      @zabo_account_id = zabo_account_id
-      @display_name = display_name
-    end
-
-    sig { params(name: String).void }
-    def source=(name)
-      @source = validate_one_of!(name, VALID_SOURCES)
-    end
-
-    sig { params(time: String).void }
-    def created_at=(time)
-      @created_at = validate_iso8601!(time)
-    end
-  end
-end

data/lib/lunchmoney/crypto/crypto_calls.rb

@@ -1,49 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative "crypto/crypto_base"
-require_relative "crypto/crypto"
-
-module LunchMoney
-  # https://lunchmoney.dev/#crypto
-  class CryptoCalls < ApiCall
-    sig { returns(T.any(T::Array[LunchMoney::Crypto], LunchMoney::Errors)) }
-    def crypto
-      response = get("crypto")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body[:crypto].map do |crypto|
-        LunchMoney::Crypto.new(**crypto)
-      end
-    end
-
-    sig do
-      params(
-        crypto_id: Integer,
-        name: T.nilable(String),
-        display_name: T.nilable(String),
-        institution_name: T.nilable(String),
-        balance: T.nilable(String),
-        currency: T.nilable(String),
-      ).returns(T.any(LunchMoney::CryptoBase, LunchMoney::Errors))
-    end
-    def update_crypto(crypto_id, name: nil, display_name: nil, institution_name: nil, balance: nil, currency: nil)
-      params = clean_params({
-        name:,
-        display_name:,
-        institution_name:,
-        balance:,
-        currency:,
-      })
-
-      response = put("crypto/manual/#{crypto_id}", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      LunchMoney::CryptoBase.new(**response.body)
-    end
-  end
-end

data/lib/lunchmoney/data_object.rb

@@ -1,25 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # Base data object for the objects returned and used when calling the LunchMoney API
-  class DataObject
-    sig { params(symbolize_keys: T::Boolean).returns(T::Hash[String, T.untyped]) }
-    def serialize(symbolize_keys: false)
-      ivars = instance_variables
-
-      output = {}
-
-      ivars.each do |ivar|
-        key = ivar.to_s.gsub("@", "")
-        key = key.to_sym if symbolize_keys
-
-        value = instance_variable_get(ivar)
-
-        output[key] = value
-      end
-
-      output
-    end
-  end
-end

data/lib/lunchmoney/plaid_accounts/plaid_account.rb

@@ -1,73 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#plaid-accounts-object
-  class PlaidAccount < LunchMoney::DataObject
-    sig { returns(Integer) }
-    attr_accessor :id
-
-    sig { returns(String) }
-    attr_accessor :date_linked,
-      :name,
-      :type,
-      :mask,
-      :institution_name,
-      :status,
-      :balance,
-      :currency,
-      :balance_last_update,
-      :display_name,
-      :plaid_last_successful_update
-
-    sig { returns(T.nilable(String)) }
-    attr_accessor :subtype, :import_start_date, :last_fetch, :last_import
-
-    sig { returns(T.nilable(Integer)) }
-    attr_accessor :limit
-
-    sig do
-      params(
-        date_linked: String,
-        name: String,
-        type: String,
-        mask: String,
-        institution_name: String,
-        status: String,
-        balance: String,
-        currency: String,
-        balance_last_update: String,
-        display_name: String,
-        id: Integer,
-        plaid_last_successful_update: String,
-        last_import: T.nilable(String),
-        limit: T.nilable(Integer),
-        subtype: T.nilable(String),
-        import_start_date: T.nilable(String),
-        last_fetch: T.nilable(String),
-      ).void
-    end
-    def initialize(date_linked:, name:, type:, mask:, institution_name:, status:, balance:, currency:,
-      balance_last_update:, display_name:, id:, plaid_last_successful_update:, last_import: nil, limit: nil,
-      subtype: nil, import_start_date: nil, last_fetch: nil)
-      super()
-      @id = id
-      @date_linked = date_linked
-      @name = name
-      @display_name = display_name
-      @type = type
-      @subtype = subtype
-      @mask = mask
-      @institution_name = institution_name
-      @status = status
-      @limit = limit
-      @balance = balance
-      @currency = currency
-      @balance_last_update = balance_last_update
-      @import_start_date = import_start_date
-      @last_import = last_import
-      @last_fetch = last_fetch
-      @plaid_last_successful_update = plaid_last_successful_update
-    end
-  end
-end

data/lib/lunchmoney/plaid_accounts/plaid_account_calls.rb

@@ -1,38 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative "plaid_account"
-
-module LunchMoney
-  # https://lunchmoney.dev/#plaid-accounts
-  class PlaidAccountCalls < ApiCall
-    sig { returns(T.any(T::Array[LunchMoney::PlaidAccount], LunchMoney::Errors)) }
-    def plaid_accounts
-      response = get("plaid_accounts")
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body[:plaid_accounts].map do |plaid_account|
-        LunchMoney::PlaidAccount.new(**plaid_account)
-      end
-    end
-
-    sig do
-      params(
-        start_date: T.nilable(String),
-        end_date: T.nilable(String),
-        plaid_account_id: T.nilable(Integer),
-      ).returns(T.any(T::Boolean, LunchMoney::Errors))
-    end
-    def plaid_accounts_fetch(start_date: nil, end_date: nil, plaid_account_id: nil)
-      params = clean_params({ start_date:, end_date:, plaid_account_id: })
-      response = post("plaid_accounts/fetch", params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body
-    end
-  end
-end

data/lib/lunchmoney/recurring_expenses/recurring_expense/recurring_expense.rb

@@ -1,65 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#recurring-expenses-object
-  class RecurringExpense < RecurringExpenseBase
-    sig { returns(Integer) }
-    attr_accessor :id
-
-    sig { returns(T.nilable(String)) }
-    attr_accessor :start_date, :end_date, :description, :original_name
-
-    sig { returns(String) }
-    attr_accessor :cadence, :billing_date, :type, :source, :created_at
-
-    sig { returns(T.nilable(Integer)) }
-    attr_accessor :plaid_account_id, :asset_id, :transaction_id, :category_id
-
-    sig do
-      params(
-        cadence: String,
-        payee: String,
-        amount: String,
-        currency: String,
-        billing_date: String,
-        type: String,
-        source: String,
-        id: Integer,
-        created_at: String,
-        category_id: T.nilable(Integer),
-        start_date: T.nilable(String),
-        end_date: T.nilable(String),
-        description: T.nilable(String),
-        original_name: T.nilable(String),
-        plaid_account_id: T.nilable(Integer),
-        asset_id: T.nilable(Integer),
-        transaction_id: T.nilable(Integer),
-        to_base: T.nilable(Number),
-      ).void
-    end
-    def initialize(cadence:, payee:, amount:, currency:, billing_date:, type:, source:, id:, created_at:,
-      category_id: nil, start_date: nil, end_date: nil, description: nil, original_name: nil, plaid_account_id: nil,
-      asset_id: nil, transaction_id: nil, to_base: nil)
-      super(payee:, amount:, currency:, to_base:)
-      @cadence = cadence
-      @payee = payee
-      @amount = amount
-      @currency = currency
-      @billing_date = billing_date
-      @type = type
-      @source = source
-      @id = id
-      @category_id = category_id
-      @created_at = created_at
-      @start_date = start_date
-      @end_date = end_date
-      @description = description
-      @original_name = original_name
-      @plaid_account_id = plaid_account_id
-      @asset_id = asset_id
-      @transaction_id = transaction_id
-      @to_base = to_base
-    end
-  end
-end

data/lib/lunchmoney/recurring_expenses/recurring_expense/recurring_expense_base.rb

@@ -1,29 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#recurring-expenses-object
-  class RecurringExpenseBase < LunchMoney::DataObject
-    sig { returns(String) }
-    attr_accessor :payee, :currency, :amount
-
-    sig { returns(T.nilable(Number)) }
-    attr_accessor :to_base
-
-    sig do
-      params(
-        payee: String,
-        amount: String,
-        currency: String,
-        to_base: T.nilable(Number),
-      ).void
-    end
-    def initialize(payee:, amount:, currency:, to_base:)
-      super()
-      @payee = payee
-      @amount = amount
-      @currency = currency
-      @to_base = to_base
-    end
-  end
-end

data/lib/lunchmoney/recurring_expenses/recurring_expense_calls.rb

@@ -1,28 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require_relative "recurring_expense/recurring_expense_base"
-require_relative "recurring_expense/recurring_expense"
-
-module LunchMoney
-  # https://lunchmoney.dev/#recurring-expenses
-  class RecurringExpenseCalls < ApiCall
-    sig do
-      params(
-        start_date: T.nilable(String),
-        end_date: T.nilable(String),
-      ).returns(T.any(T::Array[LunchMoney::RecurringExpense], LunchMoney::Errors))
-    end
-    def recurring_expenses(start_date: nil, end_date: nil)
-      params = clean_params({ start_date:, end_date: })
-      response = get("recurring_expenses", query_params: params)
-
-      api_errors = errors(response)
-      return api_errors if api_errors.present?
-
-      response.body[:recurring_expenses].map do |recurring_expense|
-        LunchMoney::RecurringExpense.new(**recurring_expense)
-      end
-    end
-  end
-end

data/lib/lunchmoney/tags/tag/tag.rb

@@ -1,20 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#tags-object
-  class Tag < TagBase
-    sig { returns(T.nilable(String)) }
-    attr_accessor :description
-
-    sig { returns(T::Boolean) }
-    attr_accessor :archived
-
-    sig { params(id: Integer, name: String, archived: T::Boolean, description: T.nilable(String)).void }
-    def initialize(id:, name:, archived:, description: nil)
-      super(id:, name:)
-      @archived = archived
-      @description = description
-    end
-  end
-end

data/lib/lunchmoney/tags/tag/tag_base.rb

@@ -1,21 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module LunchMoney
-  # https://lunchmoney.dev/#tags-object without some fields. This is used within field returns of other objects like
-  # field returns of other objects like transactions
-  class TagBase < LunchMoney::DataObject
-    sig { returns(Integer) }
-    attr_accessor :id
-
-    sig { returns(String) }
-    attr_accessor :name
-
-    sig { params(id: Integer, name: String).void }
-    def initialize(id:, name:)
-      super()
-      @id = id
-      @name = name
-    end
-  end
-end

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