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.pynew file mode 100644index 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.pyindex 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, statusfrom sqlalchemy.ext.asyncio import AsyncSessionfrom 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_servicerouter = 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 excif not category:raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Category not found")return categorydiff --git a/backend/app/api/category_groups.py b/backend/app/api/category_groups.pyindex 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, statusfrom sqlalchemy.ext.asyncio import AsyncSessionfrom 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 excif not group:raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Group not found")return groupdiff --git a/backend/app/models/category.py b/backend/app/models/category.pyindex 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/expensediff --git a/backend/app/models/category_group.py b/backend/app/models/category_group.pyindex 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.pyindex 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] = Nonetreat_as_transfer: Optional[bool] = Noneis_ignored: Optional[bool] = None+ is_hidden: Optional[bool] = Noneclass CategoryRead(CategoryBase):@@ -30,7 +31,20 @@ class CategoryRead(CategoryBase):user_id: uuid.UUIDgroup_id: Optional[uuid.UUID] = Noneis_system: bool+ is_hidden: bool = Falsetreat_as_transfer: bool = Falseis_ignored: bool = Falsemodel_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.pyindex 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] = Nonecolor: Optional[str] = Noneposition: Optional[int] = None+ is_hidden: Optional[bool] = Noneclass CategoryGroupRead(CategoryGroupBase):id: uuid.UUIDuser_id: uuid.UUIDis_system: bool+ is_hidden: bool = Falsecategories: 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.pyindex 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 CategoryGroupfrom 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.pyindex de156942..fd83473c 100644--- a/backend/app/services/category_service.py+++ b/backend/app/services/category_service.py@@ -1,15 +1,21 @@import uuidfrom typing import Optional-from sqlalchemy import select+from sqlalchemy import or_, selectfrom sqlalchemy.exc import IntegrityErrorfrom sqlalchemy.ext.asyncio import AsyncSessionfrom app.models.category import Category+from app.models.category_group import CategoryGroup+from app.models.rule import Rulefrom app.schemas.category import CategoryCreate, CategoryUpdatefrom 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 categorydiff --git a/backend/app/services/import_service.py b/backend/app/services/import_service.pyindex 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 Transactionfrom app.schemas.transaction import TransactionImportfrom app.services import recurring_match_servicefrom app.services.credit_card_service import apply_effective_date+from app.services.category_service import get_hidden_category_idsfrom app.services.rule_engine import apply_rule_actions, evaluate_conditions, merge_notesfrom app.services.rule_service import apply_rules_to_transaction, preview_rules_for_transactionfrom 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_idtxn.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.pyindex 44b3657f..43edbdea 100644--- a/backend/app/services/rule_engine.py+++ b/backend/app/services/rule_engine.py@@ -2,6 +2,7 @@import reimport unicodedataimport uuid+from collections.abc import Collectionfrom datetime import date, datetimefrom decimal import Decimal, InvalidOperationfrom 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 = Trueelif op == "set_description":if skip_description:diff --git a/backend/app/services/rule_service.py b/backend/app/services/rule_service.pyindex 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 Categoryfrom app.models.payee import Payeefrom app.models.transaction import Transactionfrom app.schemas.rule import RuleCreate, RuleExportPayload, RuleImportResponse, RuleUpdate+from app.services.category_service import get_hidden_category_idsfrom 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 = 0for 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 Noneand 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 = 0for 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) -> inttx,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.pyindex 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_categorieresponse = 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 == 201data = 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.asyncioasync 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 Truediff --git a/backend/tests/test_category_groups_api.py b/backend/tests/test_category_groups_api.pyindex cd837ba3..3c7663d1 100644--- a/backend/tests/test_category_groups_api.py+++ b/backend/tests/test_category_groups_api.py@@ -2,6 +2,9 @@ import uuidimport pytestfrom 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_idsdiff --git a/docs/categories/default-categories-hidden.png b/docs/categories/default-categories-hidden.pngnew file mode 100644index 00000000..9758658cBinary files /dev/null and b/docs/categories/default-categories-hidden.png differdiff --git a/docs/categories/default-categories-visible.png b/docs/categories/default-categories-visible.pngnew file mode 100644index 00000000..16d3aff3Binary files /dev/null and b/docs/categories/default-categories-visible.png differdiff --git a/frontend/src/components/category-select.tsx b/frontend/src/components/category-select.tsxindex 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/popoverimport { 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: stringonChange: (value: string) => voidcategories: Category[]groups: CategoryGroup[]+ currentCategory?: Category | nullplaceholder?: stringdisabled?: booleanclassName?: 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.tsxindex 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: booleanonClose: () => voidrule: Rule | nullcategories: 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.tsxindex 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 ?? categoryGroupsconst 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.nameif (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.tsxindex 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: () => voidaccounts: 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.tsindex 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 datadiff --git a/frontend/src/lib/category-reference-utils.test.ts b/frontend/src/lib/category-reference-utils.test.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsnew file mode 100644index 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.tsindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.tsxindex 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.tsxindex 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.tsxindex 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 && (<spanclassName="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>+ ) : (<buttonclassName="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><SectionHeadertitle={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"><buttonclassName="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>+ ) : (<buttonclassName="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.tsxindex 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 | nullcategories: Category[]categoryGroups: CategoryGroup[]+ currentCategory?: Categoryaccounts: { id: string; name: string; display_name?: string | null }[]onSave: (data: Partial<RecurringTransaction>) => voidonCancel: () => 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.tsxindex 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.tsxindex 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.tsindex 9cbe665e..18fa4c68 100644--- a/frontend/src/types/index.ts+++ b/frontend/src/types/index.ts@@ -95,10 +95,16 @@ export interface Category {icon: stringcolor: stringis_system: boolean+ is_hidden: booleantreat_as_transfer: booleanis_ignored: boolean}+/** Active rules that assign a category, used when retiring one. */+export interface CategoryRuleUsage {+ rules: { id: string; name: string }[]+}+export interface CategoryGroup {id: stringuser_id: string@@ -107,6 +113,7 @@ export interface CategoryGroup {color: stringposition: numberis_system: boolean+ is_hidden: booleancategories: Category[]}