Skip to content

Open-source personal finance manager. Self-hosted, privacy-first.

Allow hiding default categories (#477)

Romulo Gatto2ddcd053c47b
diff --git a/backend/alembic/versions/074_hide_default_categories.py b/backend/alembic/versions/074_hide_default_categories.py
new file mode 100644
index 00000000..96bc69d2
--- /dev/null
+++ b/backend/alembic/versions/074_hide_default_categories.py
@@ -0,0 +1,35 @@
+"""add hidden flags to categories and category groups
+
+Revision ID: 074
+Revises: 073
+Create Date: 2026-07-30
+
+Users cannot delete seeded system categories/groups because historical
+transactions may still point at them. Add an explicit visibility flag so the
+UI can hide defaults without destructive data changes.
+"""
+from typing import Sequence, Union
+
+import sqlalchemy as sa
+from alembic import op
+
+revision: str = "074"
+down_revision: Union[str, None] = "073"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+ op.add_column(
+ "categories",
+ sa.Column("is_hidden", sa.Boolean(), nullable=False, server_default=sa.false()),
+ )
+ op.add_column(
+ "category_groups",
+ sa.Column("is_hidden", sa.Boolean(), nullable=False, server_default=sa.false()),
+ )
+
+
+def downgrade() -> None:
+ op.drop_column("category_groups", "is_hidden")
+ op.drop_column("categories", "is_hidden")
diff --git a/backend/app/api/categories.py b/backend/app/api/categories.py
index 28440d77..60b5b491 100644
--- a/backend/app/api/categories.py
+++ b/backend/app/api/categories.py
@@ -1,6 +1,6 @@
import uuid
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.database import get_async_session
@@ -9,7 +9,13 @@ from app.core.workspace_context import (
current_workspace,
current_writable_workspace,
)
-from app.schemas.category import CategoryCreate, CategoryRead, CategoryUpdate
+from app.schemas.category import (
+ CategoryCreate,
+ CategoryRead,
+ CategoryRuleUsage,
+ CategoryUpdate,
+ RuleSummary,
+)
from app.services import category_service
router = APIRouter(prefix="/api/categories", tags=["categories"])
@@ -17,10 +23,15 @@ router = APIRouter(prefix="/api/categories", tags=["categories"])
@router.get("", response_model=list[CategoryRead])
async def list_categories(
+ include_hidden: bool = Query(False),
ctx: WorkspaceContext = Depends(current_workspace),
session: AsyncSession = Depends(get_async_session),
):
- return await category_service.get_categories(session, ctx.workspace.id)
+ return await category_service.get_categories(
+ session,
+ ctx.workspace.id,
+ include_hidden=include_hidden,
+ )
@router.post("", response_model=CategoryRead, status_code=status.HTTP_201_CREATED)
@@ -32,14 +43,37 @@ async def create_category(
return await category_service.create_category(session, ctx.workspace.id, ctx.user_id, data)
[email protected]("/{category_id}/rule-usage", response_model=CategoryRuleUsage)
+async def category_rule_usage(
+ category_id: uuid.UUID,
+ ctx: WorkspaceContext = Depends(current_workspace),
+ session: AsyncSession = Depends(get_async_session),
+):
+ """Active rules that assign this category, so hiding it can offer to retire them."""
+ rules = await category_service.get_rules_assigning_category(
+ session, ctx.workspace.id, category_id
+ )
+ return CategoryRuleUsage(rules=[RuleSummary(id=r.id, name=r.name) for r in rules])
+
+
@router.patch("/{category_id}", response_model=CategoryRead)
async def update_category(
category_id: uuid.UUID,
data: CategoryUpdate,
+ deactivate_rules: bool = Query(False),
ctx: WorkspaceContext = Depends(current_writable_workspace),
session: AsyncSession = Depends(get_async_session),
):
- category = await category_service.update_category(session, category_id, ctx.workspace.id, data)
+ try:
+ category = await category_service.update_category(
+ session,
+ category_id,
+ ctx.workspace.id,
+ data,
+ deactivate_rules=deactivate_rules,
+ )
+ except category_service.CategoryVisibilityError as exc:
+ raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
if not category:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Category not found")
return category
diff --git a/backend/app/api/category_groups.py b/backend/app/api/category_groups.py
index a405e8b9..df7306c4 100644
--- a/backend/app/api/category_groups.py
+++ b/backend/app/api/category_groups.py
@@ -1,6 +1,6 @@
import uuid
-from fastapi import APIRouter, Depends, HTTPException, status
+from fastapi import APIRouter, Depends, HTTPException, Query, status
from sqlalchemy.ext.asyncio import AsyncSession
from app.core.database import get_async_session
@@ -17,10 +17,15 @@ router = APIRouter(prefix="/api/category-groups", tags=["category-groups"])
@router.get("", response_model=list[CategoryGroupRead])
async def list_groups(
+ include_hidden: bool = Query(False),
ctx: WorkspaceContext = Depends(current_workspace),
session: AsyncSession = Depends(get_async_session),
):
- return await category_group_service.get_groups(session, ctx.workspace.id)
+ return await category_group_service.get_groups(
+ session,
+ ctx.workspace.id,
+ include_hidden=include_hidden,
+ )
@router.post("", response_model=CategoryGroupRead, status_code=status.HTTP_201_CREATED)
@@ -39,7 +44,12 @@ async def update_group(
ctx: WorkspaceContext = Depends(current_writable_workspace),
session: AsyncSession = Depends(get_async_session),
):
- group = await category_group_service.update_group(session, group_id, ctx.workspace.id, data)
+ try:
+ group = await category_group_service.update_group(
+ session, group_id, ctx.workspace.id, data
+ )
+ except category_group_service.CategoryGroupVisibilityError as exc:
+ raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
if not group:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")
return group
diff --git a/backend/app/models/category.py b/backend/app/models/category.py
index 4a4b5ce0..35b16fac 100644
--- a/backend/app/models/category.py
+++ b/backend/app/models/category.py
@@ -25,6 +25,7 @@ class Category(Base):
icon: Mapped[str] = mapped_column(String(50), default="circle-help")
color: Mapped[str] = mapped_column(String(7), default="#6B7280")
is_system: Mapped[bool] = mapped_column(Boolean, default=False)
+ is_hidden: Mapped[bool] = mapped_column(Boolean, default=False, server_default="false")
# Flag for "money that moves rather than money earned or spent".
# Transactions in these categories are excluded from income/expense
diff --git a/backend/app/models/category_group.py b/backend/app/models/category_group.py
index a6fbcf19..66384b7c 100644
--- a/backend/app/models/category_group.py
+++ b/backend/app/models/category_group.py
@@ -25,6 +25,7 @@ class CategoryGroup(Base):
color: Mapped[str] = mapped_column(String(7), default="#6B7280")
position: Mapped[int] = mapped_column(Integer, default=0)
is_system: Mapped[bool] = mapped_column(Boolean, default=False)
+ is_hidden: Mapped[bool] = mapped_column(Boolean, default=False, server_default="false")
user: Mapped["User"] = relationship(back_populates="category_groups")
categories: Mapped[list["Category"]] = relationship(
diff --git a/backend/app/schemas/category.py b/backend/app/schemas/category.py
index 44c20345..596fe49a 100644
--- a/backend/app/schemas/category.py
+++ b/backend/app/schemas/category.py
@@ -23,6 +23,7 @@ class CategoryUpdate(BaseModel):
group_id: Optional[uuid.UUID] = None
treat_as_transfer: Optional[bool] = None
is_ignored: Optional[bool] = None
+ is_hidden: Optional[bool] = None
class CategoryRead(CategoryBase):
@@ -30,7 +31,20 @@ class CategoryRead(CategoryBase):
user_id: uuid.UUID
group_id: Optional[uuid.UUID] = None
is_system: bool
+ is_hidden: bool = False
treat_as_transfer: bool = False
is_ignored: bool = False
model_config = ConfigDict(from_attributes=True)
+
+class RuleSummary(BaseModel):
+ """Just enough of a rule to name it in the hide-category dialog."""
+
+ id: uuid.UUID
+ name: str
+
+
+class CategoryRuleUsage(BaseModel):
+ """Active rules that assign a category."""
+
+ rules: list[RuleSummary] = []
diff --git a/backend/app/schemas/category_group.py b/backend/app/schemas/category_group.py
index 4da1f54d..53db0e5a 100644
--- a/backend/app/schemas/category_group.py
+++ b/backend/app/schemas/category_group.py
@@ -22,12 +22,14 @@ class CategoryGroupUpdate(BaseModel):
icon: Optional[str] = None
color: Optional[str] = None
position: Optional[int] = None
+ is_hidden: Optional[bool] = None
class CategoryGroupRead(CategoryGroupBase):
id: uuid.UUID
user_id: uuid.UUID
is_system: bool
+ is_hidden: bool = False
categories: list[CategoryRead] = []
model_config = ConfigDict(from_attributes=True)
diff --git a/backend/app/services/category_group_service.py b/backend/app/services/category_group_service.py
index 03e7ffc1..aa50f7c0 100644
--- a/backend/app/services/category_group_service.py
+++ b/backend/app/services/category_group_service.py
@@ -10,6 +10,10 @@ from app.models.category_group import CategoryGroup
from app.schemas.category_group import CategoryGroupCreate, CategoryGroupUpdate
+class CategoryGroupVisibilityError(ValueError):
+ """Raised when visibility is changed for a user-created category group."""
+
+
# Language-keyed translations for default groups
# Keys are internal identifiers, values are {lang: display_name}
DEFAULT_GROUPS_I18N = {
@@ -72,12 +76,25 @@ async def create_default_groups(
return groups
-async def get_groups(session: AsyncSession, workspace_id: uuid.UUID) -> list[CategoryGroup]:
+async def get_groups(
+ session: AsyncSession,
+ workspace_id: uuid.UUID,
+ *,
+ include_hidden: bool = False,
+) -> list[CategoryGroup]:
+ filters = [CategoryGroup.workspace_id == workspace_id]
+ if not include_hidden:
+ filters.append(CategoryGroup.is_hidden.is_(False))
+
+ category_loader = selectinload(CategoryGroup.categories)
+ if not include_hidden:
+ category_loader = selectinload(CategoryGroup.categories.and_(Category.is_hidden.is_(False)))
+
result = await session.execute(
select(CategoryGroup)
- .where(CategoryGroup.workspace_id == workspace_id)
- .options(selectinload(CategoryGroup.categories))
- .order_by(CategoryGroup.position)
+ .where(*filters)
+ .options(category_loader)
+ .order_by(CategoryGroup.is_hidden.asc(), CategoryGroup.position)
)
return list(result.scalars().all())
@@ -113,7 +130,11 @@ async def update_group(
if not group:
return None
- for key, value in data.model_dump(exclude_unset=True).items():
+ changes = data.model_dump(exclude_unset=True)
+ if changes.get("is_hidden") is True and not group.is_system:
+ raise CategoryGroupVisibilityError("Only system category groups can be hidden")
+
+ for key, value in changes.items():
setattr(group, key, value)
await session.commit()
diff --git a/backend/app/services/category_service.py b/backend/app/services/category_service.py
index de156942..fd83473c 100644
--- a/backend/app/services/category_service.py
+++ b/backend/app/services/category_service.py
@@ -1,15 +1,21 @@
import uuid
from typing import Optional
-from sqlalchemy import select
+from sqlalchemy import or_, select
from sqlalchemy.exc import IntegrityError
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.category import Category
+from app.models.category_group import CategoryGroup
+from app.models.rule import Rule
from app.schemas.category import CategoryCreate, CategoryUpdate
from app.services.category_group_service import CATEGORY_TO_GROUP, create_default_groups
+class CategoryVisibilityError(ValueError):
+ """Raised when visibility is changed for a user-created category."""
+
+
# Language-keyed translations for default categories
# Keys are internal identifiers used to map to groups and rules.
# `treat_as_transfer` marks categories whose transactions are flows, not
@@ -92,11 +98,41 @@ async def create_default_categories(
return categories
-async def get_categories(session: AsyncSession, workspace_id: uuid.UUID) -> list[Category]:
+async def get_hidden_category_ids(
+ session: AsyncSession, workspace_id: uuid.UUID
+) -> set[uuid.UUID]:
+ """Ids of categories the workspace hides, directly or through their group.
+
+ The rule engine needs these so it never files a transaction under a
+ category the user has taken out of circulation.
+ """
+ result = await session.execute(
+ select(Category.id)
+ .outerjoin(CategoryGroup, Category.group_id == CategoryGroup.id)
+ .where(
+ Category.workspace_id == workspace_id,
+ or_(Category.is_hidden.is_(True), CategoryGroup.is_hidden.is_(True)),
+ )
+ )
+ return set(result.scalars().all())
+
+
+async def get_categories(
+ session: AsyncSession,
+ workspace_id: uuid.UUID,
+ *,
+ include_hidden: bool = False,
+) -> list[Category]:
+ filters = [Category.workspace_id == workspace_id]
+ if not include_hidden:
+ filters.append(Category.is_hidden.is_(False))
+ filters.append(or_(Category.group_id.is_(None), CategoryGroup.is_hidden.is_(False)))
+
result = await session.execute(
select(Category)
- .where(Category.workspace_id == workspace_id)
- .order_by(Category.is_system.desc(), Category.name)
+ .outerjoin(CategoryGroup, Category.group_id == CategoryGroup.id)
+ .where(*filters)
+ .order_by(Category.is_hidden.asc(), Category.is_system.desc(), Category.name)
)
return list(result.scalars().all())
@@ -125,19 +161,69 @@ async def create_category(
return category
+async def get_rules_assigning_category(
+ session: AsyncSession, workspace_id: uuid.UUID, category_id: uuid.UUID
+) -> list[Rule]:
+ """Active rules whose `set_category` action targets this category.
+
+ Hiding a category is how a user retires it, but a rule that assigns it
+ keeps categorizing new transactions into it. The UI lists these so the
+ user can retire the rules in the same step.
+ """
+ result = await session.execute(
+ select(Rule)
+ .where(Rule.workspace_id == workspace_id, Rule.is_active.is_(True))
+ .order_by(Rule.priority, Rule.id)
+ )
+ target = str(category_id)
+ return [
+ rule
+ for rule in result.scalars().all()
+ if any(
+ action.get("op") == "set_category" and str(action.get("value")) == target
+ for action in (rule.actions or [])
+ )
+ ]
+
+
+async def deactivate_rules_assigning_category(
+ session: AsyncSession, workspace_id: uuid.UUID, category_id: uuid.UUID
+) -> int:
+ """Turn off the rules that assign this category and report how many."""
+ rules = await get_rules_assigning_category(session, workspace_id, category_id)
+ for rule in rules:
+ rule.is_active = False
+ return len(rules)
+
+
async def update_category(
session: AsyncSession,
category_id: uuid.UUID,
workspace_id: uuid.UUID,
data: CategoryUpdate,
+ *,
+ deactivate_rules: bool = False,
) -> Optional[Category]:
+ """Update a category, optionally retiring the rules that assign it.
+
+ `deactivate_rules` only applies when the category is being hidden: the
+ rules that filed transactions under it would otherwise stay listed as
+ active while the engine skips their categorization.
+ """
category = await get_category(session, category_id, workspace_id)
if not category:
return None
- for key, value in data.model_dump(exclude_unset=True).items():
+ changes = data.model_dump(exclude_unset=True)
+ if changes.get("is_hidden") is True and not category.is_system:
+ raise CategoryVisibilityError("Only system categories can be hidden")
+
+ for key, value in changes.items():
setattr(category, key, value)
+ if deactivate_rules and changes.get("is_hidden") is True:
+ await deactivate_rules_assigning_category(session, workspace_id, category_id)
+
await session.commit()
await session.refresh(category)
return category
diff --git a/backend/app/services/import_service.py b/backend/app/services/import_service.py
index 5416cc58..e155bf6b 100644
--- a/backend/app/services/import_service.py
+++ b/backend/app/services/import_service.py
@@ -19,6 +19,7 @@ from app.models.transaction import Transaction
from app.schemas.transaction import TransactionImport
from app.services import recurring_match_service
from app.services.credit_card_service import apply_effective_date
+from app.services.category_service import get_hidden_category_ids
from app.services.rule_engine import apply_rule_actions, evaluate_conditions, merge_notes
from app.services.rule_service import apply_rules_to_transaction, preview_rules_for_transaction
from app.services.fx_rate_service import stamp_primary_amount
@@ -621,6 +622,7 @@ async def enrich_with_category_suggestions(
select(Category).where(Category.workspace_id == workspace_id)
)
category_name_map = {str(c.id): c.name for c in category_result.scalars()}
+ hidden_categories = await get_hidden_category_ids(session, workspace_id)
if not rules:
return transactions
@@ -641,7 +643,12 @@ async def enrich_with_category_suggestions(
conditions = rule.conditions or []
actions = rule.actions or []
if evaluate_conditions(rule.conditions_op, conditions, proxy):
- category_set = apply_rule_actions(actions, proxy, category_set)
+ category_set = apply_rule_actions(
+ actions,
+ proxy,
+ category_set,
+ hidden_category_ids=hidden_categories,
+ )
if proxy.category_id:
txn.suggested_category_id = proxy.category_id
txn.suggested_category_name = category_name_map.get(str(proxy.category_id))
diff --git a/backend/app/services/rule_engine.py b/backend/app/services/rule_engine.py
index 44b3657f..43edbdea 100644
--- a/backend/app/services/rule_engine.py
+++ b/backend/app/services/rule_engine.py
@@ -2,6 +2,7 @@
import re
import unicodedata
import uuid
+from collections.abc import Collection
from datetime import date, datetime
from decimal import Decimal, InvalidOperation
from typing import TYPE_CHECKING
@@ -190,18 +191,29 @@ def apply_rule_actions(
category_already_set: bool,
*,
skip_description: bool = False,
+ hidden_category_ids: Collection[uuid.UUID] | None = None,
) -> bool:
- """Apply actions in-place and return the updated category-set flag."""
+ """Apply actions in-place and return the updated category-set flag.
+
+ A category the workspace has hidden is never assigned: hiding it means the
+ user stopped using it, so a rule that still points at one keeps its other
+ actions and drops only the categorization. The transaction is left
+ uncategorized rather than filed under a category the pickers no longer
+ offer.
+ """
for action in actions:
op = action.get("op")
value = action.get("value")
if op == "set_category" and not category_already_set:
try:
- tx.category_id = uuid.UUID(str(value))
- category_already_set = True
+ category_id = uuid.UUID(str(value))
except (ValueError, AttributeError):
- pass
+ continue
+ if hidden_category_ids and category_id in hidden_category_ids:
+ continue
+ tx.category_id = category_id
+ category_already_set = True
elif op == "set_description":
if skip_description:
diff --git a/backend/app/services/rule_service.py b/backend/app/services/rule_service.py
index 30719250..18377cdc 100644
--- a/backend/app/services/rule_service.py
+++ b/backend/app/services/rule_service.py
@@ -10,6 +10,7 @@ from app.models.category import Category
from app.models.payee import Payee
from app.models.transaction import Transaction
from app.schemas.rule import RuleCreate, RuleExportPayload, RuleImportResponse, RuleUpdate
+from app.services.category_service import get_hidden_category_ids
from app.services.rule_engine import (
apply_rule_actions,
compile_rule_regex,
@@ -1170,12 +1171,22 @@ async def apply_rules_to_transaction(
rules = result.scalars().all()
category_set = transaction.category_id is not None or skip_category_rules
+ hidden_categories = (
+ await get_hidden_category_ids(session, transaction.workspace_id)
+ if getattr(transaction, "workspace_id", None) is not None
+ else set()
+ )
for rule in rules:
conditions = rule.conditions or []
actions = rule.actions or []
if evaluate_conditions(rule.conditions_op, conditions, transaction):
- category_set = apply_rule_actions(actions, transaction, category_set)
+ category_set = apply_rule_actions(
+ actions,
+ transaction,
+ category_set,
+ hidden_category_ids=hidden_categories,
+ )
async def apply_single_rule(
@@ -1208,6 +1219,7 @@ async def apply_single_rule(
conditions = rule.conditions or []
actions = rule.actions or []
+ hidden_categories = await get_hidden_category_ids(session, workspace_id)
count = 0
for tx in transactions:
matches = evaluate_conditions(rule.conditions_op, conditions, tx)
@@ -1235,6 +1247,7 @@ async def apply_single_rule(
category_already_set=tx.category_id is not None
and not overwrite_existing_categories,
skip_description=_has_manual_description(tx),
+ hidden_category_ids=hidden_categories,
)
after = (
tx.category_id,
@@ -1269,6 +1282,7 @@ async def apply_all_rules(session: AsyncSession, workspace_id: uuid.UUID) -> int
)
rules = rules_result.scalars().all()
+ hidden_categories = await get_hidden_category_ids(session, workspace_id)
count = 0
for tx in transactions:
preserve_manual_description = _has_manual_description(tx)
@@ -1300,6 +1314,7 @@ async def apply_all_rules(session: AsyncSession, workspace_id: uuid.UUID) -> int
tx,
category_set,
skip_description=preserve_manual_description,
+ hidden_category_ids=hidden_categories,
)
after = (
diff --git a/backend/tests/test_categories_api.py b/backend/tests/test_categories_api.py
index 63f40a8e..a844a0ba 100644
--- a/backend/tests/test_categories_api.py
+++ b/backend/tests/test_categories_api.py
@@ -52,13 +52,19 @@ async def test_create_category(client: AsyncClient, auth_headers, test_categorie
response = await client.post(
"/api/categories",
headers=auth_headers,
- json={"name": "Educação", "icon": "📚", "color": "#9333EA"},
+ json={
+ "name": "Educação",
+ "icon": "📚",
+ "color": "#9333EA",
+ "is_hidden": True,
+ },
)
assert response.status_code == 201
data = response.json()
assert data["name"] == "Educação"
assert data["icon"] == "📚"
assert data["is_system"] is False
+ assert data["is_hidden"] is False
@pytest.mark.asyncio
@@ -209,7 +215,200 @@ async def test_delete_system_category_fails(
assert response.status_code == 400
+async def test_hide_system_category_filters_default_list(
+ client: AsyncClient, auth_headers, test_categories: list[Category]
+):
+ cat_id = str(test_categories[0].id)
+
+ update_response = await client.patch(
+ f"/api/categories/{cat_id}",
+ headers=auth_headers,
+ json={"is_hidden": True},
+ )
+ assert update_response.status_code == 200
+ assert update_response.json()["is_hidden"] is True
+
+ response = await client.get("/api/categories", headers=auth_headers)
+ assert response.status_code == 200
+ assert cat_id not in {category["id"] for category in response.json()}
+
+ include_hidden_response = await client.get(
+ "/api/categories?include_hidden=true",
+ headers=auth_headers,
+ )
+ assert include_hidden_response.status_code == 200
+ hidden_category = next(
+ category for category in include_hidden_response.json() if category["id"] == cat_id
+ )
+ assert hidden_category["is_hidden"] is True
+
+
+async def test_cannot_hide_user_category(client: AsyncClient, auth_headers):
+ create_response = await client.post(
+ "/api/categories",
+ headers=auth_headers,
+ json={"name": "Custom"},
+ )
+ assert create_response.status_code == 201
+ category_id = create_response.json()["id"]
+
+ update_response = await client.patch(
+ f"/api/categories/{category_id}",
+ headers=auth_headers,
+ json={"is_hidden": True},
+ )
+
+ assert update_response.status_code == 400
+ assert update_response.json()["detail"] == "Only system categories can be hidden"
+
+ unhide_response = await client.patch(
+ f"/api/categories/{category_id}",
+ headers=auth_headers,
+ json={"is_hidden": False},
+ )
+ assert unhide_response.status_code == 200
+ assert unhide_response.json()["is_hidden"] is False
+
+ list_response = await client.get(
+ "/api/categories?include_hidden=true",
+ headers=auth_headers,
+ )
+ category = next(item for item in list_response.json() if item["id"] == category_id)
+ assert category["is_hidden"] is False
+
+
@pytest.mark.asyncio
async def test_categories_unauthenticated(client: AsyncClient, clean_db):
response = await client.get("/api/categories")
assert response.status_code == 401
+
+
+async def test_hidden_category_is_not_assigned_by_rules(
+ client: AsyncClient, auth_headers, test_categories: list[Category], test_account
+):
+ """A category the user retired must not come back through a rule."""
+ cat_id = str(test_categories[0].id)
+ rule_response = await client.post(
+ "/api/rules",
+ headers=auth_headers,
+ json={
+ "name": "Delivery",
+ "conditions_op": "or",
+ "conditions": [
+ {"field": "description", "op": "contains", "value": "IFOOD"}
+ ],
+ "actions": [{"op": "set_category", "value": cat_id}],
+ "priority": 0,
+ },
+ )
+ assert rule_response.status_code == 201
+
+ payload = {
+ "account_id": str(test_account.id),
+ "description": "IFOOD PEDIDO",
+ "amount": -42.0,
+ "date": "2026-08-24",
+ "type": "expense",
+ }
+
+ matched = await client.post("/api/transactions", headers=auth_headers, json=payload)
+ assert matched.status_code == 201
+ assert matched.json()["category_id"] == cat_id
+
+ hide = await client.patch(
+ f"/api/categories/{cat_id}", headers=auth_headers, json={"is_hidden": True}
+ )
+ assert hide.status_code == 200
+
+ after_hiding = await client.post(
+ "/api/transactions", headers=auth_headers, json=payload
+ )
+ assert after_hiding.status_code == 201
+ assert after_hiding.json()["category_id"] is None
+
+
+async def test_rule_usage_lists_rules_assigning_the_category(
+ client: AsyncClient, auth_headers, test_categories: list[Category]
+):
+ cat_id = str(test_categories[0].id)
+ other_id = str(test_categories[1].id)
+
+ for name, target in [("Food rule", cat_id), ("Transport rule", other_id)]:
+ response = await client.post(
+ "/api/rules",
+ headers=auth_headers,
+ json={
+ "name": name,
+ "conditions_op": "or",
+ "conditions": [
+ {"field": "description", "op": "contains", "value": name}
+ ],
+ "actions": [{"op": "set_category", "value": target}],
+ "priority": 0,
+ },
+ )
+ assert response.status_code == 201
+
+ usage = await client.get(
+ f"/api/categories/{cat_id}/rule-usage", headers=auth_headers
+ )
+ assert usage.status_code == 200
+ assert [rule["name"] for rule in usage.json()["rules"]] == ["Food rule"]
+
+
+async def test_hiding_can_deactivate_the_rules_that_assign_the_category(
+ client: AsyncClient, auth_headers, test_categories: list[Category]
+):
+ cat_id = str(test_categories[0].id)
+ create = await client.post(
+ "/api/rules",
+ headers=auth_headers,
+ json={
+ "name": "Food rule",
+ "conditions_op": "or",
+ "conditions": [{"field": "description", "op": "contains", "value": "IFOOD"}],
+ "actions": [{"op": "set_category", "value": cat_id}],
+ "priority": 0,
+ },
+ )
+ assert create.status_code == 201
+ rule_id = create.json()["id"]
+
+ hide = await client.patch(
+ f"/api/categories/{cat_id}?deactivate_rules=true",
+ headers=auth_headers,
+ json={"is_hidden": True},
+ )
+ assert hide.status_code == 200
+
+ rules = await client.get("/api/rules", headers=auth_headers)
+ rule = next(item for item in rules.json() if item["id"] == rule_id)
+ assert rule["is_active"] is False
+
+ # Hiding without the flag leaves rules alone.
+ other_id = str(test_categories[1].id)
+ create_other = await client.post(
+ "/api/rules",
+ headers=auth_headers,
+ json={
+ "name": "Transport rule",
+ "conditions_op": "or",
+ "conditions": [{"field": "description", "op": "contains", "value": "UBER"}],
+ "actions": [{"op": "set_category", "value": other_id}],
+ "priority": 0,
+ },
+ )
+ assert create_other.status_code == 201
+ await client.patch(
+ f"/api/categories/{other_id}", headers=auth_headers, json={"is_hidden": True}
+ )
+ rules = await client.get("/api/rules", headers=auth_headers)
+ untouched = next(
+ item for item in rules.json() if item["id"] == create_other.json()["id"]
+ )
+ assert untouched["is_active"] is True
diff --git a/backend/tests/test_category_groups_api.py b/backend/tests/test_category_groups_api.py
index cd837ba3..3c7663d1 100644
--- a/backend/tests/test_category_groups_api.py
+++ b/backend/tests/test_category_groups_api.py
@@ -2,6 +2,9 @@ import uuid
import pytest
from httpx import AsyncClient
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.services.category_service import create_default_categories
@pytest.mark.asyncio
@@ -69,3 +72,110 @@ async def test_delete_group_not_found(client: AsyncClient, auth_headers):
f"/api/category-groups/{uuid.uuid4()}", headers=auth_headers,
)
assert response.status_code == 400
+
+
+async def test_hide_system_group_filters_default_list(
+ client: AsyncClient, auth_headers, session: AsyncSession, test_user
+):
+ await create_default_categories(session, test_user.id, "pt-BR")
+ groups_response = await client.get("/api/category-groups", headers=auth_headers)
+ group_id = groups_response.json()[0]["id"]
+
+ update_response = await client.patch(
+ f"/api/category-groups/{group_id}",
+ json={"is_hidden": True},
+ headers=auth_headers,
+ )
+ assert update_response.status_code == 200
+ assert update_response.json()["is_hidden"] is True
+
+ response = await client.get("/api/category-groups", headers=auth_headers)
+ assert response.status_code == 200
+ assert group_id not in {group["id"] for group in response.json()}
+
+ categories_response = await client.get("/api/categories", headers=auth_headers)
+ assert categories_response.status_code == 200
+ assert group_id not in {category["group_id"] for category in categories_response.json()}
+
+ include_hidden_response = await client.get(
+ "/api/category-groups?include_hidden=true",
+ headers=auth_headers,
+ )
+ assert include_hidden_response.status_code == 200
+ hidden_group = next(
+ group for group in include_hidden_response.json() if group["id"] == group_id
+ )
+ assert hidden_group["is_hidden"] is True
+
+
+async def test_cannot_hide_user_group(client: AsyncClient, auth_headers):
+ create_response = await client.post(
+ "/api/category-groups",
+ json={"name": "Custom"},
+ headers=auth_headers,
+ )
+ assert create_response.status_code == 201
+ group_id = create_response.json()["id"]
+
+ update_response = await client.patch(
+ f"/api/category-groups/{group_id}",
+ json={"is_hidden": True},
+ headers=auth_headers,
+ )
+
+ assert update_response.status_code == 400
+ assert update_response.json()["detail"] == "Only system category groups can be hidden"
+
+ unhide_response = await client.patch(
+ f"/api/category-groups/{group_id}",
+ json={"is_hidden": False},
+ headers=auth_headers,
+ )
+ assert unhide_response.status_code == 200
+ assert unhide_response.json()["is_hidden"] is False
+
+ list_response = await client.get(
+ "/api/category-groups?include_hidden=true",
+ headers=auth_headers,
+ )
+ group = next(item for item in list_response.json() if item["id"] == group_id)
+ assert group["is_hidden"] is False
+
+
+async def test_group_list_filters_hidden_child_categories(
+ client: AsyncClient, auth_headers, session: AsyncSession, test_user
+):
+ await create_default_categories(session, test_user.id, "pt-BR")
+ categories_response = await client.get("/api/categories", headers=auth_headers)
+ category_id = categories_response.json()[0]["id"]
+
+ hide_response = await client.patch(
+ f"/api/categories/{category_id}",
+ json={"is_hidden": True},
+ headers=auth_headers,
+ )
+ assert hide_response.status_code == 200
+
+ response = await client.get("/api/category-groups", headers=auth_headers)
+ assert response.status_code == 200
+ nested_ids = {
+ category["id"]
+ for group in response.json()
+ for category in group["categories"]
+ }
+ assert category_id not in nested_ids
+
+ include_hidden_response = await client.get(
+ "/api/category-groups?include_hidden=true",
+ headers=auth_headers,
+ )
+ assert include_hidden_response.status_code == 200
+ nested_hidden_ids = {
+ category["id"]
+ for group in include_hidden_response.json()
+ for category in group["categories"]
+ }
+ assert category_id in nested_hidden_ids
diff --git a/docs/categories/default-categories-hidden.png b/docs/categories/default-categories-hidden.png
new file mode 100644
index 00000000..9758658c
Binary files /dev/null and b/docs/categories/default-categories-hidden.png differ
diff --git a/docs/categories/default-categories-visible.png b/docs/categories/default-categories-visible.png
new file mode 100644
index 00000000..16d3aff3
Binary files /dev/null and b/docs/categories/default-categories-visible.png differ
diff --git a/frontend/src/components/category-select.tsx b/frontend/src/components/category-select.tsx
index 10278be5..72dc78c0 100644
--- a/frontend/src/components/category-select.tsx
+++ b/frontend/src/components/category-select.tsx
@@ -5,12 +5,17 @@ import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover
import { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem } from '@/components/ui/command'
import type { Category, CategoryGroup } from '@/types'
import { cn, normalizeText } from '@/lib/utils'
+import {
+ isCategoryHiddenFromSelection,
+ resolveSelectedCategory,
+} from '@/lib/category-selection-utils'
interface CategorySelectProps {
value: string
onChange: (value: string) => void
categories: Category[]
groups: CategoryGroup[]
+ currentCategory?: Category | null
placeholder?: string
disabled?: boolean
className?: string
@@ -24,6 +29,7 @@ export function CategorySelect({
onChange,
categories,
groups,
+ currentCategory,
placeholder,
disabled = false,
className,
@@ -50,8 +56,12 @@ export function CategorySelect({
}, [categories, groups, t])
const selectedCategory = useMemo(() => {
- return (categories ?? []).find((c) => c.id === value)
- }, [categories, value])
+ return resolveSelectedCategory(categories ?? [], value, currentCategory)
+ }, [categories, currentCategory, value])
+ const selectedCategoryIsHidden = isCategoryHiddenFromSelection(
+ categories ?? [],
+ selectedCategory
+ )
return (
<Popover open={open} onOpenChange={setOpen}>
@@ -74,6 +84,11 @@ export function CategorySelect({
/>
) : null}
<span className="truncate">{selectedCategory.name}</span>
+ {selectedCategoryIsHidden && (
+ <span className="shrink-0 rounded border border-border bg-muted px-1.5 py-0.5 text-[10px] font-medium text-muted-foreground">
+ {t('categories.hiddenBadge')}
+ </span>
+ )}
</>
) : value === '' && allowNone ? (
<span className="italic text-muted-foreground truncate">{t('transactions.noCategory')}</span>
diff --git a/frontend/src/components/rule-dialog.tsx b/frontend/src/components/rule-dialog.tsx
index adbac542..2643e09e 100644
--- a/frontend/src/components/rule-dialog.tsx
+++ b/frontend/src/components/rule-dialog.tsx
@@ -200,13 +200,14 @@ export interface RuleDialogInitialData {
}
export function RuleDialog({
- open, onClose, rule, categories, categoryGroups, accounts, payees, onSave, loading, initialData,
+ open, onClose, rule, categories, categoryGroups, currentCategories = [], accounts, payees, onSave, loading, initialData,
}: {
open: boolean
onClose: () => void
rule: Rule | null
categories: Category[]
categoryGroups: CategoryGroup[]
+ currentCategories?: Category[]
accounts: { id: string; name: string; display_name?: string | null }[]
payees: Payee[]
onSave: (data: Partial<Rule>) => void
@@ -461,6 +462,9 @@ export function RuleDialog({
onChange={(val) => updateAction(i, 'value', val)}
categories={categories}
groups={categoryGroups}
+ currentCategory={currentCategories.find(
+ (category) => category.id === action.value
+ )}
placeholder={t('rules.selectCategory')}
className={`${SELECT_CLASS} w-full`}
/>
diff --git a/frontend/src/components/transaction-dialog.tsx b/frontend/src/components/transaction-dialog.tsx
index 92071db4..648e61ff 100644
--- a/frontend/src/components/transaction-dialog.tsx
+++ b/frontend/src/components/transaction-dialog.tsx
@@ -5,10 +5,11 @@ import { useDateLocale, useDisplayLocale } from '@/hooks/use-display-locale'
import { formatCurrency } from '@/lib/format'
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query'
import { useAuth } from '@/contexts/auth-context'
-import { currencies as currenciesApi, transactions as transactionsApi, settings as settingsApi, payees as payeesApi, rules as rulesApi } from '@/lib/api'
+import { currencies as currenciesApi, transactions as transactionsApi, settings as settingsApi, payees as payeesApi, rules as rulesApi, categories as categoriesApi, categoryGroups as categoryGroupsApi } from '@/lib/api'
import { localDateString } from '@/lib/date-utils'
import { invalidateFinancialQueries } from '@/lib/invalidate-queries'
import { normalizeRuleMatchValue } from '@/lib/rule-match-utils'
+import { findCategoryReference, getRuleCategoryId } from '@/lib/category-reference-utils'
import { flattenConditions, hasConditionGroups } from '@/lib/rule-conditions'
import { cn, normalizeText } from '@/lib/utils'
import { Button } from '@/components/ui/button'
@@ -66,10 +67,6 @@ function isImageType(contentType: string): boolean {
return contentType.startsWith('image/')
}
-function getRuleCategoryId(rule: Rule): string | null {
- return rule.actions.find(action => action.op === 'set_category' && action.value)?.value ?? null
-}
-
function canExtendRuleFromTransaction(rule: Rule): boolean {
// Rules that mix AND and OR are left out: appending a top-level condition —
// and possibly flipping the rule to OR — would silently change what the
@@ -1041,6 +1038,7 @@ function TransactionForm({
onChange={setCategoryId}
categories={categories}
groups={categoryGroups}
+ currentCategory={seed?.category}
allowNone={true}
className="bg-card"
/>
@@ -1393,6 +1391,16 @@ function AddTransactionToRuleDialog({
const [openCombobox, setOpenCombobox] = useState(false)
const [matchOp, setMatchOp] = useState<'contains' | 'starts_with'>('contains')
const [matchText, setMatchText] = useState(transactionDescription)
+ const { data: allCategories } = useQuery({
+ queryKey: ['categories', 'management'],
+ queryFn: categoriesApi.listIncludingHidden,
+ })
+ const { data: allCategoryGroups } = useQuery({
+ queryKey: ['categoryGroups', 'management'],
+ queryFn: categoryGroupsApi.listIncludingHidden,
+ })
+ const displayCategories = allCategories ?? categories
+ const displayCategoryGroups = allCategoryGroups ?? categoryGroups
const effectiveRuleId = ruleId && rules.some(rule => rule.id === ruleId)
? ruleId
@@ -1407,11 +1415,11 @@ function AddTransactionToRuleDialog({
let categoryName = t('transactions.uncategorized')
if (categoryId !== 'uncategorized') {
- const category = categories.find(c => c.id === categoryId)
+ const category = findCategoryReference(displayCategories, categoryId)
if (category) {
categoryName = category.name
if (category.group_id) {
- const group = categoryGroups.find(g => g.id === category.group_id)
+ const group = displayCategoryGroups.find(g => g.id === category.group_id)
if (group) {
categoryName = `${group.name} > ${category.name}`
}
@@ -1434,7 +1442,7 @@ function AddTransactionToRuleDialog({
categoryId,
...data,
}))
- }, [rules, categories, categoryGroups, t])
+ }, [rules, displayCategories, displayCategoryGroups, t])
function handleSubmit(event: React.FormEvent) {
event.preventDefault()
diff --git a/frontend/src/components/transactions-filter-bar.tsx b/frontend/src/components/transactions-filter-bar.tsx
index 8e6b7891..cf21313d 100644
--- a/frontend/src/components/transactions-filter-bar.tsx
+++ b/frontend/src/components/transactions-filter-bar.tsx
@@ -80,6 +80,10 @@ interface TransactionsFilterBarProps {
onClearAll: () => void
accounts: Account[]
categories: Category[]
+ /** Catalog used only to label active filters, so a filter kept in the URL
+ * still names its category after that category is hidden. Selectable
+ * options always come from `categories`. */
+ referenceCategories?: Category[]
categoryGroups: CategoryGroup[]
payees: Payee[]
groups: Group[]
@@ -119,6 +123,7 @@ export function TransactionsFilterBar({
onClearAll,
accounts,
categories,
+ referenceCategories,
categoryGroups,
payees,
groups,
@@ -181,8 +186,9 @@ export function TransactionsFilterBar({
const categoryById = useMemo(() => {
const map = new Map<string, Category>()
categories.forEach((c) => map.set(c.id, c))
+ referenceCategories?.forEach((c) => map.set(c.id, c))
return map
- }, [categories])
+ }, [categories, referenceCategories])
const selectedPayee = useMemo(
() => payees.find((p) => p.id === filterPayee),
diff --git a/frontend/src/lib/api.ts b/frontend/src/lib/api.ts
index fb515663..931cb754 100644
--- a/frontend/src/lib/api.ts
+++ b/frontend/src/lib/api.ts
@@ -8,6 +8,7 @@ import type {
PasskeyOptionsResponse,
AppSetting,
Category,
+ CategoryRuleUsage,
CategoryGroup,
BankConnection,
ConnectionSettings,
@@ -273,12 +274,26 @@ export const categories = {
const { data } = await api.get('/categories')
return data
},
+ listIncludingHidden: async (): Promise<Category[]> => {
+ const { data } = await api.get('/categories', { params: { include_hidden: true } })
+ return data
+ },
create: async (category: Partial<Category>): Promise<Category> => {
const { data } = await api.post('/categories', category)
return data
},
- update: async (id: string, category: Partial<Category>): Promise<Category> => {
- const { data } = await api.patch(`/categories/${id}`, category)
+ update: async (
+ id: string,
+ category: Partial<Category>,
+ options?: { deactivateRules?: boolean },
+ ): Promise<Category> => {
+ const { data } = await api.patch(`/categories/${id}`, category, {
+ params: options?.deactivateRules ? { deactivate_rules: true } : undefined,
+ })
+ return data
+ },
+ ruleUsage: async (id: string): Promise<CategoryRuleUsage> => {
+ const { data } = await api.get(`/categories/${id}/rule-usage`)
return data
},
delete: async (id: string): Promise<void> => {
@@ -292,6 +307,10 @@ export const categoryGroups = {
const { data } = await api.get('/category-groups')
return data
},
+ listIncludingHidden: async (): Promise<CategoryGroup[]> => {
+ const { data } = await api.get('/category-groups', { params: { include_hidden: true } })
+ return data
+ },
create: async (group: Partial<CategoryGroup>): Promise<CategoryGroup> => {
const { data } = await api.post('/category-groups', group)
return data
diff --git a/frontend/src/lib/category-reference-utils.test.ts b/frontend/src/lib/category-reference-utils.test.ts
new file mode 100644
index 00000000..affeae6d
--- /dev/null
+++ b/frontend/src/lib/category-reference-utils.test.ts
@@ -0,0 +1,29 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+ findCategoryReference,
+ getRuleCategoryId,
+ getRuleCategoryName,
+} from './category-reference-utils'
+
+const hiddenCategory = {
+ id: 'hidden-category',
+ name: 'Historic category',
+ is_hidden: true,
+}
+
+const rule = {
+ actions: [{ op: 'set_category', value: hiddenCategory.id }],
+}
+
+describe('category reference resolution', () => {
+ it('resolves hidden categories when the full display catalog supplies them', () => {
+ expect(findCategoryReference([hiddenCategory], hiddenCategory.id)).toBe(hiddenCategory)
+ expect(getRuleCategoryId(rule)).toBe(hiddenCategory.id)
+ expect(getRuleCategoryName(rule, [hiddenCategory])).toBe(hiddenCategory.name)
+ })
+
+ it('does not invent a label for a missing category reference', () => {
+ expect(getRuleCategoryName(rule, [])).toBeNull()
+ })
+})
diff --git a/frontend/src/lib/category-reference-utils.ts b/frontend/src/lib/category-reference-utils.ts
new file mode 100644
index 00000000..a315fde8
--- /dev/null
+++ b/frontend/src/lib/category-reference-utils.ts
@@ -0,0 +1,28 @@
+type CategoryReference = {
+ id: string
+ name: string
+}
+
+type RuleReference = {
+ actions: Array<{ op: string; value: string }>
+}
+
+export function findCategoryReference<T extends CategoryReference>(
+ categories: readonly T[],
+ categoryId: string,
+): T | undefined {
+ return categories.find((category) => category.id === categoryId)
+}
+
+export function getRuleCategoryId(rule: RuleReference): string | null {
+ return rule.actions.find((action) => action.op === 'set_category' && action.value)?.value ?? null
+}
+
+export function getRuleCategoryName<T extends CategoryReference>(
+ rule: RuleReference,
+ categories: readonly T[],
+): string | null {
+ const categoryId = getRuleCategoryId(rule)
+ if (!categoryId) return null
+ return findCategoryReference(categories, categoryId)?.name ?? null
+}
diff --git a/frontend/src/lib/category-selection-utils.test.ts b/frontend/src/lib/category-selection-utils.test.ts
new file mode 100644
index 00000000..bcf6ee29
--- /dev/null
+++ b/frontend/src/lib/category-selection-utils.test.ts
@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+import type { Category } from '../types'
+import {
+ isCategoryHiddenFromSelection,
+ resolveSelectedCategory,
+} from './category-selection-utils'
+
+const category = (overrides: Partial<Category>): Category => ({
+ id: 'category-id',
+ user_id: 'user-id',
+ group_id: null,
+ name: 'Category',
+ icon: 'circle-help',
+ color: '#6B7280',
+ is_system: true,
+ is_hidden: false,
+ treat_as_transfer: false,
+ is_ignored: false,
+ ...overrides,
+})
+
+describe('resolveSelectedCategory', () => {
+ it('uses the selectable category when the current value is visible', () => {
+ const visible = category({ id: 'visible', name: 'Visible' })
+ const staleCurrent = category({ id: 'visible', name: 'Stale', is_hidden: true })
+
+ expect(resolveSelectedCategory([visible], 'visible', staleCurrent)).toBe(visible)
+ })
+
+ it('falls back to a hidden current category missing from selectable options', () => {
+ const hidden = category({ id: 'hidden', name: 'Historical', is_hidden: true })
+
+ expect(resolveSelectedCategory([], 'hidden', hidden)).toBe(hidden)
+ })
+
+ it('does not display an unrelated fallback category', () => {
+ const hidden = category({ id: 'other', is_hidden: true })
+
+ expect(resolveSelectedCategory([], 'selected', hidden)).toBeUndefined()
+ })
+})
+
+describe('isCategoryHiddenFromSelection', () => {
+ it('marks an explicitly hidden category as hidden', () => {
+ const hidden = category({ id: 'hidden', is_hidden: true })
+
+ expect(isCategoryHiddenFromSelection([hidden], hidden)).toBe(true)
+ })
+
+ it('marks a category filtered out with its hidden group as hidden', () => {
+ const grouped = category({ id: 'grouped', group_id: 'hidden-group' })
+
+ expect(isCategoryHiddenFromSelection([], grouped)).toBe(true)
+ })
+
+ it('keeps a selectable category visible', () => {
+ const visible = category({ id: 'visible' })
+
+ expect(isCategoryHiddenFromSelection([visible], visible)).toBe(false)
+ })
+})
diff --git a/frontend/src/lib/category-selection-utils.ts b/frontend/src/lib/category-selection-utils.ts
new file mode 100644
index 00000000..9229a443
--- /dev/null
+++ b/frontend/src/lib/category-selection-utils.ts
@@ -0,0 +1,20 @@
+import type { Category } from '../types'
+
+export function resolveSelectedCategory(
+ categories: Category[],
+ value: string,
+ currentCategory?: Category | null
+): Category | undefined {
+ return categories.find((category) => category.id === value)
+ ?? (currentCategory?.id === value ? currentCategory : undefined)
+}
+
+export function isCategoryHiddenFromSelection(
+ categories: Category[],
+ category?: Category
+): boolean {
+ return Boolean(
+ category
+ && (category.is_hidden || !categories.some((item) => item.id === category.id))
+ )
+}
diff --git a/frontend/src/lib/invalidate-queries.test.ts b/frontend/src/lib/invalidate-queries.test.ts
new file mode 100644
index 00000000..a7bcc30b
--- /dev/null
+++ b/frontend/src/lib/invalidate-queries.test.ts
@@ -0,0 +1,26 @@
+import { QueryClient } from '@tanstack/react-query'
+import { describe, expect, it } from 'vitest'
+
+import { invalidateCategoryQueries } from './invalidate-queries'
+
+describe('invalidateCategoryQueries', () => {
+ it('invalidates category displays and both category-group key conventions', () => {
+ const queryClient = new QueryClient()
+ const keys = [
+ ['categories'],
+ ['categories', 'management'],
+ ['categoryGroups'],
+ ['categoryGroups', 'management'],
+ ['category-groups'],
+ ['category-groups', 'management'],
+ ] as const
+
+ for (const queryKey of keys) queryClient.setQueryData(queryKey, [])
+
+ invalidateCategoryQueries(queryClient)
+
+ for (const queryKey of keys) {
+ expect(queryClient.getQueryState(queryKey)?.isInvalidated).toBe(true)
+ }
+ })
+})
diff --git a/frontend/src/lib/invalidate-queries.ts b/frontend/src/lib/invalidate-queries.ts
index bd31e121..f9e92e52 100644
--- a/frontend/src/lib/invalidate-queries.ts
+++ b/frontend/src/lib/invalidate-queries.ts
@@ -8,6 +8,14 @@ import type { QueryClient } from '@tanstack/react-query'
// balances. Pages that also need to refresh entity-specific lists
// (recurring, payees, connections, etc.) should invalidate those keys
// on top of this call.
+export function invalidateCategoryQueries(queryClient: QueryClient) {
+ queryClient.invalidateQueries({ queryKey: ['categories'] })
+ // Both key families are currently used across the frontend. Invalidate both
+ // until callers have been migrated to a single convention.
+ queryClient.invalidateQueries({ queryKey: ['categoryGroups'] })
+ queryClient.invalidateQueries({ queryKey: ['category-groups'] })
+}
+
export function invalidateFinancialQueries(queryClient: QueryClient) {
queryClient.invalidateQueries({ queryKey: ['transactions'] })
queryClient.invalidateQueries({ queryKey: ['dashboard'] })
diff --git a/frontend/src/locales/de.json b/frontend/src/locales/de.json
index ac68b630..03f7e025 100644
--- a/frontend/src/locales/de.json
+++ b/frontend/src/locales/de.json
@@ -957,7 +957,15 @@
"treatAsTransferBadge": "Umbuchung",
"ignoreTransfer": "Diese Umbuchung ignorieren",
"ignoreTransferDesc": "Ignorierte Transaktionen werden nicht in Einnahmen- oder Ausgabenberichten aufgeführt.",
- "ignoreTransferBadge": "Ignorieren"
+ "ignoreTransferBadge": "Ignorieren",
+ "hiddenScopeDescription": "Ausgeblendete Standardkategorien werden aus den Kategorieauswahlen entfernt und nicht mehr von Regeln zugewiesen. Bestehende Transaktionen, Budgets, Dashboards und Berichte verwenden sie weiterhin.",
+ "hiddenBadge": "Ausgeblendet",
+ "showDefault": "Standardkategorie anzeigen",
+ "hideDefault": "Standardkategorie ausblenden",
+ "hideWithRulesTitle": "{{name}} ausblenden?",
+ "hideWithRulesDescription": "{{count}} aktive Regeln weisen diese Kategorie zu. Das Ausblenden verhindert bereits, dass sie neue Transaktionen kategorisieren. Sie zu deaktivieren stoppt die ganze Regel, einschließlich Zahlungsempfänger oder Notizen, die sie ebenfalls setzt.",
+ "hideKeepRules": "Nur ausblenden",
+ "hideAndTurnOffRules": "Ausblenden und Regeln deaktivieren"
},
"groups": {
"title": "Kategoriegruppen",
@@ -974,7 +982,10 @@
"confirmDeleteTitle": "Kategoriegruppe löschen?",
"noGroup": "Keine Gruppe",
"systemGroup": "Systemgruppe",
- "confirmDeleteDescription": "Die Kategoriegruppe \"{{name}}\" wird gelöscht. Ihre Kategorien bleiben erhalten und werden keiner Gruppe mehr zugeordnet. Diese Aktion kann nicht rückgängig gemacht werden."
+ "confirmDeleteDescription": "Die Kategoriegruppe \"{{name}}\" wird gelöscht. Ihre Kategorien bleiben erhalten und werden keiner Gruppe mehr zugeordnet. Diese Aktion kann nicht rückgängig gemacht werden.",
+ "hiddenBadge": "Ausgeblendet",
+ "showDefault": "Standardgruppe anzeigen",
+ "hideDefault": "Standardgruppe ausblenden"
},
"import": {
"acceptedFormats": "Unterstützte Formate: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/en.json b/frontend/src/locales/en.json
index 9383e677..f6cf83bc 100644
--- a/frontend/src/locales/en.json
+++ b/frontend/src/locales/en.json
@@ -957,7 +957,15 @@
"treatAsTransferBadge": "Transfer",
"ignoreTransfer": "Ignore this transfer",
"ignoreTransferDesc": "Ignored transactions won't show on income or expense reports.",
- "ignoreTransferBadge": "Ignore"
+ "ignoreTransferBadge": "Ignore",
+ "hiddenScopeDescription": "Hidden defaults are removed from category pickers and are no longer assigned by rules. Existing transactions, budgets, dashboards, and reports continue to use them.",
+ "hiddenBadge": "Hidden",
+ "showDefault": "Show default category",
+ "hideDefault": "Hide default category",
+ "hideWithRulesTitle": "Hide {{name}}?",
+ "hideWithRulesDescription": "{{count}} active rules assign this category. Hiding it already stops them from categorizing new transactions. Turning them off stops the whole rule, including any payee or notes it also sets.",
+ "hideKeepRules": "Hide only",
+ "hideAndTurnOffRules": "Hide and turn off the rules"
},
"groups": {
"title": "Category Groups",
@@ -974,7 +982,10 @@
"confirmDeleteTitle": "Delete category group?",
"noGroup": "No group",
"systemGroup": "System group",
- "confirmDeleteDescription": "The category group \"{{name}}\" will be deleted. Its categories will remain and become ungrouped. This action cannot be undone."
+ "confirmDeleteDescription": "The category group \"{{name}}\" will be deleted. Its categories will remain and become ungrouped. This action cannot be undone.",
+ "hiddenBadge": "Hidden",
+ "showDefault": "Show default group",
+ "hideDefault": "Hide default group"
},
"import": {
"acceptedFormats": "Accepted formats: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/es.json b/frontend/src/locales/es.json
index a7f5ffac..0e0a78e9 100644
--- a/frontend/src/locales/es.json
+++ b/frontend/src/locales/es.json
@@ -957,7 +957,15 @@
"treatAsTransferBadge": "Transferencia",
"ignoreTransfer": "Ignorar esta transferencia",
"ignoreTransferDesc": "Las transacciones ignoradas no aparecerán en los informes de ingresos o gastos.",
- "ignoreTransferBadge": "Ignorar"
+ "ignoreTransferBadge": "Ignorar",
+ "hiddenScopeDescription": "Las categorías predeterminadas ocultas se eliminan de los selectores y las reglas dejan de asignarlas. Las transacciones, los presupuestos, los paneles y los informes existentes siguen utilizándolas.",
+ "hiddenBadge": "Oculta",
+ "showDefault": "Mostrar categoría predeterminada",
+ "hideDefault": "Ocultar categoría predeterminada",
+ "hideWithRulesTitle": "¿Ocultar {{name}}?",
+ "hideWithRulesDescription": "{{count}} reglas activas asignan esta categoría. Ocultarla ya impide que categoricen nuevas transacciones. Desactivarlas detiene la regla completa, incluidos el beneficiario o las notas que también establece.",
+ "hideKeepRules": "Solo ocultar",
+ "hideAndTurnOffRules": "Ocultar y desactivar las reglas"
},
"groups": {
"title": "Grupos de categorías",
@@ -974,7 +982,10 @@
"confirmDeleteTitle": "¿Eliminar grupo de categorías?",
"noGroup": "Sin grupo",
"systemGroup": "Grupo del sistema",
- "confirmDeleteDescription": "El grupo de categorías \"{{name}}\" se eliminará. Sus categorías permanecerán y quedarán sin grupo. Esta acción no se puede deshacer."
+ "confirmDeleteDescription": "El grupo de categorías \"{{name}}\" se eliminará. Sus categorías permanecerán y quedarán sin grupo. Esta acción no se puede deshacer.",
+ "hiddenBadge": "Oculto",
+ "showDefault": "Mostrar grupo predeterminado",
+ "hideDefault": "Ocultar grupo predeterminado"
},
"import": {
"acceptedFormats": "Formatos aceptados: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/fr.json b/frontend/src/locales/fr.json
index 7a480750..be9f8b0d 100644
--- a/frontend/src/locales/fr.json
+++ b/frontend/src/locales/fr.json
@@ -957,7 +957,15 @@
"treatAsTransferBadge": "Virement",
"ignoreTransfer": "Ignorer ce virement",
"ignoreTransferDesc": "Les transactions ignorées n'apparaîtront pas dans les rapports de revenus ou de dépenses.",
- "ignoreTransferBadge": "Ignorer"
+ "ignoreTransferBadge": "Ignorer",
+ "hiddenScopeDescription": "Les catégories par défaut masquées sont retirées des sélecteurs et ne sont plus attribuées par les règles. Les transactions, budgets, tableaux de bord et rapports existants continuent de les utiliser.",
+ "hiddenBadge": "Masquée",
+ "showDefault": "Afficher la catégorie par défaut",
+ "hideDefault": "Masquer la catégorie par défaut",
+ "hideWithRulesTitle": "Masquer {{name}} ?",
+ "hideWithRulesDescription": "{{count}} règles actives attribuent cette catégorie. La masquer les empêche déjà de catégoriser de nouvelles transactions. Les désactiver arrête la règle entière, y compris le bénéficiaire ou les notes qu’elle définit aussi.",
+ "hideKeepRules": "Masquer seulement",
+ "hideAndTurnOffRules": "Masquer et désactiver les règles"
},
"groups": {
"title": "Groupes de catégories",
@@ -974,7 +982,10 @@
"confirmDeleteTitle": "Supprimer le groupe de catégories ?",
"noGroup": "Aucun groupe",
"systemGroup": "Groupe système",
- "confirmDeleteDescription": "Le groupe de catégories « {{name}} » sera supprimé. Ses catégories resteront et ne seront plus regroupées. Cette action est irréversible."
+ "confirmDeleteDescription": "Le groupe de catégories « {{name}} » sera supprimé. Ses catégories resteront et ne seront plus regroupées. Cette action est irréversible.",
+ "hiddenBadge": "Masqué",
+ "showDefault": "Afficher le groupe par défaut",
+ "hideDefault": "Masquer le groupe par défaut"
},
"import": {
"acceptedFormats": "Formats acceptés : OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/it.json b/frontend/src/locales/it.json
index f7946ebf..ca2ffc7d 100644
--- a/frontend/src/locales/it.json
+++ b/frontend/src/locales/it.json
@@ -957,7 +957,15 @@
"treatAsTransferBadge": "Trasferimento",
"ignoreTransfer": "Ignora questo trasferimento",
"ignoreTransferDesc": "Le transazioni ignorate non appariranno nei report di entrate o spese.",
- "ignoreTransferBadge": "Ignora"
+ "ignoreTransferBadge": "Ignora",
+ "hiddenScopeDescription": "Le categorie predefinite nascoste vengono rimosse dai selettori e non vengono più assegnate dalle regole. Le transazioni, i budget, le dashboard e i report esistenti continuano a utilizzarle.",
+ "hiddenBadge": "Nascosta",
+ "showDefault": "Mostra categoria predefinita",
+ "hideDefault": "Nascondi categoria predefinita",
+ "hideWithRulesTitle": "Nascondere {{name}}?",
+ "hideWithRulesDescription": "{{count}} regole attive assegnano questa categoria. Nasconderla impedisce già di categorizzare nuove transazioni. Disattivarle ferma l’intera regola, incluso il beneficiario o le note che imposta.",
+ "hideKeepRules": "Nascondi soltanto",
+ "hideAndTurnOffRules": "Nascondi e disattiva le regole"
},
"groups": {
"title": "Gruppi di categorie",
@@ -974,7 +982,10 @@
"confirmDeleteTitle": "Eliminare il gruppo di categorie?",
"noGroup": "Nessun gruppo",
"systemGroup": "Gruppo di sistema",
- "confirmDeleteDescription": "Il gruppo di categorie \"{{name}}\" verrà eliminato. Le sue categorie rimarranno e non saranno più raggruppate. Questa azione non può essere annullata."
+ "confirmDeleteDescription": "Il gruppo di categorie \"{{name}}\" verrà eliminato. Le sue categorie rimarranno e non saranno più raggruppate. Questa azione non può essere annullata.",
+ "hiddenBadge": "Nascosto",
+ "showDefault": "Mostra gruppo predefinito",
+ "hideDefault": "Nascondi gruppo predefinito"
},
"import": {
"acceptedFormats": "Formati accettati: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/pl.json b/frontend/src/locales/pl.json
index 5aadae6f..b27ce366 100644
--- a/frontend/src/locales/pl.json
+++ b/frontend/src/locales/pl.json
@@ -1017,7 +1017,15 @@
"treatAsTransferBadge": "Transfer",
"ignoreTransfer": "Ignoruj ten transfer",
"ignoreTransferDesc": "Ignorowane transakcje nie pojawią się w raportach przychodów ani wydatków.",
- "ignoreTransferBadge": "Ignoruj"
+ "ignoreTransferBadge": "Ignoruj",
+ "hiddenScopeDescription": "Ukryte kategorie domyślne są usuwane z list wyboru i nie są już przypisywane przez reguły. Istniejące transakcje, budżety, pulpity i raporty nadal z nich korzystają.",
+ "hiddenBadge": "Ukryta",
+ "showDefault": "Pokaż domyślną kategorię",
+ "hideDefault": "Ukryj domyślną kategorię",
+ "hideWithRulesTitle": "Ukryć {{name}}?",
+ "hideWithRulesDescription": "Tę kategorię przypisuje {{count}} aktywnych reguł. Ukrycie jej już powstrzymuje je przed kategoryzowaniem nowych transakcji. Wyłączenie zatrzymuje całą regułę, w tym odbiorcę i notatki, które również ustawia.",
+ "hideKeepRules": "Tylko ukryj",
+ "hideAndTurnOffRules": "Ukryj i wyłącz reguły"
},
"groups": {
"title": "Grupy kategorii",
@@ -1034,7 +1042,10 @@
"confirmDeleteTitle": "Usunąć grupę kategorii?",
"noGroup": "Brak grupy",
"systemGroup": "Grupa systemowa",
- "confirmDeleteDescription": "Grupa kategorii „{{name}}” zostanie usunięta. Jej kategorie pozostaną i staną się niezgrupowane. Tej operacji nie można cofnąć."
+ "confirmDeleteDescription": "Grupa kategorii „{{name}}” zostanie usunięta. Jej kategorie pozostaną i staną się niezgrupowane. Tej operacji nie można cofnąć.",
+ "hiddenBadge": "Ukryta",
+ "showDefault": "Pokaż domyślną grupę",
+ "hideDefault": "Ukryj domyślną grupę"
},
"import": {
"acceptedFormats": "Akceptowane formaty: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/pt-BR.json b/frontend/src/locales/pt-BR.json
index ff1ad398..187645be 100644
--- a/frontend/src/locales/pt-BR.json
+++ b/frontend/src/locales/pt-BR.json
@@ -957,7 +957,15 @@
"treatAsTransferBadge": "Transferência",
"ignoreTransfer": "Ignorar Transações",
"ignoreTransferDesc": "Transações ignoradas não contarão como receita ou despesa nos relatórios.",
- "ignoreTransferBadge": "Ignorado"
+ "ignoreTransferBadge": "Ignorado",
+ "hiddenScopeDescription": "Categorias padrão ocultas deixam de aparecer nos seletores e não são mais atribuídas por regras. Transações existentes, orçamentos, painéis e relatórios continuam usando essas categorias.",
+ "hiddenBadge": "Oculta",
+ "showDefault": "Mostrar categoria padrão",
+ "hideDefault": "Ocultar categoria padrão",
+ "hideWithRulesTitle": "Ocultar {{name}}?",
+ "hideWithRulesDescription": "{{count}} regras ativas atribuem esta categoria. Ocultá-la já impede que elas categorizem novas transações. Desligá-las para a regra inteira, incluindo a pessoa ou as notas que ela também define.",
+ "hideKeepRules": "Apenas ocultar",
+ "hideAndTurnOffRules": "Ocultar e desligar as regras"
},
"groups": {
"title": "Grupos de Categorias",
@@ -974,7 +982,10 @@
"confirmDeleteTitle": "Excluir grupo de categorias?",
"noGroup": "Sem grupo",
"systemGroup": "Grupo do sistema",
- "confirmDeleteDescription": "O grupo de categorias \"{{name}}\" será excluído. Suas categorias permanecerão e ficarão sem grupo. Esta ação não pode ser desfeita."
+ "confirmDeleteDescription": "O grupo de categorias \"{{name}}\" será excluído. Suas categorias permanecerão e ficarão sem grupo. Esta ação não pode ser desfeita.",
+ "hiddenBadge": "Oculto",
+ "showDefault": "Mostrar grupo padrão",
+ "hideDefault": "Ocultar grupo padrão"
},
"import": {
"acceptedFormats": "Formatos aceitos: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/pt-PT.json b/frontend/src/locales/pt-PT.json
index 9ef4964c..72a64526 100644
--- a/frontend/src/locales/pt-PT.json
+++ b/frontend/src/locales/pt-PT.json
@@ -957,7 +957,15 @@
"treatAsTransferBadge": "Transferência",
"ignoreTransfer": "Ignorar Transações",
"ignoreTransferDesc": "Transações ignoradas não contarão como receita ou despesa nos relatórios.",
- "ignoreTransferBadge": "Ignorado"
+ "ignoreTransferBadge": "Ignorado",
+ "hiddenScopeDescription": "As categorias predefinidas ocultas deixam de aparecer nos seletores e deixam de ser atribuídas por regras. As transações, os orçamentos, os painéis e os relatórios existentes continuam a utilizá-las.",
+ "hiddenBadge": "Oculta",
+ "showDefault": "Mostrar categoria predefinida",
+ "hideDefault": "Ocultar categoria predefinida",
+ "hideWithRulesTitle": "Ocultar {{name}}?",
+ "hideWithRulesDescription": "{{count}} regras ativas atribuem esta categoria. Ocultá-la já impede que categorizem novas transações. Desligá-las para a regra inteira, incluindo a pessoa ou as notas que também define.",
+ "hideKeepRules": "Apenas ocultar",
+ "hideAndTurnOffRules": "Ocultar e desligar as regras"
},
"groups": {
"title": "Grupos de Categorias",
@@ -974,7 +982,10 @@
"confirmDeleteTitle": "Eliminar grupo de categorias?",
"noGroup": "Sem grupo",
"systemGroup": "Grupo do sistema",
- "confirmDeleteDescription": "O grupo de categorias \"{{name}}\" será eliminado. As suas categorias manter-se-ão e ficarão sem grupo. Esta ação não pode ser desfeita."
+ "confirmDeleteDescription": "O grupo de categorias \"{{name}}\" será eliminado. As suas categorias manter-se-ão e ficarão sem grupo. Esta ação não pode ser desfeita.",
+ "hiddenBadge": "Oculto",
+ "showDefault": "Mostrar grupo predefinido",
+ "hideDefault": "Ocultar grupo predefinido"
},
"import": {
"acceptedFormats": "Formatos aceitos: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/ru.json b/frontend/src/locales/ru.json
index c04ff923..e0758faa 100644
--- a/frontend/src/locales/ru.json
+++ b/frontend/src/locales/ru.json
@@ -963,7 +963,15 @@
"treatAsTransferBadge": "Перевод",
"ignoreTransfer": "Игнорировать этот перевод",
"ignoreTransferDesc": "Игнорируемые транзакции не будут отображаться в отчётах о доходах и расходах.",
- "ignoreTransferBadge": "Игнорировать"
+ "ignoreTransferBadge": "Игнорировать",
+ "hiddenScopeDescription": "Скрытые категории по умолчанию удаляются из списков выбора и больше не назначаются правилами. Существующие транзакции, бюджеты, панели и отчёты продолжают их использовать.",
+ "hiddenBadge": "Скрыта",
+ "showDefault": "Показать категорию по умолчанию",
+ "hideDefault": "Скрыть категорию по умолчанию",
+ "hideWithRulesTitle": "Скрыть «{{name}}»?",
+ "hideWithRulesDescription": "Эту категорию назначают {{count}} активных правил. Скрытие уже не даёт им категоризировать новые транзакции. Отключение останавливает правило целиком, включая получателя и заметки, которые оно тоже задаёт.",
+ "hideKeepRules": "Только скрыть",
+ "hideAndTurnOffRules": "Скрыть и отключить правила"
},
"groups": {
"title": "Группы категорий",
@@ -980,7 +988,10 @@
"confirmDeleteTitle": "Удалить группу категорий?",
"noGroup": "Без группы",
"systemGroup": "Системная группа",
- "confirmDeleteDescription": "Группа категорий «{{name}}» будет удалена. Её категории останутся и станут несгруппированными. Это действие нельзя отменить."
+ "confirmDeleteDescription": "Группа категорий «{{name}}» будет удалена. Её категории останутся и станут несгруппированными. Это действие нельзя отменить.",
+ "hiddenBadge": "Скрыта",
+ "showDefault": "Показать группу по умолчанию",
+ "hideDefault": "Скрыть группу по умолчанию"
},
"import": {
"acceptedFormats": "Поддерживаемые форматы: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/locales/uk.json b/frontend/src/locales/uk.json
index e640f6f6..4c4722a7 100644
--- a/frontend/src/locales/uk.json
+++ b/frontend/src/locales/uk.json
@@ -963,7 +963,15 @@
"treatAsTransferBadge": "Переказ",
"ignoreTransfer": "Ігнорувати цей переказ",
"ignoreTransferDesc": "Ігноровані транзакції не відображатимуться у звітах про доходи та витрати.",
- "ignoreTransferBadge": "Ігнорувати"
+ "ignoreTransferBadge": "Ігнорувати",
+ "hiddenScopeDescription": "Приховані типові категорії вилучаються зі списків вибору та більше не призначаються правилами. Наявні транзакції, бюджети, панелі та звіти й надалі їх використовують.",
+ "hiddenBadge": "Прихована",
+ "showDefault": "Показати типову категорію",
+ "hideDefault": "Приховати типову категорію",
+ "hideWithRulesTitle": "Приховати «{{name}}»?",
+ "hideWithRulesDescription": "Цю категорію призначають {{count}} активних правил. Приховування вже не дає їм категоризувати нові транзакції. Вимкнення зупиняє правило повністю, разом з одержувачем і нотатками, які воно теж встановлює.",
+ "hideKeepRules": "Лише приховати",
+ "hideAndTurnOffRules": "Приховати та вимкнути правила"
},
"groups": {
"title": "Групи категорій",
@@ -980,7 +988,10 @@
"confirmDeleteTitle": "Видалити групу категорій?",
"noGroup": "Без групи",
"systemGroup": "Системна група",
- "confirmDeleteDescription": "Групу категорій «{{name}}» буде видалено. Її категорії залишаться й стануть незгрупованими. Цю дію не можна скасувати."
+ "confirmDeleteDescription": "Групу категорій «{{name}}» буде видалено. Її категорії залишаться й стануть незгрупованими. Цю дію не можна скасувати.",
+ "hiddenBadge": "Прихована",
+ "showDefault": "Показати типову групу",
+ "hideDefault": "Приховати типову групу"
},
"import": {
"acceptedFormats": "Підтримувані формати: OFX, CSV, QIF, CAMT",
diff --git a/frontend/src/pages/account-detail.tsx b/frontend/src/pages/account-detail.tsx
index 8bdab1c3..ae7aaf0b 100644
--- a/frontend/src/pages/account-detail.tsx
+++ b/frontend/src/pages/account-detail.tsx
@@ -653,6 +653,7 @@ export default function AccountDetailPage() {
icon: p.category_icon ?? '',
color: p.category_color ?? '',
is_system: false,
+ is_hidden: false,
treat_as_transfer: false,
is_ignored: false,
}
diff --git a/frontend/src/pages/budgets.tsx b/frontend/src/pages/budgets.tsx
index 6d9715eb..cdb6fe80 100644
--- a/frontend/src/pages/budgets.tsx
+++ b/frontend/src/pages/budgets.tsx
@@ -28,6 +28,7 @@ import { usePrivacyMode } from '@/hooks/use-privacy-mode'
import { useAuth } from '@/contexts/auth-context'
import { useWorkspace } from '@/contexts/workspace-context'
import { resolveDateFnsLocale } from '@/lib/date-fns-locale'
+import { findCategoryReference } from '@/lib/category-reference-utils'
import { formatCurrency } from '@/lib/format'
function currentMonth() {
@@ -79,6 +80,13 @@ export default function BudgetsPage() {
queryFn: categoriesApi.list,
})
+ // Budgets can point at a hidden default category. The picker below only
+ // offers visible ones, but existing rows still have to name what they budget.
+ const { data: allCategoriesList } = useQuery({
+ queryKey: ['categories', 'management'],
+ queryFn: categoriesApi.listIncludingHidden,
+ })
+
const { data: groupsList } = useQuery({
queryKey: ['category-groups'],
queryFn: groupsApi.list,
@@ -119,13 +127,15 @@ export default function BudgetsPage() {
},
})
+ const displayCategories = allCategoriesList ?? categoriesList ?? []
+
const getCategoryDisplay = (categoryId: string) => {
- const cat = categoriesList?.find((c) => c.id === categoryId)
- if (!cat) return <span>{categoryId}</span>
+ const category = findCategoryReference(displayCategories, categoryId)
+ if (!category) return <span>{categoryId}</span>
return (
<span className="flex items-center gap-2">
- <CategoryIcon icon={cat.icon} color={cat.color} size="sm" />
- <span>{cat.name}</span>
+ <CategoryIcon icon={category.icon} color={category.color} size="sm" />
+ <span>{category.name}</span>
</span>
)
}
@@ -333,7 +343,8 @@ export default function BudgetsPage() {
? 'budgets.confirmDeleteRecurringDescription'
: 'budgets.confirmDeleteDescription',
{
- name: categoriesList?.find((category) => category.id === deletingBudget?.category_id)?.name ?? t('budgets.category'),
+ name: findCategoryReference(displayCategories, deletingBudget?.category_id ?? '')?.name
+ ?? t('budgets.category'),
},
)}
isPending={deleteMutation.isPending}
diff --git a/frontend/src/pages/categories.tsx b/frontend/src/pages/categories.tsx
index 507a3d6d..b24b3f05 100644
--- a/frontend/src/pages/categories.tsx
+++ b/frontend/src/pages/categories.tsx
@@ -17,8 +17,9 @@ import {
DialogFooter,
} from '@/components/ui/dialog'
import type { Category, CategoryGroup } from '@/types'
-import { Pencil, Trash2, Plus, ChevronDown, ChevronRight, ChevronsUpDown } from 'lucide-react'
+import { Pencil, Trash2, Plus, ChevronDown, ChevronRight, ChevronsUpDown, Eye, EyeOff } from 'lucide-react'
import { PageHeader } from '@/components/page-header'
+import { invalidateCategoryQueries } from '@/lib/invalidate-queries'
import { CategoryIcon } from '@/components/category-icon'
import { IconPicker } from '@/components/icon-picker'
import { useWorkspace } from '@/contexts/workspace-context'
@@ -59,20 +60,22 @@ export default function CategoriesPage() {
const [collapsedGroups, setCollapsedGroups] = useState<Set<string>>(new Set())
const [deletingCategory, setDeletingCategory] = useState<Category | null>(null)
const [deletingGroup, setDeletingGroup] = useState<CategoryGroup | null>(null)
+ const [hidingCategory, setHidingCategory] = useState<
+ { category: Category; rules: { id: string; name: string }[] } | null
+ >(null)
const { data: groups } = useQuery({
- queryKey: ['category-groups'],
- queryFn: groupsApi.list,
+ queryKey: ['category-groups', 'management'],
+ queryFn: groupsApi.listIncludingHidden,
})
const { data: categoriesList } = useQuery({
- queryKey: ['categories'],
- queryFn: categoriesApi.list,
+ queryKey: ['categories', 'management'],
+ queryFn: categoriesApi.listIncludingHidden,
})
const invalidateAll = () => {
- queryClient.invalidateQueries({ queryKey: ['categories'] })
- queryClient.invalidateQueries({ queryKey: ['category-groups'] })
+ invalidateCategoryQueries(queryClient)
}
const createCatMutation = useMutation({
@@ -83,6 +86,43 @@ export default function CategoriesPage() {
mutationFn: ({ id, ...data }: Partial<Category> & { id: string }) => categoriesApi.update(id, data),
onSuccess: () => { invalidateAll(); setCatDialogOpen(false); setEditingCat(null); toast.success(t('categories.updated')) },
})
+
+ // Hiding is its own mutation: it can also retire the rules that assign the
+ // category, and it must refresh the rule list rather than the category form.
+ const hideCatMutation = useMutation({
+ mutationFn: ({ id, deactivateRules }: { id: string; deactivateRules: boolean }) =>
+ categoriesApi.update(id, { is_hidden: true }, { deactivateRules }),
+ onSuccess: (_data, variables) => {
+ invalidateAll()
+ if (variables.deactivateRules) queryClient.invalidateQueries({ queryKey: ['rules'] })
+ setHidingCategory(null)
+ toast.success(t('categories.updated'))
+ },
+ onError: (err: unknown) => toast.error(extractApiError(err, t('common.error'))),
+ })
+
+ // Rules that still file transactions into a category outlive hiding it, so
+ // check for them first and only interrupt the user when there are any.
+ async function handleToggleHidden(cat: Category) {
+ if (cat.is_hidden) {
+ updateCatMutation.mutate({ id: cat.id, is_hidden: false })
+ return
+ }
+ try {
+ const usage = await queryClient.fetchQuery({
+ queryKey: ['category-rule-usage', cat.id],
+ queryFn: () => categoriesApi.ruleUsage(cat.id),
+ staleTime: 0,
+ })
+ if (usage.rules.length === 0) {
+ hideCatMutation.mutate({ id: cat.id, deactivateRules: false })
+ return
+ }
+ setHidingCategory({ category: cat, rules: usage.rules })
+ } catch (err) {
+ toast.error(extractApiError(err, t('common.error')))
+ }
+ }
const deleteCatMutation = useMutation({
mutationFn: (id: string) => categoriesApi.delete(id),
onSuccess: () => { invalidateAll(); setDeletingCategory(null); toast.success(t('categories.deleted')) },
@@ -129,6 +169,7 @@ export default function CategoriesPage() {
setFormIcon(cat?.icon ?? 'circle-help')
setFormColor(cat?.color ?? '#6366f1')
setFormTreatAsTransfer(cat?.treat_as_transfer ?? false)
+ setFormIgnoreTransfer(cat?.is_ignored ?? false)
setCatDialogOpen(true)
}
@@ -139,11 +180,18 @@ export default function CategoriesPage() {
setGroupDialogOpen(true)
}
+ const renderHiddenBadge = (label: string) => (
+ <span className="text-[10px] font-medium px-1.5 py-0.5 rounded bg-muted text-muted-foreground border border-border shrink-0">
+ {label}
+ </span>
+ )
+
const renderCategoryItem = (cat: Category) => (
- <div key={cat.id} className="flex items-center gap-3 px-4 sm:px-5 pl-6 sm:pl-12 py-2.5 border-b border-border last:border-0 hover:bg-muted transition-colors">
+ <div key={cat.id} className={`flex items-center gap-3 px-4 sm:px-5 pl-6 sm:pl-12 py-2.5 border-b border-border last:border-0 hover:bg-muted transition-colors ${cat.is_hidden ? 'opacity-60' : ''}`}>
<CategoryIcon icon={cat.icon} color={cat.color} size="md" />
<div className="flex-1 min-w-0 flex items-center gap-2">
<span className="text-sm font-medium text-foreground truncate">{cat.name}</span>
+ {cat.is_hidden && renderHiddenBadge(t('categories.hiddenBadge'))}
{cat.treat_as_transfer && (
<span
className="text-[10px] font-medium px-1.5 py-0.5 rounded bg-muted text-muted-foreground border border-border shrink-0"
@@ -174,7 +222,16 @@ export default function CategoriesPage() {
>
<Pencil size={13} />
</button>
- {!cat.is_system && (
+ {cat.is_system ? (
+ <button
+ className="p-1.5 rounded-md text-muted-foreground hover:text-primary hover:bg-primary/5 transition-colors"
+ onClick={() => handleToggleHidden(cat)}
+ disabled={updateCatMutation.isPending || hideCatMutation.isPending}
+ title={cat.is_hidden ? t('categories.showDefault') : t('categories.hideDefault')}
+ >
+ {cat.is_hidden ? <Eye size={13} /> : <EyeOff size={13} />}
+ </button>
+ ) : (
<button
className="p-1.5 rounded-md text-muted-foreground hover:text-rose-500 hover:bg-rose-50 transition-colors"
onClick={() => setDeletingCategory(cat)}
@@ -193,6 +250,10 @@ export default function CategoriesPage() {
<div>
<PageHeader section={t('categories.title')} title={t('categories.title')} />
+ <p className="mb-4 text-sm text-muted-foreground">
+ {t('categories.hiddenScopeDescription')}
+ </p>
+
<SectionCard>
<SectionHeader
title={t('categories.title')}
@@ -230,7 +291,7 @@ export default function CategoriesPage() {
{groups?.map((group) => {
const isCollapsed = collapsedGroups.has(group.id)
return (
- <div key={group.id}>
+ <div key={group.id} className={group.is_hidden ? 'opacity-60' : ''}>
<div className="flex items-center gap-2 px-4 sm:px-5 py-3 border-b border-border bg-muted/40">
<button
className="flex items-center gap-2 flex-1 min-w-0 text-left"
@@ -239,6 +300,7 @@ export default function CategoriesPage() {
{isCollapsed ? <ChevronRight size={14} className="text-muted-foreground shrink-0" /> : <ChevronDown size={14} className="text-muted-foreground shrink-0" />}
<CategoryIcon icon={group.icon} color={group.color} size="md" />
<span className="text-sm font-semibold" style={{ color: group.color }}>{group.name}</span>
+ {group.is_hidden && renderHiddenBadge(t('groups.hiddenBadge'))}
<span className="text-xs text-muted-foreground">({group.categories.length})</span>
</button>
{canWrite && (
@@ -250,7 +312,16 @@ export default function CategoriesPage() {
>
<Pencil size={13} />
</button>
- {!group.is_system && (
+ {group.is_system ? (
+ <button
+ className="p-1.5 rounded-md text-muted-foreground hover:text-primary hover:bg-primary/5 transition-colors"
+ onClick={() => updateGroupMutation.mutate({ id: group.id, is_hidden: !group.is_hidden })}
+ disabled={updateGroupMutation.isPending}
+ title={group.is_hidden ? t('groups.showDefault') : t('groups.hideDefault')}
+ >
+ {group.is_hidden ? <Eye size={13} /> : <EyeOff size={13} />}
+ </button>
+ ) : (
<button
className="p-1.5 rounded-md text-muted-foreground hover:text-rose-500 hover:bg-rose-50 transition-colors"
onClick={() => setDeletingGroup(group)}
@@ -318,8 +389,10 @@ export default function CategoriesPage() {
className="w-full border border-border rounded-lg px-3 py-2 text-sm bg-card text-foreground focus:outline-none focus:ring-2 focus:ring-primary"
>
<option value="">{t('categories.noGroup')}</option>
- {groups?.map((g) => (
- <option key={g.id} value={g.id}>{g.name}</option>
+ {groups?.filter((g) => !g.is_hidden || g.id === editingCat?.group_id).map((g) => (
+ <option key={g.id} value={g.id}>
+ {g.name}{g.is_hidden ? ` (${t('groups.hiddenBadge')})` : ''}
+ </option>
))}
</select>
</div>
@@ -438,6 +511,58 @@ export default function CategoriesPage() {
onClose={() => setDeletingGroup(null)}
onConfirm={() => deletingGroup && deleteGroupMutation.mutate(deletingGroup.id)}
/>
+
+ <Dialog open={!!hidingCategory} onOpenChange={(open) => !open && setHidingCategory(null)}>
+ <DialogContent className="sm:max-w-lg">
+ <DialogHeader>
+ <DialogTitle>
+ {t('categories.hideWithRulesTitle', { name: hidingCategory?.category.name })}
+ </DialogTitle>
+ </DialogHeader>
+ <div className="space-y-3">
+ <p className="text-sm text-muted-foreground">
+ {t('categories.hideWithRulesDescription', { count: hidingCategory?.rules.length ?? 0 })}
+ </p>
+ <ul className="max-h-40 overflow-y-auto rounded-lg border border-border divide-y divide-border">
+ {hidingCategory?.rules.map((rule) => (
+ <li key={rule.id} className="px-3 py-2 text-sm text-foreground truncate">
+ {rule.name}
+ </li>
+ ))}
+ </ul>
+ </div>
+ <DialogFooter className="gap-2 sm:justify-between">
+ <Button
+ variant="ghost"
+ onClick={() => setHidingCategory(null)}
+ disabled={hideCatMutation.isPending}
+ >
+ {t('common.cancel')}
+ </Button>
+ <div className="flex flex-wrap gap-2">
+ <Button
+ variant="outline"
+ onClick={() =>
+ hidingCategory
+ && hideCatMutation.mutate({ id: hidingCategory.category.id, deactivateRules: false })
+ }
+ disabled={hideCatMutation.isPending}
+ >
+ {t('categories.hideKeepRules')}
+ </Button>
+ <Button
+ onClick={() =>
+ hidingCategory
+ && hideCatMutation.mutate({ id: hidingCategory.category.id, deactivateRules: true })
+ }
+ disabled={hideCatMutation.isPending}
+ >
+ {t('categories.hideAndTurnOffRules')}
+ </Button>
+ </div>
+ </DialogFooter>
+ </DialogContent>
+ </Dialog>
</div>
)
}
diff --git a/frontend/src/pages/recurring.tsx b/frontend/src/pages/recurring.tsx
index 75b48c7f..a217502f 100644
--- a/frontend/src/pages/recurring.tsx
+++ b/frontend/src/pages/recurring.tsx
@@ -83,6 +83,12 @@ function RecurringTab() {
queryFn: categoriesApi.list,
})
+ const { data: allCategoriesList } = useQuery({
+ queryKey: ['categories', 'management'],
+ queryFn: categoriesApi.listIncludingHidden,
+ enabled: Boolean(editing?.category_id),
+ })
+
const { data: categoryGroupsList } = useQuery({
queryKey: ['categoryGroups'],
queryFn: categoryGroupsApi.list,
@@ -257,6 +263,9 @@ function RecurringTab() {
recurring={editing}
categories={categoriesList ?? []}
categoryGroups={categoryGroupsList ?? []}
+ currentCategory={allCategoriesList?.find(
+ (category) => category.id === editing?.category_id
+ )}
accounts={accountsList ?? []}
onSave={(data) => {
if (editing) {
@@ -287,6 +296,7 @@ function RecurringForm({
recurring,
categories,
categoryGroups,
+ currentCategory,
accounts,
onSave,
onCancel,
@@ -295,6 +305,7 @@ function RecurringForm({
recurring: RecurringTransaction | null
categories: Category[]
categoryGroups: CategoryGroup[]
+ currentCategory?: Category
accounts: { id: string; name: string; display_name?: string | null }[]
onSave: (data: Partial<RecurringTransaction>) => void
onCancel: () => void
@@ -421,6 +432,7 @@ function RecurringForm({
onChange={setCategoryId}
categories={categories}
groups={categoryGroups}
+ currentCategory={currentCategory}
allowNone={true}
className={selectClass}
/>
diff --git a/frontend/src/pages/rules.tsx b/frontend/src/pages/rules.tsx
index a568235b..6426cfad 100644
--- a/frontend/src/pages/rules.tsx
+++ b/frontend/src/pages/rules.tsx
@@ -21,6 +21,7 @@ import { cn } from '@/lib/utils'
import { PageHeader } from '@/components/page-header'
import { useWorkspace } from '@/contexts/workspace-context'
import { RuleDialog } from '@/components/rule-dialog'
+import { findCategoryReference, getRuleCategoryName } from '@/lib/category-reference-utils'
function SectionCard({ children }: { children: React.ReactNode }) {
return (
@@ -108,7 +109,7 @@ function conditionSummary(conditions: RuleConditionNode[], conditionsOp: string,
function actionSummary(actions: RuleAction[], categories: Category[], payeesList: Payee[], t: (key: string) => string): string {
return actions.map(a => {
if (a.op === 'set_category') {
- const cat = categories.find(c => c.id === a.value)
+ const cat = findCategoryReference(categories, a.value)
return cat ? `→ ${cat.name}` : `→ ${t('transactions.category')}`
}
if (a.op === 'set_payee') {
@@ -162,6 +163,11 @@ export default function RulesPage() {
queryFn: categoriesApi.list,
})
+ const { data: allCategoriesList } = useQuery({
+ queryKey: ['categories', 'management'],
+ queryFn: categoriesApi.listIncludingHidden,
+ })
+
const { data: categoryGroupsList } = useQuery({
queryKey: ['categoryGroups'],
queryFn: categoryGroupsApi.list,
@@ -290,6 +296,10 @@ export default function RulesPage() {
}
const categories = useMemo(() => categoriesList ?? [], [categoriesList])
+ const displayCategories = useMemo(
+ () => allCategoriesList ?? categoriesList ?? [],
+ [allCategoriesList, categoriesList],
+ )
const payees = useMemo(() => payeesList ?? [], [payeesList])
const [sortBy, setSortBy] = useState<'priority' | 'name' | 'category'>('priority')
@@ -303,15 +313,12 @@ export default function RulesPage() {
}
if (sortBy === 'category') {
const getCategoryName = (rule: Rule) => {
- const action = rule.actions.find(a => a.op === 'set_category')
- if (!action) return ''
- const cat = categories.find(c => c.id === action.value)
- return cat?.name ?? ''
+ return getRuleCategoryName(rule, displayCategories) ?? ''
}
return list.sort((a, b) => dir * getCategoryName(a).localeCompare(getCategoryName(b)))
}
return list.sort((a, b) => dir * (a.priority - b.priority))
- }, [rulesList, categories, sortBy, sortDir])
+ }, [rulesList, displayCategories, sortBy, sortDir])
return (
<div>
@@ -434,7 +441,7 @@ export default function RulesPage() {
{conditionSummary(rule.conditions, rule.conditions_op, t, payees)}
</p>
<p className="text-xs text-emerald-600 font-medium mt-0.5">
- {actionSummary(rule.actions, categories, payees, t)}
+ {actionSummary(rule.actions, displayCategories, payees, t)}
</p>
</div>
{canWrite && (
@@ -509,6 +516,7 @@ export default function RulesPage() {
rule={editing}
categories={categories}
categoryGroups={categoryGroupsList ?? []}
+ currentCategories={allCategoriesList ?? []}
accounts={accountsList ?? []}
payees={payees}
onSave={(data) => {
diff --git a/frontend/src/pages/transactions.tsx b/frontend/src/pages/transactions.tsx
index b5c8561d..a8ccac06 100644
--- a/frontend/src/pages/transactions.tsx
+++ b/frontend/src/pages/transactions.tsx
@@ -457,6 +457,14 @@ export default function TransactionsPage() {
queryFn: categoriesApi.list,
})
+ // A category filter survives in the URL, so it can outlive the category
+ // being hidden. Kept apart from the list that feeds the picker.
+ const { data: allCategoriesList } = useQuery({
+ queryKey: ['categories', 'management'],
+ queryFn: categoriesApi.listIncludingHidden,
+ enabled: filterCategoryIds.length > 0,
+ })
+
const { data: categoryGroupsList } = useQuery({
queryKey: ['categoryGroups'],
queryFn: categoryGroupsApi.list,
@@ -1398,6 +1406,7 @@ export default function TransactionsPage() {
}}
accounts={accountsList ?? []}
categories={categoriesList ?? []}
+ referenceCategories={allCategoriesList}
categoryGroups={categoryGroupsList ?? []}
payees={payeesList ?? []}
groups={allGroups ?? []}
diff --git a/frontend/src/types/index.ts b/frontend/src/types/index.ts
index 9cbe665e..18fa4c68 100644
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -95,10 +95,16 @@ export interface Category {
icon: string
color: string
is_system: boolean
+ is_hidden: boolean
treat_as_transfer: boolean
is_ignored: boolean
}
+/** Active rules that assign a category, used when retiring one. */
+export interface CategoryRuleUsage {
+ rules: { id: string; name: string }[]
+}
+
export interface CategoryGroup {
id: string
user_id: string
@@ -107,6 +113,7 @@ export interface CategoryGroup {
color: string
position: number
is_system: boolean
+ is_hidden: boolean
categories: Category[]
}