diff --git a/app/controllers/accountable_sparklines_controller.rb b/app/controllers/accountable_sparklines_controller.rb index 9ba69ff56..e32500773 100644 --- a/app/controllers/accountable_sparklines_controller.rb +++ b/app/controllers/accountable_sparklines_controller.rb @@ -43,8 +43,14 @@ class AccountableSparklinesController < ApplicationController ).balance_series end + # balance_type is derived purely from accountable_type, so only Investment/Crypto + # can yield :investment. Short-circuit to avoid an N+1 `account.linked?` check + # on every account for non-investment accountable types (loan, credit_card, etc). + # The `Account.linked` scope is the SQL-level mirror of `Account#linked?`. def requires_normalized_aggregation? - accounts.any? { |account| account.linked? && account.balance_type == :investment } + return false unless %w[Investment Crypto].include?(@accountable.name) + + accounts.linked.exists? end def aggregate_normalized_series diff --git a/app/controllers/accounts_controller.rb b/app/controllers/accounts_controller.rb index f7a4510be..efe9bec08 100644 --- a/app/controllers/accounts_controller.rb +++ b/app/controllers/accounts_controller.rb @@ -10,6 +10,7 @@ class AccountsController < ApplicationController @manual_accounts = family.accounts .listable_manual .where(id: @accessible_account_ids) + .includes(:accountable, :account_providers, :plaid_account, :simplefin_account) .order(:name) @plaid_items = visible_provider_items(family.plaid_items.ordered.includes(:syncs, :plaid_accounts)) @simplefin_items = visible_provider_items(family.simplefin_items.ordered.includes(:syncs)) diff --git a/app/helpers/accounts_helper.rb b/app/helpers/accounts_helper.rb index 99ef891ce..a119246fd 100644 --- a/app/helpers/accounts_helper.rb +++ b/app/helpers/accounts_helper.rb @@ -8,4 +8,41 @@ module AccountsHelper # Always use the account sync path, which handles syncing all providers sync_account_path(account) end + + # Returns the account id segment from `/accounts/(/...)?`, or nil. + # Used as a cache-key component so the sidebar's active-link styling is + # correct without busting the cache for every unrelated path change. + def sidebar_active_account_id + match = request.path.match(%r{\A/accounts/([\w-]+)}) + match && match[1] + end + + # Cache key for `accounts/_account_sidebar_tabs.html.erb`. + # Kept here (not in the ERB) so the partial stays render-only. + # + # `shares_version` includes both row count and `max(updated_at)` because + # deleting a non-most-recent share would not move `max(updated_at)` and + # could otherwise serve stale fragments to a user who lost access. + # Both are pulled in a single SQL round-trip via `pick`. Note: Rails + # returns the values as Strings for raw SQL fragments — that's fine + # since they only feed into a cache key (concat-stable, never coerced). + def account_sidebar_tabs_cache_key(family:, active_tab:, mobile:) + shares_version = + if Current.user + count, max_at = AccountShare + .where(user_id: Current.user.id) + .pick(Arel.sql("count(*)"), Arel.sql("max(updated_at)")) + "#{count}-#{max_at}" + end + + [ + family.build_cache_key("account_sidebar_tabs_v1", invalidate_on_data_updates: true), + Current.user&.id, + shares_version, + active_tab, + mobile, + I18n.locale, + sidebar_active_account_id + ] + end end diff --git a/app/models/account/linkable.rb b/app/models/account/linkable.rb index d3830ddda..b91d4ed83 100644 --- a/app/models/account/linkable.rb +++ b/app/models/account/linkable.rb @@ -8,6 +8,17 @@ module Account::Linkable # Legacy provider associations - kept for backward compatibility during migration belongs_to :plaid_account, optional: true belongs_to :simplefin_account, optional: true + + # SQL-level mirror of `linked?`. Use this for set-based checks (e.g. bulk + # `EXISTS`) so both definitions stay in sync. If `linked?` adds a new + # provider source, update this scope too. + scope :linked, -> { + left_outer_joins(:account_providers) + .where( + "account_providers.id IS NOT NULL OR accounts.plaid_account_id IS NOT NULL OR accounts.simplefin_account_id IS NOT NULL" + ) + .distinct + } end # A "linked" account gets transaction and balance data from a third party like Plaid or SimpleFin diff --git a/app/models/balance_sheet/account_totals.rb b/app/models/balance_sheet/account_totals.rb index d03340423..5c767687f 100644 --- a/app/models/balance_sheet/account_totals.rb +++ b/app/models/balance_sheet/account_totals.rb @@ -27,7 +27,14 @@ class BalanceSheet::AccountTotals def visible_accounts @visible_accounts ||= begin - scope = family.accounts.visible.with_attached_logo.includes(:account_shares) + scope = family.accounts.visible.with_attached_logo + .includes( + :account_shares, + :accountable, + :plaid_account, + :simplefin_account, + account_providers: :provider + ) scope = scope.accessible_by(user) if user scope end diff --git a/app/views/accounts/_account_sidebar_tabs.html.erb b/app/views/accounts/_account_sidebar_tabs.html.erb index ae6f793d8..653a64c85 100644 --- a/app/views/accounts/_account_sidebar_tabs.html.erb +++ b/app/views/accounts/_account_sidebar_tabs.html.erb @@ -1,5 +1,6 @@ <%# locals: (family:, active_tab:, mobile: false) %> +<% cache account_sidebar_tabs_cache_key(family: family, active_tab: active_tab, mobile: mobile), expires_in: 12.hours do %>
<% if family.missing_data_provider? %>
@@ -88,3 +89,4 @@ <% end %> <% end %>
+<% end %> diff --git a/app/views/accounts/index/_account_groups.erb b/app/views/accounts/index/_account_groups.erb index 05aa2709f..79709142e 100644 --- a/app/views/accounts/index/_account_groups.erb +++ b/app/views/accounts/index/_account_groups.erb @@ -1,6 +1,11 @@ <%# locals: (accounts:) %> -<% ActiveRecord::Associations::Preloader.new(records: accounts, associations: :account_shares).call if accounts.any? %> +<% if accounts.any? %> + <% ActiveRecord::Associations::Preloader.new( + records: accounts, + associations: [ :account_shares, :accountable, :plaid_account, :simplefin_account, { account_providers: :provider } ] + ).call %> +<% end %> <% accounts.group_by(&:accountable_type).sort_by { |group, _| group }.each do |group, accounts| %>
diff --git a/test/models/account/linkable_test.rb b/test/models/account/linkable_test.rb index a02453c39..560cb5649 100644 --- a/test/models/account/linkable_test.rb +++ b/test/models/account/linkable_test.rb @@ -66,4 +66,45 @@ class Account::LinkableTest < ActiveSupport::TestCase assert @account.can_delete_holdings? end + + # The `linked` scope mirrors `linked?` at the SQL level. These tests pin + # all three link types so a future schema or `linked?` change breaks the + # test instead of silently diverging (e.g. wrong sparkline aggregation). + test "linked scope matches accounts linked via account_providers" do + plaid_account = plaid_accounts(:one) + AccountProvider.create!(account: @account, provider: plaid_account) + + assert_includes Account.linked, @account + end + + test "linked scope matches accounts with legacy plaid_account_id" do + plaid_account = plaid_accounts(:one) + @account.update!(plaid_account: plaid_account) + + assert_includes Account.linked, @account + end + + test "linked scope matches accounts with legacy simplefin_account_id" do + simplefin_item = SimplefinItem.create!( + family: @family, + name: "Test SimpleFin", + access_url: "https://example.com/access_token" + ) + simplefin_account = SimplefinAccount.create!( + simplefin_item: simplefin_item, + name: "Test Account", + account_id: "test-acct", + currency: "USD", + account_type: "checking", + current_balance: 0 + ) + @account.update!(simplefin_account: simplefin_account) + + assert_includes Account.linked, @account + end + + test "linked scope excludes manual accounts" do + assert @account.unlinked? + refute_includes Account.linked, @account + end end