New Design System + Codebase Refresh (#1823)

Since the very first 0.1.0-alpha.1 release, we've been moving quickly to add new features to the Maybe app. In doing so, some parts of the codebase have become outdated, unnecessary, or overly-complex as a natural result of this feature prioritization.

Now that "core" Maybe is complete, we're moving into a second phase of development where we'll be working hard to improve the accuracy of existing features and build additional features on top of "core". This PR is a quick overhaul of the existing codebase aimed to:

- Establish the brand new and simplified dashboard view (pictured above)
- Establish and move towards the conventions introduced in Cursor rules and project design overview #1788
- Consolidate layouts and improve the performance of layout queries
- Organize the core models of the Maybe domain (i.e. Account::Entry, Account::Transaction, etc.) and break out specific traits of each model into dedicated concerns for better readability
- Remove stale / dead code from codebase
- Remove overly complex code paths in favor of simpler ones

app/models/account/balance.rb

@@ -4,6 +4,6 @@ class Account::Balance < ApplicationRecord
   belongs_to :account
   validates :account, :date, :balance, presence: true
   monetize :balance
-  scope :in_period, ->(period) { period.date_range.nil? ? all : where(date: period.date_range) }
+  scope :in_period, ->(period) { period.nil? ? all : where(date: period.date_range) }
   scope :chronological, -> { order(:date) }
 end

app/models/account/balance_trend_calculator.rb

@@ -80,7 +80,7 @@ class Account::BalanceTrendCalculator
     return BalanceTrend.new(trend: nil) unless intraday_balance.present?
 
     BalanceTrend.new(
-      trend: TimeSeries::Trend.new(
+      trend: Trend.new(
         current: Money.new(intraday_balance, entry.currency),
         previous: Money.new(prior_balance, entry.currency),
         favorable_direction: entry.account.favorable_direction

app/models/account/chartable.rb

@@ -0,0 +1,102 @@
+module Account::Chartable
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def balance_series(currency:, period: Period.last_30_days, favorable_direction: "up")
+      balances = Account::Balance.find_by_sql([
+        balance_series_query,
+        {
+          start_date: period.start_date,
+          end_date: period.end_date,
+          interval: period.interval,
+          target_currency: currency
+        }
+      ])
+
+      balances = gapfill_balances(balances)
+
+      values = [ nil, *balances ].each_cons(2).map do |prev, curr|
+        Series::Value.new(
+          date: curr.date,
+          date_formatted: I18n.l(curr.date, format: :long),
+          trend: Trend.new(
+            current: Money.new(curr.balance, currency),
+            previous: prev.nil? ? nil : Money.new(prev.balance, currency),
+            favorable_direction: favorable_direction
+          )
+        )
+      end
+
+      Series.new(
+        start_date: period.start_date,
+        end_date: period.end_date,
+        interval: period.interval,
+        trend: Trend.new(
+          current: Money.new(balances.last&.balance || 0, currency),
+          previous: Money.new(balances.first&.balance || 0, currency),
+          favorable_direction: favorable_direction
+        ),
+        values: values
+      )
+    end
+
+    private
+      def balance_series_query
+        <<~SQL
+          WITH dates as (
+            SELECT generate_series(DATE :start_date, DATE :end_date, :interval::interval)::date as date
+            UNION DISTINCT
+            SELECT CURRENT_DATE -- Ensures we always end on current date, regardless of interval
+          )
+          SELECT
+            d.date,
+            SUM(CASE WHEN accounts.classification = 'asset' THEN ab.balance ELSE -ab.balance END * COALESCE(er.rate, 1)) as balance,
+            COUNT(CASE WHEN accounts.currency <> :target_currency AND er.rate IS NULL THEN 1 END) as missing_rates
+          FROM dates d
+          LEFT JOIN accounts ON accounts.id IN (#{all.select(:id).to_sql})
+          LEFT JOIN account_balances ab ON (
+            ab.date = d.date AND
+            ab.currency = accounts.currency AND
+            ab.account_id = accounts.id
+          )
+          LEFT JOIN exchange_rates er ON (
+            er.date = ab.date AND
+            er.from_currency = accounts.currency AND
+            er.to_currency = :target_currency
+          )
+          GROUP BY d.date
+          ORDER BY d.date
+        SQL
+      end
+
+      def gapfill_balances(balances)
+        gapfilled = []
+
+        prev_balance = nil
+
+        [ nil, *balances ].each_cons(2).each_with_index do |(prev, curr), index|
+          if index == 0 && curr.balance.nil?
+            curr.balance = 0 # Ensure all series start with a non-nil balance
+          elsif curr.balance.nil?
+            curr.balance = prev.balance
+          end
+
+          gapfilled << curr
+        end
+
+        gapfilled
+      end
+  end
+
+  def favorable_direction
+    classification == "asset" ? "up" : "down"
+  end
+
+  def balance_series(period: Period.last_30_days)
+    self.class.where(id: self.id).balance_series(
+      currency: currency,
+      period: period,
+      favorable_direction: favorable_direction
+    )
+  end
+end

app/models/account/entry.rb

@@ -1,8 +1,6 @@
 class Account::Entry < ApplicationRecord
   include Monetizable
 
-  Stats = Struct.new(:currency, :count, :income_total, :expense_total, keyword_init: true)
-
   monetize :amount
 
   belongs_to :account
@@ -16,6 +14,10 @@ class Account::Entry < ApplicationRecord
   validates :date, uniqueness: { scope: [ :account_id, :entryable_type ] }, if: -> { account_valuation? }
   validates :date, comparison: { greater_than: -> { min_supported_date } }
 
+  scope :active, -> {
+    joins(:account).where(accounts: { is_active: true })
+  }
+
   scope :chronological, -> {
     order(
       date: :asc,
@@ -24,10 +26,6 @@ class Account::Entry < ApplicationRecord
     )
   }
 
-  scope :active, -> {
-    joins(:account).where(accounts: { is_active: true, scheduled_for_deletion: false })
-  }
-
   scope :reverse_chronological, -> {
     order(
       date: :desc,
@@ -36,35 +34,6 @@ class Account::Entry < ApplicationRecord
     )
   }
 
-  # All non-transfer entries, rejected transfers, and the outflow of a loan payment transfer are incomes/expenses
-  scope :incomes_and_expenses, -> {
-    joins("INNER JOIN account_transactions ON account_transactions.id = account_entries.entryable_id AND account_entries.entryable_type = 'Account::Transaction'")
-      .joins("LEFT JOIN transfers ON transfers.inflow_transaction_id = account_transactions.id OR transfers.outflow_transaction_id = account_transactions.id")
-      .joins("LEFT JOIN account_transactions inflow_txns ON inflow_txns.id = transfers.inflow_transaction_id")
-      .joins("LEFT JOIN account_entries inflow_entries ON inflow_entries.entryable_id = inflow_txns.id AND inflow_entries.entryable_type = 'Account::Transaction'")
-      .joins("LEFT JOIN accounts inflow_accounts ON inflow_accounts.id = inflow_entries.account_id")
-      .where("transfers.id IS NULL OR transfers.status = 'rejected' OR (account_entries.amount > 0 AND inflow_accounts.accountable_type = 'Loan')")
-  }
-
-  scope :incomes, -> {
-    incomes_and_expenses.where("account_entries.amount <= 0")
-  }
-
-  scope :expenses, -> {
-    incomes_and_expenses.where("account_entries.amount > 0")
-  }
-
-  scope :with_converted_amount, ->(currency) {
-    # Join with exchange rates to convert the amount to the given currency
-    # If no rate is available, exclude the transaction from the results
-    select(
-      "account_entries.*",
-      "account_entries.amount * COALESCE(er.rate, 1) AS converted_amount"
-    )
-      .joins(sanitize_sql_array([ "LEFT JOIN exchange_rates er ON account_entries.date = er.date AND account_entries.currency = er.from_currency AND er.to_currency = ?", currency ]))
-      .where("er.rate IS NOT NULL OR account_entries.currency = ?", currency)
-  }
-
   def sync_account_later
     sync_start_date = [ date_previously_was, date ].compact.min unless destroyed?
     account.sync_later(start_date: sync_start_date)
@@ -82,23 +51,6 @@ class Account::Entry < ApplicationRecord
     enriched_name.presence || name
   end
 
-  def transfer_match_candidates
-    candidates_scope = account.transfer_match_candidates
-
-    candidates_scope = if amount.negative?
-      candidates_scope.where("inflow_candidates.entryable_id = ?", entryable_id)
-    else
-      candidates_scope.where("outflow_candidates.entryable_id = ?", entryable_id)
-    end
-
-    candidates_scope.map do |pm|
-      Transfer.new(
-        inflow_transaction_id: pm.inflow_transaction_id,
-        outflow_transaction_id: pm.outflow_transaction_id,
-      )
-    end
-  end
-
   class << self
     def search(params)
       Account::EntrySearch.new(params).build_query(all)
@@ -109,35 +61,6 @@ class Account::Entry < ApplicationRecord
       30.years.ago.to_date
     end
 
-    def daily_totals(entries, currency, period: Period.last_30_days)
-      # Sum spending and income for each day in the period with the given currency
-      select(
-        "gs.date",
-        "COALESCE(SUM(converted_amount) FILTER (WHERE converted_amount > 0), 0) AS spending",
-        "COALESCE(SUM(-converted_amount) FILTER (WHERE converted_amount < 0), 0) AS income"
-      )
-        .from(entries.with_converted_amount(currency), :e)
-        .joins(sanitize_sql([ "RIGHT JOIN generate_series(?, ?, interval '1 day') AS gs(date) ON e.date = gs.date", period.date_range.first, period.date_range.last ]))
-        .group("gs.date")
-    end
-
-    def daily_rolling_totals(entries, currency, period: Period.last_30_days)
-      # Extend the period to include the rolling window
-      period_with_rolling = period.extend_backward(period.date_range.count.days)
-
-      # Aggregate the rolling sum of spending and income based on daily totals
-      rolling_totals = from(daily_totals(entries, currency, period: period_with_rolling))
-                         .select(
-                           "*",
-                           sanitize_sql_array([ "SUM(spending) OVER (ORDER BY date RANGE BETWEEN INTERVAL ? PRECEDING AND CURRENT ROW) as rolling_spend", "#{period.date_range.count} days" ]),
-                           sanitize_sql_array([ "SUM(income) OVER (ORDER BY date RANGE BETWEEN INTERVAL ? PRECEDING AND CURRENT ROW) as rolling_income", "#{period.date_range.count} days" ])
-                         )
-                         .order(:date)
-
-      # Trim the results to the original period
-      select("*").from(rolling_totals).where("date >= ?", period.date_range.first)
-    end
-
     def bulk_update!(bulk_update_params)
       bulk_attributes = {
         date: bulk_update_params[:date],
@@ -159,25 +82,5 @@ class Account::Entry < ApplicationRecord
 
       all.size
     end
-
-    def stats(currency = "USD")
-      result = all
-        .incomes_and_expenses
-        .joins(sanitize_sql_array([ "LEFT JOIN exchange_rates er ON account_entries.date = er.date AND account_entries.currency = er.from_currency AND er.to_currency = ?", currency ]))
-        .select(
-          "COUNT(*) AS count",
-          "SUM(CASE WHEN account_entries.amount < 0 THEN (account_entries.amount * COALESCE(er.rate, 1)) ELSE 0 END) AS income_total",
-          "SUM(CASE WHEN account_entries.amount > 0 THEN (account_entries.amount * COALESCE(er.rate, 1)) ELSE 0 END) AS expense_total"
-        )
-        .to_a
-        .first
-
-      Stats.new(
-        currency: currency,
-        count: result.count,
-        income_total: result.income_total ? result.income_total * -1 : 0,
-        expense_total: result.expense_total || 0
-      )
-    end
   end
 end

app/models/account/entry_search.rb

@@ -12,29 +12,44 @@ class Account::EntrySearch
   attribute :end_date, :string
 
   class << self
-    def from_entryable_search(entryable_search)
-      new(entryable_search.attributes.slice(*attribute_names))
+    def apply_search_filter(scope, search)
+      return scope if search.blank?
+
+      query = scope
+      query = query.where("account_entries.name ILIKE :search OR account_entries.enriched_name ILIKE :search",
+        search: "%#{ActiveRecord::Base.sanitize_sql_like(search)}%"
+      )
+      query
     end
-  end
 
-  def build_query(scope)
-    query = scope
+    def apply_date_filters(scope, start_date, end_date)
+      return scope if start_date.blank? && end_date.blank?
 
-    query = query.where("account_entries.name ILIKE :search OR account_entries.enriched_name ILIKE :search",
-      search: "%#{ActiveRecord::Base.sanitize_sql_like(search)}%"
-    ) if search.present?
-    query = query.where("account_entries.date >= ?", start_date) if start_date.present?
-    query = query.where("account_entries.date <= ?", end_date) if end_date.present?
+      query = scope
+      query = query.where("account_entries.date >= ?", start_date) if start_date.present?
+      query = query.where("account_entries.date <= ?", end_date) if end_date.present?
+      query
+    end
+
+    def apply_type_filter(scope, types)
+      return scope if types.blank?
+
+      query = scope
 
-    if types.present?
       if types.include?("income") && !types.include?("expense")
         query = query.where("account_entries.amount < 0")
       elsif types.include?("expense") && !types.include?("income")
         query = query.where("account_entries.amount >= 0")
       end
+
+      query
     end
 
-    if amount.present? && amount_operator.present?
+    def apply_amount_filter(scope, amount, amount_operator)
+      return scope if amount.blank? || amount_operator.blank?
+
+      query = scope
+
       case amount_operator
       when "equal"
         query = query.where("ABS(ABS(account_entries.amount) - ?) <= 0.01", amount.to_f.abs)
@@ -43,15 +58,27 @@ class Account::EntrySearch
       when "greater"
         query = query.where("ABS(account_entries.amount) > ?", amount.to_f.abs)
       end
+
+      query
     end
 
-    if accounts.present? || account_ids.present?
-      query = query.joins(:account)
+    def apply_accounts_filter(scope, accounts, account_ids)
+      return scope if accounts.blank? && account_ids.blank?
+
+      query = scope
+      query = query.where(accounts: { name: accounts }) if accounts.present?
+      query = query.where(accounts: { id: account_ids }) if account_ids.present?
+      query
     end
+  end
 
-    query = query.where(accounts: { name: accounts }) if accounts.present?
-    query = query.where(accounts: { id: account_ids }) if account_ids.present?
-
+  def build_query(scope)
+    query = scope.joins(:account)
+    query = self.class.apply_search_filter(query, search)
+    query = self.class.apply_date_filters(query, start_date, end_date)
+    query = self.class.apply_type_filter(query, types)
+    query = self.class.apply_amount_filter(query, amount, amount_operator)
+    query = self.class.apply_accounts_filter(query, accounts, account_ids)
     query
   end
 end

app/models/account/entryable.rb

@@ -9,5 +9,21 @@ module Account::Entryable
 
   included do
     has_one :entry, as: :entryable, touch: true
+
+    scope :with_entry, -> { joins(:entry) }
+
+    scope :active, -> { with_entry.merge(Account::Entry.active) }
+
+    scope :in_period, ->(period) {
+      with_entry.where(account_entries: { date: period.start_date..period.end_date })
+    }
+
+    scope :reverse_chronological, -> {
+      with_entry.merge(Account::Entry.reverse_chronological)
+    }
+
+    scope :chronological, -> {
+      with_entry.merge(Account::Entry.chronological)
+    }
   end
 end

app/models/account/holding.rb

@@ -53,13 +53,12 @@ class Account::Holding < ApplicationRecord
   end
 
   private
-
     def calculate_trend
       return nil unless amount_money
 
       start_amount = qty * avg_cost
 
-      TimeSeries::Trend.new \
+      Trend.new \
         current: amount_money,
         previous: start_amount
     end

app/models/account/syncer.rb

@@ -5,7 +5,7 @@ class Account::Syncer
   end
 
   def run
-    account.auto_match_transfers!
+    account.family.auto_match_transfers!
 
     holdings = sync_holdings
     balances = sync_balances(holdings)

app/models/account/trade.rb

@@ -16,6 +16,6 @@ class Account::Trade < ApplicationRecord
     current_value = current_price * qty.abs
     cost_basis = price_money * qty.abs
 
-    TimeSeries::Trend.new(current: current_value, previous: cost_basis)
+    Trend.new(current: current_value, previous: cost_basis)
   end
 end

app/models/account/transaction.rb

@@ -1,33 +1,17 @@
 class Account::Transaction < ApplicationRecord
-  include Account::Entryable
+  include Account::Entryable, Transferable
 
   belongs_to :category, optional: true
   belongs_to :merchant, optional: true
+
   has_many :taggings, as: :taggable, dependent: :destroy
   has_many :tags, through: :taggings
 
-  has_one :transfer_as_inflow, class_name: "Transfer", foreign_key: "inflow_transaction_id", dependent: :destroy
-  has_one :transfer_as_outflow, class_name: "Transfer", foreign_key: "outflow_transaction_id", dependent: :destroy
-
-  # We keep track of rejected transfers to avoid auto-matching them again
-  has_one :rejected_transfer_as_inflow, class_name: "RejectedTransfer", foreign_key: "inflow_transaction_id", dependent: :destroy
-  has_one :rejected_transfer_as_outflow, class_name: "RejectedTransfer", foreign_key: "outflow_transaction_id", dependent: :destroy
-
   accepts_nested_attributes_for :taggings, allow_destroy: true
 
-  scope :active, -> { where(excluded: false) }
-
   class << self
     def search(params)
       Account::TransactionSearch.new(params).build_query(all)
     end
   end
-
-  def transfer
-    transfer_as_inflow || transfer_as_outflow
-  end
-
-  def transfer?
-    transfer.present?
-  end
 end

app/models/account/transaction/transferable.rb

@@ -0,0 +1,40 @@
+module Account::Transaction::Transferable
+  extend ActiveSupport::Concern
+
+  included do
+    has_one :transfer_as_inflow, class_name: "Transfer", foreign_key: "inflow_transaction_id", dependent: :destroy
+    has_one :transfer_as_outflow, class_name: "Transfer", foreign_key: "outflow_transaction_id", dependent: :destroy
+
+    # We keep track of rejected transfers to avoid auto-matching them again
+    has_one :rejected_transfer_as_inflow, class_name: "RejectedTransfer", foreign_key: "inflow_transaction_id", dependent: :destroy
+    has_one :rejected_transfer_as_outflow, class_name: "RejectedTransfer", foreign_key: "outflow_transaction_id", dependent: :destroy
+  end
+
+  def transfer
+    transfer_as_inflow || transfer_as_outflow
+  end
+
+  def transfer?
+    transfer.present?
+  end
+
+  def transfer_match_candidates
+    candidates_scope = if self.entry.amount.negative?
+      family_matches_scope.where("inflow_candidates.entryable_id = ?", self.id)
+    else
+      family_matches_scope.where("outflow_candidates.entryable_id = ?", self.id)
+    end
+
+    candidates_scope.map do |match|
+      Transfer.new(
+        inflow_transaction_id: match.inflow_transaction_id,
+        outflow_transaction_id: match.outflow_transaction_id,
+      )
+    end
+  end
+
+  private
+    def family_matches_scope
+      self.entry.account.family.transfer_match_candidates
+    end
+end

app/models/account/transaction_search.rb

@@ -16,7 +16,7 @@ class Account::TransactionSearch
 
   # Returns array of Account::Entry objects to stay consistent with partials, which only deal with Account::Entry
   def build_query(scope)
-    query = scope
+    query = scope.joins(entry: :account)
 
     if types.present? && types.exclude?("transfer")
       query = query.joins("LEFT JOIN transfers ON transfers.inflow_transaction_id = account_entries.id OR transfers.outflow_transaction_id = account_entries.id")
@@ -40,8 +40,13 @@ class Account::TransactionSearch
 
     query = query.joins(:tags).where(tags: { name: tags }) if tags.present?
 
-    entries_scope = Account::Entry.account_transactions.where(entryable_id: query.select(:id))
+    # Apply common entry search filters
+    query = Account::EntrySearch.apply_search_filter(query, search)
+    query = Account::EntrySearch.apply_date_filters(query, start_date, end_date)
+    query = Account::EntrySearch.apply_type_filter(query, types)
+    query = Account::EntrySearch.apply_amount_filter(query, amount, amount_operator)
+    query = Account::EntrySearch.apply_accounts_filter(query, accounts, account_ids)
 
-    Account::EntrySearch.from_entryable_search(self).build_query(entries_scope)
+    query
   end
 end