@stamhoofd/backend 2.143.0 → 2.144.0

package/src/helpers/StripeSettlementSync.ts

@@ -12,10 +12,10 @@ import { SettlementStatus } from '@stamhoofd/structures/settlements/SettlementSt
 import Stripe from 'stripe';
 
 import { ApplicationFeeService } from '../services/ApplicationFeeService.js';
-import { ReportedRows, SettlementService } from '../services/SettlementService.js';
+import { SettlementService } from '../services/SettlementService.js';
 import { ApplicationFeeDetails } from './ApplicationFeeDetails.js';
-import { passthroughFetch } from './passthroughFetch.js';
 import { getPaymentIdForStripeCharge } from './getPaymentIdForStripeCharge.js';
+import { passthroughFetch } from './passthroughFetch.js';
 import { WebmasterReport } from './WebmasterReport.js';
 
 /**
@@ -109,8 +109,7 @@ export class StripeSettlementSync {
     }
 
     /**
-     * Sync all paid payouts that arrived in the window. A failing payout is marked, reported and
-     * skipped so the other payouts still sync; the summary tells the caller how bad it was.
+     * Sync all paid payouts that arrived in the window.
      */
     async syncPayouts({ start, end, force = false, abort }: { start: Date; end?: Date; force?: boolean; abort?: AbortSignal }): Promise<{ synced: number; skipped: number; failed: number }> {
         const result = { synced: 0, skipped: 0, failed: 0 };
@@ -180,7 +179,7 @@ export class StripeSettlementSync {
 
         // Storing a fee can link it to a balance item right away (a month the legacy invoicer
         // billed). When it is already paid out, its payout needs the derived line for it
-        const invoicedFeeBalanceItemIds = new Set<string>();
+        const settledApplicationFeeBalanceItems = new Set<string>();
 
         try {
             for await (const transaction of this.stripe.balanceTransactions.list({
@@ -195,7 +194,7 @@ export class StripeSettlementSync {
                 abort?.throwIfAborted();
 
                 try {
-                    await this.#handleApplicationFee(transaction, { invoicedFeeBalanceItemIds });
+                    await this.#handleApplicationFee(transaction, { settledApplicationFeeBalanceItems });
                 } catch (e) {
                     // The month is only invoiced after a walk without errors, so an interrupted
                     // walk has to stop the walk itself instead of joining the errors of its
@@ -209,11 +208,11 @@ export class StripeSettlementSync {
         } catch (e) {
             // The payouts of the fees stored so far still need their derived lines, but failing to
             // update them may not hide what broke the walk
-            await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]).catch(console.error);
+            await SettlementService.updatePaymentSettlementsForApplicationFeeBalanceItems([...settledApplicationFeeBalanceItems]).catch(console.error);
             throw e;
         }
 
-        await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]);
+        await SettlementService.updatePaymentSettlementsForApplicationFeeBalanceItems([...settledApplicationFeeBalanceItems]);
 
         if (errors.length > 0) {
             throw new SimpleError({
@@ -234,7 +233,7 @@ export class StripeSettlementSync {
          * be updated afterwards. Filled while storing, not from the return value: a fee that is
          * stored before a later one throws still needs its derived line.
          */
-        invoicedFeeBalanceItemIds?: Set<string>;
+        settledApplicationFeeBalanceItems?: Set<string>;
     } = {}): Promise<{ fees: ApplicationFee[]; charges: SettlementCharge[] }> {
         const fee = transaction.source as Stripe.ApplicationFee;
         const payingAccountId = typeof fee.account === 'string' ? fee.account : fee.account.id;
@@ -317,7 +316,7 @@ export class StripeSettlementSync {
             // An invoiced fee is explained by the derived line of its fee payment instead of by
             // itself, so the payouts it sits in have to rebuild those lines
             if (storedFee.balanceItemId && storedFee.settlementId) {
-                options.invoicedFeeBalanceItemIds?.add(storedFee.balanceItemId);
+                options.settledApplicationFeeBalanceItems?.add(storedFee.balanceItemId);
             }
         }
 
@@ -467,12 +466,11 @@ export class StripeSettlementSync {
     }
 
     async #walkPayout(payout: Stripe.Payout, settlement: Settlement, abort: AbortSignal) {
-        const reported = new ReportedRows();
         let transactionCount = 0;
 
-        // Invoiced fees linked to or unlinked from this settlement during the walk: their fee
-        // payments' derived lines must follow
-        const invoicedFeeBalanceItemIds = new Set<string>();
+        // Keep track of all balance items linked to (settled) application fees that are created or updated.
+        // So we can update the settlement status of the associated payments
+        const settledApplicationFeeBalanceItems = new Set<string>();
 
         try {
             for await (const transaction of this.stripe.balanceTransactions.list({
@@ -482,67 +480,51 @@ export class StripeSettlementSync {
                     ? ['data.source', 'data.source.application_fee', 'data.source.application_fee.originating_transaction', 'data.source.charge']
                     : ['data.source', 'data.source.originating_transaction', 'data.source.charge'],
             })) {
-                // Between two transactions is a safe point to stop: only a complete walk sweeps
-                // and marks the settlement synced, so an interrupted one is re-walked from scratch
                 abort.throwIfAborted();
 
                 transactionCount += 1;
-                await this.#handleTransaction(transaction, settlement, reported, invoicedFeeBalanceItemIds);
+                await this.#handleTransaction(transaction, settlement, settledApplicationFeeBalanceItems);
             }
 
-            // Stripe reported nothing for money that did move: storing that as a complete sync
-            // would silently hide the whole payout
             if (transactionCount === 0 && settlement.amount !== 0) {
                 throw new SimpleError({
                     code: 'empty_payout',
                     message: 'Payout ' + payout.id + ' of ' + settlement.amount + ' has no balance transactions',
                 });
             }
-
-            // Only a complete walk may sweep: it can't tell a row that moved away from one this
-            // walk never reached
-            const { unlinkedFees } = await SettlementService.sweepSettlement(settlement, reported);
-            for (const fee of unlinkedFees) {
-                if (fee.balanceItemId) {
-                    invoicedFeeBalanceItemIds.add(fee.balanceItemId);
-                }
-            }
         } catch (e) {
             // The fee payments still follow the fees this walk linked before it broke (a fee may
             // never sit in a payout that has no line for it), but failing to update them may not
             // hide what broke the walk
-            await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]).catch(console.error);
+            await SettlementService.updatePaymentSettlementsForApplicationFeeBalanceItems([...settledApplicationFeeBalanceItems]).catch(console.error);
             throw e;
         }
 
-        await SettlementService.updatePaymentSettlementsForAccountDeductionBalanceItems([...invoicedFeeBalanceItemIds]);
+        await SettlementService.updatePaymentSettlementsForApplicationFeeBalanceItems([...settledApplicationFeeBalanceItems]);
         await SettlementService.finishSync(settlement, { transactionCount });
     }
 
-    async #handleTransaction(transaction: Stripe.BalanceTransaction, settlement: Settlement, reported: ReportedRows, invoicedFeeBalanceItemIds: Set<string>) {
+    async #handleTransaction(transaction: Stripe.BalanceTransaction, settlement: Settlement, settledApplicationFeeBalanceItems: Set<string>) {
         const occurredAt = new Date(transaction.created * 1000);
 
-        // A plain string switch: the pinned SDK's type union misses some real-world types
-        // (e.g. network_cost)
         switch (transaction.type as string) {
             case 'charge':
             case 'payment': {
                 const payment = await this.#resolvePayment(transaction);
 
-                // A destination charge only passes through our balance on its way to the
-                // organization: its own payout settles it, ours stays out of it
                 if (payment.organizationId !== settlement.organizationId) {
-                    await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId: null });
+                    // Destination charge via the platform
+                    await this.#storePaidFeesForTransaction(transaction, settlement, { paymentId: null });
                     return;
                 }
 
-                reported.paymentLine(await SettlementService.upsertPaymentLine(settlement, {
+                await SettlementService.upsertPaymentLine(settlement, {
                     paymentId: payment.id,
                     amount: transaction.amount * 100,
                     externalId: transaction.id,
                     occurredAt,
-                }));
-                await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId: payment.id });
+                });
+                await this.#storePaidFeesForTransaction(transaction, settlement, { paymentId: payment.id });
                 await this.#updateTransferFee(transaction, settlement, payment);
                 await SettlementService.updateLegacySettlementReference(payment);
                 return;
@@ -559,30 +541,28 @@ export class StripeSettlementSync {
                 const isReturned = transaction.type === 'refund_failure';
                 const refunded = await this.#resolveRefundedPayment(transaction);
 
-                // The reverse of the pass-through above: refunding another organization's payment
-                // only moves the money back through our balance
                 if (refunded.organizationId !== settlement.organizationId) {
-                    await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId: null });
+                    // Destination charge via the platform
+                    await this.#storePaidFeesForTransaction(transaction, settlement, { paymentId: null });
                     return;
                 }
 
                 const payment = await this.#resolveReversingPayment(transaction, refunded, { negated: isReturned });
-                reported.paymentLine(await SettlementService.upsertPaymentLine(settlement, {
+                await SettlementService.upsertPaymentLine(settlement, {
                     paymentId: payment.id,
                     amount: transaction.amount * 100,
                     externalId: transaction.id,
                     occurredAt,
-                }));
-                await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId: payment.id });
+                });
+                await this.#storePaidFeesForTransaction(transaction, settlement, { paymentId: payment.id });
                 await SettlementService.updateLegacySettlementReference(payment);
                 return;
             }
 
             case 'application_fee': {
                 // The fee rows, now linked to the platform payout that contains them
-                const { fees } = await this.#handleApplicationFee(transaction, { settlementId: settlement.id, invoicedFeeBalanceItemIds });
-                reported.applicationFees(fees);
-                await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId: null });
+                await this.#handleApplicationFee(transaction, { settlementId: settlement.id, settledApplicationFeeBalanceItems });
+                await this.#storePaidFeesForTransaction(transaction, settlement, { paymentId: null });
                 return;
             }
 
