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

package/src/modules/charges-matcher/__tests__/match-scorer.test.ts

@@ -1,15 +1,71 @@
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
 import type { AggregatedTransaction, DocumentCharge, TransactionCharge } from '../types.js';
 import {
   scoreMatch,
   selectTransactionDate,
 } from '../providers/match-scorer.provider.js';
 import { createMockTransaction, createMockDocument } from './test-helpers.js';
+import { Injector } from 'graphql-modules';
+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: {name: string}) => {
+    if (token.name === 'ClientsProvider')
+      return {
+        getClientByIdLoader: {
+          load: (businessId: string) => {
+            const isRegisteredClient = businessId.startsWith('client-');
+            return Promise.resolve(isRegisteredClient ? { id: businessId } : null);
+          },
+        },
+      };
+    if (token.name === 'IssuedDocumentsProvider')
+      return {
+        getIssuedDocumentsStatusByChargeIdLoader: {
+          load: async (_chargeId: string) => ({ charge_id: _chargeId, open_docs_flag: true }),
+        },
+      };
+    return null;
+  }),
+}) as Injector;
+
+// Spy-able injector to assert DataLoader usage
+const createSpyInjector = (loaderImpl?: (businessId: string) => Promise<any>) => {
+  const load = vi.fn(loaderImpl ?? (() => Promise.resolve(null)));
+  const get = vi.fn((token: {name: string}) => {
+    if (token.name === 'ClientsProvider') {
+      return {
+        getClientByIdLoader: { load },
+      };
+    }
+    if (token.name === 'IssuedDocumentsProvider') {
+      return {
+        getIssuedDocumentsStatusByChargeIdLoader: {
+          load: vi.fn(async (chargeId: string) => ({ charge_id: chargeId, open_docs_flag: true })),
+        },
+      };
+    }
+    return null;
+  });
+  return { get, load } as unknown as Injector & { load: typeof load };
+};
+
 describe('Match Scorer', () => {
   describe('selectTransactionDate', () => {
     const transaction: AggregatedTransaction = {
@@ -22,50 +78,50 @@ describe('Match Scorer', () => {
     };
 
     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: TransactionCharge = {
           chargeId: 'charge-tx-1',
           transactions: [
@@ -92,17 +148,18 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-2',
           transactions: [
@@ -111,6 +168,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
             }),
           ],
         };
@@ -122,19 +180,20 @@ 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);
+        const result = await scoreMatch(txCharge, docCharge, USER_ID, createMockInjector());
 
-        expect(result.confidenceScore).toBeGreaterThan(0.80);
+        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: TransactionCharge = {
           chargeId: 'charge-tx-3',
           transactions: [createMockTransaction({ amount: "100.00" })],
@@ -145,14 +204,14 @@ describe('Match Scorer', () => {
           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: TransactionCharge = {
           chargeId: 'charge-tx-4',
           transactions: [createMockTransaction({ currency: 'USD' })],
@@ -163,14 +222,14 @@ describe('Match Scorer', () => {
           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: TransactionCharge = {
           chargeId: 'charge-tx-5',
           transactions: [createMockTransaction({ business_id: 'business-1' })],
@@ -186,17 +245,18 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-6',
           transactions: [
             createMockTransaction({
               event_date: new Date('2024-01-01'),
+              business_id: 'customer-1', // Different business for cross-business test
             }),
           ],
         };
@@ -206,18 +266,374 @@ 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: TransactionCharge = {
+          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: DocumentCharge = {
+          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 as any);
+
+        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: TransactionCharge = {
+          chargeId: 'charge-tx-client-30',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-31'),
+              business_id: 'client-xyz',
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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 as any);
+
+        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: TransactionCharge = {
+          chargeId: 'charge-tx-client-365',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-01'),
+              business_id: 'client-long',
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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 as any);
+
+        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: TransactionCharge = {
+          chargeId: 'charge-tx-nonclient-15',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-01'),
+              business_id: 'vendor-plain',
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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: TransactionCharge = {
+          chargeId: 'charge-tx-nonclient-45',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-01'),
+              business_id: 'vendor-far',
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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: TransactionCharge = {
+          chargeId: 'charge-tx-cross',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-01'),
+              business_id: 'customer-xyz',
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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: TransactionCharge = {
+          chargeId: 'charge-tx-null-business',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-01'),
+              business_id: null,
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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 as any);
+
+        expect(result.components.date).toBe(0.5);
+        expect(spyInjector.load).not.toHaveBeenCalled();
+      });
+
+      it('uses ClientsProvider result when lookup succeeds', async () => {
+        const txCharge: TransactionCharge = {
+          chargeId: 'charge-tx-client-lookup',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-01'),
+              business_id: 'client-lookup',
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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 as any);
+
+        expect(result.components.date).toBe(1.0);
+        expect(spyInjector.load).toHaveBeenCalledTimes(1);
+      });
+
+      it('uses standard degradation when ClientsProvider returns null', async () => {
+        const txCharge: TransactionCharge = {
+          chargeId: 'charge-tx-client-null',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-01'),
+              business_id: 'client-missing',
+            }),
+          ],
+        };
+
+        const docCharge: DocumentCharge = {
+          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 as any);
+
+        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: TransactionCharge = {
+          chargeId: 'charge-tx-client-multi',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-15'),
+              business_id: 'client-multi',
+            }),
+          ],
+        };
+
+        const janDoc: DocumentCharge = {
+          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: DocumentCharge = {
+          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 as any);
+        const febScore = await scoreMatch(txCharge, febDoc, USER_ID, spyInjector as any);
+
+        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: TransactionCharge = {
+          chargeId: 'charge-tx-nonclient-multi',
+          transactions: [
+            createMockTransaction({
+              event_date: new Date('2024-01-15'),
+              business_id: 'vendor-multi',
+            }),
+          ],
+        };
+
+        const nearDoc: DocumentCharge = {
+          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: DocumentCharge = {
+          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: TransactionCharge = {
           chargeId: 'charge-tx-7',
           transactions: [
@@ -238,12 +654,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); // Should match event_date
       });
 
-      it('should use event_date for RECEIPT matching', () => {
+      it('should use event_date for RECEIPT matching', async () => {
         const txCharge: TransactionCharge = {
           chargeId: 'charge-tx-8',
           transactions: [
@@ -251,6 +667,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
             }),
           ],
         };
@@ -261,16 +678,17 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-9',
           transactions: [
@@ -292,14 +710,14 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-10',
           transactions: [
@@ -307,6 +725,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
             }),
           ],
         };
@@ -317,18 +736,19 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-11',
           transactions: [
@@ -349,13 +769,13 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-12',
           transactions: [
@@ -377,12 +797,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);
       });
 
-      it('should handle flexible type without debit_date', () => {
+      it('should handle flexible type without debit_date', async () => {
         const txCharge: TransactionCharge = {
           chargeId: 'charge-tx-13',
           transactions: [
@@ -404,7 +824,7 @@ 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);
@@ -412,7 +832,7 @@ describe('Match Scorer', () => {
     });
 
     describe('Amount Variations', () => {
-      it('should handle small amount differences', () => {
+      it('should handle small amount differences', async () => {
         const txCharge: TransactionCharge = {
           chargeId: 'charge-tx-14',
           transactions: [createMockTransaction({ amount: "100.00" })],
@@ -423,12 +843,12 @@ describe('Match Scorer', () => {
           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: TransactionCharge = {
           chargeId: 'charge-tx-15',
           transactions: [createMockTransaction({ amount: "100.00" })],
@@ -439,14 +859,14 @@ describe('Match Scorer', () => {
           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: TransactionCharge = {
           chargeId: 'charge-tx-16',
           transactions: [
@@ -462,13 +882,13 @@ 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); // 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: TransactionCharge = {
           chargeId: 'charge-tx-17',
           transactions: [createMockTransaction({ amount: "-100.00" })],
@@ -486,12 +906,12 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-18',
           transactions: [
@@ -519,7 +939,7 @@ 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);
@@ -527,10 +947,82 @@ describe('Match Scorer', () => {
         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: TransactionCharge = {
+          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: DocumentCharge = {
+          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() as any);
+
+        // 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: TransactionCharge = {
+          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: DocumentCharge = {
+          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: TransactionCharge = {
           chargeId: 'charge-tx-19',
           transactions: [
@@ -544,10 +1036,10 @@ describe('Match Scorer', () => {
           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: TransactionCharge = {
           chargeId: 'charge-tx-20',
           transactions: [createMockTransaction()],
@@ -561,10 +1053,10 @@ describe('Match Scorer', () => {
           ],
         };
 
-        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: TransactionCharge = {
           chargeId: 'charge-tx-21',
           transactions: [
@@ -578,10 +1070,10 @@ describe('Match Scorer', () => {
           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: TransactionCharge = {
           chargeId: 'charge-tx-22',
           transactions: [createMockTransaction()],
@@ -597,12 +1089,12 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-23',
           transactions: [createMockTransaction({ business_id: null })],
@@ -618,12 +1110,12 @@ 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: TransactionCharge = {
           chargeId: 'charge-tx-24',
           transactions: [createMockTransaction({ amount: '0.00' })],
@@ -634,12 +1126,12 @@ describe('Match Scorer', () => {
           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: TransactionCharge = {
           chargeId: 'charge-tx-25',
           transactions: [createMockTransaction({ amount: '1000000.00' })],
@@ -650,7 +1142,7 @@ describe('Match Scorer', () => {
           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);
       });