Add getCategoryMappings function and related tests

- Implemented getCategoryMappings to retrieve mappings of old category IDs to merged category IDs, handling cases where the database is not initialized or the category_mapping table does not exist.
- Updated getTransactions and getBudgetedAmounts functions to resolve category IDs through the merge chain, ensuring accurate category representation in transactions and budget calculations.
- Added unit tests for getCategoryMappings to verify its behavior under various scenarios, including database initialization and table existence.
- Enhanced data transformation tests to ensure transactions are correctly categorized under merged categories.

Author: MatissJanis

src/services/fileApi.test.ts

@@ -14,6 +14,7 @@ import {
   getPayees,
   getAllTransactionsForYear,
   getCategoryGroupTombstones,
+  getCategoryMappings,
   shutdown,
   clearBudget,
   integerToAmount,
@@ -365,6 +366,50 @@ describe('fileApi', () => {
     });
   });
 
+  describe('getCategoryMappings', () => {
+    it('throws DatabaseError when database is not initialized', async () => {
+      await expect(getCategoryMappings()).rejects.toThrow(DatabaseError);
+    });
+
+    it('returns map of old category IDs to merged category IDs', async () => {
+      const file = createMockFile();
+      Object.defineProperty(file, 'size', { value: 1000, writable: false });
+
+      await initialize(file);
+
+      mockStatement.step
+        .mockReturnValueOnce(true)
+        .mockReturnValueOnce(true)
+        .mockReturnValueOnce(false);
+      mockStatement.getAsObject
+        .mockReturnValueOnce({ id: 'cat1', transferId: 'cat2' }) // Merged: cat1 -> cat2
+        .mockReturnValueOnce({ id: 'cat3', transferId: 'cat3' }); // Self-reference (not merged)
+
+      const categoryMappings = await getCategoryMappings();
+
+      expect(categoryMappings.size).toBe(1);
+      expect(categoryMappings.get('cat1')).toBe('cat2');
+      expect(categoryMappings.has('cat3')).toBe(false); // Self-references excluded
+      expect(mockDatabase.prepare).toHaveBeenCalledWith(
+        'SELECT id, transferId FROM category_mapping',
+      );
+    });
+
+    it('returns empty map when category_mapping table does not exist', async () => {
+      const file = createMockFile();
+      Object.defineProperty(file, 'size', { value: 1000, writable: false });
+
+      await initialize(file);
+      mockDatabase.prepare.mockImplementation(() => {
+        throw new Error('no such table: category_mapping');
+      });
+
+      const categoryMappings = await getCategoryMappings();
+
+      expect(categoryMappings.size).toBe(0);
+    });
+  });
+
   describe('getPayees', () => {
     it('throws DatabaseError when database is not initialized', async () => {
       await expect(getPayees()).rejects.toThrow(DatabaseError);

src/services/fileApi.ts

@@ -189,6 +189,32 @@ export async function getCategoryGroupTombstones(): Promise<Map<string, boolean>
   return groupTombstoneMap;
 }
 
+/**
+ * Get category mappings (category ID -> merged category ID)
+ * Maps deleted/merged categories to the categories they were merged into
+ */
+export async function getCategoryMappings(): Promise<Map<string, string>> {
+  if (!db) {
+    throw new DatabaseError('Database not loaded. Call initialize() first.');
+  }
+
+  const categoryMapping = new Map<string, string>();
+  try {
+    const mappings = query('SELECT id, transferId FROM category_mapping');
+    mappings.forEach(m => {
+      const oldId = String(m.id);
+      const newId = String(m.transferId);
+      // Only include actual merges (where id != transferId)
+      if (oldId !== newId) {
+        categoryMapping.set(oldId, newId);
+      }
+    });
+  } catch {
+    // No category_mapping table, that's okay
+  }
+  return categoryMapping;
+}
+
 /**
  * Get categories from database
  */
@@ -295,6 +321,22 @@ async function getTransactions(
       categories.map(c => [String(c.id), { name: String(c.name), tombstone: c.tombstone === 1 }]),
     );
 
+    // Get category mappings for resolving merged categories
+    let categoryMappings = new Map<string, string>();
+    try {
+      const mappings = query('SELECT id, transferId FROM category_mapping');
+      mappings.forEach(m => {
+        const oldId = String(m.id);
+        const newId = String(m.transferId);
+        // Only include actual merges (where id != transferId)
+        if (oldId !== newId) {
+          categoryMappings.set(oldId, newId);
+        }
+      });
+    } catch {
+      // No category_mapping table, that's okay
+    }
+
     const result: Transaction[] = [];
 
     for (const t of transactions) {
@@ -314,8 +356,20 @@ async function getTransactions(
       const payeeInfo = payeeId && payeeInfoMap ? payeeInfoMap.get(payeeId) : undefined;
       const payeeTombstone = payeeInfo ? payeeInfo.tombstone : false;
 
-      // Get category info (name and tombstone status)
-      const categoryInfo = t.category ? categoryMap.get(String(t.category)) : undefined;
+      // Resolve category ID through merge chain (handle transitive merges A -> B -> C)
+      let resolvedCategoryId = t.category ? String(t.category) : undefined;
+
+      if (resolvedCategoryId && categoryMappings.has(resolvedCategoryId)) {
+        // Follow the merge chain until we reach the final target
+        const visited = new Set<string>(); // Prevent infinite loops in case of circular references
+        while (categoryMappings.has(resolvedCategoryId) && !visited.has(resolvedCategoryId)) {
+          visited.add(resolvedCategoryId);
+          resolvedCategoryId = categoryMappings.get(resolvedCategoryId)!;
+        }
+      }
+
+      // Get category info from the resolved (merged) category
+      const categoryInfo = resolvedCategoryId ? categoryMap.get(resolvedCategoryId) : undefined;
       const categoryName = categoryInfo ? categoryInfo.name : undefined;
       const categoryTombstone = categoryInfo ? categoryInfo.tombstone : false;
 
@@ -328,7 +382,7 @@ async function getTransactions(
         payee_name: payeeName,
         payee_tombstone: payeeTombstone,
         notes: t.notes ? String(t.notes) : undefined,
-        category: t.category ? String(t.category) : undefined,
+        category: resolvedCategoryId, // Use resolved category ID
         category_name: categoryName,
         category_tombstone: categoryTombstone,
         cleared: t.cleared === 1 || false,
@@ -465,11 +519,28 @@ export async function getBudgetedAmounts(
       'December',
     ];
 
-    // Convert to structured format
-    const result: Array<{ categoryId: string; month: string; budgetedAmount: number }> = [];
+    // Get category mappings for resolving merged categories
+    let categoryMappings = new Map<string, string>();
+    try {
+      const mappings = query('SELECT id, transferId FROM category_mapping');
+      mappings.forEach(m => {
+        const oldId = String(m.id);
+        const newId = String(m.transferId);
+        // Only include actual merges (where id != transferId)
+        if (oldId !== newId) {
+          categoryMappings.set(oldId, newId);
+        }
+      });
+    } catch {
+      // No category_mapping table, that's okay
+    }
+
+    // Resolve category IDs through merge chain and accumulate budgets
+    // Use a map to combine budgets from merged categories
+    const budgetMap = new Map<string, Map<string, number>>(); // resolvedCategoryId -> month -> amount
 
     for (const row of budgetRows) {
-      const categoryId = String(row.category || '');
+      let categoryId = String(row.category || '');
       const monthInt = Number(row.month || 0);
       const amount = Number(row.amount || 0);
 
@@ -478,6 +549,15 @@ export async function getBudgetedAmounts(
         continue;
       }
 
+      // Resolve category ID through merge chain (handle transitive merges A -> B -> C)
+      if (categoryMappings.has(categoryId)) {
+        const visited = new Set<string>(); // Prevent infinite loops
+        while (categoryMappings.has(categoryId) && !visited.has(categoryId)) {
+          visited.add(categoryId);
+          categoryId = categoryMappings.get(categoryId)!;
+        }
+      }
+
       // Convert month INTEGER (YYYYMM format) to month name
       // Extract month number from YYYYMM (e.g., 202501 -> 01 -> January)
       const monthNum = monthInt % 100; // Get last 2 digits
@@ -488,13 +568,27 @@ export async function getBudgetedAmounts(
       const monthStr = monthNames[monthNum - 1];
       const budgetedAmount = integerToAmount(amount);
 
-      result.push({
-        categoryId,
-        month: monthStr,
-        budgetedAmount,
-      });
+      // Accumulate budgets for the same resolved category and month
+      if (!budgetMap.has(categoryId)) {
+        budgetMap.set(categoryId, new Map());
+      }
+      const monthMap = budgetMap.get(categoryId)!;
+      const currentAmount = monthMap.get(monthStr) || 0;
+      monthMap.set(monthStr, currentAmount + budgetedAmount);
     }
 
+    // Convert map back to array format
+    const result: Array<{ categoryId: string; month: string; budgetedAmount: number }> = [];
+    budgetMap.forEach((monthMap, categoryId) => {
+      monthMap.forEach((budgetedAmount, month) => {
+        result.push({
+          categoryId,
+          month,
+          budgetedAmount,
+        });
+      });
+    });
+
     return result;
   } catch (error) {
     // If budget data fetch fails (e.g., table doesn't exist), return empty array

src/utils/dataTransform.test.ts

@@ -344,6 +344,43 @@ describe('transformToWrappedData', () => {
       expect(deleted?.categoryName).toBe('deleted: Old Category');
     });
 
+    it('handles merged categories - transactions appear under merged category', () => {
+      // Category cat1 was merged into cat2
+      // Transaction originally had category 'cat1', but after resolution should use 'cat2'
+      const transactions: Transaction[] = [
+        createMockTransaction({ id: 't1', category: 'cat2', amount: -10000 }), // Already resolved to cat2
+      ];
+
+      const categories: Category[] = [
+        createMockCategory({ id: 'cat1', name: 'Old Category', tombstone: true }),
+        createMockCategory({ id: 'cat2', name: 'New Category', tombstone: false }),
+      ];
+
+      const result = transformToWrappedData(transactions, categories, [], []);
+
+      // Transaction should appear under merged category (cat2), not as "deleted: Old Category"
+      const merged = result.topCategories.find(c => c.categoryId === 'cat2');
+      expect(merged?.categoryName).toBe('New Category'); // Should show merged category name
+      expect(merged?.amount).toBe(100);
+      expect(result.topCategories.find(c => c.categoryId === 'cat1')).toBeUndefined();
+    });
+
+    it('handles merged categories - non-merged deleted categories still show deleted prefix', () => {
+      const transactions: Transaction[] = [
+        createMockTransaction({ id: 't1', category: 'cat1', amount: -10000 }),
+      ];
+
+      const categories: Category[] = [
+        createMockCategory({ id: 'cat1', name: 'Deleted Category', tombstone: true }),
+      ];
+
+      const result = transformToWrappedData(transactions, categories, [], []);
+
+      // Non-merged deleted category should still show "deleted: " prefix
+      const deleted = result.topCategories.find(c => c.categoryId === 'cat1');
+      expect(deleted?.categoryName).toBe('deleted: Deleted Category');
+    });
+
     it('sorts categories by amount descending', () => {
       const transactions: Transaction[] = [
         createMockTransaction({ id: 't1', category: 'cat1', amount: -10000 }),