Enhance transaction handling by adding parent_id support and filtering logic

- Updated the SQL query in getTransactions to include parent_id for split transactions.
- Modified the Transaction interface to accommodate parent_id, allowing for better handling of split transactions.
- Implemented filtering logic in transformToWrappedData to exclude parent split transactions while including child splits and regular transactions.
- Added comprehensive tests to validate the correct behavior of split transaction filtering, ensuring accurate expense calculations and category representation.

Author: MatissJanis

CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to date-based versioning with entries grouped by date.
 
+## 2026-01-05
+
+### Added
+
+- Split transaction support: Added `parent_id` field to Transaction interface to track split transaction relationships
+- Parent split transaction filtering: Automatically excludes parent split transactions (transactions with no category and child splits pointing to them) while including child split transactions in the wrapped data
+- Comprehensive unit tests for split transaction filtering covering parent splits, child splits, regular transactions, and mixed scenarios
+
 ## 2026-01-04
 
 ### Added

src/services/fileApi.ts

@@ -288,7 +288,7 @@ async function getTransactions(
       params.push(endDateInt);
     }
 
-    let sql = `SELECT id, acct as account, date, amount, category, notes, description, cleared, reconciled FROM transactions WHERE acct = ? AND tombstone = 0${dateFilter}`;
+    let sql = `SELECT id, acct as account, date, amount, category, notes, description, cleared, reconciled, parent_id FROM transactions WHERE acct = ? AND tombstone = 0${dateFilter}`;
     const transactions = query(sql, params);
 
     // Get payee information - payees are linked via payee_mapping table
@@ -387,6 +387,7 @@ async function getTransactions(
         category_tombstone: categoryTombstone,
         cleared: t.cleared === 1 || false,
         reconciled: t.reconciled === 1 || false,
+        parent_id: t.parent_id ? String(t.parent_id) : undefined,
       });
     }
 

src/types/index.ts

@@ -12,6 +12,7 @@ export interface Transaction {
   category_tombstone?: boolean; // Whether the category is deleted
   cleared?: boolean;
   reconciled?: boolean;
+  parent_id?: string; // ID of parent transaction for split transactions
 }
 
 export interface Category {

src/utils/dataTransform.test.ts

@@ -1335,6 +1335,193 @@ describe('transformToWrappedData', () => {
     });
   });
 