@@ -612,7 +592,7 @@ export class StripeSettlementSync {
             case 'stripe_fee':
             case 'network_cost':
             case 'tax_fee': {
-                const charge = await SettlementService.upsertCharge({
+                await SettlementService.upsertCharge({
                     type: transaction.type === 'tax_fee' ? SettlementChargeType.Tax : SettlementChargeType.ProviderAccountFee,
                     externalId: transaction.id,
                     amount: transaction.amount * 100,
@@ -622,7 +602,6 @@ export class StripeSettlementSync {
                     description: transaction.description ?? '',
                     occurredAt,
                 });
-                reported.charge(charge);
                 return;
             }
 
@@ -630,7 +609,7 @@ export class StripeSettlementSync {
             case 'reserved_funds':
             case 'reserve_hold':
             case 'reserve_release': {
-                const charge = await SettlementService.upsertCharge({
+                await SettlementService.upsertCharge({
                     type: SettlementChargeType.Reserve,
                     externalId: transaction.id,
                     amount: transaction.amount * 100,
@@ -639,14 +618,13 @@ export class StripeSettlementSync {
                     description: transaction.description ?? '',
                     occurredAt,
                 });
-                reported.charge(charge);
                 return;
             }
 
             case 'adjustment':
             case 'payment_reversal': {
                 const paymentId = await this.#tryResolveAdjustmentPayment(transaction, settlement);
-                const charge = await SettlementService.upsertCharge({
+                await SettlementService.upsertCharge({
                     type: SettlementChargeType.Adjustment,
                     externalId: transaction.id,
                     amount: transaction.amount * 100,
@@ -657,8 +635,7 @@ export class StripeSettlementSync {
                     description: transaction.description ?? '',
                     occurredAt,
                 });
-                reported.charge(charge);
-                await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId });
+                await this.#storePaidFeesForTransaction(transaction, settlement, { paymentId });
                 return;
             }
 
@@ -672,7 +649,7 @@ export class StripeSettlementSync {
             case 'connect_collection_transfer':
             case 'stripe_balance_payment_debit':
             case 'stripe_balance_payment_debit_reversal': {
-                const charge = await SettlementService.upsertCharge({
+                await SettlementService.upsertCharge({
                     type: SettlementChargeType.BalanceMovement,
                     externalId: transaction.id,
                     amount: transaction.amount * 100,
@@ -681,8 +658,7 @@ export class StripeSettlementSync {
                     description: transaction.description ?? transaction.type,
                     occurredAt,
                 });
-                reported.charge(charge);
-                await this.#storePaidFeesForTransaction(transaction, settlement, reported, { paymentId: null });
+                await this.#storePaidFeesForTransaction(transaction, settlement, { paymentId: null });
                 return;
             }
 
@@ -703,7 +679,7 @@ export class StripeSettlementSync {
      * connected account also the application fee we charged. The amounts always come from the
      * balance transaction itself.
      */
-    async #storePaidFeesForTransaction(transaction: Stripe.BalanceTransaction, settlement: Settlement, reported: ReportedRows, { paymentId }: { paymentId: string | null }) {
+    async #storePaidFeesForTransaction(transaction: Stripe.BalanceTransaction, settlement: Settlement, { paymentId }: { paymentId: string | null }) {
         const occurredAt = new Date(transaction.created * 1000);
 
         for (const [index, detail] of (transaction.fee_details ?? []).entries()) {
@@ -712,7 +688,7 @@ export class StripeSettlementSync {
             }
 
             if (detail.type === 'application_fee') {
-                await this.#storePaidApplicationFeeForTransaction(transaction, detail, settlement, reported, { paymentId });
+                await this.#storePaidApplicationFeeForTransaction(transaction, detail, settlement, { paymentId });
                 continue;
             }
 
@@ -729,7 +705,6 @@ export class StripeSettlementSync {
                 description: detail.description ?? '',
                 occurredAt,
             });
-            reported.charge(charge);
         }
     }
 
@@ -740,7 +715,7 @@ export class StripeSettlementSync {
      * applicationFeeId both sides of one kind sum to zero. This walk fills their settlementId; the
      * rows themselves usually already exist (created by the fee walk).
      */
-    async #storePaidApplicationFeeForTransaction(transaction: Stripe.BalanceTransaction, detail: Stripe.BalanceTransaction.FeeDetail, settlement: Settlement, reported: ReportedRows, { paymentId }: { paymentId: string | null }) {
+    async #storePaidApplicationFeeForTransaction(transaction: Stripe.BalanceTransaction, detail: Stripe.BalanceTransaction.FeeDetail, settlement: Settlement, { paymentId }: { paymentId: string | null }) {
         if (!this.stripeAccount) {
             throw new SimpleError({
                 code: 'unexpected_application_fee_detail',
@@ -803,7 +778,6 @@ export class StripeSettlementSync {
                 stripeAccountId: this.stripeAccount.id,
                 occurredAt,
             });
-            reported.charge(charge);
 
             // What the organization pays here is what we receive on the other side. The two are
             // written from different Stripe transactions, so a divergence would silently bill the

package/src/helpers/ViesHelper.ts

@@ -3,7 +3,6 @@ import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-e
 import type { Company } from '@stamhoofd/structures';
 import { PeppolScheme } from '@stamhoofd/structures';
 import { Country } from '@stamhoofd/types/Country';
-import axios from 'axios';
 import jsvat from 'jsvat-next';
 import { PeppolDirectoryService } from '../services/PeppolDirectoryService.js';
 
@@ -15,17 +14,25 @@ export class ViesHelperStatic {
 
         console.log('[VIES REQUEST]', method, url, content ? '\n [VIES REQUEST] ' : undefined, json);
 
-        const response = await axios.request({
+        const response = await fetch(url, {
             method,
-            url,
             headers: {
                 'Content-Type': json.length > 0 ? 'application/json' : 'text/plain',
             },
-            data: json,
-
+            body: json.length > 0 ? json : undefined,
+            signal: AbortSignal.timeout(5_000),
         });
-        console.log('[VIES RESPONSE]', method, url, '\n[VIES RESPONSE]', JSON.stringify(response.data));
-        return response.data;
+
+        if (!response.ok) {
+            throw new Error(`VIES request failed with status ${response.status}`);
+        }
+
+        const data = await response.json();
+        console.log('[VIES RESPONSE]', method, url, '\n[VIES RESPONSE]', JSON.stringify(data));
+        return {
+            data,
+            response,
+        };
     }
 
     async checkCompany(company: Company, patch: AutoEncoderPatchType<Company> | Company) {
@@ -177,17 +184,17 @@ export class ViesHelperStatic {
 
         try {
             const cleaned = formatted.substring(2).replace(/(?:\.-\s)+/g, '');
-            const response = await this.request('POST', 'https://ec.europa.eu/taxation_customs/vies/rest-api/check-vat-number', {
+            const { data, response } = await this.request('POST', 'https://ec.europa.eu/taxation_customs/vies/rest-api/check-vat-number', {
                 countryCode: country,
                 vatNumber: cleaned,
             });
 
-            if (typeof response !== 'object' || response === null || typeof response.valid !== 'boolean') {
-                // APi error
+            if (typeof data !== 'object' || data === null || typeof data.valid !== 'boolean') {
+                console.error('VIES error', response.status, response.statusText, data);
                 throw new Error('Invalid response from VIES');
             }
 
-            if (!response.valid) {
+            if (!data.valid) {
                 throw new SimpleError({
                     code: 'invalid_field',
                     message: $t('%1TG', { 'vat-number': formatted }),

package/src/helpers/streamForBreakdown.ts

@@ -14,7 +14,7 @@ import { fetchToAsyncIterator } from './fetchToAsyncIterator.js';
  * They are read page by page and added up right away, so they are never all in memory at once. Above
  * this many objects a breakdown takes too long to wait for, so we ask the user to narrow down instead.
  */
-export const MAX_BREAKDOWN_OBJECTS = 10000;
+export const MAX_BREAKDOWN_OBJECTS = 50_000;
 
 const PAGE_SIZE = 100;
 

package/src/services/SettlementService.test.ts

@@ -9,7 +9,7 @@ import { BalanceItemStatus, BalanceItemType, PaymentMethod, PaymentProvider, Pay
 import { ApplicationFeeType } from '@stamhoofd/structures/settlements/ApplicationFeeType.js';
 import { SettlementChargeType } from '@stamhoofd/structures/settlements/SettlementChargeType.js';
 import { v4 as uuidv4 } from 'uuid';
-import { ReportedRows, SettlementService } from './SettlementService.js';
+import { SettlementService } from './SettlementService.js';
 
 describe('SettlementService', () => {
     let organization: Organization;
@@ -272,79 +272,7 @@ describe('SettlementService', () => {
         });
     });
 
-    describe('sweepSettlement', () => {
-        test('deletes payout-only rows, but unlinks what outlives the payout', async () => {
-            const payment = await createPayment();
-            const settlement = await SettlementService.upsertSettlement(settlementData());
-
-            const keptLine = await SettlementService.upsertPaymentLine(settlement, {
-                paymentId: payment.id, amount: 50_00_00, externalId: 'txn_kept', occurredAt: new Date(2026, 0, 14),
-            });
-            const movedLine = await SettlementService.upsertPaymentLine(settlement, {
-                paymentId: payment.id, amount: 10_00_00, externalId: 'txn_moved', occurredAt: new Date(2026, 0, 14),
-            });
-
-            // A derived fee line is never reported by a walk: it belongs to the fee payment
-            const derivedLine = await SettlementService.upsertPaymentLine(settlement, {
-                paymentId: payment.id, amount: 2_00_00, externalId: null, occurredAt: new Date(2026, 0, 14),
-            });
-
-            const { fee, charge: referencedCharge } = await createApplicationFee({ settlement });
-            const providerFee = await SettlementService.upsertCharge({
-                type: SettlementChargeType.ProviderTransactionFee,
-                externalId: 'txn_moved:fee:0',
-                amount: -30_00,
-                settlementId: settlement.id,
-                organizationId: organization.id,
-                occurredAt: new Date(2026, 0, 14),
-            });
-            const keptFee = await SettlementService.upsertCharge({
-                type: SettlementChargeType.ProviderTransactionFee,
-                externalId: 'txn_kept:fee:0',
-                amount: -25_00,
-                settlementId: settlement.id,
-                organizationId: organization.id,
-                occurredAt: new Date(2026, 0, 14),
-            });
-
-            // The deduction charge is linked to this settlement too, but no longer reported
-            referencedCharge.settlementId = settlement.id;
-            await referencedCharge.save();
-
-            const reported = new ReportedRows();
-            reported.paymentLine(keptLine);
-            reported.charge(keptFee);
-            const { unlinkedFees } = await SettlementService.sweepSettlement(settlement, reported);
-
-            expect(await PaymentSettlement.getByID(keptLine.id)).toBeDefined();
-            expect(await PaymentSettlement.getByID(movedLine.id)).toBeUndefined();
-            expect(await PaymentSettlement.getByID(derivedLine.id)).toBeDefined();
-            expect(await SettlementCharge.getByID(providerFee.id)).toBeUndefined();
-            expect((await SettlementCharge.getByID(keptFee.id))?.settlementId).toBe(settlement.id);
-
-            // A charge an application fee points at may never be deleted (foreign key), only unlinked
-            const unlinkedCharge = await SettlementCharge.getByID(referencedCharge.id);
-            expect(unlinkedCharge).toBeDefined();
-            expect(unlinkedCharge!.settlementId).toBe(null);
-
-            expect(unlinkedFees.map(f => f.id)).toEqual([fee.id]);
-            expect((await ApplicationFee.getByID(fee.id))!.settlementId).toBe(null);
-        });
-
-        test('keeps the application fees the walk reported', async () => {
-            const settlement = await SettlementService.upsertSettlement(settlementData());
-            const { fee } = await createApplicationFee({ settlement });
-
-            const reported = new ReportedRows();
-            reported.applicationFee(fee);
-            const { unlinkedFees } = await SettlementService.sweepSettlement(settlement, reported);
-
-            expect(unlinkedFees).toHaveLength(0);
-            expect((await ApplicationFee.getByID(fee.id))!.settlementId).toBe(settlement.id);
-        });
-    });
-
-    describe('updatePaymentSettlementsForAccountDeductionPayment', () => {
+    describe('updatePaymentSettlementsForApplicationFeePayment', () => {
         test('one line per payout, summing the fees it contained', async () => {
             const { payment, balanceItem } = await createFeePayment(3_25_00);
             const first = await SettlementService.upsertSettlement(settlementData({ settledAt: new Date(2026, 0, 10) }));
@@ -357,7 +285,7 @@ describe('SettlementService', () => {
             // A fee that isn't paid out yet doesn't produce a line
             const { fee: pending } = await createApplicationFee({ balanceItemId: balanceItem.id, amount: 25_00 });
 
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
 
             const lines = await PaymentSettlement.select().where('paymentId', payment.id).fetch();
             expect(lines).toHaveLength(2);
@@ -374,7 +302,7 @@ describe('SettlementService', () => {
             // Paying out the last fee completes the payment
             pending.settlementId = second.id;
             await pending.save();
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
 
             const completed = await PaymentSettlement.select().where('paymentId', payment.id).fetch();
             expect(completed.reduce((total, line) => total + line.amount, 0)).toBe(payment.price);
@@ -387,10 +315,10 @@ describe('SettlementService', () => {
             await createApplicationFee({ settlement, balanceItemId: first.balanceItem.id, amount: 1_00_00 });
             await createApplicationFee({ settlement, balanceItemId: second.balanceItem.id, amount: 2_00_00 });
 
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(first.payment);
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(second.payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(first.payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(second.payment);
             // Re-running may not duplicate: the lines have no externalId to upsert on
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(first.payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(first.payment);
 
             const lines = await PaymentSettlement.select().where('settlementId', settlement.id).fetch();
             expect(lines).toHaveLength(2);
@@ -403,19 +331,19 @@ describe('SettlementService', () => {
             const settlement = await SettlementService.upsertSettlement(settlementData());
             const { fee } = await createApplicationFee({ settlement, balanceItemId: balanceItem.id, amount: 1_00_00 });
 
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
             expect(await PaymentSettlement.select().where('paymentId', payment.id).count()).toBe(1);
 
             fee.settlementId = null;
             await fee.save();
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
 
             expect(await PaymentSettlement.select().where('paymentId', payment.id).count()).toBe(0);
         });
 
         test('other payment methods are left alone', async () => {
             const payment = await createPayment();
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
             expect(await PaymentSettlement.select().where('paymentId', payment.id).count()).toBe(0);
         });
     });
@@ -464,7 +392,7 @@ describe('SettlementService', () => {
             const { payment, balanceItem } = await createFeePayment(1_00_00);
             fee.balanceItemId = balanceItem.id;
             await fee.save();
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
 
             const invoiced = await Settlement.getByID(settlement.id);
             expect(invoiced!.pendingFees).toBe(0);
@@ -476,7 +404,7 @@ describe('SettlementService', () => {
             const { payment, balanceItem } = await createFeePayment(1_00_00);
             const { fee } = await createApplicationFee({ settlement, balanceItemId: balanceItem.id, amount: 1_00_00 });
 
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
             await SettlementService.finishSync(settlement, { transactionCount: 1 });
             expect(settlement.pendingFees).toBe(0);
             expect(settlement.unexplainedAmount).toBe(0);
@@ -484,7 +412,7 @@ describe('SettlementService', () => {
             // The payout no longer contains the fee: its line goes, and so does what it explained
             fee.settlementId = null;
             await fee.save();
-            await SettlementService.updatePaymentSettlementsForAccountDeductionPayment(payment);
+            await SettlementService.updatePaymentSettlementsForApplicationFeePayment(payment);
 
             const unlinked = await Settlement.getByID(settlement.id);
             expect(unlinked!.pendingFees).toBe(0);