@accounter/server 0.0.9-alpha-20251217093036-7168648b507d62946aa287af4ea690b73b077b2d → 0.0.9-alpha-20251217131153-65f961a4072436d7f1042ea8ea4d96534cb3650e

package/dist/server/src/modules/charges-matcher/__tests__/match-scorer.test.js

@@ -1,9 +1,61 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import { scoreMatch, selectTransactionDate, } from '../providers/match-scorer.provider.js';
 import { createMockTransaction, createMockDocument } from './test-helpers.js';
+import { DocumentType } from '../../../shared/enums.js';
+// Mock DI system and ClientsProvider / IssuedDocumentsProvider
+vi.mock('../../financial-entities/providers/clients.provider.js', () => ({
+    ClientsProvider: class {
+    },
+}));
+vi.mock('../../documents/providers/issued-documents.provider.js', () => ({
+    IssuedDocumentsProvider: class {
+    },
+}));
 // Test user ID
 const USER_ID = 'user-123';
 const BUSINESS_ID = 'business-abc';
+// Create a mock injector for testing client matching
+// Create a mock injector for testing
+const createMockInjector = () => ({
+    get: vi.fn((token) => {
+        if (token.name === 'ClientsProvider')
+            return {
+                getClientByIdLoader: {
+                    load: (businessId) => {
+                        const isRegisteredClient = businessId.startsWith('client-');
+                        return Promise.resolve(isRegisteredClient ? { id: businessId } : null);
+                    },
+                },
+            };
+        if (token.name === 'IssuedDocumentsProvider')
+            return {
+                getIssuedDocumentsStatusByChargeIdLoader: {
+                    load: async (_chargeId) => ({ charge_id: _chargeId, open_docs_flag: true }),
+                },
+            };
+        return null;
+    }),
+});
+// Spy-able injector to assert DataLoader usage
+const createSpyInjector = (loaderImpl) => {
+    const load = vi.fn(loaderImpl ?? (() => Promise.resolve(null)));
+    const get = vi.fn((token) => {
+        if (token.name === 'ClientsProvider') {
+            return {
+                getClientByIdLoader: { load },
+            };
+        }
+        if (token.name === 'IssuedDocumentsProvider') {
+            return {
+                getIssuedDocumentsStatusByChargeIdLoader: {
+                    load: vi.fn(async (chargeId) => ({ charge_id: chargeId, open_docs_flag: true })),
+                },
+            };
+        }
+        return null;
+    });
+    return { get, load };
+};
 describe('Match Scorer', () => {
     describe('selectTransactionDate', () => {
         const transaction = {
@@ -15,42 +67,42 @@ describe('Match Scorer', () => {
             description: 'Test',
         };
         it('should use event_date for INVOICE', () => {
-            const result = selectTransactionDate(transaction, 'INVOICE');
+            const result = selectTransactionDate(transaction, DocumentType.Invoice);
             expect(result).toEqual(new Date('2024-01-15'));
         });
         it('should use event_date for CREDIT_INVOICE', () => {
-            const result = selectTransactionDate(transaction, 'CREDIT_INVOICE');
+            const result = selectTransactionDate(transaction, DocumentType.CreditInvoice);
             expect(result).toEqual(new Date('2024-01-15'));
         });
         it('should use event_date for RECEIPT', () => {
-            const result = selectTransactionDate(transaction, 'RECEIPT');
+            const result = selectTransactionDate(transaction, DocumentType.Receipt);
             expect(result).toEqual(new Date('2024-01-15'));
         });
         it('should use event_date for INVOICE_RECEIPT', () => {
-            const result = selectTransactionDate(transaction, 'INVOICE_RECEIPT');
+            const result = selectTransactionDate(transaction, DocumentType.InvoiceReceipt);
             expect(result).toEqual(new Date('2024-01-15'));
         });
         it('should use event_date for RECEIPT when debitDate is null', () => {
             const txWithoutDebitDate = { ...transaction, debitDate: null };
-            const result = selectTransactionDate(txWithoutDebitDate, 'RECEIPT');
+            const result = selectTransactionDate(txWithoutDebitDate, DocumentType.Receipt);
             expect(result).toEqual(new Date('2024-01-15'));
         });
         it('should use event_date for OTHER', () => {
-            const result = selectTransactionDate(transaction, 'OTHER');
+            const result = selectTransactionDate(transaction, DocumentType.Other);
             expect(result).toEqual(new Date('2024-01-15'));
         });
         it('should use event_date for PROFORMA', () => {
-            const result = selectTransactionDate(transaction, 'PROFORMA');
+            const result = selectTransactionDate(transaction, DocumentType.Proforma);
             expect(result).toEqual(new Date('2024-01-15'));
         });
         it('should use event_date for UNPROCESSED', () => {
-            const result = selectTransactionDate(transaction, 'UNPROCESSED');
+            const result = selectTransactionDate(transaction, DocumentType.Unprocessed);
             expect(result).toEqual(new Date('2024-01-15'));
         });
     });
     describe('scoreMatch', () => {
         describe('Perfect Matches', () => {
-            it('should score perfect match close to 1.0', () => {
+            it('should score perfect match close to 1.0', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-1',
                     transactions: [
@@ -75,15 +127,16 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.chargeId).toBe('charge-doc-1');
                 expect(result.confidenceScore).toBeGreaterThan(0.95);
                 expect(result.components.amount).toBe(1.0);
                 expect(result.components.currency).toBe(1.0);
                 expect(result.components.business).toBe(1.0);
+                // Non-client same-business: uses standard date calculation, not flat 1.0
                 expect(result.components.date).toBe(1.0);
             });
-            it('should handle receipt matching with event_date', () => {
+            it('should handle receipt matching with event_date', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-2',
                     transactions: [
@@ -92,6 +145,7 @@ describe('Match Scorer', () => {
                             event_date: new Date('2024-01-10'),
                             debit_date: new Date('2024-01-15'),
                             debit_timestamp: null,
+                            business_id: 'customer-receipt', // Different business for cross-business test
                         }),
                     ],
                 };
@@ -102,16 +156,17 @@ describe('Match Scorer', () => {
                             total_amount: 200,
                             date: new Date('2024-01-15'),
                             type: 'RECEIPT',
+                            creditor_id: 'vendor-receipt', // Different business
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
-                expect(result.confidenceScore).toBeGreaterThan(0.80);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
+                expect(result.confidenceScore).toBeGreaterThan(0.70); // Amount + currency + date good, business mismatch
                 expect(result.components.date).toBeCloseTo(0.83, 1);
             });
         });
         describe('Partial Matches', () => {
-            it('should handle amount mismatch', () => {
+            it('should handle amount mismatch', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-3',
                     transactions: [createMockTransaction({ amount: "100.00" })],
@@ -120,12 +175,12 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-3',
                     documents: [createMockDocument({ total_amount: 110 })], // 10% difference
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBeLessThan(1.0);
                 expect(result.components.amount).toBeGreaterThan(0.0);
                 expect(result.confidenceScore).toBeLessThan(0.95);
             });
-            it('should handle currency mismatch', () => {
+            it('should handle currency mismatch', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-4',
                     transactions: [createMockTransaction({ currency: 'USD' })],
@@ -134,12 +189,12 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-4',
                     documents: [createMockDocument({ currency_code: 'EUR' })],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.currency).toBe(0.0); // Different currencies = 0.0
                 // Overall confidence can still be decent if other factors match
                 expect(result.confidenceScore).toBeLessThan(1.0);
             });
-            it('should handle business mismatch', () => {
+            it('should handle business mismatch', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-5',
                     transactions: [createMockTransaction({ business_id: 'business-1' })],
@@ -153,15 +208,16 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.business).toBe(0.2);
             });
-            it('should handle date difference', () => {
+            it('should handle date difference', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-6',
                     transactions: [
                         createMockTransaction({
                             event_date: new Date('2024-01-01'),
+                            business_id: 'customer-1', // Different business for cross-business test
                         }),
                     ],
                 };
@@ -170,15 +226,325 @@ describe('Match Scorer', () => {
                     documents: [
                         createMockDocument({
                             date: new Date('2024-01-16'), // 15 days difference
+                            creditor_id: 'vendor-1', // Different business
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.date).toBe(0.5); // 15/30 = 0.5
             });
         });
+        describe('Client-aware date confidence', () => {
+            it('returns flat 1.0 for client same-business on same day', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-client-same-day',
+                    transactions: [
+                        createMockTransaction({
+                            amount: "100.00",
+                            currency: 'USD',
+                            event_date: new Date('2024-01-15'),
+                            business_id: 'client-abc',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-client-same-day',
+                    documents: [
+                        createMockDocument({
+                            total_amount: 100,
+                            currency_code: 'USD',
+                            date: new Date('2024-01-15'),
+                            creditor_id: 'client-abc',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const spyInjector = createSpyInjector(async () => ({ id: 'client-abc' }));
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, spyInjector);
+                expect(result.components.date).toBe(1.0);
+                expect(spyInjector.load).toHaveBeenCalledTimes(1);
+            });
+            it('returns flat 1.0 for client same-business 30 days apart', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-client-30',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-31'),
+                            business_id: 'client-xyz',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-client-30',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-01-01'),
+                            creditor_id: 'client-xyz',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const spyInjector = createSpyInjector(async () => ({ id: 'client-xyz' }));
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, spyInjector);
+                expect(result.components.date).toBe(1.0);
+                expect(spyInjector.load).toHaveBeenCalledTimes(1);
+            });
+            it('returns flat 1.0 for client same-business 365 days apart', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-client-365',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-01'),
+                            business_id: 'client-long',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-client-365',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2023-01-01'),
+                            creditor_id: 'client-long',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const spyInjector = createSpyInjector(async () => ({ id: 'client-long' }));
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, spyInjector);
+                expect(result.components.date).toBe(1.0);
+                expect(spyInjector.load).toHaveBeenCalledTimes(1);
+            });
+            it('uses standard degradation for non-client same-business (15 days)', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-nonclient-15',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-01'),
+                            business_id: 'vendor-plain',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-nonclient-15',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-01-16'),
+                            creditor_id: 'vendor-plain',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
+                expect(result.components.date).toBe(0.5);
+            });
+            it('uses standard degradation for non-client same-business (45 days)', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-nonclient-45',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-01'),
+                            business_id: 'vendor-far',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-nonclient-45',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-02-15'),
+                            creditor_id: 'vendor-far',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
+                expect(result.components.date).toBe(0.0);
+            });
+            it('uses standard degradation for cross-business matches', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-cross',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-01'),
+                            business_id: 'customer-xyz',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-cross',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-01-06'),
+                            creditor_id: 'vendor-xyz',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
+                expect(result.components.date).toBeCloseTo(0.83, 1);
+            });
+            it('skips client lookup when businessId is null', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-null-business',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-01'),
+                            business_id: null,
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-null-business',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-01-16'),
+                            creditor_id: USER_ID,
+                            debtor_id: null,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const spyInjector = createSpyInjector();
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, spyInjector);
+                expect(result.components.date).toBe(0.5);
+                expect(spyInjector.load).not.toHaveBeenCalled();
+            });
+            it('uses ClientsProvider result when lookup succeeds', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-client-lookup',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-01'),
+                            business_id: 'client-lookup',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-client-lookup',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2023-12-01'),
+                            creditor_id: 'client-lookup',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const spyInjector = createSpyInjector(async () => ({ id: 'client-lookup' }));
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, spyInjector);
+                expect(result.components.date).toBe(1.0);
+                expect(spyInjector.load).toHaveBeenCalledTimes(1);
+            });
+            it('uses standard degradation when ClientsProvider returns null', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-client-null',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-01'),
+                            business_id: 'client-missing',
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-client-null',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-01-11'),
+                            creditor_id: 'client-missing',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const spyInjector = createSpyInjector(async () => null);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, spyInjector);
+                expect(result.components.date).toBeCloseTo(0.67, 1);
+                expect(spyInjector.load).toHaveBeenCalledTimes(1);
+            });
+            it('gives equal date scores for multiple client invoices regardless of recency', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-client-multi',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-15'),
+                            business_id: 'client-multi',
+                        }),
+                    ],
+                };
+                const janDoc = {
+                    chargeId: 'charge-doc-client-jan',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2023-12-30'),
+                            creditor_id: 'client-multi',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const febDoc = {
+                    chargeId: 'charge-doc-client-feb',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2023-11-30'),
+                            creditor_id: 'client-multi',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const spyInjector = createSpyInjector(async () => ({ id: 'client-multi' }));
+                const janScore = await scoreMatch(txCharge, janDoc, USER_ID, spyInjector);
+                const febScore = await scoreMatch(txCharge, febDoc, USER_ID, spyInjector);
+                expect(janScore.components.date).toBe(1.0);
+                expect(febScore.components.date).toBe(1.0);
+                expect(spyInjector.load).toHaveBeenCalledTimes(2);
+            });
+            it('prefers closer date for non-client when amounts tie', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-nonclient-multi',
+                    transactions: [
+                        createMockTransaction({
+                            event_date: new Date('2024-01-15'),
+                            business_id: 'vendor-multi',
+                        }),
+                    ],
+                };
+                const nearDoc = {
+                    chargeId: 'charge-doc-nonclient-near',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-01-17'),
+                            creditor_id: 'vendor-multi',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const farDoc = {
+                    chargeId: 'charge-doc-nonclient-far',
+                    documents: [
+                        createMockDocument({
+                            date: new Date('2024-02-20'),
+                            creditor_id: 'vendor-multi',
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const nearScore = await scoreMatch(txCharge, nearDoc, USER_ID, createMockInjector());
+                const farScore = await scoreMatch(txCharge, farDoc, USER_ID, createMockInjector());
+                expect(nearScore.components.date).toBeGreaterThan(farScore.components.date);
+            });
+        });
         describe('Date Type Selection', () => {
-            it('should use event_date for INVOICE matching', () => {
+            it('should use event_date for INVOICE matching', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-7',
                     transactions: [
@@ -197,10 +563,10 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.date).toBe(1.0); // Should match event_date
             });
-            it('should use event_date for RECEIPT matching', () => {
+            it('should use event_date for RECEIPT matching', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-8',
                     transactions: [
@@ -208,6 +574,7 @@ describe('Match Scorer', () => {
                             event_date: new Date('2024-01-10'),
                             debit_date: new Date('2024-01-15'),
                             debit_timestamp: null,
+                            business_id: 'customer-2', // Different business for cross-business test
                         }),
                     ],
                 };
@@ -217,13 +584,14 @@ describe('Match Scorer', () => {
                         createMockDocument({
                             date: new Date('2024-01-15'), // Matches debit_date
                             type: 'RECEIPT',
+                            creditor_id: 'vendor-2', // Different business
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.date).toBeCloseTo(0.83, 1);
             });
-            it('should fall back to event_date for RECEIPT when debit_date is null', () => {
+            it('should fall back to event_date for RECEIPT when debit_date is null', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-9',
                     transactions: [
@@ -243,12 +611,12 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.date).toBe(1.0);
             });
         });
         describe('Flexible Document Types (PROFORMA/OTHER/UNPROCESSED)', () => {
-            it('should use event_date for PROFORMA and use better score', () => {
+            it('should use event_date for PROFORMA and use better score', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-10',
                     transactions: [
@@ -256,6 +624,7 @@ describe('Match Scorer', () => {
                             event_date: new Date('2024-01-01'), // Far from document date
                             debit_date: new Date('2024-01-15'), // Matches document date
                             debit_timestamp: null,
+                            business_id: 'customer-3', // Different business for cross-business test
                         }),
                     ],
                 };
@@ -265,15 +634,16 @@ describe('Match Scorer', () => {
                         createMockDocument({
                             date: new Date('2024-01-15'),
                             type: 'PROFORMA',
+                            creditor_id: 'vendor-3', // Different business
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 // Should use event_date (2024-01-01) vs latest doc date (2024-01-15) = 14 days
                 // Date confidence: 1.0 - 14/30 = 0.53
                 expect(result.components.date).toBeCloseTo(0.53, 1);
             });
-            it('should handle OTHER type with both dates', () => {
+            it('should handle OTHER type with both dates', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-11',
                     transactions: [
@@ -292,11 +662,11 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 // Should use event_date since it matches better
                 expect(result.components.date).toBe(1.0);
             });
-            it('should handle UNPROCESSED type', () => {
+            it('should handle UNPROCESSED type', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-12',
                     transactions: [
@@ -316,10 +686,10 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.date).toBe(1.0);
             });
-            it('should handle flexible type without debit_date', () => {
+            it('should handle flexible type without debit_date', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-13',
                     transactions: [
@@ -339,13 +709,13 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 // Should only use event_date
                 expect(result.components.date).toBe(1.0);
             });
         });
         describe('Amount Variations', () => {
-            it('should handle small amount differences', () => {
+            it('should handle small amount differences', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-14',
                     transactions: [createMockTransaction({ amount: "100.00" })],
@@ -354,10 +724,10 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-14',
                     documents: [createMockDocument({ total_amount: 100.5 })], // 0.5 difference
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBeGreaterThanOrEqual(0.9); // Within 1 unit = exactly 0.9
             });
-            it('should handle large amount differences', () => {
+            it('should handle large amount differences', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-15',
                     transactions: [createMockTransaction({ amount: "100.00" })],
@@ -366,12 +736,12 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-15',
                     documents: [createMockDocument({ total_amount: 150 })], // 50% difference
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBe(0.0);
             });
         });
         describe('Integration Tests', () => {
-            it('should handle multiple transactions and documents', () => {
+            it('should handle multiple transactions and documents', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-16',
                     transactions: [
@@ -385,11 +755,11 @@ describe('Match Scorer', () => {
                         createMockDocument({ total_amount: 100, serial_number: 'INV-001' }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBe(1.0); // 50 + 50 = 100
                 expect(result.confidenceScore).toBeGreaterThan(0.95);
             });
-            it('should handle credit invoice (negative amounts)', () => {
+            it('should handle credit invoice (negative amounts)', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-17',
                     transactions: [createMockTransaction({ amount: "-100.00" })],
@@ -405,10 +775,10 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBe(1.0);
             });
-            it('should handle real-world scenario with slight variations', () => {
+            it('should handle real-world scenario with slight variations', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-18',
                     transactions: [
@@ -434,16 +804,80 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBeGreaterThanOrEqual(0.9); // Within 1 unit = 0.9
                 expect(result.components.currency).toBe(1.0);
                 expect(result.components.business).toBe(1.0);
                 expect(result.components.date).toBeGreaterThan(0.95); // 1 day = 0.97
                 expect(result.confidenceScore).toBeGreaterThanOrEqual(0.9);
             });
+            it('should apply flat date confidence for CLIENT same-business matches', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-client-1',
+                    transactions: [
+                        createMockTransaction({
+                            amount: "500.00",
+                            currency: 'USD',
+                            event_date: new Date('2024-02-01'),
+                            business_id: 'client-acme', // Registered client
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-client-1',
+                    documents: [
+                        createMockDocument({
+                            total_amount: 500,
+                            currency_code: 'USD',
+                            date: new Date('2024-01-04'), // 28 days earlier - gentle eligible
+                            creditor_id: 'client-acme', // Same business, registered client
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
+                // For client same-business: date confidence should be 1.0 (flat)
+                expect(result.components.date).toBe(1.0);
+                // Overall confidence should be very high
+                expect(result.confidenceScore).toBeGreaterThan(0.95);
+            });
+            it('should use standard date degradation for NON-CLIENT same-business matches', async () => {
+                const txCharge = {
+                    chargeId: 'charge-tx-nonc-1',
+                    transactions: [
+                        createMockTransaction({
+                            amount: "500.00",
+                            currency: 'USD',
+                            event_date: new Date('2024-02-01'),
+                            business_id: 'vendor-bob', // NOT a client (no 'client-' prefix)
+                        }),
+                    ],
+                };
+                const docCharge = {
+                    chargeId: 'charge-doc-nonc-1',
+                    documents: [
+                        createMockDocument({
+                            total_amount: 500,
+                            currency_code: 'USD',
+                            date: new Date('2024-03-01'), // 28 days later = 1.0 - 28/30 = 0.07
+                            creditor_id: 'vendor-bob', // Same business, but NOT a client
+                            debtor_id: USER_ID,
+                            type: 'INVOICE',
+                        }),
+                    ],
+                };
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
+                // For non-client same-business: date confidence should use standard degradation
+                expect(result.components.date).toBeCloseTo(0.07, 1);
+                // Overall confidence lower due to date mismatch
+                // Calculation: (amount: 1.0 * 0.4) + (currency: 1.0 * 0.2) + (business: 1.0 * 0.3) + (date: 0.07 * 0.1)
+                //           = 0.4 + 0.2 + 0.3 + 0.007 = 0.907 ≈ 0.91
+                expect(result.confidenceScore).toBeLessThanOrEqual(0.91);
+            });
         });
         describe('Error Propagation', () => {
-            it('should throw error for mixed currencies in transactions', () => {
+            it('should throw error for mixed currencies in transactions', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-19',
                     transactions: [
@@ -455,9 +889,9 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-19',
                     documents: [createMockDocument()],
                 };
-                expect(() => scoreMatch(txCharge, docCharge, USER_ID)).toThrow(/multiple currencies/);
+                await expect(scoreMatch(txCharge, docCharge, USER_ID, createMockInjector())).rejects.toThrow(/multiple currencies/);
             });
-            it('should throw error for mixed currencies in documents', () => {
+            it('should throw error for mixed currencies in documents', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-20',
                     transactions: [createMockTransaction()],
@@ -469,9 +903,9 @@ describe('Match Scorer', () => {
                         createMockDocument({ currency_code: 'EUR' }),
                     ],
                 };
-                expect(() => scoreMatch(txCharge, docCharge, USER_ID)).toThrow(/multiple currencies/);
+                await expect(scoreMatch(txCharge, docCharge, USER_ID, createMockInjector())).rejects.toThrow(/multiple currencies/);
             });
-            it('should throw error for multiple business IDs in transactions', () => {
+            it('should throw error for multiple business IDs in transactions', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-21',
                     transactions: [
@@ -483,9 +917,9 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-21',
                     documents: [createMockDocument()],
                 };
-                expect(() => scoreMatch(txCharge, docCharge, USER_ID)).toThrow(/multiple business/);
+                await expect(scoreMatch(txCharge, docCharge, USER_ID, createMockInjector())).rejects.toThrow(/multiple business/);
             });
-            it('should throw error for invalid document business extraction', () => {
+            it('should throw error for invalid document business extraction', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-22',
                     transactions: [createMockTransaction()],
@@ -499,11 +933,11 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                expect(() => scoreMatch(txCharge, docCharge, USER_ID)).toThrow();
+                await expect(scoreMatch(txCharge, docCharge, USER_ID, createMockInjector())).rejects.toThrow();
             });
         });
         describe('Edge Cases', () => {
-            it('should handle null business IDs', () => {
+            it('should handle null business IDs', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-23',
                     transactions: [createMockTransaction({ business_id: null })],
@@ -517,10 +951,10 @@ describe('Match Scorer', () => {
                         }),
                     ],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.business).toBe(0.5);
             });
-            it('should handle zero amounts', () => {
+            it('should handle zero amounts', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-24',
                     transactions: [createMockTransaction({ amount: '0.00' })],
@@ -529,10 +963,10 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-24',
                     documents: [createMockDocument({ total_amount: 0 })],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBe(1.0);
             });
-            it('should handle very large amounts', () => {
+            it('should handle very large amounts', async () => {
                 const txCharge = {
                     chargeId: 'charge-tx-25',
                     transactions: [createMockTransaction({ amount: '1000000.00' })],
@@ -541,7 +975,7 @@ describe('Match Scorer', () => {
                     chargeId: 'charge-doc-25',
                     documents: [createMockDocument({ total_amount: 1000000 })],
                 };
-                const result = scoreMatch(txCharge, docCharge, USER_ID);
+                const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
                 expect(result.components.amount).toBe(1.0);
             });
         });