+  describe('Split Transaction Filtering', () => {
+    it('excludes parent split transactions (no category, no parent_id)', () => {
+      const transactions: Transaction[] = [
+        createMockTransaction({
+          id: 'parent1',
+          date: '2025-01-15',
+          category: undefined,
+          parent_id: undefined,
+          amount: -10000, // Parent split - should be excluded
+        }),
+        createMockTransaction({
+          id: 'child1',
+          date: '2025-01-15',
+          category: 'cat1',
+          parent_id: 'parent1',
+          amount: -5000, // Child split - should be included
+        }),
+        createMockTransaction({
+          id: 'child2',
+          date: '2025-01-15',
+          category: 'cat2',
+          parent_id: 'parent1',
+          amount: -5000, // Child split - should be included
+        }),
+      ];
+
+      const categories: Category[] = [
+        createMockCategory({ id: 'cat1', name: 'Groceries' }),
+        createMockCategory({ id: 'cat2', name: 'Gas' }),
+      ];
+
+      const result = transformToWrappedData(transactions, categories, [], []);
+
+      // Parent split should be excluded, only child splits included
+      expect(result.transactionStats.totalCount).toBe(2);
+      expect(result.totalExpenses).toBe(100); // $50 + $50 from child splits
+      expect(result.topCategories).toHaveLength(2);
+    });
+
+    it('includes child split transactions (has category, has parent_id)', () => {
+      const transactions: Transaction[] = [
+        createMockTransaction({
+          id: 'child1',
+          date: '2025-01-15',
+          category: 'cat1',
+          parent_id: 'parent1',
+          amount: -10000,
+        }),
+        createMockTransaction({
+          id: 'child2',
+          date: '2025-01-15',
+          category: 'cat1',
+          parent_id: 'parent1',
+          amount: -20000,
+        }),
+      ];
+
+      const categories: Category[] = [createMockCategory({ id: 'cat1', name: 'Groceries' })];
+
+      const result = transformToWrappedData(transactions, categories, [], []);
+
+      expect(result.transactionStats.totalCount).toBe(2);
+      expect(result.totalExpenses).toBe(300); // $100 + $200
+      expect(result.topCategories).toHaveLength(1);
+      expect(result.topCategories[0].amount).toBe(300);
+    });
+
+    it('includes regular transactions (has category, no parent_id)', () => {
+      const transactions: Transaction[] = [
+        createMockTransaction({
+          id: 'regular1',
+          date: '2025-01-15',
+          category: 'cat1',
+          parent_id: undefined,
+          amount: -10000,
+        }),
+        createMockTransaction({
+          id: 'regular2',
+          date: '2025-01-15',
+          category: 'cat2',
+          parent_id: undefined,
+          amount: -20000,
+        }),
+      ];
+
+      const categories: Category[] = [
+        createMockCategory({ id: 'cat1', name: 'Groceries' }),
+        createMockCategory({ id: 'cat2', name: 'Gas' }),
+      ];
+
+      const result = transformToWrappedData(transactions, categories, [], []);
+
+      expect(result.transactionStats.totalCount).toBe(2);
+      expect(result.totalExpenses).toBe(300); // $100 + $200
+      expect(result.topCategories).toHaveLength(2);
+    });
+
+    it('handles mixed split and regular transactions correctly', () => {
+      const transactions: Transaction[] = [
+        // Parent split - should be excluded
+        createMockTransaction({
+          id: 'parent1',
+          date: '2025-01-15',
+          category: undefined,
+          parent_id: undefined,
+          amount: -30000,
+        }),
+        // Child splits - should be included
+        createMockTransaction({
+          id: 'child1',
+          date: '2025-01-15',
+          category: 'cat1',
+          parent_id: 'parent1',
+          amount: -10000,
+        }),
+        createMockTransaction({
+          id: 'child2',
+          date: '2025-01-15',
+          category: 'cat2',
+          parent_id: 'parent1',
+          amount: -20000,
+        }),
+        // Regular transaction - should be included
+        createMockTransaction({
+          id: 'regular1',
+          date: '2025-01-15',
+          category: 'cat1',
+          parent_id: undefined,
+          amount: -15000,
+        }),
+      ];
+
+      const categories: Category[] = [
+        createMockCategory({ id: 'cat1', name: 'Groceries' }),
+        createMockCategory({ id: 'cat2', name: 'Gas' }),
+      ];
+
+      const result = transformToWrappedData(transactions, categories, [], []);
+
+      // Parent split excluded, 2 child splits + 1 regular = 3 transactions
+      expect(result.transactionStats.totalCount).toBe(3);
+      expect(result.totalExpenses).toBe(450); // $100 + $200 + $150
+      expect(result.topCategories).toHaveLength(2);
+      // cat1 should have $100 (child) + $150 (regular) = $250
+      const cat1 = result.topCategories.find(c => c.categoryId === 'cat1');
+      expect(cat1?.amount).toBe(250);
+    });
+
+    it('handles split transactions with income categories', () => {
+      const transactions: Transaction[] = [
+        // Parent split - should be excluded
+        createMockTransaction({
+          id: 'parent1',
+          date: '2025-01-15',
+          category: undefined,
+          parent_id: undefined,
+          amount: 50000,
+        }),
+        // Child split income - should be included
+        createMockTransaction({
+          id: 'child1',
+          date: '2025-01-15',
+          category: 'cat1',
+          parent_id: 'parent1',
+          amount: 30000,
+        }),
+        createMockTransaction({
+          id: 'child2',
+          date: '2025-01-15',
+          category: 'cat2',
+          parent_id: 'parent1',
+          amount: 20000,
+        }),
+      ];
+
+      const categories: Category[] = [
+        createMockCategory({ id: 'cat1', name: 'Salary', is_income: true }),
+        createMockCategory({ id: 'cat2', name: 'Freelance', is_income: true }),
+      ];
+
+      const result = transformToWrappedData(transactions, categories, [], []);
+
+      expect(result.transactionStats.totalCount).toBe(2);
+      expect(result.totalIncome).toBe(500); // $300 + $200 from child splits
+    });
+  });
+
   describe('Combined Filtering', () => {
     it('excludes transfers, off-budget, and starting balance together', () => {
       const transactions: Transaction[] = [

src/utils/dataTransform.ts

@@ -339,14 +339,34 @@ export function transformToWrappedData(
     // Collect transfer transactions separately for budget comparison
     const transferTransactions: Transaction[] = [];
 
+    // Build a set of parent transaction IDs that have child splits
+    // A parent split is identified by having child transactions pointing to it
+    const parentSplitIds = new Set<string>();
+    transactions.forEach(t => {
+      if (t.parent_id) {
+        parentSplitIds.add(t.parent_id);
+      }
+    });
+
     // Filter transactions for 2025 and exclude transfers, off-budget (conditionally), and starting balance
     const yearTransactions = transactions.filter(t => {
       const date = parseISO(t.date);
       if (date < yearStart || date > yearEnd) {
         return false;
       }
-      // Collect transfer transactions (payees with transfer_acct field)
+      // Collect transfer transactions (payees with transfer_acct field) - check early for parent split logic
       const isTransfer = t.payee && payeeIdToTransferAcct.has(t.payee);
+
+      // Exclude parent split transactions (no category AND no parent_id AND has child splits AND not a transfer)
+      // Parent split transactions represent the total but don't have categories themselves
+      // We identify them by checking if any child transactions point to this transaction's ID
+      // Child split transactions have parent_id and should be included
+      // Regular transactions have category and no parent_id and should be included
+      // Uncategorized transactions (no category, no parent_id, no children) should be included
+      // Transfers don't have categories but should be included (if toggles allow)
+      if (!t.parent_id && parentSplitIds.has(t.id) && !isTransfer) {
+        return false;
+      }
       if (isTransfer) {
         // Check off-budget status of source account (needed for transferTransactions collection)
         const sourceIsOffBudget = accountOffbudgetMap.get(t.account) || false;